@01.software/init 0.6.1 → 0.8.0

package/dist/index.js

@@ -1,112 +1,14 @@
 #!/usr/bin/env node
 import {
-  fetchTenantContext,
-  generateClaudeMd,
-  getSkillFiles
-} from "./chunk-SRLZ5OIV.js";
-import {
-  extractTomlApiKey,
-  readEnvValue,
-  replaceTomlMcpSection,
-  setEnvValue
-} from "./chunk-VOEXMD2S.js";
-import {
-  CODEX_MCP_SECTION_MARKER,
-  getClientTemplate,
-  getCodexMcpTomlSection,
-  getEnvContent,
-  getMcpConfigTemplate,
-  getMcpServerEntry,
-  getQueryProviderTemplate,
-  getServerTemplate
-} from "./chunk-OEAQV63E.js";
+  detectProject,
+  init
+} from "./chunk-3RQE6YVO.js";
+import "./chunk-3MXIG3ZL.js";
+import "./chunk-UA7WNT2F.js";
+import "./chunk-TBGKXE3Q.js";
 
 // src/index.ts
-import pc3 from "picocolors";
-
-// src/detect.ts
-import fs from "fs";
-import path from "path";
-function detectProject(cwd) {
-  const pkgPath = path.join(cwd, "package.json");
-  const hasPackageJson = fs.existsSync(pkgPath);
-  let env = "node";
-  let hasSdk = false;
-  let hasReactQuery = false;
-  let parseError = false;
-  if (hasPackageJson) {
-    let pkg;
-    try {
-      pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    } catch {
-      return {
-        hasPackageJson: true,
-        parseError: true,
-        env: "node",
-        packageManager: null,
-        hasSdk: false,
-        hasReactQuery: false,
-        srcDir: false
-      };
-    }
-    const deps = {
-      ...pkg.dependencies || {},
-      ...pkg.devDependencies || {}
-    };
-    hasSdk = "@01.software/sdk" in deps;
-    hasReactQuery = "@tanstack/react-query" in deps;
-    if ("next" in deps) {
-      env = "nextjs";
-    } else if ("astro" in deps || "@astrojs/node" in deps) {
-      env = "other";
-    } else if ("@remix-run/node" in deps || "@remix-run/react" in deps) {
-      env = "other";
-    } else if ("@sveltejs/kit" in deps) {
-      env = "other";
-    } else if ("react" in deps) {
-      if ("vite" in deps) {
-        env = "react-vite";
-      } else if ("react-scripts" in deps) {
-        env = "react-cra";
-      } else {
-        env = "node";
-      }
-    }
-  }
-  let packageManager = null;
-  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
-    packageManager = "pnpm";
-  } else if (fs.existsSync(path.join(cwd, "yarn.lock"))) {
-    packageManager = "yarn";
-  } else if (fs.existsSync(path.join(cwd, "bun.lockb")) || fs.existsSync(path.join(cwd, "bun.lock"))) {
-    packageManager = "bun";
-  } else if (fs.existsSync(path.join(cwd, "package-lock.json"))) {
-    packageManager = "npm";
-  }
-  const srcDir = env === "nextjs" ? fs.existsSync(path.join(cwd, "src", "app")) : fs.existsSync(path.join(cwd, "src"));
-  return { hasPackageJson, parseError, env, packageManager, hasSdk, hasReactQuery, srcDir };
-}
-function needsClient(env) {
-  return env === "nextjs" || env === "react-vite" || env === "react-cra" || env === "vanilla";
-}
-function needsServer(env) {
-  return env === "nextjs" || env === "node" || env === "edge";
-}
-function needsReactQuery(env) {
-  return env === "nextjs" || env === "react-vite" || env === "react-cra";
-}
-function getPublishableKeyEnvVar(env) {
-  switch (env) {
-    case "nextjs":
-      return "NEXT_PUBLIC_SOFTWARE_PUBLISHABLE_KEY";
-    case "react-vite":
-      return "VITE_SOFTWARE_PUBLISHABLE_KEY";
-    case "react-cra":
-      return "REACT_APP_SOFTWARE_PUBLISHABLE_KEY";
-    default:
-      return "SOFTWARE_PUBLISHABLE_KEY";
-  }
-}
+import pc from "picocolors";
 
 // src/prompts.ts
 import prompts from "prompts";
