@4yi/cli 0.1.10 → 0.2.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 4YI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,42 +1,67 @@
-# 4YI CLI
+# @4yi/cli
 
-4YI CLI signs in through the 4YI web app and launches OpenCode with 4YI model routing.
+The 4YI CLI signs in through the 4YI web app and securely connects supported local coding tools to 4YI model routing.
 
 ## Install
 
-Temporary dev environment:
-
 ```bash
 npm install -g @4yi/cli
 ```
 
-Production environment:
-
-```bash
-npm install -g @4yi/cli
-```
+Invited beta testers can opt in with `npm install -g @4yi/cli@beta`. The beta channel never replaces the normal `latest` installation automatically.
 
-Both packages install the `4yi` command. The dev package points at `https://xclaw-dev.bieases.com`; the production package points at `https://app.4yi.ai`.
+Node.js 20 or newer is required.
 
-## Commands
+## Quick start
 
 ```bash
 4yi login
 4yi whoami
-4yi code
-4yi connect claude
+4yi connect codex --dry-run
 4yi connect codex
-4yi status all
-4yi restore all
+4yi status codex
+```
+
+Supported commands:
+
+```text
+4yi login
+4yi whoami
+4yi logout
+4yi code [--model MODEL]
+4yi connect <claude|codex|all> [--scope user|project|both] [--dry-run]
+4yi status [claude|codex|all]
+4yi restore <claude|codex|all>
+4yi doctor [--json]
 ```
 
-`4yi code` installs OpenCode under `~/.4yi/vendor/opencode`, writes an OpenCode config under `~/.4yi/opencode/opencode.json`, and launches OpenCode with a 4YI provider.
+`4yi code` installs an isolated, version-pinned OpenCode runtime under `~/.4yi/vendor/opencode`, generates a 4YI-only configuration, and launches it without modifying the user's normal OpenCode state.
 
-`4yi connect claude` and `4yi connect codex` first check for the corresponding local CLI. If it is missing, 4YI asks before installing the official npm package. Pass `--yes` to approve that CLI installation non-interactively. Desktop apps are detected and reported, but are never installed automatically.
+Connection commands create protected backups before changing Claude Code or Codex configuration. Use `--dry-run` to inspect target files without changing them and `4yi restore all` to restore the latest protected backup set.
 
