likho-cli 0.4.0 → 0.5.0

package/bin/likho.js

@@ -88,10 +88,13 @@ function orgOfUrl(url) {
   }
 }
 
+/** Any folder but the home folder can be a project (a new one has no files yet). */
+const inHome = (ctx) => path.resolve(ctx.cwd) === path.resolve(ctx.home);
+
 async function chooseScope(opts, ctx, verb) {
   if (opts.scope) return opts.scope;
-  if (!isProjectFolder(ctx)) return "global";
-  if (!interactive(opts)) return "project";
+  if (inHome(ctx)) return "global";
+  if (!interactive(opts)) return isProjectFolder(ctx) ? "project" : "global";
   const folder = path.basename(ctx.cwd);
   const setup = verb === "Set up";
   return answer(ui.select({
@@ -277,6 +280,25 @@ async function connect(opts) {
       }
     }
 
+    // Old or extra Likho entries in the same tools (e.g. "likho-hub" from
+    // before the rename) are a second connection: offer to remove them.
+    const leftovers = done.flatMap((t) => (t.leftovers ? t.leftovers(ctx, scope).map((name) => ({ t, name })) : []));
+    if (leftovers.length) {
+      const list = leftovers.map(({ t, name }) => `"${name}" in ${t.name}`).join(", ");
+      const clean = interactive(opts)
+        ? await answer(ui.confirm({ message: `Also found older Likho connections: ${list}. Remove them? (recommended)`, initialValue: true }))
+        : true;
+      if (clean) {
+        for (const { t, name } of leftovers) {
+          try {
+            if (t.removeOld(ctx, scope, name)) ui.log.success(`Removed the old "${name}" from ${t.name}`);
+          } catch (err) {
+            ui.log.error(`${t.name}: couldn't remove "${name}": ${err.message}`);
+          }
+        }
+      }
+    }
+
     let helperOn = false;
     if (pair && Object.keys(helperCodes).length) {
       try {
@@ -285,7 +307,7 @@ async function connect(opts) {
           const { key, org } = await helper.redeem(opts.server, code, pair.verifier);
           orgs.push({ slug: org.slug, name: org.name, key });
         }
-        helper.install(opts.server, orgs, isProjectFolder(ctx) ? ctx.cwd : "");
+        helper.install(opts.server, orgs, inHome(ctx) ? "" : ctx.cwd);
         helperOn = true;
         ui.log.success(`Wake-ups on for ${orgs.map((o) => o.name).join(", ")}: this computer wakes your agents when they're tagged, while it's on.`);
       } catch (err) {
@@ -294,12 +316,12 @@ async function connect(opts) {
     }
 
     if (done.length) {
-      const lines = done.map((t) => `${t.name}: ${t.signIn}`);
+      const lines = done.map((t) => `${t.name}: ${(scope === "project" && t.projectSignIn) || t.signIn}`);
       if (scope === "project") lines.push("", "The files written here hold only Likho's address, no keys: safe to commit.");
       ui.note(lines.join("\n"), "Restart these tools, then sign in once in each");
     }
     if (helperOn) {
-      const where = isProjectFolder(ctx)
+      const where = !inHome(ctx)
         ? `Agents are only woken in folders set up like this one (${path.basename(ctx.cwd)}): run npx likho-cli in each other project folder too.`
         : "Agents are only woken in project folders you set up: run npx likho-cli inside each project folder whose agents should wake.";
       ui.note(

package/lib/files.js

@@ -64,6 +64,16 @@ function getEntry(file, section, name) {
   }
 }
 
+/** Every entry in data[section], as {name: entry}. */
+function listEntries(file, section) {
+  try {
+    const block = readJson(file)[section];
+    return block && typeof block === "object" ? block : {};
+  } catch {
+    return {};
+  }
+}
+
 // ---- Codex's TOML: only the [mcp_servers.<name>] table is ever touched.
 function tomlTable(name) {
   return new RegExp(`^\\[mcp_servers\\.${name}\\][\\s\\S]*?(?=^\\[|(?![\\s\\S]))`, "m");
@@ -85,6 +95,15 @@ function getTomlServerUrl(file, name) {
   return url ? url[1] : null;
 }
 
+/** {name: url} for every [mcp_servers.<name>] table. */
+function listTomlServers(file) {
+  if (!fs.existsSync(file)) return {};
+  const out = {};
+  const raw = fs.readFileSync(file, "utf8");
+  for (const m of raw.matchAll(/^\[mcp_servers\.([\w-]+)\]/gm)) out[m[1]] = getTomlServerUrl(file, m[1]) || "";
+  return out;
+}
+
 function removeTomlServer(file, name) {
   if (!fs.existsSync(file)) return false;
   const raw = fs.readFileSync(file, "utf8");
@@ -103,4 +122,6 @@ module.exports = {
   setTomlServer,
   getTomlServerUrl,
   removeTomlServer,
+  listEntries,
+  listTomlServers,
 };

package/lib/helper.js

@@ -27,7 +27,8 @@ const MAX_REPLY = 20_000;
 // How each kind of agent runs without a window. Arguments are fixed: the
 // message only ever travels on standard input, never on a command line.
 const RUNNERS = {
-  "claude-code": (session) => ({ cmd: "claude", args: ["-p", "--output-format", "json", ...(session ? ["--resume", session] : [])] }),
+  // --max-turns: one wake-up can't run away; the reply reports its token usage.
+  "claude-code": (session) => ({ cmd: "claude", args: ["-p", "--output-format", "json", "--max-turns", "30", ...(session ? ["--resume", session] : [])] }),
   codex: () => ({ cmd: "codex", args: ["exec", "--skip-git-repo-check", "-"] }),
   gemini: () => ({ cmd: "gemini", args: [] }),
 };
@@ -164,14 +165,20 @@ async function wake(cfg, org, job) {
   const result = await run(cmd, args, { cwd: job.folder, input: job.prompt, env });
 
   let reply = result.out.trim();
+  let tokens;
   if (assistant === "claude-code") {
     try {
       const parsed = JSON.parse(reply);
+      // Every token the run processed (Likho's per-day limit counts these).
+      const u = parsed.usage || {};
+      const sum = ["input_tokens", "output_tokens", "cache_creation_input_tokens", "cache_read_input_tokens"]
+        .reduce((n, k) => n + (Number(u[k]) || 0), 0);
+      if (sum > 0) tokens = sum;
       if (parsed.session_id) {
         sessions[job.agent.number] = parsed.session_id;
         fs.writeFileSync(SESSIONS, JSON.stringify(sessions, null, 2));
       }
-      if (parsed.is_error && LIMIT_TEXT.test(String(parsed.result))) return finish({ status: "limited", retry_after: 3600 });
+      if (parsed.is_error && LIMIT_TEXT.test(String(parsed.result))) return finish({ status: "limited", retry_after: 3600, tokens });
       reply = String(parsed.result || "").trim();
     } catch {
       // not JSON: an error message, handled below
@@ -183,9 +190,9 @@ async function wake(cfg, org, job) {
     if (/not recognized|ENOENT|not found/i.test(result.err)) return finish({ status: "failed", error: `${cmd} isn't installed or isn't on this computer's PATH` });
     return finish({ status: "failed", error: (result.err.trim().split("\n").pop() || `exited with ${result.code}`).slice(0, 250) });
   }
-  if (!reply) return finish({ status: "failed", error: "it finished without an answer" });
-  log(`answered for ${job.agent.name}`);
-  return finish({ status: "done", reply: reply.slice(0, MAX_REPLY) });
+  if (!reply) return finish({ status: "failed", error: "it finished without an answer", tokens });
+  log(`answered for ${job.agent.name}${tokens ? ` (${tokens} tokens)` : ""}`);
+  return finish({ status: "done", reply: reply.slice(0, MAX_REPLY), tokens });
 }
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/lib/tools.js

@@ -13,6 +13,24 @@ const files = require("./files");
 
 const NAME = "likho";
 
+// Likho's hosted MCP addresses, old and new. An entry under another name that
+// points here (or the old name "likho-hub") is a leftover second connection.
+const LIKHO_HOSTS = ["likho.me", "www.likho.me", "mcp.likho.me", "likho-mcp.onrender.com"];
+
+function isOldLikho(name, entry) {
+  if (name === NAME) return false;
+  if (name === "likho-hub") return true;
+  const url = typeof entry === "string" ? entry : entry && (entry.url || entry.httpUrl || entry.serverUrl);
+  try {
+    return LIKHO_HOSTS.includes(new URL(url).host);
+  } catch {
+    return false;
+  }
+}
+
+/** Names of old or extra Likho entries in a {name: entry} block. */
+const oldNames = (block) => Object.entries(block || {}).filter(([n, e]) => isOldLikho(n, e)).map(([n]) => n);
+
 function onPath(cmd) {
   const probe = process.platform === "win32" ? spawnSync("where", [cmd], { encoding: "utf8" }) : spawnSync("which", [cmd], { encoding: "utf8" });
   return probe.status === 0 && Boolean((probe.stdout || "").trim());
@@ -56,9 +74,35 @@ function jsonTool({ id, name, section, entry, globalFile, projectFile, detect, s
       const found = files.getEntry(this.file(ctx, scope), section, NAME);
       return found ? found.url || found.httpUrl || found.serverUrl || "(set)" : null;
     },
+    leftovers(ctx, scope) {
+      return oldNames(files.listEntries(this.file(ctx, scope), section));
+    },
+    removeOld(ctx, scope, name) {
+      return files.removeEntry(this.file(ctx, scope), section, name);
+    },
   };
 }
 
+/**
+ * Claude Code keeps servers from a project's .mcp.json "pending approval"
+ * until someone approves them, and the VS Code panel never asks: the server
+ * just doesn't appear. The person running likho-cli has chosen to add it, so
+ * record that approval in the project's own, uncommitted local settings.
+ */
+function approveProjectServer(ctx) {
+  const file = path.join(ctx.cwd, ".claude", "settings.local.json");
+  try {
+    const data = files.readJson(file);
+    const list = Array.isArray(data.enabledMcpjsonServers) ? data.enabledMcpjsonServers : [];
+    if (list.includes(NAME)) return;
+    data.enabledMcpjsonServers = [...list, NAME];
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(data, null, 2) + "\n");
+  } catch {
+    // unreadable local settings: Claude Code will ask instead
+  }
+}
+
 function tools(ctx) {
   const list = [
     {
@@ -66,6 +110,9 @@ function tools(ctx) {
       name: "Claude Code",
       detect: () => ctx.which("claude") || fs.existsSync(path.join(ctx.home, ".claude.json")) || fs.existsSync(path.join(ctx.home, ".claude")),
       signIn: "In Claude Code run /mcp, pick likho, choose Authenticate.",
+      // A new folder's .mcp.json stays "pending approval" until Claude Code is
+      // run there once in a terminal (the VS Code panel doesn't ask).
+      projectSignIn: "If likho isn't in /mcp: run `claude` once in a terminal in this folder, trust it and approve likho. Then /mcp, pick likho, Authenticate.",
       project: true,
       global: true,
       file: (c, scope) => (scope === "project" ? path.join(c.cwd, ".mcp.json") : path.join(c.home, ".claude.json")),
@@ -76,7 +123,9 @@ function tools(ctx) {
           run("claude", ["mcp", "remove", NAME, "--scope", "user"]);
           if (run("claude", ["mcp", "add", "--transport", "http", "--scope", "user", NAME, url])) return { file, replaced: false };
         }
-        return { file, replaced: Boolean(files.setEntry(file, "mcpServers", NAME, { type: "http", url })) };
+        const replaced = Boolean(files.setEntry(file, "mcpServers", NAME, { type: "http", url }));
+        if (scope === "project") approveProjectServer(c);
+        return { file, replaced };
       },
       remove(c, scope) {
         if (scope === "global" && c.which("claude") && run("claude", ["mcp", "remove", NAME, "--scope", "user"])) return true;
@@ -86,6 +135,13 @@ function tools(ctx) {
         const found = files.getEntry(this.file(c, scope), "mcpServers", NAME);
         return found ? found.url || "(set)" : null;
       },
+      leftovers(c, scope) {
+        return oldNames(files.listEntries(this.file(c, scope), "mcpServers"));
+      },
+      removeOld(c, scope, name) {
+        if (scope === "global" && c.which("claude") && run("claude", ["mcp", "remove", name, "--scope", "user"])) return true;
+        return files.removeEntry(this.file(c, scope), "mcpServers", name);
+      },
     },
     {
       id: "codex",
@@ -112,6 +168,13 @@ function tools(ctx) {
       current(c) {
         return files.getTomlServerUrl(this.file(c), NAME);
       },
+      leftovers(c) {
+        return oldNames(files.listTomlServers(this.file(c)));
+      },
+      removeOld(c, scope, name) {
+        if (c.which("codex") && run("codex", ["mcp", "remove", name])) return true;
+        return files.removeTomlServer(this.file(c), name);
+      },
     },
     jsonTool({
       id: "cursor",
@@ -189,4 +252,4 @@ function context(overrides = {}) {
   };
 }
 
-module.exports = { tools, context, NAME };
+module.exports = { tools, context, NAME, isOldLikho };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "likho-cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Connect every AI tool on your computer (Claude Code, Codex, Cursor, VS Code, Gemini CLI, opencode, Windsurf) to Likho in one command.",
   "license": "MIT",
   "homepage": "https://likho.me",