@sailresearch/code 0.1.0

package/src/run.js

@@ -0,0 +1,328 @@
+/**
+ * The default command: resolve a Sail credential, overlay the Claude Code
+ * environment block, and hand the terminal to `claude`.
+ */
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+import {
+  CONFLICTING_PROVIDER_VARS,
+  HEADER_INJECTION_VARS,
+  MODEL_ALIAS_COMPANION_VARS,
+  buildClaudeEnv,
+} from "./constants.js";
+import {
+  loadAuthKey,
+  loadSettingsBestEffort,
+  resolveTarget,
+  storedKeyMatchesTarget,
+} from "./credentials.js";
+import { browserLogin } from "./login.js";
+
+/**
+ * Resolve the credential + target. Precedence: SAIL_API_KEY env (always
+ * wins), then the stored `~/.sail` key when its tagged target matches the
+ * active one, then the interactive browser login.
+ */
+export async function resolveCredentials({ modeFlag } = {}) {
+  const target = resolveTarget({ modeFlag });
+  const envKey = process.env.SAIL_API_KEY?.trim();
+  if (envKey) {
+    return { apiKey: envKey, apiUrl: target.apiUrl, source: "SAIL_API_KEY" };
+  }
+
+  const storedKey = loadAuthKey();
+  if (storedKey) {
+    const settings = loadSettingsBestEffort();
+    if (storedKeyMatchesTarget(settings, target.apiUrl)) {
+      return { apiKey: storedKey, apiUrl: target.apiUrl, source: "~/.sail" };
+    }
+    console.error(
+      `The stored Sail key is for a different environment than ${target.apiUrl} ` +
+        `(selected via ${target.source}); logging in again.`,
+    );
+  }
+
+  if (!process.stdout.isTTY && !process.stdin.isTTY) {
+    throw new Error(
+      "no Sail credential found — set SAIL_API_KEY, or run `sail-code login` in a terminal",
+    );
+  }
+  // Pin the login to the environment this invocation resolved (login rejects
+  // a callback for a different one), so e.g. SAIL_API_URL=staging can never
+  // be silently satisfied by a prod browser login.
+  const login = await browserLogin({
+    expectedTarget: target.apiUrl,
+    expectedSource: target.source,
+  });
+  return { apiKey: login.apiKey, apiUrl: login.apiUrl, source: "login" };
+}
+
+// --- Windows spawn support -------------------------------------------------
+//
+// `npm install -g @anthropic-ai/claude-code` puts `claude.cmd`/`claude.ps1`
+// shims on PATH on Windows — no claude.exe. CreateProcess only auto-appends
+// .exe, and Node (post CVE-2024-27980) refuses to spawn .cmd/.bat without a
+// shell, so a bare spawn("claude") can never work there. We resolve the real
+// target on PATH ourselves: .exe/.com spawn directly; .cmd/.bat go through
+// cmd.exe with cross-spawn's escaping (shell:true would join args unescaped).
+
+function resolveWindowsCommand(name) {
+  const exts = (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD")
+    .split(";")
+    .filter(Boolean);
+  const dirs = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const candidate = path.join(dir, name + ext.toLowerCase());
+      if (fs.existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+// cross-spawn's escape.js, verbatim semantics. Exported for tests.
+const CMD_META = /([()\][%!^"`<>&|;, *?])/g;
+
+export function escapeCmdCommand(command) {
+  return command.replace(CMD_META, "^$1");
+}
+
+export function escapeCmdArgument(arg, doubleEscape) {
+  let escaped = String(arg)
+    .replace(/(\\*)"/g, '$1$1\\"')
+    .replace(/(\\*)$/, "$1$1");
+  escaped = `"${escaped}"`.replace(CMD_META, "^$1");
+  if (doubleEscape) escaped = escaped.replace(CMD_META, "^$1");
+  return escaped;
+}
+
+function spawnClaude(claudeArgs, options) {
+  if (process.platform !== "win32") {
+    return spawn("claude", claudeArgs, options);
+  }
+  const resolved = resolveWindowsCommand("claude");
+  if (resolved && /\.(exe|com)$/i.test(resolved)) {
+    return spawn(resolved, claudeArgs, options);
+  }
+  if (resolved && /\.(cmd|bat)$/i.test(resolved)) {
+    // npm's .cmd shim re-parses the line when expanding %*, consuming one
+    // caret level — hence the double escape on arguments.
+    const line = [
+      escapeCmdCommand(path.normalize(resolved)),
+      ...claudeArgs.map((a) => escapeCmdArgument(a, true)),
+    ].join(" ");
+    return spawn(
+      process.env.comspec || "cmd.exe",
+      ["/d", "/s", "/c", `"${line}"`],
+      {
+        ...options,
+        windowsVerbatimArguments: true,
+      },
+    );
+  }
+  // Nothing resolved: fall through so the ENOENT handler explains.
+  return spawn("claude", claudeArgs, options);
+}
+
+function claudeNotFoundError() {
+  const hint =
+    process.platform === "win32"
+      ? "  npm install -g @anthropic-ai/claude-code\n" +
+        "(npm installs a claude.cmd shim — open a new terminal after installing " +
+        "so PATH refreshes)"
+      : "  npm install -g @anthropic-ai/claude-code";
+  return new Error(
+    `\`claude\` was not found on PATH. Install Claude Code first:\n${hint}`,
+  );
+}
+
+// ---------------------------------------------------------------------------
+
+/** Exit status for a signal death, per the shell convention (128 + number). */
+function signalExitCode(signal) {
+  return 128 + (os.constants.signals[signal] ?? 1);
+}
+
+/**
+ * Whether the parent should re-send `signal` to the spawned `claude`.
+ *
+ * SIGTERM is never terminal-generated, so it only reaches the parent (a
+ * programmatic `kill`) and must be forwarded to tear the child down. SIGINT
+ * from an interactive TTY was already delivered by the kernel to the whole
+ * foreground group (child included), so forwarding it would double-interrupt;
+ * only forward SIGINT when we are NOT an interactive TTY (it then reached the
+ * parent alone). Exported for tests.
+ */
+export function shouldForwardSignal(signal, { isTTY } = {}) {
+  if (signal === "SIGINT") return !isTTY;
+  return true;
+}
+
+/**
+ * The env for the spawned `claude`: the parent env with provider-selection
+ * vars stripped (they outrank our bearer token in Claude Code's auth
+ * precedence), header-injection vars stripped (they would send stale
+ * third-party gateway headers to Sail), and alias companion vars stripped
+ * (a stale `_SUPPORTED_CAPABILITIES`/`_NAME`/`_DESCRIPTION` would mis-describe
+ * the GLM model we repoint the aliases to), then the Sail routing block
+ * overlaid. Exported for tests.
+ */
+export function buildChildEnv(baseEnv, sailEnv) {
+  const childEnv = { ...baseEnv };
+  for (const key of [
+    ...CONFLICTING_PROVIDER_VARS,
+    ...HEADER_INJECTION_VARS,
+    ...MODEL_ALIAS_COMPANION_VARS,
+  ]) {
+    delete childEnv[key];
+  }
+  return { ...childEnv, ...sailEnv };
+}
+
+/**
+ * The env block for the temp `--settings` file. Claude Code gives that file
+ * the highest settings precedence, but it *merges* with `~/.claude/settings
+ * .json` and a project `.claude/settings.json` rather than replacing them, and
+ * settings-file env outranks process env. So a conflicting key checked into
+ * one of those files (a `CLAUDE_CODE_USE_*` provider selector or
+ * `ANTHROPIC_CUSTOM_HEADERS`) would survive `buildChildEnv`'s process-env
+ * scrub and still outrank Sail. Neutralize them to empty here so our
+ * highest-precedence layer overrides the file value with a falsy one.
+ * Exported for tests.
+ */
+export function buildSettingsEnv(sailEnv) {
+  const settingsEnv = { ...sailEnv };
+  for (const key of [...CONFLICTING_PROVIDER_VARS, ...HEADER_INJECTION_VARS]) {
+    settingsEnv[key] = "";
+  }
+  return settingsEnv;
+}
+
+/**
+ * Spawn `claude` with the Sail env overlaid; resolves to its exit code.
+ *
+ * Claude Code gives a settings-file `env` block precedence over process
+ * environment variables, so a previously persisted `sail-code setup` (or a
+ * stale project settings file) would silently override this invocation's
+ * flags. Command-line settings outrank both, so the env block also rides a
+ * `--settings` temp file (0600 — keeps the token out of argv) unless the
+ * user passed their own `--settings` after `--`.
+ */
+export async function runClaude({ env, claudeArgs, spawn = spawnClaude }) {
+  const userPassedSettings = claudeArgs.some(
+    (a) => a === "--settings" || a.startsWith("--settings="),
+  );
+  let settingsFile = null;
+  let args = claudeArgs;
+  if (userPassedSettings) {
+    console.error(
+      "Note: you passed --settings, so Sail routing rides only the process " +
+        "env; a settings-file env block (e.g. from `sail-code setup`) will " +
+        "override it.",
+    );
+  } else {
+    settingsFile = path.join(
+      os.tmpdir(),
+      `sail-code-${crypto.randomBytes(8).toString("hex")}.json`,
+    );
+    try {
+      fs.writeFileSync(
+        settingsFile,
+        JSON.stringify({ env: buildSettingsEnv(env) }, null, 2),
+        { mode: 0o600 },
+      );
+    } catch (err) {
+      // writeFileSync opens (creating the file) then writes: a failure during
+      // the write (e.g. ENOSPC) leaves a partial temp file that the spawn
+      // try/finally below never reaches, since we throw before entering it.
+      // Remove it before propagating. (An open failure created nothing, so
+      // the unlink just no-ops.)
+      try {
+        fs.unlinkSync(settingsFile);
+      } catch {
+        // Never created, or already gone — nothing to clean up.
+      }
+      settingsFile = null;
+      throw err;
+    }
+    args = ["--settings", settingsFile, ...claudeArgs];
+  }
+
+  const cleanup = () => {
+    if (!settingsFile) return;
+    try {
+      fs.unlinkSync(settingsFile);
+    } catch {
+      // Already gone, or tmpdir cleanup will get it.
+    }
+    settingsFile = null;
+  };
+
+  const childEnv = buildChildEnv(process.env, env);
+
+  try {
+    return await new Promise((resolve, reject) => {
+      const child = spawn(args, {
+        stdio: "inherit",
+        env: childEnv,
+      });
+
+      // Ctrl+C in an interactive terminal is delivered by the kernel to the
+      // whole foreground process group, so `claude` already receives it
+      // directly; forwarding a second SIGINT would make one keypress read as
+      // two interrupts (Claude exits instead of just cancelling). Keep the
+      // handler regardless — it stops that same SIGINT from killing the parent,
+      // which must survive to propagate the child's exit code and clean up —
+      // but only re-send per shouldForwardSignal.
+      const onSignal = (signal) => {
+        if (
+          shouldForwardSignal(signal, {
+            isTTY: Boolean(process.stdin.isTTY),
+          }) &&
+          !child.killed
+        ) {
+          child.kill(signal);
+        }
+      };
+      process.on("SIGINT", onSignal);
+      process.on("SIGTERM", onSignal);
+      // Detach both handlers on the FIRST of error/exit. A failed spawn
+      // (e.g. ENOENT when claude isn't installed) fires `error` and never
+      // `exit`, so removing them only in the exit path would leak a SIGINT/
+      // SIGTERM listener per call. removeListener is idempotent, so the rare
+      // error-then-exit double-fire is harmless.
+      const detachSignals = () => {
+        process.removeListener("SIGINT", onSignal);
+        process.removeListener("SIGTERM", onSignal);
+      };
+
+      child.on("error", (err) => {
+        detachSignals();
+        reject(err.code === "ENOENT" ? claudeNotFoundError() : err);
+      });
+
+      child.on("exit", (code, signal) => {
+        detachSignals();
+        resolve(signal ? signalExitCode(signal) : (code ?? 1));
+      });
+    });
+  } finally {
+    cleanup();
+  }
+}
+
+/** The `run` command. */
+export async function run({ modeFlag, model, backgroundModel, claudeArgs }) {
+  const { apiKey, apiUrl } = await resolveCredentials({ modeFlag });
+  const env = buildClaudeEnv({ apiUrl, apiKey, model, backgroundModel });
+  console.error(
+    `Running Claude Code on ${env.ANTHROPIC_MODEL} via Sail (${apiUrl}) — ` +
+      "no Anthropic account used.",
+  );
+  return runClaude({ env, claudeArgs });
+}