@kodelyth/tlon 2026.5.39 → 2026.5.42

package/src/core.test.ts

@@ -0,0 +1,298 @@
+import {
+  createPluginSetupWizardConfigure,
+  createPluginSetupWizardStatus,
+  createTestWizardPrompter,
+  runSetupWizardConfigure,
+} from "klaw/plugin-sdk/plugin-test-runtime";
+import type { WizardPrompter } from "klaw/plugin-sdk/plugin-test-runtime";
+import { describe, expect, it, vi } from "vitest";
+import type { KlawConfig } from "../api.js";
+import { TlonAuthorizationSchema, TlonConfigSchema } from "./config-schema.js";
+import { tlonSetupWizard } from "./setup-surface.js";
+import { normalizeShip, resolveTlonOutboundTarget } from "./targets.js";
+import { listTlonAccountIds, resolveTlonAccount } from "./types.js";
+
+const tlonTestPlugin = {
+  id: "tlon",
+  meta: { label: "Tlon" },
+  setupWizard: tlonSetupWizard,
+  config: {
+    listAccountIds: listTlonAccountIds,
+    defaultAccountId: () => "default",
+    resolveAllowFrom: ({ cfg, accountId }: { cfg: KlawConfig; accountId?: string | null }) =>
+      resolveTlonAccount(cfg, accountId).dmAllowlist,
+    formatAllowFrom: ({
+      allowFrom,
+    }: {
+      cfg: KlawConfig;
+      allowFrom: Array<string | number> | undefined | null;
+    }) => {
+      const entries: string[] = [];
+      for (const entry of allowFrom ?? []) {
+        const normalized = normalizeShip(String(entry));
+        if (normalized) {
+          entries.push(normalized);
+        }
+      }
+      return entries;
+    },
+  },
+  setup: {
+    resolveAccountId: ({ accountId }: { cfg: KlawConfig; accountId?: string | null }) =>
+      accountId ?? "default",
+  },
+};
+
+const tlonConfigure = createPluginSetupWizardConfigure(tlonTestPlugin);
+const tlonStatus = createPluginSetupWizardStatus(tlonTestPlugin);
+
+describe("tlon core", () => {
+  it("formats dm allowlist entries through the shared hybrid adapter", () => {
+    expect(
+      tlonTestPlugin.config.formatAllowFrom?.({
+        cfg: {} as KlawConfig,
+        allowFrom: ["zod", " ~nec "],
+      }),
+    ).toEqual(["~zod", "~nec"]);
+  });
+
+  it("returns an empty dm allowlist when the default account is unconfigured", () => {
+    expect(
+      tlonTestPlugin.config.resolveAllowFrom?.({
+        cfg: {} as KlawConfig,
+        accountId: "default",
+      }),
+    ).toStrictEqual([]);
+  });
+
+  it("resolves dm allowlist from the default account", () => {
+    expect(
+      tlonTestPlugin.config.resolveAllowFrom?.({
+        cfg: {
+          channels: {
+            tlon: {
+              ship: "~sampel-palnet",
+              url: "https://urbit.example.com",
+              code: "lidlut-tabwed-pillex-ridrup",
+              dmAllowlist: ["~zod"],
+            },
+          },
+        } as KlawConfig,
+        accountId: "default",
+      }),
+    ).toEqual(["~zod"]);
+  });
+
+  it("accepts channelRules with string keys", () => {
+    const parsed = TlonAuthorizationSchema.parse({
+      channelRules: {
+        "chat/~zod/test": {
+          mode: "open",
+          allowedShips: ["~zod"],
+        },
+      },
+    });
+
+    expect(parsed.channelRules?.["chat/~zod/test"]?.mode).toBe("open");
+  });
+
+  it("accepts accounts with string keys", () => {
+    const parsed = TlonConfigSchema.parse({
+      accounts: {
+        primary: {
+          ship: "~zod",
+          url: "https://example.com",
+          code: "code-123",
+        },
+      },
+    });
+
+    expect(parsed.accounts?.primary?.ship).toBe("~zod");
+  });
+
+  it("exposes group invite allowlists in channel config schema", () => {
+    expect(TlonConfigSchema.parse({ groupInviteAllowlist: ["~zod"] }).groupInviteAllowlist).toEqual(
+      ["~zod"],
+    );
+    expect(
+      TlonConfigSchema.parse({
+        accounts: { primary: { groupInviteAllowlist: ["~nec"] } },
+      }).accounts?.primary?.groupInviteAllowlist,
+    ).toEqual(["~nec"]);
+  });
+
+  it("configures ship, auth, and discovery settings", async () => {
+    const prompter = createTestWizardPrompter({
+      text: vi.fn(async ({ message }: { message: string }) => {
+        if (message === "Ship name") {
+          return "sampel-palnet";
+        }
+        if (message === "Ship URL") {
+          return "https://urbit.example.com";
+        }
+        if (message === "Login code") {
+          return "lidlut-tabwed-pillex-ridrup";
+        }
+        if (message === "Group channels (comma-separated)") {
+          return "chat/~host-ship/general, chat/~host-ship/support";
+        }
+        if (message === "DM allowlist (comma-separated ship names)") {
+          return "~zod, nec";
+        }
+        throw new Error(`Unexpected prompt: ${message}`);
+      }) as WizardPrompter["text"],
+      confirm: vi.fn(async ({ message }: { message: string }) => {
+        if (message === "Add group channels manually? (optional)") {
+          return true;
+        }
+        if (message === "Restrict DMs with an allowlist?") {
+          return true;
+        }
+        if (message === "Enable auto-discovery of group channels?") {
+          return true;
+        }
+        return false;
+      }),
+    });
+
+    const result = await runSetupWizardConfigure({
+      configure: tlonConfigure,
+      cfg: {} as KlawConfig,
+      prompter,
+      options: {},
+    });
+
+    expect(result.accountId).toBe("default");
+    expect(result.cfg.channels?.tlon?.enabled).toBe(true);
+    expect(result.cfg.channels?.tlon?.ship).toBe("~sampel-palnet");
+    expect(result.cfg.channels?.tlon?.url).toBe("https://urbit.example.com");
+    expect(result.cfg.channels?.tlon?.code).toBe("lidlut-tabwed-pillex-ridrup");
+    expect(result.cfg.channels?.tlon?.groupChannels).toEqual([
+      "chat/~host-ship/general",
+      "chat/~host-ship/support",
+    ]);
+    expect(result.cfg.channels?.tlon?.dmAllowlist).toEqual(["~zod", "~nec"]);
+    expect(result.cfg.channels?.tlon?.autoDiscoverChannels).toBe(true);
+    expect(result.cfg.channels?.tlon?.network?.dangerouslyAllowPrivateNetwork).toBe(false);
+  });
+
+  it("resolves dm targets to normalized ships", () => {
+    expect(resolveTlonOutboundTarget("dm/sampel-palnet")).toEqual({
+      ok: true,
+      to: "~sampel-palnet",
+    });
+  });
+
+  it("resolves group targets to canonical chat nests", () => {
+    expect(resolveTlonOutboundTarget("group:host-ship/general")).toEqual({
+      ok: true,
+      to: "chat/~host-ship/general",
+    });
+  });
+
+  it("returns a helpful error for invalid targets", () => {
+    const resolved = resolveTlonOutboundTarget("group:bad-target");
+    expect(resolved.ok).toBe(false);
+    if (resolved.ok) {
+      throw new Error("expected invalid target");
+    }
+    expect(resolved.error.message).toMatch(/invalid tlon target/i);
+  });
+
+  it("lists named accounts and the implicit default account", () => {
+    const cfg = {
+      channels: {
+        tlon: {
+          ship: "~zod",
+          accounts: {
+            Work: { ship: "~bus" },
+            alerts: { ship: "~nec" },
+          },
+        },
+      },
+    } as KlawConfig;
+
+    expect(listTlonAccountIds(cfg)).toEqual(["alerts", "default", "work"]);
+  });
+
+  it("merges named account config over channel defaults", () => {
+    const resolved = resolveTlonAccount(
+      {
+        channels: {
+          tlon: {
+            name: "Base",
+            ship: "~zod",
+            url: "https://urbit.example.com",
+            code: "base-code",
+            dmAllowlist: ["~nec"],
+            groupInviteAllowlist: ["~bus"],
+            defaultAuthorizedShips: ["~marzod"],
+            accounts: {
+              Work: {
+                name: "Work",
+                code: "work-code",
+                dmAllowlist: ["~rovnys"],
+              },
+            },
+          },
+        },
+      } as KlawConfig,
+      "work",
+    );
+
+    expect(resolved.accountId).toBe("work");
+    expect(resolved.name).toBe("Work");
+    expect(resolved.ship).toBe("~zod");
+    expect(resolved.url).toBe("https://urbit.example.com");
+    expect(resolved.code).toBe("work-code");
+    expect(resolved.dmAllowlist).toEqual(["~rovnys"]);
+    expect(resolved.groupInviteAllowlist).toEqual(["~bus"]);
+    expect(resolved.defaultAuthorizedShips).toEqual(["~marzod"]);
+    expect(resolved.configured).toBe(true);
+  });
+
+  it("keeps the default account on channel-level config only", () => {
+    const resolved = resolveTlonAccount(
+      {
+        channels: {
+          tlon: {
+            ship: "~zod",
+            url: "https://urbit.example.com",
+            code: "base-code",
+            accounts: {
+              default: {
+                ship: "~ignored",
+                code: "ignored-code",
+              },
+            },
+          },
+        },
+      } as KlawConfig,
+      "default",
+    );
+
+    expect(resolved.ship).toBe("~zod");
+    expect(resolved.code).toBe("base-code");
+  });
+
+  it("setup status labels the selected account", async () => {
+    const status = await tlonStatus({
+      cfg: {
+        channels: {
+          tlon: {
+            ship: "~zod",
+            url: "https://urbit.example.com",
+            code: "base-code",
+            accounts: {
+              work: {},
+            },
+          },
+        },
+      } as KlawConfig,
+      accountOverrides: { tlon: "work" },
+    });
+
+    expect(status.configured).toBe(true);
+    expect(status.statusLines).toEqual(["Tlon (work): configured"]);
+  });
+});

