@pixelzx/genesis 2026.5.5-3 → 2026.5.5-4

package/dist/channel-D2kKLWUA.js

@@ -0,0 +1,226 @@
+import { r as buildChannelConfigSchema } from "./config-schema-BEt8F1Tk.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-C3j_3_su.js";
+import { r as createLazyRuntimeModule } from "./lazy-runtime-02MY_g6C.js";
+import { i as createHybridChannelConfigAdapter } from "./channel-config-helpers-Bn_khg_r.js";
+import { n as describeAccountSnapshot } from "./account-helpers-PRuprToh.js";
+import { i as createChatChannelPlugin, t as buildChannelOutboundSessionRoute } from "./core-DbPzffGG.js";
+import "./channel-core-DqPUhmTt.js";
+import "./channel-config-schema-B1jO952s.js";
+import { n as createRuntimeOutboundDelegates } from "./runtime-forwarders-XQ8FxOC6.js";
+import { d as createDefaultChannelRuntimeState, u as createComputedAccountStatusAdapter } from "./status-helpers-BPJZpVuU.js";
+import "./outbound-runtime-DZyO1T_R.js";
+import { r as createLegacyPrivateNetworkDoctorContract } from "./ssrf-policy-l2DzrZX2.js";
+import "./ssrf-runtime-DtkX5TMS.js";
+import { t as zod_exports } from "./zod-Bqvft_ty.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-CAFnyY_a.js";
+//#region extensions/tlon/src/config-schema.ts
+const ShipSchema = zod_exports.z.string().min(1);
+const ChannelNestSchema = zod_exports.z.string().min(1);
+const TlonChannelRuleSchema = zod_exports.z.object({
+	mode: zod_exports.z.enum(["restricted", "open"]).optional(),
+	allowedShips: zod_exports.z.array(ShipSchema).optional()
+});
+const TlonAuthorizationSchema = zod_exports.z.object({ channelRules: zod_exports.z.record(zod_exports.z.string(), TlonChannelRuleSchema).optional() });
+const TlonNetworkSchema = zod_exports.z.object({ dangerouslyAllowPrivateNetwork: zod_exports.z.boolean().optional() }).strict().optional();
+const tlonCommonConfigFields = {
+	name: zod_exports.z.string().optional(),
+	enabled: zod_exports.z.boolean().optional(),
+	ship: ShipSchema.optional(),
+	url: zod_exports.z.string().optional(),
+	code: zod_exports.z.string().optional(),
+	network: TlonNetworkSchema,
+	groupChannels: zod_exports.z.array(ChannelNestSchema).optional(),
+	dmAllowlist: zod_exports.z.array(ShipSchema).optional(),
+	autoDiscoverChannels: zod_exports.z.boolean().optional(),
+	showModelSignature: zod_exports.z.boolean().optional(),
+	responsePrefix: zod_exports.z.string().optional(),
+	autoAcceptDmInvites: zod_exports.z.boolean().optional(),
+	autoAcceptGroupInvites: zod_exports.z.boolean().optional(),
+	ownerShip: ShipSchema.optional()
+};
+const TlonAccountSchema = zod_exports.z.object({ ...tlonCommonConfigFields });
+const tlonChannelConfigSchema = buildChannelConfigSchema(zod_exports.z.object({
+	...tlonCommonConfigFields,
+	authorization: TlonAuthorizationSchema.optional(),
+	defaultAuthorizedShips: zod_exports.z.array(ShipSchema).optional(),
+	accounts: zod_exports.z.record(zod_exports.z.string(), TlonAccountSchema).optional()
+}));
+//#endregion
+//#region extensions/tlon/src/doctor-contract.ts
+const contract = createLegacyPrivateNetworkDoctorContract({ channelKey: "tlon" });
+//#endregion
+//#region extensions/tlon/src/doctor.ts
+const tlonDoctor = {
+	legacyConfigRules: contract.legacyConfigRules,
+	normalizeCompatibilityConfig: contract.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-Bhj1b9gQ.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 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: {
+			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)
+		},
+		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: {
+		deliveryMode: "direct",
+		textChunkLimit: 1e4,
+		resolveTarget: ({ to }) => resolveTlonOutboundTarget(to),
+		...createRuntimeOutboundDelegates({
+			getRuntime: loadTlonChannelRuntime,
+			sendText: { resolve: (runtime) => runtime.tlonRuntimeOutbound.sendText },
+			sendMedia: { resolve: (runtime) => runtime.tlonRuntimeOutbound.sendMedia }
+		})
+	}
+});
+//#endregion
+export { tlonPlugin as t };