cofluxd 2.10.0 → 2.12.0

package/coflux.mjs

@@ -517,11 +517,13 @@ function renderExecutorTimeout(timeoutSec, runId, phase) {
   return `等待超时（${timeoutSec}s）：executor 任务 ${runId} 仍是 ${phase}，已请求取消。可加大 --timeout 后重发`;
 }
 
-/** Submit. A transport failure retries with the same submissionId; a refusal is reported verbatim. */
-async function executorSubmit(prompt, write) {
+/** Submit. A transport failure retries with the same submissionId; a refusal is reported verbatim.
+ * `title` names the run on the desktop's card (plan 20260929-executor-pip); empty = the daemon
+ * falls back to the prompt's first line. */
+async function executorSubmit(prompt, write, title) {
   const submission = submissionId();
   for (let attempt = 0; ; attempt += 1) {
-    const result = await agentPostResult({ action: "executor.submit", submissionId: submission, prompt, write });
+    const result = await agentPostResult({ action: "executor.submit", submissionId: submission, prompt, write, title });
     if (result.ok) {
       const runId = String(result.value?.runId ?? "");
       if (!runId) die("daemon 没有返回 runId（版本太旧？）");
@@ -533,15 +535,16 @@ async function executorSubmit(prompt, write) {
 }
 
 async function cmdExecutor(values) {
-  if (positionals[1] !== "run") die(`executor 的子命令只有 run：coflux executor run --prompt="<任务>" [--write]`);
+  if (positionals[1] !== "run") die(`executor 的子命令只有 run：coflux executor run --prompt="<任务>" [--title="<标题>"] [--write]`);
   const prompt = String(values.prompt ?? "").trim();
   if (!prompt) {
     die(`executor run 需要 --prompt="<任务>"（一句把边界说清的任务描述，例如 --prompt="把 crates/worker 的 clippy 警告清掉"）`);
   }
   const write = Boolean(values.write);
+  const title = String(values.title ?? "").trim();
   const timeoutSec = executorTimeoutSecs(values.timeout);
   const deadline = Date.now() + timeoutSec * 1000;
-  const runId = await executorSubmit(prompt, write);
+  const runId = await executorSubmit(prompt, write, title);
   for (;;) {
     // The first poll does not sleep: a rejection (write lock taken, model not configured) has to
     // surface immediately instead of costing the caller a whole poll interval.
@@ -587,13 +590,14 @@ const HELP = `coflux —— 账号与终端操作
   coflux notify "<一句话>"  发送站内通知；服务器保存后确认送达
   coflux progress "<一句话>"  播报进度：显示在工作区卡片上，被下一条覆盖（不打扰用户）
   coflux ports           列出本工作区的监听端口及可直接打开的预览 URL
-  coflux executor run --prompt="<任务>" [--write] [--timeout <秒>]
+  coflux executor run --prompt="<任务>" [--title="<标题>"] [--write] [--timeout <秒>]
                           把一个边界清楚的子任务甩给内置的轻量 executor（由本机 Coflux.app
                           执行），阻塞到跑完并打印它的最终回复与改动文件。一次性：没有会话、
                           不续聊，要改就再发一次。入参只有任务描述与读写模式——模型由用户在
                           Coflux.app 里全局配一次。默认只读；--write 才允许改文件（同一工作区
                           同时只允许一个写任务）。它被内核级沙箱锁在本工作区目录内，**不联网**
                           （先把依赖装好再甩），也**不会 git commit**（改动由你自己 review 提交）
+                          --title 给这次运行起个短标题：用户在本终端上会看到一张进度小卡
                           只有装了 Coflux.app 的这台机器能用
   coflux workspace       一行 JSON 报出「我在哪」：workspaceId（cwd 所在的有效工作区，本地命令
                           都落在它上面）、path、owningWorkspaceId（本终端此刻归属哪个工作区）、

package/cofluxd.mjs

@@ -28,9 +28,15 @@ import { executorRuntime, plistXml, ptydPlistXml, ptydSystemdUnit, systemdUnit }
 const DEFAULT_SERVER = "wss://api.coflux.dev/daemon";
 
 const REPO = "myWsq/coflux";
-const RELEASE_API_BASE = (process.env.COFLUX_RELEASE_API_BASE || "https://api.github.com").replace(/\/+$/, "");
-const RELEASE_DOWNLOAD_BASE = (
-  process.env.COFLUX_RELEASE_DOWNLOAD_BASE || `https://github.com/${REPO}/releases/download`
+// Release downloads route by version, never by failure (plan 20260930-r2-download-mirror): the mirror
+// (R2 at dl.coflux.dev) holds only the latest stable release and its `latest.json` pointer; every other
+// version, and every prerelease, comes from the GitHub Releases archive. No mirror-then-GitHub fallback:
+// a mirror outage must stay visible.
+const RELEASE_MIRROR_BASE = (
+  process.env.COFLUX_RELEASE_DOWNLOAD_BASE || "https://dl.coflux.dev/releases"
+).replace(/\/+$/, "");
+const RELEASE_ARCHIVE_BASE = (
+  process.env.COFLUX_RELEASE_ARCHIVE_BASE || `https://github.com/${REPO}/releases/download`
 ).replace(/\/+$/, "");
 const MAX_RELEASE_METADATA_BYTES = 1024 * 1024;
 const HOME = process.env.COFLUX_HOME || join(homedir(), ".coflux");
@@ -258,16 +264,18 @@ function persistCliReleaseFloor(version) {
   }
 }
 
-// 取最新 release tag（含 prerelease；GitHub 的 /releases/latest 跳转不含 prerelease，故走 API）。
-async function resolveLatestTag() {
+// The latest stable tag named by the mirror's `latest.json`, or null when it cannot be read or is invalid.
+async function readMirrorLatestTag() {
   try {
     const body = await fetchBounded(
-      `${RELEASE_API_BASE}/repos/${REPO}/releases?per_page=1`,
+      `${RELEASE_MIRROR_BASE}/latest.json`,
       MAX_RELEASE_METADATA_BYTES,
-      "GitHub release 元数据",
+      "release 下载镜像 latest.json",
     );
-    const arr = JSON.parse(body.toString("utf8"));
-    return Array.isArray(arr) && typeof arr[0]?.tag_name === "string" ? arr[0].tag_name : null;
+    const tag = JSON.parse(body.toString("utf8"))?.version;
+    if (typeof tag !== "string") return null;
+    assertReleaseVersion(tag);
+    return tag;
   } catch {
     return null;
   }
@@ -322,13 +330,23 @@ async function ensureBinaries({ version, binDir, skipIfPresent }) {
   }
   const target = rustTarget();
   let releaseVersion;
+  let releaseBase;
   if (!version || version === "latest") {
-    const tag = await resolveLatestTag();
-    if (!tag) die("无法取得最新 release 的精确版本，拒绝无版本身份的下载");
+    const tag = await readMirrorLatestTag();
+    if (!tag) {
+      die(
+        `无法从下载镜像读取最新版本（${RELEASE_MIRROR_BASE}/latest.json），拒绝无版本身份的下载。\n` +
+        "  用 --version vX.Y.Z 指定版本即可从 GitHub Releases 安装。",
+      );
+    }
     releaseVersion = tag;
+    releaseBase = RELEASE_MIRROR_BASE;
     console.log(`最新版本: ${releaseVersion}`);
   } else {
     releaseVersion = version;
+    // Only the tag the mirror's pointer names lives on the mirror; any other version (older, newer or a
+    // prerelease), and any version asked for while the pointer is unreadable, comes from the archive.
+    releaseBase = (await readMirrorLatestTag()) === releaseVersion ? RELEASE_MIRROR_BASE : RELEASE_ARCHIVE_BASE;
   }
   try {
     assertReleaseVersion(releaseVersion);
@@ -348,7 +366,8 @@ async function ensureBinaries({ version, binDir, skipIfPresent }) {
     die(error instanceof Error ? error.message : String(error));
   }
 
-  const base = `${RELEASE_DOWNLOAD_BASE}/${releaseVersion}`;
+  const base = `${releaseBase}/${releaseVersion}`;
+  console.log(`下载源: ${base}`);
   const stageDir = fs.mkdtempSync(join(BIN_DIR, ".coflux-release-install-"));
   let failure;
   try {

package/executor/host.js

@@ -632,6 +632,8 @@ var ExecutorManager = class {
       const run = this.live.get(runId);
       if (run) run.settled = true;
       this.apply(this.table.finish(runId, outcome));
+    } else if (message.type === "transcript") {
+      if (this.live.has(runId)) this.deps.sendTranscript?.(runId, message.fragment);
     }
   }
   /**
@@ -683,6 +685,9 @@ function createExecutorHostCore(options) {
       };
     },
     sendReport: (report) => options.send({ type: "report", ...report }),
+    // The daemon assigns the seq and buffers per run; the same frame rides JSONL for the daemon's
+    // own host and the device channel for Coflux.app.
+    sendTranscript: (runId, fragment) => options.send({ type: "transcript", runId, fragment }),
     log: options.log
   });
   return {

package/executor/runner.js

@@ -82,6 +82,181 @@ var EXECUTOR_RUNNER_EXIT = {
   aborted: 11
 };
 
+// ../executor/src/transcript.ts
+var TOOL_OUTPUT_HEAD_CHARS = 4 * 1024;
+var TOOL_OUTPUT_TAIL_CHARS = 2 * 1024;
+var REDACTED = "***";
+var CREDENTIAL_ENV_NAMES = [
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "OPENAI_API_KEY",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "OPENROUTER_API_KEY",
+  "GROQ_API_KEY",
+  "MISTRAL_API_KEY",
+  "XAI_API_KEY",
+  "DEEPSEEK_API_KEY"
+];
+function capToolOutput(text) {
+  if (text.length <= TOOL_OUTPUT_HEAD_CHARS + TOOL_OUTPUT_TAIL_CHARS) return text;
+  const head = text.slice(0, TOOL_OUTPUT_HEAD_CHARS);
+  const tail = text.slice(text.length - TOOL_OUTPUT_TAIL_CHARS);
+  const omitted = Buffer.byteLength(text.slice(TOOL_OUTPUT_HEAD_CHARS, text.length - TOOL_OUTPUT_TAIL_CHARS));
+  return `${head}
+\u2026 ${omitted} bytes omitted \u2026
+${tail}`;
+}
+function salientArgument(toolName, args) {
+  const input = args ?? {};
+  const pick = (...keys) => {
+    for (const key of keys) {
+      const value = input[key];
+      if (typeof value === "string" && value.trim()) return value;
+    }
+    return "";
+  };
+  switch (toolName) {
+    case "bash":
+      return pick("command", "cmd");
+    case "read":
+    case "write":
+    case "edit":
+    case "ls":
+      return pick("path", "file_path", "filePath", "directory");
+    case "grep":
+    case "find": {
+      const pattern = pick("pattern", "query", "regex", "glob");
+      const path = pick("path", "directory");
+      return path ? `${pattern} ${path}`.trim() : pattern;
+    }
+    default: {
+      const direct = pick("command", "path", "pattern", "query");
+      if (direct) return direct;
+      try {
+        const json = JSON.stringify(args);
+        return json && json !== "{}" && json !== "null" ? json : "";
+      } catch {
+        return "";
+      }
+    }
+  }
+}
+function toolResultText(result) {
+  if (result === void 0 || result === null) return "";
+  if (typeof result === "string") return result;
+  if (typeof result !== "object") return String(result);
+  const record = result;
+  if (Array.isArray(record.content)) {
+    const parts = [];
+    for (const item of record.content) {
+      if (typeof item === "string") parts.push(item);
+      else if (item && typeof item === "object" && typeof item.text === "string") {
+        parts.push(item.text);
+      }
+    }
+    if (parts.length > 0) return parts.join("\n");
+  }
+  for (const key of ["output", "text", "stdout", "message", "error"]) {
+    if (typeof record[key] === "string") return record[key];
+  }
+  try {
+    return JSON.stringify(result);
+  } catch {
+    return "";
+  }
+}
+function redact(text, secrets) {
+  let out = text;
+  for (const secret of secrets) {
+    if (!secret) continue;
+    out = out.split(secret).join(REDACTED);
+  }
+  return out;
+}
+function toolEnvironment(base, extra, secrets) {
+  const env = {};
+  const stripped = new Set(CREDENTIAL_ENV_NAMES);
+  for (const [name, value] of Object.entries(base ?? {})) {
+    if (value === void 0 || stripped.has(name)) continue;
+    if (secrets.some((secret) => secret && value.includes(secret))) continue;
+    env[name] = value;
+  }
+  for (const [name, value] of Object.entries(extra)) env[name] = value;
+  return env;
+}
+function createTranscriptRecorder(options) {
+  const now = options.now ?? (() => Date.now());
+  const secrets = options.secrets.filter(Boolean);
+  const emit = (fragment) => {
+    const clean = Object.fromEntries(
+      Object.entries(fragment).map(([key, value]) => [key, typeof value === "string" ? redact(value, secrets) : value])
+    );
+    options.emit(clean);
+  };
+  let streaming = "";
+  let lastComplete = "";
+  let stopReason = "";
+  let errorMessage = "";
+  const open = /* @__PURE__ */ new Map();
+  return {
+    onEvent(event) {
+      switch (event.type) {
+        case "message_start": {
+          if (event.message?.role === "assistant") streaming = "";
+          break;
+        }
+        case "message_update": {
+          const inner = event.assistantMessageEvent;
+          if (inner?.type === "text_delta" && inner.delta) streaming += inner.delta;
+          break;
+        }
+        case "message_end": {
+          const message = event.message ?? {};
+          if (message.stopReason) stopReason = message.stopReason;
+          if (message.errorMessage) errorMessage = message.errorMessage;
+          if (message.role !== void 0 && message.role !== "assistant") break;
+          const text = streaming.trim();
+          streaming = "";
+          if (!text) break;
+          lastComplete = text;
+          emit({ kind: "assistant", text, at: now() });
+          break;
+        }
+        case "tool_execution_start": {
+          const tool = event.toolName || "tool";
+          const record = { tool, argument: salientArgument(tool, event.args), at: now() };
+          open.set(event.toolCallId || `${tool}-${open.size}`, record);
+          break;
+        }
+        case "tool_execution_end": {
+          const tool = event.toolName || "tool";
+          const key = event.toolCallId || "";
+          const started = open.get(key);
+          open.delete(key);
+          emit({
+            kind: "tool",
+            tool,
+            argument: started?.argument ?? salientArgument(tool, void 0),
+            output: capToolOutput(toolResultText(event.result)),
+            failed: event.isError === true,
+            at: now()
+          });
+          break;
+        }
+        default:
+          break;
+      }
+    },
+    error(text) {
+      if (!text) return;
+      emit({ kind: "error", text, at: now() });
+    },
+    lastAssistantText: () => streaming.trim() ? streaming.trim() : lastComplete,
+    lastStop: () => ({ reason: stopReason, errorMessage })
+  };
+}
+
 // ../executor/src/runner.ts
 var parentPort = process.parentPort;
 function send(message) {
@@ -93,10 +268,10 @@ function onHostMessage(listener) {
   else process.on("message", (value) => listener(value));
 }
 var transcriptSeq = 0;
-function transcript(kind, text) {
-  if (!text) return;
-  send({ type: "transcript", seq: ++transcriptSeq, kind, text });
+function sendFragment(fragment) {
+  send({ type: "transcript", seq: ++transcriptSeq, fragment });
 }
+var recorder = createTranscriptRecorder({ emit: sendFragment, secrets: [] });
 var liveGroups = /* @__PURE__ */ new Set();
 function killGroup(pgid, signal) {
   try {
@@ -119,17 +294,16 @@ function sandboxedBashOperations(start) {
         cwd: start.workspaceRoot,
         detached: true,
         // Its own process group, so the whole group can be killed.
-        env: {
-          ...options.env,
-          // The scratch dir, not the system /tmp: that holds other tasks and shared sockets, and the
-          // profile does not allow it anyway.
-          TMPDIR: start.scratchDir,
-          // The credential is never handed down to a tool process.
-          ANTHROPIC_API_KEY: void 0,
-          OPENAI_API_KEY: void 0,
-          GEMINI_API_KEY: void 0,
-          COFLUX_EXECUTOR_RUN_ID: start.runId
-        },
+        // The credential is never handed down to a tool process: the well-known credential
+        // variables are stripped by name, and anything carrying the key's value by value, so a tool
+        // that dumps its environment cannot echo it into the transcript. TMPDIR is the scratch dir,
+        // not the system /tmp: that holds other tasks and shared sockets, and the profile does not
+        // allow it anyway.
+        env: toolEnvironment(
+          options.env,
+          { TMPDIR: start.scratchDir, COFLUX_EXECUTOR_RUN_ID: start.runId },
+          [start.apiKey]
+        ),
         stdio: ["ignore", "pipe", "pipe"]
       });
       const pgid = child.pid;
@@ -234,7 +408,7 @@ async function run(start) {
           writable: start.write
         });
         if (verdict) {
-          transcript("error", `\u5DF2\u62E6\u4E0B ${event.toolName}\uFF1A${verdict.reason}`);
+          recorder.error(`\u5DF2\u62E6\u4E0B ${event.toolName}\uFF1A${verdict.reason}`);
           return { block: true, reason: verdict.reason };
         }
         if (event.toolName === "write" || event.toolName === "edit") {
@@ -286,23 +460,12 @@ async function run(start) {
     resourceLoader
   });
   send({ type: "running" });
-  let lastAssistantText = "";
-  let lastStopReason = "";
-  let lastErrorMessage = "";
   session.subscribe((event) => {
-    if (event.type === "message_update") {
-      const inner = event.assistantMessageEvent;
-      if (inner?.type === "text_delta" && inner.delta) lastAssistantText += inner.delta;
-    } else if (event.type === "tool_execution_start") {
+    if (event.type === "tool_execution_start") {
       const name = event.toolName ?? "tool";
       send({ type: "progress", note: `\u6B63\u5728\u6267\u884C ${name}` });
-      transcript("tool", `\u2192 ${name}`);
-    } else if (event.type === "message_end" || event.type === "turn_end") {
-      const message = event.message ?? {};
-      if (message.stopReason) lastStopReason = message.stopReason;
-      if (message.errorMessage) lastErrorMessage = message.errorMessage;
-      if (lastAssistantText) transcript("assistant", lastAssistantText);
     }
+    recorder.onEvent(event);
   });
   const timeout = setTimeout(() => void session.abort(), start.timeoutMs);
   try {
@@ -311,12 +474,14 @@ async function run(start) {
     clearTimeout(timeout);
   }
   await stopAllGroups();
+  const { reason: lastStopReason, errorMessage: lastErrorMessage } = recorder.lastStop();
+  const lastAssistantText = recorder.lastAssistantText();
   if (lastStopReason === "error") {
-    transcript("error", lastErrorMessage || "\u6A21\u578B\u8C03\u7528\u5931\u8D25");
+    recorder.error(lastErrorMessage || "\u6A21\u578B\u8C03\u7528\u5931\u8D25");
     send({
       type: "done",
       outcome: "model_error",
-      summary: lastAssistantText.trim(),
+      summary: lastAssistantText,
       changedFiles: [...changedFiles],
       error: lastErrorMessage || "\u6A21\u578B\u8C03\u7528\u5931\u8D25\uFF0C\u4E14\u672A\u7ED9\u51FA\u539F\u56E0"
     });
@@ -326,7 +491,7 @@ async function run(start) {
     send({
       type: "done",
       outcome: "cancelled",
-      summary: lastAssistantText.trim(),
+      summary: lastAssistantText,
       changedFiles: [...changedFiles],
       error: lastErrorMessage || "\u4EFB\u52A1\u88AB\u4E2D\u65AD"
     });
@@ -345,7 +510,7 @@ async function run(start) {
   send({
     type: "done",
     outcome: "succeeded",
-    summary: lastAssistantText.trim(),
+    summary: lastAssistantText,
     changedFiles: [...changedFiles]
   });
 }
@@ -361,11 +526,12 @@ onHostMessage((message) => {
   }
   if (message?.type !== "start") return;
   if (!message.scratchDir) message.scratchDir = mkdtempSync(`${tmpdir()}/coflux-executor-`);
+  recorder = createTranscriptRecorder({ emit: sendFragment, secrets: [message.apiKey] });
   run(message).catch(async (error) => {
     if (aborting) return;
     await stopAllGroups();
     const text = error instanceof Error ? error.message : String(error);
-    transcript("error", text);
+    recorder.error(text);
     send({
       type: "done",
       outcome: text.includes("\u6A21\u578B") || text.includes("model") ? "model_error" : "tool_failed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cofluxd",
-  "version": "2.10.0",
+  "version": "2.12.0",
   "description": "Coflux 无界面宿主（cofluxd）与统一操作工具（coflux）",
   "type": "module",
   "bin": {

package/skills/coflux/SKILL.md

@@ -422,14 +422,20 @@ server, use it to get the URL and tell the user directly; they click it and nobo
 ### Hand a bounded sub-task to the executor
 
 ```sh
-coflux executor run --prompt="Fix every clippy warning in crates/worker" --write
-coflux executor run --prompt="Find why the relay reconnect test flakes and report back"
+coflux executor run --title="Fix clippy in worker" --prompt="Fix every clippy warning in crates/worker" --write
+coflux executor run --title="Why does the relay test flake" --prompt="Find why the relay reconnect test flakes and report back"
 ```
 
 The executor is a small agent built into coflux. Give it one self-contained job and it works in
 **the workspace your cwd is in** while you keep your own context for the main thread. The command
 blocks until the job ends, then prints the executor's final report and the files it changed.
 
+**Always pass `--title`**: a few words naming the job. While the run is going, the user sees a
+small card on this terminal (on every desktop of the account) with that title, the run's live
+progress and a stop button; they can expand it to read everything the executor did. Without a
+title the card shows the prompt's first line, which is rarely a good name. The card is read-only
+and disappears when the run ends — the result comes back to you, not to the user.
+
 Reach for it when a job is mechanical, bounded and verbose — chasing a failing test suite, a
 repetitive refactor across many files, a search that would cost you many tool calls. Keep the work
 yourself when it needs the conversation's context, the user's judgment, or decisions the prompt
@@ -459,8 +465,9 @@ Its boundaries, enforced by that kernel sandbox — count on them, and tell it w
   refused outright rather than queued; read-only runs may go in parallel up to a small cap.
 
 A run ends if the host it is on goes away — the user quits the desktop app, signs out, or stops the
-machine's terminals — and you get a definite failure, never a hang. `--timeout <seconds>` caps how
-long you wait; the default is 30 minutes and a timeout cancels the run before failing. The model
+machine's terminals — and you get a definite failure, never a hang. The user can also stop it from
+the card, which comes back to you as `cancelled`. `--timeout <seconds>` caps how long you wait; the
+default is 30 minutes and a timeout cancels the run before failing. The model
 comes from the user's account-wide executor settings; if they have not configured one, the command
 says so in one line — relay that to the user instead of retrying.
 
@@ -528,6 +535,12 @@ this machine, so they are there whether or not a desktop is open.
   the page exposed them, the element's selector, DOM path and key computed styles, and the paths of
   its images. It always names the workspace it resolved: an empty list in the wrong workspace means
   you moved (`coflux workspace`). Add `--json` for structured output.
+- One annotation is not always one element. When the user selected several elements together, it
+  lists each one with its own component chain and context under "Element 1 of n": the comment
+  applies to all of them, so change them consistently and resolve the annotation once. When the user
+  dragged a **region**, it gives the region's size and offset, the *container* (the innermost
+  element holding it — usually the component to edit) and the components inside the region; the
+  comment is about that area as a whole, and the screenshot shows exactly the region.
 - Find the code from the most specific lead: a source location first, then the component names,
   then text and selectors (`rg` for them). Treat the computed styles as the current state, not as
   the target: map colors, sizes and spacing onto the project's design system (its tokens, theme and