@pixelzx/genesis 2026.7.8 → 2026.7.9

package/dist/channel-B_D0qB8f.js

@@ -1,297 +0,0 @@
-import { t as DEFAULT_ACCOUNT_ID } from "./account-id-CTXHUezn.js";
-import { r as createLazyRuntimeModule } from "./lazy-runtime-B-T6H2Zb.js";
-import { p as formatTrimmedAllowFromEntries, s as createScopedChannelConfigAdapter, t as adaptScopedAccountAccessor } from "./channel-config-helpers-u7T-fXUn.js";
-import { t as buildOutboundBaseSessionKey } from "./base-session-key-B-DTLUBu.js";
-import { n as describeAccountSnapshot } from "./account-helpers-BO4UPATV.js";
-import { c as getChatChannelMeta, i as createChatChannelPlugin, r as createChannelPluginBase } from "./core-DxVEjt5f.js";
-import "./channel-core-C3RFVpjy.js";
-import "./routing-C4eysASR.js";
-import { r as createRestrictSendersChannelSecurity } from "./channel-policy-CKro2sO6.js";
-import { c as collectStatusIssuesFromLastError, d as createDefaultChannelRuntimeState, u as createComputedAccountStatusAdapter } from "./status-helpers-pM311_XZ.js";
-import { t as sanitizeForPlainText } from "./sanitize-text-B0aeNV74.js";
-import "./outbound-runtime-BcayPyTD.js";
-import { t as chunkTextForOutbound } from "./text-chunking-Bn3xVWoL.js";
-import { n as buildDmGroupAccountAllowlistAdapter } from "./allowlist-config-edit-3goBsyY-.js";
-import { n as buildPassiveProbedChannelStatusSummary } from "./extension-shared-B4iTRjxK.js";
-import { a as listIMessageAccountIds, n as resolveIMessageAttachmentRoots, o as resolveDefaultIMessageAccountId, r as resolveIMessageRemoteAttachmentRoots, s as resolveIMessageAccount } from "./media-contract-Cu5jtr6E.js";
-import { c as looksLikeIMessageExplicitTargetId, d as parseIMessageTarget, i as resolveIMessageConversationIdFromTarget, l as normalizeIMessageHandle, n as matchIMessageAcpConversation, o as inferIMessageTargetChatType, p as normalizeIMessageMessagingTarget, r as normalizeIMessageAcpConversationId } from "./conversation-id-BzYtax7n.js";
-import { n as createIMessageConversationBindingManager } from "./conversation-bindings-Dxujbg9m.js";
-import { n as resolveIMessageGroupToolPolicy, t as resolveIMessageGroupRequireMention } from "./group-policy-BYrJP8Ey.js";
-import { a as imessageSetupAdapter, n as createIMessageSetupWizardProxy } from "./setup-core-CxDIk2Qq.js";
-import { t as IMessageChannelConfigSchema } from "./config-schema-CTQkD3bR.js";
-//#region extensions/imessage/src/shared.ts
-const IMESSAGE_CHANNEL = "imessage";
-async function loadIMessageChannelRuntime$1() {
-	return await import("./channel.runtime-Cuc72hD3.js");
-}
-const imessageSetupWizard = createIMessageSetupWizardProxy(async () => (await loadIMessageChannelRuntime$1()).imessageSetupWizard);
-const imessageConfigAdapter = createScopedChannelConfigAdapter({
-	sectionKey: IMESSAGE_CHANNEL,
-	listAccountIds: listIMessageAccountIds,
-	resolveAccount: adaptScopedAccountAccessor(resolveIMessageAccount),
-	defaultAccountId: resolveDefaultIMessageAccountId,
-	clearBaseFields: [
-		"cliPath",
-		"dbPath",
-		"service",
-		"region",
-		"name"
-	],
-	resolveAllowFrom: (account) => account.config.allowFrom,
-	formatAllowFrom: (allowFrom) => formatTrimmedAllowFromEntries(allowFrom),
-	resolveDefaultTo: (account) => account.config.defaultTo
-});
-const imessageSecurityAdapter = createRestrictSendersChannelSecurity({
-	channelKey: IMESSAGE_CHANNEL,
-	resolveDmPolicy: (account) => account.config.dmPolicy,
-	resolveDmAllowFrom: (account) => account.config.allowFrom,
-	resolveGroupPolicy: (account) => account.config.groupPolicy,
-	surface: "iMessage groups",
-	openScope: "any member",
-	groupPolicyPath: "channels.imessage.groupPolicy",
-	groupAllowFromPath: "channels.imessage.groupAllowFrom",
-	mentionGated: false,
-	policyPathSuffix: "dmPolicy"
-});
-function createIMessagePluginBase(params) {
-	return {
-		...createChannelPluginBase({
-			id: IMESSAGE_CHANNEL,
-			meta: {
-				...getChatChannelMeta(IMESSAGE_CHANNEL),
-				aliases: ["imsg"],
-				showConfigured: false
-			},
-			setupWizard: params.setupWizard,
-			capabilities: {
-				chatTypes: ["direct", "group"],
-				media: true
-			},
-			reload: { configPrefixes: ["channels.imessage"] },
-			configSchema: IMessageChannelConfigSchema,
-			config: {
-				...imessageConfigAdapter,
-				isConfigured: (account) => account.configured,
-				describeAccount: (account) => describeAccountSnapshot({
-					account,
-					configured: account.configured
-				})
-			},
-			security: imessageSecurityAdapter,
-			setup: params.setup
-		}),
-		messaging: {
-			resolveInboundAttachmentRoots: (params) => resolveIMessageAttachmentRoots({
-				accountId: params.accountId,
-				cfg: params.cfg
-			}),
-			resolveRemoteInboundAttachmentRoots: (params) => resolveIMessageRemoteAttachmentRoots({
-				accountId: params.accountId,
-				cfg: params.cfg
-			})
-		}
-	};
-}
-//#endregion
-//#region extensions/imessage/src/status-core.ts
-async function probeIMessageStatusAccount(params) {
-	return await params.probeIMessageAccount({
-		timeoutMs: params.timeoutMs,
-		cliPath: params.account.config.cliPath,
-		dbPath: params.account.config.dbPath
-	});
-}
-//#endregion
-//#region extensions/imessage/src/channel.ts
-const loadIMessageChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-Cuc72hD3.js"));
-function buildIMessageBaseSessionKey(params) {
-	return buildOutboundBaseSessionKey({
-		...params,
-		channel: "imessage"
-	});
-}
-function resolveIMessageOutboundSessionRoute(params) {
-	const parsed = parseIMessageTarget(params.target);
-	if (parsed.kind === "handle") {
-		const handle = normalizeIMessageHandle(parsed.to);
-		if (!handle) return null;
-		const peer = {
-			kind: "direct",
-			id: handle
-		};
-		const baseSessionKey = buildIMessageBaseSessionKey({
-			cfg: params.cfg,
-			agentId: params.agentId,
-			accountId: params.accountId,
-			peer
-		});
-		return {
-			sessionKey: baseSessionKey,
-			baseSessionKey,
-			peer,
-			chatType: "direct",
-			from: `imessage:${handle}`,
-			to: `imessage:${handle}`
-		};
-	}
-	const peerId = parsed.kind === "chat_id" ? String(parsed.chatId) : parsed.kind === "chat_guid" ? parsed.chatGuid : parsed.chatIdentifier;
-	if (!peerId) return null;
-	const peer = {
-		kind: "group",
-		id: peerId
-	};
-	const baseSessionKey = buildIMessageBaseSessionKey({
-		cfg: params.cfg,
-		agentId: params.agentId,
-		accountId: params.accountId,
-		peer
-	});
-	const toPrefix = parsed.kind === "chat_id" ? "chat_id" : parsed.kind === "chat_guid" ? "chat_guid" : "chat_identifier";
-	return {
-		sessionKey: baseSessionKey,
-		baseSessionKey,
-		peer,
-		chatType: "group",
-		from: `imessage:group:${peerId}`,
-		to: `${toPrefix}:${peerId}`
-	};
-}
-const imessagePlugin = createChatChannelPlugin({
-	base: {
-		...createIMessagePluginBase({
-			setupWizard: imessageSetupWizard,
-			setup: imessageSetupAdapter
-		}),
-		allowlist: buildDmGroupAccountAllowlistAdapter({
-			channelId: "imessage",
-			resolveAccount: resolveIMessageAccount,
-			normalize: ({ values }) => formatTrimmedAllowFromEntries(values),
-			resolveDmAllowFrom: (account) => account.config.allowFrom,
-			resolveGroupAllowFrom: (account) => account.config.groupAllowFrom,
-			resolveDmPolicy: (account) => account.config.dmPolicy,
-			resolveGroupPolicy: (account) => account.config.groupPolicy
-		}),
-		groups: {
-			resolveRequireMention: resolveIMessageGroupRequireMention,
-			resolveToolPolicy: resolveIMessageGroupToolPolicy
-		},
-		doctor: { groupAllowFromFallbackToAllowFrom: false },
-		conversationBindings: {
-			supportsCurrentConversationBinding: true,
-			createManager: ({ cfg, accountId }) => createIMessageConversationBindingManager({
-				cfg,
-				accountId: accountId ?? void 0
-			})
-		},
-		bindings: {
-			compileConfiguredBinding: ({ conversationId }) => normalizeIMessageAcpConversationId(conversationId),
-			matchInboundConversation: ({ compiledBinding, conversationId }) => matchIMessageAcpConversation({
-				bindingConversationId: compiledBinding.conversationId,
-				conversationId
-			}),
-			resolveCommandConversation: ({ originatingTo, commandTo, fallbackTo }) => {
-				const conversationId = resolveIMessageConversationIdFromTarget(originatingTo ?? "") ?? resolveIMessageConversationIdFromTarget(commandTo ?? "") ?? resolveIMessageConversationIdFromTarget(fallbackTo ?? "");
-				return conversationId ? { conversationId } : null;
-			}
-		},
-		messaging: {
-			normalizeTarget: normalizeIMessageMessagingTarget,
-			inferTargetChatType: ({ to }) => inferIMessageTargetChatType(to),
-			resolveOutboundSessionRoute: (params) => resolveIMessageOutboundSessionRoute(params),
-			targetResolver: {
-				looksLikeId: looksLikeIMessageExplicitTargetId,
-				hint: "<handle|chat_id:ID>",
-				resolveTarget: async ({ normalized }) => {
-					const to = normalized?.trim();
-					if (!to) return null;
-					const chatType = inferIMessageTargetChatType(to);
-					if (!chatType) return null;
-					return {
-						to,
-						kind: chatType === "direct" ? "user" : "group",
-						source: "normalized"
-					};
-				}
-			}
-		},
-		status: createComputedAccountStatusAdapter({
-			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, {
-				cliPath: null,
-				dbPath: null
-			}),
-			collectStatusIssues: (accounts) => collectStatusIssuesFromLastError("imessage", accounts),
-			buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot, {
-				cliPath: snapshot.cliPath ?? null,
-				dbPath: snapshot.dbPath ?? null
-			}),
-			probeAccount: async ({ account, timeoutMs }) => await probeIMessageStatusAccount({
-				account,
-				timeoutMs,
-				probeIMessageAccount: async (params) => await (await loadIMessageChannelRuntime()).probeIMessageAccount(params)
-			}),
-			resolveAccountSnapshot: ({ account, runtime }) => ({
-				accountId: account.accountId,
-				name: account.name,
-				enabled: account.enabled,
-				configured: account.configured,
-				extra: {
-					cliPath: runtime?.cliPath ?? account.config.cliPath ?? null,
-					dbPath: runtime?.dbPath ?? account.config.dbPath ?? null
-				}
-			}),
-			resolveAccountState: ({ enabled }) => enabled ? "enabled" : "disabled"
-		}),
-		gateway: { startAccount: async (ctx) => {
-			const conversationBindings = createIMessageConversationBindingManager({
-				cfg: ctx.cfg,
-				accountId: ctx.accountId
-			});
-			try {
-				return await (await loadIMessageChannelRuntime()).startIMessageGatewayAccount(ctx);
-			} finally {
-				conversationBindings.stop();
-			}
-		} }
-	},
-	pairing: { text: {
-		idLabel: "imessageSenderId",
-		message: "Genesis: your access has been approved.",
-		notify: async ({ id, cfg }) => await (await loadIMessageChannelRuntime()).notifyIMessageApproval({
-			id,
-			cfg
-		})
-	} },
-	security: imessageSecurityAdapter,
-	outbound: {
-		base: {
-			deliveryMode: "direct",
-			chunker: chunkTextForOutbound,
-			chunkerMode: "text",
-			textChunkLimit: 4e3,
-			sanitizeText: ({ text }) => sanitizeForPlainText(text)
-		},
-		attachedResults: {
-			channel: "imessage",
-			sendText: async ({ cfg, to, text, accountId, deps, replyToId }) => await (await loadIMessageChannelRuntime()).sendIMessageOutbound({
-				cfg,
-				to,
-				text,
-				accountId: accountId ?? void 0,
-				deps,
-				replyToId: replyToId ?? void 0
-			}),
-			sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, accountId, deps, replyToId }) => await (await loadIMessageChannelRuntime()).sendIMessageOutbound({
-				cfg,
-				to,
-				text,
-				mediaUrl,
-				mediaLocalRoots,
-				accountId: accountId ?? void 0,
-				deps,
-				replyToId: replyToId ?? void 0
-			})
-		}
-	}
-});
-//#endregion
-export { createIMessagePluginBase as n, imessageSetupWizard as r, imessagePlugin as t };

