@autono/pinbox-core 0.1.0

package/dist/delivery/router.js

@@ -0,0 +1,262 @@
+import { PinSchema, ThreadMessageSchema } from "../schema.js";
+import { n as buildReplyPrompt, t as buildInjectionContext } from "../context-BHcEpzVb.js";
+//#region src/delivery/hooks.ts
+/** Agents whose hook systems can register + pull (research §1: shared hooks schema). */
+const HOOK_CAPABLE_AGENTS = /* @__PURE__ */ new Set([
+	"claude",
+	"codex",
+	"hermes"
+]);
+function createHooksAdapter() {
+	return {
+		name: "hooks",
+		matches(session) {
+			return session.endedAt === void 0 && HOOK_CAPABLE_AGENTS.has(session.agent);
+		},
+		async deliver() {}
+	};
+}
+//#endregion
+//#region src/delivery/router.ts
+const PULL_ADAPTERS = /* @__PURE__ */ new Set(["hooks"]);
+const NO_ADAPTER = "none";
+const DEFAULT_HOOKS_ESCALATE_MS = 6e5;
+/** Escalation window for pull rows: PINBOX_HOOKS_ESCALATE_MS, default 10 min. */
+function hooksEscalateMs() {
+	const raw = typeof process === "undefined" ? void 0 : process.env["PINBOX_HOOKS_ESCALATE_MS"];
+	if (raw === void 0) return DEFAULT_HOOKS_ESCALATE_MS;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_HOOKS_ESCALATE_MS;
+}
+const BACKOFF_BASE_MS = 3e4;
+const BACKOFF_FACTOR = 4;
+const BACKOFF_CAP_MS = 9e5;
+var DeliveryRouter = class {
+	store;
+	adapters;
+	chain = Promise.resolve();
+	constructor(opts) {
+		this.store = opts.store;
+		this.adapters = [...opts.adapters];
+	}
+	/** THE single entry point; never throws — failures land in the queue. */
+	dispatch(event) {
+		return this.enqueueWork(() => this.dispatchOne(event));
+	}
+	/**
+	* Runs on hub wake + a coarse unref'd interval: (a) boot/cursor reconciliation,
+	* (b) retry/escalate due pending rows, (c) assign unassigned rows to the active
+	* session. Never rejects.
+	*/
+	drainDue(now) {
+		return this.enqueueWork(() => this.drainNow(now ?? (/* @__PURE__ */ new Date()).toISOString()));
+	}
+	enqueueWork(work) {
+		const run = this.chain.then(work).catch(() => {});
+		this.chain = run;
+		return run;
+	}
+	async dispatchOne(event) {
+		if (event.seq <= this.store.deliveries.lastEventSeq()) return;
+		let target;
+		try {
+			target = this.route(event);
+		} catch {
+			target = { kind: "skip" };
+		}
+		if (target.kind === "skip") {
+			this.store.deliveries.enqueue({
+				eventSeq: event.seq,
+				sessionId: null,
+				adapter: NO_ADAPTER,
+				dueAt: null,
+				status: "skipped"
+			});
+			return;
+		}
+		if (target.kind === "unassigned") {
+			this.store.deliveries.enqueue({
+				eventSeq: event.seq,
+				sessionId: null,
+				adapter: NO_ADAPTER,
+				dueAt: null
+			});
+			return;
+		}
+		await this.attemptNew(event, target.session, /* @__PURE__ */ new Date());
+	}
+	/**
+	* Deliverable events are pin.created and thread.message with role human|mirror
+	* (rule 3: agent-authored events are never delivered back). Everything else —
+	* pin.resolved, and later event types — is skipped-by-design.
+	*/
+	route(event) {
+		if (event.type === "pin.created") {
+			const pin = PinSchema.parse(event.payload);
+			return this.bindTarget(pin);
+		}
+		if (event.type === "thread.message") {
+			const message = ThreadMessageSchema.parse(event.payload);
+			if (message.role === "agent") return { kind: "skip" };
+			const pin = this.store.getPin(message.pinId);
+			if (pin === null) return { kind: "skip" };
+			return this.bindTarget(pin);
+		}
+		return { kind: "skip" };
+	}
+	bindTarget(pin) {
+		const { sessions } = this.store;
+		if (pin.agentSession !== void 0) return {
+			kind: "session",
+			session: sessions.findByRef(pin.agentSession) ?? sessions.register(pin.agentSession)
+		};
+		const active = sessions.active();
+		if (active === null) return { kind: "unassigned" };
+		this.store.bindSession(pin.id, sessionRefOf(active));
+		return {
+			kind: "session",
+			session: active
+		};
+	}
+	async attemptNew(event, session, now) {
+		const { deliveries } = this.store;
+		const adapter = await this.selectAdapter(this.adapters, session);
+		if (adapter === null) {
+			deliveries.enqueue({
+				eventSeq: event.seq,
+				sessionId: session.id,
+				adapter: NO_ADAPTER,
+				dueAt: null
+			});
+			return;
+		}
+		if (PULL_ADAPTERS.has(adapter.name)) {
+			const dueAt = new Date(now.getTime() + hooksEscalateMs()).toISOString();
+			const row = deliveries.enqueue({
+				eventSeq: event.seq,
+				sessionId: session.id,
+				adapter: adapter.name,
+				dueAt
+			});
+			try {
+				await adapter.deliver(event, session);
+			} catch (cause) {
+				this.recordFailure(row, cause, now);
+			}
+			return;
+		}
+		const row = deliveries.enqueue({
+			eventSeq: event.seq,
+			sessionId: session.id,
+			adapter: adapter.name,
+			dueAt: null
+		});
+		try {
+			await adapter.deliver(event, session);
+			deliveries.markDelivered(row.id);
+		} catch (cause) {
+			this.recordFailure(row, cause, now);
+		}
+	}
+	async drainNow(now) {
+		const { store } = this;
+		for (const event of store.eventsAfter(store.deliveries.lastEventSeq())) await this.dispatchOne(event);
+		for (const row of store.deliveries.due(now)) {
+			if (row.sessionId === null) continue;
+			try {
+				await this.retryRow(row, now);
+			} catch {}
+		}
+		const active = store.sessions.active();
+		if (active !== null) for (const row of store.deliveries.unassigned()) try {
+			await this.claimRow(row, active, now);
+		} catch {}
+	}
+	async retryRow(row, now) {
+		const { deliveries, sessions } = this.store;
+		const event = this.eventOf(row);
+		if (event === null) {
+			deliveries.markFailed(row.id, `E_DELIVERY: event ${row.eventSeq} missing from log`, null);
+			return;
+		}
+		const session = row.sessionId === null ? null : sessions.get(row.sessionId);
+		if (session === null) {
+			deliveries.markFailed(row.id, `E_SESSION_GONE: session ${row.sessionId} unknown`, null);
+			return;
+		}
+		const adapter = await this.selectAdapter(this.rotatedAfter(row.adapter), session);
+		if (adapter === null) return;
+		if (PULL_ADAPTERS.has(adapter.name)) return;
+		try {
+			await adapter.deliver(event, session);
+			deliveries.markDelivered(row.id);
+		} catch (cause) {
+			this.recordFailure(row, cause, new Date(Date.parse(now)));
+		}
+	}
+	async claimRow(row, active, now) {
+		const event = this.eventOf(row);
+		if (event === null) {
+			this.store.deliveries.markFailed(row.id, `E_DELIVERY: event ${row.eventSeq} missing from log`, null);
+			return;
+		}
+		this.store.deliveries.assign(row.id, active.id);
+		const pinId = pinIdOfEvent(event);
+		if (pinId !== null) try {
+			this.store.bindSession(pinId, sessionRefOf(active));
+		} catch {}
+		await this.retryRow({
+			...row,
+			sessionId: active.id
+		}, now);
+	}
+	async selectAdapter(candidates, session) {
+		for (const adapter of candidates) try {
+			if (await adapter.matches(session)) return adapter;
+		} catch {}
+		return null;
+	}
+	rotatedAfter(name) {
+		const index = this.adapters.findIndex((adapter) => adapter.name === name);
+		if (index < 0) return [...this.adapters];
+		return [...this.adapters.slice(index + 1), ...this.adapters.slice(0, index + 1)];
+	}
+	recordFailure(row, cause, now) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		const sessionGone = message.startsWith("E_SESSION_GONE");
+		const attempts = row.attempts;
+		if (sessionGone || attempts >= 4) {
+			const lastError = sessionGone ? message : `E_DELIVERY: ${message}`;
+			this.store.deliveries.markFailed(row.id, lastError, null);
+			return;
+		}
+		const backoffMs = Math.min(BACKOFF_BASE_MS * BACKOFF_FACTOR ** attempts, BACKOFF_CAP_MS);
+		const retryAt = new Date(now.getTime() + backoffMs).toISOString();
+		this.store.deliveries.markFailed(row.id, message, retryAt);
+	}
+	eventOf(row) {
+		const event = this.store.eventsAfter(row.eventSeq - 1).at(0);
+		return event !== void 0 && event.seq === row.eventSeq ? event : null;
+	}
+};
+function sessionRefOf(session) {
+	return {
+		agent: session.agent,
+		key: session.key,
+		...session.cwd !== void 0 ? { cwd: session.cwd } : {}
+	};
+}
+/** pin.created payloads are the Pin (`id`); thread.message payloads carry `pinId`. */
+function pinIdOfEvent(event) {
+	if (event.type === "pin.created") {
+		const parsed = PinSchema.safeParse(event.payload);
+		return parsed.success ? parsed.data.id : null;
+	}
+	if (event.type === "thread.message") {
+		const parsed = ThreadMessageSchema.safeParse(event.payload);
+		return parsed.success ? parsed.data.pinId : null;
+	}
+	return null;
+}
+//#endregion
+export { DEFAULT_HOOKS_ESCALATE_MS, DeliveryRouter, HOOK_CAPABLE_AGENTS, buildInjectionContext, buildReplyPrompt, createHooksAdapter, hooksEscalateMs };

