@kodelyth/tlon 2026.5.39 → 2026.5.42

package/src/setup-surface.ts

@@ -0,0 +1,99 @@
+import { createSetupTranslator } from "klaw/plugin-sdk/setup-runtime";
+import {
+  applyTlonSetupConfig,
+  createTlonSetupWizardBase,
+  resolveTlonSetupConfigured,
+  resolveTlonSetupStatusLines,
+} from "./setup-core.js";
+import { normalizeShip } from "./targets.js";
+import { resolveTlonAccount } from "./types.js";
+import { isBlockedUrbitHostname, validateUrbitBaseUrl } from "./urbit/base-url.js";
+
+const t = createSetupTranslator();
+
+function parseList(value: string): string[] {
+  return value
+    .split(/[\n,;]+/g)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+export const tlonSetupWizard = createTlonSetupWizardBase({
+  resolveConfigured: async ({ cfg, accountId }) => await resolveTlonSetupConfigured(cfg, accountId),
+  resolveStatusLines: async ({ cfg, accountId }) =>
+    await resolveTlonSetupStatusLines(cfg, accountId),
+  finalize: async ({ cfg, accountId, prompter }) => {
+    let next = cfg;
+    const resolved = resolveTlonAccount(next, accountId);
+    const validatedUrl = validateUrbitBaseUrl(resolved.url ?? "");
+    if (!validatedUrl.ok) {
+      throw new Error(`Invalid URL: ${validatedUrl.error}`);
+    }
+
+    let dangerouslyAllowPrivateNetwork = resolved.dangerouslyAllowPrivateNetwork ?? false;
+    if (isBlockedUrbitHostname(validatedUrl.hostname)) {
+      dangerouslyAllowPrivateNetwork = await prompter.confirm({
+        message: t("wizard.tlon.privateNetworkPrompt"),
+        initialValue: dangerouslyAllowPrivateNetwork,
+      });
+      if (!dangerouslyAllowPrivateNetwork) {
+        throw new Error("Refusing private/internal ship URL without explicit network opt-in");
+      }
+    }
+    next = applyTlonSetupConfig({
+      cfg: next,
+      accountId,
+      input: { dangerouslyAllowPrivateNetwork },
+    });
+
+    const currentGroups = resolved.groupChannels;
+    const wantsGroupChannels = await prompter.confirm({
+      message: t("wizard.tlon.addGroupsPrompt"),
+      initialValue: currentGroups.length > 0,
+    });
+    if (wantsGroupChannels) {
+      const entry = await prompter.text({
+        message: t("wizard.tlon.groupChannelsPrompt"),
+        placeholder: "chat/~host-ship/general, chat/~host-ship/support",
+        initialValue: currentGroups.join(", ") || undefined,
+      });
+      next = applyTlonSetupConfig({
+        cfg: next,
+        accountId,
+        input: { groupChannels: parseList(entry ?? "") },
+      });
+    }
+
+    const currentAllowlist = resolved.dmAllowlist;
+    const wantsAllowlist = await prompter.confirm({
+      message: t("wizard.tlon.restrictDmsPrompt"),
+      initialValue: currentAllowlist.length > 0,
+    });
+    if (wantsAllowlist) {
+      const entry = await prompter.text({
+        message: t("wizard.tlon.dmAllowlistPrompt"),
+        placeholder: "~zod, ~nec",
+        initialValue: currentAllowlist.join(", ") || undefined,
+      });
+      next = applyTlonSetupConfig({
+        cfg: next,
+        accountId,
+        input: {
+          dmAllowlist: parseList(entry ?? "").map((ship) => normalizeShip(ship)),
+        },
+      });
+    }
+
+    const autoDiscoverChannels = await prompter.confirm({
+      message: t("wizard.tlon.autoDiscoveryPrompt"),
+      initialValue: resolved.autoDiscoverChannels ?? true,
+    });
+    next = applyTlonSetupConfig({
+      cfg: next,
+      accountId,
+      input: { autoDiscoverChannels },
+    });
+
+    return { cfg: next };
+  },
+});

package/src/targets.ts

@@ -0,0 +1,102 @@
+type TlonTarget =
+  | { kind: "dm"; ship: string }
+  | { kind: "group"; nest: string; hostShip: string; channelName: string };
+
+const SHIP_RE = /^~?[a-z-]+$/i;
+const NEST_RE = /^chat\/([^/]+)\/([^/]+)$/i;
+
+export function normalizeShip(raw: string): string {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  return trimmed.startsWith("~") ? trimmed : `~${trimmed}`;
+}
+
+export function parseChannelNest(raw: string): { hostShip: string; channelName: string } | null {
+  const match = NEST_RE.exec(raw.trim());
+  if (!match) {
+    return null;
+  }
+  const hostShip = normalizeShip(match[1]);
+  const channelName = match[2];
+  return { hostShip, channelName };
+}
+
+function makeGroupTarget(parsed: { hostShip: string; channelName: string }): TlonTarget {
+  return {
+    kind: "group",
+    nest: `chat/${parsed.hostShip}/${parsed.channelName}`,
+    hostShip: parsed.hostShip,
+    channelName: parsed.channelName,
+  };
+}
+
+export function parseTlonTarget(raw?: string | null): TlonTarget | null {
+  const trimmed = raw?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const withoutPrefix = trimmed.replace(/^tlon:/i, "");
+
+  const dmPrefix = withoutPrefix.match(/^dm[/:](.+)$/i);
+  if (dmPrefix) {
+    return { kind: "dm", ship: normalizeShip(dmPrefix[1]) };
+  }
+
+  const groupPrefix = withoutPrefix.match(/^(group|room)[/:](.+)$/i);
+  if (groupPrefix) {
+    const groupTarget = groupPrefix[2].trim();
+    if (groupTarget.startsWith("chat/")) {
+      const parsed = parseChannelNest(groupTarget);
+      if (!parsed) {
+        return null;
+      }
+      return makeGroupTarget(parsed);
+    }
+    const parts = groupTarget.split("/");
+    if (parts.length === 2) {
+      const hostShip = normalizeShip(parts[0]);
+      const channelName = parts[1];
+      return {
+        kind: "group",
+        nest: `chat/${hostShip}/${channelName}`,
+        hostShip,
+        channelName,
+      };
+    }
+    return null;
+  }
+
+  if (withoutPrefix.startsWith("chat/")) {
+    const parsed = parseChannelNest(withoutPrefix);
+    if (!parsed) {
+      return null;
+    }
+    return makeGroupTarget(parsed);
+  }
+
+  if (SHIP_RE.test(withoutPrefix)) {
+    return { kind: "dm", ship: normalizeShip(withoutPrefix) };
+  }
+
+  return null;
+}
+
+export function resolveTlonOutboundTarget(to?: string | null) {
+  const parsed = parseTlonTarget(to ?? "");
+  if (!parsed) {
+    return {
+      ok: false as const,
+      error: new Error(`Invalid Tlon target. Use ${formatTargetHint()}`),
+    };
+  }
+  if (parsed.kind === "dm") {
+    return { ok: true as const, to: parsed.ship };
+  }
+  return { ok: true as const, to: parsed.nest };
+}
+
+export function formatTargetHint(): string {
+  return "dm/~sampel-palnet | ~sampel-palnet | chat/~host-ship/channel | group:~host-ship/channel";
+}