@sailresearch/code 0.1.0

package/README.md

@@ -0,0 +1,87 @@
+# @sailresearch/code
+
+Run [Claude Code](https://code.claude.com) on **GLM-5.2** via
+[Sail](https://sailresearch.com) — one command, no Anthropic account.
+
+```sh
+npx @sailresearch/code
+```
+
+That's it. On first run it opens a browser to mint a Sail API key (or reuses
+`SAIL_API_KEY` / an existing `sail auth login` credential from `~/.sail`),
+sets the routing environment, and launches `claude`. A freshly minted key is
+saved to `~/.sail` (like `sail auth login`); your Claude Code setup is left
+untouched. Set `SAIL_API_KEY` in your environment to skip the browser flow and
+persist nothing.
+
+Claude Code itself must be installed (`npm install -g @anthropic-ai/claude-code`).
+
+## Persistent setup / VS Code
+
+To make `claude` route to Sail without the launcher (for VS Code, or a bare
+`claude`), persist the env block:
+
+```sh
+npx @sailresearch/code setup            # writes ~/.claude/settings.json (backed up)
+npx @sailresearch/code setup --revert   # restores the backup
+```
+
+Notes:
+
+- After `setup`, `sail-code` runs still win over the persisted values (the
+  launcher passes its env as command-line settings, which outrank settings
+  files) — so `--mode`/`--model` flags keep working.
+- `setup` (default `--user`) writes the **lowest-precedence** settings file, so
+  a repo that ships its own `.claude/settings.json` with a conflicting
+  `ANTHROPIC_BASE_URL` / provider selector still outranks it inside that repo —
+  run `setup --project` there. Elsewhere, bare `claude` routes to Sail.
+- **VS Code:** extension sessions read the persisted env block, but the
+  extension's own pre-launch login check does not. If you have no saved
+  Anthropic login, also set `claudeCode.disableLoginPrompt: true` and
+  `claudeCode.environmentVariables` in VS Code's user settings — `setup`
+  prints the exact snippet.
+- `setup --project` writes the repo-local `.claude/settings.local.json`
+  instead — Claude Code's personal, not-shared project settings. It holds your
+  API key, so `setup` also adds it to `.claude/.gitignore`; keep it out of
+  commits. Claude Code applies project settings only after you've trusted the
+  folder in its first-run prompt.
+
+## Choosing models
+
+```sh
+npx @sailresearch/code --model zai-org/GLM-5.2-FP8 --background-model openai/gpt-oss-120b
+```
+
+Both tiers default to GLM-5.2. `--background-model` moves Claude Code's
+haiku/background tier (titles, summaries) to a cheaper model from the
+[Sail catalog](https://docs.sailresearch.com/models).
+
+## Passing flags to claude
+
+Everything after `--` goes to `claude` untouched:
+
+```sh
+npx @sailresearch/code -- --resume
+```
+
+## How it works
+
+Claude Code speaks the Anthropic Messages API to whatever
+`ANTHROPIC_BASE_URL` points at. Sail serves that API for GLM-5.2 (system
+prompts, tools, streaming included), so the launcher only sets environment
+variables — see them with `npx @sailresearch/code env`. Your Anthropic
+credentials are never involved or touched.
+
+Claude Code's own non-model traffic (update checks, error reports, usage
+telemetry) still goes to Anthropic endpoints; set
+`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1` before launching if you need
+that off (it also disables auto-updates).
+
+The native Claude Code desktop app reads routing only from managed (MDM)
+configuration and is not supported; use the terminal or VS Code.
+
+If you're signed into an enterprise **Claude apps gateway**, that session
+outranks `ANTHROPIC_AUTH_TOKEN`, so `claude` keeps using the gateway instead
+of Sail — run `/logout` first (ordinary Pro/Max users aren't affected).
+
+Docs: https://docs.sailresearch.com/claude-code

package/bin/sail-code.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from "../src/cli.js";
+
+main().catch((err) => {
+  console.error(`sail-code: ${err?.message ?? err}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@sailresearch/code",
+  "version": "0.1.0",
+  "description": "Run Claude Code on GLM-5.2 via Sail — one command, no Anthropic account.",
+  "license": "MIT",
+  "author": "Sail Research",
+  "homepage": "https://docs.sailresearch.com/claude-code",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sailresearchco/sail-code.git"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "sail-code": "bin/sail-code.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/src/cli.js

@@ -0,0 +1,166 @@
+/**
+ * Argument parsing and dispatch for `sail-code`.
+ *
+ * Everything after a literal `--` is passed to `claude` untouched. Flags
+ * before it belong to sail-code; unknown ones are an error (not silently
+ * forwarded) so a typo can't change which tool interprets a flag.
+ */
+
+import { createRequire } from "node:module";
+
+import { DEFAULT_MODEL, MODE_VALUES, buildClaudeEnv } from "./constants.js";
+import { maskSecret, resolveTarget } from "./credentials.js";
+import { browserLogin } from "./login.js";
+import { resolveCredentials, run } from "./run.js";
+import { revert, setup } from "./setup.js";
+
+const require = createRequire(import.meta.url);
+
+const HELP = `sail-code — run Claude Code on GLM-5.2 via Sail (no Anthropic account)
+
+Usage:
+  sail-code [flags] [-- <claude args...>]   Launch claude routed to Sail
+  sail-code setup [--user|--project]        Persist routing into settings
+                  [--revert]                  (--project → gitignored local file)
+  sail-code login                           Log in and store a Sail API key
+  sail-code env                             Print the env block (key masked)
+
+Flags:
+  --model <id>             Main model (default ${DEFAULT_MODEL})
+  --background-model <id>  Background/haiku-tier model (default: same as --model)
+  --mode <name>            Sail environment: ${MODE_VALUES.join(" | ")}
+  -h, --help               Show this help
+  -v, --version            Show the version
+
+Credentials resolve from SAIL_API_KEY, then ~/.sail (shared with the Sail
+CLI), then a browser login. Docs: https://docs.sailresearch.com/claude-code`;
+
+/** Parse argv (post-node, post-script). Exported for tests. */
+export function parseArgs(argv) {
+  const parsed = {
+    command: "run",
+    model: undefined,
+    backgroundModel: undefined,
+    modeFlag: undefined,
+    scope: undefined,
+    revert: false,
+    help: false,
+    version: false,
+    claudeArgs: [],
+  };
+
+  const sep = argv.indexOf("--");
+  const own = sep === -1 ? argv : argv.slice(0, sep);
+  parsed.claudeArgs = sep === -1 ? [] : argv.slice(sep + 1);
+
+  const takesValue = {
+    "--model": "model",
+    "--background-model": "backgroundModel",
+    "--mode": "modeFlag",
+  };
+  let commandSeen = false;
+
+  for (let i = 0; i < own.length; i++) {
+    const arg = own[i];
+    if (!arg.startsWith("-")) {
+      if (commandSeen)
+        throw new Error(
+          `unexpected argument "${arg}" (use -- to pass args to claude)`,
+        );
+      if (!["setup", "login", "env", "run"].includes(arg)) {
+        throw new Error(
+          `unknown command "${arg}" (expected setup, login, or env)`,
+        );
+      }
+      parsed.command = arg;
+      commandSeen = true;
+      continue;
+    }
+    if (arg in takesValue) {
+      const value = own[++i];
+      if (value === undefined || value.startsWith("-")) {
+        throw new Error(`${arg} requires a value`);
+      }
+      parsed[takesValue[arg]] = value;
+    } else if (arg === "--user") parsed.scope = "user";
+    else if (arg === "--project") parsed.scope = "project";
+    else if (arg === "--revert") parsed.revert = true;
+    else if (arg === "-h" || arg === "--help") parsed.help = true;
+    else if (arg === "-v" || arg === "--version") parsed.version = true;
+    else
+      throw new Error(`unknown flag "${arg}" (flags for claude go after --)`);
+  }
+
+  if (parsed.modeFlag && !MODE_VALUES.includes(parsed.modeFlag)) {
+    throw new Error(
+      `unknown --mode "${parsed.modeFlag}" (expected one of: ${MODE_VALUES.join(", ")})`,
+    );
+  }
+  if (parsed.scope && parsed.command !== "setup") {
+    throw new Error(`--${parsed.scope} only applies to setup`);
+  }
+  return parsed;
+}
+
+export async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.help) {
+    console.log(HELP);
+    return;
+  }
+  if (args.version) {
+    console.log(require("../package.json").version);
+    return;
+  }
+
+  let exitCode = 0;
+  switch (args.command) {
+    case "login": {
+      const target = resolveTarget({ modeFlag: args.modeFlag });
+      await browserLogin({
+        expectedTarget: target.apiUrl,
+        expectedSource: target.source,
+      });
+      break;
+    }
+    case "setup":
+      exitCode = args.revert
+        ? revert({ scope: args.scope ?? "user" })
+        : await setup({
+            scope: args.scope ?? "user",
+            modeFlag: args.modeFlag,
+            model: args.model,
+            backgroundModel: args.backgroundModel,
+          });
+      break;
+    case "env": {
+      const { apiKey, apiUrl } = await resolveCredentials({
+        modeFlag: args.modeFlag,
+      });
+      const env = buildClaudeEnv({
+        apiUrl,
+        apiKey,
+        model: args.model,
+        backgroundModel: args.backgroundModel,
+      });
+      for (const [key, value] of Object.entries(env)) {
+        const shown =
+          key === "ANTHROPIC_AUTH_TOKEN" ? maskSecret(value) : value;
+        console.log(`${key}=${shown}`);
+      }
+      console.error(
+        "\n(ANTHROPIC_AUTH_TOKEN is masked; it is your SAIL_API_KEY value)",
+      );
+      break;
+    }
+    default:
+      exitCode = await run({
+        modeFlag: args.modeFlag,
+        model: args.model,
+        backgroundModel: args.backgroundModel,
+        claudeArgs: args.claudeArgs,
+      });
+  }
+  if (exitCode !== 0) process.exit(exitCode);
+}

package/src/constants.js

@@ -0,0 +1,177 @@
+/**
+ * Shared constants: the GLM model default, Sail environment targets, and the
+ * single source of truth for the Claude Code environment block.
+ *
+ * Every surface that configures Claude Code (the `run` exec path, the `setup`
+ * settings.json path, and the `env` printout) must build its variables through
+ * `buildClaudeEnv` so the three can never drift.
+ */
+
+export const DEFAULT_MODEL = "zai-org/GLM-5.2-FP8";
+
+/** Public API targets by mode name, mirroring the Sail CLI's mode map. */
+export const MODE_API_URLS = {
+  prod: "https://api.sailresearch.com",
+  dev: "https://dev.sailresearch.com",
+  staging: "https://staging.sailresearch.com",
+  local: "http://localhost:8080",
+};
+
+export const MODE_VALUES = Object.keys(MODE_API_URLS);
+
+/** Web app that serves the browser login handoff (`/cli-auth`). */
+export const DEFAULT_APP_URL = "https://app.sailresearch.com";
+
+/**
+ * Claude Code reads the Anthropic Messages endpoint as `{base}/v1/messages`,
+ * so the base URL must be the bare API host (no `/v1` suffix).
+ *
+ * `ANTHROPIC_AUTH_TOKEN` (not `ANTHROPIC_API_KEY`) is required: Sail
+ * authenticates with `Authorization: Bearer` and rejects the Anthropic
+ * `x-api-key` header that `ANTHROPIC_API_KEY` would select.
+ */
+/**
+ * Capabilities declared for aliases pinned to the DEFAULT (GLM) model.
+ * Claude Code enables effort/thinking by matching the model ID against known
+ * patterns; a custom ID like `zai-org/GLM-5.2-FP8` matches none, so those
+ * features are silently DISABLED — `/effort` selections and
+ * `CLAUDE_CODE_EFFORT_LEVEL` get dropped before the request. Declaring
+ * `_SUPPORTED_CAPABILITIES` is the documented primary fix for pinned custom
+ * models. GLM-5.2 is a reasoning model and Sail maps Anthropic `thinking` →
+ * reasoning and `output_config.effort` → reasoning effort, so both are real.
+ * Deliberately conservative: no xhigh/max effort or adaptive/interleaved
+ * thinking claims until validated end-to-end.
+ */
+export const DEFAULT_MODEL_CAPABILITIES = "effort,thinking";
+
+export function buildClaudeEnv({ apiUrl, apiKey, model, backgroundModel }) {
+  const base = String(apiUrl ?? "").replace(/\/+$/, "");
+  const main = model || DEFAULT_MODEL;
+  const background = backgroundModel || main;
+  // Only aliases pinned to the KNOWN default model get a capabilities
+  // declaration — for a user-overridden --model/--background-model we can't
+  // know what the model supports, and `_SUPPORTED_CAPABILITIES` disables
+  // everything unlisted, so guessing wrong would be worse than Claude Code's
+  // built-in detection.
+  const capabilities = {};
+  for (const [alias, m] of [
+    ["OPUS", main],
+    ["SONNET", main],
+    ["HAIKU", background],
+    ["FABLE", main],
+  ]) {
+    if (m === DEFAULT_MODEL) {
+      capabilities[`ANTHROPIC_DEFAULT_${alias}_MODEL_SUPPORTED_CAPABILITIES`] =
+        DEFAULT_MODEL_CAPABILITIES;
+    }
+  }
+  return {
+    ANTHROPIC_BASE_URL: base,
+    ANTHROPIC_AUTH_TOKEN: apiKey,
+    // Pin the startup model. Without this, a saved /model choice (persisted
+    // into settings.json) or the model restored by --resume wins startup
+    // resolution, and a `fable` alias or full claude-* ID would reach Sail
+    // unmapped. Precedence keeps mid-session /model switching working:
+    // /model (session) > --model > ANTHROPIC_MODEL > settings model field.
+    ANTHROPIC_MODEL: main,
+    ANTHROPIC_DEFAULT_OPUS_MODEL: main,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: main,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: background,
+    ANTHROPIC_DEFAULT_FABLE_MODEL: main,
+    // Declare effort/thinking for aliases pinned to the default GLM model
+    // (see DEFAULT_MODEL_CAPABILITIES). Custom overrides get no declaration.
+    ...capabilities,
+    // Pin subagents to the main Sail model. CLAUDE_CODE_SUBAGENT_MODEL is the
+    // highest-priority subagent model source — it outranks a subagent's
+    // frontmatter `model:` and the alias remaps above — so a value inherited
+    // from the user's shell or a settings file (e.g. a stale `claude-sonnet-*`
+    // from a prior Anthropic/Bedrock setup) would otherwise make every
+    // delegated subagent request an unmapped model from Sail and fail. Setting
+    // it to the resolved main model neutralizes that inherited value on every
+    // surface (this rides the exec env and the highest-precedence --settings
+    // layer, and setup persists it) and also routes custom subagents whose
+    // frontmatter pins a full claude-* ID onto GLM instead of failing.
+    // Trade-off: per-subagent frontmatter tiers and --background-model don't
+    // apply to subagents under sail-code; they all run on the main model.
+    CLAUDE_CODE_SUBAGENT_MODEL: main,
+    // Sail turn times can exceed Claude Code's default request timeout.
+    API_TIMEOUT_MS: "3000000",
+    // Disable the separate 5-minute stream-idle watchdog. It's independent of
+    // API_TIMEOUT_MS (that's the whole-request cap; this fires when no bytes
+    // arrive for 5 min) and is ACTIVE by default on custom `ANTHROPIC_BASE_URL`
+    // connections like Sail. A throughput-optimized Sail turn can queue longer
+    // than 5 min before streaming (standard/flex completion windows), so
+    // without this it would be aborted mid-turn despite the raised request
+    // timeout. "0" disables it (documented for slow gateways).
+    API_FORCE_IDLE_TIMEOUT: "0",
+    // MCP tool search needs server-side tool_reference expansion, which Sail
+    // does not implement; force it off so Claude Code loads MCP tool schemas
+    // upfront (those Sail passes through). Explicit "false" (vs unset) also
+    // lets setup/revert clean up any previously persisted value.
+    ENABLE_TOOL_SEARCH: "false",
+  };
+}
+
+/** The env keys this tool owns in settings.json — used by setup/revert. */
+export const OWNED_ENV_KEYS = Object.keys(
+  buildClaudeEnv({ apiUrl: "", apiKey: "" }),
+);
+
+/**
+ * Provider-selection env vars that outrank ANTHROPIC_AUTH_TOKEN in Claude
+ * Code's auth precedence. If the user's shell has any of these from another
+ * Claude Code setup, an unscrubbed child would route to Bedrock / Vertex /
+ * Foundry / Mantle / Claude-Platform-on-AWS instead of Sail. `run` strips them
+ * from the spawned env. We strip only the selector, not the ancillary provider
+ * vars (`ANTHROPIC_AWS_*`, `AWS_REGION`, cloud creds): those are inert once the
+ * selector is gone, and some are too broad to safely drop from the child.
+ */
+export const CONFLICTING_PROVIDER_VARS = [
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "CLAUDE_CODE_USE_FOUNDRY",
+  "CLAUDE_CODE_USE_MANTLE",
+  "CLAUDE_CODE_USE_ANTHROPIC_AWS",
+];
+
+/**
+ * Env vars that inject extra HTTP headers into every Anthropic request.
+ * Claude Code merges `ANTHROPIC_CUSTOM_HEADERS` onto outgoing requests, so a
+ * value left over from another gateway setup (e.g. an `x-portkey-api-key`)
+ * would be sent to Sail once we overlay `ANTHROPIC_BASE_URL` — leaking a
+ * stale third-party secret and possibly mutating the Sail request. We only
+ * own the base URL and token, not arbitrary headers, so strip these from the
+ * spawned env alongside the provider selectors.
+ */
+export const HEADER_INJECTION_VARS = ["ANTHROPIC_CUSTOM_HEADERS"];
+
+/**
+ * Companion vars that customize a pinned alias model's display and
+ * capabilities. They are keyed to the ALIAS, not the concrete model id, so
+ * once we repoint `ANTHROPIC_DEFAULT_<ALIAS>_MODEL` to GLM a value inherited
+ * from another setup applies to GLM. `_SUPPORTED_CAPABILITIES` is the
+ * dangerous one: when set it enables only the listed capabilities and
+ * *disables the rest* for that pinned model, so a stale value can hide
+ * behavior GLM supports (or advertise ones it doesn't); `_NAME`/`_DESCRIPTION`
+ * just mislabel it in the picker. We scrub INHERITED values of these from the
+ * spawned child env (`run`) and the persisted settings (`setup`) — our own
+ * env block then declares `_SUPPORTED_CAPABILITIES` for aliases pinned to the
+ * default GLM model (see DEFAULT_MODEL_CAPABILITIES), and that declaration
+ * also rides the temp `--settings` layer, which outranks a companion var
+ * living in a settings file. For user-overridden models nothing is declared
+ * (built-in detection), and NAME/DESCRIPTION are never set. Empty string is
+ * NOT a documented "unset" for these — for `_SUPPORTED_CAPABILITIES` it could
+ * read as "no capabilities", worse than leaving it — so inherited values are
+ * deleted, never emptied. Residual gap: with a custom --model, a companion
+ * var in a *settings file* during `run` can't be cleared by our layers.
+ */
+export const MODEL_ALIAS_COMPANION_VARS = [
+  "OPUS",
+  "SONNET",
+  "HAIKU",
+  "FABLE",
+].flatMap((alias) => [
+  `ANTHROPIC_DEFAULT_${alias}_MODEL_NAME`,
+  `ANTHROPIC_DEFAULT_${alias}_MODEL_DESCRIPTION`,
+  `ANTHROPIC_DEFAULT_${alias}_MODEL_SUPPORTED_CAPABILITIES`,
+]);