@love-moon/conductor-cli 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @love-moon/conductor-cli
 
+## 0.6.0
+
+### Minor Changes
+
+- bcc80b5: Initialize Git submodules automatically when preparing task worktrees.
+
+### Patch Changes
+
+- @love-moon/conductor-sdk@0.6.0
+- @love-moon/ai-sdk@0.6.0
+
+## 0.5.1
+
+### Patch Changes
+
+- 39a49fc: fix: reclaim orphaned chat-web browser and cap chat-web task lifetime
+
+  chat-web persists one Chromium profile per provider, guarded by a per-profile
+  SingletonLock. A task whose browser was not cleaned up (e.g. the ai-sdk worker
+  was SIGKILLed) left an orphaned Chromium holding that lock, so the next task for
+  the same provider failed to launch with `Opening in existing browser session`.
+
+  - chat-web now reclaims stale/orphaned profile locks before launching (kills an
+    orphan whose owner process is gone, clears dead locks) and refuses with a
+    clear `ProfileLockedError` when a genuine live chat still holds the profile.
+  - The ai-sdk worker now closes its session (and browser) on SIGTERM/SIGINT and
+    bounds the close so it can't hang, preventing browser leaks on shutdown.
+  - conductor fire caps a chat-web task's active lifetime (default 24h,
+    `CONDUCTOR_CHATWEB_MAX_ACTIVE_MS`) and auto-stops it as
+    `KILLED / max_active_duration`; chat history is preserved.
+
+- Updated dependencies [39a49fc]
+  - @love-moon/ai-sdk@0.5.1
+  - @love-moon/conductor-sdk@0.5.1
+
 ## 0.5.0
 
 ### Patch Changes

package/bin/conductor-fire.js

