@fixprompt/cli 0.5.0 → 0.6.0

package/dist/cli.js

@@ -87,9 +87,362 @@ function detectContext() {
 }
 
 // src/connect.ts
-import { appendFileSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
-import { join } from "path";
+import { appendFileSync, existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/install-sdk.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
 import { spawnSync } from "child_process";
+function readPackageJson(cwd) {
+  const p = join(cwd, "package.json");
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function firstExisting(cwd, candidates) {
+  for (const c of candidates) {
+    const full = join(cwd, c);
+    if (existsSync(full)) return full;
+  }
+  return null;
+}
+function detectPackageManager(cwd) {
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync(join(cwd, "bun.lockb"))) return "bun";
+  return "npm";
+}
+function detectStack(cwd) {
+  const pj = readPackageJson(cwd);
+  const deps = { ...pj?.dependencies ?? {}, ...pj?.devDependencies ?? {} };
+  const has = (n) => Object.prototype.hasOwnProperty.call(deps, n);
+  const packageManager = detectPackageManager(cwd);
+  if (has("react-native") || has("expo")) {
+    return {
+      runtime: "react-native",
+      packageManager,
+      sdkPackage: "@fixprompt/react-native",
+      envVarName: "EXPO_PUBLIC_FIXPROMPT_KEY",
+      entryFile: firstExisting(cwd, [
+        "App.tsx",
+        "App.jsx",
+        "App.ts",
+        "App.js",
+        "src/App.tsx",
+        "src/App.jsx",
+        "src/App.ts",
+        "src/App.js",
+        "index.tsx",
+        "index.jsx",
+        "index.ts",
+        "index.js"
+      ])
+    };
+  }
+  if (has("next")) {
+    const appLayout = firstExisting(cwd, [
+      "app/layout.tsx",
+      "app/layout.jsx",
+      "app/layout.ts",
+      "app/layout.js",
+      "src/app/layout.tsx",
+      "src/app/layout.jsx",
+      "src/app/layout.ts",
+      "src/app/layout.js"
+    ]);
+    if (appLayout) {
+      return {
+        runtime: "next-app",
+        packageManager,
+        sdkPackage: "@fixprompt/browser",
+        envVarName: "NEXT_PUBLIC_FIXPROMPT_KEY",
+        entryFile: appLayout
+      };
+    }
+    const pagesApp = firstExisting(cwd, [
+      "pages/_app.tsx",
+      "pages/_app.jsx",
+      "pages/_app.ts",
+      "pages/_app.js",
+      "src/pages/_app.tsx",
+      "src/pages/_app.jsx",
+      "src/pages/_app.ts",
+      "src/pages/_app.js"
+    ]);
+    return {
+      runtime: "next-pages",
+      packageManager,
+      sdkPackage: "@fixprompt/browser",
+      envVarName: "NEXT_PUBLIC_FIXPROMPT_KEY",
+      entryFile: pagesApp
+    };
+  }
+  if (has("vite")) {
+    return {
+      runtime: "vite",
+      packageManager,
+      sdkPackage: "@fixprompt/browser",
+      envVarName: "VITE_FIXPROMPT_KEY",
+      entryFile: firstExisting(cwd, [
+        "src/main.tsx",
+        "src/main.jsx",
+        "src/main.ts",
+        "src/main.js"
+      ])
+    };
+  }
+  if (has("react-scripts")) {
+    return {
+      runtime: "cra",
+      packageManager,
+      sdkPackage: "@fixprompt/browser",
+      envVarName: "REACT_APP_FIXPROMPT_KEY",
+      entryFile: firstExisting(cwd, [
+        "src/index.tsx",
+        "src/index.jsx",
+        "src/index.ts",
+        "src/index.js"
+      ])
+    };
+  }
+  if (has("react") || has("@vitejs/plugin-react")) {
+    return {
+      runtime: "browser",
+      packageManager,
+      sdkPackage: "@fixprompt/browser",
+      envVarName: "VITE_FIXPROMPT_KEY",
+      entryFile: firstExisting(cwd, [
+        "src/main.tsx",
+        "src/main.jsx",
+        "src/index.tsx",
+        "src/index.jsx"
+      ])
+    };
+  }
+  if (has("express") || has("@nestjs/core") || has("fastify") || pj?.main) {
+    return {
+      runtime: "node",
+      packageManager,
+      // @fixprompt/node isn't published yet — fall back to the legacy
+      // GitHub install which is still what every existing backend uses.
+      sdkPackage: "@geos/loghub-client@github:goscha01/geos-loghub-client",
+      envVarName: "LOGHUB_KEY",
+      entryFile: null
+      // legacy client has no init() to inject
+    };
+  }
+  return {
+    runtime: null,
+    packageManager,
+    sdkPackage: "",
+    envVarName: "",
+    entryFile: null
+  };
+}
+function installSdk(cwd, stack) {
+  if (!stack.sdkPackage) return { skipped: true, reason: "no SDK for this stack" };
+  const pj = readPackageJson(cwd);
+  const deps = { ...pj?.dependencies ?? {}, ...pj?.devDependencies ?? {} };
+  const bareName = stack.sdkPackage.split("@github:")[0].replace(/@\^?[\d.]+$/, "");
+  if (Object.prototype.hasOwnProperty.call(deps, bareName)) {
+    return { skipped: true, reason: `${bareName} already in package.json` };
+  }
+  const useShell = process.platform === "win32";
+  const pm = stack.packageManager;
+  const args = pm === "yarn" ? ["add", stack.sdkPackage] : pm === "pnpm" ? ["add", stack.sdkPackage] : pm === "bun" ? ["add", stack.sdkPackage] : ["install", stack.sdkPackage];
+  console.log(`  \xB7 running ${pm} ${args.join(" ")}\u2026`);
+  const r = spawnSync(
+    pm,
+    useShell ? args.map((a) => `"${a.replace(/"/g, '\\"')}"`) : args,
+    { cwd, stdio: "inherit", shell: useShell }
+  );
+  if (r.status !== 0) {
+    throw new Error(`${pm} install exited ${r.status}`);
+  }
+  return { skipped: false };
+}
+function alreadyHasFixPromptInit(src) {
+  return /initFixPrompt\s*\(/.test(src) || /from\s+['"]@fixprompt\//.test(src);
+}
+function buildBrowserInitSnippet(slug, envAccess, envCheck) {
+  return `
+import { initFixPrompt } from '@fixprompt/browser';
+const __fpKey = ${envAccess};
+if (__fpKey) {
+  initFixPrompt({
+    projectKey: __fpKey,
+    source: '${slug}-prod',
+    service: '${slug}',
+    env: ${envCheck} ? 'prod' : 'dev',
+  });
+}
+`;
+}
+function buildRnInitSnippet(slug) {
+  return `
+import { initFixPrompt } from '@fixprompt/react-native';
+const __fpKey = process.env.EXPO_PUBLIC_FIXPROMPT_KEY;
+if (__fpKey) {
+  initFixPrompt({
+    projectKey: __fpKey,
+    source: '${slug}-prod',
+    service: '${slug}',
+    env: __DEV__ ? 'dev' : 'prod',
+  });
+}
+`;
+}
+function injectAfterImports(src, snippet) {
+  const lines = src.split("\n");
+  let lastImportIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i].trim();
+    if (l.startsWith("import ")) lastImportIdx = i;
+    if (lastImportIdx !== -1 && l && !l.startsWith("import ") && !l.startsWith("//") && !l.startsWith("/*")) {
+      break;
+    }
+  }
+  if (lastImportIdx === -1) return snippet.replace(/^\n/, "") + src;
+  lines.splice(lastImportIdx + 1, 0, snippet.replace(/^\n/, "").replace(/\n$/, ""));
+  return lines.join("\n");
+}
+function injectVite(opts) {
+  const entry = opts.stack.entryFile;
+  if (!entry) return { applied: false, reason: "no Vite entry file (src/main.*) found" };
+  const src = readFileSync(entry, "utf8");
+  if (alreadyHasFixPromptInit(src)) return { applied: false, file: entry, reason: "already wired" };
+  const snippet = buildBrowserInitSnippet(
+    opts.slug,
+    "import.meta.env.VITE_FIXPROMPT_KEY",
+    "import.meta.env.PROD"
+  );
+  writeFileSync(entry, injectAfterImports(src, snippet));
+  return { applied: true, file: entry };
+}
+function injectCra(opts) {
+  const entry = opts.stack.entryFile;
+  if (!entry) return { applied: false, reason: "no CRA entry file (src/index.*) found" };
+  const src = readFileSync(entry, "utf8");
+  if (alreadyHasFixPromptInit(src)) return { applied: false, file: entry, reason: "already wired" };
+  const snippet = buildBrowserInitSnippet(
+    opts.slug,
+    "process.env.REACT_APP_FIXPROMPT_KEY",
+    "process.env.NODE_ENV === 'production'"
+  );
+  writeFileSync(entry, injectAfterImports(src, snippet));
+  return { applied: true, file: entry };
+}
+function injectRn(opts) {
+  const entry = opts.stack.entryFile;
+  if (!entry) return { applied: false, reason: "no React Native entry (App.* / index.*) found" };
+  const src = readFileSync(entry, "utf8");
+  if (alreadyHasFixPromptInit(src)) return { applied: false, file: entry, reason: "already wired" };
+  const snippet = buildRnInitSnippet(opts.slug);
+  writeFileSync(entry, injectAfterImports(src, snippet));
+  return { applied: true, file: entry };
+}
+function injectNextApp(opts) {
+  const layoutPath = opts.stack.entryFile;
+  if (!layoutPath) return { applied: false, reason: "no Next.js layout file found" };
+  const layoutDir = dirname(layoutPath);
+  const initPath = join(layoutDir, "fixprompt-init.tsx");
+  if (!existsSync(initPath)) {
+    const initContent = `'use client';
+import { useEffect } from 'react';
+import { initFixPrompt } from '@fixprompt/browser';
+
+let __fpDone = false;
+
+export function FixPromptInit() {
+  useEffect(() => {
+    if (__fpDone) return;
+    const key = process.env.NEXT_PUBLIC_FIXPROMPT_KEY;
+    if (!key) return;
+    initFixPrompt({
+      projectKey: key,
+      source: '${opts.slug}-prod',
+      service: '${opts.slug}',
+      env: process.env.NODE_ENV === 'production' ? 'prod' : 'dev',
+    });
+    __fpDone = true;
+  }, []);
+  return null;
+}
+`;
+    writeFileSync(initPath, initContent);
+  }
+  const layoutSrc = readFileSync(layoutPath, "utf8");
+  if (alreadyHasFixPromptInit(layoutSrc)) {
+    return { applied: false, file: layoutPath, reason: "layout already imports FixPromptInit" };
+  }
+  let next = layoutSrc;
+  const importLine = `import { FixPromptInit } from './fixprompt-init';
+`;
+  const lines = next.split("\n");
+  let lastImportIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().startsWith("import ")) lastImportIdx = i;
+  }
+  if (lastImportIdx >= 0) {
+    lines.splice(lastImportIdx + 1, 0, importLine.trim());
+  } else {
+    lines.unshift(importLine.trim());
+  }
+  next = lines.join("\n");
+  const bodyOpen = /<body([^>]*)>/;
+  if (!bodyOpen.test(next)) {
+    return {
+      applied: false,
+      file: layoutPath,
+      reason: "layout has no <body> tag \u2014 paste <FixPromptInit /> manually"
+    };
+  }
+  next = next.replace(bodyOpen, (m) => `${m}
+        <FixPromptInit />`);
+  writeFileSync(layoutPath, next);
+  return { applied: true, file: layoutPath };
+}
+function injectNextPages(opts) {
+  const entry = opts.stack.entryFile;
+  if (!entry) return { applied: false, reason: "no pages/_app.* found" };
+  const src = readFileSync(entry, "utf8");
+  if (alreadyHasFixPromptInit(src)) return { applied: false, file: entry, reason: "already wired" };
+  const snippet = buildBrowserInitSnippet(
+    opts.slug,
+    "process.env.NEXT_PUBLIC_FIXPROMPT_KEY",
+    "process.env.NODE_ENV === 'production'"
+  );
+  writeFileSync(entry, injectAfterImports(src, snippet));
+  return { applied: true, file: entry };
+}
+function injectInit(opts) {
+  switch (opts.stack.runtime) {
+    case "vite":
+      return injectVite(opts);
+    case "cra":
+      return injectCra(opts);
+    case "browser":
+      return injectVite(opts);
+    // close enough — uses VITE_ env, edits the same kind of file
+    case "react-native":
+      return injectRn(opts);
+    case "next-app":
+      return injectNextApp(opts);
+    case "next-pages":
+      return injectNextPages(opts);
+    case "node":
+      return { applied: false, reason: "Node SDK (@geos/loghub-client) has no init() to inject" };
+    default:
+      return { applied: false, reason: "unknown stack \u2014 no injection performed" };
+  }
+}
+
+// src/connect.ts
 var DEFAULT_ENDPOINT = "https://geosloghub-production.up.railway.app";
 var ENV_VAR_BY_SCOPE = {
   deploy: "FIXPROMPT_DEPLOY_TOKEN",
@@ -114,13 +467,13 @@ function dirExists(p) {
   }
 }
 function detectProvider(cwd) {
-  if (fileExists(join(cwd, "app.json")) || fileExists(join(cwd, "app.config.js")) || fileExists(join(cwd, "app.config.ts")) || fileExists(join(cwd, "eas.json"))) {
+  if (fileExists(join2(cwd, "app.json")) || fileExists(join2(cwd, "app.config.js")) || fileExists(join2(cwd, "app.config.ts")) || fileExists(join2(cwd, "eas.json"))) {
     return "eas";
   }
-  if (fileExists(join(cwd, "vercel.json")) || fileExists(join(cwd, ".vercel", "project.json"))) {
+  if (fileExists(join2(cwd, "vercel.json")) || fileExists(join2(cwd, ".vercel", "project.json"))) {
     return "vercel";
   }
-  const wfDir = join(cwd, ".github", "workflows");
+  const wfDir = join2(cwd, ".github", "workflows");
   if (dirExists(wfDir)) {
     try {
       const files = readdirSync(wfDir);
@@ -167,7 +520,7 @@ function writeEas(envVar, token, env, force) {
     "--non-interactive"
   ];
   if (force) args.push("--force");
-  const r = spawnSync("npx", useShell ? args.map((a) => `"${a.replace(/"/g, '\\"')}"`) : args, {
+  const r = spawnSync2("npx", useShell ? args.map((a) => `"${a.replace(/"/g, '\\"')}"`) : args, {
     stdio: "inherit",
     shell: useShell
   });
@@ -184,7 +537,7 @@ function writeGitHubActions(envVar, token, cwd) {
   console.log(`  \xB7 writing ${envVar} to GitHub Actions repo secrets\u2026`);
   const useShell = process.platform === "win32";
   const args = ["secret", "set", envVar, "--body", "-"];
-  const r = spawnSync("gh", useShell ? args.map((a) => `"${a.replace(/"/g, '\\"')}"`) : args, {
+  const r = spawnSync2("gh", useShell ? args.map((a) => `"${a.replace(/"/g, '\\"')}"`) : args, {
     input: token,
     cwd,
     stdio: ["pipe", "inherit", "inherit"],
@@ -209,7 +562,7 @@ then re-run with that token exported.`
   }
   let projectId = target.vercelProjectId;
   if (!projectId) {
-    const pj = join(process.cwd(), ".vercel", "project.json");
+    const pj = join2(process.cwd(), ".vercel", "project.json");
     if (!fileExists(pj)) {
       throw new Error(
         `Could not resolve Vercel project id. Either run from a 'vercel link'-ed
@@ -217,7 +570,7 @@ directory or pass --vercel-project-id <prj_\u2026>.`
       );
     }
     try {
-      const parsed = JSON.parse(readFileSync(pj, "utf8"));
+      const parsed = JSON.parse(readFileSync2(pj, "utf8"));
       projectId = parsed.projectId;
     } catch (e) {
       throw new Error(`failed to read .vercel/project.json: ${e.message}`);
@@ -256,20 +609,20 @@ function writeToProvider(envVar, token, provider, target, force, cwd) {
   }
 }
 function ensureGitignoreHas(cwd, pattern) {
-  const gi = join(cwd, ".gitignore");
+  const gi = join2(cwd, ".gitignore");
   let s = "";
   try {
-    s = readFileSync(gi, "utf8");
+    s = readFileSync2(gi, "utf8");
   } catch {
   }
   const lines = s.split(/\r?\n/);
   if (lines.some((l) => l.trim() === pattern)) return false;
   const sep = s.length === 0 || s.endsWith("\n") ? "" : "\n";
-  writeFileSync(gi, s + sep + "\n# FixLoop\n" + pattern + "\n");
+  writeFileSync2(gi, s + sep + "\n# FixLoop\n" + pattern + "\n");
   return true;
 }
 function appendEnvLocal(cwd, token, projectId, projectSlug, endpoint) {
-  const envPath = join(cwd, ".env.local");
+  const envPath = join2(cwd, ".env.local");
   const lines = [
     "",
     "# FixLoop \u2014 read token for the local coding agent. Gitignored.",
@@ -282,17 +635,17 @@ function appendEnvLocal(cwd, token, projectId, projectSlug, endpoint) {
   lines.push(`FIXPROMPT_BROKER_URL=${endpoint}`);
   lines.push("");
   const block = lines.join("\n");
-  if (existsSync(envPath)) {
+  if (existsSync2(envPath)) {
     appendFileSync(envPath, block);
   } else {
-    writeFileSync(envPath, block.replace(/^\n/, ""));
+    writeFileSync2(envPath, block.replace(/^\n/, ""));
   }
 }
 function detectRuntime(cwd) {
-  const pj = join(cwd, "package.json");
-  if (!existsSync(pj)) return "unknown";
+  const pj = join2(cwd, "package.json");
+  if (!existsSync2(pj)) return "unknown";
   try {
-    const j = JSON.parse(readFileSync(pj, "utf8"));
+    const j = JSON.parse(readFileSync2(pj, "utf8"));
     const deps = { ...j.dependencies || {}, ...j.devDependencies || {} };
     if (deps["react-native"] || deps["expo"]) return "react-native";
     if (deps["next"]) return "next";
@@ -413,16 +766,16 @@ function stripFixloopSection(body) {
   return [...lines.slice(0, realStart), ...trimmedTail].join("\n");
 }
 function appendClaudeMdGuidance(cwd, projectId, projectSlug) {
-  const claudePath = join(cwd, "CLAUDE.md");
+  const claudePath = join2(cwd, "CLAUDE.md");
   const runtime = detectRuntime(cwd);
   const section = buildClaudeMdSection(projectId, projectSlug, runtime);
-  if (existsSync(claudePath)) {
-    const existing = readFileSync(claudePath, "utf8");
+  if (existsSync2(claudePath)) {
+    const existing = readFileSync2(claudePath, "utf8");
     const stripped = stripFixloopSection(existing);
     const next = stripped.endsWith("\n") ? stripped + section.replace(/^\n/, "") : stripped + section;
-    writeFileSync(claudePath, next);
+    writeFileSync2(claudePath, next);
   } else {
-    writeFileSync(claudePath, "# Project\n" + section);
+    writeFileSync2(claudePath, "# Project\n" + section);
   }
 }
 function writeLocalDiscovery(opts) {
@@ -432,6 +785,61 @@ function writeLocalDiscovery(opts) {
   appendEnvLocal(opts.cwd, opts.token, opts.projectId, opts.projectSlug, opts.endpoint);
   appendClaudeMdGuidance(opts.cwd, opts.projectId, opts.projectSlug);
 }
+function deriveSlug(name) {
+  const stripped = name.replace(/^@[^/]+\//, "");
+  const slug = stripped.toLowerCase().replace(/[_.@]/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (slug.length < 2 || slug.length > 32) return null;
+  if (!/^[a-z0-9]/.test(slug) || !/[a-z0-9]$/.test(slug)) return null;
+  return slug;
+}
+function deriveProjectType(runtime) {
+  switch (runtime) {
+    case "react-native":
+      return "mobile";
+    case "next-app":
+    case "next-pages":
+    case "vite":
+    case "cra":
+    case "browser":
+      return "web";
+    case "node":
+      return "api";
+    default:
+      return "other";
+  }
+}
+async function createProjectViaAdmin(opts) {
+  const res = await fetch(`${opts.endpoint}/admin/projects`, {
+    method: "POST",
+    headers: {
+      "x-internal-admin-token": opts.adminToken,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      name: opts.name,
+      slug: opts.slug,
+      project_type: opts.projectType
+    })
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`broker /admin/projects responded ${res.status}: ${text.slice(0, 200)}`);
+  }
+  return JSON.parse(text);
+}
+async function writeRuntimeKey(key, envVar, provider, target, force, cwd) {
+  if (!provider) return { wrote: false, reason: "no provider detected" };
+  switch (provider) {
+    case "eas":
+      writeEas(envVar, key, target.easEnv, force);
+      return { wrote: true };
+    case "vercel":
+      await writeVercel(envVar, key, target);
+      return { wrote: true };
+    case "github-actions":
+      return { wrote: false, reason: "github-actions has no runtime bundle \u2014 runtime key not stored" };
+  }
+}
 async function connect(args) {
   const cwd = process.cwd();
   const scopeRaw = (args.flags.scope ?? "deploy").toLowerCase();
@@ -448,25 +856,67 @@ async function connect(args) {
     process.exit(1);
   }
   const endpoint = (args.flags.endpoint ?? process.env.FIXPROMPT_ENDPOINT ?? DEFAULT_ENDPOINT).replace(/\/$/, "");
+  const stack = detectStack(cwd);
+  const shouldInstall = args.flags["no-install"] !== true;
   let projectId = args.flags["project-id"] ?? process.env.FIXPROMPT_PROJECT_ID ?? null;
   let projectSlug = args.flags["project-slug"] ?? null;
+  let freshRuntimeKey = null;
   if (!projectId && projectSlug) {
     const res = await fetch(`${endpoint}/admin/projects/by-slug/${encodeURIComponent(projectSlug)}`, {
       headers: { "x-internal-admin-token": adminToken }
     });
-    const text = await res.text();
-    if (!res.ok) {
+    if (res.ok) {
+      const parsed = await res.json();
+      projectId = parsed.id;
+      projectSlug = parsed.slug;
+      console.log(`  resolved --project-slug=${projectSlug} \u2192 ${parsed.id} (${parsed.name})`);
+    } else if (res.status !== 404) {
+      const text = await res.text();
       console.error(`Project lookup failed (${res.status}): ${text.slice(0, 200)}`);
       process.exit(1);
     }
-    const parsed = JSON.parse(text);
-    projectId = parsed.id;
-    projectSlug = parsed.slug;
-    console.log(`  resolved --project-slug=${projectSlug} \u2192 ${parsed.id} (${parsed.name})`);
+  }
+  const wantCreate = args.flags.create === true || !projectId && !projectSlug;
+  if (!projectId && wantCreate) {
+    let slugForCreate = projectSlug;
+    let nameForCreate = args.flags["project-name"] ?? null;
+    if (!slugForCreate || !nameForCreate) {
+      const pj = (() => {
+        try {
+          return JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
+        } catch {
+          return null;
+        }
+      })();
+      const pkgName = pj?.name;
+      if (pkgName) {
+        slugForCreate = slugForCreate ?? deriveSlug(pkgName);
+        nameForCreate = nameForCreate ?? pkgName;
+      }
+    }
+    if (!slugForCreate) {
+      console.error(
+        "Could not derive a project slug.\n  Pass --project-slug <slug> or set a clean package.json#name.\n  Slug rules: 2-32 chars, lowercase a-z 0-9 dashes, starts/ends with alphanum."
+      );
+      process.exit(1);
+    }
+    console.log(`
+\u2022 Creating FixLoop project '${slugForCreate}' (no existing match)\u2026`);
+    const created = await createProjectViaAdmin({
+      endpoint,
+      adminToken,
+      name: nameForCreate ?? slugForCreate,
+      slug: slugForCreate,
+      projectType: deriveProjectType(stack.runtime)
+    });
+    projectId = created.project_id;
+    projectSlug = slugForCreate;
+    freshRuntimeKey = created.key;
+    console.log(`  \u2713 project_id ${created.project_id}, source ${created.source}`);
   }
   if (!projectId) {
     console.error(
-      "Need --project-id or --project-slug (or $FIXPROMPT_PROJECT_ID).\n  --project-slug is easiest: it matches the value you see in the dashboard."
+      "Need --project-id, --project-slug, or --create (or $FIXPROMPT_PROJECT_ID).\n  --create derives slug + name from package.json#name automatically."
     );
     process.exit(1);
   }
@@ -500,6 +950,18 @@ async function connect(args) {
   const force = args.flags.force === true;
   const scopes = scope === "both" ? ["deploy", "read"] : [scope];
   const mintedTokens = [];
+  if (freshRuntimeKey && stack.envVarName) {
+    console.log(`
+\u2022 Writing runtime key (${stack.envVarName}) to ${provider ?? "no provider"}\u2026`);
+    try {
+      const r = await writeRuntimeKey(freshRuntimeKey, stack.envVarName, provider, target, force, cwd);
+      if (r.wrote) console.log("  \u2713 runtime key stored on CI provider");
+      else console.log(`  \xB7 skipped (${r.reason}) \u2014 set ${stack.envVarName} manually if needed`);
+    } catch (e) {
+      console.warn(`  ! runtime key write failed: ${e.message}`);
+      console.warn(`    Manually set ${stack.envVarName}=${freshRuntimeKey.slice(0, 8)}\u2026 in your CI provider.`);
+    }
+  }
   for (const s of scopes) {
     const envVar = ENV_VAR_BY_SCOPE[s];
     const label = scope === "both" ? `${labelBase}-${s}` : labelBase;
@@ -521,6 +983,27 @@ async function connect(args) {
     mintedTokens.push({ scope: s, token_id: minted.token_id, envVar });
   }
   const readMinted = mintedTokens.some((m) => m.scope === "read");
+  if (readMinted && shouldInstall && stack.runtime) {
+    console.log(`
+\u2022 Installing SDK + injecting init for runtime '${stack.runtime}'\u2026`);
+    try {
+      const inst = installSdk(cwd, stack);
+      if (inst.skipped) console.log(`  \xB7 ${inst.reason}`);
+      else console.log(`  \u2713 ${stack.sdkPackage} installed`);
+    } catch (e) {
+      console.warn(`  ! install failed: ${e.message}`);
+      console.warn(`    Continuing \u2014 set up the SDK manually with: ${stack.packageManager} add ${stack.sdkPackage}`);
+    }
+    if (projectSlug) {
+      const inj = injectInit({ cwd, stack, slug: projectSlug });
+      if (inj.applied) console.log(`  \u2713 init code injected into ${inj.file}`);
+      else console.log(`  \xB7 injection skipped: ${inj.reason}${inj.file ? ` (${inj.file})` : ""}`);
+    }
+  } else if (readMinted && !stack.runtime) {
+    console.log(`
+\u2022 Skipped SDK install \u2014 couldn't detect a known runtime in ${cwd}.`);
+    console.log(`  Manually install the right @fixprompt/* package and call initFixPrompt({...}).`);
+  }
   const deployMinted = mintedTokens.some((m) => m.scope === "deploy");
   console.log("");
   if (deployMinted && provider) {
@@ -547,7 +1030,7 @@ async function connect(args) {
 
 // src/version.ts
 var CLI_NAME = "@fixprompt/cli";
-var CLI_VERSION = "0.5.0";
+var CLI_VERSION = "0.6.0";
 
 // src/cli.ts
 var DEFAULT_ENDPOINT2 = "https://geosloghub-production.up.railway.app";
@@ -587,13 +1070,19 @@ Usage:
 
 connect options:
   --scope <s>                deploy | read | both (default: deploy)
-                             deploy \u2192 mints fpd_\u2026, writes FIXPROMPT_DEPLOY_TOKEN
-                             read   \u2192 mints fpr_\u2026, writes FIXPROMPT_READ_TOKEN
-                                       (lets a customer's coding agent fetch
-                                        production logs from FixLoop directly)
-                             both   \u2192 does both in one pass
+                             \u25B8 For the zero-paste new-project flow, use --scope both.
+                             deploy \u2192 mints fpd_\u2026, writes FIXPROMPT_DEPLOY_TOKEN to CI
+                             read   \u2192 mints fpr_\u2026, writes FIXPROMPT_READ_TOKEN locally,
+                                       installs the SDK, injects initFixPrompt({\u2026})
+                                       into the entry file, drops a CLAUDE.md section
+                             both   \u2192 all of the above in one pass
+  --create                   Auto-create the FixLoop project if --project-slug doesn't
+                             exist (or if no slug given, derived from package.json#name).
+                             Writes the new runtime k_ key into the CI provider env.
+  --no-install               Skip SDK install + init code injection (read scope only).
   --project-id <uuid>        FixLoop project id (or $FIXPROMPT_PROJECT_ID)
   --project-slug <slug>      Look up project_id by slug (no UUID needed)
+  --project-name <text>      Display name for --create (default: package.json#name)
   --admin-token <fpa_\u2026>      Broker admin token (or $FIXPROMPT_ADMIN_TOKEN)
   --provider <name>          eas | vercel | github-actions (auto-detected from cwd)
   --eas-env <env>            EAS env to write to (default: production)
@@ -602,6 +1091,9 @@ connect options:
   --label <text>             Token label (default: <provider>-<timestamp>)
   --force                    Overwrite an existing env var value
 
+Zero-paste flow (in your app repo root):
+  FIXPROMPT_ADMIN_TOKEN=fpa_\u2026 npx @fixprompt/cli connect --scope both --create
+
 deploy-start auth (pick one):
   --deploy-token <fpd_...>  Deploy-only token from dashboard (recommended for CI)
                             (or $FIXPROMPT_DEPLOY_TOKEN env)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fixprompt/cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "FixPrompt CLI — annotate deployments and ship them to the broker so the dashboard knows what changed.",
   "license": "UNLICENSED",
   "repository": {