@z0ne/installer 0.1.0

package/lib/tools/claude.js

@@ -0,0 +1,112 @@
+"use strict";
+// Claude Code — ~/.claude/settings.json
+// Talks to the gateway over the Anthropic wire format (/v1/messages).
+// ANTHROPIC_BASE_URL keeps the /v1 suffix: the gateway also accepts the
+// SDK's doubled /v1/v1/* form, so both styles work.
+
+const path = require("path");
+const fs = require("fs");
+const { home } = require("../fsutil");
+const fsu = require("../fsutil");
+
+const settingsPath = () => path.join(home(), ".claude", "settings.json");
+const statuslinePath = () => path.join(home(), ".claude", "z0ne-statusline.js");
+
+const ENV_KEYS = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "API_TIMEOUT_MS",
+];
+
+// Rendered from the session JSON Claude Code pipes to statusline commands.
+// Local data only — no network calls, no key access.
+const STATUSLINE_SRC = `#!/usr/bin/env node
+// z0ne.ai statusline for Claude Code (installed by @z0ne/installer).
+let raw = "";
+process.stdin.on("data", (d) => (raw += d));
+process.stdin.on("end", () => {
+  let s = {};
+  try { s = JSON.parse(raw); } catch {}
+  const model = (s.model && (s.model.display_name || s.model.id)) || "?";
+  const dirSrc = (s.workspace && (s.workspace.current_dir || s.workspace.cwd)) || process.cwd();
+  const dir = String(dirSrc).split(/[\\\\/]/).filter(Boolean).pop() || "";
+  const cost = s.cost && typeof s.cost.total_cost_usd === "number"
+    ? "$" + s.cost.total_cost_usd.toFixed(2)
+    : null;
+  const parts = ["z0ne", model];
+  if (cost) parts.push(cost);
+  if (dir) parts.push(dir);
+  process.stdout.write(parts.join(" | "));
+});
+`;
+
+module.exports = {
+  id: "claude",
+  title: "Claude Code",
+  hint: "~/.claude/settings.json",
+
+  detect() {
+    return fsu.commandExists("claude") || fs.existsSync(settingsPath());
+  },
+
+  apply(ctx) {
+    const file = settingsPath();
+    const current = fsu.readJson(file) || {};
+    const merged = {
+      ...current,
+      hasCompletedOnboarding: true,
+      env: {
+        ...(current.env || {}),
+        ANTHROPIC_BASE_URL: ctx.base + "/v1",
+        ANTHROPIC_AUTH_TOKEN: ctx.key,
+        ANTHROPIC_DEFAULT_OPUS_MODEL: ctx.opus,
+        ANTHROPIC_DEFAULT_SONNET_MODEL: ctx.sonnet,
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: ctx.haiku,
+        API_TIMEOUT_MS: "600000",
+      },
+    };
+
+    const notes = [];
+    if (ctx.statusline) {
+      const slFile = statuslinePath();
+      fsu.writeText(slFile, STATUSLINE_SRC);
+      try {
+        fs.chmodSync(slFile, 0o755);
+      } catch {}
+      const ours = 'node "' + slFile.replace(/\\/g, "/") + '"';
+      const existing = current.statusLine && current.statusLine.command;
+      if (existing && !existing.includes("z0ne-statusline")) {
+        notes.push("kept your existing statusLine (" + existing + ")");
+      } else {
+        merged.statusLine = { type: "command", command: ours };
+      }
+    }
+
+    fsu.writeJson(file, merged);
+    return { paths: [file].concat(ctx.statusline ? [statuslinePath()] : []), notes };
+  },
+
+  remove() {
+    const file = settingsPath();
+    const current = fsu.readJson(file);
+    if (!current) return { paths: [], notes: ["no settings file found"] };
+
+    if (current.env) {
+      for (const k of ENV_KEYS) delete current.env[k];
+      if (!Object.keys(current.env).length) delete current.env;
+    }
+    const notes = [];
+    if (current.statusLine && String(current.statusLine.command || "").includes("z0ne-statusline")) {
+      delete current.statusLine;
+      try {
+        fs.unlinkSync(statuslinePath());
+        notes.push("removed " + statuslinePath());
+      } catch {}
+    }
+    fsu.writeJson(file, current);
+    return { paths: [file], notes };
+  },
+};

package/lib/tools/cline.js

