@love-moon/conductor-cli 0.17.1 → 0.18.0

package/CHANGELOG.md

@@ -1,5 +1,70 @@
 # @love-moon/conductor-cli
 
+## 0.18.0
+
+### Minor Changes
+
+- 72324fd: Add a local multi-chat runtime with isolated Chromium workers, persistent profiles,
+  per-account concurrency, resumable events, request deduplication, and SDK/CLI access.
+  Add experimental Kimi and Claude webpage adapters and optional AI SDK socket transport.
+
+  Support Kimi Connect JSON envelopes and DeepSeek XHR SSE patches, with verified
+  parallel real-account text chats, independent cancellation, and restart recovery.
+
+  Add DeepSeek --deepthink / --no-deepthink controls and SDK options with persisted
+  chat defaults, per-turn overrides, verified UI state, and runtime capability checks.
+
+  Connect Conductor web-kimi and web-deepseek to managed isolated Chromium workers
+  by default. Add conductor chat-web login, account credential bootstrap, automatic
+  daemon startup and idle shutdown, stable cross-process resume IDs, and browser
+  release when tasks close. Preserve the shared-profile queue for other providers.
+  Retain cancelled conversation URLs and report confirmed stops as interruptions.
+
+### Patch Changes
+
+- 31b61ea: Bound closed-chat and terminal-turn retention, reclaim browser profiles and orphan
+  directories, and keep streaming deltas in memory between durable checkpoints.
+  Defer saturated or busy chat startup to the turn queue, validate authentication at
+  allocation, and expire queued prompts before crash recovery or delayed submission.
+  Keep Gemini on its legacy transport with global runtime sockets and consume the
+  Conductor wrapper separator before forwarding a packaged CLI command.
+- 924f51c: Time out stalled WebSocket handshakes so a fire can no longer wedge forever
+  mid-reconnect, and let an in-place restart replace a task's tmux fire that the
+  server sees as disconnected instead of refusing with "task already active".
+- Updated dependencies [bdbda18]
+- Updated dependencies [063b97c]
+- Updated dependencies [31b61ea]
+- Updated dependencies [924f51c]
+- Updated dependencies [72324fd]
+  - @love-moon/ai-sdk@0.18.0
+  - @love-moon/conductor-sdk@0.18.0
+
+## 0.17.2
+
+### Patch Changes
+
+- 0a9488e: Add Kimi website text conversations with persistent login, multi-turn context,
+  reply progress, new chats and browser diagnostics. Expose the provider through
+  ai-sdk's chat-web backend and the web-kimi Conductor configuration alias.
+
+  Explicit unknown chat-web providers now fail with a clear error instead of
+  silently opening ChatGPT. The existing kimi CLI backend is unchanged.
+
+- b16c1ae: Allow a shared daemon to run the AI side of a Global AI Backend task while code
+  stays on one of the user's own daemons. Advertise
+  `shared_ai_global_backend_v1` and forward the task id on remote exec, file, and
+  MCP requests so the backend can authorize only that task's remote binding.
+
+  Keep remote grants tied to active tasks: shared credentials cannot mint remote
+  bindings, renew them through restarts or persistent rounds, or reactivate ended
+  tasks through status updates. Check shared AI compatibility when restarting or
+  starting later rounds of an existing remote task too.
+
+- Updated dependencies [b124565]
+- Updated dependencies [0a9488e]
+  - @love-moon/ai-sdk@0.17.2
+  - @love-moon/conductor-sdk@0.17.2
+
 ## 0.17.1
 
 ### Patch Changes

