@love-moon/conductor-cli 0.2.39 → 0.2.41

package/bin/conductor-serve-ai.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import process from "node:process";
+
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+
+import { startServeAiServer } from "../src/serve-ai/index.js";
+import {
+  resolveServeAiConfigPaths,
+  writeServeAiConfigFile,
+} from "../src/serve-ai/config.js";
+
+const CLI_NAME = process.env.CONDUCTOR_CLI_NAME || "conductor serve-ai";
+
+main().catch((error) => {
+  process.stderr.write(`serve-ai failed: ${error?.message || error}\n`);
+  process.exit(1);
+});
+
+async function main() {
+  await yargs(hideBin(process.argv))
+    .scriptName(CLI_NAME)
+    .command(
+      "$0",
+      "Start an OpenAI-compatible AI server",
+      (cmd) =>
+        cmd
+          .option("host", {
+            type: "string",
+            default: process.env.CONDUCTOR_SERVE_AI_HOST || undefined,
+            describe: "Host interface to bind",
+          })
+          .option("port", {
+            type: "number",
+            default: process.env.CONDUCTOR_SERVE_AI_PORT ? Number(process.env.CONDUCTOR_SERVE_AI_PORT) : undefined,
+            describe: "TCP port to bind",
+          })
+          .option("backend", {
+            type: "string",
+            describe: "Default backend/model to use when request model is omitted",
+          })
+          .option("config-file", {
+            type: "string",
+            describe: "Primary Conductor config path to check before falling back",
+          })
+          .option("api-key", {
+            type: "string",
+            describe: "Optional API key to require via Authorization: Bearer <key>",
+          })
+          .example("$0", "Start an OpenAI-compatible server using config.yaml or config-ai-serve.yaml")
+          .example("$0 --backend kimi --port 9000", "Use kimi as default backend and listen on port 9000")
+          .example("$0 --api-key local-dev-key", "Require Bearer local-dev-key"),
+      async (args) => {
+        const server = await startServeAiServer({
+          host: args.host,
+          port: args.port,
+          backend: args.backend,
+          configFile: args.configFile,
+          apiKey: args.apiKey,
+        });
+
+        process.stdout.write(
+          `OpenAI-compatible server listening at ${server.url} (default model: ${args.backend || "auto"})\n`,
+        );
+        process.stdout.write(
+          `Config source: ${server.configSource} (${server.configPath})\n`,
+        );
+
+        const shutdown = async () => {
+          process.stdout.write("Shutting down serve-ai server\n");
+          await server.close().catch(() => {});
+          process.exit(0);
+        };
+
+        process.on("SIGINT", () => {
+          void shutdown();
+        });
+        process.on("SIGTERM", () => {
+          void shutdown();
+        });
+
+        await new Promise(() => {});
+      },
+    )
+    .command(
+      "init",
+      "Create a dedicated config-ai-serve.yaml next to the primary config path",
+      (cmd) =>
+        cmd
+          .option("config-file", {
+            type: "string",
+            describe: "Primary Conductor config path whose directory will host config-ai-serve.yaml",
+          })
+          .option("backend", {
+            type: "string",
+            default: "codex",
+            describe: "Default backend to write into serve_ai.backend",
+          })
+          .option("host", {
+            type: "string",
+            default: "127.0.0.1",
+            describe: "Default host to write into serve_ai.host",
+          })
+          .option("port", {
+            type: "number",
+            default: 8787,
+            describe: "Default port to write into serve_ai.port",
+          })
+          .option("api-key", {
+            type: "string",
+            describe: "Optional default API key to write into serve_ai.api_key",
+          })
+          .option("force", {
+            type: "boolean",
+            default: false,
+            describe: "Overwrite an existing config-ai-serve.yaml",
+          })
+          .example("$0 init", "Create ~/.conductor/config-ai-serve.yaml")
+          .example("$0 init --config-file /tmp/custom/config.yaml", "Create /tmp/custom/config-ai-serve.yaml"),
+      async (args) => {
+        const { conductorConfigPath, serveAiConfigPath } = resolveServeAiConfigPaths(args.configFile);
+        if (fs.existsSync(serveAiConfigPath) && !args.force) {
+          throw new Error(
+            `serve-ai config already exists at ${serveAiConfigPath}. Use --force to overwrite it.`,
+          );
+        }
+
+        writeServeAiConfigFile(serveAiConfigPath, {
+          backend: args.backend,
+          host: args.host,
+          port: args.port,
+          apiKey: args.apiKey,
+        });
+
+        process.stdout.write(`Primary config path: ${conductorConfigPath}\n`);
+        process.stdout.write(`Created serve-ai config: ${serveAiConfigPath}\n`);
+      },
+    )
+    .demandCommand(1, "")
+    .help()
+    .strict()
+    .parseAsync();
+}

package/bin/conductor.js