@@ -0,0 +1,60 @@
+"use strict";
+// Cline CLI — ~/.cline/data/globalState.json + secrets.json
+// Uses the OpenAI-compatible provider; Cline expects the base URL WITHOUT /v1.
+
+const path = require("path");
+const fs = require("fs");
+const { home } = require("../fsutil");
+const fsu = require("../fsutil");
+
+const dataDir = () => path.join(home(), ".cline", "data");
+const statePath = () => path.join(dataDir(), "globalState.json");
+const secretsPath = () => path.join(dataDir(), "secrets.json");
+
+module.exports = {
+  id: "cline",
+  title: "Cline",
+  hint: "~/.cline/data/globalState.json",
+
+  detect() {
+    return fsu.commandExists("cline") || fs.existsSync(statePath());
+  },
+
+  apply(ctx) {
+    fsu.ensureDir(dataDir());
+
+    const state = fsu.readJson(statePath()) || {};
+    state.actModeApiProvider = "openai";
+    state.planModeApiProvider = "openai";
+    state.openAiBaseUrl = ctx.base;
+    state.openAiModelId = ctx.model;
+    state.planModeOpenAiModelId = ctx.model;
+    fsu.writeJson(statePath(), state);
+
+    const secrets = fsu.readJson(secretsPath()) || {};
+    secrets.openAiApiKey = ctx.key;
+    fsu.writeJson(secretsPath(), secrets);
+
+    return { paths: [statePath(), secretsPath()], notes: [] };
+  },
+
+  remove() {
+    const state = fsu.readJson(statePath());
+    if (!state) return { paths: [], notes: ["no state file found"] };
+
+    if (state.actModeApiProvider === "openai") {
+      delete state.openAiBaseUrl;
+      delete state.openAiModelId;
+      delete state.planModeOpenAiModelId;
+      state.actModeApiProvider = "cline";
+      state.planModeApiProvider = "cline";
+    }
+    fsu.writeJson(statePath(), state);
+
+    const secrets = fsu.readJson(secretsPath()) || {};
+    delete secrets.openAiApiKey;
+    fsu.writeJson(secretsPath(), secrets);
+
+    return { paths: [statePath(), secretsPath()], notes: [] };
+  },
+};

package/lib/tools/codex.js

