aitable-workflow-cli 0.1.22 → 0.1.23

package/dist/{config-ui-server-GSFSGBRK.js → config-ui-server-CORDAOYI.js}

@@ -1 +1 @@
-import{c as a,d as b,e as c,f as d,g as e,h as f,i as g,j as h,k as i,l as j,m as k,n as l,o as m,p as n,q as o,r as p,s as q,t as r,u as s,v as t,w as u}from"./chunk-VYYLEYUZ.js";import"./chunk-4B6V7VHM.js";import"./chunk-EI7MMDWY.js";export{h as CONSOLE_ACCESS_FILE_REL,d as PromotionHttpError,c as TriggerOnceHttpError,j as clearConsoleAccessFile,a as consoleStartPath,b as createIdleTimer,e as detectEnvironment,l as getRuntimeRunStatus,t as getSetupProgressForTest,p as handleConsolePromotion,m as handleRuntimeRunControl,n as handleTriggerWorkflowOnce,g as hasWebRoot,r as resetPromotionForTest,q as resetRuntimeRunStatusForTest,o as resetTriggerOnceForTest,f as resolveWebRoot,k as runConfigUI,u as serveStatic,s as setSetupProgressForTest,i as writeConsoleAccessFile};
+import{c as a,d as b,e as c,f as d,g as e,h as f,i as g,j as h,k as i,l as j,m as k,n as l,o as m,p as n,q as o,r as p,s as q,t as r,u as s,v as t,w as u}from"./chunk-IGB6WDLR.js";import"./chunk-4B6V7VHM.js";import"./chunk-EI7MMDWY.js";export{h as CONSOLE_ACCESS_FILE_REL,d as PromotionHttpError,c as TriggerOnceHttpError,j as clearConsoleAccessFile,a as consoleStartPath,b as createIdleTimer,e as detectEnvironment,l as getRuntimeRunStatus,t as getSetupProgressForTest,p as handleConsolePromotion,m as handleRuntimeRunControl,n as handleTriggerWorkflowOnce,g as hasWebRoot,r as resetPromotionForTest,q as resetRuntimeRunStatusForTest,o as resetTriggerOnceForTest,f as resolveWebRoot,k as runConfigUI,u as serveStatic,s as setSetupProgressForTest,i as writeConsoleAccessFile};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aitable-workflow-cli",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "aitable-workflow 命令行工具(cli):init/design/setup/run/serve 等命令;含 relay 本地反连客户端与 daemon 进程管理。bin: aitable-workflow。",
   "type": "module",
   "bin": {
@@ -19,8 +19,8 @@
     "access": "public"
   },
   "dependencies": {
-    "aitable-workflow-core": "0.1.22",
-    "aitable-workflow-server": "0.1.22",
+    "aitable-workflow-core": "0.1.23",
+    "aitable-workflow-server": "0.1.23",
     "@inquirer/prompts": "^8.5.2",
     "commander": "^14.0.2",
     "dotenv": "^17.4.2",

package/templates/support-qa/.env.example

@@ -1,5 +1,11 @@
 # LLM(知识库编译 + 答疑推理)
-IDEALAB_API_KEY=your-idealab-key
+# 沙箱模式下 qodercli 在沙箱内运行，本地不需要 IDEALAB_API_KEY；
+# 如需本地 fallback 调试可保留。
+# IDEALAB_API_KEY=your-idealab-key
+
+# Aone Sandbox 凭据（support-qa 沙箱模式必填）
+SANDBOX_API_KEY=your-sandbox-api-key
+QODER_PERSONAL_ACCESS_TOKEN=your-qoder-pat
 
 # dws CLI 需在 PATH:消息拉取(群答疑)、todo(知识缺口待办通知)
 # L2 装 config-sync 包后:群配置与管理员名单来自 globalVar(group_configs/admins)

package/templates/support-qa/coding-agents.config.json

@@ -11,7 +11,8 @@
     },
     "qoder": {
       "enabled": true,
-      "permissionMode": "bypassPermissions"
+      "permissionMode": "bypassPermissions",
+      "model": "Efficient"
     }
   }
 }

