@downcity/agent 1.1.259 → 1.1.261

package/scripts/linux-bubblewrap-sandbox.test.mjs

@@ -1,9 +1,5 @@
 /**
- * @file 验证 Linux bubblewrap sandbox 参数生成。
- *
- * 关键点（中文）
- * - 测试编译后的 bin 输出，避免测试文件进入 package 源码导出面。
- * - 不启动真实 `bwrap`，只锁住路径挂载、网络开关与 shell 调用参数。
+ * @file 验证 Linux Bubblewrap 参数对统一 Sandbox 策略的映射。
  */
 
 import test from "node:test";
@@ -12,140 +8,61 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { buildLinuxBubblewrapArgs } from "@downcity/shell/sandbox/LinuxBubblewrapSandbox.js";
+import { build_linux_bubblewrap_args } from "@downcity/shell/sandbox/LinuxBubblewrap.js";
 
-async function createSandboxFixture() {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-bwrap-"));
-  const projectRoot = path.join(root, "project");
-  const writablePath = path.join(projectRoot, ".downcity");
-  const shellDir = path.join(writablePath, "shell", "sh_test");
-  const sandboxDir = path.join(projectRoot, ".downcity", "sandbox");
-  const tmpDir = path.join(sandboxDir, "tmp");
-  const cacheDir = path.join(sandboxDir, ".cache");
-
-  await fs.mkdir(shellDir, { recursive: true });
-  await fs.mkdir(tmpDir, { recursive: true });
-  await fs.mkdir(cacheDir, { recursive: true });
-
-  return {
-    root,
-    projectRoot,
-    writablePath,
-    shellDir,
-    sandboxDir,
-    tmpDir,
-    cacheDir,
-  };
-}
-
-function createParams(fixture, overrides = {}) {
-  return {
-    executionId: "sh_test",
-    executionDir: fixture.shellDir,
-    cmd: "printf hello",
-    cwd: fixture.projectRoot,
-    actualCwd: fixture.projectRoot,
-    shellPath: "/bin/sh",
-    login: true,
-    baseEnv: {
-      PATH: "/usr/bin:/bin",
-      LANG: "C.UTF-8",
-      DC_SESSION_ID: "session_test",
-    },
-    config: {
-      backend: "linux-bubblewrap",
-      rootPath: fixture.projectRoot,
-      sandboxDir: fixture.sandboxDir,
-      homeDir: fixture.sandboxDir,
-      tmpDir: fixture.tmpDir,
-      cacheDir: fixture.cacheDir,
-      envAllowlist: ["PATH", "LANG"],
-      writablePaths: [fixture.projectRoot, fixture.sandboxDir],
-      networkMode: "off",
-    },
-    ...overrides,
-  };
-}
-
-function hasArg(args, value) {
-  return args.includes(value);
-}
-
-function hasOptionPair(args, option, sourcePath, targetPath = sourcePath) {
+function has_option_pair(args, option, source_path, target_path = source_path) {
   for (let index = 0; index < args.length - 2; index += 1) {
     if (
       args[index] === option &&
-      args[index + 1] === sourcePath &&
-      args[index + 2] === targetPath
-    ) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function hasOptionValue(args, option, value) {
-  for (let index = 0; index < args.length - 1; index += 1) {
-    if (args[index] === option && args[index + 1] === value) {
-      return true;
-    }
+      args[index + 1] === source_path &&
+      args[index + 2] === target_path
+    ) return true;
   }
   return false;
 }
 
-test("Linux bubblewrap args isolate network and overlay writable project paths", async () => {
-  const fixture = await createSandboxFixture();
-  try {
-    const args = buildLinuxBubblewrapArgs(createParams(fixture));
-
-    assert.equal(hasArg(args, "--die-with-parent"), true);
-    assert.equal(hasArg(args, "--unshare-pid"), true);
-    assert.equal(hasArg(args, "--unshare-net"), true);
-    assert.equal(hasOptionPair(args, "--bind", fixture.projectRoot), true);
-    assert.equal(hasOptionPair(args, "--bind", fixture.sandboxDir), false);
-    assert.equal(hasOptionPair(args, "--ro-bind", fixture.projectRoot), false);
-    assert.equal(hasOptionValue(args, "--dir", fixture.writablePath), false);
-    assert.deepEqual(args.slice(-5), [
-      "--chdir",
-      fixture.projectRoot,
-      "/bin/sh",
-      "-lc",
-      "printf hello",
-    ]);
-  } finally {
-    await fs.rm(fixture.root, { recursive: true, force: true });
-  }
-});
-
-test("Linux bubblewrap args keep root writable when sandbox writablePaths includes root", async () => {
-  const fixture = await createSandboxFixture();
+test("Linux maps read paths to ro-bind and workspace to bind", async () => {
+  const fixture_root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-bwrap-"));
   try {
-    const args = buildLinuxBubblewrapArgs(createParams(fixture, {
-      config: {
+    const project_root = path.join(fixture_root, "project");
+    const tool_root = path.join(fixture_root, "tool");
+    await fs.mkdir(project_root, { recursive: true });
+    await fs.mkdir(tool_root, { recursive: true });
+    const request = {
+      execution_id: "sh_test",
+      execution_dir: path.join(project_root, ".downcity", "shell", "sh_test"),
+      cmd: "printf hello",
+      cwd: project_root,
+      shell_path: "/bin/sh",
+      login: true,
+      base_env: { PATH: "/usr/bin:/bin" },
+      policy: {
         backend: "linux-bubblewrap",
-        rootPath: fixture.projectRoot,
-        sandboxDir: fixture.sandboxDir,
-        homeDir: fixture.sandboxDir,
-        tmpDir: fixture.tmpDir,
-        cacheDir: fixture.cacheDir,
-        envAllowlist: ["PATH"],
-        writablePaths: [fixture.projectRoot],
-        networkMode: "full",
+        root_path: project_root,
+        sandbox_dir: path.join(project_root, ".downcity", "sandbox"),
+        home_dir: path.join(project_root, ".downcity", "sandbox"),
+        tmp_dir: path.join(project_root, ".downcity", "sandbox", "tmp"),
+        cache_dir: path.join(project_root, ".downcity", "sandbox", ".cache"),
+        env_allowlist: ["PATH"],
+        read_only_paths: [tool_root],
+        read_write_paths: [project_root],
+        network_mode: "off",
+        fingerprint: "policy_test",
       },
-      login: false,
-    }));
-
-    assert.equal(hasArg(args, "--unshare-net"), false);
-    assert.equal(hasOptionPair(args, "--bind", fixture.projectRoot), true);
-    assert.equal(hasOptionPair(args, "--ro-bind", fixture.projectRoot), false);
+    };
+    const args = build_linux_bubblewrap_args(request);
+    assert.equal(args.includes("--unshare-net"), true);
+    assert.equal(has_option_pair(args, "--ro-bind", tool_root), true);
+    assert.equal(has_option_pair(args, "--bind", tool_root), false);
+    assert.equal(has_option_pair(args, "--bind", project_root), true);
     assert.deepEqual(args.slice(-5), [
       "--chdir",
-      fixture.projectRoot,
+      project_root,
       "/bin/sh",
-      "-c",
+      "-lc",
       "printf hello",
     ]);
   } finally {
-    await fs.rm(fixture.root, { recursive: true, force: true });
+    await fs.rm(fixture_root, { recursive: true, force: true });
   }
 });

package/scripts/multi-agent-plugin-isolation.test.mjs

@@ -1,161 +1,100 @@
 /**
  * @file 验证多个 Agent 经 session.prompt 执行 plugin_call 时保持 registry 隔离。
  *
- * 关键点（中文）
- * - 先创建 Agent A，再创建 Agent B，锁住历史全局 runtime 的覆盖顺序。
- * - 两个 Session 并发进入模型 tool loop，验证异步作用域不会造成 registry 串线。
- * - 第二次模型请求必须收到各自 plugin action 返回的 owner。
+ * 两个 CityModel 并发进入原生 LanguageModelV3 tool loop，第二次模型调用必须只
+ * 收到各自 Agent plugin action 返回的 owner。
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import http from "node:http";
 import os from "node:os";
 import path from "node:path";
 import fs from "node:fs/promises";
+import { MockLanguageModelV3 } from "ai/test";
 
 import { Agent } from "../bin/index.js";
-import {
-  createAction,
-  createPlugin,
-} from "../bin/plugin/core/PluginActionFactory.js";
-import { CITY_MODEL_INVOKER, CITY_MODEL_KIND } from "@downcity/type";
+import { createAction, createPlugin } from "../bin/plugin/core/PluginActionFactory.js";
+import { CITY_MODEL_KIND } from "@downcity/type";
 
-/**
- * 写入一组 OpenAI-compatible SSE chunk。
- */
-function write_openai_sse(response, chunks) {
-  response.writeHead(200, {
-    "content-type": "text/event-stream; charset=utf-8",
-    "cache-control": "no-cache",
-    connection: "keep-alive",
-  });
-  for (const chunk of chunks) {
-    const payload = typeof chunk === "string" ? chunk : JSON.stringify(chunk);
-    response.write(`data: ${payload}\n\n`);
-  }
-  response.end();
+/** 构造 AI SDK V3 usage。 */
+function create_usage() {
+  return {
+    inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+    outputTokens: { total: 1, text: 1, reasoning: 0 },
+  };
 }
 
-/**
- * 读取 HTTP JSON 请求体。
- */
-async function read_json_body(request) {
-  const raw = await new Promise((resolve, reject) => {
-    let data = "";
-    request.on("data", (chunk) => {
-      data += chunk;
-    });
-    request.on("end", () => resolve(data));
-    request.on("error", reject);
-  });
-  return JSON.parse(String(raw || "{}"));
+/** 返回普通文本模型流。 */
+function create_text_stream(text) {
+  return {
+    stream: new ReadableStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: [] });
+        controller.enqueue({ type: "text-start", id: "text_1" });
+        controller.enqueue({ type: "text-delta", id: "text_1", delta: text });
+        controller.enqueue({ type: "text-end", id: "text_1" });
+        controller.enqueue({
+          type: "finish",
+          finishReason: { unified: "stop", raw: "stop" },
+          usage: create_usage(),
+        });
+        controller.close();
+      },
+    }),
+  };
 }
 
-/**
- * 返回普通文本模型流。
- */
-function write_text_response(response, input) {
-  write_openai_sse(response, [
-    {
-      id: input.id,
-      object: "chat.completion.chunk",
-      created: 1,
-      model: input.model,
-      choices: [
-        {
-          index: 0,
-          delta: { role: "assistant", content: input.text },
-          finish_reason: null,
-        },
-      ],
-    },
-    {
-      id: input.id,
-      object: "chat.completion.chunk",
-      created: 1,
-      model: input.model,
-      choices: [
-        {
-          index: 0,
-          delta: {},
-          finish_reason: "stop",
-        },
-      ],
-    },
-    "[DONE]",
-  ]);
+/** 返回一次 plugin_call tool call。 */
+function create_plugin_call_stream(model_id) {
+  const tool_input = JSON.stringify({
+    plugin: "skill",
+    action: "lookup",
+    payload: {},
+  });
+  const call_id = `call_${model_id}`;
+  return {
+    stream: new ReadableStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: [] });
+        controller.enqueue({ type: "tool-input-start", id: call_id, toolName: "plugin_call" });
+        controller.enqueue({ type: "tool-input-delta", id: call_id, delta: tool_input });
+        controller.enqueue({ type: "tool-input-end", id: call_id });
+        controller.enqueue({
+          type: "tool-call",
+          toolCallId: call_id,
+          toolName: "plugin_call",
+          input: tool_input,
+        });
+        controller.enqueue({
+          type: "finish",
+          finishReason: { unified: "tool-calls", raw: "tool_calls" },
+          usage: create_usage(),
+        });
+        controller.close();
+      },
+    }),
+  };
 }
 
