@archipelagolab/lobi 1.0.0 → 1.0.5

package/src/channel.directory.test.ts

@@ -1,601 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { createRuntimeEnv } from "../../../test/helpers/plugins/runtime-env.js";
-import type { RuntimeEnv } from "../runtime-api.js";
-import { matrixPlugin } from "./channel.js";
-import { resolveMatrixAccount } from "./matrix/accounts.js";
-import { resolveMatrixConfigForAccount } from "./matrix/client/config.js";
-import { installMatrixTestRuntime } from "./test-runtime.js";
-import type { CoreConfig } from "./types.js";
-
-describe("matrix directory", () => {
-  const runtimeEnv: RuntimeEnv = createRuntimeEnv();
-
-  beforeEach(() => {
-    installMatrixTestRuntime();
-  });
-
-  it("lists peers and groups from config", async () => {
-    const cfg = {
-      channels: {
-        matrix: {
-          dm: { allowFrom: ["matrix:@alice:example.org", "bob"] },
-          groupAllowFrom: ["@dana:example.org"],
-          groups: {
-            "!room1:example.org": { users: ["@carol:example.org"] },
-            "#alias:example.org": { users: [] },
-          },
-        },
-      },
-    } as unknown as CoreConfig;
-
-    expect(matrixPlugin.directory).toBeTruthy();
-    expect(matrixPlugin.directory?.listPeers).toBeTruthy();
-    expect(matrixPlugin.directory?.listGroups).toBeTruthy();
-
-    await expect(
-      matrixPlugin.directory!.listPeers!({
-        cfg,
-        accountId: undefined,
-        query: undefined,
-        limit: undefined,
-        runtime: runtimeEnv,
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { kind: "user", id: "user:@alice:example.org" },
-        { kind: "user", id: "bob", name: "incomplete id; expected @user:server" },
-        { kind: "user", id: "user:@carol:example.org" },
-        { kind: "user", id: "user:@dana:example.org" },
-      ]),
-    );
-
-    await expect(
-      matrixPlugin.directory!.listGroups!({
-        cfg,
-        accountId: undefined,
-        query: undefined,
-        limit: undefined,
-        runtime: runtimeEnv,
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { kind: "group", id: "room:!room1:example.org" },
-        { kind: "group", id: "#alias:example.org" },
-      ]),
-    );
-  });
-
-  it("resolves replyToMode from account config", () => {
-    const cfg = {
-      channels: {
-        matrix: {
-          replyToMode: "off",
-          accounts: {
-            Assistant: {
-              replyToMode: "all",
-            },
-          },
-        },
-      },
-    } as unknown as CoreConfig;
-
-    expect(matrixPlugin.threading?.resolveReplyToMode).toBeTruthy();
-    expect(
-      matrixPlugin.threading?.resolveReplyToMode?.({
-        cfg,
-        accountId: "assistant",
-        chatType: "direct",
-      }),
-    ).toBe("all");
-    expect(
-      matrixPlugin.threading?.resolveReplyToMode?.({
-        cfg,
-        accountId: "default",
-        chatType: "direct",
-      }),
-    ).toBe("off");
-  });
-
-  it("only exposes real Matrix thread ids in tool context", () => {
-    expect(
-      matrixPlugin.threading?.buildToolContext?.({
-        cfg: {} as CoreConfig,
-        context: {
-          To: "room:!room:example.org",
-          ReplyToId: "$reply",
-        },
-        hasRepliedRef: { value: false },
-      }),
-    ).toEqual({
-      currentChannelId: "room:!room:example.org",
-      currentThreadTs: undefined,
-      hasRepliedRef: { value: false },
-    });
-
-    expect(
-      matrixPlugin.threading?.buildToolContext?.({
-        cfg: {} as CoreConfig,
-        context: {
-          To: "room:!room:example.org",
-          ReplyToId: "$reply",
-          MessageThreadId: "$thread",
-        },
-        hasRepliedRef: { value: true },
-      }),
-    ).toEqual({
-      currentChannelId: "room:!room:example.org",
-      currentThreadTs: "$thread",
-      hasRepliedRef: { value: true },
-    });
-  });
-
-  it("exposes Matrix direct user id in dm tool context", () => {
-    expect(
-      matrixPlugin.threading?.buildToolContext?.({
-        cfg: {} as CoreConfig,
-        context: {
-          From: "matrix:@alice:example.org",
-          To: "room:!dm:example.org",
-          ChatType: "direct",
-          MessageThreadId: "$thread",
-        },
-        hasRepliedRef: { value: false },
-      }),
-    ).toEqual({
-      currentChannelId: "room:!dm:example.org",
-      currentThreadTs: "$thread",
-      currentDirectUserId: "@alice:example.org",
-      hasRepliedRef: { value: false },
-    });
-  });
-
-  it("accepts raw room ids when inferring Matrix direct user ids", () => {
-    expect(
-      matrixPlugin.threading?.buildToolContext?.({
-        cfg: {} as CoreConfig,
-        context: {
-          From: "user:@alice:example.org",
-          To: "!dm:example.org",
-          ChatType: "direct",
-        },
-        hasRepliedRef: { value: false },
-      }),
-    ).toEqual({
-      currentChannelId: "!dm:example.org",
-      currentThreadTs: undefined,
-      currentDirectUserId: "@alice:example.org",
-      hasRepliedRef: { value: false },
-    });
-  });
-
-  it("resolves group mention policy from account config", () => {
-    const cfg = {
-      channels: {
-        matrix: {
-          groups: {
-            "!room:example.org": { requireMention: true },
-          },
-          accounts: {
-            Assistant: {
-              groups: {
-                "!room:example.org": { requireMention: false },
-              },
-            },
-          },
-        },
-      },
-    } as unknown as CoreConfig;
-
-    expect(matrixPlugin.groups!.resolveRequireMention!({ cfg, groupId: "!room:example.org" })).toBe(
-      true,
-    );
-    expect(
-      matrixPlugin.groups!.resolveRequireMention!({
-        cfg,
-        accountId: "assistant",
-        groupId: "!room:example.org",
-      }),
-    ).toBe(false);
-
-    expect(
-      matrixPlugin.groups!.resolveRequireMention!({
-        cfg,
-        accountId: "assistant",
-        groupId: "matrix:room:!room:example.org",
-      }),
-    ).toBe(false);
-  });
-
-  it("matches prefixed Matrix aliases in group context", () => {
-    const cfg = {
-      channels: {
-        matrix: {
-          groups: {
-            "#ops:example.org": { requireMention: false },
-          },
-        },
-      },
-    } as unknown as CoreConfig;
-
-    expect(
-      matrixPlugin.groups!.resolveRequireMention!({
-        cfg,
-        groupId: "matrix:room:!room:example.org",
-        groupChannel: "matrix:channel:#ops:example.org",
-      }),
-    ).toBe(false);
-  });
-
-  it("reports room access warnings against the active Matrix config path", () => {
-    expect(
-      matrixPlugin.security?.collectWarnings?.({
-        cfg: {
-          channels: {
-            matrix: {
-              groupPolicy: "open",
-            },
-          },
-        } as CoreConfig,
-        account: resolveMatrixAccount({
-          cfg: {
-            channels: {
-              matrix: {
-                groupPolicy: "open",
-              },
-            },
-          } as CoreConfig,
-          accountId: "default",
-        }),
-      }),
-    ).toEqual([
-      '- Matrix rooms: groupPolicy="open" allows any room to trigger (mention-gated). Set channels.lobi.groupPolicy="allowlist" + channels.lobi.groups (and optionally channels.lobi.groupAllowFrom) to restrict rooms.',
-    ]);
-
-    expect(
-      matrixPlugin.security?.collectWarnings?.({
-        cfg: {
-          channels: {
-            matrix: {
-              defaultAccount: "assistant",
-              accounts: {
-                assistant: {
-                  groupPolicy: "open",
-                },
-              },
-            },
-          },
-        } as CoreConfig,
-        account: resolveMatrixAccount({
-          cfg: {
-            channels: {
-              matrix: {
-                defaultAccount: "assistant",
-                accounts: {
-                  assistant: {
-                    groupPolicy: "open",
-                  },
-                },
-              },
-            },
-          } as CoreConfig,
-          accountId: "assistant",
-        }),
-      }),
-    ).toEqual([
-      '- Matrix rooms: groupPolicy="open" allows any room to trigger (mention-gated). Set channels.lobi.accounts.assistant.groupPolicy="allowlist" + channels.lobi.accounts.assistant.groups (and optionally channels.lobi.accounts.assistant.groupAllowFrom) to restrict rooms.',
-    ]);
-  });
-
-  it("reports invite auto-join warnings only when explicitly enabled", () => {
-    expect(
-      matrixPlugin.security?.collectWarnings?.({
-        cfg: {
-          channels: {
-            matrix: {
-              groupPolicy: "allowlist",
-              autoJoin: "always",
-            },
-          },
-        } as CoreConfig,
-        account: resolveMatrixAccount({
-          cfg: {
-            channels: {
-              matrix: {
-                groupPolicy: "allowlist",
-                autoJoin: "always",
-              },
-            },
-          } as CoreConfig,
-          accountId: "default",
-        }),
-      }),
-    ).toEqual([
-      '- Matrix invites: autoJoin="always" joins any invited room before message policy applies. Set channels.lobi.autoJoin="allowlist" + channels.lobi.autoJoinAllowlist (or channels.lobi.autoJoin="off") to restrict joins.',
-    ]);
-  });
-
-  it("writes matrix non-default account credentials under channels.lobi.accounts", () => {
-    const cfg = {
-      channels: {
-        matrix: {
-          homeserver: "https://default.example.org",
-          accessToken: "default-token",
-          deviceId: "DEFAULTDEVICE",
-          avatarUrl: "mxc://server/avatar",
-          encryption: true,
-          threadReplies: "inbound",
-          groups: {
-            "!room:example.org": { requireMention: true },
-          },
-        },
-      },
-    } as unknown as CoreConfig;
-
-    const updated = matrixPlugin.setup!.applyAccountConfig({
-      cfg,
-      accountId: "ops",
-      input: {
-        homeserver: "https://matrix.example.org",
-        userId: "@ops:example.org",
-        accessToken: "ops-token",
-      },
-    }) as CoreConfig;
-
-    expect(updated.channels?.["matrix"]?.accessToken).toBeUndefined();
-    expect(updated.channels?.["matrix"]?.deviceId).toBeUndefined();
-    expect(updated.channels?.["matrix"]?.avatarUrl).toBeUndefined();
-    expect(updated.channels?.["matrix"]?.accounts?.default).toMatchObject({
-      accessToken: "default-token",
-      homeserver: "https://default.example.org",
-      deviceId: "DEFAULTDEVICE",
-      avatarUrl: "mxc://server/avatar",
-      encryption: true,
-      threadReplies: "inbound",
-      groups: {
-        "!room:example.org": { requireMention: true },
-      },
-    });
-    expect(updated.channels?.["matrix"]?.accounts?.ops).toMatchObject({
-      enabled: true,
-      homeserver: "https://matrix.example.org",
-      userId: "@ops:example.org",
-      accessToken: "ops-token",
-    });
-    expect(resolveMatrixConfigForAccount(updated, "ops", {})).toMatchObject({
-      homeserver: "https://matrix.example.org",
-      userId: "@ops:example.org",
-      accessToken: "ops-token",
-      deviceId: undefined,
-    });
-  });
-
-  it("writes default matrix account credentials under channels.lobi.accounts.default", () => {
-    const cfg = {
-      channels: {
-        matrix: {
-          homeserver: "https://legacy.example.org",
-          accessToken: "legacy-token",
-        },
-      },
-    } as unknown as CoreConfig;
-
-    const updated = matrixPlugin.setup!.applyAccountConfig({
-      cfg,
-      accountId: "default",
-      input: {
-        homeserver: "https://matrix.example.org",
-        userId: "@bot:example.org",
-        accessToken: "bot-token",
-      },
-    }) as CoreConfig;
-
-    expect(updated.channels?.["matrix"]).toMatchObject({
-      enabled: true,
-      homeserver: "https://matrix.example.org",
-      userId: "@bot:example.org",
-      accessToken: "bot-token",
-    });
-    expect(updated.channels?.["matrix"]?.accounts).toBeUndefined();
-  });
-
-  it("requires account-scoped env vars when --use-env is set for non-default accounts", () => {
-    const envKeys = [
-      "LOBI_OPS_HOMESERVER",
-      "MATRIX_OPS_USER_ID",
-      "LOBI_OPS_ACCESS_TOKEN",
-      "MATRIX_OPS_PASSWORD",
-    ] as const;
-    const previousEnv = Object.fromEntries(envKeys.map((key) => [key, process.env[key]])) as Record<
-      (typeof envKeys)[number],
-      string | undefined
-    >;
-    for (const key of envKeys) {
-      delete process.env[key];
-    }
-    try {
-      const error = matrixPlugin.setup!.validateInput?.({
-        cfg: {} as CoreConfig,
-        accountId: "ops",
-        input: { useEnv: true },
-      });
-      expect(error).toBe(
-        'Set per-account env vars for "ops" (for example LOBI_OPS_HOMESERVER + LOBI_OPS_ACCESS_TOKEN or MATRIX_OPS_USER_ID + MATRIX_OPS_PASSWORD).',
-      );
-    } finally {
-      for (const key of envKeys) {
-        if (previousEnv[key] === undefined) {
-          delete process.env[key];
-        } else {
-          process.env[key] = previousEnv[key];
-        }
-      }
-    }
-  });
-
-  it("accepts --use-env for non-default account when scoped env vars are present", () => {
-    const envKeys = {
-      LOBI_OPS_HOMESERVER: process.env.LOBI_OPS_HOMESERVER,
-      LOBI_OPS_ACCESS_TOKEN: process.env.LOBI_OPS_ACCESS_TOKEN,
-    };
-    process.env.LOBI_OPS_HOMESERVER = "https://ops.example.org";
-    process.env.LOBI_OPS_ACCESS_TOKEN = "ops-token";
-    try {
-      const error = matrixPlugin.setup!.validateInput?.({
-        cfg: {} as CoreConfig,
-        accountId: "ops",
-        input: { useEnv: true },
-      });
-      expect(error).toBeNull();
-    } finally {
-      for (const [key, value] of Object.entries(envKeys)) {
-        if (value === undefined) {
-          delete process.env[key];
-        } else {
-          process.env[key] = value;
-        }
-      }
-    }
-  });
-
-  it("clears stored auth fields when switching a Matrix account to env-backed auth", () => {
-    const envKeys = {
-      LOBI_OPS_HOMESERVER: process.env.LOBI_OPS_HOMESERVER,
-      LOBI_OPS_ACCESS_TOKEN: process.env.LOBI_OPS_ACCESS_TOKEN,
-      LOBI_OPS_DEVICE_ID: process.env.LOBI_OPS_DEVICE_ID,
-      LOBI_OPS_DEVICE_NAME: process.env.LOBI_OPS_DEVICE_NAME,
-    };
-    process.env.LOBI_OPS_HOMESERVER = "https://ops.env.example.org";
-    process.env.LOBI_OPS_ACCESS_TOKEN = "ops-env-token";
-    process.env.LOBI_OPS_DEVICE_ID = "OPSENVDEVICE";
-    process.env.LOBI_OPS_DEVICE_NAME = "Ops Env Device";
-
-    try {
-      const cfg = {
-        channels: {
-          matrix: {
-            accounts: {
-              ops: {
-                homeserver: "https://ops.inline.example.org",
-                userId: "@ops:inline.example.org",
-                accessToken: "ops-inline-token",
-                password: "ops-inline-password", // pragma: allowlist secret
-                deviceId: "OPSINLINEDEVICE",
-                deviceName: "Ops Inline Device",
-                encryption: true,
-              },
-            },
-          },
-        },
-      } as unknown as CoreConfig;
-
-      const updated = matrixPlugin.setup!.applyAccountConfig({
-        cfg,
-        accountId: "ops",
-        input: {
-          useEnv: true,
-          name: "Ops",
-        },
-      }) as CoreConfig;
-
-      expect(updated.channels?.["matrix"]?.accounts?.ops).toMatchObject({
-        name: "Ops",
-        enabled: true,
-        encryption: true,
-      });
-      expect(updated.channels?.["matrix"]?.accounts?.ops?.homeserver).toBeUndefined();
-      expect(updated.channels?.["matrix"]?.accounts?.ops?.userId).toBeUndefined();
-      expect(updated.channels?.["matrix"]?.accounts?.ops?.accessToken).toBeUndefined();
-      expect(updated.channels?.["matrix"]?.accounts?.ops?.password).toBeUndefined();
-      expect(updated.channels?.["matrix"]?.accounts?.ops?.deviceId).toBeUndefined();
-      expect(updated.channels?.["matrix"]?.accounts?.ops?.deviceName).toBeUndefined();
-      expect(resolveMatrixConfigForAccount(updated, "ops", process.env)).toMatchObject({
-        homeserver: "https://ops.env.example.org",
-        accessToken: "ops-env-token",
-        deviceId: "OPSENVDEVICE",
-        deviceName: "Ops Env Device",
-      });
-    } finally {
-      for (const [key, value] of Object.entries(envKeys)) {
-        if (value === undefined) {
-          delete process.env[key];
-        } else {
-          process.env[key] = value;
-        }
-      }
-    }
-  });
-
-  it("resolves account id from input name when explicit account id is missing", () => {
-    const accountId = matrixPlugin.setup!.resolveAccountId?.({
-      cfg: {} as CoreConfig,
-      accountId: undefined,
-      input: { name: "Main Bot" },
-    });
-    expect(accountId).toBe("main-bot");
-  });
-
-  it("resolves binding account id from agent id when omitted", () => {
-    const accountId = matrixPlugin.setup!.resolveBindingAccountId?.({
-      cfg: {} as CoreConfig,
-      agentId: "Ops",
-      accountId: undefined,
-    });
-    expect(accountId).toBe("ops");
-  });
-
-  it("clears stale access token when switching an account to password auth", () => {
-    const cfg = {
-      channels: {
-        matrix: {
-          accounts: {
-            default: {
-              homeserver: "https://matrix.example.org",
-              accessToken: "old-token",
-            },
-          },
-        },
-      },
-    } as unknown as CoreConfig;
-
-    const updated = matrixPlugin.setup!.applyAccountConfig({
-      cfg,
-      accountId: "default",
-      input: {
-        homeserver: "https://matrix.example.org",
-        userId: "@bot:example.org",
-        password: "new-password", // pragma: allowlist secret
-      },
-    }) as CoreConfig;
-
-    expect(updated.channels?.["matrix"]?.accounts?.default?.password).toBe("new-password");
-    expect(updated.channels?.["matrix"]?.accounts?.default?.accessToken).toBeUndefined();
-  });
-
-  it("clears stale password when switching an account to token auth", () => {
-    const cfg = {
-      channels: {
-        matrix: {
-          accounts: {
-            default: {
-              homeserver: "https://matrix.example.org",
-              userId: "@bot:example.org",
-              password: "old-password", // pragma: allowlist secret
-            },
-          },
-        },
-      },
-    } as unknown as CoreConfig;
-
-    const updated = matrixPlugin.setup!.applyAccountConfig({
-      cfg,
-      accountId: "default",
-      input: {
-        homeserver: "https://matrix.example.org",
-        accessToken: "new-token",
-      },
-    }) as CoreConfig;
-
-    expect(updated.channels?.["matrix"]?.accounts?.default?.accessToken).toBe("new-token");
-    expect(updated.channels?.["matrix"]?.accounts?.default?.password).toBeUndefined();
-  });
-});

