@archipelagolab/lobi 1.0.0

package/src/session-route.test.ts

@@ -0,0 +1,315 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import type { OpenClawConfig } from "./runtime-api.js";
+import { resolveMatrixOutboundSessionRoute } from "./session-route.js";
+
+const tempDirs = new Set<string>();
+const currentDmSessionKey = "agent:main:matrix:channel:!dm:example.org";
+type MatrixChannelConfig = NonNullable<NonNullable<OpenClawConfig["channels"]>["matrix"]>;
+
+const perRoomDmMatrixConfig = {
+  dm: {
+    sessionScope: "per-room",
+  },
+} satisfies MatrixChannelConfig;
+
+const defaultAccountPerRoomDmMatrixConfig = {
+  defaultAccount: "ops",
+  accounts: {
+    ops: {
+      dm: {
+        sessionScope: "per-room",
+      },
+    },
+  },
+} satisfies MatrixChannelConfig;
+
+function createTempStore(entries: Record<string, unknown>): string {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "matrix-session-route-"));
+  tempDirs.add(tempDir);
+  const storePath = path.join(tempDir, "sessions.json");
+  fs.writeFileSync(storePath, JSON.stringify(entries), "utf8");
+  return storePath;
+}
+
+function createMatrixRouteConfig(
+  entries: Record<string, unknown>,
+  matrix: MatrixChannelConfig = perRoomDmMatrixConfig,
+): OpenClawConfig {
+  return {
+    session: {
+      store: createTempStore(entries),
+    },
+    channels: {
+      matrix,
+    },
+  } satisfies OpenClawConfig;
+}
+
+function createStoredDirectDmSession(
+  params: {
+    from?: string;
+    to?: string;
+    accountId?: string | null;
+    nativeChannelId?: string;
+    nativeDirectUserId?: string;
+    lastTo?: string;
+    lastAccountId?: string;
+  } = {},
+): Record<string, unknown> {
+  const accountId = params.accountId === null ? undefined : (params.accountId ?? "ops");
+  const to = params.to ?? "room:!dm:example.org";
+  const accountMetadata = accountId ? { accountId } : {};
+  const nativeMetadata = {
+    ...(params.nativeChannelId ? { nativeChannelId: params.nativeChannelId } : {}),
+    ...(params.nativeDirectUserId ? { nativeDirectUserId: params.nativeDirectUserId } : {}),
+  };
+  return {
+    sessionId: "sess-1",
+    updatedAt: Date.now(),
+    chatType: "direct",
+    origin: {
+      chatType: "direct",
+      from: params.from ?? "matrix:@alice:example.org",
+      to,
+      ...nativeMetadata,
+      ...accountMetadata,
+    },
+    deliveryContext: {
+      channel: "matrix",
+      to,
+      ...accountMetadata,
+    },
+    ...(params.lastTo ? { lastTo: params.lastTo } : {}),
+    ...(params.lastAccountId ? { lastAccountId: params.lastAccountId } : {}),
+  };
+}
+
+function createStoredChannelSession(): Record<string, unknown> {
+  return {
+    sessionId: "sess-1",
+    updatedAt: Date.now(),
+    chatType: "channel",
+    origin: {
+      chatType: "channel",
+      from: "matrix:channel:!ops:example.org",
+      to: "room:!ops:example.org",
+      nativeChannelId: "!ops:example.org",
+      nativeDirectUserId: "@alice:example.org",
+      accountId: "ops",
+    },
+    deliveryContext: {
+      channel: "matrix",
+      to: "room:!ops:example.org",
+      accountId: "ops",
+    },
+    lastTo: "room:!ops:example.org",
+    lastAccountId: "ops",
+  };
+}
+
+function resolveUserRoute(params: { cfg: OpenClawConfig; accountId?: string; target?: string }) {
+  const target = params.target ?? "@alice:example.org";
+  return resolveMatrixOutboundSessionRoute({
+    cfg: params.cfg,
+    agentId: "main",
+    ...(params.accountId ? { accountId: params.accountId } : {}),
+    currentSessionKey: currentDmSessionKey,
+    target,
+    resolvedTarget: {
+      to: target,
+      kind: "user",
+      source: "normalized",
+    },
+  });
+}
+
+afterEach(() => {
+  for (const tempDir of tempDirs) {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+  tempDirs.clear();
+});
+
+describe("resolveMatrixOutboundSessionRoute", () => {
+  it("reuses the current DM room session for same-user sends when Matrix DMs are per-room", () => {
+    const cfg = createMatrixRouteConfig({
+      [currentDmSessionKey]: createStoredDirectDmSession(),
+    });
+
+    const route = resolveUserRoute({
+      cfg,
+      accountId: "ops",
+    });
+
+    expect(route).toMatchObject({
+      sessionKey: currentDmSessionKey,
+      baseSessionKey: currentDmSessionKey,
+      peer: { kind: "channel", id: "!dm:example.org" },
+      chatType: "direct",
+      from: "matrix:@alice:example.org",
+      to: "room:!dm:example.org",
+    });
+  });
+
+  it("falls back to user-scoped routing when the current session is for another DM peer", () => {
+    const cfg = createMatrixRouteConfig({
+      [currentDmSessionKey]: createStoredDirectDmSession({ from: "matrix:@bob:example.org" }),
+    });
+
+    const route = resolveUserRoute({
+      cfg,
+      accountId: "ops",
+    });
+
+    expect(route).toMatchObject({
+      sessionKey: "agent:main:main",
+      baseSessionKey: "agent:main:main",
+      peer: { kind: "direct", id: "@alice:example.org" },
+      chatType: "direct",
+      from: "matrix:@alice:example.org",
+      to: "room:@alice:example.org",
+    });
+  });
+
+  it("falls back to user-scoped routing when the current session belongs to another Matrix account", () => {
+    const cfg = createMatrixRouteConfig({
+      [currentDmSessionKey]: createStoredDirectDmSession(),
+    });
+
+    const route = resolveUserRoute({
+      cfg,
+      accountId: "support",
+    });
+
+    expect(route).toMatchObject({
+      sessionKey: "agent:main:main",
+      baseSessionKey: "agent:main:main",
+      peer: { kind: "direct", id: "@alice:example.org" },
+      chatType: "direct",
+      from: "matrix:@alice:example.org",
+      to: "room:@alice:example.org",
+    });
+  });
+
+  it("reuses the canonical DM room after user-target outbound metadata overwrites latest to fields", () => {
+    const cfg = createMatrixRouteConfig({
+      [currentDmSessionKey]: createStoredDirectDmSession({
+        from: "matrix:@bob:example.org",
+        to: "room:@bob:example.org",
+        nativeChannelId: "!dm:example.org",
+        nativeDirectUserId: "@alice:example.org",
+        lastTo: "room:@bob:example.org",
+        lastAccountId: "ops",
+      }),
+    });
+
+    const route = resolveUserRoute({
+      cfg,
+      accountId: "ops",
+    });
+
+    expect(route).toMatchObject({
+      sessionKey: currentDmSessionKey,
+      baseSessionKey: currentDmSessionKey,
+      peer: { kind: "channel", id: "!dm:example.org" },
+      chatType: "direct",
+      from: "matrix:@alice:example.org",
+      to: "room:!dm:example.org",
+    });
+  });
+
+  it("does not reuse the canonical DM room for a different Matrix user after latest metadata drift", () => {
+    const cfg = createMatrixRouteConfig({
+      [currentDmSessionKey]: createStoredDirectDmSession({
+        from: "matrix:@bob:example.org",
+        to: "room:@bob:example.org",
+        nativeChannelId: "!dm:example.org",
+        nativeDirectUserId: "@alice:example.org",
+        lastTo: "room:@bob:example.org",
+        lastAccountId: "ops",
+      }),
+    });
+
+    const route = resolveUserRoute({
+      cfg,
+      accountId: "ops",
+      target: "@bob:example.org",
+    });
+
+    expect(route).toMatchObject({
+      sessionKey: "agent:main:main",
+      baseSessionKey: "agent:main:main",
+      peer: { kind: "direct", id: "@bob:example.org" },
+      chatType: "direct",
+      from: "matrix:@bob:example.org",
+      to: "room:@bob:example.org",
+    });
+  });
+
+  it("does not reuse a room after the session metadata was overwritten by a non-DM Matrix send", () => {
+    const cfg = createMatrixRouteConfig({
+      [currentDmSessionKey]: createStoredChannelSession(),
+    });
+
+    const route = resolveUserRoute({
+      cfg,
+      accountId: "ops",
+    });
+
+    expect(route).toMatchObject({
+      sessionKey: "agent:main:main",
+      baseSessionKey: "agent:main:main",
+      peer: { kind: "direct", id: "@alice:example.org" },
+      chatType: "direct",
+      from: "matrix:@alice:example.org",
+      to: "room:@alice:example.org",
+    });
+  });
+
+  it("uses the effective default Matrix account when accountId is omitted", () => {
+    const cfg = createMatrixRouteConfig(
+      {
+        [currentDmSessionKey]: createStoredDirectDmSession(),
+      },
+      defaultAccountPerRoomDmMatrixConfig,
+    );
+
+    const route = resolveUserRoute({
+      cfg,
+    });
+
+    expect(route).toMatchObject({
+      sessionKey: currentDmSessionKey,
+      baseSessionKey: currentDmSessionKey,
+      peer: { kind: "channel", id: "!dm:example.org" },
+      chatType: "direct",
+      from: "matrix:@alice:example.org",
+      to: "room:!dm:example.org",
+    });
+  });
+
+  it("reuses the current DM room when stored account metadata is missing", () => {
+    const cfg = createMatrixRouteConfig(
+      {
+        [currentDmSessionKey]: createStoredDirectDmSession({ accountId: null }),
+      },
+      defaultAccountPerRoomDmMatrixConfig,
+    );
+
+    const route = resolveUserRoute({
+      cfg,
+    });
+
+    expect(route).toMatchObject({
+      sessionKey: currentDmSessionKey,
+      baseSessionKey: currentDmSessionKey,
+      peer: { kind: "channel", id: "!dm:example.org" },
+      chatType: "direct",
+      from: "matrix:@alice:example.org",
+      to: "room:!dm:example.org",
+    });
+  });
+});

package/src/session-route.ts

@@ -0,0 +1,113 @@
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import {
+  buildChannelOutboundSessionRoute,
+  type ChannelOutboundSessionRouteParams,
+} from "openclaw/plugin-sdk/channel-core";
+import {
+  loadSessionStore,
+  resolveSessionStoreEntry,
+  resolveStorePath,
+} from "openclaw/plugin-sdk/config-runtime";
+import { resolveMatrixAccountConfig } from "./matrix/account-config.js";
+import { resolveDefaultMatrixAccountId } from "./matrix/accounts.js";
+import { resolveMatrixStoredSessionMeta } from "./matrix/session-store-metadata.js";
+import { resolveMatrixTargetIdentity } from "./matrix/target-ids.js";
+
+function resolveEffectiveMatrixAccountId(
+  params: Pick<ChannelOutboundSessionRouteParams, "cfg" | "accountId">,
+): string {
+  return normalizeAccountId(params.accountId ?? resolveDefaultMatrixAccountId(params.cfg));
+}
+
+function resolveMatrixDmSessionScope(params: {
+  cfg: ChannelOutboundSessionRouteParams["cfg"];
+  accountId: string;
+}): "per-user" | "per-room" {
+  return (
+    resolveMatrixAccountConfig({
+      cfg: params.cfg,
+      accountId: params.accountId,
+    }).dm?.sessionScope ?? "per-user"
+  );
+}
+
+function resolveMatrixCurrentDmRoomId(params: {
+  cfg: ChannelOutboundSessionRouteParams["cfg"];
+  agentId: string;
+  accountId: string;
+  currentSessionKey?: string;
+  targetUserId: string;
+}): string | undefined {
+  const sessionKey = params.currentSessionKey?.trim();
+  if (!sessionKey) {
+    return undefined;
+  }
+  try {
+    const storePath = resolveStorePath(params.cfg.session?.store, {
+      agentId: params.agentId,
+    });
+    const store = loadSessionStore(storePath);
+    const existing = resolveSessionStoreEntry({
+      store,
+      sessionKey,
+    }).existing;
+    const currentSession = resolveMatrixStoredSessionMeta(existing);
+    if (!currentSession) {
+      return undefined;
+    }
+    if (currentSession.accountId && currentSession.accountId !== params.accountId) {
+      return undefined;
+    }
+    if (!currentSession.directUserId || currentSession.directUserId !== params.targetUserId) {
+      return undefined;
+    }
+    return currentSession.roomId;
+  } catch {
+    return undefined;
+  }
+}
+
+export function resolveMatrixOutboundSessionRoute(params: ChannelOutboundSessionRouteParams) {
+  const target =
+    resolveMatrixTargetIdentity(params.resolvedTarget?.to ?? params.target) ??
+    resolveMatrixTargetIdentity(params.target);
+  if (!target) {
+    return null;
+  }
+  const effectiveAccountId = resolveEffectiveMatrixAccountId(params);
+  const roomScopedDmId =
+    target.kind === "user" &&
+    resolveMatrixDmSessionScope({
+      cfg: params.cfg,
+      accountId: effectiveAccountId,
+    }) === "per-room"
+      ? resolveMatrixCurrentDmRoomId({
+          cfg: params.cfg,
+          agentId: params.agentId,
+          accountId: effectiveAccountId,
+          currentSessionKey: params.currentSessionKey,
+          targetUserId: target.id,
+        })
+      : undefined;
+  const peer =
+    roomScopedDmId !== undefined
+      ? { kind: "channel" as const, id: roomScopedDmId }
+      : {
+          kind: target.kind === "user" ? ("direct" as const) : ("channel" as const),
+          id: target.id,
+        };
+  const chatType = target.kind === "user" ? "direct" : "channel";
+  const from = target.kind === "user" ? `matrix:${target.id}` : `matrix:channel:${target.id}`;
+  const to = `room:${roomScopedDmId ?? target.id}`;
+
+  return buildChannelOutboundSessionRoute({
+    cfg: params.cfg,
+    agentId: params.agentId,
+    channel: "matrix",
+    accountId: effectiveAccountId,
+    peer,
+    chatType,
+    from,
+    to,
+  });
+}

package/src/setup-bootstrap.ts

@@ -0,0 +1,94 @@
+import { hasExplicitMatrixAccountConfig } from "./matrix/account-config.js";
+import { resolveMatrixAccountConfig } from "./matrix/accounts.js";
+import { bootstrapMatrixVerification } from "./matrix/actions/verification.js";
+import { formatMatrixErrorMessage } from "./matrix/errors.js";
+import type { RuntimeEnv } from "./runtime-api.js";
+import type { CoreConfig } from "./types.js";
+
+export type MatrixSetupVerificationBootstrapResult = {
+  attempted: boolean;
+  success: boolean;
+  recoveryKeyCreatedAt: string | null;
+  backupVersion: string | null;
+  error?: string;
+};
+
+export async function maybeBootstrapNewEncryptedMatrixAccount(params: {
+  previousCfg: CoreConfig;
+  cfg: CoreConfig;
+  accountId: string;
+}): Promise<MatrixSetupVerificationBootstrapResult> {
+  const accountConfig = resolveMatrixAccountConfig({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+
+  if (
+    hasExplicitMatrixAccountConfig(params.previousCfg, params.accountId) ||
+    accountConfig.encryption !== true
+  ) {
+    return {
+      attempted: false,
+      success: false,
+      recoveryKeyCreatedAt: null,
+      backupVersion: null,
+    };
+  }
+
+  try {
+    const bootstrap = await bootstrapMatrixVerification({ accountId: params.accountId });
+    return {
+      attempted: true,
+      success: bootstrap.success,
+      recoveryKeyCreatedAt: bootstrap.verification.recoveryKeyCreatedAt,
+      backupVersion: bootstrap.verification.backupVersion,
+      ...(bootstrap.success
+        ? {}
+        : { error: bootstrap.error ?? "Matrix verification bootstrap failed" }),
+    };
+  } catch (err) {
+    return {
+      attempted: true,
+      success: false,
+      recoveryKeyCreatedAt: null,
+      backupVersion: null,
+      error: formatMatrixErrorMessage(err),
+    };
+  }
+}
+
+export async function runMatrixSetupBootstrapAfterConfigWrite(params: {
+  previousCfg: CoreConfig;
+  cfg: CoreConfig;
+  accountId: string;
+  runtime: RuntimeEnv;
+}): Promise<void> {
+  const nextAccountConfig = resolveMatrixAccountConfig({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  if (nextAccountConfig.encryption !== true) {
+    return;
+  }
+
+  const bootstrap = await maybeBootstrapNewEncryptedMatrixAccount({
+    previousCfg: params.previousCfg,
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  if (!bootstrap.attempted) {
+    return;
+  }
+  if (bootstrap.success) {
+    params.runtime.log(`Matrix verification bootstrap: complete for "${params.accountId}".`);
+    if (bootstrap.backupVersion) {
+      params.runtime.log(
+        `Matrix backup version for "${params.accountId}": ${bootstrap.backupVersion}`,
+      );
+    }
+    return;
+  }
+  params.runtime.error(
+    `Matrix verification bootstrap warning for "${params.accountId}": ${bootstrap.error ?? "unknown bootstrap failure"}`,
+  );
+}