ci: add release workflow and artifact uploads

- Update CI to build both Chrome and Firefox extensions
- Upload .zip and .xpi artifacts on every build (30-day retention)
- Add release workflow triggered on version tags (v*)
- Update .gitignore to ignore all release packages in repo root

Author: 0xSero

.github/workflows/ci.yml

@@ -64,11 +64,23 @@ jobs:
           cache: 'npm'
       - run: npm ci
       - run: npm run build
+      - run: npm run build:firefox
+      - name: Package Chrome Extension
+        run: |
+          cd dist && zip -r ../parchi-chrome-${{ github.run_number }}.zip . && cd ..
+      - name: Package Firefox Extension
+        run: |
+          cd dist-firefox && zip -r ../parchi-firefox-${{ github.run_number }}.xpi . && cd ..
+      - uses: actions/upload-artifact@v4
+        with:
+          name: extension-chrome
+          path: parchi-chrome-${{ github.run_number }}.zip
+          retention-days: 30
       - uses: actions/upload-artifact@v4
         with:
-          name: extension-dist
-          path: dist/
-          retention-days: 7
+          name: extension-firefox
+          path: parchi-firefox-${{ github.run_number }}.xpi
+          retention-days: 30
 
   test:
     name: Unit Tests

.github/workflows/release.yml

@@ -0,0 +1,45 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  build-and-release:
+    name: Build and Release
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+      - run: npm ci
+      
+      - name: Get version from package.json
+        id: get_version
+        run: echo "VERSION=$(node -p "require('./package.json').version")" >> $GITHUB_OUTPUT
+      
+      - run: npm run build
+      - run: npm run build:firefox
+      
+      - name: Package Chrome Extension
+        run: |
+          cd dist && zip -r ../parchi-chrome-${{ steps.get_version.outputs.VERSION }}.zip . && cd ..
+      - name: Package Firefox Extension
+        run: |
+          cd dist-firefox && zip -r ../parchi-firefox-${{ steps.get_version.outputs.VERSION }}.xpi . && cd ..
+      
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            parchi-chrome-*.zip
+            parchi-firefox-*.xpi
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -29,6 +29,12 @@ logs/
 *.zip
 *.crx
 *.pem
+*.xpi
+
+# Release packages in repo root
+/parchi-*.zip
+/parchi-*.xpi
+/dist.crx
 
 # Environment files
 .env

package.json

@@ -1,6 +1,6 @@
 {
   "name": "parchi-extension",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Warm-paper browser automation extension with configurable LLM providers",
   "type": "module",
   "workspaces": [

packages/backend/convex/aiProxy.ts

@@ -18,7 +18,7 @@ const jsonResponse = (status: number, body: Record<string, unknown>) =>
   });
 
 type ProviderTarget = {
-  provider: 'openai' | 'anthropic' | 'kimi';
+  provider: 'openai' | 'anthropic' | 'kimi' | 'openrouter';
   upstreamBaseUrl: string;
   defaultPath: string;
   upstreamApiKey: string;
@@ -42,6 +42,14 @@ const resolveProviderTarget = (request: Request): ProviderTarget | null => {
       upstreamApiKey: String(process.env.KIMI_API_KEY || '').trim(),
     };
   }