package/dist/delivery/webhook.d.ts

@@ -0,0 +1,9 @@
+import { n as DeliveryAdapter } from "../router-D3dDjIaD.js";
+//#region src/delivery/webhook.d.ts
+type WebhookConfig = {
+  url: string;
+  secret: string;
+};
+declare function createWebhookAdapter(config: WebhookConfig): DeliveryAdapter;
+//#endregion
+export { WebhookConfig, createWebhookAdapter };

package/dist/delivery/webhook.js

@@ -0,0 +1,52 @@
+//#region src/delivery/webhook.ts
+function createWebhookAdapter(config) {
+	return {
+		name: "webhook",
+		matches() {
+			return true;
+		},
+		async deliver(event, session) {
+			const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+			const body = JSON.stringify({
+				event,
+				session: {
+					id: session.id,
+					agent: session.agent,
+					key: session.key
+				}
+			});
+			const signature = await hmacHex(config.secret, `${timestamp}.${body}`);
+			let response;
+			try {
+				response = await fetch(config.url, {
+					method: "POST",
+					headers: {
+						"content-type": "application/json",
+						"x-pinbox-timestamp": timestamp,
+						"x-pinbox-event": event.type,
+						"x-pinbox-signature": `sha256=${signature}`
+					},
+					body
+				});
+			} catch (cause) {
+				const detail = cause instanceof Error ? cause.message : String(cause);
+				throw new Error(`webhook POST ${config.url} failed: ${detail}`);
+			}
+			if (!response.ok) {
+				await response.arrayBuffer().catch(() => void 0);
+				throw new Error(`webhook POST ${config.url} returned ${response.status}`);
+			}
+		}
+	};
+}
+async function hmacHex(secret, payload) {
+	const encoder = new TextEncoder();
+	const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const bytes = new Uint8Array(await crypto.subtle.sign("HMAC", key, encoder.encode(payload)));
+	return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+//#endregion
+export { createWebhookAdapter };

package/dist/do.d.ts

@@ -0,0 +1,67 @@
+import { a as Pin, f as SessionRef, m as ThreadMessage, r as Link, t as Attachment } from "./schema-BOTmn5SM.js";
+import { r as SessionStore } from "./sessions-CJdMBH3C.js";
+import { a as LinkStore, c as PinStore, i as DeliveryStore, l as StoredEvent, t as CursorStore } from "./store-DHbwWu93.js";
+import { Broadcaster } from "./ws.js";
+import { DurableObjectState, R2Bucket, WebSocket } from "@cloudflare/workers-types";
+//#region src/do-store.d.ts
+interface DoPinStore extends PinStore {
+  addThreadMessage(pinId: string, role: "human" | "agent" | "mirror", text: string, opts?: {
+    origin?: string;
+    attachments?: Attachment[];
+  }): ThreadMessage;
+  /** @throws NotFoundError @throws ConflictError — trailing commit param is additive */
+  resolvePin(id: string, by: "human" | "agent", note?: string, commit?: string): Pin;
+  subscribe(listener: (event: StoredEvent) => void): () => void;
+  readonly sessions: SessionStore;
+  readonly deliveries: DeliveryStore;
+  /** Persists the routing binding into pin.agentSession. No event. @throws NotFoundError */
+  bindSession(pinId: string, ref: SessionRef): Pin;
+  verifyPin(id: string, outcome: "accepted" | "reopened"): Pin;
+  searchPins(query: string): Pin[];
+  readonly cursors: CursorStore;
+  addLink(pinId: string, link: Link): Pin;
+  readonly links: LinkStore;
+}
+//#endregion
+//#region src/do.d.ts
+type PinboxDoEnv = {
+  PINBOX_TOKEN?: string;
+  AUTH_STRATEGY?: "none" | "token" | "jwt";
+  ALLOW_UNAUTHENTICATED?: string;
+  JWT_ISSUER?: string;
+  JWT_JWKS_URL?: string;
+  JWT_AUDIENCE?: string;
+  MEDIA?: R2Bucket;
+  R2_ACCOUNT_ID?: string;
+  R2_BUCKET?: string;
+  R2_ACCESS_KEY_ID?: string;
+  R2_SECRET_ACCESS_KEY?: string;
+};
+declare class DoBroadcaster implements Broadcaster {
+  private readonly state;
+  constructor(state: DurableObjectState);
+  publish(topic: string, data: string): void;
+  subscriberCount(topic: string): number;
+}
+declare class PinboxHubDO {
+  readonly store: DoPinStore;
+  readonly broadcaster: DoBroadcaster;
+  readonly topic: string;
+  private readonly ctx;
+  private readonly env;
+  private readonly strategy;
+  private readonly handler;
+  constructor(ctx: DurableObjectState, env: PinboxDoEnv);
+  fetch(req: Request): Promise<Response>;
+  private intercept;
+  webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): void;
+  webSocketClose(_ws: WebSocket, _code: number, _reason: string, _wasClean: boolean): void;
+  alarm(): Promise<void>;
+  private upgrade;
+  private protocolError;
+  private unauthorized;
+  private createAttachment;
+  private serveMedia;
+}
+//#endregion
+export { DoBroadcaster, PinboxDoEnv, PinboxHubDO };