@01.software/init 0.6.1 → 0.8.0

package/dist/chunk-3RQE6YVO.js

@@ -0,0 +1,821 @@
+#!/usr/bin/env node
+import {
+  fetchTenantContext,
+  generateClaudeMd,
+  getSkillFiles
+} from "./chunk-3MXIG3ZL.js";
+import {
+  chmodSecretFile,
+  readEnvValue,
+  replaceTomlMcpSection,
+  setEnvValue,
+  writeEnvFile,
+  writeSecretGlobalConfig
+} from "./chunk-UA7WNT2F.js";
+import {
+  CODEX_MCP_SECTION_MARKER,
+  getAnalyticsTemplate,
+  getClientTemplate,
+  getCodexMcpTomlSection,
+  getEnvContent,
+  getMcpConfigTemplate,
+  getMcpRootKey,
+  getMcpServerEntry,
+  getQueryProviderTemplate,
+  getServerTemplate
+} from "./chunk-TBGKXE3Q.js";
+
+// 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 prompts from "prompts";
+
+// 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";
+  }
+}
+
+// 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";
+async function init(cwd, info, answers, deps = {}) {
+  const { packageManager, srcDir } = info;
+  const env = answers.env;
+  const baseDir = srcDir ? path2.join(cwd, "src") : cwd;
+  const browserAuth = deps.startBrowserAuth ?? startBrowserAuth;
+  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 = deps.skipInstall ? {
+    installFailed: false,
+    installSkipped: true,
+    installCmd: buildAddCmd(packageManager, hasPnpmWorkspace(cwd), [
+      "@01.software/sdk"
+    ])
+  } : 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
+    );
+    await writeFileWithPolicy(
+      cwd,
+      path2.join(libDir, "analytics.ts"),
+      getAnalyticsTemplate(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 browserAuth();
+      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) {
+    for (const tool of answers.aiTools) {
+      await writeMcpConfig(tool, cwd);
+    }
+    addToGitignore(cwd, answers.aiTools);
+    if (answers.aiTools.includes("claude")) {
+      await writeClaudeDocs(cwd, publishableKey, secretKey, tenantName, plan.policy);
+    }
+  }
+  return {
+    ...installResult,
+    publishableKey: publishableKey || void 0,
+    secretKey: secretKey || void 0,
+    tenantName: tenantName || void 0
+  };
+}
+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 prompts({
+      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 prompts({
+    type: "select",
+    name: "file",
+    message: "Which env file should I write SDK credentials 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 prompts({
+      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);
+    writeEnvFile(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 prompts({
+        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) {
+    writeEnvFile(envPath, content);
+    console.log(
+      pc2.green("  Updated"),
+      envFile,
+      fromBrowserAuth ? pc2.dim("(SDK credentials)") : ""
+    );
+  } else {
+    chmodSecretFile(envPath);
+    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"),
+        jsonClient: "vscode",
+        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,
+        jsonClient: "windsurf",
+        displayPath: p,
+        gitignoreEntry: null,
+        global: true
+      };
+    }
+    case "codex": {
+      if (!home) return null;
+      const p = path2.join(home, ".codex", "config.toml");
+      return { kind: "toml", absolutePath: p, displayPath: p, gitignoreEntry: null, global: true };
+    }
+    case "gemini": {
+      if (!home) return null;
+      const p = path2.join(home, ".gemini", "settings.json");
+      return { kind: "json", absolutePath: p, displayPath: p, gitignoreEntry: null, global: true };
+    }
+  }
+}
+async function writeMcpConfig(tool, cwd) {
+  const loc = resolveMcpLocation(tool, cwd);
+  if (!loc) {
+    console.log(pc2.yellow(`  Skipped ${tool}`), pc2.dim("(HOME not set)"));
+    return;
+  }
+  if (!loc.global) {
+    fs2.mkdirSync(path2.dirname(loc.absolutePath), { recursive: true });
+  }
+  try {
+    if (loc.kind === "json") {
+      writeJsonMcp(loc);
+    } else {
+      writeTomlMcp(loc);
+    }
+  } catch (err) {
+    console.log(
+      pc2.yellow(`  Skipped ${loc.displayPath}`),
+      pc2.dim(err instanceof Error ? err.message : String(err))
+    );
+  }
+}
+function writeJsonMcp(loc) {
+  const writeFile = loc.global ? (target, content) => writeSecretGlobalConfig(target, content) : (target, content) => fs2.writeFileSync(target, content);
+  if (!fs2.existsSync(loc.absolutePath)) {
+    writeFile(loc.absolutePath, getMcpConfigTemplate(loc.jsonClient));
+    console.log(pc2.green("  Created"), loc.displayPath);
+    return;
+  }
+  const rootKey = getMcpRootKey(loc.jsonClient);
+  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 nextEntry = getMcpServerEntry(loc.jsonClient);
+  const existingServers = existing[rootKey] ?? void 0;
+  if (existingServers?.["01software"] && JSON.stringify(existingServers["01software"]) === JSON.stringify(nextEntry)) {
+    console.log(pc2.dim("  Unchanged"), loc.displayPath);
+    return;
+  }
+  const servers = existing[rootKey] ?? {};
+  servers["01software"] = nextEntry;
+  existing[rootKey] = servers;
+  writeFile(loc.absolutePath, JSON.stringify(existing, null, 2) + "\n");
+  console.log(pc2.green("  Updated"), loc.displayPath);
+}
+function writeTomlMcp(loc) {
+  const section = getCodexMcpTomlSection();
+  const writeFile = loc.global ? (target, content) => writeSecretGlobalConfig(target, content) : (target, content) => fs2.writeFileSync(target, content);
+  if (!fs2.existsSync(loc.absolutePath)) {
+    writeFile(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";
+    writeFile(loc.absolutePath, existing + sep + section);
+    console.log(pc2.green("  Updated"), loc.displayPath);
+    return;
+  }
+  const replaced = replaceTomlMcpSection(existing, section);
+  if (replaced === existing) {
+    console.log(pc2.dim("  Unchanged"), loc.displayPath);
+    return;
+  }
+  writeFile(loc.absolutePath, replaced);
+  console.log(pc2.green("  Updated"), loc.displayPath);
+}
+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\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);
+}
+
+export {
+  detectProject,
+  init
+};
+//# sourceMappingURL=chunk-3RQE6YVO.js.map