@downcity/agent 1.1.337 → 1.1.399

package/city-test/agent-http.test.mjs

@@ -0,0 +1,326 @@
+/**
+ * @file 验证独立 AgentHTTP 与 RemoteAgent 的核心 HTTP 契约。
+ *
+ * 关键点（中文）
+ * - events 必须转发统一 SessionMutation，RemoteSession 的 turn.finished 才能结束。
+ * - AgentHTTP 必须暴露 RemoteAgent 的 plugin action 路由，不能只提供 session 路由。
+ */
+
+import assert from "node:assert/strict";
+import net from "node:net";
+import test from "node:test";
+import { RemoteAgent } from "../bin/index.js";
+import { AgentHTTP } from "../bin/city/transport/http/AgentHTTP.js";
+
+const network_tests_enabled = process.env.DOWNCITY_RUN_NETWORK_TESTS === "1";
+
+async function reserve_port() {
+  const server = net.createServer();
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : 0;
+  await new Promise((resolve, reject) => {
+    server.close((error) => (error ? reject(error) : resolve()));
+  });
+  return port;
+}
+
+function create_fake_agent() {
+  const subscribers = new Set();
+  let compact_count = 0;
+  let approval_mode = "ask";
+  const set_calls = [];
+  const info = {
+    agent_id: "http-test-agent",
+    session_id: "http-test-session",
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  };
+  const session = {
+    async get_info() {
+      return info;
+    },
+    async prompt() {
+      queueMicrotask(() => {
+        for (const subscriber of subscribers) {
+          subscriber({
+            mutation_id: "turn-start-http-test",
+            variant: "turn",
+            type: "start",
+            session_id: info.session_id,
+            turn_id: "turn-http-test",
+            status: "running",
+            created_at: Date.now(),
+          });
+          subscriber({
+            variant: "delta",
+            type: "text",
+            mutation_id: "mutation-http-test",
+            message_id: "message-http-test",
+            revision: 1,
+            session_id: info.session_id,
+            turn_id: "turn-http-test",
+            created_at: Date.now(),
+            part_id: "part-http-test",
+            delta: "HTTP transport works",
+          });
+          subscriber({
+            mutation_id: "approval-http-mutation",
+            variant: "part",
+            type: "interaction",
+            session_id: info.session_id,
+            turn_id: "turn-http-test",
+            message_id: "message-http-test",
+            revision: 2,
+            created_at: Date.now(),
+            part_id: "interaction:interaction-http-test",
+            part: {
+              part_id: "interaction:interaction-http-test",
+              sequence: 2,
+              type: "interaction",
+              interaction_id: "interaction-http-test",
+              interaction_type: "approval",
+              status: "pending",
+              request: {
+                interaction_id: "interaction-http-test",
+                turn_id: "turn-http-test",
+                type: "approval",
+                source: {
+                  type: "tool",
+                  tool_call_id: "call-http-test",
+                  tool_name: "shell_exec",
+                },
+                title: "Approve shell_exec",
+                payload: { command: "pwd", cwd: "/tmp", reason: "test", operation: "exec" },
+                created_at: Date.now(),
+                expires_at: Date.now() + 60_000,
+              },
+            },
+          });
+          subscriber({
+            mutation_id: "turn-finish-http-test",
+            variant: "turn",
+            type: "finish",
+            session_id: info.session_id,
+            turn_id: "turn-http-test",
+            status: "completed",
+            created_at: Date.now(),
+            text: "HTTP transport works",
+          });
+        }
+      });
+      return { id: "turn-http-test" };
+    },
+    subscribe(subscriber) {
+      subscribers.add(subscriber);
+      return () => subscribers.delete(subscriber);
+    },
+    async set(input, options) {
+      set_calls.push({ input, options });
+      if (input.security?.approval_mode) {
+        approval_mode = input.security.approval_mode;
+      }
+    },
+    async stop() {
+      return { stopped: false, cancelled_queued_prompts: 0, reason: "idle" };
+    },
+    async compact() {
+      compact_count += 1;
+      const compact_id = "compact-http-test";
+      queueMicrotask(() => {
+        for (const subscriber of subscribers) {
+          subscriber({
+            mutation_id: "compact-finish-http-test",
+            variant: "compact",
+            type: "finish",
+            session_id: info.session_id,
+            compact_id,
+            status: "completed",
+            compacted: false,
+            reason: "nothing_to_compact",
+            created_at: Date.now(),
+          });
+        }
+      });
+      return { id: compact_id };
+    },
+    async messages() {
+      return { items: [], total: 0, source: "active", has_more: false };
+    },
+    async system() {
+      return { session_id: info.session_id, session: info, blocks: [] };
+    },
+    async interactions() {
+      return [{
+        request: {
+          interaction_id: "interaction-http-test",
+          turn_id: "turn-http-test",
+          type: "approval",
+          source: { type: "tool", tool_call_id: "call-http-test", tool_name: "shell_exec" },
+          title: "Approve shell_exec",
+          payload: { command: "pwd", cwd: "/tmp", reason: "test", operation: "exec" },
+          created_at: Date.now(),
+        },
+      }];
+    },
+    async status() {
+      return {
+        session_id: info.session_id,
+        state: "idle",
+        security: {
+          approval_mode,
+          effective_approval_mode: "ask",
+        },
+      };
+    },
+    async respond({ interaction_id, response }) {
+      return { status: "resolved", interaction_id, response };
+    },
+    async fork() {
+      return session;
+    },
+  };
+  return {
+    read_compact_count() {
+      return compact_count;
+    },
+    read_set_calls() {
+      return structuredClone(set_calls);
+    },
+    sessions: {
+      async list() {
+        return { items: [info], has_more: false };
+      },
+      async create() {
+        return session;
+      },
+      async get() {
+        return session;
+      },
+      async archive() {
+        return { session_id: info.session_id, archived_at: new Date().toISOString() };
+      },
+      async archived() {
+        return { items: [], has_more: false };
+      },
+      async clean_archive() {
+        return { removed_session_ids: [] };
+      },
+    },
+    plugins: {
+      async run_action({ plugin, action, payload }) {
+        return { success: true, data: { plugin, action, payload } };
+      },
+    },
+  };
+}
+
+test("AgentHTTP resolves RemoteAgent turns and exposes plugin actions", {
+  skip: !network_tests_enabled,
+}, async () => {
+  const port = await reserve_port();
+  const fake_agent = create_fake_agent();
+  let resolved_model_id = "";
+  const http = new AgentHTTP(fake_agent, {
+    resolve_session_model: (model_id) => {
+      resolved_model_id = model_id;
+      return { modelId: model_id, provider: "test" };
+    },
+  });
+  const remote_agent = new RemoteAgent({ url: `http://127.0.0.1:${port}` });
+  try {
+    await http.server().listen({ host: "127.0.0.1", port });
+    const session = await remote_agent.sessions.create();
+    const mutations = [];
+    let approval_decision;
+    const unsubscribe = session.subscribe((mutation) => {
+      mutations.push(mutation);
+      if (
+        mutation.variant === "part" &&
+        mutation.type === "interaction" &&
+        mutation.part.status === "pending"
+      ) {
+        approval_decision = session.respond({
+          interaction_id: mutation.part.interaction_id,
+          response: { type: "approval", payload: { decision: "approved" } },
+        });
+      }
+    });
+    const turn = await session.prompt({ query: "test" });
+    const result = await turn.finished;
+
+    assert.equal(result.success, true);
+    assert.equal(result.text, "HTTP transport works");
+    assert.deepEqual(mutations.map((mutation) => mutation.variant), ["turn", "delta", "part", "turn"]);
+    assert.equal(mutations[1].delta, "HTTP transport works");
+    assert.deepEqual(await approval_decision, {
+      status: "resolved",
+      interaction_id: "interaction-http-test",
+      response: { type: "approval", payload: { decision: "approved" } },
+    });
+
+    assert.equal((await session.interactions())[0].request.interaction_id, "interaction-http-test");
+    await session.set(
+      { security: { approval_mode: "always-allow" } },
+      { persist_action: false, publish_mutation: false },
+    );
+    await session.set({ model_id: "http-selected-model" });
+    assert.equal(resolved_model_id, "http-selected-model");
+    assert.deepEqual(fake_agent.read_set_calls(), [
+      {
+        input: { security: { approval_mode: "always-allow" } },
+        options: { persist_action: false, publish_mutation: false },
+      },
+      {
+        input: { model: { modelId: "http-selected-model", provider: "test" } },
+        options: {},
+      },
+    ]);
+    assert.deepEqual((await session.status()).security, {
+      approval_mode: "always-allow",
+      effective_approval_mode: "ask",
+    });
+    assert.deepEqual(
+      await session.respond({
+        interaction_id: "interaction-http-test",
+        response: { type: "approval", payload: { decision: "approved" } },
+      }),
+      {
+        status: "resolved",
+        interaction_id: "interaction-http-test",
+        response: { type: "approval", payload: { decision: "approved" } },
+      },
+    );
+    const compact = await session.compact();
+    assert.deepEqual(await compact.finished, {
+      compact_id: "compact-http-test",
+      success: true,
+      compacted: false,
+      reason: "nothing_to_compact",
+    });
+    assert.equal(fake_agent.read_compact_count(), 1);
+
+    const action = await remote_agent.run_plugin_action({
+      plugin: "demo",
+      action: "echo",
+      payload: { text: "hello" },
+    });
+    assert.deepEqual(action, {
+      success: true,
+      data: {
+        plugin: "demo",
+        action: "echo",
+        payload: { text: "hello" },
+      },
+      plugin_name: "demo",
+      action_name: "echo",
+    });
+    unsubscribe();
+  } finally {
+    await remote_agent.close();
+    await http.close();
+  }
+});

