fix(hub): send Feishu files explicitly

hub/test/unit/feishu-client.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it, vi } from "vitest";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { sendFile, sendTextMessage, type FeishuRuntime } from "../../src/feishu/client.js";
+
+describe("Feishu client helpers", () => {
+  it("accepts top-level file_key from the Lark SDK file upload response", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "hub-feishu-client-"));
+    try {
+      const file = join(dir, "student.pdf");
+      await writeFile(file, "pdf bytes");
+      const fileCreate = vi.fn(async () => ({ file_key: "file-key-1" }));
+      const messageCreate = vi.fn(async () => ({ data: { message_id: "message-1" } }));
+      const rt = mockRuntime({ fileCreate, messageCreate });
+
+      await expect(sendFile(rt, "chat-1", file, "student.pdf")).resolves.toBe("message-1");
+      expect(messageCreate).toHaveBeenCalledWith({
+        params: { receive_id_type: "chat_id" },
+        data: { receive_id: "chat-1", msg_type: "file", content: JSON.stringify({ file_key: "file-key-1" }) },
+      });
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("accepts top-level message_id from message create responses", async () => {
+    const rt = mockRuntime({
+      fileCreate: vi.fn(),
+      messageCreate: vi.fn(async () => ({ message_id: "message-1" })),
+    });
+
+    await expect(sendTextMessage(rt, "chat-1", "hello")).resolves.toBe("message-1");
+  });
+});
+
+function mockRuntime(options: {
+  readonly fileCreate: (payload: unknown) => Promise<unknown>;
+  readonly messageCreate: (payload: unknown) => Promise<unknown>;
+}): FeishuRuntime {
+  return {
+    client: {
+      im: {
+        v1: {
+          file: { create: options.fileCreate },
+          message: { create: options.messageCreate },
+        },
+      },
+    } as unknown as FeishuRuntime["client"],
+    logger: {
+      info() {},
+      warn() {},
+      error() {},
+      debug() {},
+      fatal() {},
+      child() { return this; },
+      level: "silent",
+    } as unknown as FeishuRuntime["logger"],
+  };
+}

hub/test/unit/file-delivery.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resolveDeliverableFile } from "../../src/feishu/fileDelivery.js";
+
+describe("file delivery path resolution", () => {
+  it("resolves a repo-root file from a project workspace only when explicitly named", async () => {
+    const root = await makeRepo();
+    try {
+      const workspace = join(root, "examples", "TH-141");
+      await writeFile(join(root, "README.md"), "# root readme\n");
+
+      await expect(resolveDeliverableFile("README.md", workspace)).resolves.toEqual({
+        path: join(root, "README.md"),
+        name: "README.md",
+      });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("resolves a bare build filename against workspace/build", async () => {
+    const root = await makeRepo();
+    try {
+      const workspace = join(root, "examples", "TH-141");
+      const pdf = join(workspace, "build", "student.pdf");
+      await writeFile(pdf, "pdf bytes");
+
+      await expect(resolveDeliverableFile("student.pdf", workspace)).resolves.toEqual({
+        path: pdf,
+        name: "student.pdf",
+      });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("does not infer files from natural-language prompts", async () => {
+    const root = await makeRepo();
+    try {
+      const workspace = join(root, "examples", "TH-141");
+      await writeFile(join(workspace, "build", "student.pdf"), "pdf bytes");
+
+      await expect(resolveDeliverableFile("cph build 生成 PDF 给我", workspace)).resolves.toBeNull();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});
+
+async function makeRepo(): Promise<string> {
+  const root = await mkdir(join(tmpdir(), `hub-file-delivery-${Date.now()}-${Math.random().toString(36).slice(2)}`), { recursive: true });
+  await mkdir(join(root, ".git"));
+  await mkdir(join(root, "examples", "TH-141", "build"), { recursive: true });
+  return root;
+}

hub/test/unit/text-stream.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { PatchableTextStream } from "../../src/feishu/textStream.js";
+
+describe("PatchableTextStream", () => {
+  it("creates only one initial message when deltas arrive while create is pending", async () => {
+    const creates: string[] = [];
+    const patches: string[] = [];
+    let resolveCreate: ((id: string) => void) | undefined;
+    const firstCreate = new Promise<string>((resolve) => {
+      resolveCreate = resolve;
+    });
+    const stream = new PatchableTextStream(
+      {
+        create: async (text) => {
+          creates.push(text);
+          return firstCreate;
+        },
+        patch: async (_messageId, text) => {
+          patches.push(text);
+        },
+      },
+      { patchIntervalMs: 0 },
+    );
+
+    stream.append("我目前运行在");
+    await Promise.resolve();
+    stream.append(" Claude Sonnet");
+    resolveCreate?.("msg-1");
+    await stream.finish("我目前运行在 Claude Sonnet");
+
+    expect(creates).toEqual(["我目前运行在"]);
+    expect(patches.at(-1)).toBe("我目前运行在 Claude Sonnet");
+  });
+
+  it("sends a fallback message when no stream delta arrived", async () => {
+    const creates: string[] = [];
+    const stream = new PatchableTextStream({
+      create: async (text) => {
+        creates.push(text);
+        return "msg-1";
+      },
+      patch: async () => {},
+    });
+
+    await stream.finish("完整回复");
+
+    expect(creates).toEqual(["完整回复"]);
+  });
+});