@love-moon/conductor-cli 0.2.16 → 0.2.18

package/bin/conductor-config.js

@@ -25,11 +25,11 @@ const DEFAULT_CLIs = {
     execArgs: "exec --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check",
     description: "OpenAI Codex CLI"
   },
-  copilot: {
-    command: "copilot",
-    execArgs: "--allow-all-paths --allow-all-tools",
-    description: "GitHub Copilot CLI"
-  },
+  // copilot: {
+  //   command: "copilot",
+  //   execArgs: "--allow-all-paths --allow-all-tools",
+  //   description: "GitHub Copilot CLI"
+  // },
   // gemini: {
   //   command: "gemini",
   //   execArgs: "",
@@ -282,15 +282,15 @@ function checkAlternativeInstallations(command) {
     );
   }
   
-  // 特殊检查：Copilot CLI 可能是 gh copilot 扩展
-  if (command === "copilot" || command === "copilot-chat") {
-    try {
-      execSync("gh copilot --help", { stdio: "pipe", timeout: 5000 });
-      return true;
-    } catch {
-      // gh copilot 未安装
-    }
-  }
+  // // 特殊检查：Copilot CLI 可能是 gh copilot 扩展
+  // if (command === "copilot" || command === "copilot-chat") {
+  //   try {
+  //     execSync("gh copilot --help", { stdio: "pipe", timeout: 5000 });
+  //     return true;
+  //   } catch {
+  //     // gh copilot 未安装
+  //   }
+  // }
   
   // 检查文件是否存在
   for (const checkPath of commonPaths) {

package/bin/conductor-fire.js

@@ -32,6 +32,7 @@ const __dirname = path.dirname(__filename);
 const PKG_ROOT = path.join(__dirname, "..");
 const INITIAL_CLI_PROJECT_PATH = process.cwd();
 const FIRE_LOG_PATH = path.join(INITIAL_CLI_PROJECT_PATH, "conductor.log");
+const FIRE_TASK_MARKER_PREFIX = "active-fire";
 const ENABLE_FIRE_LOCAL_LOG = !process.env.CONDUCTOR_CLI_COMMAND;
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
@@ -303,6 +304,13 @@ async function main() {
       backend: cliArgs.backend,
       daemonName: configuredDaemonName,
     });
