@pome-sh/cli 0.2.0 → 0.4.0

package/dist/src/scenario/scenarioSchema.js

@@ -1,8 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 import { seedSchema as githubSeedStateSchema } from "@pome-sh/twin-github";
-// Criterion kinds are owned by the published contract. `criterionSchema`
-// accepts the legacy `D`/`P` spellings and normalizes them to `code`/`model`,
-// so existing scenario files keep parsing. The former local `["D","P"]` fork is
+import { gmailSeedSchema as gmailSeedStateSchema } from "@pome-sh/twin-gmail";
+import { linearSeedSchema as linearSeedStateSchema } from "@pome-sh/twin-linear";
+// Criterion kinds are owned by the published contract. The markdown marker
+// grammar is `[code]`/`[model]` (F-778); `criterionSchema`'s tolerant input
+// (legacy `D`/`P` enum values) exists only for 0.3.0-era persisted artifacts,
+// never for scenario markdown. The former local criterion-kind fork is
 // retired here (M6 — one published contract).
 import { criterionSchema } from "@pome-sh/shared-types";
 import { z } from "zod";
@@ -74,7 +77,9 @@ export const slackSeedStateSchema = z
 // seed carries keys it rejects, so it never mis-matches them; while a Slack
 // seed would otherwise be silently key-stripped by the non-strict GitHub arm.
 export const seedStateSchema = z.union([
+    gmailSeedStateSchema,
     slackSeedStateSchema,
+    linearSeedStateSchema,
     githubSeedStateSchema,
     stripeSeedStateSchema
 ]);

package/dist/src/twin/twinHarness.d.ts

@@ -8,13 +8,15 @@ export type TwinHarness = {
     };
     /** Uppercase env prefix: the agent reads `POME_<envName>_{REST,MCP}_URL`. */
     envName: string;
-    /** Twin state for `[D]` scoring (initial before the agent, final after). */
+    /** Twin state for `[code]` scoring (initial before the agent, final after). */
     exportState(): unknown | Promise<unknown>;
     /** Recorded twin HTTP events (shared buffer). */
     events(): RecorderEvent[];
     /** Extra JWT claims the runner mints into the agent token (e.g. Stripe's
      *  `account_id`, so the token resolves to the account the seed lives in). */
     extraClaims?: Record<string, unknown>;
