@kodelyth/zalouser 2026.5.42 → 2026.6.2

package/src/session-route.ts

@@ -1,121 +0,0 @@
-import {
-  buildChannelOutboundSessionRoute,
-  type ChannelOutboundSessionRouteParams,
-} from "klaw/plugin-sdk/core";
-import {
-  normalizeLowercaseStringOrEmpty,
-  normalizeOptionalLowercaseString,
-} from "klaw/plugin-sdk/string-coerce-runtime";
-
-function stripZalouserTargetPrefix(raw: string): string {
-  return raw
-    .trim()
-    .replace(/^(zalouser|zlu):/i, "")
-    .trim();
-}
-
-export function normalizeZalouserTarget(raw: string): string | undefined {
-  const trimmed = stripZalouserTargetPrefix(raw);
-  if (!trimmed) {
-    return undefined;
-  }
-
-  const lower = normalizeLowercaseStringOrEmpty(trimmed);
-  if (lower.startsWith("group:")) {
-    const id = trimmed.slice("group:".length).trim();
-    return id ? `group:${id}` : undefined;
-  }
-  if (lower.startsWith("g:")) {
-    const id = trimmed.slice("g:".length).trim();
-    return id ? `group:${id}` : undefined;
-  }
-  if (lower.startsWith("user:")) {
-    const id = trimmed.slice("user:".length).trim();
-    return id ? `user:${id}` : undefined;
-  }
-  if (lower.startsWith("dm:")) {
-    const id = trimmed.slice("dm:".length).trim();
-    return id ? `user:${id}` : undefined;
-  }
-  if (lower.startsWith("u:")) {
-    const id = trimmed.slice("u:".length).trim();
-    return id ? `user:${id}` : undefined;
-  }
-  if (/^g-\S+$/i.test(trimmed)) {
-    return `group:${trimmed}`;
-  }
-  if (/^u-\S+$/i.test(trimmed)) {
-    return `user:${trimmed}`;
-  }
-
-  return trimmed;
-}
-
-export function parseZalouserOutboundTarget(raw: string): {
-  threadId: string;
-  isGroup: boolean;
-} {
-  const normalized = normalizeZalouserTarget(raw);
-  if (!normalized) {
-    throw new Error("Zalouser target is required");
-  }
-  const lowered = normalizeLowercaseStringOrEmpty(normalized);
-  if (lowered.startsWith("group:")) {
-    const threadId = normalized.slice("group:".length).trim();
-    if (!threadId) {
-      throw new Error("Zalouser group target is missing group id");
-    }
-    return { threadId, isGroup: true };
-  }
-  if (lowered.startsWith("user:")) {
-    const threadId = normalized.slice("user:".length).trim();
-    if (!threadId) {
-      throw new Error("Zalouser user target is missing user id");
-    }
-    return { threadId, isGroup: false };
-  }
-  // Backward-compatible fallback for bare IDs.
-  // Group sends should use explicit `group:<id>` targets.
-  return { threadId: normalized, isGroup: false };
-}
-
-export function parseZalouserDirectoryGroupId(raw: string): string {
-  const normalized = normalizeZalouserTarget(raw);
-  if (!normalized) {
-    throw new Error("Zalouser group target is required");
-  }
-  const lowered = normalizeLowercaseStringOrEmpty(normalized);
-  if (lowered.startsWith("group:")) {
-    const groupId = normalized.slice("group:".length).trim();
-    if (!groupId) {
-      throw new Error("Zalouser group target is missing group id");
-    }
-    return groupId;
-  }
-  if (lowered.startsWith("user:")) {
-    throw new Error("Zalouser group members lookup requires a group target (group:<id>)");
-  }
-  return normalized;
-}
-
-export function resolveZalouserOutboundSessionRoute(params: ChannelOutboundSessionRouteParams) {
-  const normalized = normalizeZalouserTarget(params.target);
-  if (!normalized) {
-    return null;
-  }
-  const isGroup = (normalizeOptionalLowercaseString(normalized) ?? "").startsWith("group:");
-  const peerId = normalized.replace(/^(group|user):/i, "").trim();
-  return buildChannelOutboundSessionRoute({
-    cfg: params.cfg,
-    agentId: params.agentId,
-    channel: "zalouser",
-    accountId: params.accountId,
-    peer: {
-      kind: isGroup ? "group" : "direct",
-      id: peerId,
-    },
-    chatType: isGroup ? "group" : "direct",
-    from: isGroup ? `zalouser:group:${peerId}` : `zalouser:${peerId}`,
-    to: `zalouser:${peerId}`,
-  });
-}

package/src/setup-core.ts