@@ -0,0 +1,136 @@
+"use strict";
+// Codex CLI — ~/.codex/config.toml + auth.json + auth-command token helper.
+//
+// The token helper matters: Codex only refreshes the live model catalog
+// (GET {base_url}/models) when [model_providers.*.auth] command is set AND
+// actually starts. On Windows codex.exe spawns the command via CreateProcess,
+// so a .sh file fails with os error 193 and the catalog fetch is silently
+// skipped — the model picker would only show Codex's bundled models. Hence
+// the .cmd shim with absolute paths baked in (HOME/CODEX_HOME are not set
+// when Codex is launched from cmd or PowerShell).
+//
+// Provider key is "z0neai" to merge cleanly with configs written by the
+// earlier z0ne-codex.sh bootstrap.
+
+const path = require("path");
+const fs = require("fs");
+const { home, isWindows } = require("../fsutil");
+const fsu = require("../fsutil");
+const { tstr, setTomlKey, getTomlKey, removeTomlSection, removeTomlKey } = require("../toml");
+
+const PROVIDER = "z0neai";
+const codexDir = () => process.env.CODEX_HOME || path.join(home(), ".codex");
+const configPath = () => path.join(codexDir(), "config.toml");
+const authPath = () => path.join(codexDir(), "auth.json");
+const helperPath = () => path.join(codexDir(), isWindows ? "z0ne-token.cmd" : "z0ne-token.sh");
+
+const fwd = (p) => p.replace(/\\/g, "/");
+
+function writeTokenHelper() {
+  const helper = helperPath();
+  const node = process.execPath;
+  const auth = authPath();
+  let src;
+  if (isWindows) {
+    src =
+      "@echo off\r\n" +
+      '"' + node + '" -e "console.log(require(\'' + fwd(auth) + "').OPENAI_API_KEY)\"\r\n";
+  } else {
+    src =
+      "#!/bin/sh\n" +
+      "# Prints the z0ne.ai API key for Codex provider auth.command.\n" +
+      'exec "' + node + '" -e "console.log(require(\'' + auth + "').OPENAI_API_KEY)\"\n";
+  }
+  fsu.writeText(helper, src);
+  if (!isWindows) fs.chmodSync(helper, 0o700);
+  return helper;
+}
+
+module.exports = {
+  id: "codex",
+  title: "Codex CLI",
+  hint: "~/.codex/config.toml",
+
+  detect() {
+    return fsu.commandExists("codex") || fs.existsSync(configPath());
+  },
+
+  apply(ctx) {
+    fsu.ensureDir(codexDir());
+
+    // auth.json — merge; keep any ChatGPT-login tokens untouched.
+    const auth = fsu.readJson(authPath()) || {};
+    auth.auth_mode = "apikey";
+    auth.OPENAI_API_KEY = ctx.key;
+    fsu.writeJson(authPath(), auth);
+    try {
+      fs.chmodSync(authPath(), 0o600);
+    } catch {}
+
+    const helper = writeTokenHelper();
+
+    // config.toml — line-based merge that preserves the user's comments,
+    // other providers, and unrelated settings.
+    let toml = fsu.readText(configPath()) || "";
+    toml = setTomlKey(toml, "model", tstr(ctx.model));
+    toml = setTomlKey(toml, "model_provider", tstr(PROVIDER));
+    toml = setTomlKey(toml, "model_reasoning_effort", tstr("medium"));
+
+    const prov = "model_providers." + PROVIDER;
+    toml = setTomlKey(toml, "name", tstr("z0ne.ai"), prov);
+    toml = setTomlKey(toml, "base_url", tstr(ctx.base + "/v1"), prov);
+    toml = setTomlKey(toml, "wire_api", tstr("responses"), prov);
+
+    toml = setTomlKey(toml, "command", tstr(fwd(helper)), prov + ".auth");
+    toml = setTomlKey(toml, "timeout_ms", "5000", prov + ".auth");
+    toml = setTomlKey(toml, "refresh_interval_ms", "0", prov + ".auth");
+
+    toml = setTomlKey(toml, "description", tstr("Default subagent"), "agents.subagent");
+    toml = setTomlKey(toml, "model", tstr(ctx.model), "agents.subagent");
+
+    fsu.writeText(configPath(), toml);
+    try {
+      fs.chmodSync(configPath(), 0o600);
+    } catch {}
+
+    return { paths: [configPath(), authPath(), helper], notes: [] };
+  },
+
+  remove() {
+    const notes = [];
+    let toml = fsu.readText(configPath());
+    if (toml !== null) {
+      const provider = getTomlKey(toml, "model_provider");
+      if (provider === PROVIDER || provider === "z0ne") {
+        toml = removeTomlKey(toml, "model");
+        toml = removeTomlKey(toml, "model_provider");
+        toml = removeTomlKey(toml, "model_reasoning_effort");
+      }
+      // Clean both the installer's section and the legacy console one.
+      toml = removeTomlSection(toml, "model_providers." + PROVIDER);
+      toml = removeTomlSection(toml, "model_providers.z0ne");
+      toml = removeTomlSection(toml, "agents.subagent");
+      fsu.writeText(configPath(), toml);
+    } else {
+      notes.push("no config.toml found");
+    }
+
+    const auth = fsu.readJson(authPath());
+    if (auth) {
+      delete auth.OPENAI_API_KEY;
+      delete auth.auth_mode;
+      if (Object.keys(auth).length) fsu.writeJson(authPath(), auth);
+      else {
+        fsu.backupFile(authPath());
+        fs.unlinkSync(authPath());
+      }
+    }
+
+    for (const f of [path.join(codexDir(), "z0ne-token.cmd"), path.join(codexDir(), "z0ne-token.sh")]) {
+      try {
+        fs.unlinkSync(f);
+      } catch {}
+    }
+    return { paths: toml !== null ? [configPath()] : [], notes };
+  },
+};

package/lib/tools/hermes.js

