@kodelyth/tlon 2026.5.39 → 2026.5.42

package/README.md

@@ -0,0 +1,5 @@
+# Tlon (Klaw plugin)
+
+Tlon/Urbit channel plugin for Klaw. Supports DMs, group mentions, and thread replies.
+
+Docs: https://klaw.kodelyth.com/channels/tlon

package/api.ts

@@ -0,0 +1,16 @@
+export {
+  createDedupeCache,
+  createLoggerBackedRuntime,
+  fetchWithSsrFGuard,
+  isBlockedHostnameOrIp,
+  type LookupFn,
+  type KlawConfig,
+  type ReplyPayload,
+  type RuntimeEnv,
+  SsrFBlockedError,
+  type SsrFPolicy,
+  ssrfPolicyFromAllowPrivateNetwork,
+  ssrfPolicyFromDangerouslyAllowPrivateNetwork,
+} from "./runtime-api.js";
+export { tlonPlugin } from "./src/channel.js";
+export { setTlonRuntime } from "./src/runtime.js";

package/channel-plugin-api.ts

@@ -0,0 +1 @@
+export { tlonPlugin } from "./src/channel.js";

package/dist/api.js

@@ -0,0 +1,4 @@
+import { a as ssrfPolicyFromAllowPrivateNetwork, i as isBlockedHostnameOrIp, n as createDedupeCache, o as ssrfPolicyFromDangerouslyAllowPrivateNetwork, r as fetchWithSsrFGuard, s as createLoggerBackedRuntime, t as SsrFBlockedError } from "./runtime-api-Dq8wkBC_.js";
+import { t as tlonPlugin } from "./channel-Bvzym9ez.js";
+import { n as setTlonRuntime } from "./runtime-BmSb9A-q.js";
+export { SsrFBlockedError, createDedupeCache, createLoggerBackedRuntime, fetchWithSsrFGuard, isBlockedHostnameOrIp, setTlonRuntime, ssrfPolicyFromAllowPrivateNetwork, ssrfPolicyFromDangerouslyAllowPrivateNetwork, tlonPlugin };

package/dist/channel-Bvzym9ez.js