@@ -1,36 +0,0 @@
-import {
-  createDelegatedSetupWizardProxy,
-  createPatchedAccountSetupAdapter,
-  createSetupTranslator,
-  type ChannelSetupWizard,
-} from "klaw/plugin-sdk/setup-runtime";
-
-const t = createSetupTranslator();
-
-const channel = "zalouser" as const;
-
-export const zalouserSetupAdapter = createPatchedAccountSetupAdapter({
-  channelKey: channel,
-  validateInput: () => null,
-  buildPatch: () => ({}),
-});
-
-export function createZalouserSetupWizardProxy(
-  loadWizard: () => Promise<ChannelSetupWizard>,
-): ChannelSetupWizard {
-  return createDelegatedSetupWizardProxy({
-    channel,
-    loadWizard,
-    status: {
-      configuredLabel: t("wizard.channels.statusLoggedIn"),
-      unconfiguredLabel: t("wizard.channels.statusNeedsQrLogin"),
-      configuredHint: t("wizard.channels.statusRecommendedLoggedIn"),
-      unconfiguredHint: t("wizard.channels.statusRecommendedQrLogin"),
-      configuredScore: 1,
-      unconfiguredScore: 15,
-    },
-    credentials: [],
-    delegatePrepare: true,
-    delegateFinalize: true,
-  });
-}

package/src/setup-surface.test.ts