package/city-test/city-container.test.mjs

@@ -0,0 +1,156 @@
+/** 验证 City 只管理已实例化 Agent 的内存索引与 transport。 */
+
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { Agent } from "../bin/index.js";
+import { Workspace } from "../../workspace/bin/index.js";
+import { City } from "../bin/index.js";
+
+/** 创建临时运行时 Agent。 */
+async function create_agent(root, agent_id) {
+  const workspace_path = path.join(root, agent_id);
+  await fs.mkdir(workspace_path, { recursive: true });
+  return new Workspace({ id: agent_id, path: workspace_path, data_root_path: path.join(workspace_path, "data") });
+}
+
+test("Agent 绑定 City 后可使用 City Workspace 并拒绝重复 ID", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-city-add-"));
+  const first_workspace = await create_agent(root, "first");
+  const city = new City({ workspaces: [first_workspace] });
+  const first = new Agent({ id: "first" });
+  city.agents.add(first);
+  try {
+    assert.equal(city.agents.get("first"), first);
+    assert.throws(() => city.agents.add(new Agent({ id: "first" })), /already exists/u);
+    assert.equal(city.agents.get("missing"), null);
+    const session = await first.sessions.create({ workspace: first_workspace });
+    assert.equal(session.agent_id, first.id);
+  } finally {
+    await city.close();
+    await first.dispose();
+    await first_workspace.dispose();
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});
+
+test("Agent 创建无 City Session 后不能再切换到 City 存储", async () => {
+  const agent = new Agent({ id: "memory-first-agent" });
+  const city = new City();
+  try {
+    await agent.sessions.create();
+    assert.throws(
+      () => city.agents.add(agent),
+      /already created Session data without City/u,
+    );
+  } finally {
+    await agent.dispose();
+    await city.close();
+  }
+});
+
+test("City 运行时添加 Workspace 后 Agent 可以进入", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-city-workspace-add-"));
+  const workspace_path = path.join(root, "runtime");
+  await fs.mkdir(workspace_path, { recursive: true });
+  const city = new City();
+  const agent = new Agent({ id: "runtime-agent" });
+  city.agents.add(agent);
+  const workspace = new Workspace({
+    id: "runtime-workspace",
+    path: workspace_path,
+    data_root_path: path.join(root, "data"),
+  });
+  try {
+    assert.equal(city.workspaces.add(workspace), workspace);
+    assert.equal(city.workspaces.get(workspace.id), workspace);
+    assert.deepEqual(city.workspaces.list(), [workspace]);
+    assert.equal((await agent.sessions.create({ workspace })).agent_id, agent.id);
+  } finally {
+    await city.close();
+    await agent.dispose();
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});
+
+test("City.close 释放绑定 Agent 与 City Workspace", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-city-close-"));
+  const workspace = await create_agent(root, "owned");
+  const city = new City({ workspaces: [workspace] });
+  const agent = new Agent({ id: "owned" });
+  city.agents.add(agent);
+  try {
+    await city.close();
+    assert.equal(city.agents.get("owned"), null);
+    await city.close();
+    await city.close();
+    assert.equal(city.agents.get("owned"), null);
+  } finally {
+    await agent.dispose();
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});
+
+test("City.close 后拒绝继续添加 Agent 或 Workspace", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-city-closed-"));
+  const workspace_path = path.join(root, "workspace");
+  await fs.mkdir(workspace_path, { recursive: true });
+  const city = new City();
+  await city.close();
+  assert.throws(() => city.agents.add(new Agent({ id: "closed-agent" })), /City is closed/u);
+  assert.throws(() => city.workspaces.add(new Workspace({ id: "closed-workspace", path: workspace_path })), /City is closed/u);
+  assert.equal(city.agents.list().length, 0);
+  assert.equal(city.workspaces.list().length, 0);
+  await fs.rm(root, { recursive: true, force: true });
+});
+
+test("Agent dispose 解除 City 运行时绑定", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-city-remove-"));
+  const workspace = await create_agent(root, "retry_remove");
+  const city = new City({ workspaces: [workspace] });
+  const agent = new Agent({ id: "retry_remove" });
+  city.agents.add(agent);
+  try {
+    assert.equal(city.agents.get(agent.id), agent);
+    await agent.dispose();
+    assert.equal(city.agents.get(agent.id), null);
+  } finally {
+    await city.close();
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});
+
+test("City.listen 失败只回滚本次新启动的 transport", async () => {
+  const city = new City();
+  let rpc_listen_count = 0;
+  let rpc_close_count = 0;
+  let rpc_binding = null;
+  city.rpc_transport.listen = async () => {
+    rpc_listen_count += 1;
+    rpc_binding ??= { url: "rpc://127.0.0.1:15314", host: "127.0.0.1", port: 15314 };
+    return rpc_binding;
+  };
+  city.rpc_transport.binding = () => rpc_binding;
+  city.rpc_transport.close = async () => {
+    rpc_close_count += 1;
+    rpc_binding = null;
+  };
+  city.http_transport.listen = async () => {
+    throw new Error("http unavailable");
+  };
+  city.http_transport.binding = () => null;
+
+  await city.listen({ rpc: { port: 15314 } });
+  await assert.rejects(
+    city.listen({ rpc: { port: 15314 }, http: { port: 5314 } }),
+    /http unavailable/u,
+  );
+  assert.equal(rpc_listen_count, 2);
+  assert.equal(rpc_close_count, 0);
+  assert.notEqual(rpc_binding, null);
+
+  await city.close();
+  assert.equal(rpc_close_count, 1);
+});

