@openclawcity/become 1.0.12 → 1.0.18

package/dist/cli.js

@@ -59,146 +59,147 @@ import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 import { execSync } from "child_process";
 var OPENCLAW_CONFIG = join2(homedir2(), ".openclaw", "openclaw.json");
-var BACKUP_PATH = join2(homedir2(), ".become", "state", "original_openclaw.json");
-var ORIGINAL_MODEL_PATH = join2(homedir2(), ".become", "state", "original_model.txt");
-var PATCHED_AGENT_PATH = join2(homedir2(), ".become", "state", "patched_agent.txt");
-function patchOpenClaw(config, agentId) {
+var STATE_DIR = join2(homedir2(), ".become", "state");
+var BACKUP_PATH = join2(STATE_DIR, "original_openclaw.json");
+var ORIGINAL_URL_PATH = join2(STATE_DIR, "original_base_url.txt");
+var PATCHED_PROVIDER_PATH = join2(STATE_DIR, "patched_provider.txt");
+function patchOpenClaw(config) {
   if (!existsSync2(OPENCLAW_CONFIG)) {
     throw new Error(`OpenClaw config not found at ${OPENCLAW_CONFIG}`);
   }
   const raw = readFileSync2(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);
+  mkdirSync2(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 (existsSync2(ORIGINAL_URL_PATH)) {
+    const existingUrl = readFileSync2(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 && existsSync2(modelsJsonPath)) {
+    modelsConfig = JSON.parse(readFileSync2(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`);
   }
-  mkdirSync2(join2(homedir2(), ".become", "state"), { recursive: true });
   writeFileSync2(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}`;
+  writeFileSync2(ORIGINAL_URL_PATH, originalUrl, "utf-8");
+  writeFileSync2(PATCHED_PROVIDER_PATH, `${providerName}:${modelsSource}`, "utf-8");
+  provider.baseUrl = `http://127.0.0.1:${config.proxy_port}`;
+  if (modelsSource === "models.json" && modelsJsonPath) {
+    writeFileSync2(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}`;
-  }
-  writeFileSync2(ORIGINAL_MODEL_PATH, originalModel, "utf-8");
-  writeFileSync2(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` }
-    ]
-  };
-  writeFileSync2(OPENCLAW_CONFIG, JSON.stringify(clawConfig, null, 2), "utf-8");
-  console.log("Restarting OpenClaw gateway...");
-  try {
-    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");
+    writeFileSync2(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 (!existsSync2(OPENCLAW_CONFIG)) {
-    throw new Error(`OpenClaw config not found at ${OPENCLAW_CONFIG}`);
-  }
-  if (existsSync2(BACKUP_PATH)) {
-    const backup = readFileSync2(BACKUP_PATH, "utf-8");
-    const backupConfig = parseOpenClawConfig(backup);
-    if (!backupConfig.models?.providers?.become) {
-      writeFileSync2(OPENCLAW_CONFIG, backup, "utf-8");
-      restartGateway();
-      return;
-    }
+  const originalUrl = readSafe(ORIGINAL_URL_PATH);
+  const patchInfo = readSafe(PATCHED_PROVIDER_PATH);
+  if (!originalUrl || !patchInfo) {
+    cleanState();
+    return;
   }
-  const raw = readFileSync2(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;
-      }
-    } else {
-      if (config.agents?.defaults?.model) {
-        config.agents.defaults.model.primary = originalModel;
+  const [providerName, source] = patchInfo.split(":");
+  if (source === "models.json") {
+    const clawConfig = parseConfig(readFileSync2(OPENCLAW_CONFIG, "utf-8"));
+    const modelsJsonPath = getModelsJsonPath(clawConfig);
+    if (modelsJsonPath && existsSync2(modelsJsonPath)) {
+      const modelsConfig = JSON.parse(readFileSync2(modelsJsonPath, "utf-8"));
+      if (modelsConfig.providers?.[providerName]) {
+        modelsConfig.providers[providerName].baseUrl = originalUrl;
+        writeFileSync2(modelsJsonPath, JSON.stringify(modelsConfig, null, 2), "utf-8");
       }
     }
-  }
-  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;
+  } else {
+    if (existsSync2(OPENCLAW_CONFIG)) {
+      const clawConfig = parseConfig(readFileSync2(OPENCLAW_CONFIG, "utf-8"));
+      if (clawConfig.models?.providers?.[providerName]) {
+        clawConfig.models.providers[providerName].baseUrl = originalUrl;
+        writeFileSync2(OPENCLAW_CONFIG, JSON.stringify(clawConfig, null, 2), "utf-8");
+      }
     }
   }
-  writeFileSync2(OPENCLAW_CONFIG, JSON.stringify(config, null, 2), "utf-8");
+  cleanState();
   restartGateway();
 }
 function listOpenClawAgents() {
   if (!existsSync2(OPENCLAW_CONFIG)) return [];
   try {
-    const config = parseOpenClawConfig(readFileSync2(OPENCLAW_CONFIG, "utf-8"));
+    const config = parseConfig(readFileSync2(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 join2(defaultAgent.agentDir.replace("~", homedir2()), "models.json");
+  }
+  const mainPath = join2(homedir2(), ".openclaw", "agents", "main", "agent", "models.json");
+  if (existsSync2(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 existsSync2(path) ? readFileSync2(path, "utf-8").trim() : "";
   } catch {
     return "";
   }
 }
+function cleanState() {
+  for (const f of [ORIGINAL_URL_PATH, PATCHED_PROVIDER_PATH]) {
+    try {
+      writeFileSync2(f, "", "utf-8");
+    } catch {
+    }
+  }
+}
 function restartGateway() {
   console.log("Restarting OpenClaw gateway...");
   try {
@@ -284,6 +285,11 @@ Proxy port (default 30001): `);
   }
 }
 
+// src/cli/commands.ts
+import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir5 } from "os";
+
 // src/proxy/server.ts
 import { createServer } from "http";
 
@@ -710,7 +716,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;
@@ -757,7 +763,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);
@@ -841,8 +847,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) {
@@ -1390,98 +1396,185 @@ function readBody2(req) {
 }
 
 // src/cli/adapter/ironclaw.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync5, mkdirSync as mkdirSync5, copyFileSync } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync5, mkdirSync as mkdirSync5, copyFileSync, unlinkSync as unlinkSync2 } from "fs";
 import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 import { execSync as execSync2 } from "child_process";
-var IRONCLAW_ENV = join5(homedir3(), ".ironclaw", ".env");
+var IRONCLAW_ENV = join5(process.env.IRONCLAW_BASE_DIR ?? join5(homedir3(), ".ironclaw"), ".env");
 var BACKUP_PATH2 = join5(homedir3(), ".become", "state", "original_ironclaw.env");
 function patchIronClaw(config) {
   if (!existsSync5(IRONCLAW_ENV)) {
     throw new Error(`IronClaw .env not found at ${IRONCLAW_ENV}`);
   }
+  if (existsSync5(BACKUP_PATH2)) {
+    console.log("become is already connected to IronClaw. Run `become off` first.");
+    return;
+  }
   mkdirSync5(join5(homedir3(), ".become", "state"), { recursive: true });
   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 {
-    execSync2("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 = readFileSync5(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 (!existsSync5(BACKUP_PATH2)) {
-    throw new Error("No backup found. Was become ever turned on?");
+    return;
   }
   copyFileSync(BACKUP_PATH2, IRONCLAW_ENV);
+  try {
+    unlinkSync2(BACKUP_PATH2);
+  } catch {
+  }
+  restartIronClaw();
+}
+function restartIronClaw() {
   console.log("Restarting IronClaw...");
   try {
-    execSync2("ironclaw service restart", { stdio: "pipe", timeout: 15e3 });
+    execSync2("ironclaw service stop", { stdio: "pipe", timeout: 1e4 });
+    execSync2("ironclaw service start", { stdio: "pipe", timeout: 1e4 });
     console.log("IronClaw restarted.");
+    return;
+  } catch {
+  }
+  try {
+    execSync2("launchctl kickstart -k gui/$(id -u)/com.ironclaw.daemon", { stdio: "pipe", timeout: 1e4 });
+    console.log("IronClaw restarted via launchctl.");
+    return;
+  } catch {
+  }
+  try {
+    execSync2("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 restart ***\n");
   }
+  console.log("\n*** IronClaw needs a manual restart. ***");
+  console.log("*** Run: ironclaw service stop && ironclaw service start ***\n");
 }
 function patchDotEnv(path, vars) {
-  let content = readFileSync5(path, "utf-8");
+  let content = existsSync5(path) ? readFileSync5(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}
+`;
     }
   }
   writeFileSync5(path, content, "utf-8");
 }
 
 // src/cli/adapter/nanoclaw.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync6, mkdirSync as mkdirSync6, copyFileSync as copyFileSync2 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync6, mkdirSync as mkdirSync6, copyFileSync as copyFileSync2, unlinkSync as unlinkSync3 } from "fs";
 import { join as join6 } from "path";
 import { homedir as homedir4 } from "os";
 import { execSync as execSync3 } from "child_process";
 var BACKUP_PATH3 = join6(homedir4(), ".become", "state", "original_nanoclaw.env");
+var PATCHED_ENV_PATH_FILE = join6(homedir4(), ".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 (existsSync6(BACKUP_PATH3)) {
+    console.log("become is already connected to NanoClaw. Run `become off` first.");
+    return;
   }
   mkdirSync6(join6(homedir4(), ".become", "state"), { recursive: true });
   copyFileSync2(envPath, BACKUP_PATH3);
+  writeFileSync6(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 (!existsSync6(BACKUP_PATH3) || !envPath) {
-    throw new Error("No backup found. Was become ever turned on?");
+  if (!existsSync6(BACKUP_PATH3)) {
+    return;
+  }
+  let envPath = null;
+  if (existsSync6(PATCHED_ENV_PATH_FILE)) {
+    envPath = readFileSync6(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;
   }
   copyFileSync2(BACKUP_PATH3, envPath);
+  try {
+    unlinkSync3(BACKUP_PATH3);
+  } catch {
+  }
+  try {
+    unlinkSync3(PATCHED_ENV_PATH_FILE);
+  } catch {
+  }
   restartNanoClaw();
 }
 function findNanoClawEnv() {
-  const candidates = [
-    join6(homedir4(), ".nanoclaw", ".env"),
-    join6(homedir4(), ".config", "nanoclaw", ".env")
-  ];
-  const plistPath = join6(homedir4(), "Library", "LaunchAgents", "ai.nanoclaw.agent.plist");
+  const candidates = [];
+  const plistPath = join6(homedir4(), "Library", "LaunchAgents", "com.nanoclaw.plist");
   if (existsSync6(plistPath)) {
     try {
       const plist = readFileSync6(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(join6(match[1], ".env"));
+    } catch {
+    }
+  }
+  const userUnit = join6(homedir4(), ".config", "systemd", "user", "nanoclaw.service");
+  if (existsSync6(userUnit)) {
+    try {
+      const unit = readFileSync6(userUnit, "utf-8");
+      const match = unit.match(/WorkingDirectory=(.+)/);
+      if (match) candidates.push(join6(match[1].trim(), ".env"));
+    } catch {
+    }
+  }
+  const rootUnit = "/etc/systemd/system/nanoclaw.service";
+  if (existsSync6(rootUnit)) {
+    try {
+      const unit = readFileSync6(rootUnit, "utf-8");
+      const match = unit.match(/WorkingDirectory=(.+)/);
+      if (match) candidates.push(join6(match[1].trim(), ".env"));
     } catch {
     }
   }
+  candidates.push(join6(homedir4(), "nanoclaw", ".env"));
+  candidates.push("/opt/nanoclaw/.env");
   for (const path of candidates) {
     if (existsSync6(path)) return path;
   }
@@ -1489,35 +1582,207 @@ function findNanoClawEnv() {
 }
 function restartNanoClaw() {
   console.log("Restarting NanoClaw...");
-  try {
-    execSync3("launchctl kickstart -k gui/$(id -u)/ai.nanoclaw.agent", { stdio: "pipe", timeout: 15e3 });
-    console.log("NanoClaw restarted.");
-  } catch {
+  const plistPath = join6(homedir4(), "Library", "LaunchAgents", "com.nanoclaw.plist");
+  if (existsSync6(plistPath)) {
     try {
-      execSync3("systemctl --user restart nanoclaw", { stdio: "pipe", timeout: 15e3 });
+      execSync3(`launchctl unload "${plistPath}"`, { stdio: "pipe", timeout: 1e4 });
+      execSync3(`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 {
+    execSync3("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 = readFileSync6(path, "utf-8");
+  let content = existsSync6(path) ? readFileSync6(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}
+`;
     }
   }
   writeFileSync6(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();
@@ -1530,7 +1795,14 @@ async function start() {
     max_skills_per_call: config.max_skills_per_call,
     auto_extract: config.auto_extract
   };
-  const proxy = createProxyServer(proxyConfig);
+  const originalUrlPath = join7(homedir5(), ".become", "state", "original_base_url.txt");
+  let originalUpstreamUrl;
+  if (existsSync7(originalUrlPath)) {
+    const saved = readFileSync7(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,
@@ -1585,15 +1857,24 @@ Connected to: ${config.agent_type}${config.openclaw_agent_id ? ` (agent: ${confi
       console.log(`[become] ${s.requests_forwarded} requests forwarded, ${s.skills_injected} skills injected, ${s.lessons_extracted} lessons extracted`);
     }
   }, 6e4);
-  const shutdown = async () => {
+  let shuttingDown = false;
+  const shutdown = () => {
+    if (shuttingDown) {
+      process.exit(0);
+      return;
+    }
+    shuttingDown = true;
     clearInterval(activityInterval);
     console.log("\nShutting down...");
     try {
       turnOff();
     } catch {
     }
-    await Promise.all([proxy.close(), dashboard.close()]);
-    process.exit(0);
+    proxy.close().catch(() => {
+    });
+    dashboard.close().catch(() => {
+    });
+    setTimeout(() => process.exit(0), 500);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
@@ -1605,7 +1886,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);
@@ -1674,20 +1955,20 @@ Skills:    ${approved} approved, ${pending} pending, ${rejected} rejected`);
 }
 
 // src/cli/init.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join7, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join8, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 var command = process.argv[2];
 var VERSION = "unknown";
 try {
   const dir = dirname2(fileURLToPath(import.meta.url));
-  const pkgPath = join7(dir, "..", "package.json");
-  VERSION = JSON.parse(readFileSync7(pkgPath, "utf-8")).version;
+  const pkgPath = join8(dir, "..", "package.json");
+  VERSION = JSON.parse(readFileSync8(pkgPath, "utf-8")).version;
 } catch {
   try {
     const dir = dirname2(fileURLToPath(import.meta.url));
-    const pkgPath = join7(dir, "..", "..", "package.json");
-    VERSION = JSON.parse(readFileSync7(pkgPath, "utf-8")).version;
+    const pkgPath = join8(dir, "..", "..", "package.json");
+    VERSION = JSON.parse(readFileSync8(pkgPath, "utf-8")).version;
   } catch {
   }
 }