@@ -0,0 +1,71 @@
+"use strict";
+// Hermes Agent — ~/.hermes/config.yaml (model block) + ~/.hermes/.env (key).
+// The model block is replaced/inserted with a regex so the rest of the YAML
+// (tools, memory, etc.) is preserved verbatim.
+
+const path = require("path");
+const fs = require("fs");
+const { home } = require("../fsutil");
+const fsu = require("../fsutil");
+
+const hermesDir = () => path.join(home(), ".hermes");
+const configPath = () => path.join(hermesDir(), "config.yaml");
+const envPath = () => path.join(hermesDir(), ".env");
+
+// Top-level "model:" block, up to the next non-indented line.
+const MODEL_BLOCK_RE = /^model:[ \t]*\r?\n((?:[ \t]+.*\r?\n?|[ \t]*\r?\n)*)/m;
+
+const buildModelBlock = (model, baseUrl) =>
+  'model:\n  default: "' + model + '"\n  provider: "custom"\n  base_url: "' + baseUrl + '"\n';
+
+const upsertEnvVar = (envText, key, value) => {
+  const re = new RegExp("^" + key + "=.*$", "m");
+  const line = key + "=" + value;
+  if (re.test(envText)) return envText.replace(re, line);
+  if (envText.length > 0 && !envText.endsWith("\n")) return envText + "\n" + line + "\n";
+  return envText + line + "\n";
+};
+
+module.exports = {
+  id: "hermes",
+  title: "Hermes Agent",
+  hint: "~/.hermes/config.yaml",
+
+  detect() {
+    return fsu.commandExists("hermes") || fs.existsSync(configPath());
+  },
+
+  apply(ctx) {
+    fsu.ensureDir(hermesDir());
+
+    const block = buildModelBlock(ctx.model, ctx.base + "/v1");
+    const yaml = fsu.readText(configPath()) || "";
+    const newYaml = MODEL_BLOCK_RE.test(yaml)
+      ? yaml.replace(MODEL_BLOCK_RE, block)
+      : yaml.length > 0
+        ? block + "\n" + yaml
+        : block;
+    fsu.writeText(configPath(), newYaml);
+
+    const env = fsu.readText(envPath()) || "";
+    fsu.writeText(envPath(), upsertEnvVar(env, "OPENAI_API_KEY", ctx.key));
+    try {
+      fs.chmodSync(envPath(), 0o600);
+    } catch {}
+
+    return { paths: [configPath(), envPath()], notes: [] };
+  },
+
+  remove() {
+    const yaml = fsu.readText(configPath());
+    if (yaml === null) return { paths: [], notes: ["no config file found"] };
+
+    fsu.writeText(configPath(), yaml.replace(MODEL_BLOCK_RE, "").replace(/^\n+/, ""));
+
+    const env = fsu.readText(envPath());
+    if (env !== null) {
+      fsu.writeText(envPath(), env.replace(/^OPENAI_API_KEY=.*\r?\n?/m, ""));
+    }
+    return { paths: [configPath()], notes: [] };
+  },
+};

package/lib/tools/openclaw.js

@@ -0,0 +1,117 @@
+"use strict";
+// OpenClaw — ~/.openclaw/openclaw.json (+ per-agent models.json files).
+// Registers z0ne.ai under models.providers, allowlists the model, and sets
+// agents.defaults.model.primary to z0ne/<id>. OpenClaw 2026.5.x stores
+// agents[].model either as a plain string or as { primary, fallbacks } —
+// normalize before any .startsWith().
+
+const path = require("path");
+const fs = require("fs");
+const { home } = require("../fsutil");
+const fsu = require("../fsutil");
+
+const clawDir = () => path.join(home(), ".openclaw");
+const settingsPath = () => path.join(clawDir(), "openclaw.json");
+
+const resolveAgentModel = (m) => {
+  if (typeof m === "string") return m;
+  if (m && typeof m === "object") return m.primary || "";
+  return "";
+};
+
+function writeAgentModels(agentDir, model, baseUrl, apiKey) {
+  fsu.ensureDir(agentDir);
+  const modelsPath = path.join(agentDir, "models.json");
+  const existing = fsu.readJson(modelsPath) || {};
+  if (!existing.providers) existing.providers = {};
+  existing.providers.z0ne = {
+    baseUrl,
+    apiKey,
+    api: "openai-completions",
+    models: [{ id: model, name: model.split("/").pop() || model }],
+  };
+  fsu.writeJson(modelsPath, existing);
+  return modelsPath;
+}
+
+module.exports = {
+  id: "openclaw",
+  title: "OpenClaw",
+  hint: "~/.openclaw/openclaw.json",
+
+  detect() {
+    return fsu.commandExists("openclaw") || fs.existsSync(settingsPath());
+  },
+
+  apply(ctx) {
+    fsu.ensureDir(clawDir());
+    const settings = fsu.readJson(settingsPath()) || {};
+
+    if (!settings.agents) settings.agents = {};
+    if (!settings.agents.defaults) settings.agents.defaults = {};
+    if (!settings.agents.defaults.model) settings.agents.defaults.model = {};
+    if (!settings.agents.defaults.models) settings.agents.defaults.models = {};
+    if (!settings.models) settings.models = {};
+    if (!settings.models.providers) settings.models.providers = {};
+
+    const baseUrl = ctx.base + "/v1";
+    const fullModelId = "z0ne/" + ctx.model;
+
+    // Replace any stale z0ne/* allowlist entries with the fresh one.
+    for (const k of Object.keys(settings.agents.defaults.models)) {
+      if (k.startsWith("z0ne/")) delete settings.agents.defaults.models[k];
+    }
+    settings.agents.defaults.model.primary = fullModelId;
+    settings.agents.defaults.models[fullModelId] = {};
+
+    settings.models.providers.z0ne = {
+      baseUrl,
+      apiKey: ctx.key,
+      api: "openai-completions",
+      models: [{ id: ctx.model, name: ctx.model.split("/").pop() || ctx.model }],
+    };
+
+    const paths = [settingsPath()];
+    if (Array.isArray(settings.agents.list)) {
+      // Drop stale per-agent z0ne models so the new default applies, then
+      // refresh each agent's models.json.
+      settings.agents.list = settings.agents.list.map((agent) => {
+        if (resolveAgentModel(agent.model).startsWith("z0ne/")) {
+          const { model: _drop, ...rest } = agent;
+          return rest;
+        }
+        return agent;
+      });
+      for (const agent of settings.agents.list) {
+        if (agent.agentDir) paths.push(writeAgentModels(agent.agentDir, ctx.model, baseUrl, ctx.key));
+      }
+    }
+
+    fsu.writeJson(settingsPath(), settings);
+    return { paths, notes: [] };
+  },
+
+  remove() {
+    const settings = fsu.readJson(settingsPath());
+    if (!settings) return { paths: [], notes: ["no settings file found"] };
+
+    if (settings.models && settings.models.providers) {
+      delete settings.models.providers.z0ne;
+      if (!Object.keys(settings.models.providers).length) delete settings.models.providers;
+    }
+    if (settings.agents && settings.agents.defaults) {
+      const defaults = settings.agents.defaults;
+      if (defaults.models) {
+        for (const k of Object.keys(defaults.models)) {
+          if (k.startsWith("z0ne/")) delete defaults.models[k];
+        }
+        if (!Object.keys(defaults.models).length) delete defaults.models;
+      }
+      if (defaults.model && String(defaults.model.primary || "").startsWith("z0ne/")) {
+        delete defaults.model.primary;
+      }
+    }
+    fsu.writeJson(settingsPath(), settings);
+    return { paths: [settingsPath()], notes: [] };
+  },
+};

