@love-moon/conductor-cli 0.2.41 → 0.3.0

package/bin/conductor-fire.js

@@ -848,6 +848,10 @@ async function main() {
     let nextInitialPrompt =
       taskContext.shouldProcessInitialPrompt ? cliArgs.initialPrompt : "";
     let pendingRefreshSessionRequest = null;
+    // Only the first iteration should deliver the configured pre_prompt; any
+    // subsequent refresh-session rebuild must skip it so users don't see the
+    // pre_prompt bubble duplicated.
+    let nextShouldProcessPrePrompt = Boolean(taskContext.shouldProcessPrePrompt);
 
     const sessionCommandLine = resolveAiSessionCommandLine(
       cliArgs.backend,
@@ -930,7 +934,6 @@ async function main() {
           ...(cliArgs.sessionOptions || {}),
           ...(sessionCommandLine ? { commandLine: sessionCommandLine } : {}),
           logger: { log },
-          ...(resolvedPrePrompt ? { prePrompt: resolvedPrePrompt } : {}),
           sessionStoreKey: taskContext.taskId ? `task-${taskContext.taskId}` : undefined,
           resumePersistedSession: Boolean(!nextResumeSessionId && taskContext.taskId),
         });
@@ -947,6 +950,8 @@ async function main() {
           backendName: cliArgs.backend,
           resumeSessionId: nextResumeSessionId,
           daemonName: resolvedDaemonName,
+          prePrompt: resolvedPrePrompt || "",
+          shouldProcessPrePrompt: Boolean(resolvedPrePrompt) && nextShouldProcessPrePrompt,
         });
         reconnectRunner = runner;
         if (pendingRemoteStopEvent) {
@@ -993,6 +998,7 @@ async function main() {
           if (refreshedSessionId) {
             nextResumeSessionId = refreshedSessionId;
             nextInitialPrompt = "";
+            nextShouldProcessPrePrompt = false;
             pendingRefreshSessionRequest = refreshSessionRequest;
             continue;
           }
@@ -1460,13 +1466,34 @@ function buildEnv() {
   return env;
 }
 
-async function ensureTaskContext(conductor, opts) {
-  if (opts.providedTaskId) {
+function isBackendNotFoundError(error) {
+  return Boolean(error && typeof error === "object" && Number(error.statusCode) === 404);
+}
+
+export async function ensureTaskContext(conductor, opts) {
+  const providedTaskId =
+    typeof opts.providedTaskId === "string" ? opts.providedTaskId.trim() : "";
+  if (providedTaskId) {
+    if (typeof conductor.getTask === "function") {
+      try {
+        await conductor.getTask(providedTaskId);
+      } catch (error) {
+        if (isBackendNotFoundError(error)) {
+          throw new Error(
+            `CONDUCTOR_TASK_ID points to missing task ${providedTaskId}; unset CONDUCTOR_TASK_ID or use an existing task id`,
+          );
+        }
+        throw error;
+      }
+    }
     return {
-      taskId: opts.providedTaskId,
+      taskId: providedTaskId,
       appUrl: null,
       shouldProcessInitialPrompt: Boolean(opts.initialPrompt),
       initialPromptDelivery: opts.initialPrompt ? "synthetic" : "none",
+      // Daemon provided the task id, so this fire process is the first attach
+      // for that task — it should inject the configured pre_prompt once.
+      shouldProcessPrePrompt: true,
     };
   }
 
@@ -1493,6 +1520,9 @@ async function ensureTaskContext(conductor, opts) {
     appUrl: session.app_url || null,
     shouldProcessInitialPrompt: Boolean(opts.initialPrompt),
     initialPromptDelivery: opts.initialPrompt ? "queued" : "none",
+    // Newly created task — pre_prompt should run exactly once right after
+    // the backend session is announced, before any real user message.
+    shouldProcessPrePrompt: true,
   };
 }
 
@@ -1789,6 +1819,8 @@ export class BridgeRunner {
     backendName,
     resumeSessionId,
     daemonName,
+    prePrompt,
+    shouldProcessPrePrompt,
   }) {
     this.backendSession = backendSession;
     this.conductor = conductor;
@@ -1818,6 +1850,9 @@ export class BridgeRunner {
       this.initialPromptDelivery === "queued" && typeof initialPrompt === "string" && initialPrompt.trim()
         ? initialPrompt.trim()
         : "";
+    this.prePrompt =
+      typeof prePrompt === "string" && prePrompt.trim() ? prePrompt.trim() : "";
+    this.shouldProcessPrePrompt = Boolean(shouldProcessPrePrompt) && Boolean(this.prePrompt);
     this.sessionStreamReplyCounts = new Map();
     this.lastRuntimeStatusSignature = null;
     this.lastRuntimeStatusPayload = null;
@@ -2027,6 +2062,17 @@ export class BridgeRunner {
       return;
     }
 
+    if (this.shouldProcessPrePrompt) {
+      this.copilotLog(
+        `processing pre_prompt via synthetic attach flow contentLen=${this.prePrompt.length}`,
+      );
+      this.shouldProcessPrePrompt = false;
+      await this.handlePrePromptMessage(this.prePrompt);
+      if (this.stopped) {
+        return;
+      }
+    }
+
     if (this.initialPrompt && this.initialPromptDelivery === "synthetic") {
       this.copilotLog("processing initial prompt via synthetic attach flow");
       await this.handleSyntheticMessage(this.initialPrompt, {
@@ -3049,6 +3095,51 @@ export class BridgeRunner {
   }
 
   async handleSyntheticMessage(content, { includeImages }) {
+    return this.runSyntheticTurn({
+      content,
+      replyTarget: "initial",
+      includeImages: Boolean(includeImages),
+      logTag: "synthetic",
+      introLabel: "初始提示",
+      errorLabel: "初始提示",
+    });
+  }
+
+  async handlePrePromptMessage(content) {
+    const text = typeof content === "string" ? content.trim() : "";
+    if (!text) {
+      return;
+    }
+    return this.runSyntheticTurn({
+      content: text,
+      replyTarget: "pre_prompt",
+      includeImages: false,
+      logTag: "pre_prompt",
+      introLabel: "pre_prompt",
+      errorLabel: "pre_prompt",
+      surfaceUserMessage: {
+        content: text,
+        metadata: {
+          pre_prompt: true,
+          role: "user",
+          visible_as: "user",
+          origin: "pre_prompt",
+        },
+      },
+      replyMetadata: { pre_prompt_response: true },
+    });
+  }
+
+  async runSyntheticTurn({
+    content,
+    replyTarget,
+    includeImages,
+    logTag,
+    introLabel,
+    errorLabel,
+    surfaceUserMessage,
+    replyMetadata,
+  }) {
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
     const startedAt = Date.now();
@@ -3056,28 +3147,48 @@ export class BridgeRunner {
       this.useSessionFileReplyStream &&
       typeof this.backendSession?.setSessionReplyTarget === "function"
     ) {
-      this.backendSession.setSessionReplyTarget("initial");
+      this.backendSession.setSessionReplyTarget(replyTarget);
+    }
+    this.copilotLog(
+      `${logTag} turn start includeImages=${Boolean(includeImages)} contentLen=${String(content || "").length}`,
+    );
+    if (surfaceUserMessage) {
+      try {
+        await this.conductor.sendMessage(this.taskId, surfaceUserMessage.content, {
+          backend: this.backendName,
+          thread_id: this.backendSession?.threadId,
+          cli_args: this.cliArgs,
+          synthetic: true,
+          ...(surfaceUserMessage.metadata || {}),
+        });
+        this.copilotLog(
+          `${logTag} message surfaced to task len=${surfaceUserMessage.content.length}`,
+        );
+      } catch (error) {
+        log(`Failed to surface ${logTag} message: ${error?.message || error}`);
+      }
     }
-    this.copilotLog(`synthetic turn start includeImages=${Boolean(includeImages)} contentLen=${String(content || "").length}`);
     try {
       const result = await this.backendSession.runTurn(content, {
-        useInitialImages: includeImages,
+        useInitialImages: Boolean(includeImages),
         onProgress: (payload) => {
-          void this.reportRuntimeStatus(payload, "initial");
+          void this.reportRuntimeStatus(payload, replyTarget);
         },
       });
       this.copilotLog(
-        `synthetic runTurn completed elapsedMs=${Date.now() - startedAt} answerLen=${String(result.text || "").trim().length}`,
+        `${logTag} runTurn completed elapsedMs=${Date.now() - startedAt} answerLen=${String(result.text || "").trim().length}`,
       );
       if (!this.useSessionFileReplyStream) {
         const backendLabel = this.backendName.charAt(0).toUpperCase() + this.backendName.slice(1);
-        const intro = `${backendLabel} 已根据初始提示给出回复：`;
+        const intro = `${backendLabel} 已根据${introLabel}给出回复：`;
         const replyText =
-          result.text || extractAgentTextFromItems(result.items) || extractAgentTextFromMetadata(result.metadata);
+          result.text ||
+          extractAgentTextFromItems(result.items) ||
+          extractAgentTextFromMetadata(result.metadata);
         const text = replyText ? `${intro}\n\n${replyText}` : intro;
         logBackendReply(this.backendName, replyText || "(无文本输出)", {
           usage: result.usage,
-          replyTo: "initial",
+          replyTo: replyTarget,
         });
         await this.conductor.sendMessage(this.taskId, text, {
           model: this.backendSession.threadOptions?.model || this.backendName,
@@ -3086,27 +3197,32 @@ export class BridgeRunner {
           thread_id: this.backendSession.threadId,
           cli_args: this.cliArgs,
           synthetic: true,
+          ...(replyMetadata || {}),
         });
-        this.copilotLog(`synthetic sdk_message sent responseLen=${text.length}`);
+        this.copilotLog(`${logTag} sdk_message sent responseLen=${text.length}`);
       } else {
-        this.copilotLog("synthetic session_file turn settled");
+        this.copilotLog(`${logTag} 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))) {
-        this.copilotLog(`synthetic turn interrupted by stop_task elapsedMs=${Date.now() - startedAt}`);
+        this.copilotLog(`${logTag} turn interrupted by stop_task elapsedMs=${Date.now() - startedAt}`);
         return;
       }
-      if (await this.settleCodexCheckpointUnavailableAfterStream("initial", errorMessage, { markProcessed: false })) {
+      if (
+        await this.settleCodexCheckpointUnavailableAfterStream(replyTarget, errorMessage, {
+          markProcessed: false,
+        })
+      ) {
         return;
       }
       this.copilotLog(
-        `synthetic turn failed elapsedMs=${Date.now() - startedAt} error="${sanitizeForLog(errorMessage, 200)}"`,
+        `${logTag} turn failed elapsedMs=${Date.now() - startedAt} error="${sanitizeForLog(errorMessage, 200)}"`,
       );
-      await this.reportError(`初始提示执行失败: ${errorMessage}`);
+      await this.reportError(`${errorLabel}执行失败: ${errorMessage}`);
     } finally {
-      this.copilotLog(`synthetic turn end elapsedMs=${Date.now() - startedAt}`);
+      this.copilotLog(`${logTag} turn end elapsedMs=${Date.now() - startedAt}`);
       this.runningTurn = false;
     }
   }

package/bin/conductor-issue.js

@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+
+/**
+ * conductor issue — entity-oriented issue management.
+ *
+ * Subcommands:
+ *   list [--project ...] [--status <s>] [--limit N]
+ *   show <id>
+ *   create --title <t> [--description <d> | --description-file FILE | --description-stdin]
+ *          [--priority P1|P2|P3] [--status backlog|doing|done]
+ *          [--client-request-id <key>] [--project ...]
+ *   update <id> [--title ...] [--description ...] [--priority ...] [--status ...]
+ *   start <id>          (alias for update --status doing)
+ *   done <id> [--evidence <text>|@FILE]
+ *
+ * Global flags supported on every write subcommand:
+ *   --json, --dry-run, --project, --config-file
+ */
+
+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 {
+  EXIT,
+  buildApis,
+  buildAuditMetadata,
+  emitDryRun,
+  exitCodeForError,
+  makeDryRunPayload,
+  pad,
+  printJson,
+  printPretty,
+  readDescription,
+  readEvidence,
+  reportError,
+  resolveProject,
+} from "../src/entity-helpers.js";
+
+const isMainModule = (() => {
+  const currentFile = fileURLToPath(import.meta.url);
+  const entryFile = process.argv[1] ? path.resolve(process.argv[1]) : "";
+  return entryFile === currentFile;
+})();
+
+function buildBaseUrl(config) {
+  const raw = (config?.backendUrl || "").replace(/\/+$/, "");
+  return raw || "http://localhost";
+}
+
+function issueAsObject(issue) {
+  if (!issue) return null;
+  if (typeof issue.asObject === "function") return issue.asObject();
+  return {
+    id: issue.id,
+    title: issue.title,
+    status: issue.status,
+    priority: issue.priority,
+    description: issue.description,
+    projectId: issue.projectId,
+    metadata: issue.metadata,
+    createdAt: issue.createdAt,
+    updatedAt: issue.updatedAt,
+  };
+}
+
+function parseStatusList(value) {
+  if (!value) return undefined;
+  return String(value)
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+async function handleList(argv, deps) {
+  const apis = await buildApis(deps);
+  const project = await resolveProject(apis, { env: deps.env, cwd: deps.cwd, project: argv.project });
+  const list = await apis.issues.listIssues({
+    projectId: project.id,
+    status: parseStatusList(argv.status),
+    limit: argv.limit ? Number(argv.limit) : undefined,
+  });
+  const objects = (Array.isArray(list) ? list : []).map(issueAsObject);
+  if (argv.json) {
+    printJson(deps.stdout, objects);
+    return EXIT.OK;
+  }
+  if (objects.length === 0) {
+    printPretty(deps.stdout, "(no issues)");
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `${pad("ID", 24)} ${pad("STATUS", 9)} ${pad("PRIO", 5)} TITLE`);
+  for (const issue of objects) {
+    printPretty(
+      deps.stdout,
+      `${pad(issue.id, 24)} ${pad(issue.status, 9)} ${pad(issue.priority ?? "", 5)} ${issue.title ?? ""}`,
+    );
+  }
+  return EXIT.OK;
+}
+
+async function handleShow(argv, deps) {
+  const apis = await buildApis(deps);
+  const issue = await apis.issues.getIssue(argv.id);
+  if (!issue) {
+    const err = new Error(`Issue not found: ${argv.id}`);
+    err.statusCode = 404;
+    throw err;
+  }
+  const obj = issueAsObject(issue);
+  if (argv.json) {
+    printJson(deps.stdout, obj);
+    return EXIT.OK;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined || value === null) continue;
+    if (typeof value === "object") {
+      printPretty(deps.stdout, `${key}: ${JSON.stringify(value)}`);
+    } else {
+      printPretty(deps.stdout, `${key}: ${value}`);
+    }
+  }
+  return EXIT.OK;
+}
+
+async function handleCreate(argv, deps) {
+  const apis = await buildApis(deps);
+  const project = await resolveProject(apis, { env: deps.env, cwd: deps.cwd, project: argv.project });
+  const description = readDescription({
+    description: argv.description,
+    descriptionFile: argv.descriptionFile,
+    descriptionStdin: argv.descriptionStdin,
+    stdin: deps.stdin,
+  });
+  const metadata = buildAuditMetadata(deps.env);
+  const body = {
+    projectId: project.id,
+    title: String(argv.title),
+    ...(description !== undefined ? { description } : {}),
+    ...(argv.priority ? { priority: String(argv.priority) } : {}),
+    ...(argv.status ? { status: String(argv.status) } : {}),
+    ...(argv.clientRequestId ? { clientRequestId: String(argv.clientRequestId) } : {}),
+    metadata,
+  };
+  if (argv.dryRun) {
+    emitDryRun(
+      deps.stdout,
+      argv.json,
+      makeDryRunPayload("POST", `${buildBaseUrl(apis.config)}/api/issues`, body),
+    );
+    return EXIT.OK;
+  }
+  const created = await apis.issues.createIssue(body);
+  const obj = issueAsObject(created);
+  if (argv.json) {
+    printJson(deps.stdout, obj);
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `Created issue ${obj.id}: ${obj.title}`);
+  return EXIT.OK;
+}
+
+async function handleUpdate(argv, deps, overrides = {}) {
+  const apis = await buildApis(deps);
+  const description = readDescription({
+    description: argv.description,
+    descriptionFile: argv.descriptionFile,
+    descriptionStdin: argv.descriptionStdin,
+    stdin: deps.stdin,
+  });
+  // `--description ""` is intentionally treated as a no-op (readDescription
+  // returns undefined). To clear an existing description, the server expects
+  // an explicit `null` — exposing that requires a follow-up flag and is out of
+  // scope here (review M5 — current behavior accepted as documented).
+  const status = overrides.status || argv.status;
+  const evidence = overrides.evidence;
+  const metadata = buildAuditMetadata(deps.env);
+  const body = {
+    ...(argv.title ? { title: String(argv.title) } : {}),
+    ...(description !== undefined ? { description } : {}),
+    ...(argv.priority ? { priority: String(argv.priority) } : {}),
+    ...(status ? { status: String(status) } : {}),
+    metadata,
+  };
+  if (Object.keys(body).filter((key) => key !== "metadata").length === 0) {
+    const err = new Error("Nothing to update: pass at least one of --title/--description/--priority/--status");
+    err.code = "ARGS";
+    throw err;
+  }
+  if (argv.dryRun) {
+    // Surface evidence in the preview body so the user sees what the SDK will
+    // merge into `metadata.qa.evidence` server-side. The real call still
+    // round-trips the existing metadata; this preview is an approximation.
+    const previewBody = evidence === undefined
+      ? body
+      : {
+          ...body,
+          metadata: {
+            ...body.metadata,
+            qa: { ...((body.metadata && body.metadata.qa) || {}), evidence },
+          },
+        };
+    const previewOptions = evidence !== undefined
+      ? { note: "preview omits server-side metadata round-trip; live PATCH merges existing metadata.qa fields" }
+      : {};
+    emitDryRun(
+      deps.stdout,
+      argv.json,
+      makeDryRunPayload(
+        "PATCH",
+        `${buildBaseUrl(apis.config)}/api/issues/${encodeURIComponent(argv.id)}`,
+        previewBody,
+        previewOptions,
+      ),
+    );
+    return EXIT.OK;
+  }
+  // Pick the SDK call:
+  //   - If we have `evidence`, route through `updateIssueStatus` so the SDK
+  //     round-trips the existing metadata and merges `qa.evidence` instead of
+  //     clobbering. We pass `metadata` so the CLI's audit namespace flows
+  //     through.
+  //   - Otherwise call `updateIssue` so a multi-field patch (title + status)
+  //     reaches the server intact (review B2: previously the CLI passed the
+  //     full body as the SDK's third arg, which was ignored).
+  let updated;
+  if (evidence !== undefined && status && typeof apis.issues.updateIssueStatus === "function") {
+    updated = await apis.issues.updateIssueStatus(argv.id, String(status), {
+      evidence,
+      metadata,
+    });
+  } else {
+    updated = await apis.issues.updateIssue(argv.id, body);
+  }
+  const obj = issueAsObject(updated);
+  if (argv.json) {
+    printJson(deps.stdout, obj);
+    return EXIT.OK;
+  }
+  printPretty(deps.stdout, `Updated issue ${obj.id}`);
+  return EXIT.OK;
+}
+
+export async function main(argvInput = hideBin(process.argv), deps = {}) {
+  const stdout = deps.stdout || process.stdout;
+  const stderr = deps.stderr || process.stderr;
+  const env = deps.env || process.env;
+  const cwd = deps.cwd || process.cwd();
+  const consoleErr = { error: (msg) => stderr.write(`${msg}\n`) };
+  const handlerDeps = { ...deps, stdout, stderr, env, cwd };
+
+  let exitCode = EXIT.OK;
+  try {
+    await yargs(argvInput)
+      .scriptName("conductor issue")
+      .strict()
+      .help()
+      .option("json", { type: "boolean", default: false })
+      .option("dry-run", { type: "boolean", default: false })
+      .option("project", { type: "string", describe: "Project id or name override" })
+      .option("config-file", { type: "string", describe: "Path to Conductor config file" })
+      .command(
+        "list",
+        "List issues",
+        (cmd) => cmd
+          .option("status", { type: "string", describe: "Comma-separated status filter (e.g. backlog,doing)" })
+          .option("limit", { type: "number" }),
+        async (argv) => {
+          exitCode = await handleList(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "show <id>",
+        "Show one issue's full detail",
+        (cmd) => cmd.positional("id", { type: "string", demandOption: true }),
+        async (argv) => {
+          exitCode = await handleShow(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "create",
+        "Create a new issue",
+        (cmd) => cmd
+          .option("title", { type: "string", demandOption: true })
+          .option("description", { type: "string" })
+          .option("description-file", { type: "string" })
+          .option("description-stdin", { type: "boolean", default: false })
+          .option("priority", { choices: ["P1", "P2", "P3"] })
+          .option("status", { choices: ["backlog", "doing", "done"] })
+          .option("client-request-id", { type: "string" }),
+        async (argv) => {
+          exitCode = await handleCreate(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "update <id>",
+        "Update an issue's fields (any subset)",
+        (cmd) => cmd
+          .positional("id", { type: "string", demandOption: true })
+          .option("title", { type: "string" })
+          .option("description", { type: "string" })
+          .option("description-file", { type: "string" })
+          .option("description-stdin", { type: "boolean", default: false })
+          .option("priority", { choices: ["P1", "P2", "P3"] })
+          .option("status", { choices: ["backlog", "doing", "done"] }),
+        async (argv) => {
+          exitCode = await handleUpdate(argv, { ...handlerDeps, configFile: argv.configFile });
+        },
+      )
+      .command(
+        "start <id>",
+        "Mark issue as doing (alias for update --status doing)",
+        (cmd) => cmd.positional("id", { type: "string", demandOption: true }),
+        async (argv) => {
+          exitCode = await handleUpdate(argv, { ...handlerDeps, configFile: argv.configFile }, { status: "doing" });
+        },
+      )
+      .command(
+        "done <id>",
+        "Mark issue as done (optionally attach QA evidence)",
+        (cmd) => cmd
+          .positional("id", { type: "string", demandOption: true })
+          .option("evidence", { type: "string", describe: "Inline text or @path/to/file" }),
+        async (argv) => {
+          const evidence = readEvidence(argv.evidence);
+          exitCode = await handleUpdate(argv, { ...handlerDeps, configFile: argv.configFile }, {
+            status: "done",
+            ...(evidence !== undefined ? { evidence } : {}),
+          });
+        },
+      )
+      .demandCommand(1)
+      .fail((msg, err) => {
+        if (err) {
+          throw err;
+        }
+        stderr.write(`${msg}\n`);
+        exitCode = EXIT.ARGS;
+      })
+      .parseAsync();
+  } catch (err) {
+    exitCode = reportError(consoleErr, err);
+  }
+  return exitCode;
+}
+
+if (isMainModule) {
+  main().then((code) => {
+    if (code !== 0) process.exit(code);
+  }).catch((err) => {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(exitCodeForError(err));
+  });
+}