+  if (requestPath.startsWith('/ai-proxy/openrouter')) {
+    return {
+      provider: 'openrouter',
+      upstreamBaseUrl: 'https://openrouter.ai/api',
+      defaultPath: '/v1/chat/completions',
+      upstreamApiKey: String(process.env.OPENROUTER_API_KEY || '').trim(),
+    };
+  }
   if (requestPath.startsWith('/ai-proxy/openai') || requestPath === '/ai-proxy') {
     return {
       provider: 'openai',
@@ -53,10 +61,16 @@ const resolveProviderTarget = (request: Request): ProviderTarget | null => {
   return null;
 };
 
-const resolveForwardPath = (request: Request, provider: 'openai' | 'anthropic' | 'kimi', defaultPath: string) => {
+const providerPrefixMap: Record<string, string> = {
+  anthropic: '/ai-proxy/anthropic',
+  kimi: '/ai-proxy/kimi',
+  openrouter: '/ai-proxy/openrouter',
+  openai: '/ai-proxy/openai',
+};
+
+const resolveForwardPath = (request: Request, provider: string, defaultPath: string) => {
   const requestPath = new URL(request.url).pathname;
-  const prefix =
-    provider === 'anthropic' ? '/ai-proxy/anthropic' : provider === 'kimi' ? '/ai-proxy/kimi' : '/ai-proxy/openai';
+  const prefix = providerPrefixMap[provider] || '/ai-proxy/openai';
   const suffix = requestPath.startsWith(prefix) ? requestPath.slice(prefix.length) : '';
   return suffix || defaultPath;
 };
@@ -80,9 +94,10 @@ export const aiProxy = httpActionGeneric(async (ctx, request) => {
   }
 
   const subscription = await ctx.runQuery(anyApi.subscriptions.getByUserId, { userId });
-  const isPaid = Boolean(subscription && subscription.plan === 'pro' && subscription.status === 'active');
-  if (!isPaid) {
-    return jsonResponse(402, { error: 'Active paid subscription required' });
+  const creditBalance = subscription?.creditBalanceCents ?? 0;
+  const hasLegacySub = Boolean(subscription && subscription.plan === 'pro' && subscription.status === 'active');
+  if (creditBalance <= 0 && !hasLegacySub) {
+    return jsonResponse(402, { error: 'Insufficient credits. Purchase credits to continue.' });
   }
 
   let payload: Record<string, any>;
@@ -92,10 +107,22 @@ export const aiProxy = httpActionGeneric(async (ctx, request) => {
     return jsonResponse(400, { error: 'Invalid JSON payload' });
   }
 
+  // Estimate cost: ~$0.03/1K tokens → 0.003 cents/token, minimum 1 cent
+  const maxTokens = Number(payload?.max_tokens || payload?.maxTokens || 4096);
+  const estimatedCostCents = Math.max(1, Math.ceil(maxTokens * 0.003));
+
+  // Deduct credits upfront (best-effort for streaming responses)
+  if (creditBalance > 0) {
+    await ctx.runMutation(anyApi.subscriptions.deductCredits, {
+      userId,
+      amountCents: Math.min(estimatedCostCents, creditBalance),
+    });
+  }
+
   await ctx.runMutation(anyApi.subscriptions.recordUsage, {
     userId,
     requestCountIncrement: 1,
-    tokenEstimate: Number(payload?.max_tokens || payload?.maxTokens || 0),
+    tokenEstimate: maxTokens,
   });
 
   const forwardPath = resolveForwardPath(request, providerTarget.provider, providerTarget.defaultPath);
@@ -106,6 +133,10 @@ export const aiProxy = httpActionGeneric(async (ctx, request) => {
 
   if (providerTarget.provider === 'openai') {
     upstreamHeaders.set('authorization', `Bearer ${providerTarget.upstreamApiKey}`);
+  } else if (providerTarget.provider === 'openrouter') {
+    upstreamHeaders.set('authorization', `Bearer ${providerTarget.upstreamApiKey}`);
+    upstreamHeaders.set('http-referer', 'https://parchi.app');
+    upstreamHeaders.set('x-title', 'Parchi');
   } else if (providerTarget.provider === 'anthropic') {
     upstreamHeaders.set('x-api-key', providerTarget.upstreamApiKey);
     upstreamHeaders.set('anthropic-version', request.headers.get('anthropic-version') || '2023-06-01');

packages/backend/convex/http.ts

@@ -55,6 +55,18 @@ http.route({
   handler: aiProxy,
 });
 
+http.route({
+  pathPrefix: '/ai-proxy/openrouter/',
+  method: 'POST',
+  handler: aiProxy,
+});
+
+http.route({
+  pathPrefix: '/ai-proxy/openrouter/',
+  method: 'OPTIONS',
+  handler: aiProxy,
+});
+
 http.route({
   path: '/stripe-webhook',
   method: 'POST',

packages/backend/convex/payments.ts

@@ -80,6 +80,76 @@ export const createCheckoutSession = actionGeneric(async (ctx) => {
   };
 });
 
+const CREDIT_PACKAGES_CENTS = [500, 1500, 5000] as const;
+
+export const createCreditCheckoutSession = actionGeneric(async (ctx, args: { packageCents: number }) => {
+  const userId = await getAuthUserId(ctx);
+  if (!userId) throw new Error('Unauthorized');
+
+  const packageCents = Number(args.packageCents);
+  if (!CREDIT_PACKAGES_CENTS.includes(packageCents as any)) {
+    throw new Error(`Invalid credit package. Choose from: ${CREDIT_PACKAGES_CENTS.map((c) => `$${c / 100}`).join(', ')}`);
+  }
+
+  const stripe = getStripeClient();
+  const user = await ctx.runQuery(anyApi.users.me, {});
+  const existing = await ctx.runQuery(anyApi.subscriptions.getByUserId, { userId });
+
+  let customerId = existing?.stripeCustomerId;
+  if (!customerId) {
+    const customer = await stripe.customers.create({
+      email: user?.email || undefined,
+      metadata: { convexUserId: String(userId) },
+    });
+    customerId = customer.id;
+  }
+
+  const siteUrl = baseSiteUrl();
+  const session = await stripe.checkout.sessions.create({
+    mode: 'payment',
+    customer: customerId,
+    line_items: [
+      {
+        price_data: {
+          currency: 'usd',
+          unit_amount: packageCents,
+          product_data: {
+            name: `Parchi Credits — $${(packageCents / 100).toFixed(0)}`,
+          },
+        },
+        quantity: 1,
+      },
+    ],
+    success_url: `${siteUrl}/billing/success?session_id={CHECKOUT_SESSION_ID}`,
+    cancel_url: `${siteUrl}/billing/cancel`,
+    metadata: {
+      userId: String(userId),
+      creditAmountCents: String(packageCents),
+    },
+  });
+
+  // Ensure a subscription record exists so the webhook can find it
+  if (!existing) {
+    await ctx.runMutation(anyApi.subscriptions.upsertForUser, {
+      userId,
+      plan: 'free',
+      status: 'inactive',
+      stripeCustomerId: customerId,
+    });
+  } else if (!existing.stripeCustomerId) {
+    await ctx.runMutation(anyApi.subscriptions.upsertForUser, {
+      userId,
+      plan: existing.plan || 'free',
+      status: existing.status || 'inactive',
+      stripeCustomerId: customerId,
+      stripeSubscriptionId: existing.stripeSubscriptionId,
+      currentPeriodEnd: existing.currentPeriodEnd,
+    });
+  }
+
+  return { id: session.id, url: session.url };
+});
+
 export const manageSubscription = actionGeneric(async (ctx) => {
   const userId = await getAuthUserId(ctx);
   if (!userId) throw new Error('Unauthorized');
@@ -124,7 +194,16 @@ export const stripeWebhook = httpActionGeneric(async (ctx, request) => {
   if (event.type === 'checkout.session.completed') {
     const session = event.data.object as Stripe.Checkout.Session;
     const metadataUserId = session.metadata?.userId;
-    if (metadataUserId) {
+    const creditAmountCents = Number(session.metadata?.creditAmountCents || 0);
+
+    if (metadataUserId && creditAmountCents > 0) {
+      // One-time credit purchase — add credits to balance
+      await ctx.runMutation(anyApi.subscriptions.addCredits, {
+        userId: metadataUserId as any,
+        amountCents: creditAmountCents,
+      });
+    } else if (metadataUserId) {
+      // Subscription checkout — existing flow
       const subscriptionId =
         typeof session.subscription === 'string'
           ? session.subscription

packages/backend/convex/schema.ts

@@ -12,6 +12,7 @@ export default defineSchema({
     stripeSubscriptionId: v.optional(v.string()),
     status: v.union(v.literal('active'), v.literal('canceled'), v.literal('past_due'), v.literal('inactive')),
     currentPeriodEnd: v.optional(v.number()),
+    creditBalanceCents: v.optional(v.number()),
   })
     .index('by_userId', ['userId'])
     .index('by_stripeCustomerId', ['stripeCustomerId'])

packages/backend/convex/subscriptions.ts

@@ -30,6 +30,7 @@ export const getCurrent = queryGeneric({
         plan: 'free',
         status: 'inactive',
       }),
+      creditBalanceCents: subscription?.creditBalanceCents ?? 0,
       usage: usage || {
         requestCount: 0,
         tokensUsed: 0,
@@ -170,3 +171,69 @@ export const recordUsage = mutationGeneric({
     return ctx.db.get(createdId);
   },
 });
+
+export const addCredits = mutationGeneric({
+  args: {
+    userId: v.id('users'),
+    amountCents: v.number(),
+  },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query('subscriptions')
+      .withIndex('by_userId', (q) => q.eq('userId', args.userId))
+      .first();
+
+    if (existing?._id) {
+      const newBalance = (existing.creditBalanceCents ?? 0) + args.amountCents;
+      await ctx.db.patch(existing._id, { creditBalanceCents: newBalance });
+      return { creditBalanceCents: newBalance };
+    }
+
+    await ctx.db.insert('subscriptions', {
+      userId: args.userId,
+      plan: 'free',
+      status: 'inactive',
+      creditBalanceCents: args.amountCents,
+    });
+    return { creditBalanceCents: args.amountCents };
+  },
+});
+
+export const deductCredits = mutationGeneric({
+  args: {
+    userId: v.id('users'),
+    amountCents: v.number(),
+  },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query('subscriptions')
+      .withIndex('by_userId', (q) => q.eq('userId', args.userId))
+      .first();
+
+    const currentBalance = existing?.creditBalanceCents ?? 0;
+    if (currentBalance < args.amountCents) {
+      return { success: false, remainingCents: currentBalance };
+    }
+
+    const newBalance = currentBalance - args.amountCents;
+    if (existing?._id) {
+      await ctx.db.patch(existing._id, { creditBalanceCents: newBalance });
+    }
+    return { success: true, remainingCents: newBalance };
+  },
+});
+
+export const getBalance = queryGeneric({
+  args: {},
+  handler: async (ctx) => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) return { creditBalanceCents: 0 };
+
+    const subscription = await ctx.db
+      .query('subscriptions')
+      .withIndex('by_userId', (q) => q.eq('userId', userId))
+      .first();
+
+    return { creditBalanceCents: subscription?.creditBalanceCents ?? 0 };
+  },
+});