package/src/doctor-contract.ts

@@ -0,0 +1,9 @@
+import { createLegacyPrivateNetworkDoctorContract } from "klaw/plugin-sdk/ssrf-runtime";
+
+const contract = createLegacyPrivateNetworkDoctorContract({
+  channelKey: "tlon",
+});
+
+export const legacyConfigRules = contract.legacyConfigRules;
+
+export const normalizeCompatibilityConfig = contract.normalizeCompatibilityConfig;

package/src/doctor.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { tlonDoctor } from "./doctor.js";
+
+function getTlonCompatibilityNormalizer(): NonNullable<
+  typeof tlonDoctor.normalizeCompatibilityConfig
+> {
+  const normalize = tlonDoctor.normalizeCompatibilityConfig;
+  if (!normalize) {
+    throw new Error("Expected tlon doctor to expose normalizeCompatibilityConfig");
+  }
+  return normalize;
+}
+
+describe("tlon doctor", () => {
+  it("normalizes legacy private-network aliases", () => {
+    const normalize = getTlonCompatibilityNormalizer();
+
+    const result = normalize({
+      cfg: {
+        channels: {
+          tlon: {
+            allowPrivateNetwork: true,
+            accounts: {
+              alt: {
+                allowPrivateNetwork: false,
+              },
+            },
+          },
+        },
+      } as never,
+    });
+
+    expect(result.config.channels?.tlon?.network).toEqual({
+      dangerouslyAllowPrivateNetwork: true,
+    });
+    expect(
+      (
+        result.config.channels?.tlon?.accounts?.alt as
+          | { network?: Record<string, unknown> }
+          | undefined
+      )?.network,
+    ).toEqual({
+      dangerouslyAllowPrivateNetwork: false,
+    });
+  });
+});

package/src/doctor.ts

@@ -0,0 +1,10 @@
+import type { ChannelDoctorAdapter } from "klaw/plugin-sdk/channel-contract";
+import {
+  legacyConfigRules as TLON_LEGACY_CONFIG_RULES,
+  normalizeCompatibilityConfig as normalizeTlonCompatibilityConfig,
+} from "./doctor-contract.js";
+
+export const tlonDoctor: ChannelDoctorAdapter = {
+  legacyConfigRules: TLON_LEGACY_CONFIG_RULES,
+  normalizeCompatibilityConfig: normalizeTlonCompatibilityConfig,
+};

package/src/logger-runtime.ts

@@ -0,0 +1 @@
+export { createLoggerBackedRuntime } from "klaw/plugin-sdk/runtime";