@@ -246,6 +246,18 @@ const DEFAULT_POLL_INTERVAL_MS = parseInt(
 const DEFAULT_ERROR_LOOP_WINDOW_MS = 2 * 60 * 1000;
 const DEFAULT_ERROR_LOOP_BACKOFF_MS = 3 * 60 * 1000;
 const DEFAULT_ERROR_LOOP_THRESHOLD = 3;
+// Runtime backend tokens (first word of the resolved command line) that mean
+// "this task drives a chat-web Chromium browser". Mirrors ai-sdk's chat-web
+// aliases; user-facing aliases like `web-chatgpt` resolve to one of these.
+const CHAT_WEB_RUNTIME_BACKEND_TOKENS = new Set(["chat-web", "chatweb", "chat_web", "web-chat"]);
+// Max active lifetime for a chat-web task before it is auto-stopped (default
+// 24h). Bounded to [1min, 7d]; override via CONDUCTOR_CHATWEB_MAX_ACTIVE_MS.
+const CHAT_WEB_MAX_ACTIVE_MS = getBoundedEnvInt(
+  "CONDUCTOR_CHATWEB_MAX_ACTIVE_MS",
+  24 * 60 * 60 * 1000,
+  60_000,
+  7 * 24 * 60 * 60 * 1000,
+);
 const SESSION_BOOTSTRAP_LOCK_TIMEOUT_MS = 15_000;
 const SESSION_BOOTSTRAP_LOCK_RETRY_MS = 50;
 const FIRE_WATCHDOG_INTERVAL_MS = getBoundedEnvInt(
@@ -866,6 +878,18 @@ 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.
+    // 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 || "")
+      .trim()
+      .split(/\s+/)[0]
+      ?.toLowerCase() || "";
+    const isChatWebTask = CHAT_WEB_RUNTIME_BACKEND_TOKENS.has(runtimeBackendToken);
+
     log(`Using backend: ${cliArgs.backend}`);
 
     try {
@@ -880,6 +904,7 @@ async function main() {
 
     const signals = new AbortController();
     let shutdownSignal = null;
+    let autoStopReason = null;
     let backendShutdownRequested = false;
     const requestBackendShutdown = (source) => {
       if (backendShutdownRequested) {
@@ -911,6 +936,27 @@ async function main() {
     process.on("SIGINT", onSigint);
     process.on("SIGTERM", onSigterm);
 
+    // Cap the active lifetime of chat-web tasks (default 24h). On expiry we
+    // stop the task gracefully — abort the runner and close the backend
+    // session so the Chromium browser is released — and mark it KILLED with a
+    // max_active_duration reason. Chat history is retained on the provider side.
+    let maxActiveTimer = null;
+    if (isChatWebTask) {
+      maxActiveTimer = setTimeout(() => {
+        log(
+          `chat-web task exceeded max active duration (${CHAT_WEB_MAX_ACTIVE_MS}ms); ` +
+            `auto-stopping task (chat history is preserved).`,
+        );
+        autoStopReason = "max_active_duration";
+        fireShuttingDown = true;
+        signals.abort();
+        requestBackendShutdown("max_active_duration");
+      }, CHAT_WEB_MAX_ACTIVE_MS);
+      if (typeof maxActiveTimer.unref === "function") {
+        maxActiveTimer.unref();
+      }
+    }
+
     if (shouldFireReportTaskStatus({ launchedByDaemon, phase: "running" })) {
       try {
         await conductor.sendTaskStatus(taskContext.taskId, {
@@ -1030,7 +1076,12 @@ async function main() {
           // SDK durable outbox would retry forever, preventing the process from
           // exiting.
           const taskDeletedByUser = remoteStopReason === "deleted_by_user";
-          const finalStatus = shutdownSignal
+          const finalStatus = autoStopReason
+            ? {
+                status: "KILLED",
+                summary: `${autoStopReason}: chat-web task exceeded its max active duration`,
+              }
+            : shutdownSignal
             ? {
                 status: "KILLED",
                 summary: `terminated by ${shutdownSignal}`,
@@ -1079,6 +1130,9 @@ async function main() {
     } finally {
       process.off("SIGINT", onSigint);
       process.off("SIGTERM", onSigterm);
+      if (maxActiveTimer) {
+        clearTimeout(maxActiveTimer);
+      }
       if (shutdownSignal === "SIGINT") {
         process.exitCode = 130;
       } else if (shutdownSignal === "SIGTERM") {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.5.0",
-  "gitCommitId": "7f50aa7",
+  "version": "0.6.0",
+  "gitCommitId": "2f914a7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -23,8 +23,8 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.5.0",
-    "@love-moon/conductor-sdk": "0.5.0",
+    "@love-moon/ai-sdk": "0.6.0",
+    "@love-moon/conductor-sdk": "0.6.0",
     "@github/copilot-sdk": "^0.3.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
@@ -37,7 +37,7 @@
   },
   "optionalDependencies": {
     "@roamhq/wrtc": "^0.10.0",
-    "@love-moon/chat-web": "0.5.0"
+    "@love-moon/chat-web": "0.6.0"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

package/src/daemon.js

@@ -28,6 +28,7 @@ import {
   listAdvertisedBackends,
   resolveConfiguredRuntimeBackend,
   isBuiltInRuntimeBackend,
+  isCommandOptionalBuiltInRuntimeBackend,
   isRuntimeSupportedBackend,
   normalizeRuntimeBackendAlias,
   normalizeRuntimeBackendName,
@@ -1255,6 +1256,8 @@ export function startDaemon(config = {}, deps = {}) {
     "",
     "worktree:",
     "  sync_branch: false",
+    "  sync_submodules: true",
+    "  # When .gitmodules exists, initialize/update submodules in task worktrees.",
     "  symlink: []",
     "  # Example: symlink paths from the parent workspace into each worktree",
     "  # symlink:",
@@ -1263,6 +1266,72 @@ export function startDaemon(config = {}, deps = {}) {
     "",
   ].join("\n");
 
+  const MAX_PROJECT_ICON_IMAGE_BYTES = 128 * 1024;
+  const PROJECT_ICON_MIME_BY_EXTENSION = {
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+    ".avif": "image/avif",
+  };
+
+  function getProjectSettingsCandidates(projectWorkspacePath) {
+    return [
+      path.join(projectWorkspacePath, ".conductor", "settings.yaml"),
+      path.join(projectWorkspacePath, ".conductor", "settings.yml"),
+      path.join(projectWorkspacePath, ".conductor", "setttings.yaml"),
+      path.join(projectWorkspacePath, ".conductor", "setttings.yml"),
+    ];
+  }
+
+  function extractProjectIconFromSettings(parsed) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const direct = normalizeOptionalString(parsed.icon);
+    if (direct) return direct;
+    const projectSettings = parsed.project;
+    if (
+      projectSettings &&
+      typeof projectSettings === "object" &&
+      !Array.isArray(projectSettings)
+    ) {
+      return normalizeOptionalString(projectSettings.icon);
+    }
+    return null;
+  }
+
+  function projectIconLooksLikeFilesystemPath(iconValue) {
+    if (/^(https?:\/\/|data:)/i.test(iconValue)) return false;
+    if (iconValue.startsWith("/") || iconValue.startsWith("./") || iconValue.startsWith("../")) {
+      return true;
+    }
+    if (!iconValue.includes("/")) return false;
+    const ext = path.extname(iconValue).toLowerCase();
+    return Object.prototype.hasOwnProperty.call(PROJECT_ICON_MIME_BY_EXTENSION, ext);
+  }
+
+  function readProjectIconAsDataUri(settingsDir, iconValue) {
+    const resolvedPath = path.isAbsolute(iconValue)
+      ? iconValue
+      : path.resolve(settingsDir, iconValue);
+    const ext = path.extname(resolvedPath).toLowerCase();
+    const mime = PROJECT_ICON_MIME_BY_EXTENSION[ext];
+    if (!mime) return null;
+    try {
+      const stat = statSyncFn(resolvedPath);
+      if (!stat.isFile() || stat.size === 0 || stat.size > MAX_PROJECT_ICON_IMAGE_BYTES) {
+        return null;
+      }
+      return `data:${mime};base64,${readFileSyncFn(resolvedPath).toString("base64")}`;
+    } catch {
+      return null;
+    }
+  }
+
   function ensureProjectSettingsTemplate(projectWorkspacePath) {
     const settingsPath = path.join(projectWorkspacePath, ".conductor", "settings.yaml");
     if (existsSyncFn(settingsPath)) {
@@ -1276,15 +1345,28 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
-  function readProjectWorktreeSettings(projectWorkspacePath) {
-    const settingsCandidates = [
-      path.join(projectWorkspacePath, ".conductor", "settings.yaml"),
-      path.join(projectWorkspacePath, ".conductor", "settings.yml"),
-      path.join(projectWorkspacePath, ".conductor", "setttings.yaml"),
-      path.join(projectWorkspacePath, ".conductor", "setttings.yml"),
-    ];
+  function readProjectIconSetting(projectWorkspacePath) {
+    for (const settingsPath of getProjectSettingsCandidates(projectWorkspacePath)) {
+      if (!existsSyncFn(settingsPath)) {
+        continue;
+      }
+      let rawIcon = null;
+      try {
+        rawIcon = extractProjectIconFromSettings(yaml.load(readFileSyncFn(settingsPath, "utf8")));
+      } catch {
+        return null;
+      }
+      if (!rawIcon) return null;
+      if (!projectIconLooksLikeFilesystemPath(rawIcon)) {
+        return rawIcon;
+      }
+      return readProjectIconAsDataUri(path.dirname(settingsPath), rawIcon);
+    }
+    return null;
+  }
 
-    for (const settingsPath of settingsCandidates) {
+  function readProjectWorktreeSettings(projectWorkspacePath) {
+    for (const settingsPath of getProjectSettingsCandidates(projectWorkspacePath)) {
       if (!existsSyncFn(settingsPath)) {
         continue;
       }
@@ -1298,6 +1380,7 @@ export function startDaemon(config = {}, deps = {}) {
         return {
           symlinkPaths: normalizeConfiguredPathList(worktreeSettings.symlink, projectWorkspacePath),
           syncBranch: worktreeSettings.sync_branch === true || worktreeSettings.syncBranch === true,
+          syncSubmodules: worktreeSettings.sync_submodules !== false && worktreeSettings.syncSubmodules !== false,
           settingsPath,
         };
       } catch (error) {
@@ -1308,6 +1391,7 @@ export function startDaemon(config = {}, deps = {}) {
     return {
       symlinkPaths: [],
       syncBranch: false,
+      syncSubmodules: true,
       settingsPath: null,
     };
   }
@@ -1377,6 +1461,28 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  async function ensureTaskWorktreeSubmodules({ taskId, projectWorkspacePath, worktreeRoot }) {
+    const { syncSubmodules } = readProjectWorktreeSettings(projectWorkspacePath);
+    if (!syncSubmodules || !existsSyncFn(path.join(worktreeRoot, ".gitmodules"))) {
+      return;
+    }
+
+    try {
+      await runSpawnProcess(
+        "git",
+        ["-C", worktreeRoot, "submodule", "sync", "--recursive"],
+        { cwd: worktreeRoot, timeoutMs: WORKTREE_SUBMODULE_SYNC_TIMEOUT_MS },
+      );
+      await runSpawnProcess(
+        "git",
+        ["-C", worktreeRoot, "submodule", "update", "--init", "--recursive"],
+        { cwd: worktreeRoot, timeoutMs: WORKTREE_SUBMODULE_SYNC_TIMEOUT_MS },
+      );
+    } catch (error) {
+      throw new Error(`Failed to sync git submodules for ${taskId}: ${error?.message || error}`);
+    }
+  }
+
   async function runSpawnProcess(command, args, options = {}) {
     let child;
     const { timeoutMs, ...spawnOptions } = options || {};
@@ -1565,6 +1671,11 @@ export function startDaemon(config = {}, deps = {}) {
       }
     }
 
+    await ensureTaskWorktreeSubmodules({
+      taskId,
+      projectWorkspacePath: worktreeConfig.projectWorkspacePath,
+      worktreeRoot,
+    });
     mkdirSyncFn(finalCwd, { recursive: true });
     await ensureTaskWorktreeSymlinks({
       projectRepoRoot: worktreeConfig.projectRepoRoot,
@@ -1600,6 +1711,10 @@ export function startDaemon(config = {}, deps = {}) {
     process.env.CONDUCTOR_WORKTREE_SYNC_TIMEOUT_MS,
     5_000,
   );
+  const WORKTREE_SUBMODULE_SYNC_TIMEOUT_MS = parsePositiveInt(
+    process.env.CONDUCTOR_WORKTREE_SUBMODULE_SYNC_TIMEOUT_MS,
+    120_000,
+  );
   const SHUTDOWN_STATUS_REPORT_TIMEOUT_MS = parsePositiveInt(
     process.env.CONDUCTOR_SHUTDOWN_STATUS_REPORT_TIMEOUT_MS,
     1000,
@@ -4337,6 +4452,7 @@ export function startDaemon(config = {}, deps = {}) {
       lastCommit: null,
       lastCommitAt: null,
       fileCount: null,
+      icon: null,
       error: null,
       errorCode: null,
       validatedAt,
@@ -4390,6 +4506,7 @@ export function startDaemon(config = {}, deps = {}) {
             typeof snapshot?.fileCount === "number" && Number.isInteger(snapshot.fileCount)
               ? snapshot.fileCount
               : null,
+          icon: readProjectIconSetting(effectiveWorkspace),
         };
       }
     } catch (error) {
@@ -4413,6 +4530,7 @@ export function startDaemon(config = {}, deps = {}) {
           last_commit_at: result.lastCommitAt,
           git_remote_url: result.gitRemoteUrl,
           file_count: result.fileCount,
+          icon: result.icon,
           error: result.error,
           error_code: result.errorCode,
           validated_at: result.validatedAt,
@@ -5055,7 +5173,8 @@ export function startDaemon(config = {}, deps = {}) {
       const isAllowedExternalBackend =
         !isBuiltInRuntimeBackend(effectiveBackend) &&
         await isRuntimeSupportedBackend(effectiveBackend, { configFilePath: config.CONFIG_FILE });
-      if (!isAdvertisedBackend || (!hasConfiguredEntry && !isAllowedExternalBackend)) {
+      const isCommandOptionalBuiltIn = isCommandOptionalBuiltInRuntimeBackend(effectiveBackend);
+      if (!isAdvertisedBackend || (!hasConfiguredEntry && !isAllowedExternalBackend && !isCommandOptionalBuiltIn)) {
         logError(`Unsupported backend: ${selectedBackend}. Supported: ${SUPPORTED_BACKENDS.join(", ")}`);
         sendAgentCommandAck({
           requestId,
@@ -5526,7 +5645,8 @@ export function startDaemon(config = {}, deps = {}) {
     const isAllowedExternalBackend =
       !isBuiltInRuntimeBackend(effectiveBackend) &&
       await isRuntimeSupportedBackend(effectiveBackend, { configFilePath: config.CONFIG_FILE });
-    if (!isAdvertisedBackend || (!hasConfiguredEntry && !isAllowedExternalBackend)) {
+    const isCommandOptionalBuiltIn = isCommandOptionalBuiltInRuntimeBackend(effectiveBackend);
+    if (!isAdvertisedBackend || (!hasConfiguredEntry && !isAllowedExternalBackend && !isCommandOptionalBuiltIn)) {
       reportRestartFailure({
         taskId: normalizedTargetTaskId,
         projectId: normalizedProjectId,