@@ -1,367 +0,0 @@
-import {
-  createPluginSetupWizardConfigure,
-  createTestWizardPrompter,
-  runSetupWizardConfigure,
-} from "klaw/plugin-sdk/plugin-test-runtime";
-import { describe, expect, it, vi } from "vitest";
-import type { KlawConfig } from "../runtime-api.js";
-import "./zalo-js.test-mocks.js";
-import { zalouserSetupWizard } from "./setup-surface.js";
-import { zalouserSetupPlugin } from "./setup-test-helpers.js";
-
-const zalouserConfigure = createPluginSetupWizardConfigure(zalouserSetupPlugin);
-
-async function runSetup(params: {
-  cfg?: KlawConfig;
-  prompter: ReturnType<typeof createTestWizardPrompter>;
-  options?: Record<string, unknown>;
-  forceAllowFrom?: boolean;
-}) {
-  return await runSetupWizardConfigure({
-    configure: zalouserConfigure,
-    cfg: params.cfg,
-    prompter: params.prompter,
-    options: params.options,
-    forceAllowFrom: params.forceAllowFrom,
-  });
-}
-
-describe("zalouser setup wizard", () => {
-  function expectEnabledDefaultSetup(
-    result: Awaited<ReturnType<typeof runSetup>>,
-    dmPolicy?: "pairing" | "allowlist",
-  ) {
-    expect(result.accountId).toBe("default");
-    const channelConfig = result.cfg.channels?.zalouser;
-    if (!channelConfig) {
-      throw new Error("expected Zalo Personal channel config");
-    }
-    const pluginEntry = result.cfg.plugins?.entries?.zalouser;
-    if (!pluginEntry) {
-      throw new Error("expected Zalo Personal plugin entry");
-    }
-    expect(channelConfig.enabled).toBe(true);
-    expect(pluginEntry.enabled).toBe(true);
-    if (dmPolicy) {
-      expect(channelConfig.dmPolicy).toBe(dmPolicy);
-    }
-  }
-
-  function createQuickstartPrompter(params?: {
-    note?: ReturnType<typeof createTestWizardPrompter>["note"];
-    seen?: string[];
-    dmPolicy?: "pairing" | "allowlist";
-    groupAccess?: boolean;
-    groupPolicy?: "allowlist";
-    textByMessage?: Record<string, string>;
-  }) {
-    const select = vi.fn(
-      async ({ message, options }: { message: string; options: Array<{ value: string }> }) => {
-        const first = options[0];
-        if (!first) {
-          throw new Error("no options");
-        }
-        params?.seen?.push(message);
-        if (message === "Zalo Personal DM policy" && params?.dmPolicy) {
-          return params.dmPolicy;
-        }
-        if (message === "Zalo groups access" && params?.groupPolicy) {
-          return params.groupPolicy;
-        }
-        return first.value;
-      },
-    ) as ReturnType<typeof createTestWizardPrompter>["select"];
-    const text = vi.fn(
-      async ({ message }: { message: string }) => params?.textByMessage?.[message] ?? "",
-    ) as ReturnType<typeof createTestWizardPrompter>["text"];
-    return createTestWizardPrompter({
-      ...(params?.note ? { note: params.note } : {}),
-      confirm: vi.fn(async ({ message }: { message: string }) => {
-        params?.seen?.push(message);
-        if (message === "Login via QR code now?") {
-          return false;
-        }
-        if (message === "Configure Zalo groups access?") {
-          return params?.groupAccess ?? false;
-        }
-        return false;
-      }),
-      select,
-      text,
-    });
-  }
-
-  it("enables the account without forcing QR login", async () => {
-    const prompter = createTestWizardPrompter({
-      confirm: vi.fn(async ({ message }: { message: string }) => {
-        if (message === "Login via QR code now?") {
-          return false;
-        }
-        if (message === "Configure Zalo groups access?") {
-          return false;
-        }
-        return false;
-      }),
-    });
-
-    const result = await runSetup({ prompter });
-
-    expectEnabledDefaultSetup(result);
-  });
-
-  it("prompts DM policy before group access in quickstart", async () => {
-    const seen: string[] = [];
-    const prompter = createQuickstartPrompter({ seen, dmPolicy: "pairing" });
-
-    const result = await runSetup({
-      prompter,
-      options: { quickstartDefaults: true },
-    });
-
-    expectEnabledDefaultSetup(result, "pairing");
-    expect(seen.indexOf("Zalo Personal DM policy")).toBeGreaterThanOrEqual(0);
-    expect(seen.indexOf("Configure Zalo groups access?")).toBeGreaterThanOrEqual(0);
-    expect(seen.indexOf("Zalo Personal DM policy")).toBeLessThan(
-      seen.indexOf("Configure Zalo groups access?"),
-    );
-  });
-
-  it("allows an empty quickstart DM allowlist with a warning", async () => {
-    const note = vi.fn(async (_message: string, _title?: string) => {});
-    const prompter = createQuickstartPrompter({
-      note,
-      dmPolicy: "allowlist",
-      textByMessage: {
-        "Zalouser allowFrom (name or user id)": "",
-      },
-    });
-
-    const result = await runSetup({
-      prompter,
-      options: { quickstartDefaults: true },
-    });
-
-    expectEnabledDefaultSetup(result, "allowlist");
-    expect(result.cfg.channels?.zalouser?.allowFrom).toStrictEqual([]);
-    expect(
-      note.mock.calls.some(([message]) => message.includes("No DM allowlist entries added yet.")),
-    ).toBe(true);
-  });
-
-  it("allows an empty group allowlist with a warning", async () => {
-    const note = vi.fn(async (_message: string, _title?: string) => {});
-    const prompter = createQuickstartPrompter({
-      note,
-      groupAccess: true,
-      groupPolicy: "allowlist",
-      textByMessage: {
-        "Zalo groups allowlist (comma-separated)": "",
-      },
-    });
-
-    const result = await runSetup({ prompter });
-
-    expect(result.cfg.channels?.zalouser?.groupPolicy).toBe("allowlist");
-    expect(result.cfg.channels?.zalouser?.groups).toStrictEqual({});
-    expect(
-      note.mock.calls.some(([message]) =>
-        message.includes("No group allowlist entries added yet."),
-      ),
-    ).toBe(true);
-  });
-
-  it("writes canonical enabled entries for configured groups", async () => {
-    const prompter = createQuickstartPrompter({
-      groupAccess: true,
-      groupPolicy: "allowlist",
-      textByMessage: {
-        "Zalo groups allowlist (comma-separated)": "Family, Work",
-      },
-    });
-
-    const result = await runSetup({ prompter });
-
-    expect(result.cfg.channels?.zalouser?.groups).toEqual({
-      Family: { enabled: true, requireMention: true },
-      Work: { enabled: true, requireMention: true },
-    });
-  });
-
-  it("preserves non-quickstart forceAllowFrom behavior", async () => {
-    const note = vi.fn(async (_message: string, _title?: string) => {});
-    const seen: string[] = [];
-    const prompter = createTestWizardPrompter({
-      note,
-      confirm: vi.fn(async ({ message }: { message: string }) => {
-        seen.push(message);
-        if (message === "Login via QR code now?") {
-          return false;
-        }
-        if (message === "Configure Zalo groups access?") {
-          return false;
-        }
-        return false;
-      }),
-      text: vi.fn(async ({ message }: { message: string }) => {
-        seen.push(message);
-        if (message === "Zalouser allowFrom (name or user id)") {
-          return "";
-        }
-        return "";
-      }) as ReturnType<typeof createTestWizardPrompter>["text"],
-    });
-
-    const result = await runSetup({ prompter, forceAllowFrom: true });
-
-    expect(result.cfg.channels?.zalouser?.dmPolicy).toBe("allowlist");
-    expect(result.cfg.channels?.zalouser?.allowFrom).toStrictEqual([]);
-    expect(seen).not.toContain("Zalo Personal DM policy");
-    expect(seen).toContain("Zalouser allowFrom (name or user id)");
-    expect(
-      note.mock.calls.some(([message]) => message.includes("No DM allowlist entries added yet.")),
-    ).toBe(true);
-  });
-
-  it("allowlists the plugin when a plugin allowlist already exists", async () => {
-    const prompter = createTestWizardPrompter({
-      confirm: vi.fn(async ({ message }: { message: string }) => {
-        if (message === "Login via QR code now?") {
-          return false;
-        }
-        if (message === "Configure Zalo groups access?") {
-          return false;
-        }
-        return false;
-      }),
-    });
-
-    const result = await runSetup({
-      cfg: {
-        plugins: {
-          allow: ["telegram"],
-        },
-      } as KlawConfig,
-      prompter,
-    });
-
-    expect(result.cfg.plugins?.entries?.zalouser?.enabled).toBe(true);
-    expect(result.cfg.plugins?.allow).toEqual(["telegram", "zalouser"]);
-  });
-
-  it("reads the named-account DM policy instead of the channel root", () => {
-    expect(
-      zalouserSetupWizard.dmPolicy?.getCurrent(
-        {
-          channels: {
-            zalouser: {
-              dmPolicy: "disabled",
-              accounts: {
-                work: {
-                  profile: "work",
-                  dmPolicy: "allowlist",
-                },
-              },
-            },
-          },
-        } as KlawConfig,
-        "work",
-      ),
-    ).toBe("allowlist");
-  });
-
-  it("reports account-scoped config keys for named accounts", () => {
-    expect(zalouserSetupWizard.dmPolicy?.resolveConfigKeys?.({} as KlawConfig, "work")).toEqual({
-      policyKey: "channels.zalouser.accounts.work.dmPolicy",
-      allowFromKey: "channels.zalouser.accounts.work.allowFrom",
-    });
-  });
-
-  it("uses configured defaultAccount for omitted DM policy account context", () => {
-    const cfg = {
-      channels: {
-        zalouser: {
-          defaultAccount: "work",
-          dmPolicy: "disabled",
-          allowFrom: ["123456789"],
-          accounts: {
-            work: {
-              dmPolicy: "allowlist",
-              profile: "work-profile",
-            },
-          },
-        },
-      },
-    } as KlawConfig;
-
-    expect(zalouserSetupWizard.dmPolicy?.getCurrent(cfg)).toBe("allowlist");
-    expect(zalouserSetupWizard.dmPolicy?.resolveConfigKeys?.(cfg)).toEqual({
-      policyKey: "channels.zalouser.accounts.work.dmPolicy",
-      allowFromKey: "channels.zalouser.accounts.work.allowFrom",
-    });
-
-    const next = zalouserSetupWizard.dmPolicy?.setPolicy(cfg, "open");
-    expect(next?.channels?.zalouser?.dmPolicy).toBe("disabled");
-    const workAccount = next?.channels?.zalouser?.accounts?.work as
-      | { dmPolicy?: string; allowFrom?: Array<string | number> }
-      | undefined;
-    expect(workAccount?.dmPolicy).toBe("open");
-  });
-
-  it('writes open policy state to the named account and preserves inherited allowFrom with "*"', () => {
-    const next = zalouserSetupWizard.dmPolicy?.setPolicy(
-      {
-        channels: {
-          zalouser: {
-            allowFrom: ["123456789"],
-            accounts: {
-              work: {
-                profile: "work",
-              },
-            },
-          },
-        },
-      } as KlawConfig,
-      "open",
-      "work",
-    );
-
-    expect(next?.channels?.zalouser?.dmPolicy).toBeUndefined();
-    const workAccount = next?.channels?.zalouser?.accounts?.work as
-      | { dmPolicy?: string; allowFrom?: Array<string | number> }
-      | undefined;
-    expect(workAccount?.dmPolicy).toBe("open");
-    expect(workAccount?.allowFrom).toEqual(["123456789", "*"]);
-  });
-
-  it("shows the account-scoped current DM policy in quickstart notes", async () => {
-    const note = vi.fn(async (_message: string, _title?: string) => {});
-    const prompter = createQuickstartPrompter({ note, dmPolicy: "pairing" });
-
-    await runSetupWizardConfigure({
-      configure: zalouserConfigure,
-      cfg: {
-        channels: {
-          zalouser: {
-            dmPolicy: "disabled",
-            accounts: {
-              work: {
-                profile: "work",
-                dmPolicy: "allowlist",
-                allowFrom: ["123456789"],
-              },
-            },
-          },
-        },
-      } as KlawConfig,
-      prompter,
-      options: { quickstartDefaults: true },
-      accountOverrides: { zalouser: "work" },
-    });
-
-    expect(
-      note.mock.calls.some(([message]) =>
-        message.includes("Current: dmPolicy=allowlist, allowFrom=123456789"),
-      ),
-    ).toBe(true);
-  });
-});