+    /** Provider-specific bearer alias, when the provider SDK expects one. */
+    tokenEnvName?: string;
     /**
      * Durability barrier for the twin recorder without closing the DB.
      * Call before finalize/merge so pending TwinHttpEvent rows land on disk

package/dist/src/twin/twinHarness.js

@@ -9,7 +9,7 @@
 // regardless of twin —
 //   - `app`         a Hono app (`.fetch`) the runner serves on a localhost port
 //   - `envName`     the `POME_<NAME>_{REST,MCP}_URL` prefix the agent reads
-//   - `exportState` initial/final twin state for deterministic `[D]` scoring
+//   - `exportState` initial/final twin state for deterministic `[code]` scoring
 //   - `events`      recorded twin HTTP events (one shared recorder buffer)
 //   - `close`       tear down the underlying SQLite handle
 //
@@ -23,6 +23,8 @@ import { createSlackTwinApp, openSlackTwinDatabase, SlackDomain, } from "@pome-s
 import { createApp } from "@pome-sh/sdk/server";
 import * as stripeTwin from "@pome-sh/twin-stripe";
 import { applySeed as applyStripeSeed, createTwinStripeApp, openTwinStripeDatabase, parseSeed as parseStripeSeed, StripeDomain, } from "@pome-sh/twin-stripe";
+import { createGmailTwinApp, GmailDomain, openGmailTwinDatabase, parseSeed as parseGmailSeed, } from "@pome-sh/twin-gmail";
+import { createLinearTwinApp, DEFAULT_LINEAR_EMAIL, LinearDomain, openLinearTwinDatabase, parseSeed as parseLinearSeed, } from "@pome-sh/twin-linear";
 // The account every local Stripe scenario seeds under. The runner mints a JWT
 // whose `account_id` claim matches this, so `exportState` and the session
 // resolve to the same account the seed data lives in.
@@ -31,7 +33,7 @@ export class UnsupportedTwinError extends Error {
     twin;
     constructor(twin) {
         super(`Self-hosted local runs do not support the '${twin}' twin yet. ` +
-            `Supported: github, slack, stripe.`);
+            `Supported: github, slack, stripe, gmail, linear.`);
         this.twin = twin;
         this.name = "UnsupportedTwinError";
     }
@@ -133,6 +135,51 @@ export async function bootTwin(opts) {
                 close: () => closeRecorderAndDb(() => db.close()),
             };
         }
+        case "gmail": {
+            const db = openGmailTwinDatabase(":memory:");
+            const seed = parseGmailSeed(opts.seedState);
+            const domain = new GmailDomain(db);
+            const app = createGmailTwinApp({
+                db,
+                seed,
+                recorder,
+                runId: opts.runId,
+            });
+            return {
+                app,
+                envName: "GMAIL",
+                exportState: () => domain.exportState(),
+                events: () => recorder.events(),
+                extraClaims: { gmail_email: seed.primaryMailbox.email },
+                tokenEnvName: "POME_GMAIL_TOKEN",
+                flush: () => flushRecorder(),
+                close: () => closeRecorderAndDb(() => db.close()),
+            };
+        }
+        case "linear": {
+            const db = openLinearTwinDatabase(":memory:");
+            const seed = parseLinearSeed(opts.seedState);
+            const domain = new LinearDomain(db);
+            const app = createLinearTwinApp({
+                db,
+                seed,
+                recorder,
+                runId: opts.runId,
+            });
+            const primaryEmail = seed.users.find((user) => user.admin)?.email ??
+                seed.users[0]?.email ??
+                DEFAULT_LINEAR_EMAIL;
+            return {
+                app,
+                envName: "LINEAR",
+                exportState: () => domain.exportState(),
+                events: () => recorder.events(),
+                extraClaims: { linear_email: primaryEmail },
+                tokenEnvName: "POME_LINEAR_TOKEN",
+                flush: () => flushRecorder(),
+                close: () => closeRecorderAndDb(() => db.close()),
+            };
+        }
         default:
             throw new UnsupportedTwinError(opts.twin);
     }

package/dist/src/twin/twinStart.d.ts

@@ -1,4 +1,4 @@
-export declare const SUPPORTED_STANDALONE_TWINS: readonly ["github", "slack", "stripe"];
+export declare const SUPPORTED_STANDALONE_TWINS: readonly ["github", "slack", "stripe", "gmail", "linear"];
 export type StandaloneAuthSecret = {
     secret: string;
     source: "env" | "persisted" | "ephemeral";
@@ -14,6 +14,8 @@ export type StandaloneAuthSecret = {
  *   3. a fresh per-boot secret, NOT persisted (loopback dev path)
  */
 export declare function resolveStandaloneAuthSecret(twin: string, env?: NodeJS.ProcessEnv): StandaloneAuthSecret;
+/** Resolve listen port for `pome twin start` when `--port` is omitted. */
+export declare function defaultPortFor(twin: string, env?: NodeJS.ProcessEnv): string;
 export declare function runTwinStartCommand(name: string, options: {
     port?: string;
 }): Promise<void>;

package/dist/src/twin/twinStart.js

@@ -22,8 +22,10 @@ import { serve } from "@hono/node-server";
 import { sign } from "hono/jwt";
 import { defaultSeedState as defaultSlackSeedState } from "@pome-sh/twin-slack";
 import { defaultSeed as defaultStripeSeed } from "@pome-sh/twin-stripe";
+import { defaultSeedState as defaultGmailSeedState } from "@pome-sh/twin-gmail";
+import { defaultSeedState as defaultLinearSeedState } from "@pome-sh/twin-linear";
 import { bootTwin } from "./twinHarness.js";
