@intelli-1113/stratos-sdk 1.3.5 → 1.3.6

package/src/cli-setup.js

@@ -1,121 +1,171 @@
-#!/usr/bin/env node
-
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { homedir, platform } from "node:os";
-import { join, resolve } from "node:path";
-import { execSync } from "node:child_process";
-
-export async function setupCommand(surface) {
-  if (!surface) {
-    console.error("[stratos-setup] Error: Surface required");
-    console.error("Usage: stratos setup <surface>");
-    console.error("Example: stratos setup claude-code");
-    process.exit(1);
-  }
-
-  if (surface !== "claude-code") {
-    console.error(`[stratos-setup] Error: Unsupported surface '${surface}'`);
-    console.error("Currently supported: claude-code");
-    process.exit(1);
-  }
-
-  console.log(`[stratos-setup] Configuring Stratos for ${surface}...\n`);
-
-  const claudeCodePath = detectClaudeCode();
-  if (!claudeCodePath) {
-    console.error("[stratos-setup] Error: Claude Code not detected on this machine");
-    console.error("Install Claude Code from https://claude.ai/code before running setup.");
-    process.exit(1);
-  }
-
-  console.log(`✓ Found Claude Code at: ${claudeCodePath}\n`);
-
-  const token = process.env.STRATOS_TOKEN;
-  if (!token) {
-    console.error("[stratos-setup] Error: STRATOS_TOKEN environment variable not set");
-    console.error("Provide your enrollment token via: export STRATOS_TOKEN=sk_...");
-    process.exit(1);
-  }
-
-  const url = process.env.STRATOS_URL || "https://stratos.anthropic.com";
-  console.log(`✓ Using Stratos server: ${url}\n`);
-
-  const claudeDir = join(homedir(), ".claude");
-  mkdirSync(claudeDir, { recursive: true });
-
-  const envPath = join(claudeDir, ".env");
-  const envContent = `STRATOS_TOKEN=${token}
-STRATOS_URL=${url}
-STRATOS_RECORD_INPUTS=0
-STRATOS_RECORD_OUTPUTS=0
-NODE_OPTIONS=--import @intelli-1113/stratos-sdk/register
-`;
-
-  writeFileSync(envPath, envContent, "utf8");
-  console.log(`✓ Wrote config to: ${envPath}`);
-
-  const settingsPath = join(claudeDir, "settings.json");
-  let settings = {};
-  if (existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf8"));
-    } catch {
-      console.warn("[stratos-setup] Warning: Could not parse existing settings.json, will merge");
-    }
-  }
-
-  settings.env = settings.env || {};
-  settings.env.STRATOS_TOKEN = token;
-  settings.env.STRATOS_URL = url;
-  settings.env.STRATOS_RECORD_INPUTS = "0";
-  settings.env.STRATOS_RECORD_OUTPUTS = "0";
-  settings.env.NODE_OPTIONS = "--import @intelli-1113/stratos-sdk/register";
-
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
-  console.log(`✓ Updated: ${settingsPath}\n`);
-
-  console.log("[stratos-setup] Setup complete. Running doctor to verify...\n");
-
-  const { doctorCommand } = await import("./cli-doctor.js");
-  await doctorCommand();
-}
-
-function detectClaudeCode() {
-  const os = platform();
-  const home = homedir();
-
-  if (os === "darwin") {
-    const macPath = join(home, "Applications", "Claude.app");
-    if (existsSync(macPath)) return macPath;
-  }
-
-  if (os === "win32") {
-    const paths = [
-      join(home, "AppData", "Local", "Programs", "claude"),
-      "C:\\Program Files\\Claude",
-      "C:\\Program Files (x86)\\Claude",
-    ];
-    for (const p of paths) {
-      if (existsSync(p)) return p;
-    }
-  }
-
-  if (os === "linux") {
-    const paths = [
-      join(home, ".local", "share", "applications", "claude"),
-      join(home, ".config", "claude"),
-    ];
-    for (const p of paths) {
-      if (existsSync(p)) return p;
-    }
-  }
-
-  try {
-    const result = execSync("which claude 2>/dev/null || where claude 2>nul", {
-      encoding: "utf8",
-    }).trim();
-    if (result) return result;
-  } catch {}
-
-  return null;
-}
+// `stratos setup claude-code` — connect Claude Code to Stratos.
+//
+// Claude Code is a compiled binary, so the Node SDK cannot be loaded into it
+// (NODE_OPTIONS only leaks into every Node command Claude runs). Instead we add
+// four short-lived hooks to ~/.claude/settings.json; they read the session
+// transcript and post usage to Stratos. No background process, nothing to
+// restart after a reboot. The token stays in ~/.stratos/config.json.
+
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync, rmSync } from "node:fs";
+import { dirname } from "node:path";
+import spawn from "cross-spawn";
+import {
+  DEFAULT_URL,
+  MANAGED_SETTINGS_PATHS,
+  buildClaudeCodeHooks,
+  claudeSettingsPath,
+  cleanLegacyEnv,
+  configFile,
+  hasLegacyNodeOptions,
+  loadConfig,
+  mergeStratosHooks,
+  removeStratosHooks,
+  saveConfig,
+  LEGACY_ENV_KEYS,
+} from "./claude-code/settings.js";
+
+class SetupError extends Error {}
+
+function detectClaudeCode() {
+  // cross-spawn resolves npm's claude.cmd shim on Windows without going through a shell.
+  const r = spawn.sync("claude", ["--version"], { encoding: "utf8", timeout: 10000 });
+  return r.status === 0 && r.stdout ? r.stdout.trim() : null;
+}
+
+/** Read settings.json; refuse to continue if it exists but is not valid JSON. */
+export function readSettings(path = claudeSettingsPath()) {
+  if (!existsSync(path)) return {};
+  const raw = readFileSync(path, "utf8");
+  if (!raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("not a JSON object");
+    return parsed;
+  } catch (err) {
+    throw new SetupError(
+      `${path} is not valid JSON (${err.message}). Fix or move it, then re-run setup. Nothing was changed.`
+    );
+  }
+}
+
+function backup(path) {
+  if (!existsSync(path)) return null;
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const dest = `${path}.stratos-backup-${stamp}`;
+  copyFileSync(path, dest);
+  return dest;
+}
+
+function writeSettings(path, settings) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+}
+
+/** Pure: apply our changes to a settings object. Exported for tests. */
+export function applySetup(settings) {
+  const next = { ...settings };
+  next.hooks = mergeStratosHooks(settings.hooks || {});
+  if (settings.env) {
+    next.env = cleanLegacyEnv(settings.env);
+    if (!Object.keys(next.env).length) delete next.env;
+  }
+  return next;
+}
+
+/** Pure: remove our changes from a settings object. Exported for tests. */
+export function applyRemove(settings) {
+  const next = { ...settings };
+  if (settings.hooks) {
+    next.hooks = removeStratosHooks(settings.hooks);
+    if (!Object.keys(next.hooks).length) delete next.hooks;
+  }
+  if (settings.env) {
+    next.env = cleanLegacyEnv(settings.env);
+    if (!Object.keys(next.env).length) delete next.env;
+  }
+  return next;
+}
+
+function printManaged() {
+  const snippet = { hooks: buildClaudeCodeHooks() };
+  console.log("Add this to managed-settings.json (merge with any existing hooks):\n");
+  console.log(JSON.stringify(snippet, null, 2));
+  console.log("\nLocations:");
+  for (const [os, p] of Object.entries(MANAGED_SETTINGS_PATHS)) console.log(`  ${os.padEnd(7)} ${p}`);
+  console.log(
+    "\nThe paths above point at this machine's node and SDK install; adjust them for the target machines." +
+      "\nEach developer still needs ~/.stratos/config.json (token + URL): run `stratos setup claude-code --config-only`."
+  );
+}
+
+export async function setupCommand(surface, opts = {}) {
+  try {
+    if (opts["print-managed"]) return printManaged();
+
+    if (surface !== "claude-code") {
+      throw new SetupError(
+        surface ? `Unsupported surface '${surface}'. Currently supported: claude-code` : "Usage: stratos setup claude-code [--url URL] [--token TOKEN]"
+      );
+    }
+
+    const settingsPath = claudeSettingsPath();
+
+    if (opts.remove) {
+      const settings = readSettings(settingsPath);
+      const saved = backup(settingsPath);
+      writeSettings(settingsPath, applyRemove(settings));
+      rmSync(configFile(), { force: true });
+      console.log(`✓ Removed Stratos hooks from ${settingsPath}`);
+      if (saved) console.log(`  backup: ${saved}`);
+      console.log(`✓ Deleted ${configFile()}`);
+      return;
+    }
+
+    console.log("[stratos-setup] Configuring Stratos for Claude Code…\n");
+
+    const version = detectClaudeCode();
+    if (version) console.log(`✓ Claude Code ${version}`);
+    else console.warn("⚠ `claude` not found on PATH — continuing (the desktop app also reads ~/.claude/settings.json)");
+
+    const current = loadConfig();
+    const token = opts.token || current.token;
+    if (!token) throw new SetupError("No token. Pass --token <enrollment token> or set STRATOS_TOKEN.");
+    const url = (opts.url || current.url || DEFAULT_URL).replace(/\/+$/, "");
+    if (!/^https?:\/\//.test(url)) throw new SetupError(`Invalid --url '${url}'`);
+    if (url.startsWith("http://") && !/^http:\/\/(localhost|127\.0\.0\.1|\[::1\])(:|\/|$)/.test(url)) {
+      console.warn(`⚠ ${url} is plain http — the token will travel unencrypted`);
+    }
+
+    const cfgPath = saveConfig({
+      token,
+      url,
+      appName: opts["app-name"] || current.appName || "claude-code",
+      recordInputs: !!opts["record-prompts"],
+      recordOutputs: !!opts["record-prompts"],
+    });
+    console.log(`✓ Saved token and URL to ${cfgPath} (not in settings.json)`);
+    console.log(`✓ Stratos server: ${url}`);
+    console.log(`✓ Prompt/response text: ${opts["record-prompts"] ? "RECORDED (--record-prompts)" : "not recorded (default)"}`);
+
+    if (opts["config-only"]) return;
+
+    const settings = readSettings(settingsPath);
+    const hadLegacy = hasLegacyNodeOptions(settings.env) || LEGACY_ENV_KEYS.some((k) => settings.env?.[k] != null);
+    const saved = backup(settingsPath);
+    writeSettings(settingsPath, applySetup(settings));
+    console.log(`✓ Added Stratos hooks (SessionStart, Stop, SubagentStop, SessionEnd) to ${settingsPath}`);
+    if (saved) console.log(`  backup: ${saved}`);
+    if (hadLegacy) console.log("✓ Removed NODE_OPTIONS / STRATOS_* entries left by an older setup");
+    console.log("\nNew Claude Code sessions will report usage. Running doctor…\n");
+
+    const { doctorCommand } = await import("./cli-doctor.js");
+    await doctorCommand();
+  } catch (err) {
+    if (err instanceof SetupError) {
+      console.error(`[stratos-setup] ${err.message}`);
+      process.exitCode = 1;
+      return;
+    }
+    throw err;
+  }
+}

package/src/cli.js

@@ -1,70 +1,115 @@
-#!/usr/bin/env node
-
-import { parseArgs } from "node:util";
-import { setupCommand } from "./cli-setup.js";
-import { doctorCommand } from "./cli-doctor.js";
-
-const VERSION = "1.3.4";
-
-function printHelp() {
-  console.log(`
-stratos CLI ${VERSION}
-
-Usage:
-  stratos <command> [options]
-
-Commands:
-  setup <surface>       Configure Stratos on a surface (e.g., claude-code)
-  doctor                Validate Stratos setup and connectivity
-  --help, -h            Show this message
-  --version, -v         Show version
-
-Examples:
-  stratos setup claude-code
-  stratos doctor
-`);
-}
-
-async function main() {
-  const { values, positional } = parseArgs({
-    options: {
-      help: { type: "boolean", short: "h" },
-      version: { type: "boolean", short: "v" },
-    },
-    allowPositionals: true,
-  });
-
-  if (values.help) {
-    printHelp();
-    process.exit(0);
-  }
-
-  if (values.version) {
-    console.log(`stratos ${VERSION}`);
-    process.exit(0);
-  }
-
-  const [command, ...args] = positional;
-
-  if (!command) {
-    printHelp();
-    process.exit(0);
-  }
-
-  try {
-    if (command === "setup") {
-      await setupCommand(...args);
-    } else if (command === "doctor") {
-      await doctorCommand();
-    } else {
-      console.error(`Unknown command: ${command}`);
-      printHelp();
-      process.exit(1);
-    }
-  } catch (err) {
-    console.error(`[stratos] Error:`, err.message);
-    process.exit(1);
-  }
-}
-
-main();
+#!/usr/bin/env node
+
+import { parseArgs } from "node:util";
+import { readFileSync } from "node:fs";
+
+const VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+
+function printHelp() {
+  console.log(`
+stratos CLI ${VERSION}
+
+Getting started:
+  1. Install: npm install @intelli-1113/stratos-sdk
+
+  2. Add to your code (app.js):
+     node --import @intelli-1113/stratos-sdk/register app.js
+
+     OR in your code:
+     import Stratos from '@intelli-1113/stratos-sdk';
+     Stratos.start({ token: 'sk_...', url: 'https://...' });
+
+  3. Set up config:
+     stratos env add STRATOS_TOKEN=sk_your_token
+     stratos env add STRATOS_URL=https://stratos.example.com
+
+  4. Verify connection:
+     stratos doctor
+
+Usage:
+  stratos <command> [options]
+
+Commands:
+  setup <agent>                          Connect agent to Stratos (adds configuration)
+      --token <token>                      Enrollment token (or STRATOS_TOKEN)
+      --url <url>                          Stratos server (or STRATOS_URL; default http://localhost:4000)
+      --record-prompts                     Also send prompt and response text (off by default)
+      --config-only                        Only write ~/.stratos/config.json
+      --remove                             Remove configuration and ~/.stratos/config.json
+      --print-managed                      Print a managed-settings.json snippet for admins
+  doctor                                 Check setup and connectivity
+  env add <VAR>=<value> [VAR2=value2...] Add environment variable(s) to .env (project directory only)
+  hook <event>                           Used by Claude Code hooks (session-start | stop | subagent-stop | session-end)
+  --help, -h                             Show this message
+  --version, -v                          Show version
+
+Examples:
+  stratos setup claude-code --token <your-token> --url https://stratos.example.com
+  stratos doctor
+  stratos env add STRATOS_RECORD_PROMPTS=1
+  stratos env add STRATOS_TOKEN=sk_... STRATOS_URL=https://... STRATOS_RECORD_PROMPTS=1
+`);
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+
+  // Hook path first: quiet, fast, never fails Claude Code.
+  if (argv[0] === "hook") {
+    try {
+      const { runHook, readStdin } = await import("./claude-code/hook.js");
+      await runHook(argv[1], await readStdin());
+    } catch {
+      /* runHook logs its own errors; nothing may reach Claude Code */
+    }
+    // Let fetch sockets finish closing first: exiting mid-close can trip a libuv assertion on Windows.
+    await new Promise((r) => setTimeout(r, 20));
+    process.exit(0);
+  }
+
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: {
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" },
+      token: { type: "string" },
+      url: { type: "string" },
+      "app-name": { type: "string" },
+      "record-prompts": { type: "boolean" },
+      "config-only": { type: "boolean" },
+      remove: { type: "boolean" },
+      "print-managed": { type: "boolean" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.version) return console.log(`stratos ${VERSION}`);
+  const [command, ...args] = positionals;
+  if (values.help || !command) return printHelp();
+
+  if (command === "setup") {
+    const { setupCommand } = await import("./cli-setup.js");
+    await setupCommand(args[0], values);
+  } else if (command === "doctor") {
+    const { doctorCommand } = await import("./cli-doctor.js");
+    await doctorCommand();
+  } else if (command === "env") {
+    if (args[0] === "add") {
+      const { envAddCommand } = await import("./cli-env.js");
+      await envAddCommand(...args.slice(1));
+    } else {
+      console.error(`Unknown env subcommand: ${args[0]}`);
+      console.log("Usage: stratos env add <VAR>=<value> [VAR2=value2 ...]");
+      process.exitCode = 1;
+    }
+  } else {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exitCode = 1;
+  }
+}
+
+main().catch((err) => {
+  console.error("[stratos] Error:", err?.message || err);
+  process.exit(1);
+});