package/city-test/city-host-registry.test.mjs

@@ -0,0 +1,68 @@
+/** 验证 CLI 与 Desktop 共用的 City 宿主所有权协议。 */
+
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import {
+  create_city_host_instance_id,
+  get_city_host_state_path,
+  read_city_host_state,
+  register_city_host,
+  unregister_city_host,
+} from "../bin/index.js";
+
+test("City 宿主登记拒绝覆盖活跃实例并按 instance_id 注销", async () => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-city-host-"));
+  const previous_root_path = process.env.DC_PLATFORM_ROOT;
+  process.env.DC_PLATFORM_ROOT = root_path;
+  const first_instance_id = create_city_host_instance_id();
+  const second_instance_id = create_city_host_instance_id();
+  try {
+    await register_city_host({
+      owner: "cli",
+      pid: process.pid,
+      instance_id: first_instance_id,
+      started_at: new Date().toISOString(),
+    });
+    assert.equal((await read_city_host_state())?.instance_id, first_instance_id);
+    await assert.rejects(register_city_host({
+      owner: "desktop",
+      pid: process.pid,
+      instance_id: second_instance_id,
+      started_at: new Date().toISOString(),
+    }), /already owned by cli/u);
+
+    await unregister_city_host(second_instance_id);
+    assert.equal((await read_city_host_state())?.instance_id, first_instance_id);
+    await unregister_city_host(first_instance_id);
+    assert.equal(await read_city_host_state(), null);
+  } finally {
+    if (previous_root_path === undefined) delete process.env.DC_PLATFORM_ROOT;
+    else process.env.DC_PLATFORM_ROOT = previous_root_path;
+    await fs.rm(root_path, { recursive: true, force: true });
+  }
+});
+
+test("City 宿主读取会清理已退出进程留下的状态", async () => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-city-host-stale-"));
+  const previous_root_path = process.env.DC_PLATFORM_ROOT;
+  process.env.DC_PLATFORM_ROOT = root_path;
+  try {
+    const file_path = get_city_host_state_path();
+    await fs.mkdir(path.dirname(file_path), { recursive: true });
+    await fs.writeFile(file_path, JSON.stringify({
+      owner: "desktop",
+      pid: 2_147_483_647,
+      instance_id: create_city_host_instance_id(),
+      started_at: new Date().toISOString(),
+    }), "utf8");
+    assert.equal(await read_city_host_state(), null);
+    await assert.rejects(fs.access(file_path));
+  } finally {
+    if (previous_root_path === undefined) delete process.env.DC_PLATFORM_ROOT;
+    else process.env.DC_PLATFORM_ROOT = previous_root_path;
+    await fs.rm(root_path, { recursive: true, force: true });
+  }
+});