-export const SUPPORTED_STANDALONE_TWINS = ["github", "slack", "stripe"];
+export const SUPPORTED_STANDALONE_TWINS = ["github", "slack", "stripe", "gmail", "linear"];
 /** The fixed session id a standalone twin serves under (`/s/standalone`). */
 const STANDALONE_SID = "standalone";
 /**
@@ -65,19 +67,33 @@ function defaultSeedFor(twin) {
             return defaultSlackSeedState();
         case "stripe":
             return defaultStripeSeed();
+        case "gmail":
+            return defaultGmailSeedState();
+        case "linear":
+            return defaultLinearSeedState();
         default:
             // github: bootTwin's adapter seeds the default world when the seed is
             // undefined (pre-existing standalone behavior).
             return undefined;
     }
 }
+/** Resolve listen port for `pome twin start` when `--port` is omitted. */
+export function defaultPortFor(twin, env = process.env) {
+    if (env.PORT)
+        return env.PORT;
+    if (twin === "gmail")
+        return env.GMAIL_TWIN_PORT ?? "3336";
+    if (twin === "linear")
+        return env.LINEAR_TWIN_PORT ?? "3337";
+    return "3333";
+}
 export async function runTwinStartCommand(name, options) {
     if (!SUPPORTED_STANDALONE_TWINS.includes(name)) {
         throw new Error(`Unknown twin '${name}'. Supported: ${SUPPORTED_STANDALONE_TWINS.join(", ")}.`);
     }
-    // `PORT` fallback keeps the spawn surface env-drivable (the contract
-    // suite injects PORT, same as the packaged twin entries).
-    const portRaw = options.port ?? process.env.PORT ?? "3333";
+    // `PORT` wins when set (contract suite / packaged entries). Gmail defaults
+    // to 3336 via GMAIL_TWIN_PORT; other twins keep 3333.
+    const portRaw = options.port ?? defaultPortFor(name, process.env);
     const port = Number(portRaw);
     // Port 0 (ephemeral) is rejected: every printed URL and the status-file
     // token would name a port nobody can discover from outside the process.
@@ -127,6 +143,8 @@ export async function runTwinStartCommand(name, options) {
     console.log(`POME_${harness.envName}_REST_URL=${restUrl}`);
     console.log(`POME_${harness.envName}_MCP_URL=${mcpUrl}`);
     console.log(`POME_AUTH_TOKEN=${token}`);
+    if (harness.tokenEnvName)
+        console.log(`${harness.tokenEnvName}=${token}`);
     // F28 — every `/s/<sid>/*` endpoint requires a Bearer JWT, including
     // /s/standalone/healthz. New users curling the printed `${restUrl}` get
     // HTTP 401 and assume the twin is broken. The unauth liveness probe lives

package/node_modules/@hono/node-server/dist/index.cjs

@@ -60,6 +60,54 @@ const newHeadersFromIncoming = (incoming) => {
 	return new Headers(headerRecord);
 };
 const wrapBodyStream = Symbol("wrapBodyStream");
+const byteExactEncodings = new Set([
+	"latin1",
+	"binary",
+	"hex",
+	"base64",
+	"base64url"
+]);
+const isByteExactEncoding = (encoding) => encoding === null || byteExactEncodings.has(encoding);
+const bodyBufferedBeforeDisconnectKey = Symbol("bodyBufferedBeforeDisconnect");
+const bodyBufferedLengthBeforeDisconnectKey = Symbol("bodyBufferedLengthBeforeDisconnect");
+const toBufferChunk = (chunk, encoding) => Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding ?? "utf8");
+const isRecoverableDisconnectedIncoming = (incoming) => !(incoming instanceof node_http2.Http2ServerRequest) && !!incoming.complete && !!incoming.readableAborted && typeof incoming.read === "function" && isByteExactEncoding(incoming.readableEncoding);
+const recordBodyBufferedBeforeDisconnect = (incoming) => {
+	if (incoming.readableDidRead || !isRecoverableDisconnectedIncoming(incoming)) return;
+	const incomingWithRecovery = incoming;
+	incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey] ??= incoming.readableLength;
+};
+const readBodyBufferedBeforeDisconnect = (incoming, chunks) => {
+	if (incoming.readableDidRead && !chunks || !isRecoverableDisconnectedIncoming(incoming)) return;
+	const incomingWithRecovery = incoming;
+	if (incomingWithRecovery[bodyBufferedBeforeDisconnectKey] !== void 0) return incomingWithRecovery[bodyBufferedBeforeDisconnectKey];
+	let result;
+	const errored = incoming.errored;
+	if (errored && errored.code !== "ECONNRESET") result = errored;
+	else if (incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey] !== void 0 && incoming.readableLength !== incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey]) result = newBodyUnusableError();
+	else {
+		const bodyChunks = chunks ?? [];
+		const chunk = incoming.read();
+		if (chunk !== null) bodyChunks.push(toBufferChunk(chunk, incoming.readableEncoding));
+		const buffer = bodyChunks.length === 1 ? bodyChunks[0] : Buffer.concat(bodyChunks);
+		result = buffer;
+		const contentLength = incoming.headers["content-length"];
+		if (typeof contentLength === "string" && /^\d+$/.test(contentLength)) {
+			const expectedLength = Number(contentLength);
+			if (Number.isSafeInteger(expectedLength) && buffer.length !== expectedLength) result = newBodyUnusableError();
+		}
+	}
+	incomingWithRecovery[bodyBufferedBeforeDisconnectKey] = result;
+	return result;
+};
+const enqueueBufferedBody = (controller, buffered) => {
+	if (buffered instanceof Error) {
+		controller.error(buffered);
+		return;
+	}
+	if (buffered.length > 0) controller.enqueue(buffered);
+	controller.close();
+};
 const newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
 	const init = {
 		method,
@@ -82,6 +130,13 @@ const newRequestFromIncoming = (method, url, headers, incoming, abortController)
 		let reader;
 		init.body = new ReadableStream({ async pull(controller) {
 			try {
+				if (!reader) {
+					const buffered = readBodyBufferedBeforeDisconnect(incoming);
+					if (buffered !== void 0) {
+						enqueueBufferedBody(controller, buffered);
+						return;
+					}
+				}
 				reader ||= node_stream.Readable.toWeb(incoming).getReader();
 				const { done, value } = await reader.read();
 				if (done) controller.close();
@@ -90,7 +145,13 @@ const newRequestFromIncoming = (method, url, headers, incoming, abortController)
 				controller.error(error);
 			}
 		} });
-	} else init.body = node_stream.Readable.toWeb(incoming);
+	} else {
+		const buffered = readBodyBufferedBeforeDisconnect(incoming);
+		if (buffered !== void 0) init.body = new ReadableStream({ start(controller) {
+			enqueueBufferedBody(controller, buffered);
+		} });
+		else init.body = node_stream.Readable.toWeb(incoming);
+	}
 	return new Request$1(url, init);
 };
 const getRequestCache = Symbol("getRequestCache");
