@love-moon/conductor-cli 0.2.15 → 0.2.17

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.15",
-  "gitCommitId": "e500981",
+  "version": "0.2.17",
+  "gitCommitId": "c2654e1",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -17,8 +17,8 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@love-moon/tui-driver": "0.2.15",
-    "@love-moon/conductor-sdk": "0.2.15",
+    "@love-moon/ai-sdk": "0.2.17",
+    "@love-moon/conductor-sdk": "0.2.17",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",
@@ -29,8 +29,8 @@
   },
   "pnpm": {
     "overrides": {
-      "@love-moon/tui-driver": "file:../modules/tui-driver",
-      "@love-moon/conductor-sdk": "file:../modules/sdk"
+      "@love-moon/ai-sdk": "file:../modules/ai-sdk",
+      "@love-moon/conductor-sdk": "file:../modules/conductor-sdk"
     }
   }
 }

package/src/daemon.js

@@ -8,6 +8,7 @@ import dotenv from "dotenv";
 import yaml from "js-yaml";
 
 import { ConductorWebSocketClient, ConductorConfig, loadConfig, ConfigFileNotFound } from "@love-moon/conductor-sdk";
+import { DaemonLogCollector } from "./log-collector.js";
 
 dotenv.config();
 
@@ -212,6 +213,7 @@ export function startDaemon(config = {}, deps = {}) {
   const createWebSocketClient =
     deps.createWebSocketClient ||
     ((clientConfig, options) => new ConductorWebSocketClient(clientConfig, options));
+  const createLogCollector = deps.createLogCollector || ((backendUrl) => new DaemonLogCollector(backendUrl));
   const PROJECT_PATH_LOOKUP_TIMEOUT_MS = parsePositiveInt(
     process.env.CONDUCTOR_PROJECT_PATH_LOOKUP_TIMEOUT_MS,
     1500,
@@ -364,6 +366,7 @@ export function startDaemon(config = {}, deps = {}) {
   const activeTaskProcesses = new Map();
   const suppressedExitStatusReports = new Set();
   const seenCommandRequestIds = new Set();
+  const logCollector = createLogCollector(BACKEND_HTTP);
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders: {
       "x-conductor-host": AGENT_NAME,
@@ -574,6 +577,59 @@ export function startDaemon(config = {}, deps = {}) {
     }
     if (event.type === "stop_task") {
       handleStopTask(event.payload);
+      return;
+    }
+    if (event.type === "collect_logs") {
+      void handleCollectLogs(event.payload);
+    }
+  }
+
+  async function handleCollectLogs(payload) {
+    const requestId = payload?.request_id ? String(payload.request_id).trim() : "";
+    const taskId = payload?.task_id ? String(payload.task_id).trim() : "";
+    const collectedAt = new Date().toISOString();
+
+    if (!requestId || !taskId) {
+      logError(`Invalid collect_logs payload: ${JSON.stringify(payload)}`);
+      return;
+    }
+
+    let result;
+    try {
+      result = await Promise.resolve(
+        logCollector.collect(taskId, {
+          tailLines: payload?.options?.tail_lines,
+          since: payload?.options?.since,
+        }),
+      );
+    } catch (error) {
+      result = {
+        projectPath: null,
+        logPath: null,
+        entries: [],
+        truncated: false,
+        error: `Failed to read log file: ${error?.message || error}`,
+        collectedAt,
+      };
+    }
+
+    try {
+      await client.sendJson({
+        type: "agent_log_collected",
+        payload: {
+          request_id: requestId,
+          task_id: taskId,
+          daemon_host: AGENT_NAME,
+          project_path: result.projectPath,
+          log_path: result.logPath,
+          logs: result.entries,
+          truncated: Boolean(result.truncated),
+          error: result.error,
+          collected_at: result.collectedAt || collectedAt,
+        },
+      });
+    } catch (error) {
+      logError(`Failed to report agent_log_collected for ${taskId}: ${error?.message || error}`);
     }
   }
 

package/src/fire/resume.js

@@ -0,0 +1,420 @@
+import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+
+import yaml from "js-yaml";
+
+function normalizeBackend(backend) {
+  return String(backend || "").trim().toLowerCase();
+}
+
+function resolveHomeDir(options) {
+  if (options?.homeDir) {
+    return options.homeDir;
+  }
+  return os.homedir();
+}
+
+function normalizeSessionId(sessionId) {
+  return typeof sessionId === "string" ? sessionId.trim() : "";
+}
+
+export function buildResumeArgsForBackend(backend, sessionId) {
+  const resumeSessionId = normalizeSessionId(sessionId);
+  if (!resumeSessionId) {
+    return [];
+  }
+  const normalizedBackend = normalizeBackend(backend);
+  if (normalizedBackend === "codex" || normalizedBackend === "code") {
+    return ["resume", resumeSessionId];
+  }
+  if (normalizedBackend === "claude" || normalizedBackend === "claude-code") {
+    return ["--resume", resumeSessionId];
+  }
+  if (normalizedBackend === "copilot") {
+    return [`--resume=${resumeSessionId}`];
+  }
+  throw new Error(`--resume is not supported for backend "${backend}"`);
+}
+
+export function resumeProviderForBackend(backend) {
+  const normalizedBackend = normalizeBackend(backend);
+  if (normalizedBackend === "codex" || normalizedBackend === "code") {
+    return "codex";
+  }
+  if (normalizedBackend === "claude" || normalizedBackend === "claude-code") {
+    return "claude";
+  }
+  if (normalizedBackend === "copilot") {
+    return "copilot";
+  }
+  return 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);
+}
+
+export async function resolveSessionRunDirectory(sessionPath) {
+  const normalizedPath = typeof sessionPath === "string" ? sessionPath.trim() : "";
+  if (!normalizedPath) {
+    throw new Error("Invalid session path");
+  }
+  let stats;
+  try {
+    stats = await fsp.stat(normalizedPath);
+  } catch {
+    throw new Error(`Session path does not exist: ${normalizedPath}`);
+  }
+  return stats.isDirectory() ? normalizedPath : path.dirname(normalizedPath);
+}
+
+export async function inspectResumeTarget(backend, sessionId, options = {}) {
+  return resolveResumeContext(backend, sessionId, options);
+}
+
+export async function resolveResumeContext(backend, sessionId, options = {}) {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  if (!normalizedSessionId) {
+    throw new Error("--resume requires a session id");
+  }
+  const provider = resumeProviderForBackend(backend);
+  if (!provider) {
+    throw new Error(`--resume is not supported for backend "${backend}"`);
+  }
+
+  const sessionPath = await findSessionPath(provider, normalizedSessionId, options);
+  if (!sessionPath) {
+    throw new Error(`Invalid --resume session id for ${provider}: ${normalizedSessionId}`);
+  }
+
+  const cwdFromSession = await extractResumeCwdFromSession(provider, sessionPath, normalizedSessionId);
+  const fallbackCwd = await resolveSessionRunDirectory(sessionPath);
+  const cwd = cwdFromSession || fallbackCwd;
+  if (!(await isExistingDirectory(cwd))) {
+    throw new Error(`Resume workspace path does not exist: ${cwd}`);
+  }
+
+  return {
+    provider,
+    sessionId: normalizedSessionId,
+    sessionPath,
+    cwd,
+    debugMetadata: {
+      cwdSource: cwdFromSession ? "session" : "session_path",
+      sessionPath,
+    },
+  };
+}
+
+async function isExistingDirectory(targetPath) {
+  const normalizedPath = typeof targetPath === "string" ? targetPath.trim() : "";
+  if (!normalizedPath) {
+    return false;
+  }
+  try {
+    const stats = await fsp.stat(normalizedPath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function extractCodexResumeCwd(sessionPath) {
+  if (!sessionPath.endsWith(".jsonl")) {
+    return null;
+  }
+  const rl = readline.createInterface({
+    input: fs.createReadStream(sessionPath),
+    crlfDelay: Infinity,
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const maybeCwd = entry?.type === "session_meta" ? entry?.payload?.cwd : null;
+    if (typeof maybeCwd === "string" && maybeCwd.trim()) {
+      return maybeCwd.trim();
+    }
+  }
+  return null;
+}
+
+async function extractClaudeResumeCwd(sessionPath, sessionId) {
+  if (!sessionPath.endsWith(".jsonl")) {
+    return null;
+  }
+  const rl = readline.createInterface({
+    input: fs.createReadStream(sessionPath),
+    crlfDelay: Infinity,
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const idMatches = String(entry?.sessionId || "").trim() === sessionId;
+    const maybeCwd = entry?.cwd;
+    if (idMatches && typeof maybeCwd === "string" && maybeCwd.trim()) {
+      return maybeCwd.trim();
+    }
+  }
+  return null;
+}
+
+async function extractCopilotResumeCwd(sessionPath) {
+  let stats;
+  try {
+    stats = await fsp.stat(sessionPath);
+  } catch {
+    return null;
+  }
+
+  if (stats.isDirectory()) {
+    const workspaceYamlPath = path.join(sessionPath, "workspace.yaml");
+    try {
+      const yamlContent = await fsp.readFile(workspaceYamlPath, "utf8");
+      const parsed = yaml.load(yamlContent);
+      const maybeCwd = parsed && typeof parsed === "object" ? parsed.cwd : null;
+      if (typeof maybeCwd === "string" && maybeCwd.trim()) {
+        return maybeCwd.trim();
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+
+  if (!sessionPath.endsWith(".jsonl")) {
+    return null;
+  }
+
+  const rl = readline.createInterface({
+    input: fs.createReadStream(sessionPath),
+    crlfDelay: Infinity,
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const maybeCwd = entry?.data?.context?.cwd || entry?.data?.cwd;
+    if (typeof maybeCwd === "string" && maybeCwd.trim()) {
+      return maybeCwd.trim();
+    }
+  }
+  return null;
+}
+
+async function extractResumeCwdFromSession(provider, sessionPath, sessionId) {
+  if (provider === "codex") {
+    return extractCodexResumeCwd(sessionPath);
+  }
+  if (provider === "claude") {
+    return extractClaudeResumeCwd(sessionPath, sessionId);
+  }
+  if (provider === "copilot") {
+    return extractCopilotResumeCwd(sessionPath);
+  }
+  return null;
+}
+
+async function findCodexSessionFile(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.isDirectory()) {
+        queue.push(fullPath);
+      } else if (entry.isFile() && entry.name.includes(sessionId) && entry.name.endsWith(".jsonl")) {
+        return fullPath;
+      }
+    }
+  }
+  return null;
+}
+
+async function findClaudeSessionEntries(projectsDir, sessionId) {
+  const entries = [];
+  let projectDirs = [];
+  try {
+    projectDirs = await fsp.readdir(projectsDir, { withFileTypes: true });
+  } catch {
+    return entries;
+  }
+
+  for (const projectDir of projectDirs) {
+    if (!projectDir.isDirectory()) {
+      continue;
+    }
+    const projectPath = path.join(projectsDir, projectDir.name);
+    let files = [];
+    try {
+      files = await fsp.readdir(projectPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const file of files) {
+      if (!file.isFile()) {
+        continue;
+      }
+      if (!file.name.endsWith(".jsonl") || file.name.startsWith("agent-")) {
+        continue;
+      }
+
+      const filePath = path.join(projectPath, file.name);
+      const rl = readline.createInterface({
+        input: fs.createReadStream(filePath),
+        crlfDelay: Infinity,
+      });
+
+      for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+          continue;
+        }
+        let entry;
+        try {
+          entry = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        if (entry.sessionId === sessionId) {
+          entries.push({ ...entry, source: filePath });
+        }
+      }
+    }
+  }
+
+  return entries;
+}
+
+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;
+  }
+}

package/src/log-collector.js

@@ -0,0 +1,181 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { SessionDiskStore } from "@love-moon/conductor-sdk";
+
+const DEFAULT_TAIL_LINES = 200;
+const MAX_TAIL_LINES = 500;
+const DEFAULT_TAIL_BYTES = 256 * 1024;
+const MAX_TAIL_BYTES = 1024 * 1024;
+
+function clampPositiveInt(value, fallback, max) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return Math.min(parsed, max);
+}
+
+function normalizeSince(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+function inferLevel(message) {
+  const normalized = String(message || "").toLowerCase();
+  if (normalized.includes("error") || normalized.includes("failed")) {
+    return "ERROR";
+  }
+  if (normalized.includes("warn")) {
+    return "WARN";
+  }
+  return "INFO";
+}
+
+function parseLogLine(line) {
+  const content = String(line || "").trim();
+  if (!content) {
+    return null;
+  }
+
+  const rfcMatch = content.match(/^\[([^\]]+)\]\s+\[([A-Z]+)\]\s+(.*)$/);
+  if (rfcMatch) {
+    const timestamp = Date.parse(rfcMatch[1]);
+    if (Number.isFinite(timestamp)) {
+      return {
+        timestamp: new Date(timestamp).toISOString(),
+        level: rfcMatch[2],
+        message: rfcMatch[3],
+      };
+    }
+  }
+
+  const conductorMatch = content.match(/^\[([^\]]+?)\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})\]\s+(.*)$/);
+  if (conductorMatch) {
+    const timestamp = Date.parse(conductorMatch[2]);
+    if (Number.isFinite(timestamp)) {
+      return {
+        timestamp: new Date(timestamp).toISOString(),
+        level: inferLevel(conductorMatch[3]),
+        message: `[${conductorMatch[1]}] ${conductorMatch[3]}`,
+      };
+    }
+  }
+
+  return {
+    timestamp: null,
+    level: inferLevel(content),
+    message: content,
+  };
+}
+
+function readTailText(filePath, maxBytes) {
+  const stats = fs.statSync(filePath);
+  const bytesToRead = Math.min(stats.size, maxBytes);
+  const start = Math.max(0, stats.size - bytesToRead);
+  const buffer = Buffer.alloc(bytesToRead);
+  const fd = fs.openSync(filePath, "r");
+  try {
+    fs.readSync(fd, buffer, 0, bytesToRead, start);
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  let text = buffer.toString("utf8");
+  if (start > 0) {
+    const firstNewline = text.indexOf("\n");
+    text = firstNewline >= 0 ? text.slice(firstNewline + 1) : "";
+  }
+  return {
+    text,
+    truncatedByBytes: start > 0,
+  };
+}
+
+export class DaemonLogCollector {
+  constructor(backendUrl, options = {}) {
+    this.sessionStore = options.sessionStore || SessionDiskStore.forBackendUrl(backendUrl);
+    this.readTailText = options.readTailText || readTailText;
+    this.existsSync = options.existsSync || fs.existsSync;
+  }
+
+  collect(taskId, options = {}) {
+    const normalizedTaskId = String(taskId || "").trim();
+    const collectedAt = new Date().toISOString();
+    if (!normalizedTaskId) {
+      return {
+        projectPath: null,
+        logPath: null,
+        entries: [],
+        truncated: false,
+        error: "task_id is required",
+        collectedAt,
+      };
+    }
+
+    const record = this.sessionStore.findByTaskId(normalizedTaskId);
+    if (!record) {
+      return {
+        projectPath: null,
+        logPath: null,
+        entries: [],
+        truncated: false,
+        error: "Task not found in session store",
+        collectedAt,
+      };
+    }
+
+    const projectPath = path.resolve(record.projectPath);
+    const logPath = path.join(projectPath, "conductor.log");
+    if (!this.existsSync(logPath)) {
+      return {
+        projectPath,
+        logPath,
+        entries: [],
+        truncated: false,
+        error: "Log file not found",
+        collectedAt,
+      };
+    }
+
+    const tailLines = clampPositiveInt(options.tailLines, DEFAULT_TAIL_LINES, MAX_TAIL_LINES);
+    const maxBytes = clampPositiveInt(options.maxBytes, DEFAULT_TAIL_BYTES, MAX_TAIL_BYTES);
+    const sinceMs = normalizeSince(options.since);
+    const { text, truncatedByBytes } = this.readTailText(logPath, maxBytes);
+    let anchorTimestampMs = null;
+    const allEntries = [];
+    for (const line of text.split(/\r?\n/)) {
+      const entry = parseLogLine(line);
+      if (!entry) {
+        continue;
+      }
+      const entryTimestampMs =
+        typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : anchorTimestampMs;
+      if (typeof entry.timestamp === "string" && Number.isFinite(entryTimestampMs)) {
+        anchorTimestampMs = entryTimestampMs;
+      }
+      if (sinceMs !== null) {
+        if (!Number.isFinite(entryTimestampMs)) {
+          continue;
+        }
+        if (entryTimestampMs < sinceMs) {
+          continue;
+        }
+      }
+      allEntries.push(entry);
+    }
+    const entries = allEntries.slice(-tailLines);
+
+    return {
+      projectPath,
+      logPath,
+      entries,
+      truncated: truncatedByBytes || allEntries.length > entries.length,
+      error: null,
+      collectedAt,
+    };
+  }
+}