@downcity/plugins 1.0.253 → 1.0.280

package/scripts/memory-plugin.test.mjs

@@ -0,0 +1,204 @@
+/**
+ * MemoryPlugin Provider 与本地 Adapter 回归测试。
+ *
+ * 关键点（中文）
+ * - MemoryPlugin 只委托 Provider，不读取 Workspace 文件。
+ * - Builtin Provider 只公开 memory_id/citation，不泄漏物理路径。
+ * - File Adapter 始终把逻辑 key 限制在独占根目录。
+ */
+
+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 {
+  BuiltinMemoryProvider,
+  FileMemoryStorageAdapter,
+  MemoryPlugin,
+  get_default_file_memory_root_path,
+} from "@downcity/plugins/memory";
+
+/** 创建测试使用的最小 Agent scope。 */
+function create_scope(workspace_path, session_id) {
+  return {
+    agent_id: "memory_test_agent",
+    workspace_id: workspace_path,
+    ...(session_id ? { session_id } : {}),
+  };
+}
+
+test("Builtin Provider 把 Memory 数据写入独立 Adapter 根而不是 Workspace", async (context) => {
+  const temporary_root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-memory-"));
+  context.after(async () => await fs.rm(temporary_root, { recursive: true, force: true }));
+  const workspace_path = path.join(temporary_root, "workspace");
+  const memory_root = path.join(temporary_root, "agent-data", "memory");
+  await fs.mkdir(workspace_path, { recursive: true });
+  const provider = new BuiltinMemoryProvider({
+    storage: new FileMemoryStorageAdapter({ root_path: memory_root }),
+  });
+  await provider.initialize({ agent_id: "memory_test_agent" });
+
+  const remembered = await provider.remember({
+    scope: create_scope(workspace_path),
+    content: "The user prefers concise answers.",
+    topic: "user-preferences",
+    memory_type: "preference",
+    source: "explicit user statement",
+  });
+  assert.equal(remembered.memory_id, "wiki/user-preferences");
+  assert.equal(remembered.mode, "created");
+  assert.equal(await fs.stat(path.join(memory_root, "wiki", "user-preferences.md")).then(() => true), true);
+  assert.equal(await fs.access(path.join(workspace_path, ".downcity", "memory")).then(() => true).catch(() => false), false);
+
+  const recalled = await provider.recall({
+    scope: create_scope(workspace_path),
+    query: "concise answers",
+    min_score: 0.1,
+  });
+  assert.equal(recalled.items[0]?.memory.memory_id, "wiki/user-preferences");
+  assert.deepEqual(recalled.items[0]?.memory.scope, { agent_id: "memory_test_agent" });
+  assert.match(recalled.items[0]?.memory.citation || "", /^memory:\/\/builtin\//);
+  assert.equal(JSON.stringify(recalled).includes(memory_root), false);
+
+  const read = await provider.read({
+    scope: create_scope(workspace_path),
+    memory_id: remembered.memory_id,
+  });
+  assert.match(read.memory?.content || "", /concise answers/);
+  assert.deepEqual(read.memory?.scope, { agent_id: "memory_test_agent" });
+
+  await provider.remember({
+    scope: create_scope(workspace_path, "session-that-must-not-own-memory"),
+    content: "The user also prefers structured results.",
+    topic: "user-preferences",
+    memory_type: "preference",
+    source: "second explicit user statement",
+  });
+  const updated_read = await provider.read({
+    scope: create_scope(workspace_path),
+    memory_id: remembered.memory_id,
+  });
+  assert.equal(updated_read.memory?.source_refs.length, 2);
+  assert.deepEqual(updated_read.memory?.scope, { agent_id: "memory_test_agent" });
+
+  await assert.rejects(provider.read({
+    scope: { agent_id: "another_agent" },
+    memory_id: remembered.memory_id,
+  }), /does not match initialized Provider/);
+  await assert.rejects(provider.digest({
+    scope: create_scope(workspace_path, "empty-session"),
+    session_id: "empty-session",
+    transcript: "",
+    message_count: 0,
+  }), /requires transcript content/);
+
+  const revised = await provider.revise({
+    scope: create_scope(workspace_path),
+    memory_id: remembered.memory_id,
+    instruction: "Add the latest preference.",
+    evidence: "The user also prefers structured results.",
+  });
+  assert.equal(revised.mode, "appended");
+  assert.match(revised.evidence_id || "", /^evidence\/manual\//);
+  const revised_read = await provider.read({
+    scope: create_scope(workspace_path),
+    memory_id: remembered.memory_id,
+  });
+  assert.match(revised_read.memory?.content || "", /structured results/);
+  assert.equal(revised_read.memory?.source_refs.length, 3);
+
+  const forgotten = await provider.forget({
+    scope: create_scope(workspace_path),
+    memory_id: remembered.memory_id,
+  });
+  assert.equal(forgotten.forgotten, true);
+  assert.equal((await provider.read({
+    scope: create_scope(workspace_path),
+    memory_id: remembered.memory_id,
+  })).memory, null);
+  await provider.dispose();
+});
+
+test("File Adapter 拒绝目录穿越并由 Memory Plugin 定义默认路径", async (context) => {
+  const temporary_root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-memory-key-"));
+  context.after(async () => await fs.rm(temporary_root, { recursive: true, force: true }));
+  const adapter = new FileMemoryStorageAdapter({ root_path: temporary_root });
+  await adapter.initialize();
+  await assert.rejects(adapter.write("../outside.md", "blocked"), /Invalid Memory storage key/);
+  await assert.rejects(adapter.read("wiki/../../outside.md"), /Invalid Memory storage key/);
+  if (process.platform !== "win32") {
+    const outside_root = path.join(path.dirname(temporary_root), `${path.basename(temporary_root)}-outside`);
+    await fs.mkdir(outside_root, { recursive: true });
+    context.after(async () => await fs.rm(outside_root, { recursive: true, force: true }));
+    await fs.symlink(outside_root, path.join(temporary_root, "linked"), "dir");
+    await assert.rejects(
+      adapter.write("linked/outside.md", "blocked"),
+      /contains symbolic link/,
+    );
+  }
+  const provider = new BuiltinMemoryProvider({ storage: adapter });
+  await provider.initialize({ agent_id: "memory_test_agent" });
+  await assert.rejects(provider.read({
+    scope: { agent_id: "memory_test_agent" },
+    memory_id: "wiki/invalid.name",
+  }), /Invalid memory_id/);
+  assert.equal(
+    get_default_file_memory_root_path({
+      platform_root_path: "/platform-root",
+      agent_id: "memory_test_agent",
+    }),
+    path.join("/platform-root", "agents", "memory_test_agent", "memory"),
+  );
+  await provider.dispose();
+});
+
+test("Builtin Provider 在 initialize 阶段按 Agent 延迟创建 Adapter", async (context) => {
+  const temporary_root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-memory-factory-"));
+  context.after(async () => await fs.rm(temporary_root, { recursive: true, force: true }));
+  const initialized_agents = [];
+  const provider = new BuiltinMemoryProvider({
+    create_storage(input) {
+      initialized_agents.push(input.agent_id);
+      return new FileMemoryStorageAdapter({
+        root_path: path.join(temporary_root, input.agent_id),
+      });
+    },
+  });
+  assert.deepEqual(initialized_agents, []);
+  await provider.initialize({ agent_id: "memory_test_agent" });
+  assert.deepEqual(initialized_agents, ["memory_test_agent"]);
+  await provider.dispose();
+  await provider.initialize({ agent_id: "memory_test_agent" });
+  assert.deepEqual(initialized_agents, ["memory_test_agent", "memory_test_agent"]);
+  await provider.dispose();
+});
+
+test("MemoryPlugin 使用显式运行时目录并公开完整 Action", async (context) => {
+  const memory_root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-memory-plugin-"));
+  context.after(async () => await fs.rm(memory_root, { recursive: true, force: true }));
+  const plugin = new MemoryPlugin({ root_path: memory_root });
+  const plugin_context = {
+    agent_id: "memory_test_agent",
+    workspace_path: "/workspace",
+  };
+  await plugin.lifecycle.start(plugin_context);
+  const result = await plugin.actions.remember.execute({
+    context: plugin_context,
+    input: {
+      content: "Remember this",
+      topic: "test",
+      memory_type: "fact",
+    },
+    plugin_name: "memory",
+    action_name: "remember",
+  });
+  assert.equal(result.success, true);
+  assert.equal(result.data.memory_id, "wiki/test");
+  assert.equal(
+    await fs.access(path.join(memory_root, "wiki", "test.md")).then(() => true).catch(() => false),
+    true,
+  );
+  assert.equal("files" in plugin_context, false);
+  await plugin.lifecycle.stop(plugin_context);
+});

package/scripts/playwright-browser-provider.test.mjs

@@ -0,0 +1,260 @@
+/**
+ * PlaywrightBrowserProvider 的 CDP 连接与页面所有权专项测试。
+ *
+ * 关键点（中文）
+ * - 通过 Node 模块 mock 隔离真实 CDP endpoint，只验证 provider 的连接契约。
+ * - 默认 context 和既有 page 均属于外部浏览器，测试确保 provider 不接管或关闭它们。
+ * - 每个用例使用独立 provider 和 browser，避免 session registry 在测试之间共享。
+ */
+
+import assert from "node:assert/strict";
+import test, { mock } from "node:test";
+
+const connect_calls = [];
+let current_browser;
+
+mock.module("playwright-core", {
+  namedExports: {
+    chromium: {
+      async connectOverCDP(...args) {
+        connect_calls.push(args);
+        if (current_browser instanceof Error) throw current_browser;
+        return current_browser;
+      },
+    },
+  },
+});
+
+const { PlaywrightBrowserProvider } = await import("../bin/web.js");
+
+function create_page(overrides = {}) {
+  return {
+    closed: false,
+    default_timeout: null,
+    default_navigation_timeout: null,
+    goto_calls: [],
+    setDefaultTimeout(value) { this.default_timeout = value; },
+    setDefaultNavigationTimeout(value) { this.default_navigation_timeout = value; },
+    async goto(...args) { this.goto_calls.push(args); },
+    locator() {
+      return {
+        async innerText() { return "Page body"; },
+        async allTextContents() { return ["Page body"]; },
+      };
+    },
+    url() { return "https://example.com/"; },
+    async title() { return "Example"; },
+    async close() { this.closed = true; },
+    ...overrides,
+  };
+}
+
+function create_browser(overrides = {}) {
+  const disconnected_listeners = [];
+  const existing_page = create_page();
+  const session_page = create_page();
+  const context = {
+    closed: false,
+    new_page_calls: 0,
+    pages() { return [existing_page]; },
+    async newPage() {
+      this.new_page_calls += 1;
+      return session_page;
+    },
+    async close() { this.closed = true; },
+  };
+  const browser = {
+    context,
+    existing_page,
+    session_page,
+    closed: false,
+    new_context_calls: 0,
+    connected: true,
+    contexts() { return [context]; },
+    async newContext() {
+      this.new_context_calls += 1;
+      throw new Error("newContext must not be called");
+    },
+    isConnected() { return this.connected; },
+    on(event, listener) {
+      if (event === "disconnected") disconnected_listeners.push(listener);
+    },
+    disconnect() {
+      this.connected = false;
+      for (const listener of disconnected_listeners) listener();
+    },
+    async close() { this.closed = true; },
+    ...overrides,
+  };
+  return browser;
+}
+
+test.beforeEach(() => {
+  connect_calls.length = 0;
+  current_browser = create_browser();
+});
+
+test("连接传递 timeout 和 noDefaults，并在默认 context 创建独占 page", async () => {
+  const provider = new PlaywrightBrowserProvider({
+    cdp_url: "http://127.0.0.1:9222",
+    timeout_ms: 4_000,
+  });
+
+  const result = await provider.create_session({ url: "https://example.com" });
+
+  assert.deepEqual(connect_calls, [[
+    "http://127.0.0.1:9222",
+    { timeout: 4_000, noDefaults: true },
+  ]]);
+  assert.equal(current_browser.context.new_page_calls, 1);
+  assert.equal(current_browser.new_context_calls, 0);
+  assert.equal(current_browser.existing_page.closed, false);
+  assert.equal(current_browser.session_page.default_timeout, 4_000);
+  assert.equal(current_browser.session_page.default_navigation_timeout, 4_000);
+  assert.deepEqual(current_browser.session_page.goto_calls, [[
+    "https://example.com",
+    { waitUntil: "domcontentloaded" },
+  ]]);
+  assert.equal(result.title, "Example");
+
+  await provider.close_session({ session_id: result.session_id });
+  assert.equal(current_browser.session_page.closed, true);
+  assert.equal(current_browser.existing_page.closed, false);
+  assert.equal(current_browser.context.closed, false);
+});
+
+test("默认 context 不存在时返回 resolve-context 且不创建隔离 context", async () => {
+  current_browser = create_browser({ contexts: () => [] });
+  const provider = new PlaywrightBrowserProvider({
+    cdp_url: "ws://user:password@127.0.0.1:9222/devtools/browser/id?token=secret",
+  });
+
+  await assert.rejects(
+    provider.create_session({}),
+    (error) => {
+      assert.match(error.message, /during resolve-context/);
+      assert.match(error.message, /ws:\/\/127\.0\.0\.1:9222/);
+      assert.doesNotMatch(error.message, /user|password|token|browser\/id/);
+      return true;
+    },
+  );
+  assert.equal(current_browser.new_context_calls, 0);
+});
+
+test("page 创建失败时返回 create-page 且保留默认 context", async () => {
+  current_browser = create_browser();
+  current_browser.context.newPage = async () => {
+    throw new Error(
+      "Protocol error for ws://user:pass@127.0.0.1:9222/devtools/browser/private?token=secret",
+    );
+  };
+  const provider = new PlaywrightBrowserProvider({
+    cdp_url: "ws://user:password@127.0.0.1:9222/devtools/browser/id?token=secret",
+  });
+
+  await assert.rejects(
+    provider.create_session({}),
+    (error) => {
+      assert.match(error.message, /during create-page/);
+      assert.match(error.message, /ws:\/\/127\.0\.0\.1:9222/);
+      assert.doesNotMatch(error.message, /user|pass|token|private|browser\/id/);
+      return true;
+    },
+  );
+  assert.equal(current_browser.context.closed, false);
+});
+
+test("页面初始化失败时关闭新 page 并复用 browser connection", async () => {
+  current_browser = create_browser();
+  const first_page = current_browser.session_page;
+  first_page.goto = async () => {
+    throw new Error("Navigation failed for https://example.com/private?token=secret");
+  };
+  const second_page = create_page();
+  current_browser.context.newPage = async () => {
+    current_browser.context.new_page_calls += 1;
+    return current_browser.context.new_page_calls === 1 ? first_page : second_page;
+  };
+  const provider = new PlaywrightBrowserProvider({
+    cdp_url: "http://127.0.0.1:9222",
+  });
+
+  await assert.rejects(
+    provider.create_session({ url: "https://example.com/private" }),
+    (error) => {
+      assert.match(error.message, /during initialize-page/);
+      assert.doesNotMatch(error.message, /private|token|secret/);
+      return true;
+    },
+  );
+  assert.equal(first_page.closed, true);
+
+  const result = await provider.create_session({ url: "https://example.com" });
+  assert.equal(connect_calls.length, 1);
+  assert.equal(second_page.closed, false);
+  await provider.close_session({ session_id: result.session_id });
+});
+
+test("连接失败返回脱敏 connect 错误", async () => {
+  current_browser = new Error(
+    "connect ECONNREFUSED ws://user:pass@127.0.0.1:9222/devtools/browser/id?token=secret",
+  );
+  const provider = new PlaywrightBrowserProvider({
+    cdp_url: "ws://user:password@127.0.0.1:9222/devtools/browser/id?token=secret",
+  });
+
+  await assert.rejects(
+    provider.create_session({}),
+    (error) => {
+      assert.match(error.message, /during connect/);
+      assert.match(error.message, /ws:\/\/127\.0\.0\.1:9222/);
+      assert.doesNotMatch(error.message, /user|pass|token|secret|browser\/id/);
+      return true;
+    },
+  );
+});
+
+test("browser disconnected 后清理 session registry", async () => {
+  const provider = new PlaywrightBrowserProvider({
+    cdp_url: "http://127.0.0.1:9222",
+  });
+  const result = await provider.create_session({});
+
+  current_browser.disconnect();
+
+  await assert.rejects(
+    provider.observe({ session_id: result.session_id }),
+    /Browser session not found/,
+  );
+});
+
+test("旧 browser 延迟断开不会清理新连接的 session", async () => {
+  const first_browser = current_browser;
+  const provider = new PlaywrightBrowserProvider({
+    cdp_url: "http://127.0.0.1:9222",
+  });
+  await provider.create_session({});
+
+  first_browser.connected = false;
+  current_browser = create_browser();
+  const result = await provider.create_session({});
+  first_browser.disconnect();
+
+  const observation = await provider.observe({ session_id: result.session_id });
+  assert.equal(observation.session_id, result.session_id);
+  assert.equal(connect_calls.length, 2);
+});
+
+test("dispose 关闭 provider page 和 CDP connection，不关闭默认 context", async () => {
+  const provider = new PlaywrightBrowserProvider({
+    cdp_url: "http://127.0.0.1:9222",
+  });
+  await provider.create_session({});
+
+  await provider.dispose();
+
+  assert.equal(current_browser.session_page.closed, true);
+  assert.equal(current_browser.existing_page.closed, false);
+  assert.equal(current_browser.context.closed, false);
+  assert.equal(current_browser.closed, true);
+});

package/scripts/plugin-main.test.mjs

@@ -0,0 +1,101 @@
+/** Plugin main 的 Profile action 与凭据边界测试。 */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { CHAT_PLUGIN_MAIN } from "../bin/chat/main/ChatPluginMain.js";
+
+/** 激活 main 并返回按 ID 注册的 action。 */
+async function activate_chat_main() {
+  const actions = new Map();
+  await CHAT_PLUGIN_MAIN.activate({
+    plugin: {
+      id: "chat",
+      action(action) {
+        actions.set(action.id, action);
+      },
+    },
+    logger: {
+      debug() {},
+      info() {},
+      warn() {},
+      error() {},
+    },
+    system: {
+      async open_external() {},
+      async show_item_in_folder() {},
+      async write_clipboard_text() {},
+    },
+  });
+  return actions;
+}
+
+/** 创建可观察完整替换结果的 Profile 配置上下文。 */
+function create_config_context(initial_config) {
+  let config = structuredClone(initial_config);
+  return {
+    context: {
+      config: {
+        async get() {
+          return structuredClone(config);
+        },
+        async set(next) {
+          config = structuredClone(next);
+        },
+      },
+    },
+    read: () => structuredClone(config),
+  };
+}
+
+test("Chat main 读取 Profile 时不泄漏 Channel 凭据", async () => {
+  const actions = await activate_chat_main();
+  const store = create_config_context({
+    channels: [
+      { id: "telegram_main", type: "telegram", name: "Main", bot_token: "telegram-secret" },
+      { id: "feishu_main", type: "feishu", name: "Work", app_id: "cli_a", app_secret: "feishu-secret" },
+    ],
+  });
+
+  const profile = await actions.get("profile.read").run(undefined, store.context);
+
+  assert.equal(JSON.stringify(profile).includes("telegram-secret"), false);
+  assert.equal(JSON.stringify(profile).includes("feishu-secret"), false);
+  assert.deepEqual(profile.channels.map((channel) => channel.secret_configured), [true, true]);
+});
+
+test("Chat main 保存时为空的凭据输入会保留已有凭据", async () => {
+  const actions = await activate_chat_main();
+  const store = create_config_context({
+    channels: [
+      { id: "telegram_main", type: "telegram", name: "Old", bot_token: "kept-secret" },
+    ],
+  });
+
+  const result = await actions.get("profile.save").run({
+    queue: { max_concurrency: 4 },
+    channels: [{
+      id: "telegram_main",
+      type: "telegram",
+      name: "New",
+      bot_token: "",
+      secret_configured: true,
+    }],
+  }, store.context);
+
+  assert.equal(store.read().channels[0].bot_token, "kept-secret");
+  assert.equal(result.channels[0].secret_configured, true);
+  assert.equal("bot_token" in result.channels[0], false);
+});
+
+test("Chat main 拒绝没有凭据的新 Channel", async () => {
+  const actions = await activate_chat_main();
+  const store = create_config_context({ channels: [] });
+
+  await assert.rejects(
+    () => actions.get("profile.save").run({
+      queue: {},
+      channels: [{ id: "telegram_new", type: "telegram", name: "New" }],
+    }, store.context),
+    /Telegram Bot Token is required/u,
+  );
+});

package/scripts/plugin-subpaths.test.mjs

@@ -48,3 +48,39 @@ test("根入口不再导出默认内建集合工厂", async () => {
   assert.equal("createBuiltinPlugins" in plugin_module, false);
   assert.equal("BUILTIN_PLUGIN_CLASSES" in plugin_module, false);
 });
+
+test("Renderer 子路径统一导出 React Mainview registry", async () => {
+  const plugin_react = await import("@downcity/plugin/react");
+  const renderers = await import("@downcity/plugins/renderers");
+  assert.equal(typeof plugin_react.define_plugin_renderer, "function");
+  assert.deepEqual(Object.keys(renderers.BUILTIN_PLUGIN_RENDERERS).sort(), [
+    "chat",
+    "image",
+    "sound",
+    "web",
+  ]);
+  for (const renderer of Object.values(renderers.BUILTIN_PLUGIN_RENDERERS)) {
+    assert.equal(typeof renderer, "function");
+  }
+});
+
+test("内建 Plugin 子路径不再公开宿主通用配置 Schema", async () => {
+  const schema_exports = [
+    ["chat", "CHAT_PLUGIN_CONFIG_JSON_SCHEMA"],
+    ["image", "IMAGE_PLUGIN_CONFIG_JSON_SCHEMA"],
+    ["sound", "SOUND_PLUGIN_CONFIG_JSON_SCHEMA"],
+    ["web", "WEB_PLUGIN_CONFIG_JSON_SCHEMA"],
+  ];
+  for (const [plugin_name, export_name] of schema_exports) {
+    const plugin_module = await import(`@downcity/plugins/${plugin_name}`);
+    assert.equal(export_name in plugin_module, false, `${plugin_name} 不应导出 ${export_name}`);
+  }
+});
+
+test("memory 子路径导出 Provider 与 Storage Adapter", async () => {
+  const memory_module = await import("@downcity/plugins/memory");
+  assert.equal(typeof memory_module.MemoryPlugin, "function");
+  assert.equal(typeof memory_module.BuiltinMemoryProvider, "function");
+  assert.equal(typeof memory_module.FileMemoryStorageAdapter, "function");
+  assert.equal(typeof memory_module.get_default_file_memory_root_path, "function");
+});