@love-moon/conductor-cli 0.2.35 → 0.2.36

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.35",
-  "gitCommitId": "686ee4d",
+  "version": "0.2.36",
+  "gitCommitId": "54d9de4",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -18,8 +18,9 @@
   },
   "dependencies": {
     "@love-moon/ai-bridge": "0.1.4",
-    "@love-moon/ai-sdk": "0.2.35",
-    "@love-moon/conductor-sdk": "0.2.35",
+    "@love-moon/ai-manager": "0.2.36",
+    "@love-moon/ai-sdk": "0.2.36",
+    "@love-moon/conductor-sdk": "0.2.36",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
     "dotenv": "^16.4.5",
@@ -39,6 +40,7 @@
     ],
     "overrides": {
       "@love-moon/ai-sdk": "file:../modules/ai-sdk",
+      "@love-moon/ai-manager": "file:../modules/ai-manager",
       "@love-moon/conductor-sdk": "file:../modules/conductor-sdk"
     }
   }

package/src/ai-manager-handlers.js

@@ -0,0 +1,158 @@
+// Daemon-side glue between the realtime WebSocket and the @love-moon/ai-manager module.
+// The web backend sends `ai_manager_request`; we dispatch by `action`, run it, and
+// reply with `ai_manager_response` carrying the same `request_id`.
+
+import { AiManager } from "@love-moon/ai-manager";
+
+const VALID_ACTIONS = new Set(["status", "quota", "list_accounts", "switch_account"]);
+
+/**
+ * @param {object} opts
+ * @param {string} [opts.configPath] Path to ~/.conductor/config.yaml. Defaults to ai-manager's default.
+ */
+export function createAiManagerHandlers(opts = {}) {
+  const manager = new AiManager(opts.configPath ? { configPath: opts.configPath } : undefined);
+
+  async function status() {
+    // Probe install first; only check network for tools that are actually
+    // present so we don't pay an outbound HTTP timeout for a CLI the user
+    // never installed.
+    const [install, current] = await Promise.all([
+      manager.checkInstallAll(),
+      manager.getCurrentCodexAccount().catch(() => null),
+    ]);
+    const network = {};
+    const tools = ["codex", "claude", "kimi"];
+    await Promise.all(
+      tools.map(async (tool) => {
+        if (install[tool]?.installed) {
+          network[tool] = await manager.checkNetwork(tool);
+        } else {
+          network[tool] = {
+            reachable: false,
+            endpoint: "",
+            error: "not installed",
+          };
+        }
+      }),
+    );
+    return { install, network, currentCodexAccount: current };
+  }
+
+  async function quota(args = {}) {
+    const tools = pickToolFilter(args);
+    const out = {};
+    if (tools.has("codex")) {
+      try {
+        out.codex = await manager.getCodexQuota({
+          forceRefresh: Boolean(args.forceRefresh),
+        });
+      } catch (err) {
+        out.codex = { tool: "codex", error: errMsg(err), source: "unknown" };
+      }
+    }
+    if (tools.has("claude")) {
+      try {
+        out.claude = await manager.getClaudeQuota({
+          forceRefresh: Boolean(args.forceRefresh),
+        });
+      } catch (err) {
+        out.claude = { tool: "claude", error: errMsg(err), source: "unknown" };
+      }
+    }
+    if (tools.has("kimi")) {
+      try {
+        out.kimi = await manager.getKimiQuota({
+          forceRefresh: Boolean(args.forceRefresh),
+        });
+      } catch (err) {
+        out.kimi = { tool: "kimi", error: errMsg(err), source: "unknown" };
+      }
+    }
+    return out;
+  }
+
+  async function listAccounts() {
+    return { accounts: await manager.listCodexAccounts() };
+  }
+
+  async function switchAccount(args = {}) {
+    if (!args.name || typeof args.name !== "string") {
+      throw new Error("switch_account requires a `name` string");
+    }
+    return await manager.switchCodexAccount(args.name);
+  }
+
+  /**
+   * Run a single action and return a `result` object, never throwing.
+   * @param {{action:string,args?:object}} payload
+   */
+  async function dispatch(payload) {
+    const action = payload?.action;
+    if (!VALID_ACTIONS.has(action)) {
+      return { error: `unknown action: ${action}` };
+    }
+    try {
+      switch (action) {
+        case "status":
+          return { result: await status() };
+        case "quota":
+          return { result: await quota(payload?.args ?? {}) };
+        case "list_accounts":
+          return { result: await listAccounts() };
+        case "switch_account":
+          return { result: await switchAccount(payload?.args ?? {}) };
+        default:
+          return { error: `unhandled action: ${action}` };
+      }
+    } catch (err) {
+      return { error: errMsg(err) };
+    }
+  }
+
+  return { dispatch, manager };
+}
+
+/**
+ * Wire a handler against an event payload from the web backend, sending the
+ * response back through `client.sendJson` once the action completes.
+ *
+ * @param {object} client - conductor websocket client (must have sendJson)
+ * @param {ReturnType<typeof createAiManagerHandlers>} handlers
+ * @param {object} payload - event.payload with shape { request_id, action, args }
+ */
+export async function handleAiManagerRequest(client, handlers, payload) {
+  const requestId = payload?.request_id ? String(payload.request_id) : "";
+  const action = payload?.action ? String(payload.action) : "";
+  if (!requestId) {
+    // Without a request_id we cannot route the response anywhere; drop and log upstream.
+    return { error: "missing request_id" };
+  }
+
+  const out = await handlers.dispatch({ action, args: payload?.args });
+  await client
+    .sendJson({
+      type: "ai_manager_response",
+      payload: {
+        request_id: requestId,
+        action,
+        result: out.result,
+        error: out.error,
+      },
+    })
+    .catch(() => {});
+  return out;
+}
+
+function pickToolFilter(args) {
+  const t = args?.tool;
+  if (t === "codex") return new Set(["codex"]);
+  if (t === "claude") return new Set(["claude"]);
+  if (t === "kimi") return new Set(["kimi"]);
+  return new Set(["codex", "claude", "kimi"]);
+}
+
+function errMsg(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}

package/src/daemon.js

@@ -16,6 +16,7 @@ import {
   ProjectContext,
 } from "@love-moon/conductor-sdk";
 import { DaemonLogCollector } from "./log-collector.js";
+import { createAiManagerHandlers, handleAiManagerRequest } from "./ai-manager-handlers.js";
 import { resolveResumeContext } from "./fire/resume.js";
 import {
   filterRuntimeSupportedAllowCliList,
@@ -1456,6 +1457,8 @@ export function startDaemon(config = {}, deps = {}) {
   if (advertisedCapabilities.length > 0) {
     extraHeaders["x-conductor-capabilities"] = advertisedCapabilities.join(",");
   }
+  const aiManagerHandlers = createAiManagerHandlers({ configPath: config.CONFIG_FILE });
+
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders,
     onConnected: ({ isReconnect, connectedAt } = { isReconnect: false, connectedAt: Date.now() }) => {
@@ -3431,6 +3434,11 @@ export function startDaemon(config = {}, deps = {}) {
     if (event.type === "validate_project_path") {
       void handleValidateProjectPath(event.payload);
     }
+    if (event.type === "ai_manager_request") {
+      handleAiManagerRequest(client, aiManagerHandlers, event.payload).catch((error) => {
+        logError(`Unhandled ai_manager_request failure: ${error?.message || error}`);
+      });
+    }
   }
 
   function markWatchdogHealthy(signal, at = Date.now()) {