primcli 1.75.0 → 3.0.0-preview.1

package/dist/{cli-config-B80p0pLk.js → cli-config-Ms_0vNjq.js}

@@ -391,6 +391,7 @@ var LegacyApiKeyCredentialFormatError = class extends Error {
 };
 function parseCredentials(raw) {
 	if (!isRecord$1(raw)) throw new Error(`Stored Primitive CLI credentials are malformed: expected a JSON object. ${MALFORMED_CREDENTIALS_HINT}`);
+	if (raw.auth_method === "user_grant") return parseUserGrantCredentials(raw);
 	if (raw.auth_method !== "oauth") {
 		if (typeof raw.api_key === "string" || typeof raw.key_id === "string" || typeof raw.base_url === "string") throw new LegacyApiKeyCredentialFormatError();
 		throw new Error(`Stored Primitive CLI credentials are malformed: auth_method must be oauth. ${MALFORMED_CREDENTIALS_HINT}`);
@@ -412,6 +413,63 @@ function parseCredentials(raw) {
 		created_at: requireString(raw, "created_at")
 	};
 }
+function malformed(detail) {
+	return /* @__PURE__ */ new Error(`Stored Primitive CLI credentials are malformed: ${detail}. ${MALFORMED_CREDENTIALS_HINT}`);
+}
+function requireText(value, key, options = {}) {
+	const raw = value[key];
+	if (typeof raw !== "string" || !options.allowEmpty && raw.trim().length === 0) throw malformed(`${key} must be a non-empty string`);
+	return raw;
+}
+function nullableText(value, key) {
+	const raw = value[key];
+	if (raw === void 0 || raw === null) return null;
+	if (typeof raw !== "string") throw malformed(`${key} must be a string or null`);
+	return raw;
+}
+function parseOrgToken(raw) {
+	if (!isRecord$1(raw)) throw malformed("user_grant.org_tokens entries must be objects");
+	return {
+		access_token: requireText(raw, "access_token"),
+		expires_at: requireText(raw, "expires_at"),
+		oauth_grant_id: requireText(raw, "oauth_grant_id"),
+		org_id: requireText(raw, "org_id"),
+		org_name: nullableText(raw, "org_name"),
+		role: nullableText(raw, "role")
+	};
+}
+function parseUserGrantCredentials(raw) {
+	const grantRaw = raw.user_grant;
+	if (!isRecord$1(grantRaw)) throw malformed("user_grant must be an object");
+	if (raw.token_type !== "Bearer") throw malformed("token_type must be Bearer");
+	const tokensRaw = grantRaw.org_tokens ?? {};
+	if (!isRecord$1(tokensRaw)) throw malformed("user_grant.org_tokens must be an object");
+	const orgTokens = {};
+	for (const [orgId, token] of Object.entries(tokensRaw)) orgTokens[orgId] = parseOrgToken(token);
+	const orgId = requireText(raw, "org_id", { allowEmpty: true });
+	return {
+		access_token: requireText(raw, "access_token", { allowEmpty: true }),
+		api_base_url: readStoredApiBaseUrl(raw),
+		auth_method: "user_grant",
+		created_at: requireText(raw, "created_at"),
+		expires_at: requireText(raw, "expires_at"),
+		oauth_client_id: requireText(raw, "oauth_client_id"),
+		oauth_grant_id: requireText(raw, "oauth_grant_id", { allowEmpty: true }),
+		org_id: orgId,
+		org_name: nullableText(raw, "org_name"),
+		refresh_token: requireText(raw, "refresh_token"),
+		token_type: "Bearer",
+		user_grant: {
+			access_token: requireText(grantRaw, "access_token"),
+			expires_at: requireText(grantRaw, "expires_at"),
+			org_role: nullableText(grantRaw, "org_role"),
+			org_tokens: orgTokens,
+			requested_grant: nullableText(grantRaw, "requested_grant"),
+			user_grant_id: requireText(grantRaw, "user_grant_id"),
+			user_id: requireText(grantRaw, "user_id")
+		}
+	};
+}
 function credentialsPath(configDir) {
 	return join(configDir, CREDENTIALS_FILE);
 }
@@ -674,21 +732,6 @@ function detectPrimitiveKeyEnvMisname(env = process.env) {
 	if ((primitiveKey?.length ?? 0) > 0 && (primitiveApiKey?.length ?? 0) === 0) return "PRIMITIVE_KEY is set but the CLI reads PRIMITIVE_API_KEY. Rename your env var, or re-run with PRIMITIVE_API_KEY=$PRIMITIVE_KEY.";
 	return null;
 }
-/**
-* True when a usable OAuth login session is saved on disk. Used by `pay-email`
-* to decide whether it can safely ignore an env-only `PRIMITIVE_API_KEY` in
-* favor of the payer's logged-in account (which owns the inbound challenge
-* inbox). Returns false when nothing is stored or the stored credential is
-* unreadable/legacy, so the caller falls back to whatever key did resolve
-* rather than silently dropping the user's only auth.
-*/
-function hasStoredCliLogin(configDir) {
-	try {
-		return loadCliCredentials(configDir) !== null;
-	} catch {
-		return false;
-	}
-}
 function resolveCliAuth(params) {
 	const apiKey = params.apiKey?.trim();
 	const apiBaseUrl = normalizeApiBaseUrl(params.apiBaseUrl);
@@ -903,4 +946,4 @@ function redactCliEnvironment(environment) {
 		...headers ? { headers } : {}
 	};
 }
-export { saveActiveChatState as A, parseConnectedAgentProfile as B, resolveCliAuth as C, deleteChatState as D, chatStatePath as E, agentProfileName as F, PrimitiveApiClient as G, profileAlreadyConnectedMessage as H, agentProfilesDirectory as I, connectedAgentIdentity as L, AGENT_PROFILE_ENV as M, AgentConnectionSetupError as N, loadActiveChatState as O, agentProfileDirectory as P, connectedApiBaseUrl as R, normalizeApiBaseUrl as S, saveSignupCredentials as T, requireDefaultLoginProfile as U, parseOwnerMemberAddress as V, saveConnectedAgentProfile as W, deleteCliCredentials as _, normalizeCliEnvironmentName as a, hasStoredCliLogin as b, resolveConfigEnvironment as c, validateCliHeaderName as d, validateCliHeaderValue as f, credentialsPath as g, credentialsLockPath as h, loadCliConfig as i, AGENT_ADDRESS_ENV as j, loadChatConversationByLocalId as k, saveCliConfig as l, cliAccessTokenExpiresAt as m, deleteCliConfig as n, redactCliEnvironment as o, acquireCliCredentialsLock as p, emptyCliConfig as r, removeCliEnvironment as s, DEFAULT_ENVIRONMENT as t, upsertCliEnvironment as u, deleteCliCredentialsLock as v, saveCliCredentials as w, loadCliCredentials as x, detectPrimitiveKeyEnvMisname as y, loadConnectedAgentProfile as z };
+export { AGENT_ADDRESS_ENV as A, parseOwnerMemberAddress as B, saveCliCredentials as C, loadActiveChatState as D, deleteChatState as E, agentProfilesDirectory as F, requireDefaultLoginProfile as H, connectedAgentIdentity as I, connectedApiBaseUrl as L, AgentConnectionSetupError as M, agentProfileDirectory as N, loadChatConversationByLocalId as O, agentProfileName as P, loadConnectedAgentProfile as R, resolveCliAuth as S, chatStatePath as T, saveConnectedAgentProfile as U, profileAlreadyConnectedMessage as V, PrimitiveApiClient as W, deleteCliCredentials as _, normalizeCliEnvironmentName as a, loadCliCredentials as b, resolveConfigEnvironment as c, validateCliHeaderName as d, validateCliHeaderValue as f, credentialsPath as g, credentialsLockPath as h, loadCliConfig as i, AGENT_PROFILE_ENV as j, saveActiveChatState as k, saveCliConfig as l, cliAccessTokenExpiresAt as m, deleteCliConfig as n, redactCliEnvironment as o, acquireCliCredentialsLock as p, emptyCliConfig as r, removeCliEnvironment as s, DEFAULT_ENVIRONMENT as t, upsertCliEnvironment as u, deleteCliCredentialsLock as v, saveSignupCredentials as w, normalizeApiBaseUrl as x, detectPrimitiveKeyEnvMisname as y, parseConnectedAgentProfile as z };

package/dist/{machine-session-Cq_nD5eF.js → machine-session-Cp_eQ9t_.js}

@@ -1,11 +1,12 @@
-import { B as parseConnectedAgentProfile, F as agentProfileName, G as PrimitiveApiClient, H as profileAlreadyConnectedMessage, I as agentProfilesDirectory, L as connectedAgentIdentity, M as AGENT_PROFILE_ENV, N as AgentConnectionSetupError, P as agentProfileDirectory, R as connectedApiBaseUrl, V as parseOwnerMemberAddress, W as saveConnectedAgentProfile, x as loadCliCredentials, z as loadConnectedAgentProfile } from "./cli-config-B80p0pLk.js";
-import { $t as listDomains, At as getAgentContactPolicy, Dn as sendEmail, Ft as getEmail, Jt as listAgentContacts, Kn as __exportAll, Kt as inviteAgentConnection, Xt as listContacts, cn as listSentEmails, gn as putContact, hn as putAgentContactPolicy, jt as getContact, mn as putAgentContact, qt as listAgentConnections, vt as deleteAgentContact, wn as searchEmails, yt as deleteContact } from "./repeats-Dj_o6c-X-LyCkKYjp.js";
-import { Pt as refreshStoredCliCredentials, gt as defaultConnectionName, mt as cliInvocation, xt as detectAgentRuntime } from "./api-command-rlS3eTlZ.js";
+import { B as parseOwnerMemberAddress, F as agentProfilesDirectory, I as connectedAgentIdentity, L as connectedApiBaseUrl, M as AgentConnectionSetupError, N as agentProfileDirectory, P as agentProfileName, R as loadConnectedAgentProfile, U as saveConnectedAgentProfile, V as profileAlreadyConnectedMessage, W as PrimitiveApiClient, b as loadCliCredentials, j as AGENT_PROFILE_ENV, z as parseConnectedAgentProfile } from "./cli-config-Ms_0vNjq.js";
+import { $n as __exportAll, $t as listContacts, Cn as putContact, It as getEmail, Jt as inviteAgentConnection, Mt as getContact, Pn as sendEmail, Sn as putAgentContactPolicy, Xt as listAgentConnections, Zt as listAgentContacts, hn as listSentEmails, jn as searchEmails, jt as getAgentContactPolicy, rn as listDomains, vt as deleteAgentContact, xn as putAgentContact, yt as deleteContact } from "./repeats-Dj_o6c-X-Bf9G0xds.js";
+import { Ft as refuseOrgSelectionForProfile, Pt as refreshStoredCliCredentials, St as detectAgentRuntime, _t as defaultConnectionName, ht as cliInvocation } from "./api-command-ctHBqTL5.js";
 import { _ as acquireListenLock, b as listenLockHeld, c as mailTime, d as readMailJson, f as removeMailFile, g as ListenStateError, h as writeMailJson, i as mailId, l as privateMailDirectory, o as mailObject, p as syncMailDirectory, r as mailAddress, s as mailString } from "./shared-mail-files-BAQSGxxz.js";
-import { _ as installConnectSkill, a as NotificationRetryError, b as readBundledConnectSkill, d as defaultSessionSocket, f as NativeSessionDisconnectedError, l as SESSION_UUID, t as notificationScope, u as connectNativeSession } from "./notify-session-CbY4FYUt.js";
+import { S as readBundledConnectSkill, a as NotificationRetryError, d as SESSION_UUID, f as connectNativeSession, m as NativeSessionDisconnectedError, p as defaultSessionSocket, t as notificationScope, y as installConnectSkill } from "./notify-session-BN0JTPZ3.js";
 import { l as stopBackgroundListen, r as backgroundListenStatus } from "./listen-background-C0F9gNDD.js";
 import { t as readSharedMailOwner } from "./shared-mail-watch-BAPMsFNv.js";
-import { o as scopedChatSenderTrust } from "./scoped-chat-B0thCwME.js";
+import { withoutOrgSelection } from "./oclif/global-org-flag.js";
+import { o as scopedChatSenderTrust } from "./scoped-chat-DZ42V3jq.js";
 import { accessSync, chmodSync, closeSync, constants, copyFileSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { basename, delimiter, dirname, isAbsolute, join, resolve } from "node:path";
@@ -3009,6 +3010,7 @@ async function revoke(profile, fetcher) {
 /** Revoke one selected connected credential; never alter OAuth login or mail evidence. */
 async function disconnectAgent(params) {
 	const profileName = agentProfileName(params.profileName);
+	refuseOrgSelectionForProfile(profileName);
 	if (!loadConnectedAgentProfile(params.configDir, profileName)) throw new AgentDisconnectError("This agent profile is not configured. Nothing was changed.");
 	const directory = agentProfileDirectory(params.configDir, profileName);
 	let releaseSetup;
@@ -3448,6 +3450,11 @@ var ContactPolicyReadRetryError = class extends NotificationRetryError {
 		super("Contact notification policy is temporarily unavailable. Mail remains pending while permissions are refreshed.");
 	}
 };
+/** A network decision is trusted only when every field agrees with the others. */
+function consistentNetworkAdmission(decision) {
+	const relation = decision.sender_relation;
+	return typeof decision.allowed === "boolean" && typeof decision.pending === "boolean" && typeof decision.member_policy_required === "boolean" && (relation === void 0 || decision.member_policy_required && (relation === "owner" || relation === "member")) && !(decision.member_policy_required && decision.allowed && !relation) && !(decision.pending && (decision.allowed || decision.allowed_since !== null)) && (decision.allowed ? typeof decision.allowed_since === "string" : decision.allowed_since === null);
+}
 const unavailable = () => new ListenStateError("Contact notification preferences are unavailable or invalid. No contact notification was submitted; restart after access is restored.");
 const changed = () => new NotificationRetryError("Contact notification permission changed or expired before dispatch.");
 /** Read one connected address's policy. Partial pages never authorize delivery. */
@@ -3561,10 +3568,8 @@ function createNotificationContactPolicy(options) {
 		if (!emailId) throw unavailable();
 		const network = await networkReader(emailId, sender, signal);
 		signal.throwIfAborted();
-		if (typeof network.member_policy_required !== "boolean") throw unavailable();
-		if (network.sender_relation !== void 0 && (!network.member_policy_required || !["owner", "member"].includes(network.sender_relation))) throw unavailable();
+		if (!consistentNetworkAdmission(network)) throw unavailable();
 		if (network.member_policy_required) {
-			if (network.allowed && !network.sender_relation) throw unavailable();
 			if (network.pending) throw new NetworkAdmissionPendingError();
 			if (!network.allowed) return null;
 			if (decision.kind === "silent" && decision.source !== "default") return null;
@@ -4192,11 +4197,11 @@ function defaults$1() {
 				"--contacts",
 				...contactRequests ? ["--contact-requests"] : []
 			], {
-				env: {
+				env: withoutOrgSelection({
 					...process.env,
 					[AGENT_PROFILE_ENV]: profile,
 					PRIMITIVE_CONFIG_DIR: configDir
-				},
+				}),
 				timeout: 35e3,
 				maxBuffer: 65536
 			});
@@ -5058,11 +5063,18 @@ function assertNativeSessionIdentity(session, env) {
 	if (env.CODEX_THREAD_ID && env.CODEX_THREAD_ID !== session) throw refuse("The requested session differs from this Codex thread. No address was created.");
 	if (!env.CODEX_THREAD_ID && env.CODEX_SESSION_ID && env.CODEX_SESSION_ID !== session) throw refuse("The requested session differs from this Codex session. No address was created.");
 }
+/**
+* Preflight for enrollment: the managed domains an address could land on.
+* Null when the member's grant may not list domains; creating a connection
+* needs only agent_connections:manage, and the server picks the address and
+* refuses with connection_domain_unavailable when none is usable.
+*/
 async function managedDomains(client, apiBaseUrl) {
 	const response = await listDomains({
 		client: client.client,
 		responseStyle: "fields"
 	});
+	if (response.response?.status === 403) return null;
 	const rows = response.data?.data;
 	if (response.error || !Array.isArray(rows)) throw refuse("Could not list the owner's managed domains. No address was created.");
 	const suffix = apiBaseUrl === "https://api.primitive-staging-1.com/v1" ? ".primitive-staging.email" : ".primitive.email";
@@ -5579,11 +5591,12 @@ async function enrollAgent(params) {
 		if (state?.continueAttempted) throw refuse(stuckEnrollmentStep(resolvedEnrollment(state).address));
 		if (!state) {
 			if (params.continueSetup) throw refuse("There is no saved enrollment to continue. Start enrollment normally first.");
-			if (!(await managedDomains(new PrimitiveApiClient({
+			const domains = await managedDomains(new PrimitiveApiClient({
 				apiKey: credentials.access_token,
 				apiBaseUrl,
 				fetch: params.fetch
-			}), apiBaseUrl)).length) throw refuse("No managed domain is available for enrollment.");
+			}), apiBaseUrl);
+			if (domains && !domains.length) throw refuse("No managed domain is available for enrollment.");
 			state = {
 				version: 2,
 				session: params.session,

package/dist/{notify-session-CbY4FYUt.js → notify-session-BN0JTPZ3.js}

@@ -1,13 +1,17 @@
-import { Et as downloadEmailAttachmentPart, J as parseWebhookEvent, K as isEmailReceivedEvent, c as classifySignalContent, q as isTrustedSender } from "./repeats-Dj_o6c-X-LyCkKYjp.js";
-import { B as wakeInteractionSentence, T as wakeReadCommand, w as skillFirstLine } from "./api-command-rlS3eTlZ.js";
+import { Et as downloadEmailAttachmentPart, J as parseWebhookEvent, K as isEmailReceivedEvent, c as classifySignalContent, q as isTrustedSender } from "./repeats-Dj_o6c-X-Bf9G0xds.js";
+import { E as wakeReadCommand, T as skillFirstLine, V as wakeInteractionSentence } from "./api-command-ctHBqTL5.js";
 import { _ as acquireListenLock, g as ListenStateError, y as listenIdentity } from "./shared-mail-files-BAQSGxxz.js";
 import { closeSync, copyFileSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, opendirSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID, scryptSync } from "node:crypto";
 import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
+import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { lstat, realpath } from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
 import WebSocket from "ws";
+import { request } from "node:http";
+import { request as request$1 } from "node:https";
+import { performance } from "node:perf_hooks";
 // src/oclif/connect-skill.ts
 const CONNECT_SKILL_NAME = "primitive-connect";
 function connectSkillTarget(options) {
@@ -564,6 +568,331 @@ async function connectNativeSession(options) {
 		}
 	};
 }
+// src/oclif/listen-handlers.ts
+const HANDLER_TIMEOUT_MS = 3e4;
+const MAX_RESPONSE_BYTES = 1048576;
+const FORWARDED_HEADERS = /* @__PURE__ */ new Set([
+	"content-type",
+	"user-agent",
+	"primitive-signature",
+	"mymx-signature",
+	"x-webhook-event",
+	"x-webhook-id",
+	"x-primitive-webhook-delivery-id",
+	"x-primitive-email-id",
+	"x-primitive-endpoint-id"
+]);
+function normalizeForwardTarget(target) {
+	if (/^\d+$/.test(target)) return `http://localhost:${target}`;
+	if (/^(localhost|127\.0\.0\.1|\[::1\])(?::|\/|$)/.test(target)) return `http://${target}`;
+	return target;
+}
+function validateListenHandlerOptions(options) {
+	if (options.exec !== void 0 && process.platform === "win32") throw new Error("--exec requires a POSIX shell and process groups. On Windows, use --forward-to with a local HTTP handler.");
+	if (options.exec !== void 0 && options.forwardTo !== void 0) throw new Error("Choose either --exec or --forward-to.");
+	if (options.exec !== void 0 && (!options.exec.trim() || options.exec.includes("\0"))) throw new Error("--exec requires a nonempty shell command.");
+	if (options.forwardTo !== void 0) {
+		let url;
+		try {
+			url = new URL(normalizeForwardTarget(options.forwardTo));
+		} catch {
+			throw new Error("--forward-to requires an HTTP or HTTPS URL.");
+		}
+		if (!["http:", "https:"].includes(url.protocol) || !url.hostname || url.username || url.password || url.hash) throw new Error("--forward-to requires HTTP or HTTPS without userinfo or a fragment.");
+	}
+}
+/** User hooks retain their configuration, but not the CLI's API credentials. */
+function hookEnvironment(delivery) {
+	const env = { ...process.env };
+	for (const name of Object.keys(env)) if (/^PRIMITIVE_(?:(?:API_|OAUTH_|AUTH_)?(?:KEY|TOKEN|ACCESS_TOKEN|REFRESH_TOKEN)|API_HEADERS|LEASE_TOKEN)$/i.test(name)) delete env[name];
+	return {
+		...env,
+		PRIMITIVE_EVENT_ID: delivery.event_id,
+		PRIMITIVE_DELIVERY_ID: delivery.delivery_id,
+		PRIMITIVE_EVENT_TYPE: delivery.event_type
+	};
+}
+async function writeChunk(output, chunk, signal) {
+	signal.throwIfAborted();
+	let onError = () => {};
+	let onAbort = () => {};
+	let onDrain = () => {};
+	let onClose = () => {};
+	try {
+		await new Promise((resolve, reject) => {
+			let callbackDone = false;
+			let returned = false;
+			let accepted = false;
+			let drained = false;
+			const finish = () => {
+				if (returned && callbackDone && (accepted || drained)) resolve();
+			};
+			onError = reject;
+			onAbort = () => reject(signal.reason);
+			onClose = () => reject(/* @__PURE__ */ new Error("Output closed before accepting the event."));
+			onDrain = () => {
+				drained = true;
+				finish();
+			};
+			output.on("error", onError);
+			output.on("close", onClose);
+			output.on("drain", onDrain);
+			signal.addEventListener("abort", onAbort, { once: true });
+			accepted = output.write(chunk, (error) => {
+				if (error) reject(error);
+				else {
+					callbackDone = true;
+					finish();
+				}
+			});
+			returned = true;
+			finish();
+		});
+	} finally {
+		output.off("error", onError);
+		output.off("close", onClose);
+		output.off("drain", onDrain);
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+function stopProcessGroup(child) {
+	if (!child.pid) return;
+	try {
+		process.kill(-child.pid, "SIGKILL");
+	} catch {}
+}
+var ChildCleanupError = class extends Error {};
+async function reapChild(child, closed) {
+	stopProcessGroup(child);
+	child.stdin?.destroy();
+	child.stdout?.destroy();
+	child.stderr?.destroy();
+	let timer;
+	try {
+		await Promise.race([closed, new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(new ChildCleanupError("The hook did not close after termination. Its delivery remains uncompleted.")), 1e3);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function execute(command, delivery, stderr, signal) {
+	signal.throwIfAborted();
+	const child = spawn(command, {
+		shell: true,
+		detached: true,
+		env: hookEnvironment(delivery),
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true
+	});
+	const closed = new Promise((resolve) => child.once("close", () => resolve()));
+	const stop = () => stopProcessGroup(child);
+	signal.addEventListener("abort", stop, { once: true });
+	const consume = async (stream) => {
+		for await (const chunk of stream) await writeChunk(stderr, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk), signal);
+	};
+	child.once("exit", stop);
+	try {
+		const exited = new Promise((resolve, reject) => {
+			child.once("error", reject);
+			child.once("close", (code) => resolve(code));
+		});
+		const stdin = writeChunk(child.stdin, Buffer.from(delivery.body, "utf8"), signal).then(() => child.stdin.end());
+		const [code] = await Promise.all([
+			exited,
+			stdin,
+			consume(child.stdout),
+			consume(child.stderr)
+		]);
+		signal.throwIfAborted();
+		return code;
+	} finally {
+		try {
+			await reapChild(child, closed);
+		} finally {
+			signal.removeEventListener("abort", stop);
+		}
+	}
+}
+function structuredErrorCode(body) {
+	try {
+		const value = JSON.parse(body);
+		if (typeof value !== "object" || value === null) return void 0;
+		const object = value;
+		const nested = typeof object.error === "object" && object.error !== null ? object.error.code : void 0;
+		const code = typeof nested === "string" ? nested : object.code;
+		return typeof code === "string" && /^[a-z][a-z0-9_]{0,63}$/.test(code) ? code : void 0;
+	} catch {
+		return;
+	}
+}
+var ForwardFailure = class extends Error {
+	statusCode;
+	transportError;
+	constructor(statusCode, transportError) {
+		super("Webhook transport did not complete.");
+		this.statusCode = statusCode;
+		this.transportError = transportError;
+	}
+};
+async function forward(target, delivery, signal) {
+	signal.throwIfAborted();
+	const url = new URL(normalizeForwardTarget(target));
+	const body = Buffer.from(delivery.body, "utf8");
+	const headers = {};
+	for (const [name, value] of Object.entries(delivery.headers)) if (FORWARDED_HEADERS.has(name.toLowerCase())) headers[name.toLowerCase()] = value;
+	headers["content-length"] = String(body.length);
+	return new Promise((resolve, reject) => {
+		let observedStatus = null;
+		let settled = false;
+		const fail = (kind = observedStatus === null ? "network" : "io") => {
+			if (settled) return;
+			settled = true;
+			reject(new ForwardFailure(observedStatus, kind));
+		};
+		const request$2 = (url.protocol === "https:" ? request$1 : request)(url, {
+			method: "POST",
+			headers,
+			signal,
+			rejectUnauthorized: true
+		}, (response) => {
+			observedStatus = response.statusCode ?? null;
+			const chunks = [];
+			let size = 0;
+			response.on("error", () => fail());
+			response.on("aborted", () => fail());
+			response.on("data", (chunk) => {
+				size += chunk.length;
+				if (size > MAX_RESPONSE_BYTES) {
+					fail("response_too_large");
+					request$2.destroy();
+				} else chunks.push(chunk);
+			});
+			response.on("end", () => {
+				if (settled) return;
+				if (!response.complete || size > MAX_RESPONSE_BYTES) {
+					fail(size > MAX_RESPONSE_BYTES ? "response_too_large" : "io");
+					return;
+				}
+				settled = true;
+				const status = response.statusCode ?? 0;
+				const succeeded = status >= 200 && status < 300;
+				resolve({
+					status,
+					confirmed: succeeded && (response.headers["x-primitive-confirmed"] === "true" || response.headers["x-mymx-confirmed"] === "true"),
+					errorCode: succeeded ? void 0 : status >= 300 && status < 400 ? "handler_redirect" : structuredErrorCode(Buffer.concat(chunks).toString("utf8")) ?? (status >= 400 && status < 500 ? "handler_4xx" : status >= 500 ? "handler_5xx" : "unknown_error")
+				});
+			});
+		});
+		request$2.on("error", () => fail());
+		request$2.end(body);
+	});
+}
+function jsonLine(body) {
+	try {
+		return JSON.stringify(JSON.parse(body));
+	} catch {
+		throw new Error("Webhook body is not valid JSON.");
+	}
+}
+/**
+* The API withholds an event's body from a credential that cannot read the
+* mail it carries. Such an event is never handed on as if it were the event:
+* listening stops with an explanation and the delivery stays uncompleted.
+*/
+function readableDelivery(delivery) {
+	if (delivery.body === null) throw new ListenStateError("The API withheld this event's content from the listening credential; the delivery remains uncompleted. Listen with a credential that can read this mail.");
+	return {
+		...delivery,
+		body: delivery.body
+	};
+}
+function createListenHandler(options = {}) {
+	validateListenHandlerOptions(options);
+	return async (received, signal) => {
+		signal.throwIfAborted();
+		const delivery = readableDelivery(received);
+		const start = performance.now();
+		const work = new AbortController();
+		let timedOut = false;
+		const cancel = () => work.abort(signal.reason);
+		signal.addEventListener("abort", cancel, { once: true });
+		const timer = setTimeout(() => {
+			timedOut = true;
+			work.abort(/* @__PURE__ */ new Error("Event handler timed out."));
+		}, HANDLER_TIMEOUT_MS);
+		const duration = () => Math.min(HANDLER_TIMEOUT_MS, Math.max(0, Math.round(performance.now() - start)));
+		try {
+			if (options.exec !== void 0) {
+				const code = await execute(options.exec, delivery, options.stderr ?? process.stderr, work.signal);
+				signal.throwIfAborted();
+				return {
+					succeeded: code === 0,
+					outcome: {
+						mode: "exec",
+						exit_code: code,
+						duration_ms: duration()
+					}
+				};
+			}
+			if (options.forwardTo !== void 0) {
+				const response = await forward(options.forwardTo, delivery, work.signal);
+				signal.throwIfAborted();
+				return {
+					succeeded: response.status >= 200 && response.status < 300,
+					outcome: {
+						mode: "http",
+						status_code: response.status,
+						confirmed: response.confirmed,
+						duration_ms: duration(),
+						...response.errorCode ? { error_code: response.errorCode } : {}
+					}
+				};
+			}
+			await writeChunk(options.stdout ?? process.stdout, Buffer.from(`${jsonLine(delivery.body)}\n`, "utf8"), work.signal);
+			signal.throwIfAborted();
+			return {
+				succeeded: true,
+				outcome: {
+					mode: "stdout",
+					write_succeeded: true,
+					duration_ms: duration()
+				}
+			};
+		} catch (error) {
+			signal.throwIfAborted();
+			if (error instanceof ChildCleanupError) throw error;
+			if (options.exec !== void 0) return {
+				succeeded: false,
+				outcome: {
+					mode: "exec",
+					exit_code: null,
+					transport_error: timedOut ? "timeout" : "io",
+					duration_ms: duration()
+				}
+			};
+			if (options.forwardTo !== void 0) return {
+				succeeded: false,
+				outcome: {
+					mode: "http",
+					status_code: error instanceof ForwardFailure ? error.statusCode : null,
+					confirmed: false,
+					transport_error: timedOut ? "timeout" : error instanceof ForwardFailure ? error.transportError : "network",
+					duration_ms: duration()
+				}
+			};
+			throw error;
+		} finally {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", cancel);
+			work.abort();
+		}
+	};
+}
 // src/oclif/notify-session-content.ts
 var NotificationRetryError = class extends ListenStateError {};
 function notificationPartReader(client) {
@@ -951,9 +1280,10 @@ async function openSessionNotifications(options) {
 			}
 		});
 		if (delivery.event_type !== "email.received") throw new ListenStateError("Notification mode received an unrelated event. It remains uncompleted; use an email.received-only subscription.");
+		const { body } = readableDelivery(delivery);
 		let event;
 		try {
-			event = parseWebhookEvent(JSON.parse(delivery.body), delivery.event_type);
+			event = parseWebhookEvent(JSON.parse(body), delivery.event_type);
 		} catch {
 			throw new ListenStateError("Invalid email event; the delivery remains uncompleted.");
 		}
@@ -1114,4 +1444,4 @@ async function openSessionNotifications(options) {
 }
 var ContactNoticeSuppressed = class extends Error {};
 var ContactNoticeDeferred = class extends Error {};
-export { installConnectSkill as _, NotificationRetryError as a, readBundledConnectSkill as b, readConversationStatusContent as c, defaultSessionSocket as d, NativeSessionDisconnectedError as f, connectSkillTarget as g, NotificationOutcomeUnknownError as h, notificationReceiptPage as i, SESSION_UUID as l, NativeSessionNotLoadedError as m, notificationSenders as n, isRoutineNotificationContent as o, NativeSessionError as p, openSessionNotifications as r, notificationPartReader as s, notificationScope as t, connectNativeSession as u, installedConnectSkillFile as v, installedVersion as y };
+export { readBundledConnectSkill as S, NotificationOutcomeUnknownError as _, NotificationRetryError as a, installedConnectSkillFile as b, readConversationStatusContent as c, SESSION_UUID as d, connectNativeSession as f, NativeSessionNotLoadedError as g, NativeSessionError as h, notificationReceiptPage as i, createListenHandler as l, NativeSessionDisconnectedError as m, notificationSenders as n, isRoutineNotificationContent as o, defaultSessionSocket as p, openSessionNotifications as r, notificationPartReader as s, notificationScope as t, readableDelivery as u, connectSkillTarget as v, installedVersion as x, installConnectSkill as y };

package/dist/oclif/auto-signal-worker.js

@@ -1,8 +1,8 @@
-import { Ut as getSentEmail } from "../repeats-Dj_o6c-X-LyCkKYjp.js";
-import { Mt as createAuthenticatedCliApiClient, b as readThreadContext } from "../api-command-rlS3eTlZ.js";
+import { Gt as getSentEmail } from "../repeats-Dj_o6c-X-Bf9G0xds.js";
+import { Mt as createAuthenticatedCliApiClient, x as readThreadContext } from "../api-command-ctHBqTL5.js";
 import { AUTO_SIGNAL_KIND_ENV, AUTO_WORKING_RENEW_MS, autoSignalsDisabled, clearWorkingSending, markWorkingSending, readAutoClaim, readWorkingLease, recordRenewer, stopWorkingLease, writeWorkingLease } from "./auto-signals.js";
 import { _ as acquireListenLock } from "../shared-mail-files-BAQSGxxz.js";
-import { t as sendSignal } from "../signal-command-DCPsJBdz.js";
+import { t as sendSignal } from "../signal-command-CRUMUCNa.js";
 import { join } from "node:path";
 import { homedir } from "node:os";
 // src/oclif/auto-signal-worker.ts

package/dist/oclif/auto-signals.js

@@ -1,4 +1,4 @@
-import { n as isPlainChatReply, o as scopedChatSenderTrust } from "../scoped-chat-B0thCwME.js";
+import { n as isPlainChatReply, o as scopedChatSenderTrust } from "../scoped-chat-DZ42V3jq.js";
 import { d as readMailJson, h as writeMailJson, i as mailId, l as privateMailDirectory, r as mailAddress } from "../shared-mail-files-BAQSGxxz.js";
 import { existsSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
@@ -63,7 +63,7 @@ function autoSignalEligible(detail, identity, admission) {
 		if (!detail.message_id) return false;
 		const parsed = detail.parsed;
 		const to = parsed?.to_addresses;
-		if (!Array.isArray(to) || to.length !== 1 || lower(to[0]?.address) !== agent || (parsed.cc?.length ?? 0) > 0 || (parsed.bcc?.length ?? 0) > 0) return false;
+		if (!Array.isArray(to) || to.length !== 1 || lower(to[0]?.address) !== agent || (parsed?.cc?.length ?? 0) > 0 || (parsed?.bcc?.length ?? 0) > 0) return false;
 		return isPlainChatReply(detail);
 	} catch {
 		return false;