@intelli-1113/stratos-sdk 1.3.4 → 1.3.6

package/src/cli-setup.js

@@ -0,0 +1,171 @@
+// `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

@@ -0,0 +1,115 @@
+#!/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);
+});

package/src/config-templates.js

@@ -0,0 +1,148 @@
+// Config bundles for rolling Stratos out to many developers (MDM / scripts).
+//
+// Claude Code reports through hooks (see src/claude-code/), so a bundle is:
+//   - the hook block for ~/.claude/settings.json or managed-settings.json
+//   - the per-developer ~/.stratos/config.json (token + URL)
+// Tokens come from Stratos enrollment; they are never invented here.
+
+import { platform } from "node:os";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { buildClaudeCodeHooks, MANAGED_SETTINGS_PATHS } from "./claude-code/settings.js";
+
+const SDK_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+const SURFACES = ["claude-code"];
+
+export class ConfigTemplate {
+  constructor(opts = {}) {
+    if (!opts.personEmail) throw new Error("ConfigTemplate: personEmail is required");
+    if (!opts.token) throw new Error("ConfigTemplate: token is required (issue one from Stratos enrollment)");
+    this.personEmail = opts.personEmail;
+    this.surface = opts.surface || "claude-code";
+    if (!SURFACES.includes(this.surface)) throw new Error(`ConfigTemplate: unsupported surface '${this.surface}'`);
+    this.token = opts.token;
+    this.url = (opts.url || "http://localhost:4000").replace(/\/+$/, "");
+    this.osType = opts.osType || platform();
+    this.recordContent = opts.recordContent === true;
+    // Paths of node and the SDK on the *target* machines, if they differ from this one.
+    this.hookPaths = { node: opts.nodePath, cli: opts.cliPath };
+  }
+
+  hooks() {
+    const o = {};
+    if (this.hookPaths.node) o.node = this.hookPaths.node;
+    if (this.hookPaths.cli) o.cli = this.hookPaths.cli;
+    return buildClaudeCodeHooks(o);
+  }
+
+  /** Contents of ~/.claude/settings.json additions (merge into existing hooks). */
+  toSettingsJson() {
+    return { hooks: this.hooks() };
+  }
+
+  /** Contents for managed-settings.json, enforced for every user on the machine. */
+  toManagedSettings() {
+    return { hooks: this.hooks() };
+  }
+
+  managedSettingsPath() {
+    return MANAGED_SETTINGS_PATHS[this.osType] || MANAGED_SETTINGS_PATHS.linux;
+  }
+
+  /** Contents of ~/.stratos/config.json for this developer. */
+  toStratosConfig() {
+    return {
+      token: this.token,
+      url: this.url,
+      appName: `claude-code:${this.personEmail.split("@")[0]}`,
+      recordInputs: this.recordContent,
+      recordOutputs: this.recordContent,
+    };
+  }
+
+  toBundle() {
+    return {
+      version: "2.0",
+      person: this.personEmail,
+      surface: this.surface,
+      os: this.osType,
+      claude_settings: this.toSettingsJson(),
+      managed_settings: { path: this.managedSettingsPath(), content: this.toManagedSettings() },
+      stratos_config: { path: "~/.stratos/config.json", content: this.toStratosConfig() },
+      metadata: { created_at: new Date().toISOString(), sdk_version: SDK_VERSION },
+    };
+  }
+
+  save(dirPath) {
+    const name = `stratos-config-${this.personEmail.replace(/@.*/, "")}-${this.surface}.json`;
+    const jsonPath = join(dirPath, name);
+    writeFileSync(jsonPath, JSON.stringify(this.toBundle(), null, 2), { encoding: "utf8", mode: 0o600 });
+    return { jsonPath };
+  }
+}
+
+export class MDMBundleGenerator {
+  constructor(opts = {}) {
+    this.orgUrl = opts.orgUrl || "http://localhost:4000";
+    this.adminToken = opts.adminToken;
+    this.templates = [];
+  }
+
+  addTemplate(template) {
+    this.templates.push(template);
+  }
+
+  /** @param {Record<string,string>} tokens  surface → enrollment token for this person */
+  generateForPerson(personEmail, tokens, opts = {}) {
+    return Object.entries(tokens).map(
+      ([surface, token]) => new ConfigTemplate({ ...opts, personEmail, surface, token, url: this.orgUrl })
+    );
+  }
+
+  toManifest() {
+    return {
+      version: "2.0",
+      org_url: this.orgUrl,
+      bundles: this.templates.map((t) => t.toBundle()),
+      metadata: {
+        created_at: new Date().toISOString(),
+        sdk_version: SDK_VERSION,
+        total_bundles: this.templates.length,
+        total_people: new Set(this.templates.map((t) => t.personEmail)).size,
+      },
+    };
+  }
+
+  async postToEnrollment(enrollmentUrl) {
+    if (!this.adminToken) {
+      console.error("[mdm-bundle] Admin token required to post enrollment");
+      return false;
+    }
+    try {
+      const res = await fetch(`${enrollmentUrl.replace(/\/+$/, "")}/api/mdm/bundle`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${this.adminToken}` },
+        body: JSON.stringify(this.toManifest()),
+        signal: AbortSignal.timeout(10000),
+      });
+      if (!res.ok) {
+        console.error(`[mdm-bundle] Enrollment returned ${res.status}`);
+        return false;
+      }
+      console.log("[mdm-bundle] Bundle posted to enrollment successfully");
+      return true;
+    } catch (err) {
+      console.error(`[mdm-bundle] Failed to post: ${err.message}`);
+      return false;
+    }
+  }
+}
+
+/** @param {Record<string,string>} tokensByEmail  email → claude-code enrollment token */
+export function createDefaultMDMBundle(tokensByEmail, orgUrl) {
+  const generator = new MDMBundleGenerator({ orgUrl });
+  for (const [email, token] of Object.entries(tokensByEmail)) {
+    generator.generateForPerson(email, { "claude-code": token }).forEach((t) => generator.addTemplate(t));
+  }
+  return generator;
+}