@insforge/cli 0.1.70 → 0.1.71

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { join as join14, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import { join as join17, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
-import * as clack16 from "@clack/prompts";
+import * as clack17 from "@clack/prompts";
 
 // src/lib/prompts.ts
 import * as readline from "readline";
@@ -1329,36 +1329,36 @@ function registerBranchCreateCommand(branch) {
         throw new CLIError(`Invalid --mode: ${opts.mode} (must be "full" or "schema-only")`);
       }
       const mode = opts.mode;
-      const spinner9 = !json ? clack5.spinner() : null;
+      const spinner10 = !json ? clack5.spinner() : null;
       let ready;
       let provisioned = false;
       try {
-        spinner9?.start(`Creating branch '${name}'...`);
+        spinner10?.start(`Creating branch '${name}'...`);
         const created = await createBranchApi(project.project_id, { mode, name }, apiUrl);
         captureEvent(project.project_id, "cli_branch_create", {
           mode,
           parent_project_id: project.project_id
         });
-        spinner9?.message(`Branch '${name}' created (appkey: ${created.appkey}). Provisioning...`);
-        ready = await pollUntilReady(created.id, apiUrl, spinner9);
+        spinner10?.message(`Branch '${name}' created (appkey: ${created.appkey}). Provisioning...`);
+        ready = await pollUntilReady(created.id, apiUrl, spinner10);
         provisioned = ready.branch_state === "ready";
         if (provisioned && opts.switch) {
-          spinner9?.message("Branch ready. Switching context...");
+          spinner10?.message("Branch ready. Switching context...");
           await runBranchSwitch({ name, apiUrl, json, silent: true });
-          spinner9?.stop(`Branch '${name}' is ready and active`);
+          spinner10?.stop(`Branch '${name}' is ready and active`);
         } else if (provisioned) {
-          spinner9?.stop(`Branch '${name}' is ready`);
+          spinner10?.stop(`Branch '${name}' is ready`);
         } else {
-          spinner9?.stop(`Branch '${name}' is in '${ready.branch_state}' state`);
+          spinner10?.stop(`Branch '${name}' is in '${ready.branch_state}' state`);
         }
       } catch (err) {
         if (provisioned) {
-          spinner9?.stop(
+          spinner10?.stop(
             `Branch '${name}' is ready, but switching context failed \u2014 run \`insforge branch switch ${name}\` to retry`,
             1
           );
         } else {
-          spinner9?.stop(`Branch '${name}' creation failed`, 1);
+          spinner10?.stop(`Branch '${name}' creation failed`, 1);
         }
         throw err;
       }
@@ -1382,7 +1382,7 @@ function registerBranchCreateCommand(branch) {
     }
   });
 }