package/templates/support-qa/lib/__tests__/sandbox-agent.test.ts

@@ -0,0 +1,382 @@
+import { createHash } from "node:crypto";
+import { mkdtempSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from "vitest";
+import { unzipSync } from "fflate";
+import { SandboxManager } from "@ali/aone-sandbox";
+import { CodeInterpreter, QoderRemoteAgent, Sandbox, type SandboxClient } from "@ali/aone-remote-agent";
+import { SupportQaSandboxAgentPool, runSandboxAgent, stopSandboxAgentPool } from "../sandbox-agent.js";
+
+vi.mock("@ali/aone-sandbox", () => ({
+  SandboxManager: { create: vi.fn() },
+}));
+
+vi.mock("@ali/aone-remote-agent", () => ({
+  CodeInterpreter: { fromSandbox: vi.fn() },
+  QoderRemoteAgent: vi.fn(),
+  Sandbox: { create: vi.fn() },
+}));
+
+const createMockAcpClient = () => {
+  const listeners = new Set<(update: { sessionId: string; update: Record<string, unknown>; raw: Record<string, unknown> }) => void>();
+  const emitText = (sessionId: string, text: string) => {
+    listeners.forEach((listener) =>
+      listener({
+        sessionId,
+        update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text } },
+        raw: {},
+      }),
+    );
+  };
+  return {
+    newAcpSession: vi.fn().mockResolvedValue("session-1"),
+    query: vi.fn().mockImplementation(async (_prompt: string, sessionId: string) => {
+      emitText(sessionId, '{"action":"reply","reply":"hi"}');
+      return { stopReason: "end_turn", raw: {} };
+    }),
+    addUpdateListener: vi.fn().mockImplementation((listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }),
+    closeAcpSession: vi.fn().mockResolvedValue(undefined),
+    _emitText: emitText,
+  };
+};
+
+const createMockAgent = (sandbox: SandboxClient) => {
+  const client = createMockAcpClient();
+  return {
+    start: vi.fn().mockResolvedValue(undefined),
+    stop: vi.fn().mockResolvedValue(undefined),
+    sandbox: vi.fn().mockReturnValue(sandbox),
+    client: vi.fn().mockReturnValue(client),
+    _client: client,
+  };
+};
+
+function createLocalWorkspace(): { root: string; workDir: string; indexPath: string; mediaDir: string } {
+  const root = mkdtempSync(path.join(tmpdir(), "support-qa-sandbox-"));
+  const workDir = path.join(root, "workspaces", "support");
+  const compiledWiki = path.join(root, "wiki", "faq-support", ".kb", "wiki");
+  const mediaDir = path.join(root, ".aitable", "media", "dingtalk");
+  mkdirSync(path.join(workDir, "wiki"), { recursive: true });
+  mkdirSync(compiledWiki, { recursive: true });
+  mkdirSync(mediaDir, { recursive: true });
+  writeFileSync(path.join(workDir, "AGENTS.md"), "agent instructions");
+  writeFileSync(path.join(workDir, "owner-map.json"), "{}");
+  writeFileSync(path.join(root, "coding-agents.config.json"), JSON.stringify({
+    version: 1,
+    agents: { qoder: { enabled: true, model: "ConfiguredModel" } },
+  }));
+  writeFileSync(path.join(compiledWiki, "_index.md"), "# first index");
+  symlinkSync(compiledWiki, path.join(workDir, "wiki", "faq-support"), process.platform === "win32" ? "junction" : "dir");
+  return { root, workDir, indexPath: path.join(compiledWiki, "_index.md"), mediaDir };
+}
+
+function createRawSandbox(id: string) {
+  return {
+    id,
+    connectionConfig: { getBaseUrl: vi.fn().mockReturnValue("https://sandbox.test"), apiKey: "test-api-key" },
+    getEndpoint: vi.fn().mockResolvedValue({ endpoint: "https://endpoint.test", headers: {} }),
+    kill: vi.fn().mockResolvedValue(undefined),
+    close: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+describe("runSandboxAgent", () => {
+  const originalEnv = process.env;
+  let local: ReturnType<typeof createLocalWorkspace>;
+  let manager: { listSandboxInfos: Mock; killSandbox: Mock; close: Mock };
+  let mockInterpreter: {
+    commands: { run: Mock };
+    files: { readFile: Mock; writeFiles: Mock };
+  };
+  let rawSandboxes: ReturnType<typeof createRawSandbox>[];
+  let agents: ReturnType<typeof createMockAgent>[];
+  let configureAgent: (agent: ReturnType<typeof createMockAgent>) => void;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv, SANDBOX_API_KEY: "test-api-key", QODER_PERSONAL_ACCESS_TOKEN: "test-pat" };
+    local = createLocalWorkspace();
+    manager = {
+      listSandboxInfos: vi.fn().mockResolvedValue({ items: [] }),
+      killSandbox: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+    mockInterpreter = {
+      commands: { run: vi.fn().mockResolvedValue({ exitCode: 0, logs: { stdout: [], stderr: [] } }) },
+      files: {
+        readFile: vi.fn(),
+        writeFiles: vi.fn().mockResolvedValue(undefined),
+      },
+    };
+    rawSandboxes = [];
+    agents = [];
+    configureAgent = () => {};
+
+    vi.mocked(SandboxManager.create).mockReturnValue(manager as unknown as SandboxManager);
+    vi.mocked(Sandbox.create).mockImplementation(async () => {
+      const sandbox = createRawSandbox(`sandbox-${rawSandboxes.length + 1}`);
+      rawSandboxes.push(sandbox);
+      return sandbox as unknown as Sandbox;
+    });
+    vi.mocked(CodeInterpreter.fromSandbox).mockResolvedValue(
+      mockInterpreter as unknown as Awaited<ReturnType<typeof CodeInterpreter.fromSandbox>>,
+    );
+    vi.mocked(QoderRemoteAgent).mockImplementation((sandbox) => {
+      const agent = createMockAgent(sandbox as SandboxClient);
+      configureAgent(agent);
+      agents.push(agent);
+      return agent as unknown as QoderRemoteAgent;
+    });
+  });
+
+  afterEach(async () => {
+    await stopSandboxAgentPool(() => {});
+    rmSync(local.root, { recursive: true, force: true });
+    process.env = originalEnv;
+    vi.clearAllMocks();
+  });
+
+  it("缺少 SANDBOX_API_KEY 时抛出可读错误", async () => {
+    delete process.env.SANDBOX_API_KEY;
+    await expect(runSandboxAgent("prompt", local.workDir, () => {})).rejects.toThrow("SANDBOX_API_KEY");
+  });
+
+  it("缺少 QODER_PERSONAL_ACCESS_TOKEN 时抛出可读错误", async () => {
+    delete process.env.QODER_PERSONAL_ACCESS_TOKEN;
+    await expect(runSandboxAgent("prompt", local.workDir, () => {})).rejects.toThrow("QODER_PERSONAL_ACCESS_TOKEN");
+  });
+
+  it("创建三个独立 Sandbox、预装 qodercli 并返回 ACP 文本与会话标识", async () => {
+    const logs: string[] = [];
+    const result = await runSandboxAgent("prompt", local.workDir, (message) => logs.push(message));
+
+    expect(Sandbox.create).toHaveBeenCalledTimes(3);
+    for (let index = 0; index < 3; index++) {
+      expect(Sandbox.create).toHaveBeenNthCalledWith(index + 1, expect.objectContaining({
+        template: "code-interpreter",
+        metadata: expect.objectContaining({ slot: String(index + 1) }),
+      }));
+    }
+    expect(QoderRemoteAgent).toHaveBeenCalledTimes(3);
+    expect(QoderRemoteAgent).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ model: "ConfiguredModel" }),
+      "/workspace",
+      false,
+    );
+    expect(agents.every((agent) => agent.start.mock.calls.length === 1)).toBe(true);
+
+    const commands = mockInterpreter.commands.run.mock.calls.map(([command]) => String(command));
+    expect(commands.filter((command) => command.includes("@qoder-ai/qodercli"))).toHaveLength(3);
+    expect(commands.some((command) => command.includes("python3 -c"))).toBe(true);
+    expect(commands.some((command) => command.includes("ln -s /workspace/.kb/faq-support/"))).toBe(true);
+
+    const uploaded = mockInterpreter.files.writeFiles.mock.calls[0][0] as Array<{ path: string; data: Uint8Array }>;
+    expect(uploaded).toEqual(expect.arrayContaining([
+      expect.objectContaining({ path: "/workspace/.request/AGENTS.md" }),
+      expect.objectContaining({ path: "/workspace/.request/owner-map.json" }),
+    ]));
+    const archive = uploaded.find((entry) => entry.path.endsWith(".zip"));
+    expect(archive).toBeDefined();
+    const archiveFiles = unzipSync(archive!.data);
+    expect(new TextDecoder().decode(archiveFiles["wiki/_index.md"])).toBe("# first index");
+
+    expect(agents[0]._client.newAcpSession).toHaveBeenCalledWith("/workspace");
+    expect(agents[0]._client.query).toHaveBeenCalledWith("prompt", "session-1");
+    expect(result).toMatchObject({ sandboxId: "sandbox-1", sessionId: "session-1" });
+    expect(result.response).toContain('"action":"reply"');
+    expect(logs).toContain("沙箱：ACP Session 已创建 sandboxId=sandbox-1 sessionId=session-1");
+  });
+
+  it("启动时清理同 workspace 的全部遗留 Sandbox", async () => {
+    manager.listSandboxInfos.mockResolvedValue({
+      items: [{ id: "old-1" }, { id: "old-2" }],
+    });
+    const pool = new SupportQaSandboxAgentPool(2);
+    try {
+      await pool.run("prompt", local.workDir, () => {});
+      expect(manager.listSandboxInfos).toHaveBeenCalledWith(expect.objectContaining({
+        states: ["Running"],
+        metadata: expect.objectContaining({ application: "aitable-agent", workload: "support-qa" }),
+      }));
+      expect(manager.killSandbox).toHaveBeenCalledTimes(2);
+      expect(manager.killSandbox).toHaveBeenCalledWith("old-1");
+      expect(manager.killSandbox).toHaveBeenCalledWith("old-2");
+      expect(Sandbox.create).toHaveBeenCalledTimes(2);
+    } finally {
+      await pool.stop(() => {});
+    }
+  });
+
+  it("同一进程的后续请求复用已启动的 Sandbox 池", async () => {
+    const pool = new SupportQaSandboxAgentPool(2);
+    try {
+      await pool.run("first", local.workDir, () => {});
+      await pool.run("second", local.workDir, () => {});
+      expect(manager.listSandboxInfos).toHaveBeenCalledTimes(1);
+      expect(Sandbox.create).toHaveBeenCalledTimes(2);
+      expect(QoderRemoteAgent).toHaveBeenCalledTimes(2);
+      expect(agents[0]._client.query).toHaveBeenCalledTimes(2);
+      expect(pool.status()).toMatchObject({
+        capacity: 2,
+        busy: 0,
+        idle: 2,
+        sandboxIds: ["sandbox-1", "sandbox-2"],
+      });
+    } finally {
+      await pool.stop(() => {});
+    }
+  });
+
+  it("生命周期重建先释放旧 Sandbox，再创建替代实例", async () => {
+    const pool = new SupportQaSandboxAgentPool(1);
+    try {
+      await pool.run("first", local.workDir, () => {});
+      const firstSandbox = rawSandboxes[0];
+
+      await (pool as unknown as { rebuild(log: (message: string) => void): Promise<void> }).rebuild(() => {});
+
+      expect(Sandbox.create).toHaveBeenCalledTimes(2);
+      expect(firstSandbox.kill).toHaveBeenCalledTimes(1);
+      expect(firstSandbox.kill.mock.invocationCallOrder[0]).toBeLessThan(
+        vi.mocked(Sandbox.create).mock.invocationCallOrder[1],
+      );
+      expect(pool.status().sandboxIds).toEqual(["sandbox-2"]);
+    } finally {
+      await pool.stop(() => {});
+    }
+  });
+
+  it("上传消息图片并重写 prompt，忽略远程 URL 与目录外路径", async () => {
+    const imageData = Buffer.from("local image");
+    const localImage = path.join(local.mediaDir, "question.PNG");
+    const outsideImage = path.join(local.root, "outside.png");
+    writeFileSync(localImage, imageData);
+    writeFileSync(outsideImage, "outside");
+    const digest = createHash("sha256").update(imageData).digest("hex").slice(0, 20);
+    const sandboxImage = `/workspace/.media/${digest}.png`;
+    const remoteImage = "https://example.test/image.png";
+    const prompt = [
+      `第一张 ![图片](${localImage})`,
+      `重复引用 ![图片](<${localImage}>)`,
+      `远程图片 ![图片](${remoteImage})`,
+      `目录外图片 ![图片](${outsideImage})`,
+    ].join("\n");
+    const logs: string[] = [];
+
+    await runSandboxAgent(prompt, local.workDir, (message) => logs.push(message));
+
+    const imageUploads = mockInterpreter.files.writeFiles.mock.calls
+      .flatMap(([entries]) => entries as Array<{ path: string; data: Uint8Array }>)
+      .filter((entry) => entry.path.startsWith("/workspace/.media/"));
+    expect(imageUploads).toHaveLength(1);
+    expect(imageUploads[0]).toEqual({ path: sandboxImage, data: imageData });
+
+    const rewrittenPrompt = agents[0]._client.query.mock.calls[0][0] as string;
+    expect(rewrittenPrompt.match(new RegExp(sandboxImage, "g"))).toHaveLength(2);
+    expect(rewrittenPrompt).not.toContain(localImage);
+    expect(rewrittenPrompt).toContain(remoteImage);
+    expect(rewrittenPrompt).toContain(outsideImage);
+    expect(logs).toContain("沙箱：已同步消息图片 1 张");
+  });
+
+  it("知识库未变化时不重复上传归档，内容变化后上传新版本", async () => {
+    await runSandboxAgent("p1", local.workDir, () => {});
+    await runSandboxAgent("p2", local.workDir, () => {});
+    writeFileSync(local.indexPath, "# second index");
+    await runSandboxAgent("p3", local.workDir, () => {});
+
+    const archives = mockInterpreter.files.writeFiles.mock.calls.flatMap(([entries]) =>
+      (entries as Array<{ path: string }>).filter((entry) => entry.path.endsWith(".zip")),
+    );
+    expect(archives).toHaveLength(2);
+    expect(archives[0].path).not.toBe(archives[1].path);
+  });
+
+  it("status 反映当前并发占用", async () => {
+    let resolveQuery: ((value: { stopReason: string; raw: { text: string } }) => void) | undefined;
+    configureAgent = (agent) => {
+      agent._client.addUpdateListener.mockImplementation(() => () => {});
+      agent._client.query.mockImplementation(() => new Promise((resolve) => {
+        resolveQuery = resolve;
+      }));
+    };
+    const pool = new SupportQaSandboxAgentPool(1);
+    const running = pool.run("prompt", local.workDir, () => {});
+    await vi.waitFor(() => expect(agents[0]._client.query).toHaveBeenCalledTimes(1));
+    expect(pool.status()).toMatchObject({ capacity: 1, busy: 1, idle: 0, sandboxIds: ["sandbox-1"] });
+
+    resolveQuery?.({ stopReason: "end_turn", raw: { text: "done" } });
+    await running;
+    expect(pool.status()).toMatchObject({ capacity: 1, busy: 0, idle: 1 });
+    await pool.stop(() => {});
+  });
+
+  it("ACP 查询失败时在错误中保留模型已输出的内容", async () => {
+    configureAgent = (agent) => {
+      agent._client.query.mockImplementation(async (_prompt: string, sessionId: string) => {
+        agent._client._emitText(sessionId, "partial model output");
+        throw new Error("connection reset");
+      });
+    };
+    const pool = new SupportQaSandboxAgentPool(1);
+    await expect(pool.run("prompt", local.workDir, () => {})).rejects.toThrow(
+      'responseLength=20, response="partial model output", error=connection reset',
+    );
+    await pool.stop(() => {});
+  });
+
+  it("Agent 返回空响应时抛出错误", async () => {
+    configureAgent = (agent) => {
+      agent._client.query.mockResolvedValue({ stopReason: "end_turn", raw: {} });
+      agent._client.addUpdateListener.mockImplementation(() => () => {});
+    };
+    const pool = new SupportQaSandboxAgentPool(1);
+    await expect(pool.run("prompt", local.workDir, () => {})).rejects.toThrow("空响应");
+    await pool.stop(() => {});
+  });
+});
+
+describe("stopSandboxAgentPool", () => {
+  it("停止时释放每个 Agent 与 Sandbox", async () => {
+    process.env = { ...process.env, SANDBOX_API_KEY: "k", QODER_PERSONAL_ACCESS_TOKEN: "p" };
+    const local = createLocalWorkspace();
+    const interpreter = {
+      commands: { run: vi.fn().mockResolvedValue({ exitCode: 0, logs: { stdout: [], stderr: [] } }) },
+      files: { readFile: vi.fn(), writeFiles: vi.fn().mockResolvedValue(undefined) },
+    };
+    const sandboxes = [createRawSandbox("sandbox-a"), createRawSandbox("sandbox-b")];
+    const agents: ReturnType<typeof createMockAgent>[] = [];
+    vi.mocked(SandboxManager.create).mockReturnValue({
+      listSandboxInfos: vi.fn().mockResolvedValue({ items: [] }),
+      killSandbox: vi.fn(),
+      close: vi.fn().mockResolvedValue(undefined),
+    } as unknown as SandboxManager);
+    vi.mocked(Sandbox.create).mockImplementation(async () => sandboxes.shift() as unknown as Sandbox);
+    vi.mocked(CodeInterpreter.fromSandbox).mockResolvedValue(
+      interpreter as unknown as Awaited<ReturnType<typeof CodeInterpreter.fromSandbox>>,
+    );
+    vi.mocked(QoderRemoteAgent).mockImplementation((sandbox) => {
+      const agent = createMockAgent(sandbox as SandboxClient);
+      agents.push(agent);
+      return agent as unknown as QoderRemoteAgent;
+    });
+
+    const pool = new SupportQaSandboxAgentPool(2);
+    const ownedSandboxes = [...sandboxes];
+    try {
+      await pool.run("p", local.workDir, () => {});
+      await pool.stop(() => {});
+      expect(agents.every((agent) => agent.stop.mock.calls.length === 1)).toBe(true);
+      expect(ownedSandboxes.every((sandbox) => sandbox.kill.mock.calls.length === 1)).toBe(true);
+      expect(ownedSandboxes.every((sandbox) => sandbox.close.mock.calls.length === 1)).toBe(true);
+    } finally {
+      rmSync(local.root, { recursive: true, force: true });
+      await pool.stop(() => {});
+      await stopSandboxAgentPool(() => {});
+    }
+  });
+});