GitHub App Reinstallation Callback Issue

// apps/web/src/app/api/github/webhook/route.ts
import { Webhooks } from '@octokit/webhooks';
import { db } from '@onbook/db';
import { githubInstallations } from '@onbook/db/schema';
import { eq } from 'drizzle-orm';

const webhooks = new Webhooks({
  secret: process.env.GITHUB_WEBHOOK_SECRET!,
});

webhooks.on('installation.created', async ({ payload }) => {
  const { installation, sender } = payload;

  // Store as "pending" - no org association yet
  // User will claim it when they complete onboarding
  await db.insert(githubInstallations).values({
    installationId: installation.id,
    accountId: installation.account.id,
    accountLogin: installation.account.login,
    accountType: installation.account.type,
    accountAvatarUrl: installation.account.avatar_url,
    organizationId: null, // Pending - will be claimed
    userId: null,
    installedBy: sender.login, // Track who installed
  }).onConflictDoUpdate({
    target: githubInstallations.installationId,
    set: {
      accountLogin: installation.account.login,
      accountAvatarUrl: installation.account.avatar_url,
      updatedAt: new Date(),
      deletedAt: null,
    },
  });
});

webhooks.on('installation.deleted', async ({ payload }) => {
  await db.update(githubInstallations)
    .set({ deletedAt: new Date() })
    .where(eq(githubInstallations.installationId, payload.installation.id));
});

export async function POST(request: Request) {
  const body = await request.text();
  const signature = request.headers.get('x-hub-signature-256')!;

  await webhooks.verifyAndReceive({
    id: request.headers.get('x-github-delivery')!,
    name: request.headers.get('x-github-event') as any,
    signature,
    payload: body,
  });

  return new Response('OK');
}

// Add to githubInstallations table
installedBy: varchar('installed_by', { length: 255 }), // GitHub username who installed
// Make organizationId nullable for pending installations
organizationId: varchar('organization_id', { length: 255 }), // Remove .notNull()

// New endpoint: github.claimInstallation
claimInstallation: protectedProcedure
  .input(z.object({ installationId: z.number() }))
  .mutation(async ({ ctx, input }) => {
    // Verify installation exists and is unclaimed
    const installation = await db.query.githubInstallations.findFirst({
      where: and(
        eq(githubInstallations.installationId, input.installationId),
        isNull(githubInstallations.organizationId),
      ),
    });

    if (!installation) {
      throw new TRPCError({ code: 'NOT_FOUND' });
    }

    // Claim it for current org
    await db.update(githubInstallations)
      .set({
        organizationId: ctx.auth.session.activeOrganizationId,
        userId: ctx.auth.user.id,
      })
      .where(eq(githubInstallations.installationId, input.installationId));
  }),

// packages/trpc/src/router/github/index.ts

/**
 * Look up installation by GitHub org/username
 * Used when callback failed but user already installed
 */
syncInstallation: protectedProcedure
  .input(z.object({
    accountLogin: z.string(),
    accountType: z.enum(['Organization', 'User']),
  }))
  .mutation(async ({ ctx, input }) => {
    const octokit = await getAppOctokit();

    try {
      // Direct lookup - no pagination needed
      const endpoint = input.accountType === 'Organization'
        ? octokit.apps.getOrgInstallation({ org: input.accountLogin })
        : octokit.apps.getUserInstallation({ username: input.accountLogin });

      const { data } = await endpoint;

      // Save/update installation
      await db.insert(githubInstallations).values({
        installationId: data.id,
        accountId: data.account?.id ?? 0,
        accountLogin: data.account?.login ?? input.accountLogin,
        accountType: input.accountType,
        accountAvatarUrl: data.account?.avatar_url ?? null,
        organizationId: ctx.auth.session.activeOrganizationId,
        userId: ctx.auth.user.id,
      }).onConflictDoUpdate({
        target: githubInstallations.installationId,
        set: {
          organizationId: ctx.auth.session.activeOrganizationId,
          userId: ctx.auth.user.id,
          updatedAt: new Date(),
          deletedAt: null,
        },
      });

      return { success: true, installationId: data.id };
    } catch (error) {
      if ((error as any).status === 404) {
        throw new TRPCError({
          code: 'NOT_FOUND',
          message: 'GitHub App not installed on this account',
        });
      }
      throw error;
    }
  }),

// In ConnectStep.tsx - add "Already connected?" section

const [showSync, setShowSync] = useState(false);
const [accountLogin, setAccountLogin] = useState('');
const syncMutation = trpc.github.syncInstallation.useMutation();

// Show after user returns from GitHub without callback
{showSync && (
  <div className="mt-4 p-4 border rounded">
    <p className="text-sm text-muted-foreground mb-2">
      Already installed the app? Enter your GitHub organization or username:
    </p>
    <div className="flex gap-2">
      <Input
        value={accountLogin}
        onChange={(e) => setAccountLogin(e.target.value)}
        placeholder="acme-corp or username"
      />
      <Button
        onClick={() => syncMutation.mutate({
          accountLogin,
          accountType: 'Organization', // Could add toggle
        })}
        disabled={syncMutation.isPending}
      >
        Sync
      </Button>
    </div>
  </div>
)}