package/bin/conductor-chat-web.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import yaml from "js-yaml";
+import { resolveConductorConfigPath } from "../src/conductor-paths.js";
+
+export async function runChatWebCommand(args = process.argv.slice(2), deps = {}) {
+  const log = deps.log ?? (text => process.stdout.write(text));
+  if (!args.length || args[0] === "--help" || args[0] === "-h") {
+    log("Usage: conductor chat-web login <kimi|deepseek> [--config-file PATH]\n       conductor chat-web <serve|chat|turn|runtime> ...\n\nSign in once on the daemon host. web-kimi and web-deepseek start their runtime automatically.\n");
+    return 0;
+  }
+  const env = deps.env ?? process.env;
+  const forwarded = [];
+  let configFile;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--") { forwarded.push(...args.slice(i + (forwarded.length === 0 ? 1 : 0))); break; }
+    if (args[i] === "--config-file") {
+      if (!args[i + 1]) throw new Error("--config-file requires a path");
+      configFile = args[++i];
+    } else if (args[i].startsWith("--config-file=")) {
+      configFile = args[i].slice("--config-file=".length);
+      if (!configFile) throw new Error("--config-file requires a path");
+    } else forwarded.push(args[i]);
+  }
+  args = forwarded;
+  const configPath = resolveConductorConfigPath(configFile, env);
+  if (configFile && !fs.existsSync(configPath)) throw new Error("Conductor config not found: " + configPath);
+  if (fs.existsSync(configPath)) {
+    const config = yaml.load(fs.readFileSync(configPath, "utf8"));
+    for (const [key, value] of Object.entries(config?.envs ?? {})) {
+      if (/^(CHAT_WEB_|https?_proxy$|all_proxy$|no_proxy$)/i.test(key) && env[key] === undefined && value !== null && value !== undefined) env[key] = String(value);
+    }
+  }
+  const req = createRequire(import.meta.url);
+  let mod;
+  try { mod = deps.chatWebModule ?? await import("@love-moon/chat-web"); }
+  catch { throw new Error("Browser chat is unavailable. Install @love-moon/chat-web on this daemon host."); }
+  if (args[0] === "login") {
+    if (args.length !== 2 || !["kimi", "deepseek"].includes(args[1])) throw new Error("Usage: conductor chat-web login <kimi|deepseek>");
+    if (typeof mod.RuntimeChatSession?.open !== "function") throw new Error("Upgrade @love-moon/chat-web to use Conductor browser chat login");
+    mod.registerBuiltinProviders();
+    await mod.login(args[1], { autoExit: true });
+    log("Browser chat account saved. Select web-" + args[1] + " in Conductor.\n");
+    return 0;
+  }
+  const entry = deps.cliEntry ?? path.join(path.dirname(req.resolve("@love-moon/chat-web/package.json")), "dist/cli.js");
+  // The packaged CLI handles socket management and prints structured results.
+  process.argv = [process.execPath, entry, ...args];
+  await (deps.importCli ?? (url => import(url)))(pathToFileURL(entry).href);
+}
+
+const entry = process.argv[1];
+if (entry && fs.existsSync(entry) && fs.realpathSync(entry) === fs.realpathSync(new URL(import.meta.url))) {
+  runChatWebCommand().then(code => { if (typeof code === "number") process.exitCode = code; }, error => {
+    process.stderr.write(error.message + "\n"); process.exitCode = 1;
+  });
+}

package/bin/conductor-config.js