@@ -240,7 +142,7 @@ async function promptUser(hasSdk, detectedEnv, detectedPm) {
       {
         type: "select",
         name: "method",
-        message: "API keys:",
+        message: "SDK credentials:",
         choices: [
           { title: "Browser login (recommended)", value: "browser" },
           { title: "Enter manually", value: "manual" },
@@ -269,703 +171,6 @@ async function promptUser(hasSdk, detectedEnv, detectedPm) {
   };
 }
 
-// src/init.ts
-import fs2 from "fs";
-import path2 from "path";
-import os from "os";
-import { execSync } from "child_process";
-import pc2 from "picocolors";
-import prompts2 from "prompts";
-
-// src/browser-auth.ts
-import { randomBytes } from "crypto";
-import { createServer } from "http";
-import { execFile, exec } from "child_process";
-import { platform } from "os";
-import { URL } from "url";
-import pc from "picocolors";
-var DEFAULT_WEB_URL = process.env.SOFTWARE_WEB_URL || "https://01.software";
-var TIMEOUT_MS = 5 * 60 * 1e3;
-function escapeHtml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function openBrowser(url) {
-  const os2 = platform();
-  const onError = () => {
-    console.log(
-      pc.yellow(
-        `Could not open browser automatically. Open this URL manually:
-${url}`
-      )
-    );
-  };
-  if (os2 === "win32") {
-    exec(`start "" "${url}"`, (err) => {
-      if (err) onError();
-    });
-  } else {
-    const cmd = os2 === "darwin" ? "open" : "xdg-open";
-    execFile(cmd, [url], (err) => {
-      if (err) onError();
-    });
-  }
-}
-var PAGE_STYLE = `*{margin:0;box-sizing:border-box}
-body{font-family:system-ui,-apple-system,sans-serif;display:flex;justify-content:center;align-items:center;min-height:100vh;background:#fff;color:#252525}
-@media(prefers-color-scheme:dark){body{background:#252525;color:#f5f5f5}}
-.card{text-align:center;padding:2rem 2.5rem;border-radius:10px;max-width:380px;width:100%}
-.icon{width:40px;height:40px;margin:0 auto 1rem;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:1.25rem}
-.icon.ok{background:rgba(0,0,0,.05);color:#252525}
-.icon.err{background:rgba(220,38,38,.08);color:#dc2626}
-@media(prefers-color-scheme:dark){.icon.ok{background:rgba(255,255,255,.08);color:#f5f5f5}}
-h1{font-size:.875rem;font-weight:600;margin-bottom:.375rem}
-p{font-size:.75rem;color:#737373;line-height:1.5}`;
-var SUCCESS_HTML = `<!DOCTYPE html>
-<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>Login</title>
-<style>${PAGE_STYLE}</style>
-</head><body><div class="card"><div class="icon ok">\u2713</div><h1>Authenticated</h1><p>You can close this tab and return to the terminal.</p></div></body></html>`;
-var ERROR_HTML = (msg) => `<!DOCTYPE html>
-<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>Login Error</title>
-<style>${PAGE_STYLE}</style>
-</head><body><div class="card"><div class="icon err">!</div><h1>Authentication failed</h1><p>${escapeHtml(msg)}</p></div></body></html>`;
-async function exchangeCode(webUrl, code) {
-  const url = `${webUrl}/api/cli/exchange`;
-  try {
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ code })
-    });
-    if (!res.ok) {
-      const body = await res.text().catch(() => "");
-      console.error(
-        pc.red(
-          `Exchange failed: HTTP ${res.status} from ${url}${body ? ` \u2014 ${body.slice(0, 200)}` : ""}`
-        )
-      );
-      return null;
-    }
-    const data = await res.json();
-    if (typeof data.publishableKey !== "string" || typeof data.secretKey !== "string" || typeof data.tenantName !== "string" || typeof data.tenantId !== "string") {
-      console.error(pc.red(`Exchange failed: malformed response from ${url}`));
-      return null;
-    }
-    return {
-      publishableKey: data.publishableKey,
-      secretKey: data.secretKey,
-      tenantName: data.tenantName,
-      tenantId: data.tenantId
-    };
-  } catch (err) {
-    console.error(
-      pc.red(
-        `Exchange request to ${url} failed: ${err instanceof Error ? err.message : String(err)}`
-      )
-    );
-    return null;
-  }
-}
-async function startBrowserAuth(options) {
-  const state = randomBytes(32).toString("hex");
-  const webUrl = options?.webUrl ?? DEFAULT_WEB_URL;
-  return new Promise((resolve, reject) => {
-    const server = createServer((req, res) => {
-      if (!req.url) {
-        res.writeHead(400).end();
-        return;
-      }
-      const url = new URL(req.url, `http://localhost`);
-      if (url.pathname !== "/callback" || req.method !== "GET") {
-        res.writeHead(404).end();
-        return;
-      }
-      const error = url.searchParams.get("error");
-      if (error) {
-        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", Connection: "close" }).end(ERROR_HTML(error));
-        console.error(pc.red(`Login failed: ${error}`));
-        cleanup(new Error(`Login failed: ${error}`));
-        return;
-      }
-      const code = url.searchParams.get("code");
-      const receivedState = url.searchParams.get("state");
-      if (!code || !receivedState) {
-        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8", Connection: "close" }).end(ERROR_HTML("Missing code or state."));
-        cleanup(new Error("Login failed: missing code or state."));
-        return;
-      }
-      if (receivedState !== state) {
-        res.writeHead(403, { "Content-Type": "text/html; charset=utf-8", Connection: "close" }).end(ERROR_HTML("State mismatch."));
-        console.error(pc.red("Login failed: state mismatch."));
-        cleanup(new Error("Login failed: state mismatch."));
-        return;
-      }
-      exchangeCode(webUrl, code).then((creds) => {
-        if (!creds) {
-          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8", Connection: "close" }).end(ERROR_HTML("Invalid or expired code."));
-          cleanup(new Error("Login failed: code exchange failed."));
-          return;
-        }
-        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", Connection: "close" }).end(SUCCESS_HTML);
-        console.log(pc.green(`
-Logged in successfully!`));
-        console.log(pc.dim(`Tenant: ${creds.tenantName}`));
-        cleanup(null, creds);
-      });
-    });
-    let timeout;
-    let completed = false;
-    function cleanup(err, result) {
-      if (completed) return;
-      completed = true;
-      clearTimeout(timeout);
-      server.closeAllConnections?.();
-      server.close(() => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(result);
-        }
-      });
-    }
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      if (!addr || typeof addr === "string") {
-        reject(new Error("Failed to start local server."));
-        return;
-      }
-      const port = addr.port;
-      timeout = setTimeout(() => {
-        console.error(pc.red("\nLogin timed out (5 minutes). Please try again."));
-        cleanup(new Error("Login timed out"));
-      }, TIMEOUT_MS);
-      const params = new URLSearchParams({ port: String(port), state });
-      if (options?.tenantId) {
-        params.set("tenantId", options.tenantId);
-      }
-      const loginUrl = `${webUrl}/cli-auth?${params.toString()}`;
-      console.log(pc.dim("Opening browser for login..."));
-      console.log(pc.dim(`If the browser does not open, visit:
-${loginUrl}`));
-      openBrowser(loginUrl);
-    });
-    server.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-
-// src/init.ts
-var SECRET_KEY_ENV_VAR = "SOFTWARE_SECRET_KEY";
-var API_KEY_PLACEHOLDER = "YOUR_API_KEY";
-async function init(cwd, info, answers) {
-  const { packageManager, srcDir } = info;
-  const env = answers.env;
-  const baseDir = srcDir ? path2.join(cwd, "src") : cwd;
-  const publishableKeyEnvVar = getPublishableKeyEnvVar(env);
-  const wantsClient = needsClient(env);
-  const wantsServer = needsServer(env);
-  const wantsReactQuery = needsReactQuery(env);
-  const plan = await planConflictsAndEnv(cwd, baseDir, env, answers);
-  const installResult = installDeps(
-    cwd,
-    packageManager,
-    info.hasSdk,
-    info.hasReactQuery,
-    wantsReactQuery
-  );
-  if (wantsClient || wantsReactQuery || wantsServer) {
-    fs2.mkdirSync(path2.join(baseDir, "lib", "software"), { recursive: true });
-  }
-  const libDir = path2.join(baseDir, "lib", "software");
-  if (wantsClient) {
-    await writeFileWithPolicy(
-      cwd,
-      path2.join(libDir, "client.ts"),
-      getClientTemplate(env, publishableKeyEnvVar),
-      plan.policy
-    );
-  }
-  if (wantsReactQuery) {
-    await writeFileWithPolicy(
-      cwd,
-      path2.join(libDir, "query-provider.tsx"),
-      getQueryProviderTemplate(env),
-      plan.policy
-    );
-  }
-  if (wantsServer) {
-    await writeFileWithPolicy(
-      cwd,
-      path2.join(libDir, "server.ts"),
-      getServerTemplate(env, publishableKeyEnvVar, SECRET_KEY_ENV_VAR),
-      plan.policy
-    );
-  }
-  if (plan.envFile && answers.authMethod !== "browser") {
-    await writeEnv(
-      cwd,
-      plan.envFile,
-      answers.publishableKey || "",
-      answers.secretKey || "",
-      publishableKeyEnvVar,
-      wantsServer ? SECRET_KEY_ENV_VAR : null,
-      plan.policy
-    );
-  }
-  let publishableKey = answers.publishableKey;
-  let secretKey = answers.secretKey;
-  let tenantName = "";
-  if (answers.authMethod === "browser" && answers.aiTools.length > 0) {
-    try {
-      console.log();
-      const creds = await startBrowserAuth();
-      publishableKey = creds.publishableKey;
-      secretKey = creds.secretKey;
-      tenantName = creds.tenantName;
-      if (plan.envFile && publishableKey) {
-        await writeEnv(
-          cwd,
-          plan.envFile,
-          publishableKey,
-          secretKey,
-          publishableKeyEnvVar,
-          wantsServer ? SECRET_KEY_ENV_VAR : null,
-          "overwrite",
-          true
-        );
-      }
-    } catch (err) {
-      console.log(
-        pc2.yellow("  Browser auth skipped:"),
-        err instanceof Error ? err.message : String(err)
-      );
-    }
-  }
-  if (answers.aiTools.length > 0) {
-    const apiKey = secretKey || API_KEY_PLACEHOLDER;
-    for (const tool of answers.aiTools) {
-      await writeMcpConfig(tool, cwd, apiKey, plan.policy);
-    }
-    addToGitignore(cwd, answers.aiTools);
-    if (answers.aiTools.includes("claude")) {
-      await writeClaudeDocs(cwd, publishableKey, secretKey, tenantName, plan.policy);
-    }
-  }
-  return installResult;
-}
-function installDeps(cwd, pm, hasSdk, hasReactQuery, wantsReactQuery) {
-  const allDeps = [
-    { name: "@01.software/sdk", installed: hasSdk, needed: true },
-    { name: "@tanstack/react-query", installed: hasReactQuery, needed: wantsReactQuery }
-  ];
-  const fullList = allDeps.filter((d) => d.needed).map((d) => d.name);
-  const toInstall = allDeps.filter((d) => d.needed && !d.installed).map((d) => d.name);
-  const fullCmd = buildAddCmd(pm, hasPnpmWorkspace(cwd), fullList);
-  if (toInstall.length === 0) {
-    console.log(pc2.dim(`  Dependencies already installed: ${fullList.join(", ")}`));
-    return { installFailed: false, installSkipped: true, installCmd: fullCmd };
-  }
-  const addCmd = buildAddCmd(pm, hasPnpmWorkspace(cwd), toInstall);
-  console.log(pc2.dim(`  Installing ${toInstall.join(" and ")}...`));
-  const wsPatched = pm === "pnpm" && patchPnpmWorkspace(cwd);
-  let installFailed = false;
-  try {
-    execSync(addCmd, { cwd, stdio: "pipe" });
-    console.log(pc2.green("  Installed"), toInstall.join(", "));
-  } catch (error) {
-    installFailed = true;
-    const err = error;
-    const msg = String(err.stderr || "").trim() || String(err.stdout || "").trim() || String(error);
-    console.log(pc2.yellow("  Install failed \u2014 continuing with scaffolding"));
-    const firstLines = msg.split("\n").slice(0, 3).map((l) => `    ${l}`).join("\n");
-    if (firstLines) console.log(pc2.dim(firstLines));
-    console.log(pc2.dim(`    Run manually: ${addCmd}`));
-  } finally {
-    if (wsPatched) restorePnpmWorkspace(cwd);
-  }
-  return { installFailed, installSkipped: false, installCmd: addCmd };
-}
-function buildAddCmd(pm, hasPnpmWs, deps) {
-  const pkgs = deps.join(" ");
-  switch (pm) {
-    case "pnpm":
-      return hasPnpmWs ? `pnpm add -w ${pkgs}` : `pnpm add ${pkgs}`;
-    case "yarn":
-      return `yarn add ${pkgs}`;
-    case "bun":
-      return `bun add ${pkgs}`;
-    default:
-      return `npm install ${pkgs}`;
-  }
-}
-async function planConflictsAndEnv(cwd, baseDir, env, answers) {
-  const candidates = [];
-  const libDir = path2.join(baseDir, "lib", "software");
-  if (needsClient(env)) candidates.push(path2.join(libDir, "client.ts"));
-  if (needsReactQuery(env)) candidates.push(path2.join(libDir, "query-provider.tsx"));
-  if (needsServer(env)) candidates.push(path2.join(libDir, "server.ts"));
-  if (answers.aiTools.includes("claude")) {
-    for (const { dirName } of getSkillFiles()) {
-      candidates.push(path2.join(cwd, ".claude", "skills", dirName, "SKILL.md"));
-    }
-  }
-  const conflicts = candidates.filter((p) => fs2.existsSync(p));
-  let policy = "skip";
-  if (conflicts.length > 0) {
-    console.log(pc2.yellow(`  ${conflicts.length} file(s) already exist:`));
-    for (const c of conflicts) console.log(pc2.dim(`    ${path2.relative(cwd, c)}`));
-    const { selected } = await prompts2({
-      type: "select",
-      name: "selected",
-      message: "How should I handle existing files?",
-      choices: [
-        { title: "Keep existing (skip)", value: "skip" },
-        { title: "Overwrite all", value: "overwrite" },
-        { title: "Ask for each", value: "ask" }
-      ],
-      initial: 0
-    });
-    policy = selected ?? "skip";
-  }
-  const envFile = env === "vanilla" || env === "edge" ? "" : await pickEnvFile(cwd, env);
-  return { policy, envFile };
-}
-async function pickEnvFile(cwd, env) {
-  const candidates = [".env.local", ".env", ".env.development"];
-  const existing = candidates.filter((f) => fs2.existsSync(path2.join(cwd, f)));
-  const preferred = env === "nextjs" ? ".env.local" : ".env";
-  if (existing.length === 0) return preferred;
-  if (existing.length === 1 && existing[0] === preferred) return existing[0];
-  const options = Array.from(/* @__PURE__ */ new Set([...existing, preferred]));
-  const choices = options.map((f) => ({
-    title: f,
-    description: existing.includes(f) ? "exists" : "create",
-    value: f
-  }));
-  const initial = Math.max(
-    0,
-    choices.findIndex((c) => c.value === preferred)
-  );
-  const { file } = await prompts2({
-    type: "select",
-    name: "file",
-    message: "Which env file should I write API keys to?",
-    choices,
-    initial
-  });
-  return file ?? preferred;
-}
-async function writeFileWithPolicy(cwd, filePath, content, policy) {
-  const rel = path2.relative(cwd, filePath);
-  if (!fs2.existsSync(filePath)) {
-    fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
-    fs2.writeFileSync(filePath, content);
-    console.log(pc2.green("  Created"), rel);
-    return;
-  }
-  const existing = fs2.readFileSync(filePath, "utf-8");
-  if (existing === content) {
-    console.log(pc2.dim("  Unchanged"), rel);
-    return;
-  }
-  let shouldWrite = false;
-  if (policy === "overwrite") {
-    shouldWrite = true;
-  } else if (policy === "ask") {
-    const { confirm } = await prompts2({
-      type: "confirm",
-      name: "confirm",
-      message: `Overwrite ${rel}?`,
-      initial: false
-    });
-    shouldWrite = !!confirm;
-  }
-  if (shouldWrite) {
-    fs2.writeFileSync(filePath, content);
-    console.log(pc2.green("  Overwrote"), rel);
-  } else {
-    console.log(pc2.yellow("  Skipped"), rel, pc2.dim("(already exists)"));
-  }
-}
-async function writeEnv(cwd, envFile, publishableKey, secretKey, publishableKeyEnvVar, secretKeyEnvVar, policy, fromBrowserAuth = false) {
-  const envPath = path2.join(cwd, envFile);
-  const targets = [
-    { name: publishableKeyEnvVar, value: publishableKey }
-  ];
-  if (secretKeyEnvVar) {
-    targets.push({ name: secretKeyEnvVar, value: secretKey });
-  }
-  if (!fs2.existsSync(envPath)) {
-    const initial = getEnvContent(publishableKey, secretKey, publishableKeyEnvVar, secretKeyEnvVar);
-    fs2.writeFileSync(envPath, initial.trimStart());
-    console.log(pc2.green("  Created"), envFile);
-    return;
-  }
-  let content = fs2.readFileSync(envPath, "utf-8");
-  let modified = false;
-  let appendedHeader = false;
-  const headerAlreadyPresent = targets.some(
-    (t) => readEnvValue(content, t.name) !== null
-  );
-  for (const { name, value } of targets) {
-    const existing = readEnvValue(content, name);
-    if (existing === null) {
-      if (!headerAlreadyPresent && !appendedHeader) {
-        if (content.length > 0 && !content.endsWith("\n")) content += "\n";
-        content += "\n# 01.software\n";
-        appendedHeader = true;
-      }
-      content = setEnvValue(content, name, value);
-      modified = true;
-      continue;
-    }
-    if (existing === value) continue;
-    if (!value) continue;
-    let shouldOverwrite = false;
-    if (policy === "overwrite") {
-      shouldOverwrite = true;
-    } else if (policy === "ask") {
-      const { confirm } = await prompts2({
-        type: "confirm",
-        name: "confirm",
-        message: `${name} already set in ${envFile}. Overwrite?`,
-        initial: fromBrowserAuth
-      });
-      shouldOverwrite = !!confirm;
-    }
-    if (shouldOverwrite) {
-      content = setEnvValue(content, name, value);
-      modified = true;
-    }
-  }
-  if (modified) {
-    fs2.writeFileSync(envPath, content);
-    console.log(
-      pc2.green("  Updated"),
-      envFile,
-      fromBrowserAuth ? pc2.dim("(API keys)") : ""
-    );
-  } else {
-    console.log(pc2.dim("  Unchanged"), envFile);
-  }
-}
-function resolveMcpLocation(tool, cwd) {
-  const home = os.homedir();
-  switch (tool) {
-    case "claude":
-      return {
-        kind: "json",
-        absolutePath: path2.join(cwd, ".mcp.json"),
-        displayPath: ".mcp.json",
-        gitignoreEntry: ".mcp.json"
-      };
-    case "cursor":
-      return {
-        kind: "json",
-        absolutePath: path2.join(cwd, ".cursor", "mcp.json"),
-        displayPath: ".cursor/mcp.json",
-        gitignoreEntry: ".cursor/mcp.json"
-      };
-    case "vscode":
-      return {
-        kind: "json",
-        absolutePath: path2.join(cwd, ".vscode", "mcp.json"),
-        displayPath: ".vscode/mcp.json",
-        gitignoreEntry: ".vscode/mcp.json"
-      };
-    case "windsurf": {
-      if (!home) return null;
-      const p = path2.join(home, ".codeium", "windsurf", "mcp_config.json");
-      return { kind: "json", absolutePath: p, displayPath: p, gitignoreEntry: null };
-    }
-    case "codex": {
-      if (!home) return null;
-      const p = path2.join(home, ".codex", "config.toml");
-      return { kind: "toml", absolutePath: p, displayPath: p, gitignoreEntry: null };
-    }
-    case "gemini": {
-      if (!home) return null;
-      const p = path2.join(home, ".gemini", "settings.json");
-      return { kind: "json", absolutePath: p, displayPath: p, gitignoreEntry: null };
-    }
-  }
-}
-async function writeMcpConfig(tool, cwd, apiKey, policy) {
-  const loc = resolveMcpLocation(tool, cwd);
-  if (!loc) {
-    console.log(pc2.yellow(`  Skipped ${tool}`), pc2.dim("(HOME not set)"));
-    return;
-  }
-  fs2.mkdirSync(path2.dirname(loc.absolutePath), { recursive: true });
-  if (loc.kind === "json") {
-    await writeJsonMcp(loc, apiKey, policy);
-  } else {
-    await writeTomlMcp(loc, apiKey, policy);
-  }
-}
-async function writeJsonMcp(loc, apiKey, policy) {
-  if (!fs2.existsSync(loc.absolutePath)) {
-    fs2.writeFileSync(loc.absolutePath, getMcpConfigTemplate(apiKey));
-    console.log(pc2.green("  Created"), loc.displayPath);
-    return;
-  }
-  let existing;
-  try {
-    existing = JSON.parse(fs2.readFileSync(loc.absolutePath, "utf-8"));
-  } catch {
-    console.log(pc2.yellow("  Skipped"), loc.displayPath, pc2.dim("(could not parse existing file)"));
-    return;
-  }
-  const existingApiKey = existing.mcpServers?.["01software"]?.headers?.["x-api-key"];
-  if (existingApiKey === apiKey) {
-    console.log(pc2.dim("  Unchanged"), loc.displayPath);
-    return;
-  }
-  if (apiKey === API_KEY_PLACEHOLDER && existingApiKey && existingApiKey !== API_KEY_PLACEHOLDER) {
-    console.log(pc2.dim("  Kept existing API key in"), loc.displayPath);
-    return;
-  }
-  if (existingApiKey) {
-    const shouldUpdate = await confirmKeyUpdate(loc.displayPath, policy);
-    if (!shouldUpdate) {
-      console.log(pc2.yellow("  Skipped"), loc.displayPath, pc2.dim("(kept existing API key)"));
-      return;
-    }
-  }
-  existing.mcpServers = existing.mcpServers || {};
-  existing.mcpServers["01software"] = getMcpServerEntry(apiKey);
-  fs2.writeFileSync(loc.absolutePath, JSON.stringify(existing, null, 2) + "\n");
-  console.log(pc2.green("  Updated"), loc.displayPath);
-}
-async function writeTomlMcp(loc, apiKey, policy) {
-  const section = getCodexMcpTomlSection(apiKey);
-  if (!fs2.existsSync(loc.absolutePath)) {
-    fs2.writeFileSync(loc.absolutePath, section.trimStart());
-    console.log(pc2.green("  Created"), loc.displayPath);
-    return;
-  }
-  const existing = fs2.readFileSync(loc.absolutePath, "utf-8");
-  if (!existing.includes(CODEX_MCP_SECTION_MARKER)) {
-    const sep = existing.endsWith("\n") ? "" : "\n";
-    fs2.appendFileSync(loc.absolutePath, sep + section);
-    console.log(pc2.green("  Updated"), loc.displayPath);
-    return;
-  }
-  const existingApiKey = extractTomlApiKey(existing);
-  if (existingApiKey === apiKey) {
-    console.log(pc2.dim("  Unchanged"), loc.displayPath);
-    return;
-  }
-  if (apiKey === API_KEY_PLACEHOLDER && existingApiKey && existingApiKey !== API_KEY_PLACEHOLDER) {
-    console.log(pc2.dim("  Kept existing API key in"), loc.displayPath);
-    return;
-  }
-  const shouldUpdate = await confirmKeyUpdate(loc.displayPath, policy);
-  if (!shouldUpdate) {
-    console.log(pc2.yellow("  Skipped"), loc.displayPath, pc2.dim("(kept existing API key)"));
-    return;
-  }
-  const replaced = replaceTomlMcpSection(existing, section);
-  fs2.writeFileSync(loc.absolutePath, replaced);
-  console.log(pc2.green("  Updated"), loc.displayPath);
-}
-async function confirmKeyUpdate(displayPath, policy) {
-  if (policy === "overwrite") return true;
-  const { confirm } = await prompts2({
-    type: "confirm",
-    name: "confirm",
-    message: `${displayPath} has a different 01software API key. Update?`,
-    initial: true
-  });
-  return !!confirm;
-}
-function addToGitignore(cwd, tools) {
-  const entries = [];
-  for (const tool of tools) {
-    const loc = resolveMcpLocation(tool, cwd);
-    if (loc?.gitignoreEntry) entries.push(loc.gitignoreEntry);
-  }
-  if (entries.length === 0) return;
-  const gitignorePath = path2.join(cwd, ".gitignore");
-  const existing = fs2.existsSync(gitignorePath) ? fs2.readFileSync(gitignorePath, "utf-8") : "";
-  const toAdd = entries.filter((e) => !existing.includes(e));
-  if (toAdd.length === 0) return;
-  const content = "\n# MCP configs (contain API key)\n" + toAdd.join("\n") + "\n";
-  if (fs2.existsSync(gitignorePath)) {
-    fs2.appendFileSync(gitignorePath, content);
-  } else {
-    fs2.writeFileSync(gitignorePath, content.trimStart());
-  }
-  console.log(pc2.green("  Updated"), ".gitignore", pc2.dim(`(added ${toAdd.join(", ")})`));
-}
-async function writeClaudeDocs(cwd, publishableKey, secretKey, tenantName, policy) {
-  let ctx = {
-    tenantName: tenantName || "Your Tenant",
-    features: void 0,
-    collections: void 0
-  };
-  if (publishableKey && secretKey) {
-    const fetched = await fetchTenantContext(publishableKey, secretKey);
-    if (fetched) {
-      ctx = {
-        tenantName: fetched.tenantName || ctx.tenantName,
-        features: fetched.features,
-        collections: fetched.collections
-      };
-    }
-  }
-  const claudeDir = path2.join(cwd, ".claude");
-  const softwareDir = path2.join(claudeDir, "01software");
-  const skillsDir = path2.join(claudeDir, "skills");
-  fs2.mkdirSync(softwareDir, { recursive: true });
-  fs2.mkdirSync(skillsDir, { recursive: true });
-  const contextPath = path2.join(softwareDir, "context.md");
-  const contextExists = fs2.existsSync(contextPath);
-  fs2.writeFileSync(contextPath, generateClaudeMd(ctx));
-  console.log(pc2.green(contextExists ? "  Updated" : "  Created"), ".claude/01software/context.md");
-  const claudeMdPath = path2.join(claudeDir, "CLAUDE.md");
-  const importLine = "@.claude/01software/context.md";
-  if (!fs2.existsSync(claudeMdPath)) {
-    fs2.writeFileSync(claudeMdPath, importLine + "\n");
-    console.log(pc2.green("  Created"), ".claude/CLAUDE.md");
-  } else {
-    const existing = fs2.readFileSync(claudeMdPath, "utf-8");
-    if (!existing.includes(importLine)) {
-      const prefix = existing.endsWith("\n") ? "\n" : "\n\n";
-      fs2.appendFileSync(claudeMdPath, prefix + importLine + "\n");
-      console.log(pc2.green("  Updated"), ".claude/CLAUDE.md", pc2.dim("(added @import)"));
-    } else {
-      console.log(pc2.dim("  Unchanged"), ".claude/CLAUDE.md");
-    }
-  }
-  for (const { dirName, content } of getSkillFiles()) {
-    const skillDir = path2.join(skillsDir, dirName);
-    const skillPath = path2.join(skillDir, "SKILL.md");
-    fs2.mkdirSync(skillDir, { recursive: true });
-    await writeFileWithPolicy(cwd, skillPath, content, policy);
-  }
-}
-var WS_FILE = "pnpm-workspace.yaml";
-var WS_BACKUP = "pnpm-workspace.yaml.bak";
-function hasPnpmWorkspace(cwd) {
-  return fs2.existsSync(path2.join(cwd, WS_FILE));
-}
-function patchPnpmWorkspace(cwd) {
-  const wsPath = path2.join(cwd, WS_FILE);
-  if (!fs2.existsSync(wsPath)) return false;
-  const content = fs2.readFileSync(wsPath, "utf-8");
-  if (content.includes("packages:")) return false;
-  fs2.copyFileSync(wsPath, path2.join(cwd, WS_BACKUP));
-  fs2.writeFileSync(wsPath, content.trimEnd() + "\npackages: []\n");
-  return true;
-}
-function restorePnpmWorkspace(cwd) {
-  const backupPath = path2.join(cwd, WS_BACKUP);
-  if (!fs2.existsSync(backupPath)) return;
-  fs2.copyFileSync(backupPath, path2.join(cwd, WS_FILE));
-  fs2.unlinkSync(backupPath);
-}
-
 // src/index.ts
 var ENV_LABELS = {
   nextjs: "Next.js",
@@ -999,17 +204,17 @@ var OTHER_FRAMEWORK_GUIDE = `
 async function main() {
   const cwd = process.cwd();
   console.log();
-  console.log(pc3.bold("  @01.software/init"));
-  console.log(pc3.dim("  Initialize 01.software SDK in your project"));
+  console.log(pc.bold("  @01.software/init"));
+  console.log(pc.dim("  Initialize 01.software SDK in your project"));
   console.log();
   const info = detectProject(cwd);
   if (!info.hasPackageJson || info.parseError) {
     if (info.parseError) {
-      console.log(pc3.red("  Could not parse package.json (invalid JSON)."));
-      console.log(pc3.dim("  Fix the syntax error and try again."));
+      console.log(pc.red("  Could not parse package.json (invalid JSON)."));
+      console.log(pc.dim("  Fix the syntax error and try again."));
     } else {
-      console.log(pc3.red("  No package.json found in the current directory."));
-      console.log(pc3.dim("  Run this command inside an existing project."));
+      console.log(pc.red("  No package.json found in the current directory."));
+      console.log(pc.dim("  Run this command inside an existing project."));
     }
     console.log();
     process.exit(1);
@@ -1018,17 +223,17 @@ async function main() {
   if (info.packageManager) detectedParts.push(info.packageManager);
   if (info.srcDir) detectedParts.push("src/");
   if (info.env !== "node") {
-    console.log(pc3.dim(`  Detected: ${detectedParts.join(" / ")}`));
+    console.log(pc.dim(`  Detected: ${detectedParts.join(" / ")}`));
     console.log();
   }
   try {
     const answers = await promptUser(info.hasSdk, info.env, info.packageManager);
     if (!answers) {
-      console.log(pc3.yellow("  Cancelled."));
+      console.log(pc.yellow("  Cancelled."));
       process.exit(0);
     }
     if (answers.env === "other") {
-      console.log(pc3.yellow("  Manual setup required for your framework:"));
+      console.log(pc.yellow("  Manual setup required for your framework:"));
       console.log(OTHER_FRAMEWORK_GUIDE);
       process.exit(0);
     }
@@ -1039,70 +244,80 @@ async function main() {
     const env = answers.env;
     const run = resolvedPm === "npm" ? "npm run" : resolvedPm;
     console.log();
-    console.log(pc3.green("  Done!"));
+    console.log(pc.green("  Done!"));
     console.log();
     console.log("  Next steps:");
     console.log();
     if (result.installFailed) {
-      console.log(pc3.yellow("  Install the SDK manually:"));
-      console.log(pc3.cyan(`    ${result.installCmd}`));
+      console.log(pc.yellow("  Install the SDK manually:"));
+      console.log(pc.cyan(`    ${result.installCmd}`));
       console.log();
     }
     if (env === "nextjs") {
-      console.log(pc3.dim("  Add QueryProvider to your root layout:"));
+      console.log(pc.dim("  Add QueryProvider to your root layout:"));
+      console.log();
+      console.log(pc.cyan("    import { QueryProvider } from '@/lib/software/query-provider'"));
+      console.log(pc.cyan("    <QueryProvider>{children}</QueryProvider>"));
       console.log();
-      console.log(pc3.cyan("    import { QueryProvider } from '@/lib/software/query-provider'"));
-      console.log(pc3.cyan("    <QueryProvider>{children}</QueryProvider>"));
+      console.log(pc.dim("  Optional: start browser analytics with the generated helper:"));
+      console.log();
+      console.log(pc.cyan("    import { analytics } from '@/lib/software/analytics'"));
+      console.log(pc.cyan("    analytics.track('signup')"));
       console.log();
     } else if (env === "react-vite" || env === "react-cra") {
-      console.log(pc3.dim("  Wrap your app entry with QueryProvider:"));
+      console.log(pc.dim("  Wrap your app entry with QueryProvider:"));
+      console.log();
+      console.log(pc.cyan("    import { QueryProvider } from './lib/software/query-provider'"));
+      console.log(pc.cyan("    <QueryProvider><App /></QueryProvider>"));
       console.log();
-      console.log(pc3.cyan("    import { QueryProvider } from './lib/software/query-provider'"));
-      console.log(pc3.cyan("    <QueryProvider><App /></QueryProvider>"));
+      console.log(pc.dim("  Optional: start browser analytics with the generated helper:"));
+      console.log();
+      console.log(pc.cyan("    import { analytics } from './lib/software/analytics'"));
+      console.log(pc.cyan("    analytics.track('signup')"));
       console.log();
     } else if (env === "vanilla") {
-      console.log(pc3.dim("  Replace YOUR_PUBLISHABLE_KEY in lib/software/client.ts"));
+      console.log(pc.dim("  Replace YOUR_PUBLISHABLE_KEY in lib/software/client.ts"));
+      console.log();
+      console.log(pc.cyan("    import { client } from './lib/software/client'"));
+      console.log(pc.cyan("    const articles = await client.collections.from('articles').find()"));
       console.log();
-      console.log(pc3.cyan("    import { client } from './lib/software/client'"));
-      console.log(pc3.cyan("    const posts = await client.from('posts').find()"));
+      console.log(pc.dim("  Optional: wire the analytics helper in lib/software/analytics.ts"));
       console.log();
     } else if (env === "node") {
-      console.log(pc3.dim("  Use the server client:"));
+      console.log(pc.dim("  Use the server client:"));
       console.log();
-      console.log(pc3.cyan("    import { serverClient } from './lib/software/server'"));
-      console.log(pc3.cyan("    const posts = await serverClient.from('posts').find()"));
+      console.log(pc.cyan("    import { serverClient } from './lib/software/server'"));
+      console.log(pc.cyan("    const articles = await serverClient.collections.from('articles').find()"));
       console.log();
     } else if (env === "edge") {
-      console.log(pc3.dim("  Pass your env bindings to createEdgeClient():"));
+      console.log(pc.dim("  Pass your env bindings to createEdgeClient():"));
       console.log();
-      console.log(pc3.cyan("    import { createEdgeClient } from './lib/software/server'"));
-      console.log(pc3.cyan("    const serverClient = createEdgeClient(env.PUBLISHABLE_KEY, env.SECRET_KEY)"));
+      console.log(pc.cyan("    import { createEdgeClient } from './lib/software/server'"));
+      console.log(pc.cyan("    const serverClient = createEdgeClient(env.PUBLISHABLE_KEY, env.SECRET_KEY)"));
       console.log();
     }
-    const missingPublishableKey = env !== "vanilla" && !answers.publishableKey;
-    const missingSecretKey = (env === "nextjs" || env === "node") && !answers.secretKey;
+    const effectivePublishableKey = result.publishableKey ?? answers.publishableKey;
+    const effectiveSecretKey = result.secretKey ?? answers.secretKey;
+    const missingPublishableKey = env !== "vanilla" && !effectivePublishableKey;
+    const missingSecretKey = (env === "nextjs" || env === "node") && !effectiveSecretKey;
     if (missingPublishableKey || missingSecretKey) {
-      console.log(pc3.dim("  Update .env with your API keys"));
+      console.log(pc.dim("  Update .env with your SDK credentials"));
       console.log();
     }
-    if (answers.aiTools.length > 0 && (!answers.publishableKey || !answers.secretKey)) {
-      console.log(
-        pc3.dim(
-          "  Update MCP config x-api-key with your sk01_... or pat01_... bearer token"
-        )
-      );
+    if (answers.aiTools.length > 0) {
+      console.log(pc.dim("  MCP config uses OAuth discovery."));
       console.log();
     }
     if (env !== "vanilla") {
-      console.log(pc3.cyan(`    ${run} dev`));
+      console.log(pc.cyan(`    ${run} dev`));
       console.log();
     }
   } catch (error) {
     if (error instanceof Error && error.message === "cancelled") {
-      console.log(pc3.yellow("  Cancelled."));
+      console.log(pc.yellow("  Cancelled."));
       process.exit(0);
     }
-    console.error(pc3.red("  Error:"), error);
+    console.error(pc.red("  Error:"), error);
     process.exit(1);
   }
 }