@@ -11,6 +11,7 @@
  *   diagnose - Diagnose a task in production/backend
  *   send-file - Upload a local file into a task session
  *   channel  - Connect user-owned chat channel providers
+ *   serve-ai - Start an OpenAI-compatible local AI server
  */
 
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -34,7 +35,7 @@ export function runConductorCli(args = argv, deps = {}) {
   const processArgv = deps.processArgv || process.argv;
   const fsExistsSync = deps.existsSync || fs.existsSync;
   const checkForUpdates = deps.maybeCheckForUpdates || maybeCheckForUpdates;
-  const validSubcommands = ["fire", "daemon", "config", "update", "diagnose", "send-file", "channel"];
+  const validSubcommands = ["fire", "daemon", "config", "update", "diagnose", "send-file", "channel", "serve-ai"];
 
   if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
     showHelp(consoleImpl);
@@ -115,6 +116,7 @@ Subcommands:
   diagnose  Diagnose a task and print likely root cause
   send-file Upload a local file into a task session
   channel   Connect user-owned chat channel providers
+  serve-ai  Start an OpenAI-compatible local AI server
 
 Options:
   -h, --help     Show this help message
@@ -127,6 +129,7 @@ Examples:
   conductor diagnose <task-id>
   conductor send-file ./screenshot.png
   conductor channel connect feishu
+  conductor serve-ai --port 8787
   conductor config
   conductor update
 
@@ -138,6 +141,7 @@ For subcommand-specific help:
   conductor diagnose --help
   conductor send-file --help
   conductor channel --help
+  conductor serve-ai --help
 
 Version: ${pkgJson.version}
 `);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.39",
-  "gitCommitId": "30204c8",
+  "version": "0.2.41",
+  "gitCommitId": "89ac834",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -17,10 +17,10 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-bridge": "0.1.4",
-    "@love-moon/ai-manager": "0.2.39",
-    "@love-moon/ai-sdk": "0.2.39",
-    "@love-moon/conductor-sdk": "0.2.39",
+    "@love-moon/ai-manager": "0.2.41",
+    "@love-moon/ai-sdk": "0.2.41",
+    "@love-moon/conductor-sdk": "0.2.41",
+    "@github/copilot-sdk": "^0.2.2",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
     "dotenv": "^16.4.5",

package/src/ai-manager-handlers.js

@@ -22,7 +22,7 @@ export function createAiManagerHandlers(opts = {}) {
       manager.getCurrentCodexAccount().catch(() => null),
     ]);
     const network = {};
-    const tools = ["codex", "claude", "kimi"];
+    const tools = ["codex", "claude", "kimi", "copilot"];
     await Promise.all(
       tools.map(async (tool) => {
         if (install[tool]?.installed) {
@@ -42,32 +42,37 @@ export function createAiManagerHandlers(opts = {}) {
   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" };
+    const forceRefresh = Boolean(args.forceRefresh);
+    const jobs = [];
+    const addJob = (tool, fetcher) => {
+      if (!tools.has(tool)) {
+        return;
       }
+      jobs.push((async () => {
+        try {
+          return [tool, await fetcher()];
+        } catch (err) {
+          return [tool, { tool, error: errMsg(err), source: "unknown" }];
+        }
+      })());
+    };
+
+    addJob("codex", () => manager.getCodexQuota({
+      forceRefresh,
+    }));
+    addJob("claude", () => manager.getClaudeQuota({
+      forceRefresh,
+    }));
+    addJob("kimi", () => manager.getKimiQuota({
+      forceRefresh,
+    }));
+    addJob("copilot", () => manager.getCopilotQuota({
+      forceRefresh,
+    }));
+
+    const entries = await Promise.all(jobs);
+    for (const [tool, result] of entries) {
+      out[tool] = result;
     }
     return out;
   }
@@ -129,30 +134,29 @@ export async function handleAiManagerRequest(client, handlers, payload) {
     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;
+  const response = await handlers.dispatch({
+    action,
+    args: payload?.args && typeof payload.args === "object" ? payload.args : {},
+  });
+
+  const outgoing = {
+    type: "ai_manager_response",
+    payload: {
+      request_id: requestId,
+      action,
+      ...(response?.error ? { error: response.error } : { result: response?.result }),
+    },
+  };
+  await client.sendJson(outgoing).catch(() => {});
+  return response;
 }
 
-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 pickToolFilter(args = {}) {
+  const tool = typeof args.tool === "string" ? args.tool.trim().toLowerCase() : "";
+  if (tool && ["codex", "claude", "kimi", "copilot"].includes(tool)) return new Set([tool]);
+  return new Set(["codex", "claude", "kimi", "copilot"]);
 }
 
 function errMsg(err) {
-  if (err instanceof Error) return err.message;
-  return String(err);
+  return err?.message ?? String(err);
 }