@sailresearch/code 0.1.1 → 0.1.2

package/README.md

@@ -16,6 +16,21 @@ persist nothing.
 
 Claude Code itself must be installed (`npm install -g @anthropic-ai/claude-code`).
 
+## Trusted workspaces (no permission prompts)
+
+For trusted repos, containers, or VMs where you want long-running agent tasks
+without clicking through Claude Code permission prompts:
+
+```sh
+npx @sailresearch/code --trusted
+```
+
+`--trusted` launches Claude Code in bypass-permissions mode. This avoids Claude
+Code's auto-mode safety classifier path, so it also avoids failures like
+`safety classifier temporarily unavailable` when Sail model requests are
+otherwise healthy. Use it only where you are comfortable letting Claude Code run
+tools without prompting.
+
 ## Persistent setup / VS Code
 
 To make `claude` route to Sail without the launcher (for VS Code, or a bare
@@ -49,18 +64,25 @@ Notes:
 ## Choosing models
 
 ```sh
-npx @sailresearch/code --model zai-org/GLM-5.2-FP8 --background-model openai/gpt-oss-120b
+npx @sailresearch/code --model moonshotai/Kimi-K2.6
 ```
 
-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).
+GLM-5.2 is the default. The `/model` picker also exposes Kimi-K2.6 via Sail.
+Use `--model` with any model from the [Sail catalog](https://docs.sailresearch.com/models)
+to launch directly into that model.
+
+The launcher and `setup` write Claude Code's `availableModels` setting so fresh
+local sessions show only Sail-backed picker rows. Claude Code concatenates
+non-managed `availableModels` from user, project, local, and temporary settings,
+though, so rows from another settings scope may still appear. Rows that name
+non-Sail models (for example `claude-*` IDs) still route to Sail and will not be
+served there; remove them from the other settings file or enforce the picker
+with managed settings. `sail-code` prints a warning when it can see those extra
+rows.
 
 The launcher does **not** force a completion window: Claude Code has no flag
 for adding request metadata, so requests go out without `completion_window` and
-Sail's API default applies. For GLM-5.2 that is the **standard** tier
-(`$0.50` input / `$2.50` output per 1M tokens) because standard pricing is
-available. See [Completion windows](https://docs.sailresearch.com/completion-windows)
+Sail's API default applies. See [Completion windows](https://docs.sailresearch.com/completion-windows)
 for the latency/price tradeoff and how to opt into another tier.
 
 ## Commit attribution

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailresearch/code",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Run Claude Code on GLM-5.2 via Sail — one command, no Anthropic account.",
   "license": "MIT",
   "author": "Sail Research",

package/src/cli.js

@@ -15,6 +15,12 @@ import { resolveCredentials, run } from "./run.js";
 import { revert, setup } from "./setup.js";
 
 const require = createRequire(import.meta.url);
+const TRUSTED_CLAUDE_ARGS = ["--permission-mode", "bypassPermissions"];
+const CLAUDE_PERMISSION_FLAGS = [
+  "--permission-mode",
+  "--dangerously-skip-permissions",
+  "--allow-dangerously-skip-permissions",
+];
 
 const HELP = `sail-code — run Claude Code on GLM-5.2 via Sail (no Anthropic account)
 
@@ -29,6 +35,7 @@ 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(" | ")}
+  --trusted                Skip Claude Code permission prompts in trusted workspaces
   -h, --help               Show this help
   -v, --version            Show the version
 
@@ -44,6 +51,7 @@ export function parseArgs(argv) {
     modeFlag: undefined,
     scope: undefined,
     revert: false,
+    trusted: false,
     help: false,
     version: false,
     claudeArgs: [],
@@ -85,6 +93,7 @@ export function parseArgs(argv) {
     } else if (arg === "--user") parsed.scope = "user";
     else if (arg === "--project") parsed.scope = "project";
     else if (arg === "--revert") parsed.revert = true;
+    else if (arg === "--trusted") parsed.trusted = true;
     else if (arg === "-h" || arg === "--help") parsed.help = true;
     else if (arg === "-v" || arg === "--version") parsed.version = true;
     else
@@ -99,6 +108,22 @@ export function parseArgs(argv) {
   if (parsed.scope && parsed.command !== "setup") {
     throw new Error(`--${parsed.scope} only applies to setup`);
   }
+  if (parsed.trusted && parsed.command !== "run") {
+    throw new Error("--trusted only applies when launching claude");
+  }
+  if (parsed.trusted) {
+    const conflict = parsed.claudeArgs.find((arg) =>
+      CLAUDE_PERMISSION_FLAGS.some(
+        (flag) => arg === flag || arg.startsWith(`${flag}=`),
+      ),
+    );
+    if (conflict) {
+      throw new Error(
+        `--trusted conflicts with Claude permission flag "${conflict}" after --`,
+      );
+    }
+    parsed.claudeArgs = [...TRUSTED_CLAUDE_ARGS, ...parsed.claudeArgs];
+  }
   return parsed;
 }
 
@@ -159,6 +184,7 @@ export async function main() {
         modeFlag: args.modeFlag,
         model: args.model,
         backgroundModel: args.backgroundModel,
+        trusted: args.trusted,
         claudeArgs: args.claudeArgs,
       });
   }

package/src/constants.js

@@ -8,6 +8,7 @@
  */
 
 export const DEFAULT_MODEL = "zai-org/GLM-5.2-FP8";
+export const KIMI_MODEL = "moonshotai/Kimi-K2.6";
 
 /** Public API targets by mode name, mirroring the Sail CLI's mode map. */
 export const MODE_API_URLS = {
@@ -58,6 +59,53 @@ export const DEFAULT_MODEL_CAPABILITIES = "effort,thinking";
 export const DEFAULT_MODEL_NAME = "GLM-5.2 via Sail";
 export const DEFAULT_MODEL_DESCRIPTION =
   "Sail standard pricing: $0.50 input / $2.50 output per 1M tokens";
+export const KIMI_MODEL_NAME = "Kimi-K2.6 via Sail";
+export const KIMI_MODEL_DESCRIPTION =
+  "Sail pricing: priority $0.45 input / $3.00 output, ASAP $1.00 input / $4.00 output per 1M tokens";
+export const KIMI_MODEL_CAPABILITIES = "effort,thinking,xhigh_effort";
+
+export function buildModelPickerSettings(
+  mainModel = DEFAULT_MODEL,
+  backgroundModel = mainModel,
+) {
+  return {
+    availableModels: [
+      ...new Set([
+        DEFAULT_MODEL,
+        mainModel || DEFAULT_MODEL,
+        backgroundModel || mainModel || DEFAULT_MODEL,
+        KIMI_MODEL,
+      ]),
+    ],
+    enforceAvailableModels: true,
+  };
+}
+
+export function extraAvailableModels(settings, mainModel, backgroundModel) {
+  if (!Array.isArray(settings?.availableModels)) return [];
+  const allowed = new Set(
+    buildModelPickerSettings(mainModel, backgroundModel).availableModels,
+  );
+  return [
+    ...new Set(
+      settings.availableModels.filter(
+        (model) => typeof model === "string" && !allowed.has(model),
+      ),
+    ),
+  ];
+}
+
+export function formatExtraAvailableModelsWarning(source, extras) {
+  if (extras.length === 0) return null;
+  return (
+    `Warning: ${source} already allows model(s) outside Sail's picker list: ` +
+    `${extras.join(", ")}. Claude Code concatenates non-managed ` +
+    "`availableModels` across user/project/local settings, so those rows " +
+    "may remain selectable. Rows that name non-Sail models (for example " +
+    "`claude-*` IDs) still route to Sail and will not be served there. Remove " +
+    "them from that settings file or enforce the picker with managed settings."
+  );
+}
 
 export function buildClaudeEnv({ apiUrl, apiKey, model, backgroundModel }) {
   const base = String(apiUrl ?? "").replace(/\/+$/, "");
@@ -97,6 +145,14 @@ export function buildClaudeEnv({ apiUrl, apiKey, model, backgroundModel }) {
     ANTHROPIC_DEFAULT_SONNET_MODEL: main,
     ANTHROPIC_DEFAULT_HAIKU_MODEL: background,
     ANTHROPIC_DEFAULT_FABLE_MODEL: main,
+    // Add a single explicit Kimi row to the /model picker. Claude Code supports
+    // only one custom option this way; keep aliases pinned separately above so
+    // built-in Claude IDs cannot leak through to Sail.
+    ANTHROPIC_CUSTOM_MODEL_OPTION: KIMI_MODEL,
+    ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: KIMI_MODEL_NAME,
+    ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION: KIMI_MODEL_DESCRIPTION,
+    ANTHROPIC_CUSTOM_MODEL_OPTION_SUPPORTED_CAPABILITIES:
+      KIMI_MODEL_CAPABILITIES,
     // Declare effort/thinking and friendly display metadata for aliases pinned
     // to the default GLM model (see DEFAULT_MODEL_CAPABILITIES / _NAME /
     // _DESCRIPTION). Custom overrides get no declaration.

package/src/run.js

@@ -14,6 +14,9 @@ import {
   HEADER_INJECTION_VARS,
   MODEL_ALIAS_COMPANION_VARS,
   buildClaudeEnv,
+  buildModelPickerSettings,
+  extraAvailableModels,
+  formatExtraAvailableModelsWarning,
 } from "./constants.js";
 import {
   loadAuthKey,
@@ -203,6 +206,72 @@ export function buildSettingsEnv(sailEnv) {
   return settingsEnv;
 }
 
+export function buildRuntimeSettings(sailEnv) {
+  return {
+    env: buildSettingsEnv(sailEnv),
+    ...buildModelPickerSettings(
+      sailEnv.ANTHROPIC_MODEL,
+      sailEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL,
+    ),
+  };
+}
+
+function userClaudeSettingsPath() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR?.trim();
+  return path.join(
+    configDir || path.join(os.homedir(), ".claude"),
+    "settings.json",
+  );
+}
+
+function projectClaudeSettingsPaths() {
+  const claudeDir = path.join(process.cwd(), ".claude");
+  return [
+    path.join(claudeDir, "settings.json"),
+    path.join(claudeDir, "settings.local.json"),
+  ];
+}
+
+function readJSONFileBestEffort(filePath) {
+  try {
+    const text = fs.readFileSync(filePath, "utf8").replace(/^\uFEFF/, "");
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    // Runtime picker warnings are advisory; malformed or missing settings files
+    // should not block launching Claude Code.
+  }
+  return null;
+}
+
+export function lowerScopeAvailableModelWarnings(sailEnv, paths) {
+  const mainModel = sailEnv.ANTHROPIC_MODEL;
+  const backgroundModel = sailEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+  return paths
+    .map((filePath) => {
+      const settings = readJSONFileBestEffort(filePath);
+      if (!settings) return null;
+      const extras = extraAvailableModels(settings, mainModel, backgroundModel);
+      return formatExtraAvailableModelsWarning(filePath, extras);
+    })
+    .filter(Boolean);
+}
+
+export function runtimeAvailableModelWarnings(sailEnv) {
+  return lowerScopeAvailableModelWarnings(sailEnv, [
+    userClaudeSettingsPath(),
+    ...projectClaudeSettingsPaths(),
+  ]);
+}
+
+function warnRuntimeAvailableModels(sailEnv) {
+  for (const warning of runtimeAvailableModelWarnings(sailEnv)) {
+    console.error(warning);
+  }
+}
+
 /**
  * Spawn `claude` with the Sail env overlaid; resolves to its exit code.
  *
@@ -226,6 +295,7 @@ export async function runClaude({ env, claudeArgs, spawn = spawnClaude }) {
         "override it.",
     );
   } else {
+    warnRuntimeAvailableModels(env);
     settingsFile = path.join(
       os.tmpdir(),
       `sail-code-${crypto.randomBytes(8).toString("hex")}.json`,
@@ -233,7 +303,7 @@ export async function runClaude({ env, claudeArgs, spawn = spawnClaude }) {
     try {
       fs.writeFileSync(
         settingsFile,
-        JSON.stringify({ env: buildSettingsEnv(env) }, null, 2),
+        JSON.stringify(buildRuntimeSettings(env), null, 2),
         { mode: 0o600 },
       );
     } catch (err) {
@@ -317,9 +387,20 @@ export async function runClaude({ env, claudeArgs, spawn = spawnClaude }) {
 }
 
 /** The `run` command. */
-export async function run({ modeFlag, model, backgroundModel, claudeArgs }) {
+export async function run({
+  modeFlag,
+  model,
+  backgroundModel,
+  trusted,
+  claudeArgs,
+}) {
   const { apiKey, apiUrl } = await resolveCredentials({ modeFlag });
   const env = buildClaudeEnv({ apiUrl, apiKey, model, backgroundModel });
+  if (trusted) {
+    console.error(
+      "Trusted mode: skipping Claude Code permission prompts. Use only in trusted workspaces.",
+    );
+  }
   console.error(
     `Running Claude Code on ${env.ANTHROPIC_MODEL} via Sail (${apiUrl}) — ` +
       "no Anthropic account used.",

package/src/setup.js

@@ -23,6 +23,9 @@ import {
   MODEL_ALIAS_COMPANION_VARS,
   OWNED_ENV_KEYS,
   buildClaudeEnv,
+  buildModelPickerSettings,
+  extraAvailableModels,
+  formatExtraAvailableModelsWarning,
 } from "./constants.js";
 import { atomicWrite } from "./credentials.js";
 import { resolveCredentials } from "./run.js";
@@ -60,6 +63,7 @@ export const SAIL_PR_ATTRIBUTION = "";
  * to disable PR attribution) and indistinguishable from what we write.
  */
 export const OWNED_ATTRIBUTION_KEYS = ["commit", "pr"];
+export const MANAGED_MODEL_PICKER_ENV_KEY = "SAIL_CODE_MANAGED_MODEL_PICKER";
 
 /**
  * Merge the Sail commit attribution into a settings object's top-level
@@ -77,6 +81,129 @@ export function mergeAttribution(settings, mainModel) {
   };
 }
 
+export function mergeModelPickerSettings(settings, mainModel, backgroundModel) {
+  const pickerSettings = buildModelPickerSettings(mainModel, backgroundModel);
+  Object.assign(settings, pickerSettings);
+  // Record the exact non-secret picker list setup wrote. If the byte backup is
+  // lost, fallback revert can then strip custom-model picker settings without
+  // guessing whether an arbitrary row was Sail-generated or user-managed.
+  settings.env = {
+    ...(settings.env ?? {}),
+    [MANAGED_MODEL_PICKER_ENV_KEY]: JSON.stringify(pickerSettings),
+  };
+}
+
+function sameStringArray(a, b) {
+  return (
+    Array.isArray(a) &&
+    Array.isArray(b) &&
+    a.length === b.length &&
+    a.every((value, i) => value === b[i])
+  );
+}
+
+function sameModelPickerSettings(settings, pickerSettings) {
+  return (
+    pickerSettings?.enforceAvailableModels === true &&
+    settings?.enforceAvailableModels === true &&
+    sameStringArray(settings.availableModels, pickerSettings.availableModels)
+  );
+}
+
+function managedModelPickerSettings(settings) {
+  const encoded = settings?.env?.[MANAGED_MODEL_PICKER_ENV_KEY];
+  if (typeof encoded !== "string") return null;
+  try {
+    const parsed = JSON.parse(encoded);
+    if (
+      parsed &&
+      typeof parsed === "object" &&
+      !Array.isArray(parsed) &&
+      parsed.enforceAvailableModels === true &&
+      Array.isArray(parsed.availableModels) &&
+      parsed.availableModels.every((model) => typeof model === "string")
+    ) {
+      return parsed;
+    }
+  } catch {
+    // Malformed marker: ignore it and fall back to the exact default matcher.
+  }
+  return null;
+}
+
+export function isSailGeneratedModelPickerSettings(settings) {
+  const managedPicker = managedModelPickerSettings(settings);
+  if (managedPicker) {
+    return sameModelPickerSettings(settings, managedPicker);
+  }
+  return sameModelPickerSettings(
+    settings,
+    buildModelPickerSettings(DEFAULT_MODEL),
+  );
+}
+
+function readSettingsIfPresent(filePath) {
+  try {
+    return readSettings(filePath);
+  } catch {
+    // Best-effort sibling-scope inspection for warnings only. The target
+    // settings file is parsed strictly by setup(); a sibling project
+    // settings.json should not block writing the local Sail file.
+    return { settings: {}, existed: false };
+  }
+}
+
+function projectSharedSettingsPath(localSettingsPath) {
+  return path.join(path.dirname(localSettingsPath), "settings.json");
+}
+
+function currentProjectSettingsPaths() {
+  const claudeDir = path.join(process.cwd(), ".claude");
+  return [
+    path.join(claudeDir, "settings.json"),
+    path.join(claudeDir, "settings.local.json"),
+  ];
+}
+
+export function extraAvailableModelWarningSources({
+  scope,
+  filePath,
+  settings,
+  mainModel,
+  backgroundModel,
+}) {
+  const background = backgroundModel || mainModel;
+  const seenPaths = new Set();
+  const sources = [];
+
+  const addSource = (source, sourceSettings) => {
+    const resolved = path.resolve(source);
+    if (seenPaths.has(resolved)) return;
+    seenPaths.add(resolved);
+    const extras = extraAvailableModels(sourceSettings, mainModel, background);
+    if (extras.length > 0) sources.push({ source, extras });
+  };
+
+  addSource(filePath, settings);
+
+  const extraPaths =
+    scope === "project"
+      ? [projectSharedSettingsPath(filePath)]
+      : currentProjectSettingsPaths();
+
+  for (const source of extraPaths) {
+    const { settings: sourceSettings, existed } = readSettingsIfPresent(source);
+    if (existed) addSource(source, sourceSettings);
+  }
+
+  return sources;
+}
+
+function warnExtraAvailableModels(source, extras) {
+  const warning = formatExtraAvailableModelsWarning(source, extras);
+  if (warning) console.error(warning);
+}
+
 /**
  * Backup sentinel recorded when the settings file did NOT exist before the
  * first `setup`. A re-run then finds a backup already present (so it won't
@@ -393,6 +520,13 @@ export async function setup({
   const mainModel = model || DEFAULT_MODEL;
 
   const { settings, existed } = readSettings(filePath);
+  const extraModelWarningSources = extraAvailableModelWarningSources({
+    scope,
+    filePath,
+    settings,
+    mainModel,
+    backgroundModel: backgroundModel || mainModel,
+  });
   // Create the settings dir before writing the backup/sentinel. On a fresh
   // machine (no ~/.claude, or a brand-new CLAUDE_CONFIG_DIR) the sentinel write
   // below would otherwise ENOENT — after the key was already minted — since
@@ -425,6 +559,7 @@ export async function setup({
 
   const removedKeys = mergeSailEnv(settings, env, { scope });
   mergeAttribution(settings, mainModel);
+  mergeModelPickerSettings(settings, mainModel, backgroundModel || mainModel);
   writeSettings(filePath, settings, { containsSecret: true });
 
   if (removedKeys.length > 0) {
@@ -452,6 +587,9 @@ export async function setup({
         "them in your shell profile.",
     );
   }
+  for (const { source, extras } of extraModelWarningSources) {
+    warnExtraAvailableModels(source, extras);
+  }
 
   const revertCmd =
     "sail-code setup --revert" + (scope === "project" ? " --project" : "");
@@ -522,6 +660,7 @@ export function revert({ scope = "user" }) {
     console.error(`Nothing to revert: ${filePath} does not exist.`);
     return 0;
   }
+  const shouldStripModelPicker = isSailGeneratedModelPickerSettings(settings);
   if (settings.env && typeof settings.env === "object") {
     for (const key of OWNED_ENV_KEYS) delete settings.env[key];
     // Clear the falsy overrides a project-scope setup wrote, but only when
@@ -532,6 +671,7 @@ export function revert({ scope = "user" }) {
     ]) {
       if (settings.env[key] === "") delete settings.env[key];
     }
+    delete settings.env[MANAGED_MODEL_PICKER_ENV_KEY];
     if (Object.keys(settings.env).length === 0) delete settings.env;
   }
   // Remove the Sail commit attribution, but only where the value still matches
@@ -561,6 +701,10 @@ export function revert({ scope = "user" }) {
       delete settings.attribution;
     }
   }
+  if (shouldStripModelPicker) {
+    delete settings.availableModels;
+    delete settings.enforceAvailableModels;
+  }
   writeSettings(filePath, settings);
   console.error(
     `Removed Sail routing keys from ${filePath} (no backup was present).`,