@openclawcity/become 1.0.1 → 1.0.3

package/dist/cli.js

@@ -53,6 +53,157 @@ var LLM_DEFAULTS = {
   openrouter: { base_url: "https://openrouter.ai/api" }
 };
 
+// src/cli/adapter/openclaw.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+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) {
+  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;
+  }
+  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}`;
+  } 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");
+  try {
+    execSync("openclaw gateway restart", { stdio: "pipe", timeout: 15e3 });
+  } catch {
+    console.log("Warning: Could not restart OpenClaw gateway. Restart it manually: openclaw gateway restart");
+  }
+}
+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 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;
+      }
+    }
+  }
+  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;
+    }
+  }
+  writeFileSync2(OPENCLAW_CONFIG, JSON.stringify(config, null, 2), "utf-8");
+  restartGateway();
+}
+function listOpenClawAgents() {
+  if (!existsSync2(OPENCLAW_CONFIG)) return [];
+  try {
+    const config = parseOpenClawConfig(readFileSync2(OPENCLAW_CONFIG, "utf-8"));
+    const agents = config.agents?.list ?? [];
+    const defaultModel = unbecome(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)
+    }));
+  } 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 parseOpenClawConfig(raw) {
+  const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([\]}])/g, "$1");
+  return JSON.parse(stripped);
+}
+function readStateFile(path) {
+  try {
+    return existsSync2(path) ? readFileSync2(path, "utf-8").trim() : "";
+  } catch {
+    return "";
+  }
+}
+function restartGateway() {
+  try {
+    execSync("openclaw gateway restart", { stdio: "pipe", timeout: 15e3 });
+  } catch {
+    console.log("Warning: Could not restart OpenClaw gateway. Restart it manually: openclaw gateway restart");
+  }
+}
+
 // src/cli/setup.ts
 var AGENT_TYPES = ["openclaw", "ironclaw", "nanoclaw", "generic"];
 var LLM_PROVIDERS = ["anthropic", "openai", "ollama", "openrouter", "custom"];
@@ -68,7 +219,25 @@ async function runSetup() {
     const agentChoice = await ask(rl, "> ");
     const agentIdx = parseInt(agentChoice, 10) - 1;
     const agent_type = AGENT_TYPES[agentIdx] ?? "openclaw";
-    console.log("\nWhich LLM provider?");
+    let openclaw_agent_id;
+    if (agent_type === "openclaw") {
+      const agents = listOpenClawAgents();
+      if (agents.length > 1) {
+        console.log("\nWhich OpenClaw agent should learn from other agents?");
+        agents.forEach((a, i) => console.log(`  ${i + 1}. ${a.id} (${a.model})`));
+        const agentPick = await ask(rl, "> ");
+        const pickIdx = parseInt(agentPick, 10) - 1;
+        const picked = agents[pickIdx];
+        if (picked && picked.id !== "_defaults") {
+          openclaw_agent_id = picked.id;
+        }
+      } else if (agents.length === 1 && agents[0].id !== "_defaults") {
+        openclaw_agent_id = agents[0].id;
+        console.log(`
+OpenClaw agent: ${openclaw_agent_id} (${agents[0].model})`);
+      }
+    }
+    console.log("\nWhich LLM provider does your agent use?");
     LLM_PROVIDERS.forEach((p, i) => console.log(`  ${i + 1}. ${p}`));
     const llmChoice = await ask(rl, "> ");
     const llmIdx = parseInt(llmChoice, 10) - 1;
@@ -90,6 +259,7 @@ Proxy port (default 30001): `);
     const dashboard_port = parseInt(dashInput, 10) || 30002;
     const config = {
       agent_type,
+      openclaw_agent_id,
       llm_provider,
       llm_base_url,
       llm_api_key: llm_api_key.trim(),
@@ -113,20 +283,20 @@ Proxy port (default 30001): `);
 import { createServer } from "http";
 
 // src/skills/store.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, readdirSync, mkdirSync as mkdirSync2, renameSync, unlinkSync, existsSync as existsSync2 } from "fs";
-import { join as join2, basename } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, readdirSync, mkdirSync as mkdirSync3, renameSync, unlinkSync, existsSync as existsSync3 } from "fs";
+import { join as join3, basename } from "path";
 import { createHash } from "crypto";
 var FileSkillStore = class {
   skillsDir;
   pendingDir;
   rejectedDir;
   constructor(config) {
-    this.skillsDir = join2(config.baseDir, "skills");
-    this.pendingDir = join2(config.baseDir, "pending");
-    this.rejectedDir = join2(config.baseDir, "rejected");
-    mkdirSync2(this.skillsDir, { recursive: true });
-    mkdirSync2(this.pendingDir, { recursive: true });
-    mkdirSync2(this.rejectedDir, { recursive: true });
+    this.skillsDir = join3(config.baseDir, "skills");
+    this.pendingDir = join3(config.baseDir, "pending");
+    this.rejectedDir = join3(config.baseDir, "rejected");
+    mkdirSync3(this.skillsDir, { recursive: true });
+    mkdirSync3(this.pendingDir, { recursive: true });
+    mkdirSync3(this.rejectedDir, { recursive: true });
   }
   // ── Read ────────────────────────────────────────────────────────────────
   listApproved() {
@@ -140,7 +310,7 @@ var FileSkillStore = class {
   }
   getApproved(id) {
     this.validateId(id);
-    return this.readFile(join2(this.skillsDir, `${id}.md`));
+    return this.readFile(join3(this.skillsDir, `${id}.md`));
   }
   // ── Write ───────────────────────────────────────────────────────────────
   savePending(lesson) {
@@ -151,42 +321,42 @@ var FileSkillStore = class {
     }
     const id = this.generateId(lesson.name);
     const file = { ...lesson, id, approved_at: void 0 };
-    this.writeFile(join2(this.pendingDir, `${id}.md`), file);
+    this.writeFile(join3(this.pendingDir, `${id}.md`), file);
     return file;
   }
   approve(id) {
     this.validateId(id);
-    const src = join2(this.pendingDir, `${id}.md`);
-    if (!existsSync2(src)) return false;
+    const src = join3(this.pendingDir, `${id}.md`);
+    if (!existsSync3(src)) return false;
     const skill = this.readFile(src);
     if (!skill) return false;
     skill.approved_at = (/* @__PURE__ */ new Date()).toISOString();
-    const dest = join2(this.skillsDir, `${id}.md`);
+    const dest = join3(this.skillsDir, `${id}.md`);
     this.writeFile(dest, skill);
     unlinkSync(src);
     return true;
   }
   reject(id) {
     this.validateId(id);
-    const src = join2(this.pendingDir, `${id}.md`);
-    if (!existsSync2(src)) return false;
-    const dest = join2(this.rejectedDir, `${id}.md`);
+    const src = join3(this.pendingDir, `${id}.md`);
+    if (!existsSync3(src)) return false;
+    const dest = join3(this.rejectedDir, `${id}.md`);
     renameSync(src, dest);
     return true;
   }
   disable(id) {
     this.validateId(id);
-    const src = join2(this.skillsDir, `${id}.md`);
-    if (!existsSync2(src)) return false;
-    const dest = join2(this.rejectedDir, `${id}.md`);
+    const src = join3(this.skillsDir, `${id}.md`);
+    if (!existsSync3(src)) return false;
+    const dest = join3(this.rejectedDir, `${id}.md`);
     renameSync(src, dest);
     return true;
   }
   remove(id) {
     this.validateId(id);
     for (const dir of [this.skillsDir, this.pendingDir, this.rejectedDir]) {
-      const path = join2(dir, `${id}.md`);
-      if (existsSync2(path)) {
+      const path = join3(dir, `${id}.md`);
+      if (existsSync3(path)) {
         unlinkSync(path);
         return true;
       }
@@ -205,19 +375,19 @@ var FileSkillStore = class {
     }
   }
   readDir(dir) {
-    if (!existsSync2(dir)) return [];
+    if (!existsSync3(dir)) return [];
     const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
     const skills = [];
     for (const f of files) {
-      const skill = this.readFile(join2(dir, f));
+      const skill = this.readFile(join3(dir, f));
       if (skill) skills.push(skill);
     }
     return skills.sort((a, b) => b.created_at.localeCompare(a.created_at));
   }
   readFile(path) {
-    if (!existsSync2(path)) return null;
+    if (!existsSync3(path)) return null;
     try {
-      const content = readFileSync2(path, "utf-8");
+      const content = readFileSync3(path, "utf-8");
       return this.parseSkillFile(content, basename(path, ".md"));
     } catch {
       return null;
@@ -225,7 +395,7 @@ var FileSkillStore = class {
   }
   writeFile(path, skill) {
     const content = this.formatSkillFile(skill);
-    writeFileSync2(path, content, "utf-8");
+    writeFileSync3(path, content, "utf-8");
   }
   parseSkillFile(content, id) {
     const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
@@ -274,8 +444,8 @@ var FileSkillStore = class {
 };
 
 // src/skills/trust.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
-import { join as join3, dirname } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync4 } from "fs";
+import { join as join4, dirname } from "path";
 var DEFAULT_TRUST = {
   trusted: [],
   blocked: [],
@@ -292,9 +462,9 @@ var TrustManager = class {
   config;
   dailyCounts;
   constructor(baseDir) {
-    this.trustPath = join3(baseDir, "trust.json");
-    this.statsPath = join3(baseDir, "state", "daily_counts.json");
-    mkdirSync3(join3(baseDir, "state"), { recursive: true });
+    this.trustPath = join4(baseDir, "trust.json");
+    this.statsPath = join4(baseDir, "state", "daily_counts.json");
+    mkdirSync4(join4(baseDir, "state"), { recursive: true });
     this.config = this.loadTrust();
     this.dailyCounts = this.loadDailyCounts();
   }
@@ -337,9 +507,9 @@ var TrustManager = class {
   }
   // ── Private ─────────────────────────────────────────────────────────────
   loadTrust() {
-    if (!existsSync3(this.trustPath)) return { ...DEFAULT_TRUST, trusted: [], blocked: [] };
+    if (!existsSync4(this.trustPath)) return { ...DEFAULT_TRUST, trusted: [], blocked: [] };
     try {
-      const raw = JSON.parse(readFileSync3(this.trustPath, "utf-8"));
+      const raw = JSON.parse(readFileSync4(this.trustPath, "utf-8"));
       return {
         trusted: Array.isArray(raw.trusted) ? raw.trusted.filter((a) => typeof a === "string") : [],
         blocked: Array.isArray(raw.blocked) ? raw.blocked.filter((a) => typeof a === "string") : [],
@@ -350,14 +520,14 @@ var TrustManager = class {
     }
   }
   saveTrust() {
-    mkdirSync3(dirname(this.trustPath), { recursive: true });
-    writeFileSync3(this.trustPath, JSON.stringify(this.config, null, 2), "utf-8");
+    mkdirSync4(dirname(this.trustPath), { recursive: true });
+    writeFileSync4(this.trustPath, JSON.stringify(this.config, null, 2), "utf-8");
   }
   loadDailyCounts() {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    if (!existsSync3(this.statsPath)) return { date: today, total: 0, perAgent: {} };
+    if (!existsSync4(this.statsPath)) return { date: today, total: 0, perAgent: {} };
     try {
-      const data = JSON.parse(readFileSync3(this.statsPath, "utf-8"));
+      const data = JSON.parse(readFileSync4(this.statsPath, "utf-8"));
       if (data.date !== today) return { date: today, total: 0, perAgent: {} };
       return data;
     } catch {
@@ -365,7 +535,7 @@ var TrustManager = class {
     }
   }
   saveDailyCounts() {
-    writeFileSync3(this.statsPath, JSON.stringify(this.dailyCounts, null, 2), "utf-8");
+    writeFileSync4(this.statsPath, JSON.stringify(this.dailyCounts, null, 2), "utf-8");
   }
   refreshDailyCountsIfNewDay() {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -1212,54 +1382,6 @@ function readBody2(req) {
   });
 }
 
-// src/cli/adapter/openclaw.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync4 } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir2 } from "os";
-import { execSync } from "child_process";
-var OPENCLAW_CONFIG = join4(homedir2(), ".openclaw", "openclaw.json");
-var BACKUP_PATH = join4(homedir2(), ".become", "state", "original_openclaw.json");
-function patchOpenClaw(config) {
-  if (!existsSync4(OPENCLAW_CONFIG)) {
-    throw new Error(`OpenClaw config not found at ${OPENCLAW_CONFIG}`);
-  }
-  const raw = readFileSync4(OPENCLAW_CONFIG, "utf-8");
-  const clawConfig = JSON.parse(raw);
-  mkdirSync4(join4(homedir2(), ".become", "state"), { recursive: true });
-  writeFileSync4(BACKUP_PATH, raw, "utf-8");
-  if (!clawConfig.models) clawConfig.models = {};
-  if (!clawConfig.models.providers) clawConfig.models.providers = {};
-  clawConfig.models.providers.become = {
-    api: "anthropic-messages",
-    baseUrl: `http://127.0.0.1:${config.proxy_port}`,
-    apiKey: config.llm_api_key
-  };
-  if (clawConfig.agents?.defaults?.model?.primary) {
-    const original = clawConfig.agents.defaults.model.primary;
-    clawConfig.models.providers.become._originalModel = original;
-    const modelId = original.includes("/") ? original.split("/").slice(1).join("/") : original;
-    clawConfig.agents.defaults.model.primary = `become/${modelId}`;
-  }
-  writeFileSync4(OPENCLAW_CONFIG, JSON.stringify(clawConfig, null, 2), "utf-8");
-  try {
-    execSync("openclaw gateway restart", { stdio: "pipe", timeout: 15e3 });
-  } catch {
-    console.log("Warning: Could not restart OpenClaw gateway. Restart it manually: openclaw gateway restart");
-  }
-}
-function restoreOpenClaw() {
-  if (!existsSync4(BACKUP_PATH)) {
-    throw new Error("No backup found. Was become ever turned on?");
-  }
-  const backup = readFileSync4(BACKUP_PATH, "utf-8");
-  writeFileSync4(OPENCLAW_CONFIG, backup, "utf-8");
-  try {
-    execSync("openclaw gateway restart", { stdio: "pipe", timeout: 15e3 });
-  } catch {
-    console.log("Warning: Could not restart OpenClaw gateway. Restart it manually: openclaw gateway restart");
-  }
-}
-
 // src/cli/adapter/ironclaw.ts
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync5, mkdirSync as mkdirSync5, copyFileSync } from "fs";
 import { join as join5 } from "path";
@@ -1443,7 +1565,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);
+      patchOpenClaw(config, config.openclaw_agent_id);
       break;
     case "ironclaw":
       patchIronClaw(config);