-async function pollUntilReady(branchId, apiUrl, spinner9) {
+async function pollUntilReady(branchId, apiUrl, spinner10) {
   const start = Date.now();
   let lastState = "";
   while (Date.now() - start < POLL_TIMEOUT_MS) {
@@ -1391,8 +1391,8 @@ async function pollUntilReady(branchId, apiUrl, spinner9) {
     if (branch2.branch_state === "deleted" || branch2.branch_state === "conflicted") {
       throw new CLIError(`Branch creation failed (state: ${branch2.branch_state})`);
     }
-    if (spinner9 && branch2.branch_state !== lastState) {
-      spinner9.message(`Provisioning branch (state: ${branch2.branch_state})...`);
+    if (spinner10 && branch2.branch_state !== lastState) {
+      spinner10.message(`Provisioning branch (state: ${branch2.branch_state})...`);
       lastState = branch2.branch_state;
     }
     await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
@@ -2376,8 +2376,8 @@ async function startDirectDeployment(deploymentId, startBody) {
   });
   await response.json();
 }
-async function pollDeployment(deploymentId, spinner9, syncBeforeRead) {
-  spinner9?.message("Building and deploying...");
+async function pollDeployment(deploymentId, spinner10, syncBeforeRead) {
+  spinner10?.message("Building and deploying...");
   const startTime = Date.now();
   let deployment = null;
   while (Date.now() - startTime < POLL_TIMEOUT_MS3) {
@@ -2393,13 +2393,13 @@ async function pollDeployment(deploymentId, spinner9, syncBeforeRead) {
         break;
       }
       if (status === "ERROR" || status === "CANCELED") {
-        spinner9?.stop("Deployment failed");
+        spinner10?.stop("Deployment failed");
         throw new CLIError(
           getDeploymentError(deployment.metadata) ?? `Deployment failed with status: ${deployment.status}`
         );
       }
       const elapsed = Math.round((Date.now() - startTime) / 1e3);
-      spinner9?.message(`Building and deploying... (${elapsed}s, status: ${deployment.status})`);
+      spinner10?.message(`Building and deploying... (${elapsed}s, status: ${deployment.status})`);
     } catch (err) {
       if (err instanceof CLIError) throw err;
     }
@@ -2409,20 +2409,20 @@ async function pollDeployment(deploymentId, spinner9, syncBeforeRead) {
   return { deploymentId, deployment, isReady, liveUrl };
 }
 async function deployProjectDirect(opts, config) {
-  const { sourceDir, startBody = {}, spinner: spinner9 } = opts;
-  spinner9?.start("Scanning source files...");
+  const { sourceDir, startBody = {}, spinner: spinner10 } = opts;
+  spinner10?.start("Scanning source files...");
   const localFiles = await collectDeploymentFiles(sourceDir);
   if (localFiles.length === 0) {
     throw new CLIError("No deployable files found in the source directory.");
   }
-  spinner9?.message("Creating deployment...");
+  spinner10?.message("Creating deployment...");
   const createResult = await createDirectDeploymentSession(
     config,
     localFiles.map(({ path: relativePath, sha, size }) => ({ path: relativePath, sha, size }))
   );
   const localFileByPath = new Map(localFiles.map((file) => [file.path, file]));
   const pendingFiles = createResult.files.filter((file) => !file.uploadedAt);
-  spinner9?.message(`Uploading ${pendingFiles.length} file${pendingFiles.length === 1 ? "" : "s"}...`);
+  spinner10?.message(`Uploading ${pendingFiles.length} file${pendingFiles.length === 1 ? "" : "s"}...`);
   await runWithConcurrency(pendingFiles, DIRECT_UPLOAD_CONCURRENCY, async (manifestFile) => {
     const localFile = localFileByPath.get(manifestFile.path);
     if (!localFile) {
@@ -2433,18 +2433,18 @@ async function deployProjectDirect(opts, config) {
     }
     await uploadDirectDeploymentFile(createResult.id, manifestFile, localFile);
   });
-  spinner9?.message("Starting deployment...");
+  spinner10?.message("Starting deployment...");
   await startDirectDeployment(createResult.id, startBody);
-  return await pollDeployment(createResult.id, spinner9, !isInsforgeCloudOssHost(config.oss_host));
+  return await pollDeployment(createResult.id, spinner10, !isInsforgeCloudOssHost(config.oss_host));
 }
 async function deployProjectLegacy(opts) {
-  const { sourceDir, startBody = {}, spinner: spinner9 } = opts;
-  spinner9?.message("Creating deployment...");
+  const { sourceDir, startBody = {}, spinner: spinner10 } = opts;
+  spinner10?.message("Creating deployment...");
   const createRes = await ossFetch("/api/deployments", { method: "POST" });
   const { id: deploymentId, uploadUrl, uploadFields } = await createRes.json();
-  spinner9?.message("Compressing source files...");
+  spinner10?.message("Compressing source files...");
   const zipBuffer = await createZipBuffer(sourceDir);
-  spinner9?.message("Uploading...");
+  spinner10?.message("Uploading...");
   const formData = new FormData();
   for (const [key, value] of Object.entries(uploadFields)) {
     formData.append(key, value);
@@ -2455,13 +2455,13 @@ async function deployProjectLegacy(opts) {
     const uploadErr = await uploadRes.text();
     throw new CLIError(`Failed to upload: ${uploadErr}`);
   }
-  spinner9?.message("Starting deployment...");
+  spinner10?.message("Starting deployment...");
   const startRes = await ossFetch(`/api/deployments/${deploymentId}/start`, {
     method: "POST",
     body: JSON.stringify(startBody)
   });
   await startRes.json();
-  return await pollDeployment(deploymentId, spinner9, false);
+  return await pollDeployment(deploymentId, spinner10, false);
 }
 async function deployProject(opts) {
   const config = getProjectConfig();
@@ -2496,7 +2496,7 @@ function registerDeploymentsDeployCommand(deploymentsCmd2) {
           `"${dirName}" is an excluded directory and cannot be used as a deploy source. Please specify your project root or output directory instead.`
         );
       }
-      const spinner9 = !json ? clack11.spinner() : null;
+      const spinner10 = !json ? clack11.spinner() : null;
       const startBody = {};
       if (opts.env) {
         try {
@@ -2522,9 +2522,9 @@ function registerDeploymentsDeployCommand(deploymentsCmd2) {
           throw new CLIError("Invalid --meta JSON.");
         }
       }
-      const result = await deployProject({ sourceDir, startBody, spinner: spinner9 });
+      const result = await deployProject({ sourceDir, startBody, spinner: spinner10 });
       if (result.isReady) {
-        spinner9?.stop("Deployment complete");
+        spinner10?.stop("Deployment complete");
         if (json) {
           outputJson(result.deployment);
         } else {
@@ -2534,7 +2534,7 @@ function registerDeploymentsDeployCommand(deploymentsCmd2) {
           clack11.log.info(`Deployment ID: ${result.deploymentId}`);
         }
       } else {
-        spinner9?.stop("Deployment is still building");
+        spinner10?.stop("Deployment is still building");
         if (json) {
           outputJson({
             id: result.deploymentId,
@@ -3100,13 +3100,13 @@ async function downloadGitHubTemplate(templateName, projectConfig, json) {
 // src/commands/projects/link.ts
 var execAsync3 = promisify4(exec3);
 async function runNpmInstall(startMessage = "Installing dependencies...") {
-  const spinner9 = clack13.spinner();
-  spinner9.start(startMessage);
+  const spinner10 = clack13.spinner();
+  spinner10.start(startMessage);
   try {
     await execAsync3("npm install", { cwd: process.cwd(), maxBuffer: 10 * 1024 * 1024 });
-    spinner9.stop("Dependencies installed");
+    spinner10.stop("Dependencies installed");
   } catch (err) {
-    spinner9.stop("Failed to install dependencies");
+    spinner10.stop("Failed to install dependencies");
     clack13.log.warn(`npm install failed: ${err.message}`);
     clack13.log.info("Run `npm install` manually to install dependencies.");
   }
@@ -6853,7 +6853,7 @@ function registerDiagnoseCommands(diagnoseCmd2) {
         const s = !json ? clack15.spinner() : null;
         s?.start("Collecting diagnostic data...");
         const data2 = await collectDiagnosticData(projectId, ossMode, apiUrl);
-        const cliVersion = "0.1.70";
+        const cliVersion = "0.1.71";
         s?.stop("Data collected");
         if (!json) {
           console.log(`
@@ -8216,9 +8216,739 @@ function registerPaymentsCommands(paymentsCmd2) {
   registerPaymentsHistoryCommand(paymentsCmd2);
 }
 
+// src/commands/posthog/setup.ts
+import { existsSync as existsSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync3 } from "fs";
+import { join as join16, dirname as dirname2 } from "path";
+import * as clack16 from "@clack/prompts";
+import pc3 from "picocolors";
+
+// src/lib/api/posthog.ts
+var REQUEST_TIMEOUT_MS = 3e4;
+async function fetchWithTimeout(url, init, callerSignal) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), REQUEST_TIMEOUT_MS);
+  const onCallerAbort = () => ac.abort();
+  callerSignal?.addEventListener("abort", onCallerAbort);
+  try {
+    return await fetch(url, { ...init, signal: ac.signal });
+  } finally {
+    clearTimeout(timer);
+    callerSignal?.removeEventListener("abort", onCallerAbort);
+  }
+}
+async function fetchPosthogConnection(projectId, jwt, apiUrl, signal) {
+  const baseUrl = getPlatformApiUrl(apiUrl);
+  const url = `${baseUrl}/integrations/posthog/v1/connection?project_id=${encodeURIComponent(projectId)}`;
+  let res;
+  try {
+    res = await fetchWithTimeout(
+      url,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${jwt}`,
+          Accept: "application/json"
+        }
+      },
+      signal
+    );
+  } catch (err) {
+    return { kind: "error", message: formatFetchError(err, url) };
+  }
+  if (res.status === 404) {
+    return { kind: "not-connected" };
+  }
+  if (res.status === 403) {
+    const body = await res.json().catch(() => ({}));
+    return {
+      kind: "forbidden",
+      message: body.error ?? "Forbidden \u2014 you may not have access to this project."
+    };
+  }
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    return {
+      kind: "error",
+      message: body.error ?? `Request failed: HTTP ${res.status}`,
+      status: res.status
+    };
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch (err) {
+    return {
+      kind: "error",
+      message: `Could not parse connection response: ${err.message}`
+    };
+  }
+  const conn = data ?? {};
+  if (!conn.apiKey) {
+    return { kind: "not-connected" };
+  }
+  if (conn.status && conn.status !== "active") {
+    return { kind: "not-connected" };
+  }
+  return { kind: "connected", connection: conn };
+}
+async function pollPosthogConnection(projectId, jwt, opts, apiUrl) {
+  const start = Date.now();
+  let consecutiveErrors = 0;
+  for (; ; ) {
+    if (opts.signal?.aborted) {
+      throw new CLIError("Connection wait cancelled.");
+    }
+    const elapsed = Date.now() - start;
+    if (elapsed >= opts.timeoutMs) {
+      throw new CLIError(
+        "Timed out waiting for PostHog connection. Re-run `insforge posthog setup` after authorizing."
+      );
+    }
+    opts.onTick?.(elapsed);
+    const result = await fetchPosthogConnection(projectId, jwt, apiUrl, opts.signal);
+    switch (result.kind) {
+      case "connected":
+        return result.connection;
+      case "forbidden":
+        throw new CLIError(`Forbidden: ${result.message}`, 5);
+      case "error":
+        consecutiveErrors += 1;
+        if (consecutiveErrors > opts.maxTransientRetries) {
+          throw new CLIError(
+            `Connection check failed after ${opts.maxTransientRetries} retries: ${result.message}`
+          );
+        }
+        break;
+      case "not-connected":
+        consecutiveErrors = 0;
+        break;
+    }
+    await sleep(opts.intervalMs, opts.signal);
+  }
+}
+async function startPosthogCliFlow(projectId, jwt, apiUrl) {
+  const baseUrl = getPlatformApiUrl(apiUrl);
+  const url = `${baseUrl}/integrations/posthog/v1/cli-start?p=${encodeURIComponent(projectId)}`;
+  let res;
+  try {
+    res = await fetchWithTimeout(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${jwt}`,
+        Accept: "application/json"
+      }
+    });
+  } catch (err) {
+    throw new CLIError(`Failed to start PostHog connect flow: ${formatFetchError(err, url)}`);
+  }
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    const msg = body.error ?? res.statusText ?? `HTTP ${res.status}`;
+    if (res.status === 401) {
+      throw new CLIError(`Not authenticated (HTTP 401): ${msg}. Re-run \`insforge login\`.`);
+    }
+    if (res.status === 403) {
+      throw new CLIError(`Forbidden (HTTP 403): ${msg}`, 5);
+    }
+    if (res.status === 404) {
+      throw new CLIError(
+        `PostHog connect flow unavailable (HTTP 404): ${msg}. Check that the project is linked.`
+      );
+    }
+    throw new CLIError(`PostHog cli-start failed (HTTP ${res.status}): ${msg}`);
+  }
+  const data = await res.json().catch(() => ({}));
+  if (data.type === "connected") {
+    return { type: "connected" };
+  }
+  if (data.type === "authorize" && typeof data.authorizeUrl === "string" && data.authorizeUrl) {
+    return { type: "authorize", authorizeUrl: data.authorizeUrl };
+  }
+  throw new CLIError("PostHog cli-start returned an unexpected response shape.");
+}
+function sleep(ms, signal) {
+  return new Promise((resolve5, reject) => {
+    if (signal?.aborted) {
+      reject(new CLIError("Connection wait cancelled."));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve5();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new CLIError("Connection wait cancelled."));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/lib/framework-detect.ts
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { join as join14 } from "path";
+function contextFromCwd(cwd) {
+  let pkg2 = null;
+  const pkgPath = join14(cwd, "package.json");
+  if (existsSync10(pkgPath)) {
+    try {
+      pkg2 = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    } catch {
+      pkg2 = null;
+    }
+  }
+  return {
+    hasDir: (rel) => existsSync10(join14(cwd, rel)),
+    pkg: pkg2
+  };
+}
+function hasDep(pkg2, name) {
+  if (!pkg2) return false;
+  return Boolean(pkg2.dependencies?.[name] ?? pkg2.devDependencies?.[name]);
+}
+function detectFramework(ctx) {
+  if (hasDep(ctx.pkg, "next")) {
+    const hasApp = ctx.hasDir("app") || ctx.hasDir("src/app");
+    const hasPages = ctx.hasDir("pages") || ctx.hasDir("src/pages");
+    if (hasApp && !hasPages) return "next-app";
+    if (hasPages && !hasApp) return "next-pages";
+    if (hasApp && hasPages) return "next-app";
+    return "next-app";
+  }
+  if (hasDep(ctx.pkg, "vite") && hasDep(ctx.pkg, "react")) {
+    return "vite-react";
+  }
+  if (hasDep(ctx.pkg, "@sveltejs/kit")) {
+    return "sveltekit";
+  }
+  if (hasDep(ctx.pkg, "astro")) {
+    return "astro";
+  }
+  return null;
+}
+
+// src/lib/package-manager.ts
+import { existsSync as existsSync11 } from "fs";
+import { join as join15 } from "path";
+import { exec as exec4 } from "child_process";
+import { promisify as promisify5 } from "util";
+var execAsync4 = promisify5(exec4);
+function detectPackageManager(cwd) {
+  if (existsSync11(join15(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync11(join15(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync11(join15(cwd, "bun.lockb")) || existsSync11(join15(cwd, "bun.lock"))) {
+    return "bun";
+  }
+  return "npm";
+}
+function installCommand(pm, pkg2) {
+  switch (pm) {
+    case "pnpm":
+      return `pnpm add ${pkg2}`;
+    case "yarn":
+      return `yarn add ${pkg2}`;
+    case "bun":
+      return `bun add ${pkg2}`;
+    case "npm":
+    default:
+      return `npm install ${pkg2}`;
+  }
+}
+function hasPackage(pkg2, name) {
+  if (!pkg2) return false;
+  return Boolean(pkg2.dependencies?.[name] ?? pkg2.devDependencies?.[name]);
+}
+async function runInstall(pm, pkgName, cwd) {
+  const cmd = installCommand(pm, pkgName);
+  await execAsync4(cmd, { cwd, maxBuffer: 16 * 1024 * 1024 });
+}
+
+// src/lib/env-writer.ts
+import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+var KEY_LINE_RE = (key) => (
+  // Match `KEY=...` at the start of a line (allowing leading whitespace).
+  // Captures the value side; we only need the value portion to compare.
+  new RegExp(`^\\s*${key.replace(/[$.*+?^()[\\]{}|]/g, "\\$&")}\\s*=\\s*(.*)$`, "m")
+);
+function stripQuotes(v) {
+  const t = v.trim();
+  if (t.startsWith('"') && t.endsWith('"') && t.length >= 2 || t.startsWith("'") && t.endsWith("'") && t.length >= 2) {
+    return t.slice(1, -1);
+  }
+  const hash = t.indexOf(" #");
+  return hash >= 0 ? t.slice(0, hash).trimEnd() : t;
+}
+function upsertEnvFile(path6, entries) {
+  const exists = existsSync12(path6);
+  let content = exists ? readFileSync9(path6, "utf-8") : "";
+  const result = { added: [], skipped: [], mismatched: [] };
+  const additions = [];
+  for (const [key, value] of Object.entries(entries)) {
+    const re = KEY_LINE_RE(key);
+    const match = content.match(re);
+    if (match) {
+      const existingValue = stripQuotes(match[1] ?? "");
+      if (existingValue === value) {
+        result.skipped.push(key);
+      } else {
+        result.mismatched.push({ key, existingValue, newValue: value });
+      }
+      continue;
+    }
+    additions.push(`${key}=${value}`);
+    result.added.push(key);
+  }
+  if (additions.length > 0) {
+    if (content.length > 0 && !content.endsWith("\n")) {
+      content += "\n";
+    }
+    content += additions.join("\n") + "\n";
+    writeFileSync7(path6, content);
+  } else if (!exists) {
+  }
+  return result;
+}
+
+// src/templates/posthog/next-app/posthog-provider.tsx.txt
+var posthog_provider_tsx_default = "'use client';\n\nimport { useEffect } from 'react';\nimport posthog from 'posthog-js';\n\n// PostHog client-side provider for the Next.js App Router.\n// Initialises posthog-js exactly once on the client; SSR is skipped because\n// `useEffect` only runs in the browser.\nexport function PostHogProvider({ children }: { children: React.ReactNode }) {\n  useEffect(() => {\n    if (typeof window === 'undefined') return;\n    if (posthog.__loaded) return;\n\n    const key = process.env.NEXT_PUBLIC_POSTHOG_KEY;\n    if (!key) {\n      // Fail closed in production: missing env var \u2192 no init, no events.\n      // Avoids accidentally firing events without a key in CI/preview builds.\n      return;\n    }\n\n    posthog.init(key, {\n      api_host: process.env.NEXT_PUBLIC_POSTHOG_HOST || '{{HOST}}',\n      capture_pageview: true,\n      capture_pageleave: true,\n    });\n  }, []);\n\n  return <>{children}</>;\n}\n";
+
+// src/templates/posthog/next-app/layout-snippet.tsx.txt
+var layout_snippet_tsx_default = `// Wrap your <body> children with <PostHogProvider> in app/layout.tsx:
+//
+//   import { PostHogProvider } from './posthog-provider';
+//
+//   export default function RootLayout({ children }: { children: React.ReactNode }) {
+//     return (
+//       <html lang="en">
+//         <body>
+//           <PostHogProvider>{children}</PostHogProvider>
+//         </body>
+//       </html>
+//     );
+//   }
+`;
+
+// src/templates/posthog/next-pages/_app.tsx.txt
+var app_tsx_default = "import type { AppProps } from 'next/app';\nimport { useEffect } from 'react';\nimport posthog from 'posthog-js';\n\nif (typeof window !== 'undefined') {\n  const key = process.env.NEXT_PUBLIC_POSTHOG_KEY;\n  if (key && !posthog.__loaded) {\n    posthog.init(key, {\n      api_host: process.env.NEXT_PUBLIC_POSTHOG_HOST || '{{HOST}}',\n      capture_pageview: true,\n      capture_pageleave: true,\n    });\n  }\n}\n\nexport default function App({ Component, pageProps }: AppProps) {\n  useEffect(() => {\n    // Capture pageviews on client-side route changes.\n    const handleRouteChange = () => posthog.capture('$pageview');\n    if (typeof window !== 'undefined') {\n      window.addEventListener('popstate', handleRouteChange);\n      return () => window.removeEventListener('popstate', handleRouteChange);\n    }\n  }, []);\n\n  return <Component {...pageProps} />;\n}\n";
+
+// src/templates/posthog/vite-react/main-snippet.tsx.txt
+var main_snippet_tsx_default = "// Add this near the top of src/main.tsx, before ReactDOM.createRoot:\nimport posthog from 'posthog-js';\n\nconst posthogKey = import.meta.env.VITE_PUBLIC_POSTHOG_KEY;\nif (posthogKey) {\n  posthog.init(posthogKey, {\n    api_host: import.meta.env.VITE_PUBLIC_POSTHOG_HOST || '{{HOST}}',\n    capture_pageview: true,\n    capture_pageleave: true,\n  });\n}\n";
+
+// src/templates/posthog/sveltekit/hooks.client.ts.txt
+var hooks_client_ts_default = "import posthog from 'posthog-js';\nimport { browser } from '$app/environment';\nimport { PUBLIC_POSTHOG_KEY, PUBLIC_POSTHOG_HOST } from '$env/static/public';\n\n// `hooks.client.ts` only runs in the browser, so we don't need an explicit\n// `typeof window` guard. The `browser` import is included so future edits\n// (e.g. moving init to a non-client hook) don't accidentally fire on the server.\nif (browser && PUBLIC_POSTHOG_KEY) {\n  posthog.init(PUBLIC_POSTHOG_KEY, {\n    api_host: PUBLIC_POSTHOG_HOST || '{{HOST}}',\n    capture_pageview: true,\n    capture_pageleave: true,\n  });\n}\n\nexport const handleError = ({ error }: { error: unknown }) => {\n  posthog.capture('$exception', { error: String(error) });\n};\n";
+
+// src/templates/posthog/astro/posthog-init.ts.txt
+var posthog_init_ts_default = "import posthog from 'posthog-js';\n\n// PostHog client init for Astro. This module runs only in the browser bundle\n// (Astro inlines `client:load` / `<script>` imports into client JS). We still\n// guard with `typeof window` because the same file may be transitively\n// imported during SSR \u2014 the guard prevents init from accidentally running on\n// the server during static generation.\nif (typeof window !== 'undefined') {\n  const key = import.meta.env.PUBLIC_POSTHOG_KEY;\n  if (key) {\n    posthog.init(key, {\n      api_host: import.meta.env.PUBLIC_POSTHOG_HOST || '{{HOST}}',\n      capture_pageview: 'history_change',\n      capture_pageleave: true,\n    });\n  }\n}\n";
+
+// src/templates/posthog/index.ts
+var templates = {
+  "next-app": {
+    provider: posthog_provider_tsx_default,
+    layoutSnippet: layout_snippet_tsx_default
+  },
+  "next-pages": {
+    app: app_tsx_default
+  },
+  "vite-react": {
+    mainSnippet: main_snippet_tsx_default
+  },
+  sveltekit: {
+    hooks: hooks_client_ts_default
+  },
+  astro: {
+    init: posthog_init_ts_default
+  }
+};
+function renderTemplate(raw, vars) {
+  return raw.replace(/\{\{([A-Z0-9_]+)\}\}/g, (match, key) => {
+    return Object.prototype.hasOwnProperty.call(vars, key) ? vars[key] : match;
+  });
+}
+
+// src/commands/posthog/setup.ts
+var POLL_INTERVAL_MS4 = 2e3;
+var POLL_TIMEOUT_MS4 = 15 * 60 * 1e3;
+var MAX_TRANSIENT_RETRIES = 5;
+function registerPosthogSetupCommand(program2) {
+  program2.command("setup").description("Install the PostHog SDK into the current directory app").option("--framework <name>", "Force framework (next-app|next-pages|vite-react|sveltekit|astro)").option("--skip-install", "Do not run the package manager install step").option("--skip-browser", "Do not auto-open the browser; only print the URL").action(async (opts, cmd) => {
+    const { json, apiUrl } = getRootOpts(cmd);
+    try {
+      const result = await runSetup({
+        json,
+        apiUrl,
+        forceFramework: opts.framework,
+        skipInstall: Boolean(opts.skipInstall),
+        skipBrowser: Boolean(opts.skipBrowser)
+      });
+      if (json) {
+        outputJson({ success: true, ...result });
+      }
+    } catch (err) {
+      handleError(err, json);
+    }
+  });
+}
+async function runSetup(opts) {
+  const proj = getProjectConfig();
+  if (!proj || !proj.project_id) {
+    throw new ProjectNotLinkedError();
+  }
+  const token = getAccessToken();
+  if (!token) {
+    throw new AuthError("Not logged in. Run `insforge login` first.");
+  }
+  if (!opts.json) {
+    clack16.intro("PostHog setup");
+    outputSuccess(`Linked to InsForge project: ${proj.project_name} (${proj.project_id})`);
+  }
+  const startResult = await startPosthogCliFlow(proj.project_id, token, opts.apiUrl);
+  let conn;
+  if (startResult.type === "connected") {
+    if (!opts.json) {
+      outputSuccess("PostHog already connected (or auto-provisioned for new user). Continuing...");
+    }
+    const fetchResult = await fetchPosthogConnection(proj.project_id, token, opts.apiUrl);
+    if (fetchResult.kind !== "connected") {
+      throw new CLIError(
+        "cli-start reported connected, but /connection returned not-connected. Try again, or check the dashboard."
+      );
+    }
+    conn = fetchResult.connection;
+  } else {
+    conn = await runConnectFlow(proj.project_id, token, startResult.authorizeUrl, opts);
+  }
+  if (!conn.apiKey) {
+    throw new CLIError(
+      "Connection succeeded but cloud-backend returned no apiKey. Try again or check the dashboard."
+    );
+  }
+  const framework = resolveFramework(opts);
+  if (framework === null) {
+    return reportNoFramework(conn, opts);
+  }
+  if (!opts.json) outputSuccess(`Detected framework: ${frameworkLabel(framework)}`);
+  const cwd = process.cwd();
+  const ctx = contextFromCwd(cwd);
+  const pm = detectPackageManager(cwd);
+  const alreadyInstalled = hasPackage(ctx.pkg, "posthog-js");
+  let installedSdk = false;
+  if (alreadyInstalled) {
+    if (!opts.json) outputInfo(pc3.dim("posthog-js is already installed \u2014 skipping install."));
+  } else if (opts.skipInstall) {
+    if (!opts.json) {
+      outputInfo(pc3.yellow(`Skipping install. Run manually: ${installCommand(pm, "posthog-js")}`));
+    }
+  } else {
+    installedSdk = await installSdk(pm, cwd, opts);
+  }
+  const filesWritten = [];
+  const notes = [];
+  const envResult = writeForFramework(framework, conn, cwd, filesWritten, notes, opts);
+  if (!opts.json) {
+    if (notes.length > 0) {
+      for (const n of notes) clack16.log.info(n);
+    }
+    clack16.outro("Done. Run your dev server to start sending events.");
+  }
+  return {
+    framework,
+    installedSdk,
+    filesWritten,
+    envWritten: envResult,
+    notes
+  };
+}
+async function runConnectFlow(projectId, token, authorizeUrl, opts) {
+  if (opts.json) {
+    process.stderr.write(`Authorize PostHog: ${authorizeUrl}
+`);
+    process.stderr.write("Your browser should open automatically. If not, copy the URL above.\n");
+  } else {
+    clack16.log.info("PostHog is not connected to this project yet.");
+    outputInfo("");
+    outputInfo(`Open this URL to authorize PostHog:
+  ${pc3.cyan(pc3.underline(authorizeUrl))}`);
+    outputInfo("");
+  }
+  if (!opts.skipBrowser) {
+    try {
+      const open = (await import("open")).default;
+      await open(authorizeUrl);
+    } catch {
+    }
+  }
+  const spinner10 = !opts.json && isInteractive ? clack16.spinner() : null;
+  spinner10?.start("Waiting for connection... (timeout: 15 minutes)");
+  try {
+    const conn = await pollPosthogConnection(
+      projectId,
+      token,
+      {
+        intervalMs: POLL_INTERVAL_MS4,
+        timeoutMs: POLL_TIMEOUT_MS4,
+        maxTransientRetries: MAX_TRANSIENT_RETRIES,
+        onTick: (elapsed) => {
+          if (spinner10) {
+            const secs = Math.floor(elapsed / 1e3);
+            const mins = Math.floor(secs / 60);
+            const remaining = `${mins}m ${secs % 60}s elapsed`;
+            spinner10.message(`Waiting for connection... (${remaining})`);
+          }
+        }
+      },
+      opts.apiUrl
+    );
+    spinner10?.stop("Connection received from PostHog.");
+    return conn;
+  } catch (err) {
+    spinner10?.stop("Connection wait failed.");
+    throw err;
+  }
+}
+function resolveFramework(opts) {
+  if (opts.forceFramework) {
+    const valid = ["next-app", "next-pages", "vite-react", "sveltekit", "astro"];
+    if (!valid.includes(opts.forceFramework)) {
+      throw new CLIError(
+        `Invalid --framework "${opts.forceFramework}". Valid: ${valid.join(", ")}`
+      );
+    }
+    return opts.forceFramework;
+  }
+  return detectFramework(contextFromCwd(process.cwd()));
+}
+async function installSdk(pm, cwd, opts) {
+  const cmd = installCommand(pm, "posthog-js");
+  const spinner10 = !opts.json && isInteractive ? clack16.spinner() : null;
+  spinner10?.start(`Installing posthog-js (${cmd})...`);
+  try {
+    await runInstall(pm, "posthog-js", cwd);
+    spinner10?.stop("Installed posthog-js.");
+    return true;
+  } catch (err) {
+    spinner10?.stop("Install failed.");
+    if (!opts.json) {
+      clack16.log.warn(
+        `Could not run \`${cmd}\` automatically: ${err.message}
+Run it manually, then re-run \`insforge posthog setup\`.`
+      );
+    }
+    return false;
+  }
+}
+function writeForFramework(framework, conn, cwd, filesWritten, notes, opts) {
+  const host = conn.host || "https://us.posthog.com";
+  const phc = conn.apiKey ?? "";
+  switch (framework) {
+    case "next-app":
+      return writeNextApp(cwd, phc, host, filesWritten, notes, opts);
+    case "next-pages":
+      return writeNextPages(cwd, phc, host, filesWritten, notes, opts);
+    case "vite-react":
+      return writeViteReact(cwd, phc, host, filesWritten, notes, opts);
+    case "sveltekit":
+      return writeSveltekit(cwd, phc, host, filesWritten, notes, opts);
+    case "astro":
+      return writeAstro(cwd, phc, host, filesWritten, notes, opts);
+  }
+}
+function writeNextApp(cwd, phc, host, filesWritten, notes, opts) {
+  const appDir = existsSync13(join16(cwd, "src/app")) ? "src/app" : "app";
+  const providerPath = join16(cwd, appDir, "posthog-provider.tsx");
+  writeIfMissing(
+    providerPath,
+    renderTemplate(templates["next-app"].provider, { HOST: host }),
+    filesWritten,
+    notes,
+    opts
+  );
+  notes.push(
+    `Add the provider to your ${appDir}/layout.tsx:
+${templates["next-app"].layoutSnippet}`
+  );
+  const envFile = ".env.local";
+  return writeEnv(
+    cwd,
+    envFile,
+    {
+      NEXT_PUBLIC_POSTHOG_KEY: phc,
+      NEXT_PUBLIC_POSTHOG_HOST: host
+    },
+    opts
+  );
+}
+function writeNextPages(cwd, phc, host, filesWritten, notes, opts) {
+  const pagesDir = existsSync13(join16(cwd, "src/pages")) ? "src/pages" : "pages";
+  const appPath = join16(cwd, pagesDir, "_app.tsx");
+  writeIfMissing(
+    appPath,
+    renderTemplate(templates["next-pages"].app, { HOST: host }),
+    filesWritten,
+    notes,
+    opts,
+    "pages/_app.tsx already exists. Open it and add `posthog.init(...)` near the top \u2014 see PostHog Next.js docs."
+  );
+  const envFile = ".env.local";
+  return writeEnv(
+    cwd,
+    envFile,
+    {
+      NEXT_PUBLIC_POSTHOG_KEY: phc,
+      NEXT_PUBLIC_POSTHOG_HOST: host
+    },
+    opts
+  );
+}
+function writeViteReact(cwd, phc, host, _filesWritten, notes, opts) {
+  notes.push(
+    `Add this snippet near the top of src/main.tsx:
+${renderTemplate(templates["vite-react"].mainSnippet, { HOST: host })}`
+  );
+  const envFile = ".env";
+  return writeEnv(
+    cwd,
+    envFile,
+    {
+      VITE_PUBLIC_POSTHOG_KEY: phc,
+      VITE_PUBLIC_POSTHOG_HOST: host
+    },
+    opts
+  );
+}
+function writeSveltekit(cwd, phc, host, filesWritten, notes, opts) {
+  const hooksPath = join16(cwd, "src/hooks.client.ts");
+  writeIfMissing(
+    hooksPath,
+    renderTemplate(templates.sveltekit.hooks, { HOST: host }),
+    filesWritten,
+    notes,
+    opts,
+    "src/hooks.client.ts already exists. Add `posthog.init(...)` to it \u2014 see PostHog SvelteKit docs."
+  );
+  const envFile = ".env";
+  return writeEnv(
+    cwd,
+    envFile,
+    {
+      PUBLIC_POSTHOG_KEY: phc,
+      PUBLIC_POSTHOG_HOST: host
+    },
+    opts
+  );
+}
+function writeAstro(cwd, phc, host, filesWritten, notes, opts) {
+  const initPath = join16(cwd, "src/lib/posthog.ts");
+  writeIfMissing(
+    initPath,
+    renderTemplate(templates.astro.init, { HOST: host }),
+    filesWritten,
+    notes,
+    opts,
+    "src/lib/posthog.ts already exists. Add `posthog.init(...)` per PostHog Astro docs."
+  );
+  notes.push(
+    `Import the init module from your layout to load it on the client:
+  // src/layouts/Layout.astro (inside <head> or <body>)
+  <script>import '../lib/posthog';</script>`
+  );
+  const envFile = ".env";
+  return writeEnv(
+    cwd,
+    envFile,
+    {
+      PUBLIC_POSTHOG_KEY: phc,
+      PUBLIC_POSTHOG_HOST: host
+    },
+    opts
+  );
+}
+function writeIfMissing(filePath, contents, filesWritten, notes, opts, conflictNote) {
+  if (existsSync13(filePath)) {
+    const existing = readFileSync10(filePath, "utf-8");
+    if (existing.includes("posthog.init")) {
+      if (!opts.json) {
+        outputInfo(pc3.dim(`${relative3(filePath)} already calls posthog.init \u2014 leaving it alone.`));
+      }
+      return;
+    }
+    if (conflictNote) notes.push(conflictNote);
+    if (!opts.json) {
+      outputInfo(
+        pc3.yellow(
+          `${relative3(filePath)} exists. Skipped writing \u2014 see notes below for manual changes.`
+        )
+      );
+    }
+    return;
+  }
+  mkdirSync3(dirname2(filePath), { recursive: true });
+  writeFileSync8(filePath, contents);
+  filesWritten.push(filePath);
+  if (!opts.json) outputSuccess(`Wrote ${relative3(filePath)}`);
+}
+function writeEnv(cwd, envFile, entries, opts) {
+  const path6 = join16(cwd, envFile);
+  const r = upsertEnvFile(path6, entries);
+  if (!opts.json) {
+    if (r.added.length > 0) {
+      outputSuccess(`Wrote ${envFile}: ${r.added.join(", ")}`);
+    }
+    if (r.skipped.length > 0) {
+      outputInfo(
+        pc3.dim(`${envFile}: ${r.skipped.join(", ")} already set (matching) \u2014 left as-is.`)
+      );
+    }
+    for (const m of r.mismatched) {
+      clack16.log.warn(
+        `${envFile} has ${m.key}=${pc3.dim(m.existingValue)}, expected ${m.newValue}. Left existing value untouched.`
+      );
+    }
+  }
+  return {
+    file: envFile,
+    added: r.added,
+    mismatched: r.mismatched.map((m) => m.key)
+  };
+}
+function reportNoFramework(conn, opts) {
+  if (!opts.json) {
+    clack16.log.warn("No supported framework detected in this directory.");
+    outputInfo("");
+    outputInfo(`Your PostHog public key:  ${pc3.cyan(conn.apiKey ?? "(missing)")}`);
+    outputInfo(`Your PostHog host:        ${conn.host ?? "https://us.posthog.com"}`);
+    outputInfo("");
+    outputInfo("See https://posthog.com/docs/libraries to install the SDK manually.");
+    clack16.outro("Done.");
+  }
+  return {
+    framework: null,
+    installedSdk: false,
+    filesWritten: [],
+    envWritten: { file: "", added: [], mismatched: [] },
+    notes: ["No supported framework detected."]
+  };
+}
+function frameworkLabel(framework) {
+  switch (framework) {
+    case "next-app":
+      return "Next.js (App Router)";
+    case "next-pages":
+      return "Next.js (Pages Router)";
+    case "vite-react":
+      return "Vite + React";
+    case "sveltekit":
+      return "SvelteKit";
+    case "astro":
+      return "Astro";
+  }
+}
+function relative3(p) {
+  return p.replace(process.cwd() + "/", "");
+}
+
 // src/index.ts
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(readFileSync8(join14(__dirname, "../package.json"), "utf-8"));
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(readFileSync11(join17(__dirname, "../package.json"), "utf-8"));
 var INSFORGE_LOGO = `
 \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D
@@ -8300,6 +9030,8 @@ registerComputeDeleteCommand(computeCmd);
 registerComputeStartCommand(computeCmd);
 registerComputeStopCommand(computeCmd);
 registerComputeEventsCommand(computeCmd);
+var posthogCmd = program.command("posthog").description("Manage PostHog product analytics integration");
+registerPosthogSetupCommand(posthogCmd);
 var schedulesCmd = program.command("schedules").description("Manage scheduled tasks (cron jobs)");
 registerSchedulesListCommand(schedulesCmd);
 registerSchedulesGetCommand(schedulesCmd);
@@ -8324,7 +9056,7 @@ async function showInteractiveMenu() {
   } catch {
   }
   console.log(INSFORGE_LOGO);
-  clack16.intro(`InsForge CLI v${pkg.version}`);
+  clack17.intro(`InsForge CLI v${pkg.version}`);
   const options = [];
   if (!isLoggedIn) {
     options.push({ value: "login", label: "Log in to InsForge" });
@@ -8345,7 +9077,7 @@ async function showInteractiveMenu() {
     options
   });
   if (isCancel2(action)) {
-    clack16.cancel("Bye!");
+    clack17.cancel("Bye!");
     process.exit(0);
   }
   switch (action) {