@agent-proxy/gateway 0.14.2 → 0.15.0

package/dist/index.js

@@ -12,8 +12,8 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import fs21 from "fs";
-import path15 from "path";
+import fs24 from "fs";
+import path17 from "path";
 import { createHash as createHash3 } from "crypto";
 import { execFileSync as execFileSync5 } from "child_process";
 import bytes2 from "bytes";
@@ -8512,6 +8512,7 @@ function modelCatalogResponse(catalog, clientVersion, owner, prefix = "cliproxy/
     data: catalog.models.map((model) => ({
       id: model.slug,
       object: "model",
+      ...typeof model.display_name === "string" && model.display_name ? { display_name: model.display_name, name: model.display_name } : {},
       owned_by: registry.match(model.slug)?.plugin.id ?? (owner === "mixed" ? model.slug.startsWith(prefix) ? "cliproxy" : "openai" : owner)
     }))
   });
@@ -9356,14 +9357,452 @@ function updateCodexModelCatalog2(paths, config, dependencies = {}, options = {}
     managedFiles: managedRuntimeCatalogFiles(paths)
   });
 }
-// src/webui.ts
+
+// src/models-push.ts
+import fs18 from "fs";
+function pushTimestamp(date = new Date) {
+  return date.toISOString().replace(/[-:]/g, "").slice(0, 15).replace("T", "");
+}
+function writeIfChanged(file, contents) {
+  if (fs18.existsSync(file) && fs18.readFileSync(file, "utf8") === contents)
+    return;
+  const backup = `${file}.bak-agent-proxy-${pushTimestamp()}`;
+  fs18.copyFileSync(file, backup);
+  atomicWrite(file, contents);
+  return backup;
+}
+function writeAllOrRollback(entries) {
+  const written = [];
+  try {
+    for (const { file, contents } of entries) {
+      const backup = writeIfChanged(file, contents);
+      if (backup !== undefined)
+        written.push({ file, backup });
+    }
+  } catch (error) {
+    const unrestored = [];
+    for (const { file, backup } of written) {
+      try {
+        fs18.copyFileSync(backup, file);
+      } catch {
+        unrestored.push(file);
+      }
+    }
+    if (unrestored.length === 0)
+      throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${message}; failed to restore: ${unrestored.join(", ")} (their backups remain beside the files)`);
+  }
+  return written.map((item) => item.backup);
+}
+function modelReasoningEfforts(entry) {
+  const raw = entry.supported_reasoning_levels;
+  if (!Array.isArray(raw))
+    return [];
+  const efforts = [];
+  for (const item of raw) {
+    const effort = typeof item === "string" ? item : item && typeof item === "object" && typeof item.effort === "string" ? item.effort : undefined;
+    if (typeof effort === "string" && effort && !efforts.includes(effort))
+      efforts.push(effort);
+  }
+  return efforts;
+}
+function modelContextWindow(entry) {
+  for (const key of ["context_window", "max_context_window"]) {
+    const value = entry[key];
+    if (typeof value === "number" && Number.isFinite(value) && value > 0)
+      return value;
+  }
+  return;
+}
+function modelInputModalities(entry) {
+  const raw = entry.input_modalities;
+  if (!Array.isArray(raw))
+    return ["text"];
+  const modalities = raw.filter((item) => item === "text" || item === "image");
+  return modalities.length > 0 ? [...new Set(modalities)] : ["text"];
+}
+async function pushModelsToTargets(options) {
+  for (const failure of options.failures) {
+    console.log(`WARNING: ${failure}; its models are not included in this push.`);
+  }
+  const scoped = filterExcludedModels({ models: [...options.entries] }, options.config.excludedModels, isInstalledPluginModel).models;
+  if (scoped.length === 0) {
+    throw new Error("model push aborted; no local adapter models to push" + " (enable an adapter via config --zcode on / --codebuddy on / \u2026 and refresh its catalog first)");
+  }
+  const known = options.targets.map((target) => target.id);
+  const requested = options.targetOption === undefined ? known : [...new Set(options.targetOption.split(",").map((id) => id.trim().toLowerCase()).filter(Boolean))];
+  if (requested.length === 0)
+    throw new Error("--push requires at least one target name (or no value to push every target)");
+  const selected = requested.map((id) => {
+    const target = options.targets.find((candidate) => candidate.id === id);
+    if (!target)
+      throw new Error(`unknown --push target "${id}"; available targets: ${known.join(", ")}`);
+    return target;
+  });
+  const failed = [];
+  for (const target of selected) {
+    try {
+      target.assertInstalled();
+      const outcome = target.push(scoped);
+      console.log(outcome.summary);
+      for (const note of outcome.notes)
+        console.log(`  ${note}`);
+    } catch (error) {
+      failed.push(target.id);
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`WARNING: ${target.id} push failed: ${message}`);
+    }
+  }
+  if (failed.length > 0)
+    throw new Error(`model push failed for: ${failed.join(", ")} (see warnings above)`);
+}
+
+// src/zcode-client-sync.ts
+import fs19 from "fs";
+import os3 from "os";
+import path13 from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+import { isZcodeModel } from "@agent-proxy/zcode/catalog";
+var ZCODE_PROVIDER_DISPLAY_NAME = "AgentProxy";
+function isManagedProviderName(name) {
+  return typeof name === "string" && name.toLowerCase().replace(/-/g, "") === "agentproxy";
+}
+var ZCODE_API_KEY_PLACEHOLDER = "EMPTY";
+var ZCODE_PROVIDER_GROUP = "standard-personal";
+function resolveZcodeClientPaths(env = process.env) {
+  const home = env.ZCODE_HOME || path13.join(env.HOME || os3.homedir(), ".zcode");
+  const v2 = path13.join(home, "v2");
+  return { home, v2, configFile: path13.join(v2, "config.json"), providerConfigFile: path13.join(v2, "provider_config.json") };
+}
+function synthesizeZcodeModelDefinition(entry) {
+  const definition = {};
+  definition.name = typeof entry.display_name === "string" && entry.display_name ? entry.display_name : entry.slug;
+  const efforts = modelReasoningEfforts(entry);
+  if (efforts.length > 0) {
+    const declared = typeof entry.default_reasoning_level === "string" ? entry.default_reasoning_level : undefined;
+    definition.reasoning = {
+      enabled: true,
+      variants: [...efforts],
+      defaultVariant: declared && efforts.includes(declared) ? declared : efforts[efforts.length - 1]
+    };
+  }
+  const context = modelContextWindow(entry);
+  if (context !== undefined)
+    definition.limit = { context };
+  definition.modalities = { input: modelInputModalities(entry), output: ["text"] };
+  definition.zcode = { modalitiesConfigured: true, modified: true };
+  return definition;
+}
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readJsonFile(file) {
+  const parsed = JSON.parse(fs19.readFileSync(file, "utf8"));
+  if (!isRecord3(parsed))
+    throw new Error(`${file} does not contain a JSON object`);
+  return parsed;
+}
+function pushZcodeModels(models, options) {
+  const paths = resolveZcodeClientPaths(options.env);
+  const pushModels = models.filter((model) => !isZcodeModel(model.slug));
+  if (pushModels.length === 0) {
+    throw new Error("zcode push aborted; no models remain after excluding ZCode plugin models");
+  }
+  const providerDoc = readJsonFile(paths.providerConfigFile);
+  const configDoc = readJsonFile(paths.configFile);
+  const providerRules = providerDoc.config?.providerConfigRules?.providerRules;
+  if (!Array.isArray(providerRules)) {
+    throw new Error(`${paths.providerConfigFile}: config.providerConfigRules.providerRules is missing or not an array`);
+  }
+  const modelRules = providerDoc.config?.modelConfigRules?.providerModelRules;
+  if (!Array.isArray(modelRules)) {
+    throw new Error(`${paths.providerConfigFile}: config.modelConfigRules.providerModelRules is missing or not an array`);
+  }
+  configDoc.provider ??= {};
+  const existingRule = providerRules.find((item) => isRecord3(item) && isManagedProviderName(item.providerName));
+  const baseURL = `http://${options.config.host}:${options.config.port}`;
+  let rule = existingRule;
+  let providerId = rule && typeof rule.providerId === "string" ? rule.providerId : undefined;
+  if (providerId === undefined) {
+    providerId = randomUUID5();
+    rule = {
+      providerId,
+      providerName: ZCODE_PROVIDER_DISPLAY_NAME,
+      config: {
+        group: ZCODE_PROVIDER_GROUP,
+        access: { type: "api-key", apiKey: ZCODE_API_KEY_PLACEHOLDER },
+        api: { type: "anthropic-messages", baseUrl: baseURL },
+        personalModelIds: [],
+        modelOrder: []
+      }
+    };
+    providerRules.push(rule);
+    if (Array.isArray(providerDoc.config?.providerOrder) && !providerDoc.config.providerOrder.includes(providerId)) {
+      providerDoc.config.providerOrder.push(providerId);
+    }
+  } else {
+    const managedRule = rule;
+    if (Array.isArray(providerDoc.config?.providerOrder) && !providerDoc.config.providerOrder.includes(providerId)) {
+      providerDoc.config.providerOrder.push(providerId);
+    }
+    if (managedRule.providerName !== ZCODE_PROVIDER_DISPLAY_NAME)
+      managedRule.providerName = ZCODE_PROVIDER_DISPLAY_NAME;
+  }
+  if (!isRecord3(rule.config))
+    throw new Error(`${paths.providerConfigFile}: managed provider rule has no config object`);
+  if (rule.config.group !== ZCODE_PROVIDER_GROUP)
+    rule.config.group = ZCODE_PROVIDER_GROUP;
+  let entry = configDoc.provider[providerId];
+  if (!isRecord3(entry)) {
+    entry = {
+      name: ZCODE_PROVIDER_DISPLAY_NAME,
+      kind: "anthropic",
+      options: { apiKey: ZCODE_API_KEY_PLACEHOLDER, apiKeyRequired: true, baseURL },
+      source: "custom",
+      models: {}
+    };
+    configDoc.provider[providerId] = entry;
+  } else if (entry.name !== ZCODE_PROVIDER_DISPLAY_NAME) {
+    entry.name = ZCODE_PROVIDER_DISPLAY_NAME;
+  }
+  const deletedModels = isRecord3(entry.zcode) ? entry.zcode.deletedModels : undefined;
+  const deleted = new Set((Array.isArray(deletedModels) ? deletedModels : []).filter((item) => typeof item === "string").map((slug) => slug.toLowerCase()));
+  const newSlugs = pushModels.filter((model) => !deleted.has(model.slug.toLowerCase())).map((model) => model.slug);
+  if (newSlugs.length === 0) {
+    throw new Error("zcode push aborted; every remaining model is hidden by ZCode deletedModels");
+  }
+  const newSet = new Set(newSlugs.map((slug) => slug.toLowerCase()));
+  const bySlug = new Map(pushModels.map((model) => [model.slug.toLowerCase(), model]));
+  const oldOrder = Array.isArray(rule.config.modelOrder) ? rule.config.modelOrder.filter((item) => typeof item === "string") : [];
+  const oldSet = new Set(oldOrder.map((slug) => slug.toLowerCase()));
+  const addedCount = newSlugs.filter((slug) => !oldSet.has(slug.toLowerCase())).length;
+  const removedCount = oldOrder.filter((slug) => !newSet.has(slug.toLowerCase())).length;
+  const unchangedCount = newSlugs.length - addedCount;
+  rule.config.modelOrder = [...newSlugs];
+  rule.config.personalModelIds = [...newSlugs];
+  const syncedRules = newSlugs.map((slug) => {
+    const model = bySlug.get(slug.toLowerCase());
+    const context = modelContextWindow(model);
+    return {
+      modelId: slug,
+      providerId,
+      config: {
+        properties: {
+          ...context === undefined ? {} : { contextWindow: context },
+          inputFormat: { supportsImage: modelInputModalities(model).includes("image") }
+        }
+      }
+    };
+  });
+  providerDoc.config.modelConfigRules.providerModelRules = [
+    ...modelRules.filter((item) => !(isRecord3(item) && item.providerId === providerId)),
+    ...syncedRules
+  ];
+  const manualRules = providerDoc.config.modelConfigRules.manualProviderModelRules;
+  if (Array.isArray(manualRules)) {
+    providerDoc.config.modelConfigRules.manualProviderModelRules = manualRules.filter((item) => !(isRecord3(item) && item.providerId === providerId));
+  }
+  entry.models = Object.fromEntries(newSlugs.map((slug) => [
+    slug,
+    synthesizeZcodeModelDefinition(bySlug.get(slug.toLowerCase()))
+  ]));
+  const pendingWrites = [
+    { file: paths.providerConfigFile, contents: `${JSON.stringify(providerDoc, null, 2)}
+` },
+    { file: paths.configFile, contents: `${JSON.stringify(configDoc, null, 2)}
+` }
+  ];
+  const displayOrderFile = path13.join(paths.v2, "model-provider-display-order.json");
+  if (fs19.existsSync(displayOrderFile)) {
+    try {
+      const displayOrder = JSON.parse(fs19.readFileSync(displayOrderFile, "utf8"));
+      if (Array.isArray(displayOrder.providerIds) && !displayOrder.providerIds.includes(providerId)) {
+        displayOrder.providerIds.push(providerId);
+        displayOrder.updatedAt = Date.now();
+        pendingWrites.push({ file: displayOrderFile, contents: `${JSON.stringify(displayOrder, null, 2)}
+` });
+      }
+    } catch {}
+  }
+  const backups = writeAllOrRollback(pendingWrites);
+  return {
+    summary: backups.length === 0 ? `zcode: provider "${ZCODE_PROVIDER_DISPLAY_NAME}" already up to date (${newSlugs.length} models)` : `zcode: ${newSlugs.length} models pushed to provider "${ZCODE_PROVIDER_DISPLAY_NAME}"` + ` (+${addedCount} added, -${removedCount} removed, ${unchangedCount} unchanged)`,
+    notes: [
+      ...backups.map((backup) => `backup: ${backup}`),
+      "note: the gateway /v1/messages endpoint currently converts only OpenCode Zen models end-to-end;" + " models from other sources may fail over this provider",
+      "restart ZCode to refresh its model list"
+    ]
+  };
+}
+function createZcodePushTarget(options) {
+  return {
+    id: "zcode",
+    assertInstalled() {
+      const paths = resolveZcodeClientPaths(options.env);
+      if (!fs19.existsSync(paths.configFile) || !fs19.existsSync(paths.providerConfigFile)) {
+        throw new Error(`ZCode is not installed (expected ${paths.v2}/config.json and provider_config.json);` + ` install ZCode or point ZCODE_HOME at its config directory`);
+      }
+    },
+    push(models) {
+      return pushZcodeModels(models, options);
+    }
+  };
+}
+
+// src/dsh-client-sync.ts
 import fs20 from "fs";
+import os4 from "os";
 import path14 from "path";
+import YAML, { isMap, isSeq, YAMLMap, YAMLSeq } from "yaml";
+var DSH_PROVIDER_KEY = "agent-proxy";
+var DSH_PROVIDER_DISPLAY_NAME = "AgentProxy";
+var DSH_PROVIDER_API = "anthropic-messages";
+var DSH_API_KEY_ENV = "AGENT_PROXY_API_KEY";
+var DSH_LLM_ENTRY_ID = "llm-pi-ai";
+var DSH_PATCH_FILE = "cordis.patch.yml";
+function resolveDshClientPaths(env = process.env) {
+  const home = env.DSH_HOME || path14.join(env.HOME || os4.homedir(), ".dsh");
+  return { home, profilesDir: path14.join(home, "profiles") };
+}
+var DSH_EFFORT_KEYS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+function dshReasoningEfforts(efforts) {
+  const mapped = {};
+  for (const effort of efforts) {
+    const key = effort === "none" ? "off" : effort;
+    if (!DSH_EFFORT_KEYS.includes(key))
+      continue;
+    if (!(key in mapped))
+      mapped[key] = effort;
+  }
+  return mapped;
+}
+function synthesizeDshModel(entry) {
+  const model = {
+    id: entry.slug,
+    name: typeof entry.display_name === "string" && entry.display_name ? entry.display_name : entry.slug
+  };
+  const context = modelContextWindow(entry);
+  if (context !== undefined)
+    model.contextWindow = context;
+  model.input = modelInputModalities(entry);
+  const efforts = modelReasoningEfforts(entry);
+  if (efforts.length > 0) {
+    const reasoningEfforts = dshReasoningEfforts(efforts);
+    if (Object.keys(reasoningEfforts).length > 0)
+      model.reasoningEfforts = reasoningEfforts;
+  }
+  return model;
+}
+function parseDshPatch(file, profile) {
+  const raw = fs20.readFileSync(file, "utf8");
+  const doc = YAML.parseDocument(raw);
+  if (doc.errors.length > 0) {
+    const first = doc.errors[0];
+    throw new Error(`${file} is not valid YAML (${first.message}); fix or restore it (see its .bak-* backups), then rerun models --push`);
+  }
+  if (doc.contents === null)
+    doc.contents = new YAMLSeq;
+  if (!isSeq(doc.contents))
+    throw new Error(`${file}: expected a top-level YAML array of patch entries`);
+  const documents = [];
+  for (const item of doc.contents.items) {
+    if (isMap(item) && item.toJS(doc).id === DSH_LLM_ENTRY_ID)
+      documents.push({ file, profile, doc, entry: item });
+  }
+  return documents;
+}
+function pushDshModels(models, options) {
+  const paths = resolveDshClientPaths(options.env);
+  if (!fs20.existsSync(paths.profilesDir)) {
+    throw new Error(`dsh profiles directory is missing (${paths.profilesDir}); reinstall dsh or point DSH_HOME at it`);
+  }
+  const profileNames = fs20.readdirSync(paths.profilesDir, { withFileTypes: true }).filter((item) => item.isDirectory()).map((item) => item.name).sort();
+  const touched = [];
+  for (const profile of profileNames) {
+    const file = path14.join(paths.profilesDir, profile, DSH_PATCH_FILE);
+    if (!fs20.existsSync(file))
+      continue;
+    touched.push(...parseDshPatch(file, profile));
+  }
+  if (touched.length === 0) {
+    throw new Error(`dsh is installed but no profile has an "${DSH_LLM_ENTRY_ID}" patch entry under ${paths.profilesDir};` + " configure any custom provider inside dsh once so the patch layer exists, then rerun models --push");
+  }
+  const baseURL = `http://${options.config.host}:${options.config.port}`;
+  const createdProfiles = [];
+  const pendingWrites = [];
+  for (const { file, profile, doc, entry } of touched) {
+    const before = doc.toString();
+    let config;
+    const rawConfig = entry.get("config");
+    if (isMap(rawConfig))
+      config = rawConfig;
+    else {
+      config = new YAMLMap;
+      entry.set("config", config);
+    }
+    let providers;
+    const rawProviders = config.get("providers");
+    if (isMap(rawProviders))
+      providers = rawProviders;
+    else {
+      providers = new YAMLMap;
+      config.set("providers", providers);
+    }
+    let provider;
+    const rawProvider = providers.get(DSH_PROVIDER_KEY);
+    if (isMap(rawProvider))
+      provider = rawProvider;
+    else {
+      provider = doc.createNode({
+        displayName: DSH_PROVIDER_DISPLAY_NAME,
+        apiKeyEnv: DSH_API_KEY_ENV,
+        api: DSH_PROVIDER_API,
+        baseURL
+      });
+      providers.set(DSH_PROVIDER_KEY, provider);
+      createdProfiles.push(profile);
+    }
+    provider.set("models", doc.createNode(models.map(synthesizeDshModel)));
+    const after = doc.toString();
+    if (after === before)
+      continue;
+    pendingWrites.push({ file, contents: after });
+  }
+  const backups = writeAllOrRollback(pendingWrites);
+  const managedProfiles = [...new Set(touched.map((item) => item.profile))].join(", ");
+  return {
+    summary: backups.length === 0 ? `dsh: provider "${DSH_PROVIDER_KEY}" already up to date (${models.length} models, profiles: ${managedProfiles})` : `dsh: ${models.length} models pushed to provider "${DSH_PROVIDER_KEY}"` + ` (${DSH_PROVIDER_DISPLAY_NAME}, ${DSH_PROVIDER_API}; profiles: ${managedProfiles})`,
+    notes: [
+      ...createdProfiles.length > 0 ? [`provider "${DSH_PROVIDER_KEY}" created in: ${createdProfiles.join(", ")}` + ` (apiKey is a placeholder; the gateway ignores client keys \u2014 its plugins authorize upstreams themselves)`] : [],
+      ...backups.map((backup) => `backup: ${backup}`),
+      "note: the gateway /v1/messages endpoint currently converts only OpenCode Zen models end-to-end;" + " models from other sources may fail over this provider",
+      "restart DeepSeek Harness (dsh) to refresh its model list"
+    ]
+  };
+}
+function createDshPushTarget(options) {
+  return {
+    id: "dsh",
+    assertInstalled() {
+      const paths = resolveDshClientPaths(options.env);
+      if (!fs20.existsSync(paths.home)) {
+        throw new Error(`dsh (DeepSeek Harness) is not installed (no ${paths.home}); install dsh or point DSH_HOME at it`);
+      }
+    },
+    push(models) {
+      return pushDshModels(models, options);
+    }
+  };
+}
+// src/webui.ts
+import fs23 from "fs";
+import path16 from "path";
 import { randomBytes } from "crypto";
 
 // src/app-server.ts
-import fs18 from "fs";
-import path13 from "path";
+import fs21 from "fs";
+import path15 from "path";
 import { execFileSync as execFileSync4 } from "child_process";
 import { dlopen } from "bun:ffi";
 var GLOBAL_OPTIONS_WITH_VALUE = new Set([
@@ -9524,22 +9963,22 @@ function listLinuxProcesses() {
   const uid = process.getuid?.();
   if (uid === undefined)
     throw new Error("Current user ID is unavailable");
-  const entries = fs18.readdirSync("/proc", { withFileTypes: true });
+  const entries = fs21.readdirSync("/proc", { withFileTypes: true });
   const processes = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || !/^\d+$/.test(entry.name))
       continue;
     const root = `/proc/${entry.name}`;
     try {
-      const status = fs18.readFileSync(`${root}/status`, "utf8");
+      const status = fs21.readFileSync(`${root}/status`, "utf8");
       const owner = status.match(/^Uid:\s+(\d+)/m)?.[1];
       if (owner !== String(uid))
         continue;
-      const executable = fs18.readlinkSync(`${root}/exe`);
+      const executable = fs21.readlinkSync(`${root}/exe`);
       if (!isCodexExecutable(executable) && !/^codex-code-mode-host(?:\.exe)?$/i.test(executableName(executable)))
         continue;
-      const args = fs18.readFileSync(`${root}/cmdline`).toString("utf8").split("\x00").filter(Boolean);
-      const stat = fs18.readFileSync(`${root}/stat`, "utf8");
+      const args = fs21.readFileSync(`${root}/cmdline`).toString("utf8").split("\x00").filter(Boolean);
+      const stat = fs21.readFileSync(`${root}/stat`, "utf8");
       const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
       const startedAt = fields[19];
       if (!startedAt || args.length === 0)
@@ -9584,9 +10023,9 @@ function parseWindowsCommandLine(commandLine) {
 }
 function windowsSystemPath(...segments) {
   const systemRoot = process.env.SystemRoot || process.env.windir;
-  if (!systemRoot || !path13.win32.isAbsolute(systemRoot))
+  if (!systemRoot || !path15.win32.isAbsolute(systemRoot))
     throw new Error("Windows system root is unavailable");
-  return path13.win32.join(systemRoot, ...segments);
+  return path15.win32.join(systemRoot, ...segments);
 }
 function listWindowsProcesses() {
   const powershell = windowsSystemPath("System32", "WindowsPowerShell", "v1.0", "powershell.exe");
@@ -9638,7 +10077,7 @@ function terminateSystemProcess(pid) {
   }
   try {
     const taskkill = windowsSystemPath("System32", "taskkill.exe");
-    if (!fs18.existsSync(taskkill))
+    if (!fs21.existsSync(taskkill))
       throw new Error("taskkill.exe not found");
     execFileSync4(taskkill, ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
   } catch {
@@ -9713,9 +10152,9 @@ async function stopCodexAppServers(runtime = SYSTEM_RUNTIME) {
 }
 
 // src/config-update.ts
-import fs19 from "fs";
+import fs22 from "fs";
 import bytes from "bytes";
-import { isZcodeModel, zcodeStaticModelPrefixes } from "@agent-proxy/zcode/catalog";
+import { isZcodeModel as isZcodeModel2, zcodeStaticModelPrefixes } from "@agent-proxy/zcode/catalog";
 import { isCodebuddyAccountValue } from "@agent-proxy/codebuddy/credentials";
 import { CODEBUDDY_PREFIX, isCodebuddyModel, WORKBUDDY_PREFIX, codebuddyModelPrefixes } from "@agent-proxy/codebuddy/catalog";
 import { isQoderModel, QODER_CN_PREFIX, QODER_INTL_PREFIX } from "@agent-proxy/qoder/catalog";
@@ -9904,7 +10343,7 @@ function expandExcludedModelGroups(groupsInput, definitions) {
   return normalizeExcludedModels(rules);
 }
 function applySelectedModelsPatch(paths, selectedModels, syncState = true) {
-  if (!fs19.existsSync(paths.gatewayConfig))
+  if (!fs22.existsSync(paths.gatewayConfig))
     throw new Error("Gateway is not installed");
   const config = readGatewayConfigFile(paths.gatewayConfig);
   const before = Array.isArray(config.selectedModels) ? config.selectedModels : [];
@@ -9914,8 +10353,8 @@ function applySelectedModelsPatch(paths, selectedModels, syncState = true) {
   config.selectedModels = selectedModels;
   validateConfiguredPlugins(config);
   writeGatewayConfigFile(paths.gatewayConfig, config);
-  if (syncState && fs19.existsSync(paths.stateFile)) {
-    const state = JSON.parse(fs19.readFileSync(paths.stateFile, "utf8"));
+  if (syncState && fs22.existsSync(paths.stateFile)) {
+    const state = JSON.parse(fs22.readFileSync(paths.stateFile, "utf8"));
     state.config = config;
     atomicWrite(paths.stateFile, `${JSON.stringify(state, null, 2)}
 `);
@@ -9932,7 +10371,7 @@ function applyWebUiConfigPatch(paths, patch, syncState = true, { write = true }
     if (!SUPPORTED_PATCH_FIELDS.has(key))
       throw new Error(`Unsupported field: ${key}`);
   }
-  if (!fs19.existsSync(paths.gatewayConfig))
+  if (!fs22.existsSync(paths.gatewayConfig))
     throw new Error("Gateway is not installed");
   const config = readGatewayConfigFile(paths.gatewayConfig);
   const before = config;
@@ -10033,8 +10472,8 @@ function applyWebUiConfigPatch(paths, patch, syncState = true, { write = true }
   if (!write)
     return { config, applied };
   writeGatewayConfigFile(paths.gatewayConfig, config);
-  if (syncState && fs19.existsSync(paths.stateFile)) {
-    const state = JSON.parse(fs19.readFileSync(paths.stateFile, "utf8"));
+  if (syncState && fs22.existsSync(paths.stateFile)) {
+    const state = JSON.parse(fs22.readFileSync(paths.stateFile, "utf8"));
     state.config = config;
     atomicWrite(paths.stateFile, `${JSON.stringify(state, null, 2)}
 `);
@@ -10043,20 +10482,20 @@ function applyWebUiConfigPatch(paths, patch, syncState = true, { write = true }
   return { config, applied };
 }
 function markPendingRestart(stateFile) {
-  if (!fs19.existsSync(stateFile))
+  if (!fs22.existsSync(stateFile))
     return;
   try {
-    const state = JSON.parse(fs19.readFileSync(stateFile, "utf8"));
+    const state = JSON.parse(fs22.readFileSync(stateFile, "utf8"));
     state.pendingRestart = true;
     atomicWrite(stateFile, `${JSON.stringify(state, null, 2)}
 `);
   } catch {}
 }
 function clearPendingRestart(stateFile) {
-  if (!fs19.existsSync(stateFile))
+  if (!fs22.existsSync(stateFile))
     return;
   try {
-    const state = JSON.parse(fs19.readFileSync(stateFile, "utf8"));
+    const state = JSON.parse(fs22.readFileSync(stateFile, "utf8"));
     if (state.pendingRestart !== true)
       return;
     state.pendingRestart = false;
@@ -10082,14 +10521,14 @@ var REQUEST_LOG_TAIL_BYTES = 64 * 1024;
 var REQUEST_LOG_DEFAULT_PAGE_SIZE = 100;
 var REQUEST_LOG_MAX_PAGE_SIZE = 500;
 var RESTART_DELAY_MS = 400;
-var UI_HTML_PATH = path14.resolve(import.meta.dir, "../dist/ui/index.html");
+var UI_HTML_PATH = path16.resolve(import.meta.dir, "../dist/ui/index.html");
 function webUiContextForInstance(configPath, defaultPaths) {
   const resolved = realPathOrResolve(configPath);
   if (resolved === realPathOrResolve(defaultPaths.gatewayConfig))
     return { paths: defaultPaths };
   return {
     paths: {
-      ...resolvePaths({ HOME: defaultPaths.home, CODEX_HOME: defaultPaths.codexHome }, path14.dirname(resolved)),
+      ...resolvePaths({ HOME: defaultPaths.home, CODEX_HOME: defaultPaths.codexHome }, path16.dirname(resolved)),
       gatewayConfig: resolved
     },
     instanceOnly: true
@@ -10100,7 +10539,7 @@ function isLoopbackHost(host) {
 }
 function ensureUiToken(file) {
   try {
-    const existing = fs20.readFileSync(file, "utf8").trim();
+    const existing = fs23.readFileSync(file, "utf8").trim();
     if (existing)
       return existing;
   } catch {}
@@ -10111,7 +10550,7 @@ function ensureUiToken(file) {
 }
 function readUiToken(file) {
   try {
-    const value = fs20.readFileSync(file, "utf8").trim();
+    const value = fs23.readFileSync(file, "utf8").trim();
     return value || null;
   } catch {
     return null;
@@ -10127,22 +10566,22 @@ var TAIL_EXPAND_CAP_BYTES = 1024 * 1024;
 function tailFile(file, maxBytes) {
   let stat;
   try {
-    stat = fs20.statSync(file);
+    stat = fs23.statSync(file);
   } catch {
     return null;
   }
   try {
     if (stat.size <= maxBytes) {
-      return { text: fs20.readFileSync(file, "utf8"), truncated: false };
+      return { text: fs23.readFileSync(file, "utf8"), truncated: false };
     }
-    const fd = fs20.openSync(file, "r");
+    const fd = fs23.openSync(file, "r");
     try {
       let window = maxBytes;
       for (;; ) {
         const start = Math.max(0, stat.size - window);
         const length = stat.size - start;
         const buffer = Buffer.alloc(length);
-        fs20.readSync(fd, buffer, 0, length, start);
+        fs23.readSync(fd, buffer, 0, length, start);
         const text = buffer.toString("utf8");
         const firstNewline = text.indexOf(`
 `);
@@ -10164,7 +10603,7 @@ function tailFile(file, maxBytes) {
         window = Math.min(stat.size, window * 2);
       }
     } finally {
-      fs20.closeSync(fd);
+      fs23.closeSync(fd);
     }
   } catch {
     return null;
@@ -10200,7 +10639,7 @@ function uiHtmlResponse(ctx) {
   const uiHtmlPath = ctx.uiHtmlPath ?? UI_HTML_PATH;
   let html;
   try {
-    html = fs20.readFileSync(uiHtmlPath, "utf8");
+    html = fs23.readFileSync(uiHtmlPath, "utf8");
   } catch {
     return Response.json({
       error: {
@@ -10231,7 +10670,7 @@ function faviconResponse() {
 }
 function readCodexConfigManaged(stateFile) {
   try {
-    const state = JSON.parse(fs20.readFileSync(stateFile, "utf8"));
+    const state = JSON.parse(fs23.readFileSync(stateFile, "utf8"));
     return state.codexConfigManaged !== false;
   } catch {
     return true;
@@ -10239,10 +10678,10 @@ function readCodexConfigManaged(stateFile) {
 }
 function manualCodexConfigGuidance(paths, config) {
   const gatewayBaseUrl = `http://${config.host}:${config.port}${MOUNT_PATH}`;
-  const source = fs20.existsSync(paths.configToml) ? fs20.readFileSync(paths.configToml, "utf8") : "";
+  const source = fs23.existsSync(paths.configToml) ? fs23.readFileSync(paths.configToml, "utf8") : "";
   let staticCatalogAvailable = false;
   try {
-    const catalog = JSON.parse(fs20.readFileSync(codexCatalogFile(paths), "utf8"));
+    const catalog = JSON.parse(fs23.readFileSync(codexCatalogFile(paths), "utf8"));
     staticCatalogAvailable = Array.isArray(catalog.models) && catalog.models.length > 0;
   } catch {}
   const staticCatalogActive = config.upstreamOnly === true && staticCatalogAvailable;
@@ -10329,7 +10768,7 @@ function configResponse(paths, providerDeps, instanceOnly = false) {
       excludedOther
     },
     detected: {
-      zcode: zcodeConfigPresent(providerDeps?.zcodeHome ?? path14.join(paths.home, ".zcode")),
+      zcode: zcodeConfigPresent(providerDeps?.zcodeHome ?? path16.join(paths.home, ".zcode")),
       codebuddy: codebuddyCredentialsPresent(codebuddyAuthDir),
       codebuddyAccountLabel: accountLabel ?? null,
       codebuddyAccounts,
@@ -10384,13 +10823,13 @@ function requestLogsResponse(config, paths, url) {
   const dir = requestLogDir(paths);
   let names;
   try {
-    names = fs20.readdirSync(dir);
+    names = fs23.readdirSync(dir);
   } catch {
     return Response.json({ files: [], total: 0, offset: 0, limit: REQUEST_LOG_DEFAULT_PAGE_SIZE, logging });
   }
   const all = names.filter((name) => isRequestLogName(name)).flatMap((name) => {
     try {
-      const stat = fs20.statSync(path14.join(dir, name));
+      const stat = fs23.statSync(path16.join(dir, name));
       return [{
         name,
         size: stat.size,
@@ -10448,8 +10887,8 @@ function modelSaveRollback(paths, config) {
     codexCatalogFile(paths),
     paths.configToml
   ])];
-  const previous = files.map((file) => ({ file, source: fs20.existsSync(file) ? fs20.readFileSync(file) : undefined }));
-  const readToml = () => fs20.existsSync(paths.configToml) ? fs20.readFileSync(paths.configToml, "utf8") : undefined;
+  const previous = files.map((file) => ({ file, source: fs23.existsSync(file) ? fs23.readFileSync(file) : undefined }));
+  const readToml = () => fs23.existsSync(paths.configToml) ? fs23.readFileSync(paths.configToml, "utf8") : undefined;
   let expectedToml = readToml();
   const restore = () => {
     for (const { file, source } of previous) {
@@ -10457,8 +10896,8 @@ function modelSaveRollback(paths, config) {
         continue;
       if (source)
         atomicWrite(file, source.toString("utf8"));
-      else if (fs20.existsSync(file))
-        fs20.unlinkSync(file);
+      else if (fs23.existsSync(file))
+        fs23.unlinkSync(file);
     }
     logConfigChange(paths.stdoutLog, {
       command: "webui model rollback",
@@ -10579,7 +11018,7 @@ async function handleWebUiRequestCore(request, config, ctx, port) {
       }
       const structural = applied.some((change) => change.field !== "excludedModels");
       const modelsChanged = selection !== undefined || applied.some((change) => change.field === "excludedModels" || change.field === "codebuddyAccount" || next.upstreamOnly === true && ["zcode", "codebuddy", "qoder", "agy", "opencodeZen"].includes(change.field));
-      const restarting = structural && managesService && fs20.existsSync(ctx.paths.launchAgent);
+      const restarting = structural && managesService && fs23.existsSync(ctx.paths.launchAgent);
       if (restarting) {
         markPendingRestart(ctx.paths.stateFile);
         (ctx.scheduleRestart ?? defaultScheduleRestart)(ctx.paths);
@@ -10736,7 +11175,7 @@ Usage:
   agent-proxy start|stop
   agent-proxy restart [--restart-codex]
   agent-proxy serve [--config PATH]
-  agent-proxy models [--sync] [--select SELECTOR] [--exclude [PATTERNS]] [--restart-codex]
+  agent-proxy models [--sync] [--select SELECTOR] [--exclude [PATTERNS]] [--push [TARGETS]] [--restart-codex]
   agent-proxy config [--zcode on|off] [--codebuddy on|off] [--qoder on|off] [--agy on|off] [--opencode-zen on|off] [--log on|off] [--debug on|off] [--max-request-logs N] [--max-log-size SIZE]
   agent-proxy codebuddy --switch
   agent-proxy web
@@ -10791,6 +11230,19 @@ Models:
                         compatibility model (space toggles exclusion, enter
                         saves)
   --model-merge-json URL  update the cached models.json override
+  --push [TARGETS]     push the local agent plugin models into client tools;
+                        a checkbox picker confirms the list first (every model
+                        preselected \u2014 uncheck what you do not want and press
+                        Enter; requires a terminal) and the managed
+                        provider's model list is then fully replaced by ID
+                        (manual additions inside the managed provider are
+                        removed); upstream cliproxy/newapi and official models
+                        are not pushed (authorization); the zcode plugin's own
+                        models are never pushed to zcode; each tool gets a
+                        managed "agent-proxy" provider created on first push;
+                        targets: zcode, dsh; without a value every target is
+                        pushed; each modified file is backed up first; always
+                        runs after --sync/--exclude
   --restart-codex       stop Codex app-server after sync or exclusion changes
                         to refresh the model picker; active tasks may error
                         and require recovery or reopening
@@ -10873,6 +11325,15 @@ function parseArgs(args) {
       }
       continue;
     }
+    if (key === "push") {
+      if (next === undefined || next.startsWith("--"))
+        options.push = true;
+      else {
+        options.push = next;
+        i += 1;
+      }
+      continue;
+    }
     if (next === undefined || next.startsWith("--"))
       throw new Error(`--${key} requires a value`);
     options[key] = next;
@@ -10905,7 +11366,7 @@ function confirmInstallOverwrite() {
   let bytes3 = 0;
   try {
     while (bytes3 < buffer.length) {
-      const read = fs21.readSync(0, buffer, bytes3, buffer.length - bytes3, null);
+      const read = fs24.readSync(0, buffer, bytes3, buffer.length - bytes3, null);
       if (read <= 0)
         break;
       bytes3 += read;
@@ -10923,7 +11384,7 @@ function promptModifyCodexConfig() {
   let bytes3 = 0;
   try {
     while (bytes3 < buffer.length) {
-      const read = fs21.readSync(0, buffer, bytes3, buffer.length - bytes3, null);
+      const read = fs24.readSync(0, buffer, bytes3, buffer.length - bytes3, null);
       if (read <= 0)
         break;
       bytes3 += read;
@@ -11063,13 +11524,13 @@ function timestamp() {
   return new Date().toISOString().replace(/[-:]/g, "").slice(0, 15).replace("T", "");
 }
 function backupConfig(file) {
-  fs21.mkdirSync(path15.dirname(file), { recursive: true });
-  const existed = fs21.existsSync(file);
+  fs24.mkdirSync(path17.dirname(file), { recursive: true });
+  const existed = fs24.existsSync(file);
   const backup = `${file}.bak-cliproxy-gateway-${timestamp()}`;
   if (existed)
-    fs21.copyFileSync(file, backup);
+    fs24.copyFileSync(file, backup);
   else
-    fs21.writeFileSync(backup, "", { mode: 384 });
+    fs24.writeFileSync(backup, "", { mode: 384 });
   return { existed, backup };
 }
 function hash2(contents) {
@@ -11077,10 +11538,10 @@ function hash2(contents) {
 }
 function restoreBackup(file, record) {
   if (record.existed) {
-    fs21.mkdirSync(path15.dirname(file), { recursive: true });
-    fs21.copyFileSync(record.backup, file);
+    fs24.mkdirSync(path17.dirname(file), { recursive: true });
+    fs24.copyFileSync(record.backup, file);
   } else {
-    fs21.rmSync(file, { force: true });
+    fs24.rmSync(file, { force: true });
   }
 }
 function restoreManagedCodexToml(paths, state, currentToml) {
@@ -11090,12 +11551,12 @@ function restoreManagedCodexToml(paths, state, currentToml) {
   if (state.installedConfigHash !== undefined && hash2(currentToml) === state.installedConfigHash) {
     restoreBackup(paths.configToml, state.configBackup);
   } else {
-    const backupToml = fs21.readFileSync(state.configBackup.backup, "utf8");
+    const backupToml = fs24.readFileSync(state.configBackup.backup, "utf8");
     atomicWrite(paths.configToml, restoreRootTomlKeys(currentToml, backupToml, MANAGED_CONFIG_KEYS));
   }
 }
 function loadJson(file) {
-  return JSON.parse(fs21.readFileSync(file, "utf8"));
+  return JSON.parse(fs24.readFileSync(file, "utf8"));
 }
 function writeJson(file, value) {
   atomicWrite(file, `${JSON.stringify(value, null, 2)}
@@ -11140,13 +11601,13 @@ function removeManagedRuntimeFiles(paths, options = {}) {
     ...options.preserveGatewayConfig ? [] : [paths.gatewayConfig],
     ...options.preserveState ? [] : [paths.stateFile],
     ...managedRuntimeCatalogFiles(paths),
-    path15.join(paths.runtimeHome, "catalog-metadata.json"),
+    path17.join(paths.runtimeHome, "catalog-metadata.json"),
     paths.modelMergeFile,
     paths.stdoutLog,
-    path15.join(paths.runtimeHome, "webui.log"),
-    path15.join(paths.runtimeHome, LEGACY_STDERR_LOG)
+    path17.join(paths.runtimeHome, "webui.log"),
+    path17.join(paths.runtimeHome, LEGACY_STDERR_LOG)
   ]) {
-    fs21.rmSync(file, { force: true });
+    fs24.rmSync(file, { force: true });
   }
 }
 async function waitForHealth(url, attempts = 100, expectedMarker = instanceMarker(resolvePaths().runtimeHome)) {
@@ -11221,7 +11682,7 @@ function recordConfigAudit(command, config, before, paths, extraChanges = []) {
 }
 async function restartGatewayOnce(paths, config) {
   const markPending = (pending) => {
-    if (!fs21.existsSync(paths.stateFile))
+    if (!fs24.existsSync(paths.stateFile))
       return;
     const state = loadJson(paths.stateFile);
     state.pendingRestart = pending;
@@ -11311,9 +11772,9 @@ async function installCurrent(options, completeMigration) {
   requireMacOS();
   requireBun();
   const requestedUpstreamOnly = upstreamOnlyOption(options);
-  const previousConfig = fs21.existsSync(resolvePaths().gatewayConfig) ? loadGatewayConfig(resolvePaths().gatewayConfig) : undefined;
+  const previousConfig = fs24.existsSync(resolvePaths().gatewayConfig) ? loadGatewayConfig(resolvePaths().gatewayConfig) : undefined;
   const upstreamOnly = options["upstream-only"] !== undefined || options["cpa-only"] !== undefined ? requestedUpstreamOnly : previousConfig?.upstreamOnly ?? requestedUpstreamOnly;
-  const priorInstallState = fs21.existsSync(resolvePaths().stateFile) ? loadJson(resolvePaths().stateFile) : undefined;
+  const priorInstallState = fs24.existsSync(resolvePaths().stateFile) ? loadJson(resolvePaths().stateFile) : undefined;
   let manualCodexConfig = options["manual-codex-config"] === true || priorInstallState?.codexConfigManaged === false;
   if (options["manual-codex-config"] === true && upstreamOnly && resolveCodexConfigConflict({ skipPrompt: options.yes === true }) === "managed") {
     manualCodexConfig = false;
@@ -11321,15 +11782,15 @@ async function installCurrent(options, completeMigration) {
   }
   const paths = resolvePaths();
   assertCodexHomeAvailable(paths, manualCodexConfig);
-  const switching = fs21.existsSync(paths.stateFile);
+  const switching = fs24.existsSync(paths.stateFile);
   const portValue = stringOption(options, "port");
   const port = portValue ? Number(portValue) : undefined;
   if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535)) {
     throw new Error("Invalid port");
   }
-  const currentToml = fs21.existsSync(paths.configToml) ? fs21.readFileSync(paths.configToml, "utf8") : "";
+  const currentToml = fs24.existsSync(paths.configToml) ? fs24.readFileSync(paths.configToml, "utf8") : "";
   const modelMergeJson = stringOption(options, "model-merge-json");
-  const previousGatewayConfig = fs21.existsSync(paths.gatewayConfig) ? fs21.readFileSync(paths.gatewayConfig, "utf8") : undefined;
+  const previousGatewayConfig = fs24.existsSync(paths.gatewayConfig) ? fs24.readFileSync(paths.gatewayConfig, "utf8") : undefined;
   const currentGatewayConfig = previousGatewayConfig === undefined ? {} : loadGatewayConfig(paths.gatewayConfig);
   const overrides = {};
   if (port !== undefined)
@@ -11373,7 +11834,7 @@ async function installCurrent(options, completeMigration) {
   });
   const { modelsConfigFile, rules } = await loadModelOverrideRules(paths, config, Boolean(modelMergeJson));
   const explicitSelect = stringOption(options, "select") !== undefined;
-  const reuseCatalog = switching && !explicitSelect && !Boolean(modelMergeJson) && fs21.existsSync(configuredCatalogFile(paths, config));
+  const reuseCatalog = switching && !explicitSelect && !Boolean(modelMergeJson) && fs24.existsSync(configuredCatalogFile(paths, config));
   let selectedModels;
   const selectNone = isSelectNone(installSelector);
   const proxyCatalog = selectNone ? { models: [] } : await fetchUpstreamCatalog(config.upstreamBaseUrl, apiKey, configuredUpstreamType(config), upstreamClientVersion(paths, configuredUpstreamType(config)), newapiCatalogOptions(configuredUpstreamType(config), rules));
@@ -11396,14 +11857,14 @@ async function installCurrent(options, completeMigration) {
   }
   config.selectedModels = selectedModels;
   const { patchedToml: modelCatalogToml } = manualCodexConfig ? { patchedToml: currentToml } : applyModelCatalogToml(currentToml, upstreamOnly, paths, codexCatalogFile(paths), managedRuntimeCatalogFiles(paths));
-  const previousState = switching ? fs21.readFileSync(paths.stateFile, "utf8") : undefined;
+  const previousState = switching ? fs24.readFileSync(paths.stateFile, "utf8") : undefined;
   const priorState = switching ? loadJson(paths.stateFile) : undefined;
   const previousManaged = priorState ? isCodexConfigManaged(priorState) && priorState.uninstallClientRestored !== true : true;
   let configBackup;
   let rollbackCodexClaim;
   let installationTouched = false;
   let launchInstalled = false;
-  const previousPlist = fs21.existsSync(paths.launchAgent) ? fs21.readFileSync(paths.launchAgent, "utf8") : undefined;
+  const previousPlist = fs24.existsSync(paths.launchAgent) ? fs24.readFileSync(paths.launchAgent, "utf8") : undefined;
   const previousServiceLoaded = previousPlist !== undefined && launchAgentStatus(gatewayServiceLabel(paths.instanceSuffix)) !== null;
   let launchTouched = false;
   let tomlUnchanged = false;
@@ -11475,7 +11936,7 @@ async function installCurrent(options, completeMigration) {
       }
       writeJson(paths.stateFile, state);
     }
-    const cliPath = fs21.realpathSync(process.argv[1]);
+    const cliPath = fs24.realpathSync(process.argv[1]);
     launchTouched = true;
     installLaunchAgent({
       bunPath: process.execPath,
@@ -11571,7 +12032,7 @@ async function installCurrent(options, completeMigration) {
   }
   console.log("Codex ChatGPT OAuth was not modified.");
   if (manualCodexConfig) {
-    const currentTomlAfterInstall = fs21.existsSync(paths.configToml) ? fs21.readFileSync(paths.configToml, "utf8") : "";
+    const currentTomlAfterInstall = fs24.existsSync(paths.configToml) ? fs24.readFileSync(paths.configToml, "utf8") : "";
     const configuredCatalog = readRootTomlString(currentTomlAfterInstall, "model_catalog_json");
     const staticCatalogActive = upstreamOnly;
     console.log("WARNING: --manual-codex-config keeps ~/.codex/config.toml untouched. Configure it manually:");
@@ -11600,7 +12061,7 @@ async function installCurrent(options, completeMigration) {
 async function uninstall(options) {
   requireMacOS();
   const paths = resolvePaths();
-  if (!fs21.existsSync(paths.stateFile))
+  if (!fs24.existsSync(paths.stateFile))
     throw new Error("No managed installation found");
   const state = loadJson(paths.stateFile);
   const restoresClient = isCodexConfigManaged(state) && state.uninstallClientRestored !== true;
@@ -11608,12 +12069,12 @@ async function uninstall(options) {
     assertCodexHomeAvailable(paths, false);
   uninstallLaunchAgent(paths.launchAgent);
   uninstallLaunchAgent(paths.webUiLaunchAgent);
-  const legacyCatalogFile = path15.join(paths.codexHome, "cliproxy-catalog.json");
+  const legacyCatalogFile = path17.join(paths.codexHome, "cliproxy-catalog.json");
   if (restoresClient) {
-    const currentToml = fs21.existsSync(paths.configToml) ? fs21.readFileSync(paths.configToml, "utf8") : "";
+    const currentToml = fs24.existsSync(paths.configToml) ? fs24.readFileSync(paths.configToml, "utf8") : "";
     restoreManagedCodexToml(paths, state, currentToml);
     if (readRootTomlString(currentToml, "model_catalog_json") === legacyCatalogFile) {
-      fs21.rmSync(legacyCatalogFile, { force: true });
+      fs24.rmSync(legacyCatalogFile, { force: true });
     }
     invalidateModelsCache(paths.modelsCacheFile);
     state.uninstallClientRestored = true;
@@ -11622,7 +12083,7 @@ async function uninstall(options) {
   deleteApiKey();
   removeManagedRuntimeFiles(paths, { preserveGatewayConfig: true, preserveState: true });
   releaseCodexHome(paths);
-  fs21.rmSync(paths.stateFile, { force: true });
+  fs24.rmSync(paths.stateFile, { force: true });
   if (isCodexConfigManaged(state)) {
     console.log("Uninstalled. Managed config.toml values were restored; config.json was preserved.");
   } else {
@@ -11637,7 +12098,7 @@ function configuredSelectedModels(paths, config) {
   if (Array.isArray(config.selectedModels))
     return config.selectedModels;
   const catalogFile = configuredCatalogFile(paths, config);
-  if (!fs21.existsSync(catalogFile))
+  if (!fs24.existsSync(catalogFile))
     return [];
   const prefix = configuredModelPrefix(config);
   try {
@@ -11662,7 +12123,7 @@ async function collectCompatibleModels(config, dependencies = {}, { includeUpstr
   });
   if (includeUpstream) {
     try {
-      const proxy = JSON.parse(fs21.readFileSync(configuredCatalogFile(paths, config), "utf8"));
+      const proxy = JSON.parse(fs24.readFileSync(configuredCatalogFile(paths, config), "utf8"));
       if (!Array.isArray(proxy.models))
         throw new Error("catalog file does not contain a models array");
       const prefix = config.upstreamOnly === true ? "" : configuredModelPrefix(config);
@@ -11757,26 +12218,65 @@ async function excludeModels(paths, config, option, restartCodex = false, depend
 }
 async function withModelFileRollback(paths, catalogPath, action) {
   const files = [...new Set([paths.gatewayConfig, paths.stateFile, catalogPath, codexCatalogFile(paths), paths.configToml])];
-  const saved = files.map((file) => ({ file, contents: fs21.existsSync(file) ? fs21.readFileSync(file, "utf8") : undefined }));
+  const saved = files.map((file) => ({ file, contents: fs24.existsSync(file) ? fs24.readFileSync(file, "utf8") : undefined }));
   try {
     return await action();
   } catch (error) {
     for (const { file, contents } of saved) {
       if (contents !== undefined) {
-        if (!fs21.existsSync(file) || fs21.readFileSync(file, "utf8") !== contents)
+        if (!fs24.existsSync(file) || fs24.readFileSync(file, "utf8") !== contents)
           atomicWrite(file, contents);
-      } else if (fs21.existsSync(file))
-        fs21.rmSync(file, { force: true });
+      } else if (fs24.existsSync(file))
+        fs24.rmSync(file, { force: true });
     }
     throw error;
   }
 }
+async function runModelsPush(targetOption, config, dependencies = {}) {
+  const targets = [
+    createZcodePushTarget({ config }),
+    createDshPushTarget({ config })
+  ];
+  if (targetOption !== undefined) {
+    const known = targets.map((target) => target.id);
+    for (const id of [...new Set(targetOption.split(",").map((value) => value.trim().toLowerCase()).filter(Boolean))]) {
+      if (!known.includes(id))
+        throw new Error(`unknown --push target "${id}"; available targets: ${known.join(", ")}`);
+    }
+  }
+  const { entries, failures } = await collectAdapterModels(config, {}, { refresh: false });
+  const scoped = filterExcludedModels({ models: [...entries] }, config.excludedModels, isInstalledPluginModel).models;
+  if (scoped.length === 0) {
+    throw new Error("model push aborted; no local adapter models to push" + " (enable an adapter via config --zcode on / --codebuddy on / \u2026 and refresh its catalog first)");
+  }
+  const input = dependencies.input ?? process.stdin;
+  const output = dependencies.output ?? process.stdout;
+  if (!input.isTTY || !output.isTTY) {
+    throw new Error("models --push requires an interactive terminal to confirm the model list" + " (every model is preselected and Enter pushes them all)");
+  }
+  const selectedSlugs = await chooseModels({
+    availableModels: scoped,
+    currentSelection: scoped.map((model) => model.slug),
+    requireNonEmpty: true,
+    input,
+    output,
+    title: "Local plugin models - space toggles, Enter pushes"
+  });
+  const selectedSet = new Set(selectedSlugs);
+  await pushModelsToTargets({
+    targetOption,
+    entries: scoped.filter((model) => selectedSet.has(model.slug)),
+    failures,
+    config,
+    targets
+  });
+}
 async function models(options) {
   const restartCodex = options["restart-codex"] === true;
   const selector = stringOption(options, "select");
   const modelMergeJson = stringOption(options, "model-merge-json");
   const paths = resolvePaths();
-  if (!fs21.existsSync(paths.gatewayConfig))
+  if (!fs24.existsSync(paths.gatewayConfig))
     throw new Error("Gateway is not installed");
   const config = loadGatewayConfig(paths.gatewayConfig);
   const auditBefore = { ...config };
@@ -11784,22 +12284,31 @@ async function models(options) {
   if (modelMergeJson)
     config.modelMergeJson = modelMergeJson;
   const currentSelection = configuredSelectedModels(paths, config);
+  const pushDeferred = async () => {
+    if (options.push !== undefined) {
+      await runModelsPush(options.push === true ? undefined : String(options.push), config);
+    }
+  };
   if (options.exclude !== undefined) {
     if (options.sync === true)
       throw new Error("--exclude cannot be combined with --sync");
     if (options.select !== undefined)
       throw new Error("--select cannot be combined with --exclude");
     await excludeModels(paths, config, options.exclude, restartCodex);
+    await pushDeferred();
     return;
   }
   if (options.sync !== true) {
-    printCurrentModels(config, currentSelection);
-    await printCompatibleModels(config);
+    if (options.push === undefined) {
+      printCurrentModels(config, currentSelection);
+      await printCompatibleModels(config);
+    }
+    await pushDeferred();
     return;
   }
-  const manualCodexConfig = fs21.existsSync(paths.stateFile) && !isCodexConfigManaged(loadJson(paths.stateFile));
-  const source = fs21.existsSync(paths.configToml) ? fs21.readFileSync(paths.configToml, "utf8") : "";
-  const legacyCatalogFile = path15.join(paths.codexHome, "cliproxy-catalog.json");
+  const manualCodexConfig = fs24.existsSync(paths.stateFile) && !isCodexConfigManaged(loadJson(paths.stateFile));
+  const source = fs24.existsSync(paths.configToml) ? fs24.readFileSync(paths.configToml, "utf8") : "";
+  const legacyCatalogFile = path17.join(paths.codexHome, "cliproxy-catalog.json");
   if (!manualCodexConfig) {
     applyModelCatalogToml(source, upstreamOnly, paths, codexCatalogFile(paths), managedRuntimeCatalogFiles(paths));
   }
@@ -11824,7 +12333,7 @@ async function models(options) {
     const result2 = await rebuildCatalog(paths, config, selectedProxyModels, modelsConfigFile);
     config.selectedModels = selectedModels;
     writeGatewayConfig(paths.gatewayConfig, config);
-    if (fs21.existsSync(paths.stateFile)) {
+    if (fs24.existsSync(paths.stateFile)) {
       const state = loadJson(paths.stateFile);
       state.config = config;
       writeJson(paths.stateFile, state);
@@ -11845,16 +12354,17 @@ async function models(options) {
     } else {
       console.log("Dynamic catalog synced; Codex refreshes /models periodically, but the current model picker may require --restart-codex.");
     }
-    return;
+  } else {
+    await refreshCodexAppServer();
   }
-  await refreshCodexAppServer();
+  await pushDeferred();
 }
 async function status() {
   const paths = resolvePaths();
-  const installed = fs21.existsSync(paths.stateFile);
-  const config = fs21.existsSync(paths.gatewayConfig) ? loadGatewayConfig(paths.gatewayConfig) : undefined;
+  const installed = fs24.existsSync(paths.stateFile);
+  const config = fs24.existsSync(paths.gatewayConfig) ? loadGatewayConfig(paths.gatewayConfig) : undefined;
   const service = process.platform === "darwin" ? launchAgentStatus(gatewayServiceLabel(paths.instanceSuffix)) : null;
-  const source = fs21.existsSync(paths.configToml) ? fs21.readFileSync(paths.configToml, "utf8") : "";
+  const source = fs24.existsSync(paths.configToml) ? fs24.readFileSync(paths.configToml, "utf8") : "";
   const configuredBaseUrl = readRootTomlString(source, "openai_base_url");
   const configuredCatalog = readRootTomlString(source, "model_catalog_json");
   const configuredRealtimeWsBaseUrl = readRootTomlString(source, "experimental_realtime_ws_base_url");
@@ -11882,7 +12392,7 @@ async function status() {
     modelCatalogJson: configuredCatalog,
     authJsonModified: false,
     cachedCatalogPath: configuredCatalogFile(paths, config ?? {}),
-    cachedCatalogPresent: fs21.existsSync(configuredCatalogFile(paths, config ?? {})),
+    cachedCatalogPresent: fs24.existsSync(configuredCatalogFile(paths, config ?? {})),
     upstreamOnly: config?.upstreamOnly === true,
     upstreamType: config?.upstreamType ?? "cliproxy",
     codexClientVersion: resolveCodexClientVersion(paths.upstreamModelsCacheFile)
@@ -11892,10 +12402,10 @@ function serve(options) {
   requireBun();
   const paths = resolvePaths();
   const configPath = realPathOrResolve(stringOption(options, "config") || paths.gatewayConfig);
-  if (!fs21.existsSync(configPath))
+  if (!fs24.existsSync(configPath))
     throw new Error(`Gateway config not found: ${configPath}`);
   const config = loadGatewayConfig(configPath);
-  const isProductionInstance = configPath === realPathOrResolve(path15.join(paths.runtimeHome, "config.json"));
+  const isProductionInstance = configPath === realPathOrResolve(path17.join(paths.runtimeHome, "config.json"));
   const processLog = isProductionInstance ? { file: paths.stdoutLog, maxBytes: config.maxGatewayLogBytes ?? 0 } : undefined;
   startGateway(config, loadRealtimeProviderMode(paths.configToml), paths.upstreamModelsCacheFile, { codexModelsCacheFile: paths.modelsCacheFile }, processLog, { codexModelsCacheFile: paths.modelsCacheFile }, { codexModelsCacheFile: paths.modelsCacheFile }, { codexModelsCacheFile: paths.modelsCacheFile }, { codexModelsCacheFile: paths.modelsCacheFile });
   if (isProductionInstance)
@@ -11927,7 +12437,7 @@ async function waitForWebUi(port, timeoutMs = 1e4) {
   throw new Error(`Web UI did not come up on port ${port} within ${timeoutMs / 1000}s`);
 }
 function webUiLogPath(paths) {
-  return path15.join(paths.runtimeHome, "webui.log");
+  return path17.join(paths.runtimeHome, "webui.log");
 }
 function runWebUiForeground(paths, config, openBrowser) {
   const ctx = webUiContextForInstance(paths.gatewayConfig, paths);
@@ -11963,7 +12473,7 @@ async function ensureGatewayRunning(paths, config) {
 async function startWebUiService(paths, config) {
   startWebUiLaunchAgent(paths.webUiLaunchAgent, {
     bunPath: process.execPath,
-    cliPath: fs21.realpathSync(process.argv[1]),
+    cliPath: fs24.realpathSync(process.argv[1]),
     codexHome: paths.codexHome,
     logPath: webUiLogPath(paths),
     label: webUiServiceLabel(paths.instanceSuffix),
@@ -11979,7 +12489,7 @@ async function webCommand(options) {
   if (process.env.CODEX_CLIPROXY_UI_SERVICE === "1") {
     requireBun();
     const paths2 = resolvePaths();
-    if (!fs21.existsSync(paths2.gatewayConfig)) {
+    if (!fs24.existsSync(paths2.gatewayConfig)) {
       throw new Error(`Gateway config not found: ${paths2.gatewayConfig}`);
     }
     const config2 = loadGatewayConfig(paths2.gatewayConfig);
@@ -11991,7 +12501,7 @@ async function webCommand(options) {
   }
   requireMacOS();
   const paths = resolvePaths();
-  if (!fs21.existsSync(paths.stateFile))
+  if (!fs24.existsSync(paths.stateFile))
     throw new Error("Gateway is not installed");
   const config = loadGatewayConfig(paths.gatewayConfig);
   if (!isLoopbackHost(config.host)) {
@@ -12067,7 +12577,7 @@ async function promptCodebuddyAccountSelection(dependencies = {}) {
   const items = [
     {
       value: "auto",
-      label: `${current?.label ?? "no login yet"} (auto, follows the most recently refreshed login)`,
+      label: current ? `Auto(${current.label})` : "Auto",
       selectable: true
     },
     ...entries.filter((entry) => entry.file !== resolved).map((entry) => ({
@@ -12117,7 +12627,7 @@ async function writeConfigAndRestart(paths, config, auditBefore, command, applie
   validateConfiguredPlugins(config);
   const persist = async () => {
     writeGatewayConfig(paths.gatewayConfig, config);
-    if (fs21.existsSync(paths.stateFile)) {
+    if (fs24.existsSync(paths.stateFile)) {
       const state = loadJson(paths.stateFile);
       state.config = config;
       writeJson(paths.stateFile, state);
@@ -12141,7 +12651,7 @@ async function writeConfigAndRestart(paths, config, auditBefore, command, applie
     console.log(result.loaded ? "Gateway model configuration reloaded." : "Models saved; the gateway will load them when started.");
     return;
   }
-  if (fs21.existsSync(paths.launchAgent)) {
+  if (fs24.existsSync(paths.launchAgent)) {
     await restartGatewayOnce(paths, config);
     console.log("Gateway restarted to apply the new configuration.");
   } else {
@@ -12161,7 +12671,7 @@ async function configCommand(options) {
   const maxLogsOption = stringOption(options, "max-request-logs");
   const maxLogSizeOption = stringOption(options, "max-log-size");
   const paths = resolvePaths();
-  if (!fs21.existsSync(paths.gatewayConfig))
+  if (!fs24.existsSync(paths.gatewayConfig))
     throw new Error("Gateway is not installed");
   const config = loadGatewayConfig(paths.gatewayConfig);
   const auditBefore = { ...config };
@@ -12201,9 +12711,9 @@ async function configCommand(options) {
     config.upstreamOnly = upstreamOnlyTarget;
     applied.push(`Default upstream-only routing ${upstreamOnlyTarget ? "enabled" : "disabled"}.`);
   }
-  const managesCodex = !fs21.existsSync(paths.stateFile) || isCodexConfigManaged(loadJson(paths.stateFile));
+  const managesCodex = !fs24.existsSync(paths.stateFile) || isCodexConfigManaged(loadJson(paths.stateFile));
   if (managesCodex) {
-    const source = fs21.existsSync(paths.configToml) ? fs21.readFileSync(paths.configToml, "utf8") : "";
+    const source = fs24.existsSync(paths.configToml) ? fs24.readFileSync(paths.configToml, "utf8") : "";
     applyModelCatalogToml(source, config.upstreamOnly === true, paths, codexCatalogFile(paths), managedRuntimeCatalogFiles(paths));
   }
   if (zcodeTarget !== undefined) {
@@ -12242,8 +12752,8 @@ async function configCommand(options) {
     config.debug = debugTarget;
     applied.push(`Debug dump ${debugTarget ? "enabled" : "disabled"} ` + `(upstream error request bodies go to: ${requestLogDir(paths)}).`);
   }
-  const previousConfig = fs21.readFileSync(paths.gatewayConfig, "utf8");
-  const previousState = fs21.existsSync(paths.stateFile) ? fs21.readFileSync(paths.stateFile, "utf8") : undefined;
+  const previousConfig = fs24.readFileSync(paths.gatewayConfig, "utf8");
+  const previousState = fs24.existsSync(paths.stateFile) ? fs24.readFileSync(paths.stateFile, "utf8") : undefined;
   try {
     await withModelFileRollback(paths, configuredCatalogFile(paths, config), async () => {
       await writeConfigAndRestart(paths, config, auditBefore, "config", applied, {
@@ -12252,14 +12762,14 @@ async function configCommand(options) {
       });
       const changesModels = upstreamOnlyTarget !== undefined || zcodeTarget !== undefined || codebuddyTarget !== undefined || qoderTarget !== undefined || agyTarget !== undefined || opencodeZenTarget !== undefined;
       if (changesModels) {
-        await updateCodexModelCatalog2(paths, config, {}, { refreshAdapters: !fs21.existsSync(paths.launchAgent) });
+        await updateCodexModelCatalog2(paths, config, {}, { refreshAdapters: !fs24.existsSync(paths.launchAgent) });
       }
     });
   } catch (error) {
     atomicWrite(paths.gatewayConfig, previousConfig);
     if (previousState !== undefined)
       atomicWrite(paths.stateFile, previousState);
-    if (fs21.existsSync(paths.launchAgent)) {
+    if (fs24.existsSync(paths.launchAgent)) {
       try {
         await restartGatewayOnce(paths, loadGatewayConfig(paths.gatewayConfig));
       } catch {
@@ -12274,7 +12784,7 @@ async function configCommand(options) {
 async function codebuddyCommand(dependencies = {}) {
   requireMacOS();
   const paths = resolvePaths();
-  if (!fs21.existsSync(paths.gatewayConfig))
+  if (!fs24.existsSync(paths.gatewayConfig))
     throw new Error("Gateway is not installed");
   const config = loadGatewayConfig(paths.gatewayConfig);
   const auditBefore = { ...config };
@@ -12283,6 +12793,10 @@ async function codebuddyCommand(dependencies = {}) {
     console.log("CodeBuddy account switch cancelled; no account change was saved.");
     return;
   }
+  if (selection === (config.codebuddyAccount ?? "auto")) {
+    console.log("CodeBuddy account unchanged; nothing to save.");
+    return;
+  }
   config.codebuddyAccount = selection;
   await writeConfigAndRestart(paths, config, auditBefore, "codebuddy --switch", [
     codebuddyAccountApplied(selection)
@@ -12291,7 +12805,7 @@ async function codebuddyCommand(dependencies = {}) {
 async function controlGateway(action, restartCodex = false) {
   requireMacOS();
   const paths = resolvePaths();
-  if (!fs21.existsSync(paths.stateFile))
+  if (!fs24.existsSync(paths.stateFile))
     throw new Error("Gateway is not installed");
   if (action === "stop") {
     stopLaunchAgent(paths.launchAgent);
@@ -12303,7 +12817,7 @@ async function controlGateway(action, restartCodex = false) {
   if (action === "start") {
     startLaunchAgent(paths.launchAgent, gatewayServiceLabel(paths.instanceSuffix));
   } else {
-    const source = fs21.existsSync(paths.configToml) ? fs21.readFileSync(paths.configToml, "utf8") : "";
+    const source = fs24.existsSync(paths.configToml) ? fs24.readFileSync(paths.configToml, "utf8") : "";
     const gatewayBaseUrl = `http://${config.host}:${config.port}${MOUNT_PATH}`;
     const state = loadJson(paths.stateFile);
     if (isCodexConfigManaged(state)) {
@@ -12335,15 +12849,15 @@ function ownsManagedCodexConfig(paths, state, legacyBaseUrl) {
   const owner = codexOwnerRuntimeHome(paths);
   if (owner !== undefined)
     return owner === realPathOrResolve(paths.runtimeHome);
-  if (!fs21.existsSync(paths.configToml))
+  if (!fs24.existsSync(paths.configToml))
     return false;
-  const currentUrl = readRootTomlString(fs21.readFileSync(paths.configToml, "utf8"), "openai_base_url");
+  const currentUrl = readRootTomlString(fs24.readFileSync(paths.configToml, "utf8"), "openai_base_url");
   return currentUrl === state.gatewayBaseUrl || currentUrl === legacyBaseUrl;
 }
 function syncGatewayConfigFile(paths, configFile = paths.gatewayConfig) {
-  if (!fs21.existsSync(configFile))
+  if (!fs24.existsSync(configFile))
     return;
-  const managesState = realPathOrResolve(configFile) === realPathOrResolve(path15.join(paths.runtimeHome, "config.json"));
+  const managesState = realPathOrResolve(configFile) === realPathOrResolve(path17.join(paths.runtimeHome, "config.json"));
   const raw = loadJson(configFile);
   if (!isJsonObject(raw))
     throw new Error(`Gateway config must be a JSON object: ${configFile}`);
@@ -12384,11 +12898,11 @@ function syncGatewayConfigFile(paths, configFile = paths.gatewayConfig) {
         if (legacyMount && legacyMount !== MOUNT_PATH) {
           const gatewayBaseUrl = `http://${current.host}:${current.port}${MOUNT_PATH}`;
           const legacyBaseUrl = `http://${current.host}:${current.port}${legacyMount}`;
-          const state = managesState && fs21.existsSync(paths.stateFile) ? loadJson(paths.stateFile) : undefined;
+          const state = managesState && fs24.existsSync(paths.stateFile) ? loadJson(paths.stateFile) : undefined;
           if (state?.uninstallClientRestored === true) {} else if (state && isCodexConfigManaged(state)) {
             if (ownsManagedCodexConfig(paths, state, legacyBaseUrl)) {
-              if (fs21.existsSync(paths.configToml)) {
-                const source = fs21.readFileSync(paths.configToml, "utf8");
+              if (fs24.existsSync(paths.configToml)) {
+                const source = fs24.readFileSync(paths.configToml, "utf8");
                 const patched = managedCodexServiceToml(source, gatewayBaseUrl);
                 if (patched !== source)
                   atomicWrite(paths.configToml, patched);
@@ -12416,7 +12930,7 @@ function syncGatewayConfigFile(paths, configFile = paths.gatewayConfig) {
   if (current.configVersion === GATEWAY_CONFIG_VERSION) {
     if (dirty) {
       writeGatewayConfig(configFile, current);
-      if (managesState && fs21.existsSync(paths.stateFile)) {
+      if (managesState && fs24.existsSync(paths.stateFile)) {
         const state = loadJson(paths.stateFile);
         state.config = current;
         writeJson(paths.stateFile, state);
@@ -12436,7 +12950,7 @@ function syncGatewayConfigFile(paths, configFile = paths.gatewayConfig) {
     });
   }
   writeGatewayConfig(configFile, merged.config);
-  if (managesState && fs21.existsSync(paths.stateFile)) {
+  if (managesState && fs24.existsSync(paths.stateFile)) {
     const state = loadJson(paths.stateFile);
     state.version = 4;
     state.config = merged.config;
@@ -12455,7 +12969,7 @@ var COMMAND_OPTIONS = {
   uninstall: ["restart-codex"],
   restart: ["restart-codex"],
   serve: ["config"],
-  models: ["sync", "select", "restart-codex", "model-merge-json", "exclude"],
+  models: ["sync", "select", "restart-codex", "model-merge-json", "exclude", "push"],
   config: ["upstream-only", "restart-codex", "zcode", "codebuddy", "qoder", "agy", "opencode-zen", "log", "debug", "max-request-logs", "max-log-size"],
   codebuddy: ["switch"],
   web: ["start", "daemon", "status", "stop", "restart"]
@@ -12506,18 +13020,18 @@ async function runCli(args) {
   }
   const configOption = command === "serve" ? stringOption(options, "config") : undefined;
   const configPath = configOption ? realPathOrResolve(configOption) : undefined;
-  let paths = configPath ? { ...resolvePaths(process.env, path15.dirname(configPath)), gatewayConfig: configPath } : resolvePaths();
+  let paths = configPath ? { ...resolvePaths(process.env, path17.dirname(configPath)), gatewayConfig: configPath } : resolvePaths();
   const migration = command === "install" ? prepareDefaultInstallMigration(paths) : undefined;
   paths = migration?.paths ?? resolveInstalledCodexPaths(paths);
   return runWithInstancePaths(paths, async () => {
-    if (fs21.existsSync(paths.stateFile)) {
+    if (fs24.existsSync(paths.stateFile)) {
       const state = loadJson(paths.stateFile);
       if (state.uninstallClientRestored === true && !["install", "uninstall", "status"].includes(command)) {
         throw new Error("An uninstall is unfinished; rerun uninstall or install --yes before managing this instance");
       }
     }
     const writesClient = command === "restart" || command === "codebuddy" || command === "models" && (options.sync === true || options.exclude !== undefined) || command === "config" && Object.keys(options).length > 0;
-    if (writesClient && fs21.existsSync(paths.stateFile)) {
+    if (writesClient && fs24.existsSync(paths.stateFile)) {
       const state = loadJson(paths.stateFile);
       if (isCodexConfigManaged(state))
         assertCodexHomeAvailable(paths, false);