package/dist/channel-CveiiHEq.js

@@ -1,226 +0,0 @@
-import { r as buildChannelConfigSchema } from "./config-schema-jug-eHfF.js";
-import { t as DEFAULT_ACCOUNT_ID } from "./account-id-CTXHUezn.js";
-import { r as createLazyRuntimeModule } from "./lazy-runtime-B-T6H2Zb.js";
-import { i as createHybridChannelConfigAdapter } from "./channel-config-helpers-u7T-fXUn.js";
-import { n as describeAccountSnapshot } from "./account-helpers-BO4UPATV.js";
-import { i as createChatChannelPlugin, t as buildChannelOutboundSessionRoute } from "./core-DxVEjt5f.js";
-import "./channel-core-C3RFVpjy.js";
-import "./channel-config-schema-Ry4DuFfZ.js";
-import { n as createRuntimeOutboundDelegates } from "./runtime-forwarders-xRBAPDFG.js";
-import { d as createDefaultChannelRuntimeState, u as createComputedAccountStatusAdapter } from "./status-helpers-pM311_XZ.js";
-import "./outbound-runtime-BcayPyTD.js";
-import { r as createLegacyPrivateNetworkDoctorContract } from "./ssrf-policy-ChAc-ige.js";
-import "./ssrf-runtime-DXdCQqiX.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-KQe39zUH.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-mLdKu3mE.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 };