package/lib/tools/opencode.js

@@ -0,0 +1,76 @@
+"use strict";
+// OpenCode — ~/.config/opencode/opencode.json
+// Registers z0ne.ai as an @ai-sdk/openai-compatible provider and sets the
+// active model to z0ne/<id>. Image input modality follows the live catalog.
+
+const path = require("path");
+const fs = require("fs");
+const { home } = require("../fsutil");
+const fsu = require("../fsutil");
+
+const configDir = () => path.join(home(), ".config", "opencode");
+const configPath = () => path.join(configDir(), "opencode.json");
+
+module.exports = {
+  id: "opencode",
+  title: "OpenCode",
+  hint: "~/.config/opencode/opencode.json",
+
+  detect() {
+    return fsu.commandExists("opencode") || fs.existsSync(configPath());
+  },
+
+  apply(ctx) {
+    const config = fsu.readJson(configPath()) || {};
+    if (!config.provider) config.provider = {};
+
+    const existing = config.provider.z0ne || {
+      npm: "@ai-sdk/openai-compatible",
+      options: {},
+      models: {},
+    };
+    existing.options = {
+      ...existing.options,
+      baseURL: ctx.base + "/v1",
+      apiKey: ctx.key,
+    };
+    existing.models = existing.models || {};
+
+    const row = ctx.rowsById[ctx.model];
+    const inputs =
+      row && Array.isArray(row.input_modalities) && row.input_modalities.includes("image")
+        ? ["text", "image"]
+        : ["text"];
+    existing.models[ctx.model] = {
+      name: ctx.model,
+      modalities: { input: inputs, output: ["text"] },
+    };
+
+    config.provider.z0ne = existing;
+    config.model = "z0ne/" + ctx.model;
+
+    if (!config.agent) config.agent = {};
+    config.agent.explorer = {
+      description: "Fast explorer subagent for codebase exploration",
+      mode: "subagent",
+      model: "z0ne/" + ctx.model,
+    };
+
+    fsu.writeJson(configPath(), config);
+    return { paths: [configPath()], notes: [] };
+  },
+
+  remove() {
+    const config = fsu.readJson(configPath());
+    if (!config) return { paths: [], notes: ["no config file found"] };
+
+    if (config.provider) delete config.provider.z0ne;
+    if (config.model && config.model.startsWith("z0ne/")) delete config.model;
+    if (config.agent && config.agent.explorer && String(config.agent.explorer.model || "").startsWith("z0ne/")) {
+      delete config.agent.explorer;
+      if (!Object.keys(config.agent).length) delete config.agent;
+    }
+    fsu.writeJson(configPath(), config);
+    return { paths: [configPath()], notes: [] };
+  },
+};