@openclawcity/become 1.0.13 → 1.0.19

package/dist/cli.cjs

@@ -98,146 +98,187 @@ var import_node_path2 = require("path");
 var import_node_os2 = require("os");
 var import_node_child_process = require("child_process");
 var OPENCLAW_CONFIG = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".openclaw", "openclaw.json");
-var BACKUP_PATH = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".become", "state", "original_openclaw.json");
-var ORIGINAL_MODEL_PATH = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".become", "state", "original_model.txt");
-var PATCHED_AGENT_PATH = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".become", "state", "patched_agent.txt");
-function patchOpenClaw(config, agentId) {
+var STATE_DIR = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".become", "state");
+var BACKUP_PATH = (0, import_node_path2.join)(STATE_DIR, "original_openclaw.json");
+var ORIGINAL_URL_PATH = (0, import_node_path2.join)(STATE_DIR, "original_base_url.txt");
+var PATCHED_PROVIDER_PATH = (0, import_node_path2.join)(STATE_DIR, "patched_provider.txt");
+function patchOpenClaw(config) {
   if (!(0, import_node_fs2.existsSync)(OPENCLAW_CONFIG)) {
     throw new Error(`OpenClaw config not found at ${OPENCLAW_CONFIG}`);
   }
   const raw = (0, import_node_fs2.readFileSync)(OPENCLAW_CONFIG, "utf-8");
-  const clawConfig = parseOpenClawConfig(raw);
-  if (clawConfig.models?.providers?.become) {
-    console.log("become is already connected. Run `become off` first to disconnect.");
-    return;
+  const clawConfig = parseConfig(raw);
+  (0, import_node_fs2.mkdirSync)(STATE_DIR, { recursive: true });
+  const primaryModel = clawConfig.agents?.defaults?.model?.primary ?? "";
+  if (!primaryModel) {
+    throw new Error("No default model configured in openclaw.json (agents.defaults.model.primary)");
+  }
+  const providerName = primaryModel.split("/")[0];
+  if (!providerName) {
+    throw new Error(`Cannot determine provider from model: ${primaryModel}`);
+  }
+  if ((0, import_node_fs2.existsSync)(ORIGINAL_URL_PATH)) {
+    const existingUrl = (0, import_node_fs2.readFileSync)(ORIGINAL_URL_PATH, "utf-8").trim();
+    if (existingUrl) {
+      console.log("become is already connected. Run `become off` first to disconnect.");
+      return;
+    }
+  }
+  const modelsJsonPath = getModelsJsonPath(clawConfig);
+  let modelsConfig = null;
+  let modelsSource = "openclaw.json";
+  if (modelsJsonPath && (0, import_node_fs2.existsSync)(modelsJsonPath)) {
+    modelsConfig = JSON.parse((0, import_node_fs2.readFileSync)(modelsJsonPath, "utf-8"));
+    modelsSource = "models.json";
+  }
+  let provider = null;
+  let providerLocation = null;
+  if (modelsConfig?.providers?.[providerName]) {
+    provider = modelsConfig.providers[providerName];
+    providerLocation = modelsConfig.providers;
+  } else if (clawConfig.models?.providers?.[providerName]) {
+    provider = clawConfig.models.providers[providerName];
+    providerLocation = clawConfig.models.providers;
+    modelsSource = "openclaw.json";
+  }
+  if (!provider) {
+    throw new Error(
+      `Provider "${providerName}" not found in models.json or openclaw.json. Your model is "${primaryModel}" which needs a "${providerName}" provider.`
+    );
+  }
+  const originalUrl = provider.baseUrl;
+  if (!originalUrl) {
+    throw new Error(`Provider "${providerName}" has no baseUrl`);
   }
-  (0, import_node_fs2.mkdirSync)((0, import_node_path2.join)((0, import_node_os2.homedir)(), ".become", "state"), { recursive: true });
   (0, import_node_fs2.writeFileSync)(BACKUP_PATH, raw, "utf-8");
-  const agents = clawConfig.agents?.list ?? [];
-  let originalModel;
-  let patchedAgentId;
-  if (agents.length > 0 && agentId) {
-    const agent = agents.find((a) => a.id === agentId);
-    if (!agent) {
-      throw new Error(`Agent "${agentId}" not found in agents.list. Available: ${agents.map((a) => a.id).join(", ")}`);
-    }
-    originalModel = agent.model ?? clawConfig.agents?.defaults?.model?.primary ?? "";
-    patchedAgentId = agentId;
-    const modelId2 = stripProvider(originalModel);
-    if (!modelId2) {
-      throw new Error("No model configured for this agent. Set a model in openclaw.json first.");
-    }
-    agent.model = `become/${modelId2}`;
+  (0, import_node_fs2.writeFileSync)(ORIGINAL_URL_PATH, originalUrl, "utf-8");
+  (0, import_node_fs2.writeFileSync)(PATCHED_PROVIDER_PATH, `${providerName}:${modelsSource}`, "utf-8");
+  provider.baseUrl = `http://127.0.0.1:${config.proxy_port}`;
+  if (modelsSource === "models.json" && modelsJsonPath) {
+    (0, import_node_fs2.writeFileSync)(modelsJsonPath, JSON.stringify(modelsConfig, null, 2), "utf-8");
   } else {
-    originalModel = clawConfig.agents?.defaults?.model?.primary ?? "";
-    patchedAgentId = "_defaults";
-    const modelId2 = stripProvider(originalModel);
-    if (!modelId2) {
-      throw new Error("No default model configured. Set agents.defaults.model.primary in openclaw.json first.");
-    }
-    if (!clawConfig.agents) clawConfig.agents = {};
-    if (!clawConfig.agents.defaults) clawConfig.agents.defaults = {};
-    if (!clawConfig.agents.defaults.model) clawConfig.agents.defaults.model = {};
-    clawConfig.agents.defaults.model.primary = `become/${modelId2}`;
-  }
-  (0, import_node_fs2.writeFileSync)(ORIGINAL_MODEL_PATH, originalModel, "utf-8");
-  (0, import_node_fs2.writeFileSync)(PATCHED_AGENT_PATH, patchedAgentId, "utf-8");
-  const modelId = stripProvider(originalModel);
-  if (!clawConfig.models) clawConfig.models = {};
-  if (!clawConfig.models.providers) clawConfig.models.providers = {};
-  clawConfig.models.providers.become = {
-    api: config.llm_provider === "openai" || config.llm_provider === "openrouter" ? "openai-completions" : "anthropic-messages",
-    baseUrl: `http://127.0.0.1:${config.proxy_port}`,
-    apiKey: config.llm_api_key,
-    models: [
-      { id: modelId, name: `${modelId} via become` }
-    ]
-  };
-  (0, import_node_fs2.writeFileSync)(OPENCLAW_CONFIG, JSON.stringify(clawConfig, null, 2), "utf-8");
-  console.log("Restarting OpenClaw gateway...");
-  try {
-    (0, import_node_child_process.execSync)("openclaw gateway restart", { stdio: "pipe", timeout: 15e3 });
-    console.log("OpenClaw gateway restarted. Your agent is now routing through become.");
-  } catch {
-    console.log("\n*** OpenClaw gateway needs a manual restart to pick up the new config. ***");
-    console.log("*** Run: openclaw gateway restart ***\n");
+    (0, import_node_fs2.writeFileSync)(OPENCLAW_CONFIG, JSON.stringify(clawConfig, null, 2), "utf-8");
   }
+  console.log(`  provider: ${providerName}`);
+  console.log(`  baseUrl: ${originalUrl} -> localhost:${config.proxy_port}`);
+  restartGateway();
 }
 function restoreOpenClaw() {
-  if (!(0, import_node_fs2.existsSync)(OPENCLAW_CONFIG)) {
-    throw new Error(`OpenClaw config not found at ${OPENCLAW_CONFIG}`);
+  const originalUrl = readSafe(ORIGINAL_URL_PATH);
+  const patchInfo = readSafe(PATCHED_PROVIDER_PATH);
+  if (!originalUrl || !patchInfo) {
+    cleanState();
+    return;
   }
-  if ((0, import_node_fs2.existsSync)(BACKUP_PATH)) {
-    const backup = (0, import_node_fs2.readFileSync)(BACKUP_PATH, "utf-8");
-    const backupConfig = parseOpenClawConfig(backup);
-    if (!backupConfig.models?.providers?.become) {
-      (0, import_node_fs2.writeFileSync)(OPENCLAW_CONFIG, backup, "utf-8");
-      restartGateway();
-      return;
+  const [providerName, source] = patchInfo.split(":");
+  if (source === "models.json") {
+    const clawConfig = parseConfig((0, import_node_fs2.readFileSync)(OPENCLAW_CONFIG, "utf-8"));
+    const modelsJsonPath = getModelsJsonPath(clawConfig);
+    if (modelsJsonPath && (0, import_node_fs2.existsSync)(modelsJsonPath)) {
+      const modelsConfig = JSON.parse((0, import_node_fs2.readFileSync)(modelsJsonPath, "utf-8"));
+      if (modelsConfig.providers?.[providerName]) {
+        modelsConfig.providers[providerName].baseUrl = originalUrl;
+        (0, import_node_fs2.writeFileSync)(modelsJsonPath, JSON.stringify(modelsConfig, null, 2), "utf-8");
+      }
+    }
+  } else {
+    if ((0, import_node_fs2.existsSync)(OPENCLAW_CONFIG)) {
+      const clawConfig = parseConfig((0, import_node_fs2.readFileSync)(OPENCLAW_CONFIG, "utf-8"));
+      if (clawConfig.models?.providers?.[providerName]) {
+        clawConfig.models.providers[providerName].baseUrl = originalUrl;
+        (0, import_node_fs2.writeFileSync)(OPENCLAW_CONFIG, JSON.stringify(clawConfig, null, 2), "utf-8");
+      }
     }
   }
-  const raw = (0, import_node_fs2.readFileSync)(OPENCLAW_CONFIG, "utf-8");
-  const config = parseOpenClawConfig(raw);
-  const patchedAgentId = readStateFile(PATCHED_AGENT_PATH);
-  const originalModel = readStateFile(ORIGINAL_MODEL_PATH);
-  if (originalModel) {
-    const agents = config.agents?.list ?? [];
-    if (patchedAgentId && patchedAgentId !== "_defaults") {
-      const agent = agents.find((a) => a.id === patchedAgentId);
-      if (agent) {
-        agent.model = originalModel;
+  cleanLegacy();
+  cleanState();
+  restartGateway();
+}
+function cleanLegacy() {
+  if ((0, import_node_fs2.existsSync)(OPENCLAW_CONFIG)) {
+    try {
+      const config = parseConfig((0, import_node_fs2.readFileSync)(OPENCLAW_CONFIG, "utf-8"));
+      let changed = false;
+      if (config.models?.providers?.become) {
+        delete config.models.providers.become;
+        changed = true;
       }
-    } else {
-      if (config.agents?.defaults?.model) {
-        config.agents.defaults.model.primary = originalModel;
+      const primary = config.agents?.defaults?.model?.primary ?? "";
+      if (primary.startsWith("become/")) {
+        config.agents.defaults.model.primary = "openrouter/" + primary.slice("become/".length);
+        changed = true;
+      }
+      for (const prov of Object.values(config.models?.providers ?? {})) {
+        if (prov && typeof prov === "object" && "_originalModel" in prov) {
+          delete prov._originalModel;
+          changed = true;
+        }
       }
+      if (changed) (0, import_node_fs2.writeFileSync)(OPENCLAW_CONFIG, JSON.stringify(config, null, 2), "utf-8");
+    } catch {
     }
   }
-  if (config.models?.providers?.become) {
-    delete config.models.providers.become;
-  }
-  for (const provider of Object.values(config.models?.providers ?? {})) {
-    if (provider && typeof provider === "object" && "_originalModel" in provider) {
-      delete provider._originalModel;
+  try {
+    const clawConfig = parseConfig((0, import_node_fs2.readFileSync)(OPENCLAW_CONFIG, "utf-8"));
+    const modelsJsonPath = getModelsJsonPath(clawConfig);
+    if (modelsJsonPath && (0, import_node_fs2.existsSync)(modelsJsonPath)) {
+      const models = JSON.parse((0, import_node_fs2.readFileSync)(modelsJsonPath, "utf-8"));
+      let changed = false;
+      if (models.providers?.become) {
+        delete models.providers.become;
+        changed = true;
+      }
+      if (changed) (0, import_node_fs2.writeFileSync)(modelsJsonPath, JSON.stringify(models, null, 2), "utf-8");
     }
+  } catch {
   }
-  (0, import_node_fs2.writeFileSync)(OPENCLAW_CONFIG, JSON.stringify(config, null, 2), "utf-8");
-  restartGateway();
 }
 function listOpenClawAgents() {
   if (!(0, import_node_fs2.existsSync)(OPENCLAW_CONFIG)) return [];
   try {
-    const config = parseOpenClawConfig((0, import_node_fs2.readFileSync)(OPENCLAW_CONFIG, "utf-8"));
+    const config = parseConfig((0, import_node_fs2.readFileSync)(OPENCLAW_CONFIG, "utf-8"));
     const agents = config.agents?.list ?? [];
-    const defaultModel = unbecome(config.agents?.defaults?.model?.primary ?? "unknown");
+    const defaultModel = config.agents?.defaults?.model?.primary ?? "unknown";
     if (agents.length === 0) {
       return [{ id: "_defaults", model: defaultModel }];
     }
     return agents.map((a) => ({
       id: a.id,
-      model: unbecome(a.model ?? defaultModel)
+      model: a.model ?? defaultModel
     }));
   } catch {
     return [];
   }
 }
-function stripProvider(model) {
-  return model.includes("/") ? model.split("/").slice(1).join("/") : model;
-}
-function unbecome(model) {
-  return model.startsWith("become/") ? model.replace("become/", "") : model;
+function getModelsJsonPath(clawConfig) {
+  const agentList = clawConfig.agents?.list ?? [];
+  const defaultAgent = agentList.find((a) => a.default) ?? agentList[0];
+  if (defaultAgent?.agentDir) {
+    return (0, import_node_path2.join)(defaultAgent.agentDir.replace("~", (0, import_node_os2.homedir)()), "models.json");
+  }
+  const mainPath = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".openclaw", "agents", "main", "agent", "models.json");
+  if ((0, import_node_fs2.existsSync)(mainPath)) return mainPath;
+  return null;
 }
-function parseOpenClawConfig(raw) {
+function parseConfig(raw) {
   const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([\]}])/g, "$1");
   return JSON.parse(stripped);
 }
-function readStateFile(path) {
+function readSafe(path) {
   try {
     return (0, import_node_fs2.existsSync)(path) ? (0, import_node_fs2.readFileSync)(path, "utf-8").trim() : "";
   } catch {
     return "";
   }
 }
+function cleanState() {
+  for (const f of [ORIGINAL_URL_PATH, PATCHED_PROVIDER_PATH]) {
+    try {
+      (0, import_node_fs2.writeFileSync)(f, "", "utf-8");
+    } catch {
+    }
+  }
+}
 function restartGateway() {
   console.log("Restarting OpenClaw gateway...");
   try {
@@ -323,6 +364,11 @@ Proxy port (default 30001): `);
   }
 }
 
+// src/cli/commands.ts
+var import_node_fs7 = require("fs");
+var import_node_path7 = require("path");
+var import_node_os5 = require("os");
+
 // src/proxy/server.ts
 var import_node_http = require("http");
 
@@ -749,7 +795,7 @@ Rules:
 
 // src/proxy/server.ts
 var SKILL_CACHE_TTL_MS = 5e3;
-function createProxyServer(config, analyzer) {
+function createProxyServer(config, analyzer, overrideUpstreamUrl) {
   const store = new FileSkillStore({ baseDir: config.baseDir });
   const trust = new TrustManager(config.baseDir);
   const extractor = analyzer ? new LessonExtractor(store, trust, analyzer) : null;
@@ -796,7 +842,7 @@ function createProxyServer(config, analyzer) {
           stats.skills_injected++;
         }
       }
-      const upstreamUrl = buildUpstreamUrl(config, req.url);
+      const upstreamUrl = buildUpstreamUrl(overrideUpstreamUrl ?? config.llm_base_url, req.url);
       const upstreamHeaders = buildUpstreamHeaders(config, req.headers);
       const isStreaming = body.stream === true;
       const modifiedBody = JSON.stringify(body);
@@ -880,8 +926,8 @@ function readBody(req) {
     req.on("error", reject);
   });
 }
-function buildUpstreamUrl(config, path) {
-  const base = config.llm_base_url.replace(/\/+$/, "");
+function buildUpstreamUrl(baseUrl, path) {
+  const base = baseUrl.replace(/\/+$/, "");
   return `${base}${path}`;
 }
 function buildUpstreamHeaders(config, incomingHeaders) {
@@ -1433,49 +1479,88 @@ var import_node_fs5 = require("fs");
 var import_node_path5 = require("path");
 var import_node_os3 = require("os");
 var import_node_child_process2 = require("child_process");
-var IRONCLAW_ENV = (0, import_node_path5.join)((0, import_node_os3.homedir)(), ".ironclaw", ".env");
+var IRONCLAW_ENV = (0, import_node_path5.join)(process.env.IRONCLAW_BASE_DIR ?? (0, import_node_path5.join)((0, import_node_os3.homedir)(), ".ironclaw"), ".env");
 var BACKUP_PATH2 = (0, import_node_path5.join)((0, import_node_os3.homedir)(), ".become", "state", "original_ironclaw.env");
 function patchIronClaw(config) {
   if (!(0, import_node_fs5.existsSync)(IRONCLAW_ENV)) {
     throw new Error(`IronClaw .env not found at ${IRONCLAW_ENV}`);
   }
+  if ((0, import_node_fs5.existsSync)(BACKUP_PATH2)) {
+    console.log("become is already connected to IronClaw. Run `become off` first.");
+    return;
+  }
   (0, import_node_fs5.mkdirSync)((0, import_node_path5.join)((0, import_node_os3.homedir)(), ".become", "state"), { recursive: true });
   (0, import_node_fs5.copyFileSync)(IRONCLAW_ENV, BACKUP_PATH2);
-  patchDotEnv(IRONCLAW_ENV, {
-    LLM_BASE_URL: `http://127.0.0.1:${config.proxy_port}/v1`
-  });
-  console.log("Restarting IronClaw...");
-  try {
-    (0, import_node_child_process2.execSync)("ironclaw service restart", { stdio: "pipe", timeout: 15e3 });
-    console.log("IronClaw restarted.");
-  } catch {
-    console.log("\n*** IronClaw needs a manual restart. ***");
-    console.log("*** Run: ironclaw service restart ***\n");
+  const content = (0, import_node_fs5.readFileSync)(IRONCLAW_ENV, "utf-8");
+  const backendMatch = content.match(/^LLM_BACKEND=(.+)$/m);
+  const backend = backendMatch?.[1]?.trim().toLowerCase() ?? "openai_compatible";
+  const proxyUrl = `http://127.0.0.1:${config.proxy_port}`;
+  const vars = {};
+  switch (backend) {
+    case "anthropic":
+      vars["ANTHROPIC_BASE_URL"] = proxyUrl;
+      break;
+    case "ollama":
+      vars["OLLAMA_BASE_URL"] = proxyUrl;
+      break;
+    case "nearai":
+    case "near_ai":
+    case "near":
+      vars["NEARAI_BASE_URL"] = proxyUrl;
+      break;
+    default:
+      vars["LLM_BASE_URL"] = proxyUrl;
+      break;
   }
+  patchDotEnv(IRONCLAW_ENV, vars);
+  console.log(`  backend: ${backend}`);
+  console.log(`  patched: ${Object.keys(vars).join(", ")} -> localhost:${config.proxy_port}`);
+  restartIronClaw();
 }
 function restoreIronClaw() {
   if (!(0, import_node_fs5.existsSync)(BACKUP_PATH2)) {
-    throw new Error("No backup found. Was become ever turned on?");
+    return;
   }
   (0, import_node_fs5.copyFileSync)(BACKUP_PATH2, IRONCLAW_ENV);
+  try {
+    (0, import_node_fs5.unlinkSync)(BACKUP_PATH2);
+  } catch {
+  }
+  restartIronClaw();
+}
+function restartIronClaw() {
   console.log("Restarting IronClaw...");
   try {
-    (0, import_node_child_process2.execSync)("ironclaw service restart", { stdio: "pipe", timeout: 15e3 });
+    (0, import_node_child_process2.execSync)("ironclaw service stop", { stdio: "pipe", timeout: 1e4 });
+    (0, import_node_child_process2.execSync)("ironclaw service start", { stdio: "pipe", timeout: 1e4 });
     console.log("IronClaw restarted.");
+    return;
+  } catch {
+  }
+  try {
+    (0, import_node_child_process2.execSync)("launchctl kickstart -k gui/$(id -u)/com.ironclaw.daemon", { stdio: "pipe", timeout: 1e4 });
+    console.log("IronClaw restarted via launchctl.");
+    return;
   } catch {
-    console.log("\n*** IronClaw needs a manual restart. ***");
-    console.log("*** Run: ironclaw service restart ***\n");
   }
+  try {
+    (0, import_node_child_process2.execSync)("systemctl --user restart ironclaw", { stdio: "pipe", timeout: 1e4 });
+    console.log("IronClaw restarted via systemd.");
+    return;
+  } catch {
+  }
+  console.log("\n*** IronClaw needs a manual restart. ***");
+  console.log("*** Run: ironclaw service stop && ironclaw service start ***\n");
 }
 function patchDotEnv(path, vars) {
-  let content = (0, import_node_fs5.readFileSync)(path, "utf-8");
+  let content = (0, import_node_fs5.existsSync)(path) ? (0, import_node_fs5.readFileSync)(path, "utf-8") : "";
   for (const [key, value] of Object.entries(vars)) {
     const regex = new RegExp(`^${key}=.*$`, "m");
     if (regex.test(content)) {
       content = content.replace(regex, `${key}=${value}`);
     } else {
-      content += `
-${key}=${value}`;
+      content = content.trimEnd() + (content.length > 0 ? "\n" : "") + `${key}=${value}
+`;
     }
   }
   (0, import_node_fs5.writeFileSync)(path, content, "utf-8");
@@ -1487,40 +1572,88 @@ var import_node_path6 = require("path");
 var import_node_os4 = require("os");
 var import_node_child_process3 = require("child_process");
 var BACKUP_PATH3 = (0, import_node_path6.join)((0, import_node_os4.homedir)(), ".become", "state", "original_nanoclaw.env");
+var PATCHED_ENV_PATH_FILE = (0, import_node_path6.join)((0, import_node_os4.homedir)(), ".become", "state", "nanoclaw_env_path.txt");
+var NANOCLAW_URL_VAR = "ANTHROPIC_BASE_URL";
 function patchNanoClaw(config) {
   const envPath = findNanoClawEnv();
   if (!envPath) {
-    throw new Error("Could not find NanoClaw .env. Set ANTHROPIC_BASE_URL manually to http://127.0.0.1:" + config.proxy_port);
+    throw new Error(
+      `Could not find NanoClaw .env file.
+NanoClaw stores .env in its project root (where you cloned it).
+Set ${NANOCLAW_URL_VAR}=http://127.0.0.1:${config.proxy_port} manually in your NanoClaw .env file.`
+    );
+  }
+  if ((0, import_node_fs6.existsSync)(BACKUP_PATH3)) {
+    console.log("become is already connected to NanoClaw. Run `become off` first.");
+    return;
   }
   (0, import_node_fs6.mkdirSync)((0, import_node_path6.join)((0, import_node_os4.homedir)(), ".become", "state"), { recursive: true });
   (0, import_node_fs6.copyFileSync)(envPath, BACKUP_PATH3);
+  (0, import_node_fs6.writeFileSync)(PATCHED_ENV_PATH_FILE, envPath, "utf-8");
   patchDotEnv2(envPath, {
-    ANTHROPIC_BASE_URL: `http://127.0.0.1:${config.proxy_port}`
+    [NANOCLAW_URL_VAR]: `http://127.0.0.1:${config.proxy_port}`
   });
+  console.log(`  env file: ${envPath}`);
+  console.log(`  patched: ${NANOCLAW_URL_VAR} -> localhost:${config.proxy_port}`);
   restartNanoClaw();
 }
 function restoreNanoClaw() {
-  const envPath = findNanoClawEnv();
-  if (!(0, import_node_fs6.existsSync)(BACKUP_PATH3) || !envPath) {
-    throw new Error("No backup found. Was become ever turned on?");
+  if (!(0, import_node_fs6.existsSync)(BACKUP_PATH3)) {
+    return;
+  }
+  let envPath = null;
+  if ((0, import_node_fs6.existsSync)(PATCHED_ENV_PATH_FILE)) {
+    envPath = (0, import_node_fs6.readFileSync)(PATCHED_ENV_PATH_FILE, "utf-8").trim();
+  }
+  if (!envPath) {
+    envPath = findNanoClawEnv();
+  }
+  if (!envPath) {
+    console.log("Warning: Cannot find NanoClaw .env to restore. Backup is at " + BACKUP_PATH3);
+    return;
   }
   (0, import_node_fs6.copyFileSync)(BACKUP_PATH3, envPath);
+  try {
+    (0, import_node_fs6.unlinkSync)(BACKUP_PATH3);
+  } catch {
+  }
+  try {
+    (0, import_node_fs6.unlinkSync)(PATCHED_ENV_PATH_FILE);
+  } catch {
+  }
   restartNanoClaw();
 }
 function findNanoClawEnv() {
-  const candidates = [
-    (0, import_node_path6.join)((0, import_node_os4.homedir)(), ".nanoclaw", ".env"),
-    (0, import_node_path6.join)((0, import_node_os4.homedir)(), ".config", "nanoclaw", ".env")
-  ];
-  const plistPath = (0, import_node_path6.join)((0, import_node_os4.homedir)(), "Library", "LaunchAgents", "ai.nanoclaw.agent.plist");
+  const candidates = [];
+  const plistPath = (0, import_node_path6.join)((0, import_node_os4.homedir)(), "Library", "LaunchAgents", "com.nanoclaw.plist");
   if ((0, import_node_fs6.existsSync)(plistPath)) {
     try {
       const plist = (0, import_node_fs6.readFileSync)(plistPath, "utf-8");
-      const match = plist.match(/<string>([^<]*\.env)<\/string>/);
-      if (match) candidates.unshift(match[1]);
+      const match = plist.match(/<key>WorkingDirectory<\/key>\s*<string>([^<]+)<\/string>/);
+      if (match) candidates.push((0, import_node_path6.join)(match[1], ".env"));
     } catch {
     }
   }
+  const userUnit = (0, import_node_path6.join)((0, import_node_os4.homedir)(), ".config", "systemd", "user", "nanoclaw.service");
+  if ((0, import_node_fs6.existsSync)(userUnit)) {
+    try {
+      const unit = (0, import_node_fs6.readFileSync)(userUnit, "utf-8");
+      const match = unit.match(/WorkingDirectory=(.+)/);
+      if (match) candidates.push((0, import_node_path6.join)(match[1].trim(), ".env"));
+    } catch {
+    }
+  }
+  const rootUnit = "/etc/systemd/system/nanoclaw.service";
+  if ((0, import_node_fs6.existsSync)(rootUnit)) {
+    try {
+      const unit = (0, import_node_fs6.readFileSync)(rootUnit, "utf-8");
+      const match = unit.match(/WorkingDirectory=(.+)/);
+      if (match) candidates.push((0, import_node_path6.join)(match[1].trim(), ".env"));
+    } catch {
+    }
+  }
+  candidates.push((0, import_node_path6.join)((0, import_node_os4.homedir)(), "nanoclaw", ".env"));
+  candidates.push("/opt/nanoclaw/.env");
   for (const path of candidates) {
     if ((0, import_node_fs6.existsSync)(path)) return path;
   }
@@ -1528,35 +1661,207 @@ function findNanoClawEnv() {
 }
 function restartNanoClaw() {
   console.log("Restarting NanoClaw...");
-  try {
-    (0, import_node_child_process3.execSync)("launchctl kickstart -k gui/$(id -u)/ai.nanoclaw.agent", { stdio: "pipe", timeout: 15e3 });
-    console.log("NanoClaw restarted.");
-  } catch {
+  const plistPath = (0, import_node_path6.join)((0, import_node_os4.homedir)(), "Library", "LaunchAgents", "com.nanoclaw.plist");
+  if ((0, import_node_fs6.existsSync)(plistPath)) {
     try {
-      (0, import_node_child_process3.execSync)("systemctl --user restart nanoclaw", { stdio: "pipe", timeout: 15e3 });
+      (0, import_node_child_process3.execSync)(`launchctl unload "${plistPath}"`, { stdio: "pipe", timeout: 1e4 });
+      (0, import_node_child_process3.execSync)(`launchctl load "${plistPath}"`, { stdio: "pipe", timeout: 1e4 });
       console.log("NanoClaw restarted.");
+      return;
     } catch {
-      console.log("\n*** NanoClaw needs a manual restart. ***");
-      console.log("*** macOS: launchctl kickstart -k gui/$(id -u)/ai.nanoclaw.agent ***");
-      console.log("*** Linux: systemctl --user restart nanoclaw ***\n");
     }
   }
+  try {
+    (0, import_node_child_process3.execSync)("systemctl --user restart nanoclaw", { stdio: "pipe", timeout: 1e4 });
+    console.log("NanoClaw restarted.");
+    return;
+  } catch {
+  }
+  console.log("\n*** NanoClaw needs a manual restart. ***");
+  console.log("*** macOS: launchctl unload ~/Library/LaunchAgents/com.nanoclaw.plist && launchctl load ~/Library/LaunchAgents/com.nanoclaw.plist ***");
+  console.log("*** Linux: systemctl --user restart nanoclaw ***\n");
 }
 function patchDotEnv2(path, vars) {
-  let content = (0, import_node_fs6.readFileSync)(path, "utf-8");
+  let content = (0, import_node_fs6.existsSync)(path) ? (0, import_node_fs6.readFileSync)(path, "utf-8") : "";
   for (const [key, value] of Object.entries(vars)) {
     const regex = new RegExp(`^${key}=.*$`, "m");
     if (regex.test(content)) {
       content = content.replace(regex, `${key}=${value}`);
     } else {
-      content += `
-${key}=${value}`;
+      content = content.trimEnd() + (content.length > 0 ? "\n" : "") + `${key}=${value}
+`;
     }
   }
   (0, import_node_fs6.writeFileSync)(path, content, "utf-8");
 }
 
+// src/adapters/llm.ts
+var DEFAULT_TIMEOUT_MS = 6e4;
+var OpenAIAdapter = class {
+  apiKey;
+  baseUrl;
+  defaultModel;
+  constructor(config) {
+    if (!config.apiKey) throw new Error("OpenAI API key is required");
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? "https://api.openai.com").replace(/\/+$/, "");
+    this.defaultModel = config.model ?? "gpt-4o-mini";
+  }
+  async complete(prompt, opts) {
+    const response = await this.request({
+      model: opts?.model ?? this.defaultModel,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: opts?.maxTokens ?? 2e3,
+      temperature: opts?.temperature ?? 0.7
+    }, opts?.timeoutMs);
+    return response.choices?.[0]?.message?.content ?? "";
+  }
+  async json(prompt, opts) {
+    const response = await this.request({
+      model: opts?.model ?? this.defaultModel,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: opts?.maxTokens ?? 2e3,
+      temperature: opts?.temperature ?? 0.3,
+      response_format: { type: "json_object" }
+    }, opts?.timeoutMs);
+    const text = response.choices?.[0]?.message?.content ?? "{}";
+    return JSON.parse(text);
+  }
+  async request(body, timeoutMs) {
+    const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      throw new Error(`OpenAI API error ${res.status}: ${text.slice(0, 200)}`);
+    }
+    return res.json();
+  }
+};
+var AnthropicAdapter = class {
+  apiKey;
+  defaultModel;
+  constructor(config) {
+    if (!config.apiKey) throw new Error("Anthropic API key is required");
+    this.apiKey = config.apiKey;
+    this.defaultModel = config.model ?? "claude-sonnet-4-20250514";
+  }
+  async complete(prompt, opts) {
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: opts?.model ?? this.defaultModel,
+        max_tokens: opts?.maxTokens ?? 2e3,
+        messages: [{ role: "user", content: prompt }]
+      }),
+      signal: AbortSignal.timeout(opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      throw new Error(`Anthropic API error ${res.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return data.content?.[0]?.text ?? "";
+  }
+  async json(prompt, opts) {
+    const text = await this.complete(
+      `${prompt}
+
+Respond with valid JSON only, no other text.`,
+      { ...opts, temperature: opts?.temperature ?? 0.3 }
+    );
+    try {
+      return JSON.parse(text.trim());
+    } catch {
+      const match = text.match(/\{[\s\S]*?\}(?=\s*$|\s*[^}\]])/);
+      const arrMatch = text.match(/\[[\s\S]*?\](?=\s*$|\s*[^}\]])/);
+      const candidate = match?.[0] ?? arrMatch?.[0];
+      if (!candidate) throw new Error("No JSON found in response");
+      return JSON.parse(candidate);
+    }
+  }
+};
+var OllamaAdapter = class {
+  baseUrl;
+  defaultModel;
+  constructor(config) {
+    this.baseUrl = (config?.baseUrl ?? "http://localhost:11434").replace(/\/+$/, "");
+    this.defaultModel = config?.model ?? "llama3.1";
+  }
+  async complete(prompt, opts) {
+    const res = await fetch(`${this.baseUrl}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: opts?.model ?? this.defaultModel,
+        prompt,
+        stream: false,
+        options: {
+          num_predict: opts?.maxTokens ?? 2e3,
+          temperature: opts?.temperature ?? 0.7
+        }
+      }),
+      signal: AbortSignal.timeout(opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      throw new Error(`Ollama error ${res.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return data.response ?? "";
+  }
+  async json(prompt, opts) {
+    const res = await fetch(`${this.baseUrl}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: opts?.model ?? this.defaultModel,
+        prompt: `${prompt}
+
+Respond with valid JSON only.`,
+        stream: false,
+        format: "json",
+        options: {
+          num_predict: opts?.maxTokens ?? 2e3,
+          temperature: opts?.temperature ?? 0.3
+        }
+      }),
+      signal: AbortSignal.timeout(opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      throw new Error(`Ollama error ${res.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return JSON.parse(data.response ?? "{}");
+  }
+};
+
 // src/cli/commands.ts
+function createAnalyzer(config) {
+  switch (config.llm_provider) {
+    case "anthropic":
+      return { analyze: (p) => new AnthropicAdapter({ apiKey: config.llm_api_key }).complete(p) };
+    case "ollama":
+      return { analyze: (p) => new OllamaAdapter({ baseUrl: config.llm_base_url }).complete(p) };
+    case "openai":
+    case "openrouter":
+    case "custom":
+    default:
+      return { analyze: (p) => new OpenAIAdapter({ apiKey: config.llm_api_key, baseUrl: config.llm_base_url }).complete(p) };
+  }
+}
 async function start() {
   const config = loadConfig();
   const baseDir = getBecomeDir();
@@ -1569,7 +1874,14 @@ async function start() {
     max_skills_per_call: config.max_skills_per_call,
     auto_extract: config.auto_extract
   };
-  const proxy = createProxyServer(proxyConfig);
+  const originalUrlPath = (0, import_node_path7.join)((0, import_node_os5.homedir)(), ".become", "state", "original_base_url.txt");
+  let originalUpstreamUrl;
+  if ((0, import_node_fs7.existsSync)(originalUrlPath)) {
+    const saved = (0, import_node_fs7.readFileSync)(originalUrlPath, "utf-8").trim();
+    if (saved) originalUpstreamUrl = saved;
+  }
+  const analyzer = createAnalyzer(config);
+  const proxy = createProxyServer(proxyConfig, analyzer, originalUpstreamUrl);
   await proxy.listen();
   const dashboard = createDashboardServer({
     store: proxy.store,
@@ -1653,7 +1965,7 @@ Patching ${config.agent_type} config...`);
   console.log(`  baseUrl: ${config.llm_base_url} \u2192 localhost:${config.proxy_port}`);
   switch (config.agent_type) {
     case "openclaw":
-      patchOpenClaw(config, config.openclaw_agent_id);
+      patchOpenClaw(config);
       break;
     case "ironclaw":
       patchIronClaw(config);
@@ -1722,21 +2034,21 @@ Skills:    ${approved} approved, ${pending} pending, ${rejected} rejected`);
 }
 
 // src/cli/init.ts
-var import_node_fs7 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path8 = require("path");
 var import_node_url = require("url");
 var import_meta = {};
 var command = process.argv[2];
 var VERSION = "unknown";
 try {
-  const dir = (0, import_node_path7.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-  const pkgPath = (0, import_node_path7.join)(dir, "..", "package.json");
-  VERSION = JSON.parse((0, import_node_fs7.readFileSync)(pkgPath, "utf-8")).version;
+  const dir = (0, import_node_path8.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+  const pkgPath = (0, import_node_path8.join)(dir, "..", "package.json");
+  VERSION = JSON.parse((0, import_node_fs8.readFileSync)(pkgPath, "utf-8")).version;
 } catch {
   try {
-    const dir = (0, import_node_path7.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-    const pkgPath = (0, import_node_path7.join)(dir, "..", "..", "package.json");
-    VERSION = JSON.parse((0, import_node_fs7.readFileSync)(pkgPath, "utf-8")).version;
+    const dir = (0, import_node_path8.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+    const pkgPath = (0, import_node_path8.join)(dir, "..", "..", "package.json");
+    VERSION = JSON.parse((0, import_node_fs8.readFileSync)(pkgPath, "utf-8")).version;
   } catch {
   }
 }