@love-moon/conductor-cli 0.2.11 → 0.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -16,8 +16,8 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@love-moon/tui-driver": "0.2.11",
-    "@love-moon/conductor-sdk": "0.2.11",
+    "@love-moon/tui-driver": "0.2.12",
+    "@love-moon/conductor-sdk": "0.2.12",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",

package/src/daemon.js

@@ -16,6 +16,11 @@ const __dirname = path.dirname(__filename);
 const CLI_PATH = path.resolve(__dirname, "..", "bin", "conductor-fire.js");
 const DAEMON_LOG_DIR = path.join(os.homedir(), ".conductor", "logs");
 const DAEMON_LOG_PATH = path.join(DAEMON_LOG_DIR, "conductor-daemon.log");
+const PLAN_LIMIT_MESSAGES = {
+  manual_fire_active_task: "Free plan limit reached: only 1 active fire task is allowed.",
+  app_active_task: "Free plan limit reached: only 1 active app task is allowed.",
+  daemon_active_connection: "Free plan limit reached: only 1 active daemon connection is allowed.",
+};
 
 function appendDaemonLog(line) {
   try {
@@ -57,6 +62,51 @@ function getUserConfig(configFilePath) {
   return {};
 }
 
+function normalizePlanLimitType(limitType) {
+  if (typeof limitType !== "string") {
+    return null;
+  }
+  const normalized = limitType.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  if (normalized === "free_daemon_connection" || normalized === "free-daemon-limit") {
+    return "daemon_active_connection";
+  }
+  return normalized;
+}
+
+function inferPlanLimitMessage(text) {
+  if (typeof text !== "string" || !text.trim()) {
+    return null;
+  }
+  const lower = text.trim().toLowerCase();
+  if (lower.includes("one active manual fire task")) {
+    return PLAN_LIMIT_MESSAGES.manual_fire_active_task;
+  }
+  if (lower.includes("one active app task")) {
+    return PLAN_LIMIT_MESSAGES.app_active_task;
+  }
+  if (lower.includes("one active daemon connection")) {
+    return PLAN_LIMIT_MESSAGES.daemon_active_connection;
+  }
+  if (lower.includes("free plan task limit reached")) {
+    return "Free plan task limit reached: only 1 active fire task and 1 active app task are allowed.";
+  }
+  return null;
+}
+
+function getPlanLimitMessage(payload) {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  const normalizedType = normalizePlanLimitType(payload.limit_type);
+  if (normalizedType && PLAN_LIMIT_MESSAGES[normalizedType]) {
+    return PLAN_LIMIT_MESSAGES[normalizedType];
+  }
+  return inferPlanLimitMessage(payload.message) || inferPlanLimitMessage(payload.error);
+}
+
 // Default CLI commands for supported backends
 const DEFAULT_CLI_LIST = {
   codex: "codex --dangerously-bypass-approvals-and-sandbox",
@@ -493,6 +543,22 @@ export function startDaemon(config = {}, deps = {}) {
   }
 
   function handleEvent(event) {
+    if (event.type === "error") {
+      const payload = event?.payload && typeof event.payload === "object" ? event.payload : {};
+      const planLimitMessage = getPlanLimitMessage(payload);
+      if (planLimitMessage) {
+        logError(planLimitMessage);
+        return;
+      }
+      const backendMessage = typeof payload.message === "string" ? payload.message.trim() : "";
+      if (backendMessage) {
+        logError(`Backend error: ${backendMessage}`);
+      } else {
+        logError("Backend returned an error event");
+      }
+      return;
+    }
+
     if (event.type === "create_task") {
       handleCreateTask(event.payload);
       return;

package/src/fire/history.js

@@ -125,6 +125,73 @@ export async function selectHistorySession(provider, options = {}) {
   return selected || null;
 }
 
+export async function findSessionPath(provider, sessionId, options = {}) {
+  const normalizedProvider = String(provider || "").trim().toLowerCase();
+  if (normalizedProvider === "codex") {
+    return findCodexSessionPath(sessionId, options);
+  }
+  if (normalizedProvider === "claude") {
+    return findClaudeSessionPath(sessionId, options);
+  }
+  if (normalizedProvider === "copilot") {
+    return findCopilotSessionPath(sessionId, options);
+  }
+  throw new Error(`Unsupported provider: ${provider}`);
+}
+
+export async function findCodexSessionPath(sessionId, options = {}) {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  if (!normalizedSessionId) {
+    return null;
+  }
+  const homeDir = resolveHomeDir(options);
+  const sessionsDir = options.codexSessionsDir || path.join(homeDir, ".codex", "sessions");
+  return findCodexSessionFile(sessionsDir, normalizedSessionId);
+}
+
+export async function findClaudeSessionPath(sessionId, options = {}) {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  if (!normalizedSessionId) {
+    return null;
+  }
+
+  const homeDir = resolveHomeDir(options);
+  const projectsDir = options.claudeProjectsDir || path.join(homeDir, ".claude", "projects");
+  const sessionEntries = await findClaudeSessionEntries(projectsDir, normalizedSessionId);
+  if (sessionEntries.length > 0) {
+    return sessionEntries[0]?.source || null;
+  }
+
+  const tasksDir = options.claudeTasksDir || path.join(homeDir, ".claude", "tasks");
+  const directTaskDir = path.join(tasksDir, normalizedSessionId);
+  if (await pathExists(directTaskDir, "directory")) {
+    return directTaskDir;
+  }
+
+  return null;
+}
+
+export async function findCopilotSessionPath(sessionId, options = {}) {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  if (!normalizedSessionId) {
+    return null;
+  }
+
+  const homeDir = resolveHomeDir(options);
+  const sessionStateDir = options.copilotSessionStateDir || path.join(homeDir, ".copilot", "session-state");
+  const directJsonlPath = path.join(sessionStateDir, `${normalizedSessionId}.jsonl`);
+  if (await pathExists(directJsonlPath, "file")) {
+    return directJsonlPath;
+  }
+
+  const directSessionDir = path.join(sessionStateDir, normalizedSessionId);
+  if (await pathExists(directSessionDir, "directory")) {
+    return directSessionDir;
+  }
+
+  return findPathByName(sessionStateDir, normalizedSessionId);
+}
+
 function resolveHomeDir(options) {
   if (options?.homeDir) {
     return options.homeDir;
@@ -132,6 +199,10 @@ function resolveHomeDir(options) {
   return os.homedir();
 }
 
+function normalizeSessionId(sessionId) {
+  return typeof sessionId === "string" ? sessionId.trim() : "";
+}
+
 function trimHistory(history, limit) {
   const max = Number.isFinite(limit) ? Math.max(1, limit) : DEFAULT_HISTORY_LIMIT;
   if (history.length <= max) {
@@ -473,6 +544,44 @@ async function findJsonlFiles(rootDir) {
   return files;
 }
 
+async function findPathByName(rootDir, sessionId) {
+  const queue = [rootDir];
+  while (queue.length) {
+    const current = queue.pop();
+    let entries = [];
+    try {
+      entries = await fsp.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.name.includes(sessionId)) {
+        return fullPath;
+      }
+      if (entry.isDirectory()) {
+        queue.push(fullPath);
+      }
+    }
+  }
+  return null;
+}
+
+async function pathExists(targetPath, expectedType) {
+  try {
+    const stats = await fsp.stat(targetPath);
+    if (expectedType === "file") {
+      return stats.isFile();
+    }
+    if (expectedType === "directory") {
+      return stats.isDirectory();
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function parseCodexSessionFile(filePath) {
   const fileStream = fs.createReadStream(filePath);
   const rl = readline.createInterface({