@@ -178,11 +239,23 @@ const readRawBodyIfAvailable = (request) => {
 	const incoming = request[incomingKey];
 	if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) return incoming.rawBody;
 };
+const normalizeAbortError = (request, incoming) => {
+	if (incoming.errored) return incoming.errored;
+	const reason = request[abortReasonKey];
+	if (reason !== void 0) return reason instanceof Error ? reason : new Error(String(reason));
+	return /* @__PURE__ */ new Error("Client connection prematurely closed.");
+};
 const readBodyDirect = (request) => {
 	if (request[bodyBufferKey]) return Promise.resolve(request[bodyBufferKey]);
 	if (request[bodyReadPromiseKey]) return request[bodyReadPromiseKey];
 	const incoming = request[incomingKey];
-	if (node_stream.Readable.isDisturbed(incoming)) return rejectBodyUnusable();
+	if (incoming.readableDidRead) return rejectBodyUnusable();
+	const buffered = readBodyBufferedBeforeDisconnect(incoming);
+	if (buffered !== void 0) {
+		if (buffered instanceof Error) return Promise.reject(buffered);
+		request[bodyBufferKey] = buffered;
+		return Promise.resolve(buffered);
+	}
 	const promise = new Promise((resolve, reject) => {
 		const chunks = [];
 		let settled = false;
@@ -192,8 +265,22 @@ const readBodyDirect = (request) => {
 			cleanup();
 			callback();
 		};
+		const recoverCompleteBodyAfterDisconnect = (error) => {
+			const streamError = incoming.errored ?? error;
+			if (!isRecoverableDisconnectedIncoming(incoming) || streamError && streamError.code !== "ECONNRESET") return false;
+			finish(() => {
+				const recovered = readBodyBufferedBeforeDisconnect(incoming, chunks);
+				if (recovered instanceof Error) reject(recovered);
+				else if (recovered === void 0) reject(error ?? normalizeAbortError(request, incoming));
+				else {
+					request[bodyBufferKey] = recovered;
+					resolve(recovered);
+				}
+			});
+			return true;
+		};
 		const onData = (chunk) => {
-			chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+			chunks.push(toBufferChunk(chunk, incoming.readableEncoding));
 		};
 		const onEnd = () => {
 			finish(() => {
@@ -203,6 +290,7 @@ const readBodyDirect = (request) => {
 			});
 		};
 		const onError = (error) => {
+			if (recoverCompleteBodyAfterDisconnect(error)) return;
 			finish(() => {
 				reject(error);
 			});
@@ -212,17 +300,9 @@ const readBodyDirect = (request) => {
 				onEnd();
 				return;
 			}
+			if (recoverCompleteBodyAfterDisconnect()) return;
 			finish(() => {
-				if (incoming.errored) {
-					reject(incoming.errored);
-					return;
-				}
-				const reason = request[abortReasonKey];
-				if (reason !== void 0) {
-					reject(reason instanceof Error ? reason : new Error(String(reason)));
-					return;
-				}
-				reject(/* @__PURE__ */ new Error("Client connection prematurely closed."));
+				reject(normalizeAbortError(request, incoming));
 			});
 		};
 		const cleanup = () => {
@@ -617,8 +697,13 @@ const drainIncoming = (incoming) => {
 	incoming.resume();
 };
 const makeCloseHandler = (req, incoming, outgoing, needsBodyCleanup) => () => {
-	if (incoming.errored) req[abortRequest](incoming.errored.toString());
-	else if (!outgoing.writableFinished) req[abortRequest]("Client connection prematurely closed.");
+	if (incoming.errored) {
+		recordBodyBufferedBeforeDisconnect(incoming);
+		req[abortRequest](incoming.errored.toString());
+	} else if (!outgoing.writableFinished) {
+		recordBodyBufferedBeforeDisconnect(incoming);
+		req[abortRequest]("Client connection prematurely closed.");
+	}
 	if (needsBodyCleanup && !incoming.readableEnded) setTimeout(() => {
 		if (!incoming.readableEnded) setTimeout(() => {
 			drainIncoming(incoming);
@@ -839,6 +924,32 @@ const CloseEvent = globalThis.CloseEvent ?? class extends Event {
 		return this.#eventInitDict.reason ?? "";
 	}
 };
+/**
+* Node.js has no global `ErrorEvent`, unlike `Event`/`MessageEvent`/`CloseEvent`.
+* @link https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
+*/
+const ErrorEvent = globalThis.ErrorEvent ?? class extends Event {
+	#eventInitDict;
+	constructor(type, eventInitDict = {}) {
+		super(type, eventInitDict);
+		this.#eventInitDict = eventInitDict;
+	}
+	get message() {
+		return this.#eventInitDict.message ?? "";
+	}
+	get filename() {
+		return this.#eventInitDict.filename ?? "";
+	}
+	get lineno() {
+		return this.#eventInitDict.lineno ?? 0;
+	}
+	get colno() {
+		return this.#eventInitDict.colno ?? 0;
+	}
+	get error() {
+		return this.#eventInitDict.error ?? null;
+	}
+};
 const generateConnectionSymbol = () => Symbol("connection");
 const CONNECTION_SYMBOL_KEY = Symbol("CONNECTION_SYMBOL_KEY");
 const WAIT_FOR_WEBSOCKET_SYMBOL = Symbol("WAIT_FOR_WEBSOCKET_SYMBOL");
@@ -890,10 +1001,18 @@ const setupWebSocket = (options) => {
 			waiterMap.delete(request);
 		}
 	});
+	const rejectWaiter = (request) => {
+		const waiter = waiterMap.get(request);
+		if (waiter) {
+			waiterMap.delete(request);
+			waiter.reject(/* @__PURE__ */ new Error("WebSocket handshake aborted"));
+		}
+	};
 	const waitForWebSocket = (request, connectionSymbol) => {
-		return new Promise((resolve) => {
+		return new Promise((resolve, reject) => {
 			waiterMap.set(request, {
 				resolve,
+				reject,
 				connectionSymbol
 			});
 		});
@@ -920,16 +1039,19 @@ const setupWebSocket = (options) => {
 		}
 		const waiter = waiterMap.get(request);
 		if (!waiter || waiter.connectionSymbol !== env[CONNECTION_SYMBOL_KEY]) {
-			waiterMap.delete(request);
+			rejectWaiter(request);
 			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, status, responseHeaders);
 			return;
 		}
 		const addResponseHeaders = (headers) => {
 			appendResponseHeaders(headers, responseHeaders);
 		};
+		const reclaimWaiterOnClose = () => rejectWaiter(request);
+		socket.once("close", reclaimWaiterOnClose);
 		wss.on("headers", addResponseHeaders);
 		try {
 			wss.handleUpgrade(request, socket, head, (ws) => {
+				socket.off("close", reclaimWaiterOnClose);
 				wss.emit("connection", ws, request);
 			});
 		} finally {
@@ -948,7 +1070,12 @@ const upgradeWebSocket = (0, hono_ws.defineWebSocketHelper)(async (c, events, op
 	const connectionSymbol = generateConnectionSymbol();
 	env[CONNECTION_SYMBOL_KEY] = connectionSymbol;
 	(async () => {
-		const ws = await waitForWebSocket(env.incoming, connectionSymbol);
+		let ws;
+		try {
+			ws = await waitForWebSocket(env.incoming, connectionSymbol);
+		} catch {
+			return;
+		}
 		const messagesReceivedInStarting = [];
 		const bufferMessage = (data, isBinary) => {
 			messagesReceivedInStarting.push([data, isBinary]);