+    injectResolvedTaskId(taskContext.taskId);
+    injectResolvedTaskId(taskContext.taskId, env);
+    try {
+      writeFireTaskMarker(taskContext.taskId, runtimeProjectPath);
+    } catch (error) {
+      log(`Note: Could not persist local task marker: ${error.message}`);
+    }
 
     log(
       `Attached to Conductor task ${taskContext.taskId}${
@@ -711,6 +719,73 @@ export function resolveRequestedTaskTitle({
   return resolveTaskTitle(explicit, runtimeProjectPath);
 }
 
+function normalizeTaskId(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim();
+}
+
+function resolveFireStateDir(workingDirectory = process.cwd()) {
+  const baseDir =
+    typeof workingDirectory === "string" && workingDirectory.trim()
+      ? path.resolve(workingDirectory.trim())
+      : process.cwd();
+  return path.join(baseDir, ".conductor", "state");
+}
+
+export function injectResolvedTaskId(taskId, env = process.env) {
+  const normalizedTaskId = normalizeTaskId(taskId);
+  if (!normalizedTaskId) {
+    return "";
+  }
+  env.CONDUCTOR_TASK_ID = normalizedTaskId;
+  return normalizedTaskId;
+}
+
+export function writeFireTaskMarker(taskId, workingDirectory = process.cwd()) {
+  const normalizedTaskId = normalizeTaskId(taskId);
+  if (!normalizedTaskId) {
+    return "";
+  }
+
+  const stateDir = resolveFireStateDir(workingDirectory);
+  const markerFileName = `${FIRE_TASK_MARKER_PREFIX}.task_${normalizedTaskId}.json`;
+  const markerPath = path.join(stateDir, markerFileName);
+
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(
+    markerPath,
+    `${JSON.stringify(
+      {
+        source: "conductor-fire",
+        taskId: normalizedTaskId,
+        cwd: path.resolve(workingDirectory),
+        updatedAt: new Date().toISOString(),
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+
+  for (const entry of fs.readdirSync(stateDir)) {
+    if (entry === markerFileName) {
+      continue;
+    }
+    if (!entry.startsWith(`${FIRE_TASK_MARKER_PREFIX}.task_`) || !entry.endsWith(".json")) {
+      continue;
+    }
+    try {
+      fs.unlinkSync(path.join(stateDir, entry));
+    } catch {
+      // ignore stale marker cleanup failures
+    }
+  }
+
+  return markerPath;
+}
+
 function normalizeArray(value) {
   if (!value) {
     return [];
@@ -992,6 +1067,7 @@ export class BridgeRunner {
     this.needsReconnectRecovery = false;
     this.remoteStopInfo = null;
     this.sessionAnnouncementSent = false;
+    this.boundSessionId = "";
     this.errorLoop = null;
     this.errorLoopWindowMs = getBoundedEnvInt(
       "CONDUCTOR_ERROR_LOOP_WINDOW_MS",
@@ -1058,16 +1134,11 @@ export class BridgeRunner {
     const message = hasRealSessionId
       ? `${this.backendName} session started: ${sessionId}`
       : `${this.backendName} session started`;
-    if (hasRealSessionId && typeof this.conductor?.bindTaskSession === "function") {
-      try {
-        await this.conductor.bindTaskSession(this.taskId, {
-          session_id: sessionId,
-          session_file_path: sessionFilePath || undefined,
-          backend_type: this.backendName,
-        });
-      } catch (error) {
-        log(`Failed to persist task session binding for ${this.taskId}: ${error?.message || error}`);
-      }
+    if (hasRealSessionId) {
+      await this.persistTaskSessionBinding({
+        sessionId,
+        sessionFilePath,
+      });
     }
     try {
       await this.conductor.sendMessage(this.taskId, message, {
@@ -1101,6 +1172,51 @@ export class BridgeRunner {
     }
   }
 
+  async persistTaskSessionBinding({ sessionId, sessionFilePath } = {}) {
+    const normalizedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
+    if (!normalizedSessionId || normalizedSessionId === this.boundSessionId) {
+      return false;
+    }
+    if (typeof this.conductor?.bindTaskSession !== "function") {
+      return false;
+    }
+    try {
+      await this.conductor.bindTaskSession(this.taskId, {
+        session_id: normalizedSessionId,
+        session_file_path:
+          typeof sessionFilePath === "string" && sessionFilePath.trim() ? sessionFilePath.trim() : undefined,
+        backend_type: this.backendName,
+      });
+      this.boundSessionId = normalizedSessionId;
+      return true;
+    } catch (error) {
+      log(`Failed to persist task session binding for ${this.taskId}: ${error?.message || error}`);
+      return false;
+    }
+  }
+
+  async syncBackendSessionBinding() {
+    if (!this.backendSession) {
+      return false;
+    }
+    let sessionInfo = null;
+    try {
+      if (typeof this.backendSession.getSessionInfo === "function") {
+        sessionInfo = this.backendSession.getSessionInfo();
+      }
+      if (!sessionInfo && typeof this.backendSession.ensureSessionInfo === "function") {
+        sessionInfo = await this.backendSession.ensureSessionInfo();
+      }
+    } catch (error) {
+      this.copilotLog(`session binding sync skipped: ${sanitizeForLog(error?.message || error, 160)}`);
+      return false;
+    }
+    return this.persistTaskSessionBinding({
+      sessionId: sessionInfo?.sessionId,
+      sessionFilePath: sessionInfo?.sessionFilePath,
+    });
+  }
+
   async start(abortSignal) {
     abortSignal?.addEventListener("abort", () => {
       this.stopped = true;
@@ -1505,6 +1621,11 @@ export class BridgeRunner {
       return;
     }
 
+    await this.persistTaskSessionBinding({
+      sessionId,
+      sessionFilePath,
+    });
+
     logBackendReply(this.backendName, normalizedText, {
       usage: null,
       replyTo: replyTo || "latest",
@@ -1748,6 +1869,7 @@ export class BridgeRunner {
           cli_args: this.cliArgs,
         });
       }
+      await this.syncBackendSessionBinding();
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
@@ -1877,6 +1999,7 @@ export class BridgeRunner {
       } else {
         this.copilotLog("synthetic session_file turn settled");
       }
+      await this.syncBackendSessionBinding();
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {

package/bin/conductor-send-file.js

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+import { ConductorConfig, loadConfig } from "@love-moon/conductor-sdk";
+
+const DEFAULT_MIME_TYPE = "application/octet-stream";
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".conductor", "config.yaml");
+const FIRE_TASK_MARKER_PREFIX = "active-fire";
+
+const EXTENSION_TO_MIME = {
+  ".gif": "image/gif",
+  ".heic": "image/heic",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+};
+
+const isMainModule = (() => {
+  const currentFile = fileURLToPath(import.meta.url);
+  const entryFile = process.argv[1] ? path.resolve(process.argv[1]) : "";
+  return entryFile === currentFile;
+})();
+
+function walkUpDirectories(startDir) {
+  const visited = [];
+  let currentDir = path.resolve(startDir);
+  while (true) {
+    visited.push(currentDir);
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return visited;
+}
+
+function normalizeTaskId(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim();
+}
+
+function pickLatestTaskIdFromStateDir(stateDir) {
+  if (!fs.existsSync(stateDir)) {
+    return "";
+  }
+
+  const matches = [];
+  for (const entry of fs.readdirSync(stateDir)) {
+    const match = entry.match(new RegExp(`^${FIRE_TASK_MARKER_PREFIX}\\.task_([0-9a-f-]+)\\.json$`, "i"));
+    if (!match) {
+      continue;
+    }
+    const filePath = path.join(stateDir, entry);
+    let mtimeMs = 0;
+    try {
+      mtimeMs = fs.statSync(filePath).mtimeMs;
+    } catch {
+      continue;
+    }
+    matches.push({ taskId: match[1], mtimeMs });
+  }
+
+  if (matches.length === 0) {
+    return "";
+  }
+
+  matches.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  return matches[0].taskId;
+}
+
+export function detectTaskId(options = {}) {
+  const env = options.env || process.env;
+  const cwd = options.cwd || process.cwd();
+
+  const envTaskId = normalizeTaskId(env.CONDUCTOR_TASK_ID);
+  if (envTaskId) {
+    return envTaskId;
+  }
+
+  for (const directory of walkUpDirectories(cwd)) {
+    const stateTaskId = pickLatestTaskIdFromStateDir(path.join(directory, ".conductor", "state"));
+    if (stateTaskId) {
+      return stateTaskId;
+    }
+  }
+
+  return "";
+}
+
+function loadCliConfig(configFile, env = process.env) {
+  const configPath = configFile ? path.resolve(configFile) : DEFAULT_CONFIG_PATH;
+  if (fs.existsSync(configPath)) {
+    return loadConfig(configPath, { env });
+  }
+
+  const agentToken = typeof env.CONDUCTOR_AGENT_TOKEN === "string" ? env.CONDUCTOR_AGENT_TOKEN.trim() : "";
+  const backendUrl = typeof env.CONDUCTOR_BACKEND_URL === "string" ? env.CONDUCTOR_BACKEND_URL.trim() : "";
+  if (agentToken && backendUrl) {
+    return new ConductorConfig({
+      agentToken,
+      backendUrl,
+    });
+  }
+
+  return loadConfig(configPath, { env });
+}
+
+export function guessMimeType(fileName, preferredMimeType = "") {
+  const preferred = typeof preferredMimeType === "string" ? preferredMimeType.trim() : "";
+  if (preferred) {
+    return preferred;
+  }
+  const extension = path.extname(fileName).toLowerCase();
+  return EXTENSION_TO_MIME[extension] || DEFAULT_MIME_TYPE;
+}
+
+function formatErrorBody(text) {
+  const normalized = text.trim();
+  if (!normalized) {
+    return "";
+  }
+  try {
+    const parsed = JSON.parse(normalized);
+    if (parsed && typeof parsed === "object" && typeof parsed.error === "string") {
+      return parsed.error;
+    }
+  } catch {
+    // ignore parse failures
+  }
+  return normalized;
+}
+
+export async function sendFileToTask(options) {
+  const env = options.env || process.env;
+  const cwd = options.cwd || process.cwd();
+  const fetchImpl = options.fetchImpl || global.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error("fetch is not available");
+  }
+
+  const taskId = normalizeTaskId(options.taskId) || detectTaskId({ env, cwd });
+  if (!taskId) {
+    throw new Error("Unable to resolve task ID. Pass --task-id or run inside an active Conductor fire workspace.");
+  }
+
+  const config = loadCliConfig(options.configFile, env);
+  const filePath = path.resolve(cwd, String(options.filePath || ""));
+  const stats = await fsp.stat(filePath).catch(() => null);
+  if (!stats || !stats.isFile()) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const fileBuffer = await fsp.readFile(filePath);
+  const fileName =
+    typeof options.name === "string" && options.name.trim()
+      ? path.basename(options.name.trim())
+      : path.basename(filePath);
+  const mimeType = guessMimeType(fileName, options.mimeType);
+  const body = new FormData();
+  body.set("file", new Blob([fileBuffer], { type: mimeType }), fileName);
+
+  const content = typeof options.content === "string" ? options.content.trim() : "";
+  if (content) {
+    body.set("content", content);
+  }
+
+  const role = typeof options.role === "string" && options.role.trim()
+    ? options.role.trim().toLowerCase()
+    : "sdk";
+  body.set("role", role);
+
+  const url = new URL(`/api/tasks/${encodeURIComponent(taskId)}/attachments`, config.backendUrl);
+  const response = await fetchImpl(String(url), {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.agentToken}`,
+      Accept: "application/json",
+    },
+    body,
+  });
+
+  const rawText = await response.text();
+  if (!response.ok) {
+    const details = formatErrorBody(rawText);
+    throw new Error(`Upload failed (${response.status})${details ? `: ${details}` : ""}`);
+  }
+
+  return {
+    taskId,
+    response: rawText ? JSON.parse(rawText) : {},
+  };
+}
+
+export async function main(argvInput = hideBin(process.argv)) {
+  await yargs(argvInput)
+    .scriptName("conductor send-file")
+    .command(
+      "$0 <file>",
+      "Upload a local file into the task session",
+      (command) => command
+        .positional("file", {
+          describe: "Path to the local file to upload into the task session",
+          type: "string",
+          demandOption: true,
+        })
+        .option("task-id", {
+          type: "string",
+          describe: "Explicit Conductor task ID. Defaults to auto-detecting the current task.",
+        })
+        .option("config-file", {
+          type: "string",
+          describe: "Path to Conductor config file",
+        })
+        .option("content", {
+          alias: "m",
+          type: "string",
+          describe: "Optional message text to accompany the uploaded file",
+        })
+        .option("role", {
+          choices: ["sdk", "assistant", "user"],
+          default: "sdk",
+          describe: "Message role to write into the task session",
+        })
+        .option("mime-type", {
+          type: "string",
+          describe: "Override MIME type detection",
+        })
+        .option("name", {
+          type: "string",
+          describe: "Override the filename shown in Conductor",
+        })
+        .option("json", {
+          type: "boolean",
+          default: false,
+          describe: "Print the raw JSON response",
+        }),
+      async (argv) => {
+        const result = await sendFileToTask({
+          filePath: argv.file,
+          taskId: argv.taskId,
+          configFile: argv.configFile,
+          content: argv.content,
+          role: argv.role,
+          mimeType: argv.mimeType,
+          name: argv.name,
+        });
+
+        if (argv.json) {
+          process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+          return;
+        }
+
+        const attachments = Array.isArray(result.response?.attachments) ? result.response.attachments : [];
+        const attachmentNames = attachments.map((attachment) => attachment?.name).filter(Boolean);
+        const summary = attachmentNames.length > 0 ? attachmentNames.join(", ") : path.basename(String(argv.file));
+        process.stdout.write(`Uploaded ${summary} to task ${result.taskId}\n`);
+      },
+    )
+    .help()
+    .strict()
+    .parse();
+}
+
+if (isMainModule) {
+  main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  });
+}

package/bin/conductor.js

@@ -9,6 +9,7 @@
  *   config   - Interactive configuration setup
  *   update   - Update the CLI to the latest version
  *   diagnose - Diagnose a task in production/backend
+ *   send-file - Upload a local file into a task session
  */
 
 import { fileURLToPath } from "node:url";
@@ -45,7 +46,7 @@ if (argv[0] === "--version" || argv[0] === "-v") {
 const subcommand = argv[0];
 
 // Valid subcommands
-const validSubcommands = ["fire", "daemon", "config", "update", "diagnose"];
+const validSubcommands = ["fire", "daemon", "config", "update", "diagnose", "send-file"];
 
 if (!validSubcommands.includes(subcommand)) {
   console.error(`Error: Unknown subcommand '${subcommand}'`);
@@ -88,6 +89,7 @@ Subcommands:
   config    Interactive configuration setup
   update    Update the CLI to the latest version
   diagnose  Diagnose a task and print likely root cause
+  send-file Upload a local file into a task session
 
 Options:
   -h, --help     Show this help message
@@ -98,6 +100,7 @@ Examples:
   conductor fire --backend claude -- "add feature"
   conductor daemon --config-file ~/.conductor/config.yaml
   conductor diagnose <task-id>
+  conductor send-file ./screenshot.png
   conductor config
   conductor update
 
@@ -107,6 +110,7 @@ For subcommand-specific help:
   conductor config --help
   conductor update --help
   conductor diagnose --help
+  conductor send-file --help
 
 Version: ${pkgJson.version}
 `);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.16",
-  "gitCommitId": "13b4d6c",
+  "version": "0.2.18",
+  "gitCommitId": "942418b",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -14,11 +14,11 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node --test"
+    "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.2.16",
-    "@love-moon/conductor-sdk": "0.2.16",
+    "@love-moon/ai-sdk": "0.2.18",
+    "@love-moon/conductor-sdk": "0.2.18",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",