@@ -0,0 +1,236 @@
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-Ip6FcHDH.js";
+import { a as tlonSetupAdapter, d as formatTargetHint, f as normalizeShip, h as resolveTlonOutboundTarget, l as listTlonAccountIds, m as parseTlonTarget, n as createTlonSetupWizardBase, u as resolveTlonAccount } from "./setup-core-CF3ryHqs.js";
+import { buildChannelOutboundSessionRoute } from "klaw/plugin-sdk/core";
+import { describeAccountSnapshot } from "klaw/plugin-sdk/account-helpers";
+import { DEFAULT_ACCOUNT_ID } from "klaw/plugin-sdk/account-id";
+import { createHybridChannelConfigAdapter } from "klaw/plugin-sdk/channel-config-helpers";
+import { createChatChannelPlugin } from "klaw/plugin-sdk/channel-core";
+import { createChannelMessageAdapterFromOutbound } from "klaw/plugin-sdk/channel-message";
+import { createLazyRuntimeModule } from "klaw/plugin-sdk/lazy-runtime";
+import { createRuntimeOutboundDelegates } from "klaw/plugin-sdk/outbound-runtime";
+import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "klaw/plugin-sdk/status-helpers";
+import { buildChannelConfigSchema } from "klaw/plugin-sdk/channel-config-schema";
+import { z } from "zod";
+//#region extensions/tlon/src/config-schema.ts
+const ShipSchema = z.string().min(1);
+const ChannelNestSchema = z.string().min(1);
+const TlonChannelRuleSchema = z.object({
+	mode: z.enum(["restricted", "open"]).optional(),
+	allowedShips: z.array(ShipSchema).optional()
+});
+const TlonAuthorizationSchema = z.object({ channelRules: z.record(z.string(), TlonChannelRuleSchema).optional() });
+const TlonNetworkSchema = z.object({ dangerouslyAllowPrivateNetwork: z.boolean().optional() }).strict().optional();
+const tlonCommonConfigFields = {
+	name: z.string().optional(),
+	enabled: z.boolean().optional(),
+	ship: ShipSchema.optional(),
+	url: z.string().optional(),
+	code: z.string().optional(),
+	network: TlonNetworkSchema,
+	groupChannels: z.array(ChannelNestSchema).optional(),
+	dmAllowlist: z.array(ShipSchema).optional(),
+	groupInviteAllowlist: z.array(ShipSchema).optional(),
+	autoDiscoverChannels: z.boolean().optional(),
+	showModelSignature: z.boolean().optional(),
+	responsePrefix: z.string().optional(),
+	autoAcceptDmInvites: z.boolean().optional(),
+	autoAcceptGroupInvites: z.boolean().optional(),
+	ownerShip: ShipSchema.optional()
+};
+const TlonAccountSchema = z.object({ ...tlonCommonConfigFields });
+const tlonChannelConfigSchema = buildChannelConfigSchema(z.object({
+	...tlonCommonConfigFields,
+	authorization: TlonAuthorizationSchema.optional(),
+	defaultAuthorizedShips: z.array(ShipSchema).optional(),
+	accounts: z.record(z.string(), TlonAccountSchema).optional()
+}));
+//#endregion
+//#region extensions/tlon/src/doctor.ts
+const tlonDoctor = {
+	legacyConfigRules,
+	normalizeCompatibilityConfig
+};
+//#endregion
+//#region extensions/tlon/src/session-route.ts
+function resolveTlonOutboundSessionRoute(params) {
+	const parsed = parseTlonTarget(params.target);
+	if (!parsed) return null;
+	if (parsed.kind === "group") return buildChannelOutboundSessionRoute({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "tlon",
+		accountId: params.accountId,
+		peer: {
+			kind: "group",
+			id: parsed.nest
+		},
+		chatType: "group",
+		from: `tlon:group:${parsed.nest}`,
+		to: `tlon:${parsed.nest}`
+	});
+	return buildChannelOutboundSessionRoute({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "tlon",
+		accountId: params.accountId,
+		peer: {
+			kind: "direct",
+			id: parsed.ship
+		},
+		chatType: "direct",
+		from: `tlon:${parsed.ship}`,
+		to: `tlon:${parsed.ship}`
+	});
+}
+//#endregion
+//#region extensions/tlon/src/channel.ts
+const TLON_CHANNEL_ID = "tlon";
+const loadTlonChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-CDY2BdfM.js"));
+const tlonSetupWizardProxy = createTlonSetupWizardBase({
+	resolveConfigured: async ({ cfg, accountId }) => await (await loadTlonChannelRuntime()).tlonSetupWizard.status.resolveConfigured({
+		cfg,
+		accountId
+	}),
+	resolveStatusLines: async ({ cfg, accountId, configured }) => await (await loadTlonChannelRuntime()).tlonSetupWizard.status.resolveStatusLines?.({
+		cfg,
+		accountId,
+		configured
+	}) ?? [],
+	finalize: async (params) => await (await loadTlonChannelRuntime()).tlonSetupWizard.finalize(params)
+});
+const tlonConfigAdapter = createHybridChannelConfigAdapter({
+	sectionKey: TLON_CHANNEL_ID,
+	listAccountIds: listTlonAccountIds,
+	resolveAccount: resolveTlonAccount,
+	defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+	clearBaseFields: [
+		"ship",
+		"code",
+		"url",
+		"name"
+	],
+	preserveSectionOnDefaultDelete: true,
+	resolveAllowFrom: (account) => account.dmAllowlist,
+	formatAllowFrom: (allowFrom) => allowFrom.map((entry) => normalizeShip(String(entry))).filter(Boolean)
+});
+const tlonChannelOutbound = {
+	deliveryMode: "direct",
+	textChunkLimit: 1e4,
+	resolveTarget: ({ to }) => resolveTlonOutboundTarget(to),
+	deliveryCapabilities: { durableFinal: {
+		text: true,
+		media: true,
+		replyTo: true,
+		thread: true,
+		messageSendingHooks: true
+	} },
+	...createRuntimeOutboundDelegates({
+		getRuntime: loadTlonChannelRuntime,
+		sendText: { resolve: (runtime) => runtime.tlonRuntimeOutbound.sendText },
+		sendMedia: { resolve: (runtime) => runtime.tlonRuntimeOutbound.sendMedia }
+	})
+};
+const tlonMessageAdapter = createChannelMessageAdapterFromOutbound({
+	id: TLON_CHANNEL_ID,
+	outbound: tlonChannelOutbound
+});
+const tlonPlugin = createChatChannelPlugin({
+	base: {
+		id: TLON_CHANNEL_ID,
+		meta: {
+			id: TLON_CHANNEL_ID,
+			label: "Tlon",
+			selectionLabel: "Tlon (Urbit)",
+			docsPath: "/channels/tlon",
+			docsLabel: "tlon",
+			blurb: "Decentralized messaging on Urbit",
+			aliases: ["urbit"],
+			order: 90
+		},
+		capabilities: {
+			chatTypes: [
+				"direct",
+				"group",
+				"thread"
+			],
+			media: true,
+			reply: true,
+			threads: true
+		},
+		setup: tlonSetupAdapter,
+		setupWizard: tlonSetupWizardProxy,
+		reload: { configPrefixes: ["channels.tlon"] },
+		configSchema: tlonChannelConfigSchema,
+		config: {
+			...tlonConfigAdapter,
+			isConfigured: (account) => account.configured,
+			describeAccount: (account) => describeAccountSnapshot({
+				account,
+				configured: account.configured,
+				extra: {
+					ship: account.ship,
+					url: account.url
+				}
+			})
+		},
+		doctor: tlonDoctor,
+		messaging: {
+			targetPrefixes: ["tlon"],
+			normalizeTarget: (target) => {
+				const parsed = parseTlonTarget(target);
+				if (!parsed) return target.trim();
+				if (parsed.kind === "dm") return parsed.ship;
+				return parsed.nest;
+			},
+			targetResolver: {
+				looksLikeId: (target) => Boolean(parseTlonTarget(target)),
+				hint: formatTargetHint()
+			},
+			resolveOutboundSessionRoute: (params) => resolveTlonOutboundSessionRoute(params)
+		},
+		message: tlonMessageAdapter,
+		status: createComputedAccountStatusAdapter({
+			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+			collectStatusIssues: (accounts) => {
+				return accounts.flatMap((account) => {
+					if (!account.configured) return [{
+						channel: TLON_CHANNEL_ID,
+						accountId: account.accountId,
+						kind: "config",
+						message: "Account not configured (missing ship, code, or url)"
+					}];
+					return [];
+				});
+			},
+			buildChannelSummary: ({ snapshot }) => {
+				const s = snapshot;
+				return {
+					configured: s.configured ?? false,
+					ship: s.ship ?? null,
+					url: s.url ?? null
+				};
+			},
+			probeAccount: async ({ account }) => {
+				if (!account.configured || !account.ship || !account.url || !account.code) return {
+					ok: false,
+					error: "Not configured"
+				};
+				return await (await loadTlonChannelRuntime()).probeTlonAccount(account);
+			},
+			resolveAccountSnapshot: ({ account }) => ({
+				accountId: account.accountId,
+				name: account.name ?? void 0,
+				enabled: account.enabled,
+				configured: account.configured,
+				extra: {
+					ship: account.ship,
+					url: account.url
+				}
+			})
+		}),
+		gateway: { startAccount: async (ctx) => await (await loadTlonChannelRuntime()).startTlonGatewayAccount(ctx) }
+	},
+	outbound: tlonChannelOutbound
+});
+//#endregion
+export { tlonPlugin as t };

package/dist/channel-plugin-api.js

@@ -0,0 +1,2 @@
+import { t as tlonPlugin } from "./channel-Bvzym9ez.js";
+export { tlonPlugin };