@zzclub/pipeline 0.10.2 → 0.12.0

package/src/monitor.test.ts

@@ -0,0 +1,241 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { appendFile, mkdtemp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { defaultState, writeState } from "./state";
+import { runWithCommandLog } from "./logger";
+import { notifyProgress, reportLog, reportProgress } from "./monitor/recorder";
+import { MonitorStore } from "./monitor/store";
+import { serveMonitor } from "./monitor/server";
+import { LOG_LIMIT } from "./monitor/runtime";
+import type { MonitorDescriptor, MonitorSnapshot } from "./monitor/types";
+
+let root = "";
+let stop: (() => void) | undefined;
+const previousEnv = { ...process.env };
+const cli = resolve(import.meta.dir, "cli.ts");
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), "zzp-monitor-test-"));
+  process.env.ZZHUB_PIPELINE_MONITOR_DIR = join(root, "monitor");
+  process.env.ZZHUB_PIPELINE_LOG_DIR = join(root, "logs");
+  process.env.ZZHUB_PIPELINE_CONFIG = join(root, "config.json");
+  process.env.ZZHUB_PIPELINE_MONITOR = "1";
+  process.env.NO_COLOR = "1";
+  await writeFile(process.env.ZZHUB_PIPELINE_CONFIG, "{}");
+});
+
+afterEach(async () => {
+  stop?.();
+  stop = undefined;
+  for (const key of ["ZZHUB_PIPELINE_MONITOR_DIR", "ZZHUB_PIPELINE_LOG_DIR", "ZZHUB_PIPELINE_CONFIG", "ZZHUB_PIPELINE_MONITOR", "NO_COLOR"]) {
+    if (previousEnv[key] === undefined) delete process.env[key];
+    else process.env[key] = previousEnv[key];
+  }
+  await rm(root, { recursive: true, force: true });
+});
+
+async function run(args: string[]) {
+  const child = Bun.spawn([process.execPath, cli, ...args], { env: { ...process.env }, stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, exitCode] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+  return { stdout, stderr, exitCode };
+}
+
+async function seed(workspace = root, runId = "same-run") {
+  const asset = join(workspace, "posts", "test");
+  await mkdir(asset, { recursive: true });
+  await writeFile(join(asset, "post.md"), "# 测试\n\n正文");
+  const state = defaultState();
+  state.run_id = runId;
+  state.workspace_root = workspace;
+  state.state_path = join(asset, "workflow-state.json");
+  state.asset_path = asset;
+  state.metadata = { ...state.metadata, title: "测试", slug: "test", date: "2026-09-06" };
+  state.content_review.status = "passed";
+  state.intent.requires.render = false;
+  state.intent.requires.publish = true;
+  state.route.primary = "blog";
+  state.phase.current = "publish";
+  state.phase.prepare.status = "done";
+  state.phase.render.status = "done";
+  await writeState(state.state_path, state);
+  return state;
+}
+
+async function blogCommand(script: string) {
+  await writeFile(process.env.ZZHUB_PIPELINE_CONFIG!, JSON.stringify({ paths: { workspaceRoot: root, blogRoot: join(root, "blog") }, commands: { blogPublish: [process.execPath, "-e", script] } }));
+}
+
+function headers(descriptor: MonitorDescriptor) { return { Authorization: `Bearer ${descriptor.token}` }; }
+
+test("CLI partial failures persist, exit 1, keep JSON stdout and retry only failed targets", async () => {
+  const state = await seed();
+  state.publish_targets = [{ route: "blog", account: "first" }, { route: "blog", account: "second" }];
+  await writeState(state.state_path!, state);
+  await blogCommand("const fs = require('fs'); console.log('child diagnostic'); if (fs.existsSync('attempt')) process.exit(7); fs.writeFileSync('attempt', 'ok');");
+  const failed = await run(["publish", "--state", state.state_path!]);
+  expect(failed.exitCode).toBe(1);
+  const result = JSON.parse(failed.stdout);
+  expect(result.publish_results.map((item: { status: string }) => item.status)).toEqual(["success", "failed"]);
+  expect(result.errors[0].error).toContain("exit=7");
+  expect(failed.stderr).toContain("child diagnostic");
+  expect(failed.stderr).toContain("PUBLISH_TARGET_FAILED");
+  const saved = JSON.parse(await readFile(state.state_path!, "utf8"));
+  expect(saved.mode).toBe("active");
+  expect(saved.phase.publish.status).toBe("pending");
+  const store = new MonitorStore("test");
+  await store.refresh();
+  expect(store.snapshot().executions[0]?.outcome?.status).toBe("partial_failure");
+  await blogCommand("require('fs').appendFileSync('retried', 'once');");
+  expect((await run(["publish", "--state", state.state_path!])).exitCode).toBe(0);
+  expect(await readFile(join(root, "blog", "retried"), "utf8")).toBe("once");
+  expect((await run(["publish", "--state", state.state_path!])).exitCode).toBe(0);
+  expect(await readFile(join(root, "blog", "retried"), "utf8")).toBe("once");
+});
+
+test("checkpoint failure exits through common cleanup; status and dry-run still exit 0", async () => {
+  const state = await seed();
+  state.content_review.status = "unchecked";
+  await writeState(state.state_path!, state);
+  const checkpoint = await run(["checkpoint", "--state", state.state_path!]);
+  expect(checkpoint.exitCode).toBe(1);
+  expect(JSON.parse(checkpoint.stdout).validation.valid).toBe(false);
+  expect((await run(["status", "--state", state.state_path!])).exitCode).toBe(0);
+  state.content_review.status = "passed";
+  await writeState(state.state_path!, state);
+  await blogCommand("process.exit(9)");
+  expect((await run(["publish", "--state", state.state_path!, "--dry-run"])).exitCode).toBe(0);
+  const store = new MonitorStore("test");
+  await store.refresh();
+  expect(store.snapshot().executions.find((execution) => execution.command === "checkpoint")?.status).toBe("exited");
+});
+
+test("20 parallel CLI calls preserve execution identities and separate identical run IDs across workspaces", async () => {
+  const a = await seed(join(root, "a"));
+  const b = await seed(join(root, "b"));
+  const results = await Promise.all(Array.from({ length: 20 }, (_, index) => run(["status", "--state", (index % 2 ? a : b).state_path!])));
+  expect(results.every((result) => result.exitCode === 0)).toBe(true);
+  const store = new MonitorStore("test");
+  await store.refresh();
+  expect(store.snapshot().executions).toHaveLength(20);
+  expect(store.snapshot().tasks).toHaveLength(2);
+  expect(store.snapshot({ workspace: a.workspace_root }).executions).toHaveLength(10);
+  expect(new Set(store.snapshot().executions.map((execution) => execution.id)).size).toBe(20);
+}, 15_000);
+
+test("recording failure and optional callback failure cannot change command results", async () => {
+  const file = join(root, "not-a-directory");
+  await writeFile(file, "x");
+  process.env.ZZHUB_PIPELINE_MONITOR_DIR = file;
+  const state = await seed();
+  expect((await run(["status", "--state", state.state_path!])).exitCode).toBe(0);
+  expect(() => notifyProgress(() => { throw new Error("observer unavailable"); }, { stage: "test" })).not.toThrow();
+  await expect(runWithCommandLog("render", [], async () => { throw new Error("original failure"); })).rejects.toThrow("original failure");
+});
+
+test("logs redact secrets, preserve UTF-8 and retain terminal errors after truncation", async () => {
+  const message = "中文".repeat(2000);
+  await runWithCommandLog("render", ["--pat", "private-pat"], async () => {
+    reportLog("info", "Authorization: Bearer private-token ?access_token=another-secret");
+    for (let index = 0; index < 1100; index++) reportLog("debug", message);
+    reportProgress({ stage: "render.pages", current: 3, total: 3, unit: "pages" });
+    return { status: "failed", errors: [{ code: "RENDER_FAILED", message: "最终错误" }] };
+  });
+  const store = new MonitorStore("test");
+  await store.refresh();
+  const execution = store.snapshot().executions[0]!;
+  expect(execution.logs_truncated).toBe(true);
+  expect(store.eventsAfter("test:0")).toBeNull();
+  expect(execution.outcome?.errors?.[0]?.message).toBe("最终错误");
+  const logs = await store.logs(execution.id, 0, 30);
+  expect(JSON.stringify(logs)).not.toContain("private-token");
+  expect(JSON.stringify(logs)).not.toContain("another-secret");
+  expect(JSON.stringify(logs)).not.toContain("�");
+  const raw = await readFile(join(process.env.ZZHUB_PIPELINE_MONITOR_DIR!, "events", `${execution.id}.jsonl`), "utf8");
+  expect(raw).not.toContain("private-pat");
+  expect(Buffer.byteLength(raw)).toBeLessThan(LOG_LIMIT + 300_000);
+});
+
+test("incomplete final records resume on the next read and state aliases keep one task", async () => {
+  await runWithCommandLog("prepare-finalize", [], async () => {
+    const state = await seed();
+    await writeState(join(root, "temporary-state.json"), state);
+  });
+  const eventDir = join(process.env.ZZHUB_PIPELINE_MONITOR_DIR!, "events");
+  const file = join(eventDir, (await readdir(eventDir))[0]!);
+  const raw = await readFile(file, "utf8");
+  const lines = raw.trimEnd().split("\n");
+  const final = lines.pop()!;
+  await writeFile(file, `${lines.join("\n")}\ninvalid-event\n${final.slice(0, -5)}`);
+  const store = new MonitorStore("test");
+  await store.refresh();
+  expect(store.snapshot().tasks).toHaveLength(1);
+  expect(store.snapshot().executions[0]?.outcome).toBeNull();
+  expect(store.snapshot().executions[0]?.status).not.toBe("interrupted");
+  await appendFile(file, `${final.slice(-5)}\n`);
+  await store.refresh();
+  expect(store.snapshot().executions[0]?.status).toBe("exited");
+  expect(store.snapshot().tasks[0]?.state_path).toContain("posts/test/workflow-state.json");
+});
+
+test("HTTP/SSE support auth, shared subscriptions, cursor replay, resync and server restart", async () => {
+  const server = await serveMonitor();
+  expect(server).not.toBeNull();
+  stop = server!.stop;
+  const descriptor = server!.descriptor;
+  expect((await fetch(`${descriptor.url}/v1/snapshot`)).status).toBe(401);
+  expect((await fetch(`${descriptor.url}/v1/snapshot`, { headers: { ...headers(descriptor), Origin: "https://untrusted.example" } })).status).toBe(403);
+  const initial = await (await fetch(`${descriptor.url}/v1/snapshot`, { headers: headers(descriptor) })).json() as MonitorSnapshot;
+  const controllers = [new AbortController(), new AbortController()];
+  const streams = await Promise.all(controllers.map((controller) => fetch(`${descriptor.url}/v1/events?after=${encodeURIComponent(initial.cursor)}`, { headers: headers(descriptor), signal: controller.signal })));
+  const readers = streams.map((response) => response.body!.getReader());
+  await Promise.all(readers.map((reader) => reader.read()));
+  try {
+    await runWithCommandLog("render", [], async () => { reportProgress({ stage: "render.pages", current: 1, total: 2, unit: "pages" }); });
+    await fetch(`${descriptor.url}/v1/snapshot`, { headers: headers(descriptor) });
+    const events = await Promise.all(readers.map(async (reader) => new TextDecoder().decode((await reader.read()).value)));
+    expect(events.every((event) => event.includes("execution.updated"))).toBe(true);
+    const replay = await fetch(`${descriptor.url}/v1/events?after=${encodeURIComponent(initial.cursor)}`, { headers: headers(descriptor) });
+    const replayReader = replay.body!.getReader();
+    expect(new TextDecoder().decode((await replayReader.read()).value)).toContain("execution.updated");
+    await replayReader.cancel();
+    const stale = await fetch(`${descriptor.url}/v1/events?after=old-instance:1`, { headers: headers(descriptor) });
+    expect(await stale.text()).toContain("resync");
+  } finally {
+    controllers.forEach((controller) => controller.abort());
+    await Promise.all(readers.map((reader) => reader.cancel().catch(() => {})));
+  }
+  stop();
+  const restarted = await serveMonitor();
+  stop = restarted!.stop;
+  expect(restarted!.descriptor.instance_id).not.toBe(descriptor.instance_id);
+  const restored = await (await fetch(`${restarted!.descriptor.url}/v1/snapshot`, { headers: headers(restarted!.descriptor) })).json() as MonitorSnapshot;
+  expect(restored.executions).toHaveLength(1);
+});
+
+test("parallel monitor start calls reuse a single service and stop only that service", async () => {
+  const results = await Promise.all(Array.from({ length: 4 }, () => run(["monitor", "start"])));
+  const descriptors = results.map((result) => JSON.parse(result.stdout) as MonitorDescriptor);
+  try {
+    expect(new Set(descriptors.map((descriptor) => descriptor.instance_id)).size).toBe(1);
+    expect(results.every((result) => result.exitCode === 0)).toBe(true);
+    expect(await readdir(join(root, "logs")).catch(() => [])).toHaveLength(0);
+  } finally { await run(["monitor", "stop"]); }
+}, 20_000);
+
+test("a killed execution becomes interrupted without a heartbeat timeout", async () => {
+  const script = `import { runWithCommandLog } from ${JSON.stringify(resolve(import.meta.dir, "logger.ts"))}; await runWithCommandLog('render', [], async () => { await Bun.sleep(60000); });`;
+  const child = Bun.spawn([process.execPath, "-e", script], { env: { ...process.env }, stdout: "ignore", stderr: "ignore" });
+  try {
+    for (let attempt = 0; attempt < 100; attempt++) {
+      if ((await readdir(join(process.env.ZZHUB_PIPELINE_MONITOR_DIR!, "events")).catch(() => [])).length) break;
+      await Bun.sleep(20);
+    }
+    child.kill("SIGKILL");
+    await child.exited;
+    const store = new MonitorStore("test");
+    await store.refresh();
+    expect(store.snapshot().executions[0]?.status).toBe("interrupted");
+    expect(store.snapshot().executions[0]?.exit_code).toBeNull();
+  } finally { if (child.exitCode === null) { child.kill(); await child.exited; } }
+});

package/src/plugins.ts

@@ -1,5 +1,4 @@
 import { abandon } from "./commands/abandon";
-import { analytics } from "./commands/analytics";
 import { attachBody } from "./commands/attach-body";
 import { attachBodyImages } from "./commands/attach-body-images";
 import { attachNewspicSpec } from "./commands/attach-newspic-spec";
@@ -23,17 +22,18 @@ import { review } from "./commands/review";
 import { status } from "./commands/status";
 import { syncBlog } from "./commands/sync-blog";
 import { tasks } from "./commands/tasks";
-import { topic } from "./commands/topic";
 import { wechatExport } from "./commands/wechat-export";
 import { wechatPreview } from "./commands/wechat-preview";
 import { wxDrafts } from "./commands/wx-drafts";
 import { wxDraftDelete } from "./commands/wx-draft-delete";
+import type { CommandOutcome } from "./command-outcome";
+import { monitor } from "./commands/monitor";
 
 export interface CommandDefinition {
   name: string;
   summary: string;
   plugin: string;
-  handler: (args: string[]) => Promise<void>;
+  handler: (args: string[]) => Promise<void | CommandOutcome>;
 }
 
 export interface CommandPlugin {
@@ -68,6 +68,7 @@ export function getCommandPlugins(): CommandPlugin[] {
     {
       name: "ops",
       commands: [
+        { name: "monitor", summary: "Manage local HTTP/SSE multi-task monitoring", plugin: "ops", handler: monitor },
         { name: "sync-blog", summary: "Copy post.md to blog repo, publish, and record result in state JSON", plugin: "ops", handler: syncBlog },
         { name: "republish", summary: "Publish completed task to additional accounts/platforms", plugin: "ops", handler: republish },
         { name: "imgx", summary: "Run bundled imgx renderer subcommands", plugin: "ops", handler: imgxCommand },
@@ -79,8 +80,6 @@ export function getCommandPlugins(): CommandPlugin[] {
         { name: "hermes-metrics", summary: "Show Hermes execution metrics per task", plugin: "ops", handler: hermesMetrics },
         { name: "wx-drafts", summary: "List or get drafts from WeChat draft box", plugin: "ops", handler: wxDrafts },
         { name: "wx-draft-delete", summary: "Delete a draft from WeChat draft box", plugin: "ops", handler: wxDraftDelete },
-        { name: "topic", summary: "Manage topics (add, list, update, schedule, retro, abandon)", plugin: "ops", handler: topic },
-        { name: "analytics", summary: "Record and analyze post-publish metrics", plugin: "ops", handler: analytics },
       ],
     },
   ];

package/src/providers/blog.ts

@@ -2,6 +2,7 @@ import { mkdir, readFile, writeFile } from "fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "path";
 import { PipelineConfig, ResolvedWorkspacePaths } from "../config";
 import { spawnSync } from "../spawn";
+import { reportProgress } from "../monitor/recorder";
 import { PublishResult, WorkflowState } from "../state";
 import { stripFrontmatter } from "../text";
 import { uploadFileToCos } from "./cos";
@@ -171,14 +172,16 @@ export async function publishBlogRoute({
 
   await mkdir(blogPostDir, { recursive: true });
   await writeFile(blogPostPath, blogContent, "utf-8");
+  reportProgress({ stage: "publish.script", message: "正在运行博客发布命令" });
   const result = spawnSync(config.commands.blogPublish, { cwd: blogRoot });
+  reportProgress({ stage: "publish.script", message: result.exitCode === 0 ? "博客发布命令完成" : "博客发布命令失败", current: 1, total: 1, unit: "targets" });
 
   if (result.exitCode !== 0) {
     return {
       route: "blog",
       account: "default",
       status: "failed",
-      detail: `blog publish command failed: ${config.commands.blogPublish.join(" ")}`,
+      detail: `blog publish command failed: ${config.commands.blogPublish[0]} (exit=${result.exitCode ?? "unknown"}, signal=${result.signal ?? "none"}${result.error ? `, cause=${result.error.message}` : ""})`,
       published_at: null,
       content_version: state.artifacts.content_version,
       render_version: state.artifacts.render_version,

package/src/providers/cos.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "fs";
 import { basename } from "path";
 import COS from "cos-nodejs-sdk-v5";
+import { reportProgress } from "../monitor/recorder";
 
 const STS_PATH = "/api/v1/upload/cos";
 const STS_TIMEOUT = 30000;
@@ -142,6 +143,7 @@ export async function uploadFileToCos(input: {
   }
 
   const sts = await requestSts(baseUrl, cosPat, filename, folder);
+  reportProgress({ stage: "upload.cos", message: "正在上传 COS 文件" });
   const buffer = readFileSync(localPath);
 
   const cos = new COS({
@@ -165,6 +167,7 @@ export async function uploadFileToCos(input: {
         Key: sts.Key,
         Body: buffer,
         ContentType: contentType,
+        onProgress: ({ loaded, total }) => reportProgress({ stage: "upload.cos", current: loaded, total, unit: "bytes" }),
       },
       (err) => {
         if (settled) return;

package/src/providers/index.ts

@@ -11,6 +11,7 @@ import {
   prepareBodyForNewspic,
 } from "../text";
 import { resolveMarkdownRenderer } from "../adapter-loader";
+import { reportProgress } from "../monitor/recorder";
 import { publishBlogRoute } from "./blog";
 import { createWechatDraft, createWechatNewspic, extractImageUrls, mergePhotoLists } from "./wechat";
 
@@ -80,6 +81,7 @@ async function publishWechatArticleRoute({
     const markdownRenderer = await resolveMarkdownRenderer(config);
     const wxAccount = config.wx.accounts[account] ?? config.wx.accounts[config.wx.defaultAccount];
     const rendered = await markdownRenderer.render({
+      onProgress: reportProgress,
       markdownPath: exportPostPath,
       outPath: workspacePaths.zotepadExportHtml,
       account,
@@ -93,7 +95,7 @@ async function publishWechatArticleRoute({
     if (process.env.ZZHUB_WECHAT_PREVIEW_ON_PUBLISH !== "0") {
       try {
         const { registerPreviewEntry } = await import("../wechat-preview/server");
-        await registerPreviewEntry(
+        const registration = await registerPreviewEntry(
           {
             title: `[publish] ${state.metadata.title || "untitled"}`,
             account,
@@ -110,8 +112,10 @@ async function publishWechatArticleRoute({
           },
           { autoStart: process.env.ZZHUB_WECHAT_PREVIEW_AUTO_START !== "0" },
         );
-      } catch {
-        // preview registration must never block publish
+        if (!registration.ok) console.warn(`微信预览登记失败：${registration.error || "未知原因"}`);
+      } catch (error) {
+        // 预览故障只记录警告，不改变发布结果。
+        console.warn("微信预览登记失败：", error);
       }
     }
 

package/src/providers/publish-core.ts

@@ -7,6 +7,7 @@
 import type { PipelineConfig, ResolvedWorkspacePaths } from "../config";
 import type { PublishResult, PublishTarget, WorkflowState } from "../state";
 import { getPublishProvider, type PublishRouteContext } from "./index";
+import { reportProgress } from "../monitor/recorder";
 
 export interface PublishTargetError {
   route: string;
@@ -102,6 +103,7 @@ export async function executePublishTargets(
   const errors: PublishTargetError[] = [];
 
   for (const target of filtered) {
+    reportProgress({ stage: "publish.targets", message: "正在发布", current: results.length, total: filtered.length, unit: "targets", route: target.route, account: target.account });
     let result: PublishResult;
     try {
       const provider = getPublishProvider(target.route);
@@ -135,10 +137,14 @@ export async function executePublishTargets(
         content_version: state.artifacts.content_version,
         render_version: state.artifacts.render_version,
       };
-      errors.push(error);
+    }
+    // provider 返回 failed 与抛出异常使用同一条错误汇总路径。
+    if (result.status === "failed") {
+      errors.push({ route: target.route, account: target.account, error: result.detail || "发布失败，provider 未提供原因" });
     }
     results.push(result);
     await onResult?.(result);
+    reportProgress({ stage: "publish.targets", message: result.status === "failed" ? "目标发布失败" : "目标处理完成", current: results.length, total: filtered.length, unit: "targets", route: target.route, account: target.account });
   }
 
   return { results, errors };

package/src/providers/wechat.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "fs";
 import { basename, extname } from "path";
 import { PipelineConfig, WxAccountConfig } from "../config";
+import { reportProgress } from "../monitor/recorder";
 
 const TOKEN_PATH = "/api/v1/wx/cgi-bin/token";
 const MATERIAL_PATH = "/api/v1/wx/cgi-bin/material/add_material";
@@ -161,8 +162,10 @@ export function normalizeAccountName(value: string): string {
   return account;
 }
 
-function fillWxAccountConfig(source?: WxAccountConfig): WxAccountConfig {
+/** Fill missing wx account fields with defaults. Preserves optional display `name`. */
+export function fillWxAccountConfig(source?: WxAccountConfig): WxAccountConfig {
   return {
+    name: source?.name ?? "",
     pat: source?.pat ?? "",
     appId: source?.appId ?? "",
     appSecret: source?.appSecret ?? "",
@@ -540,6 +543,7 @@ async function uploadPhotos(
       continue;
     }
 
+    reportProgress({ stage: "publish.upload", message: "正在上传微信图片", current: index, total: photos.length, unit: "files" });
     const payload = await resolvePhotoPayload(photoUrl, index);
     const formData = new FormData();
     formData.append("access_token", accessToken);
@@ -574,6 +578,7 @@ async function uploadPhotos(
       index,
     });
     imageUrlMap[photoUrl] = wxUrl || photoUrl;
+    reportProgress({ stage: "publish.upload", current: index + 1, total: photos.length, unit: "files" });
   }
 
   return {
@@ -781,7 +786,7 @@ async function notifyNezusPublishResult(params: {
     console.error(`[nezus] publish-result callback OK for note ${params.noteId}`);
   } catch (err) {
     // Non-fatal: the draft was created successfully even if the callback failed
-    console.error(`[nezus] publish-result callback failed for note ${params.noteId}:`, err);
+    console.warn(`[nezus] publish-result callback failed for note ${params.noteId}:`, err);
   }
 }
 

package/src/schema/config.account-name.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test";
+
+import { normalizeConfig, SUGGESTED_ACCOUNT_NAMES } from "../config";
+import { fillWxAccountConfig } from "../providers/wechat";
+import { PipelineConfigSchema } from "./config";
+
+describe("wx account display name", () => {
+  test("schema keeps name when provided", () => {
+    const parsed = PipelineConfigSchema.parse({
+      wx: {
+        accounts: {
+          default: {
+            name: "早早集市",
+            appId: "wx123",
+          },
+        },
+      },
+    });
+    expect(parsed.wx.accounts.default?.name).toBe("早早集市");
+    expect(parsed.wx.accounts.default?.appId).toBe("wx123");
+  });
+
+  test("schema defaults name to empty string when missing", () => {
+    const parsed = PipelineConfigSchema.parse({
+      wx: {
+        accounts: {
+          custom: {
+            appId: "wx999",
+          },
+        },
+      },
+    });
+    // custom key has no soft-suggest unless normalizeConfig is used
+    expect(parsed.wx.accounts.custom?.name).toBe("");
+  });
+
+  test("normalizeConfig soft-fills known keys only when name empty", () => {
+    const normalized = normalizeConfig({
+      wx: {
+        accounts: {
+          default: { appId: "wx1" },
+          ancientone: { name: "我自定义的小号", appId: "wx2" },
+          other: { appId: "wx3" },
+        },
+      },
+    });
+    expect(normalized.wx.accounts.default?.name).toBe(SUGGESTED_ACCOUNT_NAMES.default);
+    expect(normalized.wx.accounts.ancientone?.name).toBe("我自定义的小号");
+    expect(normalized.wx.accounts.other?.name).toBe("");
+  });
+
+  test("normalizeConfig does not override explicit empty-then-set name after trim", () => {
+    const normalized = normalizeConfig({
+      wx: {
+        accounts: {
+          default: { name: "  大号定制  ", appId: "wx1" },
+        },
+      },
+    });
+    expect(normalized.wx.accounts.default?.name).toBe("大号定制");
+  });
+
+  test("fillWxAccountConfig preserves name", () => {
+    const filled = fillWxAccountConfig({
+      name: "大号",
+      pat: "p",
+      appId: "id",
+      appSecret: "s",
+      customCss: null,
+      theme: { editorVars: {}, exportTheme: {} },
+    });
+    expect(filled.name).toBe("大号");
+  });
+
+  test("fillWxAccountConfig defaults name to empty", () => {
+    const filled = fillWxAccountConfig(undefined);
+    expect(filled.name).toBe("");
+  });
+});

package/src/schema/config.ts

@@ -56,6 +56,12 @@ const WechatThemeOverridesSchema = withObjectDefault(
 );
 
 const WxAccountConfigSchema = z.object({
+  /**
+   * Optional Chinese display name for UIs (e.g. 大号（早早集市）).
+   * Config map key remains the stable account id (default / ancientone).
+   * Whitespace is trimmed in normalizeConfig when soft-filling / merging.
+   */
+  name: z.string().default(""),
   pat: z.string().default(""),
   appId: z.string().default(""),
   appSecret: z.string().default(""),
@@ -74,9 +80,9 @@ const WxConfigSchema = withObjectDefault(
       z.number().default(30000),
     ),
     defaultAccount: trimmedNonEmptyString("default"),
-    accounts: z
-      .record(z.string(), WxAccountConfigSchema)
-      .default({ default: { pat: "", appId: "", appSecret: "", customCss: null, theme: { editorVars: {}, exportTheme: {} } } }),
+    accounts: z.record(z.string(), WxAccountConfigSchema).default(() => ({
+      default: WxAccountConfigSchema.parse({}),
+    })),
   }),
 );
 

package/src/spawn.ts

@@ -42,6 +42,7 @@ export interface SpawnOptions {
 
 export interface SpawnResult {
   exitCode: number | null;
+  signal?: NodeJS.Signals | null;
   error?: Error;
 }
 
@@ -81,20 +82,21 @@ export function resolveBunBinary(): string {
 function normalizeResult(result: SpawnSyncReturns<Buffer>): SpawnResult {
   return {
     exitCode: result.status,
+    signal: result.signal,
     ...(result.error ? { error: result.error } : {}),
   };
 }
 
 /**
  * Run a command synchronously with enriched PATH.
- * stdout and stderr are inherited (printed to terminal).
+ * 子脚本诊断输出统一写入 stderr，保留 CLI stdout 的 JSON 契约。
  *
  * Returns a normalized spawn result.
  */
 export function spawnSync(cmd: string[], opts?: SpawnOptions): SpawnResult {
   const [binary, ...args] = cmd;
   const result = nodeSpawnSync(binary, args, {
-    stdio: "inherit",
+    stdio: ["inherit", 2, 2],
     env: enrichedEnv(),
     ...(opts?.cwd ? { cwd: opts.cwd } : {}),
   });

package/src/state.ts

@@ -9,6 +9,7 @@
 
 import { access, mkdir, open, readFile, rename, rm, stat, writeFile } from "fs/promises";
 import { dirname, isAbsolute, resolve } from "path";
+import { observeState } from "./monitor/recorder";
 import {
   WorkflowStateSchema,
   NewspicRenderSpecSchema,
@@ -245,6 +246,8 @@ export async function readResolvedState(path: string): Promise<ResolvedState> {
     state.state_path = currentPath;
   }
 
+  observeState(state, currentPath);
+
   return {
     path: currentPath,
     requested_path: requestedPath,
@@ -310,6 +313,7 @@ export async function writeState(
   } finally {
     await releaseLock();
   }
+  observeState(validated, normalizedPath);
 }
 
 /**

package/src/workflow.test.ts

@@ -50,7 +50,7 @@ async function makeTempDir(prefix: string): Promise<string> {
   return mkdtemp(join(tmpdir(), prefix));
 }
 
-async function captureJsonOutput<T>(fn: () => Promise<void>): Promise<T> {
+async function captureJsonOutput<T>(fn: () => Promise<unknown>): Promise<T> {
   const original = console.log;
   const lines: string[] = [];
   console.log = (...args: unknown[]) => {
@@ -66,7 +66,7 @@ async function captureJsonOutput<T>(fn: () => Promise<void>): Promise<T> {
   return JSON.parse(payload) as T;
 }
 
-async function captureTextOutput(fn: () => Promise<void>): Promise<string> {
+async function captureTextOutput(fn: () => Promise<unknown>): Promise<string> {
   const original = console.log;
   const lines: string[] = [];
   console.log = (...args: unknown[]) => {
@@ -1437,6 +1437,7 @@ describe("config", () => {
           defaultAccount: "default",
           accounts: {
             default: {
+              name: "",
               pat: "",
               appId: "",
               appSecret: "",