package/src/channel.resolve.test.ts

@@ -1,38 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createNonExitingRuntimeEnv } from "../../../test/helpers/plugins/runtime-env.js";
-
-const resolveMatrixTargetsMock = vi.hoisted(() => vi.fn(async () => []));
-
-vi.mock("./resolve-targets.js", () => ({
-  resolveMatrixTargets: resolveMatrixTargetsMock,
-}));
-
-import { matrixResolverAdapter } from "./resolver.js";
-
-describe("matrix resolver adapter", () => {
-  beforeEach(() => {
-    resolveMatrixTargetsMock.mockClear();
-  });
-
-  it("forwards accountId into Matrix target resolution", async () => {
-    await matrixResolverAdapter.resolveTargets({
-      cfg: { channels: { matrix: {} } },
-      accountId: "ops",
-      inputs: ["Alice"],
-      kind: "user",
-      runtime: createNonExitingRuntimeEnv(),
-    });
-
-    expect(resolveMatrixTargetsMock).toHaveBeenCalledWith({
-      cfg: { channels: { matrix: {} } },
-      accountId: "ops",
-      inputs: ["Alice"],
-      kind: "user",
-      runtime: expect.objectContaining({
-        log: expect.any(Function),
-        error: expect.any(Function),
-        exit: expect.any(Function),
-      }),
-    });
-  });
-});

package/src/channel.runtime.ts

@@ -1,16 +0,0 @@
-import { listMatrixDirectoryGroupsLive, listMatrixDirectoryPeersLive } from "./directory-live.js";
-import { resolveMatrixAuth } from "./matrix/client.js";
-import { probeMatrix } from "./matrix/probe.js";
-import { sendMessageMatrix } from "./matrix/send.js";
-import { matrixOutbound } from "./outbound.js";
-import { resolveMatrixTargets } from "./resolve-targets.js";
-
-export const matrixChannelRuntime = {
-  listMatrixDirectoryGroupsLive,
-  listMatrixDirectoryPeersLive,
-  matrixOutbound,
-  probeMatrix,
-  resolveMatrixAuth,
-  resolveMatrixTargets,
-  sendMessageMatrix,
-};