-/**
- * 返回一次 plugin_call tool call。
- */
-function write_plugin_call_response(response, model) {
-  write_openai_sse(response, [
-    {
-      id: `chatcmpl_${model}_tool`,
-      object: "chat.completion.chunk",
-      created: 1,
-      model,
-      choices: [
-        {
-          index: 0,
-          delta: { role: "assistant" },
-          finish_reason: null,
-        },
-      ],
-    },
-    {
-      id: `chatcmpl_${model}_tool`,
-      object: "chat.completion.chunk",
-      created: 1,
-      model,
-      choices: [
-        {
-          index: 0,
-          delta: {
-            tool_calls: [
-              {
-                index: 0,
-                id: `call_${model}`,
-                type: "function",
-                function: {
-                  name: "plugin_call",
-                  arguments: JSON.stringify({
-                    plugin: "skill",
-                    action: "lookup",
-                    payload: {},
-                  }),
-                },
-              },
-            ],
-          },
-          finish_reason: null,
-        },
-      ],
+/** 创建原生 LanguageModelV3 CityModel。 */
+function create_test_model(model_id, model_requests) {
+  let request_count = 0;
+  const language_model = new MockLanguageModelV3({
+    modelId: model_id,
+    doStream: async (options) => {
+      if (!Array.isArray(options.tools) || options.tools.length === 0) {
+        return create_text_stream(`Title ${model_id}`);
+      }
+      request_count += 1;
+      const requests = model_requests.get(model_id) ?? [];
+      requests.push(options);
+      model_requests.set(model_id, requests);
+      return request_count === 1
+        ? create_plugin_call_stream(model_id)
+        : create_text_stream("done");
     },
-    {
-      id: `chatcmpl_${model}_tool`,
-      object: "chat.completion.chunk",
-      created: 1,
-      model,
-      choices: [
-        {
-          index: 0,
-          delta: {},
-          finish_reason: "tool_calls",
-        },
-      ],
-    },
-    "[DONE]",
-  ]);
-}
-
-/**
- * 创建绑定测试 HTTP 服务的 CityModel。
- */
-function create_test_model(base_url, model_id) {
-  return Object.freeze({
+  });
+  return Object.assign(language_model, {
     id: model_id,
     name: model_id,
     description: "Multi-agent plugin isolation model",
@@ -163,19 +102,10 @@ function create_test_model(base_url, model_id) {
     tags: [],
     meta: {},
     kind: CITY_MODEL_KIND,
-    [CITY_MODEL_INVOKER]: {
-      connection: () => ({
-        base_url,
-        api_key: "test_key",
-        model_id,
-      }),
-    },
   });
 }
 
-/**
- * 创建返回固定 owner 的 skill plugin。
- */
+/** 创建返回固定 owner 的 skill plugin。 */
 function create_owner_plugin(owner, executed_owners) {
   return createPlugin({
     name: "skill",
@@ -200,63 +130,19 @@ function create_owner_plugin(owner, executed_owners) {
 test("multiple session prompts use only their owning Agent plugin registry", async () => {
   const model_requests = new Map();
   const executed_owners = [];
-  const server = http.createServer(async (request, response) => {
-    const url = new URL(String(request.url || "/"), "http://127.0.0.1");
-    if (
-      request.method !== "POST" ||
-      url.pathname !== "/v1/ai/chat/completions"
-    ) {
-      response.writeHead(404);
-      response.end("not found");
-      return;
-    }
-
-    const body = await read_json_body(request);
-    const model = String(body.model || "");
-    if (!Array.isArray(body.tools)) {
-      write_text_response(response, {
-        id: `chatcmpl_${model}_title`,
-        model,
-        text: `Title ${model}`,
-      });
-      return;
-    }
-
-    const requests = model_requests.get(model) || [];
-    requests.push(body);
-    model_requests.set(model, requests);
-    if (requests.length === 1) {
-      write_plugin_call_response(response, model);
-      return;
-    }
-    write_text_response(response, {
-      id: `chatcmpl_${model}_done`,
-      model,
-      text: "done",
-    });
-  });
-
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const address = server.address();
-  assert.ok(address && typeof address === "object");
-  const base_url = `http://127.0.0.1:${String(address.port)}/v1/ai`;
-  const root_a = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-plugin-isolation-a-"),
-  );
-  const root_b = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-plugin-isolation-b-"),
-  );
+  const root_a = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-plugin-isolation-a-"));
+  const root_b = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-plugin-isolation-b-"));
   const agent_a = new Agent({
     id: "agent_a",
     path: root_a,
     plugins: [create_owner_plugin("agent_a", executed_owners)],
-    model: create_test_model(base_url, "model_a"),
+    model: create_test_model("model_a", model_requests),
   });
   const agent_b = new Agent({
     id: "agent_b",
     path: root_b,
     plugins: [create_owner_plugin("agent_b", executed_owners)],
-    model: create_test_model(base_url, "model_b"),
+    model: create_test_model("model_b", model_requests),
   });
 
   try {
@@ -266,24 +152,17 @@ test("multiple session prompts use only their owning Agent plugin registry", asy
       session_a.prompt({ query: "Call your skill plugin" }),
       session_b.prompt({ query: "Call your skill plugin" }),
     ]);
-    const [result_a, result_b] = await Promise.all([
-      turn_a.finished,
-      turn_b.finished,
-    ]);
+    const [result_a, result_b] = await Promise.all([turn_a.finished, turn_b.finished]);
 
     assert.equal(result_a.success, true);
     assert.equal(result_b.success, true);
     assert.deepEqual([...executed_owners].sort(), ["agent_a", "agent_b"]);
-    for (const [model, owner] of [
-      ["model_a", "agent_a"],
-      ["model_b", "agent_b"],
-    ]) {
-      const requests = model_requests.get(model) || [];
+    for (const [model_id, owner] of [["model_a", "agent_a"], ["model_b", "agent_b"]]) {
+      const requests = model_requests.get(model_id) ?? [];
       assert.equal(requests.length, 2);
-      assert.match(JSON.stringify(requests[1].messages), new RegExp(owner));
+      assert.match(JSON.stringify(requests[1].prompt), new RegExp(owner));
     }
   } finally {
     await Promise.all([agent_a.dispose(), agent_b.dispose()]);
-    await new Promise((resolve) => server.close(() => resolve()));
   }
 });