-For local development:
+## Authentication and local data
+
+`4yi login` uses browser-based device authorization. On Unix-like systems, the CLI stores its local session in `~/.4yi/config.json` with owner-only permissions. Do not share this file or attach it to a public issue.
+
+See the repository [security policy](https://github.com/4yi-ai/4yi-ai-bridge/blob/main/SECURITY.md) before reporting a vulnerability.
+
+## Development
+
+From the repository root:
+
+```bash
+npm install
+npm test
+npm run smoke:cli
+npm run pack:dry
+```
+
+For local service development, set `FOURYI_BASE_URL` explicitly:
 
 ```bash
 FOURYI_BASE_URL=http://localhost:3000 node packages/cli/bin/4yi.mjs login
-node packages/cli/bin/4yi.mjs code
 ```
+
+## License
+
+The CLI source in this package is licensed under the [MIT License](LICENSE). The hosted 4YI service remains a separate commercial service.

package/bin/4yi.mjs

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
+import fs from "node:fs";
 import { login, loadSession, clearSession } from "../src/auth.mjs";
 import { runCode } from "../src/opencode.mjs";
-import { connect, connectionStatus, prepareConnectionTools, restoreConnection } from "../src/connect.mjs";
+import { connect, connectionPlan, connectionStatus, prepareConnectionTools, restoreConnection } from "../src/connect.mjs";
+import { runDoctor } from "../src/doctor.mjs";
 
 const command = process.argv[2] || "help";
 
 if (command === "help" || command === "--help" || command === "-h") {
-  console.log("Usage: 4yi <login|whoami|logout|code|connect|status|restore>");
+  console.log("Usage: 4yi <login|whoami|logout|code|connect|status|restore|doctor>");
   console.log("  4yi code            launch OpenCode; switch models live with Tab / /models");
   console.log("  4yi code --model X  pin model X as the default for future sessions");
   console.log("  4yi connect <claude|codex|all>  connect existing coding tools to 4YI");
   console.log("    --yes                         install a missing CLI without prompting");
+  console.log("    --dry-run                     show affected files without changing them");
   console.log("  4yi status [claude|codex|all]   inspect the current connection");
   console.log("  4yi restore <claude|codex|all>  restore the latest protected config");
+  console.log("  4yi doctor [--json]             inspect local CLI readiness safely");
   process.exit(0);
 }
 
@@ -24,6 +28,7 @@ function parseConnectArgs(args) {
   let codexBaseUrl;
   let skipCheck = false;
   let autoInstall = false;
+  let dryRun = false;
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
     if (!arg.startsWith("-") && i === 0) target = arg;
@@ -33,9 +38,10 @@ function parseConnectArgs(args) {
     else if (arg === "--codex-base-url") codexBaseUrl = args[++i];
     else if (arg === "--skip-codex-responses-check") skipCheck = true;
     else if (arg === "--yes" || arg === "-y") autoInstall = true;
+    else if (arg === "--dry-run") dryRun = true;
     else throw new Error(`Unknown option: ${arg}`);
   }
-  return { target, scope, platformUrl, claudeBaseUrl, codexBaseUrl, skipCheck, autoInstall };
+  return { target, scope, platformUrl, claudeBaseUrl, codexBaseUrl, skipCheck, autoInstall, dryRun };
 }
 
 /** Split out `--model <id>` / `--model=<id>` / `-m <id>`; the rest pass through to OpenCode. */
@@ -57,8 +63,8 @@ function parseCodeArgs(args) {
 }
 
 if (command === "--version" || command === "-v") {
-  const pkg = await import("../package.json", { with: { type: "json" } });
-  console.log(pkg.default.version);
+  const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+  console.log(pkg.version);
   process.exit(0);
 }
 
@@ -79,6 +85,14 @@ try {
     process.exit(Number(code || 0));
   } else if (command === "connect") {
     const connectArgs = parseConnectArgs(process.argv.slice(3));
+    if (connectArgs.dryRun) {
+      const plan = connectionPlan(connectArgs);
+      console.log("Dry run — no files will be changed:");
+      for (const item of plan) {
+        console.log(`  ${item.target}: ${item.action} ${item.file} (${item.exists ? "existing" : "new"})`);
+      }
+      process.exit(0);
+    }
     await prepareConnectionTools(connectArgs);
     let session = loadSession();
     if (!session.token) {
@@ -92,6 +106,12 @@ try {
   } else if (command === "restore") {
     const { target } = parseConnectArgs(process.argv.slice(3));
     restoreConnection({ target });
+  } else if (command === "doctor") {
+    const args = process.argv.slice(3);
+    const unknown = args.filter((arg) => arg !== "--json");
+    if (unknown.length > 0) throw new Error(`Unknown option: ${unknown[0]}`);
+    const result = runDoctor({ json: args.includes("--json") });
+    if (!result.ok) process.exitCode = 1;
   } else {
     console.error(`Unknown command: ${command}`);
     process.exit(1);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@4yi/cli",
-  "version": "0.1.10",
-  "description": "4YI command-line launcher for OAuth login and OpenCode runtime",
+  "version": "0.2.0-beta.1",
+  "description": "Securely connect Claude Code, Codex, and OpenCode to 4YI AI Bridge",
   "type": "module",
   "bin": {
     "4yi": "bin/4yi.mjs"
@@ -9,20 +9,39 @@
   "files": [
     "bin",
     "src",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "test": "node --test",
-    "pack:dry": "npm pack --dry-run",
-    "stage:dev": "node scripts/stage-package.mjs dev",
-    "stage:prod": "node scripts/stage-package.mjs prod",
-    "pack:dev": "node scripts/stage-package.mjs dev --pack",
-    "pack:prod": "node scripts/stage-package.mjs prod --pack",
-    "publish:dev": "node scripts/stage-package.mjs dev --publish",
-    "publish:prod": "node scripts/stage-package.mjs prod --publish"
+    "smoke": "node bin/4yi.mjs --version && node bin/4yi.mjs --help",
+    "pack:dry": "npm pack --dry-run"
   },
   "engines": {
     "node": ">=20.0.0"
   },
-  "license": "UNLICENSED"
+  "keywords": [
+    "4yi",
+    "ai",
+    "llm",
+    "cli",
+    "claude-code",
+    "codex",
+    "opencode",
+    "openai-compatible"
+  ],
+  "homepage": "https://github.com/4yi-ai/4yi-ai-bridge#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/4yi-ai/4yi-ai-bridge.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/4yi-ai/4yi-ai-bridge/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "license": "MIT"
 }

package/src/auth.mjs

@@ -13,16 +13,17 @@ export function saveSession(session, home = os.homedir()) {
 
 export function clearSession(home = os.homedir()) {
   const current = readConfig(home);
-  writeConfig({ baseUrl: current.baseUrl }, home);
+  const { token: _token, org: _org, user: _user, ...localPreferences } = current;
+  writeConfig(localPreferences, home);
 }
 
 export function openBrowser(url) {
   const command = process.platform === "darwin"
     ? "open"
     : process.platform === "win32"
-      ? "cmd"
+      ? "rundll32"
       : "xdg-open";
-  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
   const child = spawn(command, args, { stdio: "ignore", detached: true });
   child.unref();
 }

package/src/config.mjs

@@ -3,17 +3,7 @@ import os from "node:os";
 import path from "node:path";
 
 export const PACKAGE_NAME = "@4yi/cli";
-
-const PACKAGE_BASE_URLS = {
-  "@4yi-dev/cli": "https://xclaw-dev.bieases.com",
-  "@4yi/cli": "https://app.4yi.ai",
-};
-
-export function defaultBaseUrlForPackage(packageName = PACKAGE_NAME) {
-  return PACKAGE_BASE_URLS[packageName] || PACKAGE_BASE_URLS["@4yi/cli"];
-}
-
-export const DEFAULT_BASE_URL = defaultBaseUrlForPackage(PACKAGE_NAME);
+export const DEFAULT_BASE_URL = "https://app.4yi.ai";
 
 export function normalizeBaseUrl(value) {
   return String(value || DEFAULT_BASE_URL).replace(/\/+$/, "");
@@ -48,7 +38,11 @@ export function readConfig(home = os.homedir()) {
 export function writeConfig(config, home = os.homedir()) {
   const paths = pathsForHome(home);
   ensureDir(paths.homeDir);
-  fs.writeFileSync(paths.configFile, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+  try { fs.chmodSync(paths.homeDir, 0o700); } catch { /* Windows may ignore POSIX modes. */ }
+  const temporary = path.join(paths.homeDir, `.config.${process.pid}.${Date.now()}.tmp`);
+  fs.writeFileSync(temporary, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporary, paths.configFile);
+  try { fs.chmodSync(paths.configFile, 0o600); } catch { /* Windows may ignore POSIX modes. */ }
 }
 
 /** The user's pinned default model id for `4yi code`, or null if unset. */

package/src/connect.mjs

@@ -24,13 +24,13 @@ const TOOL_METADATA = {
   claude: {
     label: "Claude Code",
     command: "claude",
-    npmPackage: "@anthropic-ai/claude-code",
+    npmPackage: "@anthropic-ai/claude-code@2.1.250",
     appLabel: "Claude App",
   },
   codex: {
     label: "Codex",
     command: "codex",
-    npmPackage: "@openai/codex",
+    npmPackage: "@openai/codex@0.150.1",
     appLabel: "Codex App",
   },
 };
@@ -61,6 +61,28 @@ export function connectionPaths({ home = os.homedir(), cwd = process.cwd(), code
   };
 }
 
+export function connectionPlan({ target = "all", home = os.homedir(), cwd = process.cwd(), codexHome = process.env.CODEX_HOME, scope = "user" } = {}) {
+  const normalized = normalizeTarget(target);
+  if (!new Set(["user", "project", "both"]).has(scope)) {
+    throw new Error(`Unknown scope: ${scope}. Use user, project, or both.`);
+  }
+  const paths = connectionPaths({ home, cwd, codexHome });
+  const plan = [];
+  if (normalized === "claude" || normalized === "all") {
+    const files = scope === "project"
+      ? [paths.claudeProject]
+      : scope === "both"
+        ? [paths.claudeUser, paths.claudeProject]
+        : [paths.claudeUser];
+    for (const file of files) plan.push({ target: "claude", file, exists: fs.existsSync(file), action: "backup-and-update" });
+  }
+  if (normalized === "codex" || normalized === "all") {
+    plan.push({ target: "codex", file: paths.codexConfig, exists: fs.existsSync(paths.codexConfig), action: "backup-and-update" });
+    plan.push({ target: "codex", file: paths.codexCatalog, exists: fs.existsSync(paths.codexCatalog), action: "generate" });
+  }
+  return plan;
+}
+
 function atomicWrite(file, value) {
   ensureDir(path.dirname(file));
   const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
@@ -373,9 +395,11 @@ async function connectCodex({ session, home, codexHome, codexBaseUrl, stdout, sk
   ensureDir(path.dirname(paths.codexConfig));
   const template = parseBundledCatalog(tooling);
   const catalog = buildCodexCatalog(models, template);
+  const backupGroup = timestamp();
+  const configBackup = backupFile("codex", paths.codexConfig, home, backupGroup);
+  const catalogBackup = backupFile("codex", paths.codexCatalog, home, backupGroup);
   atomicWrite(paths.codexCatalog, `${JSON.stringify(catalog, null, 2)}\n`);
 
-  const backup = backupFile("codex", paths.codexConfig, home);
   let existing = fs.existsSync(paths.codexConfig) ? fs.readFileSync(paths.codexConfig, "utf8") : "";
   existing = removeManagedBlock(existing, CODEX_ROOT_START, CODEX_ROOT_END);
   existing = removeManagedBlock(existing, CODEX_PROVIDER_START, CODEX_PROVIDER_END);
@@ -385,7 +409,7 @@ async function connectCodex({ session, home, codexHome, codexBaseUrl, stdout, sk
   atomicWrite(paths.codexConfig, `${root}\n\n${existing ? `${existing}\n\n` : ""}${provider}\n`);
   stdout(`Connected Codex: ${paths.codexConfig}`);
   stdout(`Available Codex models: ${models.map((model) => model.id).join(", ")}`);
-  stdout(`Backup: ${backup}`);
+  stdout(`Backups: ${configBackup}, ${catalogBackup}`);
 }
 
 function resolveUrls(session, options) {

package/src/doctor.mjs

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import os from "node:os";
+import { spawnSync } from "node:child_process";
+import { DEFAULT_BASE_URL, pathsForHome, readConfig } from "./config.mjs";
+
+function commandName(name, platform) {
+  return platform === "win32" ? `${name}.cmd` : name;
+}
+
+function commandAvailable(name, { platform, spawn }) {
+  const result = spawn(commandName(name, platform), ["--version"], {
+    encoding: "utf8",
+    shell: platform === "win32",
+    stdio: "ignore",
+  });
+  return !result.error && result.status === 0;
+}
+
+function check(id, status, message, required = false) {
+  return { id, status, message, required };
+}
+
+export function diagnose({
+  home = os.homedir(),
+  platform = process.platform,
+  nodeVersion = process.versions.node,
+  spawn = spawnSync,
+} = {}) {
+  const results = [];
+  const major = Number.parseInt(String(nodeVersion).split(".")[0], 10);
+  results.push(check("node", major >= 20 ? "pass" : "fail", `Node.js ${nodeVersion}`, true));
+
+  const paths = pathsForHome(home);
+  let config = {};
+  try {
+    config = readConfig(home);
+    results.push(check("config-json", "pass", fs.existsSync(paths.configFile) ? "Local configuration is valid JSON" : "No local configuration yet"));
+  } catch {
+    results.push(check("config-json", "fail", "Local configuration is not valid JSON", true));
+  }
+  const baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+  let safeBaseUrl = false;
+  try {
+    const parsed = new URL(baseUrl);
+    safeBaseUrl = parsed.protocol === "https:" || ["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname);
+  } catch { /* Report a failed URL check below. */ }
+  results.push(check("base-url", safeBaseUrl ? "pass" : "fail", safeBaseUrl ? `Service URL: ${baseUrl}` : "Service URL is invalid or insecure", true));
+
+  if (fs.existsSync(paths.configFile)) {
+    if (platform === "win32") {
+      results.push(check("config-permissions", "warn", "Local session file exists; Windows ACLs were not inspected"));
+    } else {
+      const mode = fs.statSync(paths.configFile).mode & 0o777;
+      const permissionStatus = (mode & 0o077) === 0 ? "pass" : "fail";
+      const permissionMessage = permissionStatus === "pass"
+        ? "Local session file is owner-only"
+        : `Local session file permissions are too broad (${mode.toString(8)})`;
+      results.push(check("config-permissions", permissionStatus, permissionMessage, true));
+    }
+  } else {
+    results.push(check("config-permissions", "warn", "No local session file yet; run `4yi login`"));
+  }
+
+  results.push(check("session", config.token ? "pass" : "warn", config.token ? "Signed-in session is present" : "Not signed in"));
+  results.push(check("claude", commandAvailable("claude", { platform, spawn }) ? "pass" : "warn", "Claude Code CLI"));
+  results.push(check("codex", commandAvailable("codex", { platform, spawn }) ? "pass" : "warn", "Codex CLI"));
+
+  return {
+    ok: results.every((result) => !result.required || result.status === "pass"),
+    results,
+  };
+}
+
+export function runDoctor({ stdout = console.log, json = false, ...options } = {}) {
+  const report = diagnose(options);
+  if (json) {
+    stdout(JSON.stringify(report, null, 2));
+    return report;
+  }
+  stdout("4YI CLI doctor");
+  for (const result of report.results) {
+    const marker = result.status === "pass" ? "PASS" : result.status === "warn" ? "WARN" : "FAIL";
+    stdout(`${marker.padEnd(4)} ${result.message}`);
+  }
+  return report;
+}

package/src/http.mjs

@@ -1,17 +1,19 @@
 export async function requestJson(baseUrl, path, options = {}) {
   const url = `${baseUrl}${path}`;
+  const { token, timeoutMs = 30_000, signal, ...fetchOptions } = options;
   const optionHeaders = normalizeHeaders(options.headers);
   const headers = {
     "content-type": "application/json",
-    ...(options.token ? { authorization: `Bearer ${options.token}` } : {}),
+    ...(token ? { authorization: `Bearer ${token}` } : {}),
     ...optionHeaders,
   };
   if (shouldGenerateIdempotencyKey(path, options, headers)) {
     headers["Idempotency-Key"] = `cli-${randomId()}`;
   }
   const res = await fetch(url, {
-    ...options,
+    ...fetchOptions,
     headers,
+    signal: signal || AbortSignal.timeout(timeoutMs),
   });
   const text = await res.text();
   let body = null;

package/src/opencode.mjs

@@ -5,11 +5,16 @@ import { spawn, spawnSync } from "node:child_process";
 import { pathsForHome, ensureDir, getPreferredModel, setPreferredModel } from "./config.mjs";
 import { requestJson } from "./http.mjs";
 
-const DEFAULT_OPENCODE_PACKAGE = "opencode-ai";
+const OPENCODE_VERSION = "1.18.25";
+const OPENAI_COMPATIBLE_VERSION = "3.0.39";
+const DEFAULT_OPENCODE_PACKAGE = `opencode-ai@${OPENCODE_VERSION}`;
+const OPENAI_COMPATIBLE_PACKAGE = `@ai-sdk/openai-compatible@${OPENAI_COMPATIBLE_VERSION}`;
+const TRUSTED_OPENCODE_INSTALL_SCRIPT = `opencode-ai@${OPENCODE_VERSION}`;
 const DEFAULT_CONTEXT_LIMIT = 200000;
 const DEFAULT_OUTPUT_LIMIT = 8192;
 
 function isClaudeModel(model) {
+  if (model?.family === "claude") return true;
   const id = model?.id || "";
   const name = model?.display_name || "";
   return /claude/i.test(id) || /claude/i.test(name);
@@ -23,14 +28,23 @@ function modelOutputLimit(model) {
   return model.output_limit || model.max_output_tokens || model.max_tokens || DEFAULT_OUTPUT_LIMIT;
 }
 
+function modelPickerName(model) {
+  const displayName = model.display_name || model.id;
+  if (model.family === "claude") {
+    return `Claude · ${displayName.replace(/^(?:anthropic[ ._-]*)?claude[ ._-]*/i, "")}`;
+  }
+  if (model.family === "codex") return `Codex · ${displayName}`;
+  return displayName;
+}
+
 export function buildOpenCodeConfig({ modelConfig, preferredModel = null, tokenEnv = "FOURYI_CLI_TOKEN", orgEnv = "FOURYI_ORG_ID" }) {
-  // Register EVERY model the server returned so OpenCode's native switcher
-  // (`Tab` / `/models`) can move between them. Claude stays the default.
+  // Register every server-approved coding model so OpenCode's native switcher
+  // (`Tab` / `/models`) can move between Claude and Codex. Claude stays the default.
   const list = modelConfig.models || [];
   const models = {};
   for (const model of list) {
     const entry = {
-      name: model.display_name || model.id,
+      name: modelPickerName(model),
       limit: {
         context: modelContextLimit(model),
         output: modelOutputLimit(model),
@@ -84,23 +98,37 @@ export function opencodeEnv({ home = os.homedir(), token, orgId = "", configFile
   };
 }
 
-export function ensureOpenCodeRuntime({ home = os.homedir(), stdout = console.log } = {}) {
+export function ensureOpenCodeRuntime({ home = os.homedir(), stdout = console.log, spawn = spawnSync, env = process.env } = {}) {
   const paths = pathsForHome(home);
   ensureDir(paths.opencodeDir);
-  if (!fs.existsSync(paths.opencodePackageFile)) {
-    fs.writeFileSync(paths.opencodePackageFile, JSON.stringify({
+  const packageJson = fs.existsSync(paths.opencodePackageFile)
+    ? JSON.parse(fs.readFileSync(paths.opencodePackageFile, "utf8"))
+    : {
       private: true,
       type: "module",
       dependencies: {},
-    }, null, 2));
+    };
+  const installScriptTrusted = packageJson.allowScripts?.[TRUSTED_OPENCODE_INSTALL_SCRIPT] === true;
+  if (!installScriptTrusted) {
+    packageJson.allowScripts = {
+      ...(packageJson.allowScripts || {}),
+      [TRUSTED_OPENCODE_INSTALL_SCRIPT]: true,
+    };
+    fs.writeFileSync(paths.opencodePackageFile, `${JSON.stringify(packageJson, null, 2)}\n`);
   }
 
   const bin = path.join(paths.opencodeDir, "node_modules", ".bin", process.platform === "win32" ? "opencode.cmd" : "opencode");
-  if (fs.existsSync(bin)) return bin;
+  const opencodePackage = env.FOURYI_OPENCODE_PACKAGE || DEFAULT_OPENCODE_PACKAGE;
+  const usesDefaultRuntime = opencodePackage === DEFAULT_OPENCODE_PACKAGE;
+  const runtimeCurrent = fs.existsSync(bin)
+    && (!usesDefaultRuntime || (
+      packageJson.dependencies?.["opencode-ai"] === OPENCODE_VERSION
+      && packageJson.dependencies?.["@ai-sdk/openai-compatible"] === OPENAI_COMPATIBLE_VERSION
+    ));
+  if (runtimeCurrent) return bin;
 
-  const opencodePackage = process.env.FOURYI_OPENCODE_PACKAGE || DEFAULT_OPENCODE_PACKAGE;
   stdout(`Installing OpenCode runtime into ${paths.opencodeDir}...`);
-  const result = spawnSync("npm", ["install", "--prefix", paths.opencodeDir, opencodePackage, "@ai-sdk/openai-compatible"], {
+  const result = spawn("npm", ["install", "--prefix", paths.opencodeDir, "--save-exact", opencodePackage, OPENAI_COMPATIBLE_PACKAGE], {
     stdio: "inherit",
   });
   if (result.status !== 0) throw new Error("OpenCode runtime install failed");
@@ -111,7 +139,7 @@ export function ensureOpenCodeRuntime({ home = os.homedir(), stdout = console.lo
 
 export async function runCode({ session, home = os.homedir(), argv = [], stdout = console.log, preferredModel = null } = {}) {
   if (!session?.token) throw new Error("Not signed in. Run `4yi login`.");
-  const modelConfig = await requestJson(session.baseUrl, "/api/cli/models", { token: session.token });
+  const modelConfig = await requestJson(session.baseUrl, "/api/cli/models?runtime=opencode", { token: session.token });
   const list = modelConfig.models || [];
   if (list.length === 0) throw new Error("No chat models available for this organization.");