@@ -55,13 +55,25 @@ const DEFAULT_CLIs = {
   // chat-web is the runtime backend (an in-process Chromium driver, not a CLI
   // binary). It has multiple sub-providers selected via --model. Each user-
   // facing alias below resolves to the chat-web runtime; advertising the bare
-  // `chat-web` backend would be ambiguous, so we emit two explicit aliases.
+  // `chat-web` backend would be ambiguous, so we emit explicit aliases.
   "web-chatgpt": {
     command: "chat-web",
     execArgs: "--model chatgpt",
     description: "Chat web (ChatGPT) via @love-moon/chat-web",
     runtimeBackend: "chat-web"
   },
+  "web-kimi": {
+    command: "chat-web",
+    execArgs: "--model kimi",
+    description: "Chat web (Kimi) via @love-moon/chat-web",
+    runtimeBackend: "chat-web"
+  },
+  "web-deepseek": {
+    command: "chat-web",
+    execArgs: "--model deepseek",
+    description: "Chat web (DeepSeek) via @love-moon/chat-web",
+    runtimeBackend: "chat-web"
+  },
   "web-gemini": {
     command: "chat-web",
     execArgs: "--model gemini",
@@ -137,10 +149,10 @@ function buildConfigEntryLines(cli, info, { commented = false } = {}) {
     lines.push(`${commentPrefix}opencode runs via ai-sdk server mode with permission=allow`);
   }
   if (cli === "web-chatgpt") {
-    // web-chatgpt / web-gemini both resolve to the chat-web runtime backend
+    // web-chatgpt / web-gemini / web-kimi / web-deepseek resolve to the chat-web runtime backend
     // (an in-process Chromium driver via @love-moon/chat-web). The command
     // line is not executed; CLI parses --model from it.
-    lines.push(`${commentPrefix}web-chatgpt / web-gemini drive a real Chromium browser via @love-moon/chat-web`);
+    lines.push(`${commentPrefix}web-chatgpt / web-gemini / web-kimi / web-deepseek drive a real Chromium browser via @love-moon/chat-web`);
   }
 
   lines.push(`${entryPrefix}${cli}: ${fullCommand}`);

package/bin/conductor-fire.js

@@ -266,9 +266,17 @@ export function resolveAiSessionCommandLine(backend, allowCliList, env = process
 }
 
 export function resolveAiSessionOptions(backend, allowCliList, env = process.env, sessionBackend = backend) {
-  return extractAiSessionOptionsFromCommandLine(
-    resolveAiSessionCommandLine(backend, allowCliList, env, sessionBackend),
-  );
+  const commandLine = resolveAiSessionCommandLine(backend, allowCliList, env, sessionBackend);
+  const options = extractAiSessionOptionsFromCommandLine(commandLine);
+  if (normalizeRuntimeBackendName(sessionBackend) === "chat-web") {
+    const { parts } = parseCommandParts(commandLine);
+    for (const [positive, negative, key] of [["--headless", "--headed", "headless"], ["--deepthink", "--no-deepthink", "chatWebDeepThink"]]) {
+      if (parts.includes(positive) && parts.includes(negative)) throw new Error(`Choose ${positive} or ${negative}`);
+      if (parts.includes(positive)) options[key] = true;
+      else if (parts.includes(negative)) options[key] = false;
+    }
+  }
+  return options;
 }
 
 const DEFAULT_POLL_INTERVAL_MS = parseInt(
@@ -940,10 +948,10 @@ async function main() {
       env: process.env,
     });
 
-    // chat-web tasks drive a real Chromium browser that holds a per-profile
-    // singleton lock for as long as the task lives. A task that never ends
-    // pins that browser indefinitely (and blocks other chats for the same
-    // provider), so we cap its active lifetime and auto-stop it when exceeded.
+    // chat-web tasks retain a tab in the shared profile browser while alive.
+    // New runtimes schedule turns across tasks; older runtimes exclusively
+    // own the profile. Cap task lifetime so abandoned sessions release their
+    // browser resources in either runtime.
     // The conversation itself is preserved (it lives in the provider account
     // and the persisted profile; closing the browser does not delete it).
     const runtimeBackendToken = String(sessionCommandLine || "")

package/bin/conductor.js

@@ -51,6 +51,7 @@ export function runConductorCli(args = argv, deps = {}) {
     "send-file",
     "channel",
     "serve-ai",
+    "chat-web",
     "project",
     "issue",
     "task",
@@ -140,6 +141,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
+  chat-web  Sign in and manage browser chat accounts and conversations
   serve-ai  Start an OpenAI-compatible local AI server
   project   Manage Conductor projects (list/show/create/update/delete/reorder/
             agents/collab/labels/...)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.17.1",
-  "gitCommitId": "e3dbbad",
+  "version": "0.18.0",
+  "gitCommitId": "825d90a",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -20,12 +20,12 @@
     "provenance": true
   },
   "scripts": {
-    "pretest": "pnpm --dir ../modules/ai-sdk build && pnpm --dir ../modules/conductor-sdk build",
+    "pretest": "pnpm --dir ../modules/chat-web build && pnpm --dir ../modules/ai-sdk build && pnpm --dir ../modules/conductor-sdk build",
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.17.1",
-    "@love-moon/conductor-sdk": "0.17.1",
+    "@love-moon/ai-sdk": "0.18.0",
+    "@love-moon/conductor-sdk": "0.18.0",
     "@github/copilot-sdk": "^0.3.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
@@ -38,7 +38,7 @@
   },
   "optionalDependencies": {
     "@roamhq/wrtc": "^0.10.0",
-    "@love-moon/chat-web": "0.17.1"
+    "@love-moon/chat-web": "0.18.0"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

package/src/daemon.js

@@ -3928,6 +3928,9 @@ export function startDaemon(config = {}, deps = {}) {
     // another daemon over `conductor remote` and binds the remote_* MCP tools
     // to a remoteWorkspace as well as a remoteWorktree.
     "global_backend_v1",
+    // A shared AI also sends CONDUCTOR_TASK_ID on every remote request so the
+    // backend can grant only that task's A → B remote permission.
+    "shared_ai_global_backend_v1",
     "backend_session_list",
     CUSTOM_COMMANDS_CAPABILITY,
     UPDATE_DAEMON_CAPABILITY,
@@ -7078,7 +7081,7 @@ export function startDaemon(config = {}, deps = {}) {
   // left is a still-exiting child or a tmux record the liveness reaper has not
   // swept yet; a fire that is somehow still alive is stopped here. Its terminal
   // status is suppressed because the task row now belongs to the new round.
-  async function releaseReplacedFire(taskId) {
+  async function releaseReplacedFire(taskId, reason = "persistent_new_round") {
     const record = activeTaskProcesses.get(taskId);
     if (!recordHasLiveFire(record)) {
       return true;
@@ -7096,12 +7099,12 @@ export function startDaemon(config = {}, deps = {}) {
         forgetFireSessionRecord(record);
         return true;
       }
-      stopActiveTaskProcess(taskId, { reason: "persistent_new_round", suppressExitStatusReport: true });
+      stopActiveTaskProcess(taskId, { reason, suppressExitStatusReport: true });
       // The tmux stop path retires the record synchronously and never consumes the flag.
       suppressedExitStatusReports.delete(taskId);
       return !activeTaskProcesses.has(taskId);
     }
-    stopActiveTaskProcess(taskId, { reason: "persistent_new_round", suppressExitStatusReport: true });
+    stopActiveTaskProcess(taskId, { reason, suppressExitStatusReport: true });
     const stopped = await waitForTaskToStop(taskId);
     if (!stopped) {
       suppressedExitStatusReports.delete(taskId);
@@ -8275,6 +8278,18 @@ export function startDaemon(config = {}, deps = {}) {
       }
     }
 
+    // The server saw no connected fire for this task, so a surviving session
+    // is a wedged fire (e.g. stuck mid-reconnect): replace it, don't refuse.
+    if (
+      !isRefreshSessionInplace &&
+      payload?.replace_existing_fire === true &&
+      recordHasLiveFire(activeTarget)
+    ) {
+      log(`Replacing disconnected fire for task ${normalizedTargetTaskId} before restart`);
+      await releaseReplacedFire(normalizedTargetTaskId, "restart_replace_disconnected_fire");
+      activeTarget = activeTaskProcesses.get(normalizedTargetTaskId);
+    }
+
     // The probe above already cleared the record if the session was
     // conclusively gone, so a surviving tmuxMode entry means a live session.
     const targetHasLiveFire = recordHasLiveFire(activeTarget);

package/src/remote/client.js

@@ -62,7 +62,11 @@ export function loadCliConfig(configFile, env = process.env) {
 }
 
 function authHeaders(config) {
-  return { Authorization: `Bearer ${config.agentToken}` };
+  const taskId = process.env.CONDUCTOR_TASK_ID?.trim();
+  return {
+    Authorization: `Bearer ${config.agentToken}`,
+    ...(taskId ? { "X-Conductor-Task-Id": taskId } : {}),
+  };
 }
 
 async function toApiError(response) {

package/src/remote/mcp-launch.js

@@ -19,6 +19,7 @@ export const REMOTE_WORKTREE_ENV = "CONDUCTOR_REMOTE_WORKTREE";
 const FORWARDED_ENV = [
   "CONDUCTOR_AGENT_TOKEN",
   "CONDUCTOR_BACKEND_URL",
+  "CONDUCTOR_TASK_ID",
   "CONDUCTOR_CONFIG",
   "CONDUCTOR_HOME",
   "CONDUCTOR_REMOTE_CHUNK_BYTES",

package/src/runtime-backends.js

@@ -19,9 +19,9 @@ const BUILT_IN_RUNTIME_BACKEND_SET = new Set(BUILT_IN_RUNTIME_BACKENDS);
 //
 // chat-web is intentionally NOT here even though it's also command-optional
 // (it drives a Chromium browser, not a CLI). The reason: chat-web has
-// configurable sub-providers (chatgpt / gemini / deepseek) selected via
+// configurable sub-providers (chatgpt / gemini / kimi / deepseek) selected via
 // `--model`, and surfacing a bare `chat-web` backend alongside user
-// aliases like `web-chatgpt` / `web-gemini` is just confusing — the alias
+// aliases like `web-chatgpt` / `web-gemini` / `web-kimi` is just confusing — the alias
 // IS the sub-provider choice. Users who want chat-web must declare an
 // explicit allow_cli_list entry (which is also where `--model` lives).
 const COMMAND_OPTIONAL_BUILT_IN_RUNTIME_BACKENDS = ["copilot", "dsh"];