@modootoday/pmcp 0.9.2 → 0.10.0

package/dist/mailbox/index.js

@@ -0,0 +1,387 @@
+import {
+  HEARTBEAT_INTERVAL_MS,
+  MailboxError,
+  MailboxService,
+  MailboxStore,
+  PRESENCE_TTL_MS,
+  SCHEMA_VERSION,
+  attachMailbox,
+  failure,
+  initializeMailboxConfig,
+  mailboxConfigFrom,
+  openDatabase,
+  readBinding,
+  readCredential,
+  restoreBackup,
+  writeBindingFile,
+  writePrivateJson
+} from "../chunk-HNAVQG6R.js";
+import "../chunk-MSTKY33C.js";
+import {
+  inboxSchema,
+  messageSchema,
+  operationSchema,
+  registerMailboxTools,
+  sendSchema,
+  sessionsSchema
+} from "../chunk-XOH2CW6P.js";
+
+// src/mailbox/notifications.ts
+import { randomUUID } from "crypto";
+var NotificationOutbox = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  discover(binding, nativeTarget) {
+    return this.store.run(() => {
+      this.store.assertBinding(binding);
+      if (!nativeTarget) {
+        throw new MailboxError("invalid_target", "Native target is required");
+      }
+      this.store.database.run(
+        "UPDATE mailbox_notifications SET state = 'stale', lease_token = NULL, lease_until_ms = NULL WHERE actor_id = ? AND session_id != ? AND state IN ('pending', 'leased')",
+        binding.actorId,
+        binding.sessionId
+      );
+      this.store.database.run(
+        "INSERT OR IGNORE INTO mailbox_notifications(message_id, actor_id, session_id, generation, native_target, state, next_attempt_ms) SELECT DISTINCT r.message_id, r.actor_id, ?, ?, ?, 'pending', ? FROM mailbox_receipts r WHERE r.actor_id = ? AND r.ack_at_ms IS NULL AND (r.session_id IS NULL OR r.session_id = ?) AND NOT EXISTS (SELECT 1 FROM mailbox_notifications n WHERE n.message_id = r.message_id AND n.actor_id = r.actor_id AND n.session_id = ?) ORDER BY r.message_id LIMIT 100",
+        binding.sessionId,
+        binding.generation,
+        nativeTarget,
+        this.store.now(),
+        binding.actorId,
+        binding.sessionId,
+        binding.sessionId
+      );
+    });
+  }
+  retryUnsent(binding, claim) {
+    return this.store.run(() => {
+      this.assertLease(binding, claim);
+      const attempts = Number(claim.attempts);
+      this.store.database.run(
+        "UPDATE mailbox_notifications SET state = ?, outcome_code = 'known_unsent', lease_token = NULL, lease_until_ms = NULL, next_attempt_ms = ? WHERE message_id = ? AND actor_id = ? AND session_id = ?",
+        attempts >= 3 ? "failed" : "pending",
+        this.store.now() + Math.min(2e3, 100 * 2 ** (attempts - 1)),
+        claim.message_id,
+        binding.actorId,
+        binding.sessionId
+      );
+    });
+  }
+  reconcile(binding, messageId, delivered) {
+    return this.store.run(() => {
+      this.store.assertBinding(binding);
+      const row = this.store.database.get(
+        "SELECT state, attempts FROM mailbox_notifications WHERE message_id = ? AND actor_id = ? AND session_id = ?",
+        messageId,
+        binding.actorId,
+        binding.sessionId
+      );
+      if (row?.state !== "uncertain") {
+        throw new MailboxError(
+          "reconciliation_conflict",
+          "Only uncertain delivery can be reconciled"
+        );
+      }
+      let state = "pending";
+      if (delivered) {
+        state = "accepted";
+      } else if (Number(row.attempts) >= 3) {
+        state = "failed";
+      }
+      this.store.database.run(
+        "UPDATE mailbox_notifications SET state = ?, outcome_code = 'operator_reconciled', next_attempt_ms = ? WHERE message_id = ? AND actor_id = ? AND session_id = ?",
+        state,
+        this.store.now(),
+        messageId,
+        binding.actorId,
+        binding.sessionId
+      );
+    });
+  }
+  enqueue(messageId, binding, nativeTarget) {
+    return this.store.run(() => {
+      this.store.assertBinding(binding);
+      const receipt = this.store.database.get(
+        "SELECT session_id FROM mailbox_receipts WHERE message_id = ? AND actor_id = ? AND (session_id IS NULL OR session_id = ?)",
+        messageId,
+        binding.actorId,
+        binding.sessionId
+      );
+      if (!receipt || !nativeTarget) {
+        throw new MailboxError(
+          "unknown_message",
+          "Notification target is not a recipient"
+        );
+      }
+      this.store.database.run(
+        "INSERT OR IGNORE INTO mailbox_notifications(message_id, actor_id, session_id, generation, native_target, state, next_attempt_ms) VALUES (?, ?, ?, ?, ?, 'pending', ?)",
+        messageId,
+        binding.actorId,
+        binding.sessionId,
+        binding.generation,
+        nativeTarget,
+        this.store.now()
+      );
+    });
+  }
+  claim(binding) {
+    return this.store.run(() => {
+      this.store.assertBinding(binding);
+      this.store.database.run(
+        "UPDATE mailbox_notifications SET state = 'uncertain', outcome_code = 'dispatcher_lost', lease_token = NULL WHERE actor_id = ? AND state = 'leased' AND lease_until_ms <= ?",
+        binding.actorId,
+        this.store.now()
+      );
+      const row = this.store.database.get(
+        "SELECT * FROM mailbox_notifications WHERE actor_id = ? AND session_id = ? AND generation = ? AND state = 'pending' AND next_attempt_ms <= ? AND attempts < 3 ORDER BY next_attempt_ms LIMIT 1",
+        binding.actorId,
+        binding.sessionId,
+        binding.generation,
+        this.store.now()
+      );
+      if (!row) {
+        return void 0;
+      }
+      const leaseToken = randomUUID();
+      this.store.database.run(
+        "UPDATE mailbox_notifications SET state = 'leased', attempts = attempts + 1, lease_token = ?, lease_until_ms = ? WHERE message_id = ? AND actor_id = ? AND session_id = ?",
+        leaseToken,
+        this.store.now() + 2e4,
+        row.message_id,
+        binding.actorId,
+        binding.sessionId
+      );
+      return { ...row, leaseToken, attempts: Number(row.attempts) + 1 };
+    });
+  }
+  renew(binding, claim) {
+    return this.store.run(() => {
+      this.assertLease(binding, claim);
+      this.store.database.run(
+        "UPDATE mailbox_notifications SET lease_until_ms = ? WHERE message_id = ? AND actor_id = ? AND session_id = ?",
+        this.store.now() + 2e4,
+        claim.message_id,
+        binding.actorId,
+        binding.sessionId
+      );
+    });
+  }
+  assertLease(binding, claim) {
+    this.store.assertBinding(binding);
+    const lease = this.store.database.get(
+      "SELECT state, lease_token, lease_until_ms FROM mailbox_notifications WHERE message_id = ? AND actor_id = ? AND session_id = ?",
+      claim.message_id,
+      binding.actorId,
+      binding.sessionId
+    );
+    if (lease?.state !== "leased" || lease.lease_token !== claim.leaseToken || Number(lease.lease_until_ms) <= this.store.now()) {
+      throw new MailboxError(
+        "stale_lease",
+        "Notification lease is no longer current"
+      );
+    }
+  }
+  complete(binding, claim, outcome) {
+    return this.store.run(() => {
+      this.assertLease(binding, claim);
+      this.store.database.run(
+        "UPDATE mailbox_notifications SET state = ?, outcome_code = ?, lease_token = NULL, lease_until_ms = NULL WHERE message_id = ? AND actor_id = ? AND session_id = ?",
+        outcome,
+        outcome,
+        claim.message_id,
+        binding.actorId,
+        binding.sessionId
+      );
+    });
+  }
+};
+
+// src/mailbox/recovery.ts
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  randomBytes,
+  randomUUID as randomUUID2
+} from "crypto";
+import {
+  closeSync,
+  existsSync,
+  fsyncSync,
+  linkSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname, join } from "path";
+var hash = (value) => createHash("sha256").update(value).digest("hex");
+async function createRecoveryBundle(store, credentials, destination, key) {
+  if (key.length !== 32 || existsSync(destination)) {
+    throw new MailboxError(
+      "invalid_recovery_target",
+      "Use a new destination and a 32-byte recovery key"
+    );
+  }
+  const temporary = `${destination}.${randomUUID2()}.tmp`;
+  const snapshot = `${temporary}.sqlite`;
+  mkdirSync(dirname(destination), { recursive: true, mode: 448 });
+  try {
+    await store.backup(snapshot);
+    const probe = await openDatabase(snapshot);
+    try {
+      if (probe.get("PRAGMA integrity_check")?.integrity_check !== "ok" || probe.all("PRAGMA foreign_key_check").length > 0) {
+        throw new MailboxError(
+          "storage_corrupt",
+          "Recovery snapshot failed validation"
+        );
+      }
+      for (const credential of credentials) {
+        if (credential.projectId !== store.config.projectId || probe.get(
+          "SELECT credential_hash FROM mailbox_actors WHERE id = ?",
+          credential.actorId
+        )?.credential_hash !== hash(credential.secret)) {
+          throw new MailboxError(
+            "credential_mismatch",
+            "Escrow credential does not match the snapshot"
+          );
+        }
+      }
+    } finally {
+      probe.close();
+    }
+    const database = readFileSync(snapshot);
+    const manifest = {
+      version: 1,
+      schemaVersion: SCHEMA_VERSION,
+      projectId: store.config.projectId,
+      createdAtMs: store.now(),
+      providerRuntime: process.version,
+      databaseSha256: hash(database),
+      database: database.toString("base64"),
+      credentials
+    };
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    cipher.setAAD(Buffer.from("pmcp-mailbox-recovery-v1"));
+    const encrypted = Buffer.concat([
+      cipher.update(JSON.stringify(manifest)),
+      cipher.final()
+    ]);
+    writeFileSync(
+      temporary,
+      Buffer.concat([Buffer.from("PMB1"), iv, cipher.getAuthTag(), encrypted]),
+      { flag: "wx", mode: 384 }
+    );
+    const handle = openSync(temporary, "r");
+    try {
+      fsyncSync(handle);
+    } finally {
+      closeSync(handle);
+    }
+    linkSync(temporary, destination);
+    const directory = openSync(dirname(destination), "r");
+    try {
+      fsyncSync(directory);
+    } finally {
+      closeSync(directory);
+    }
+  } finally {
+    for (const file of [
+      temporary,
+      snapshot,
+      `${snapshot}-wal`,
+      `${snapshot}-shm`
+    ]) {
+      rmSync(file, { force: true });
+    }
+  }
+}
+async function restoreRecoveryBundle(source, config, key) {
+  let manifest;
+  try {
+    const bundle = readFileSync(source);
+    if (key.length !== 32 || bundle.subarray(0, 4).toString() !== "PMB1") {
+      throw new Error("Invalid header");
+    }
+    const decipher = createDecipheriv(
+      "aes-256-gcm",
+      key,
+      bundle.subarray(4, 16)
+    );
+    decipher.setAAD(Buffer.from("pmcp-mailbox-recovery-v1"));
+    decipher.setAuthTag(bundle.subarray(16, 32));
+    manifest = JSON.parse(
+      Buffer.concat([
+        decipher.update(bundle.subarray(32)),
+        decipher.final()
+      ]).toString("utf8")
+    );
+    if (manifest.version !== 1 || !Number.isInteger(manifest.schemaVersion) || manifest.schemaVersion < 1 || manifest.schemaVersion > SCHEMA_VERSION || manifest.projectId !== config.projectId || hash(Buffer.from(manifest.database, "base64")) !== manifest.databaseSha256) {
+      throw new Error("Invalid manifest");
+    }
+  } catch {
+    throw new MailboxError(
+      "invalid_recovery_bundle",
+      "Recovery bundle cannot be authenticated or validated"
+    );
+  }
+  const directory = dirname(config.databasePath);
+  mkdirSync(directory, { mode: 448 });
+  const snapshot = join(directory, ".snapshot.sqlite");
+  let store;
+  try {
+    writeFileSync(snapshot, Buffer.from(manifest.database, "base64"), {
+      flag: "wx",
+      mode: 384
+    });
+    await restoreBackup(snapshot, config);
+    store = await MailboxStore.open(config);
+    const actors = await store.run(
+      () => store.database.all("SELECT id FROM mailbox_actors ORDER BY id"),
+      false
+    );
+    const credentials = [];
+    for (const actor of actors) {
+      credentials.push(await store.rotateActor(actor.id));
+    }
+    await store.close();
+    unlinkSync(snapshot);
+    return credentials;
+  } catch (error) {
+    await store?.close();
+    rmSync(directory, { recursive: true, force: true });
+    throw error;
+  }
+}
+export {
+  HEARTBEAT_INTERVAL_MS,
+  MailboxError,
+  MailboxService,
+  MailboxStore,
+  NotificationOutbox,
+  PRESENCE_TTL_MS,
+  attachMailbox,
+  createRecoveryBundle,
+  failure,
+  inboxSchema,
+  initializeMailboxConfig,
+  mailboxConfigFrom,
+  messageSchema,
+  operationSchema,
+  readBinding,
+  readCredential,
+  registerMailboxTools,
+  restoreBackup,
+  restoreRecoveryBundle,
+  sendSchema,
+  sessionsSchema,
+  writeBindingFile,
+  writePrivateJson
+};
+//# sourceMappingURL=index.js.map

package/dist/{server-C9eO6LMI.d.ts → server-CwWcRjqz.d.ts}

@@ -1,6 +1,125 @@
-import { S as SkillEntry, M as MetadataValue, C as CatalogOptions, A as AssetKind } from './catalog-BU5VLLyd.js';
 import { z } from 'zod';
 
+/**
+ * SKILL.md frontmatter, read as YAML the way a host reads it, and checked against
+ * the Agent Skills specification (https://agentskills.io/specification).
+ */
+type MetadataLeaf = string | readonly string[];
+/** A metadata value: a leaf, or a map of leaves one level below the metadata key. */
+type MetadataValue = MetadataLeaf | {
+    readonly [key: string]: MetadataLeaf;
+};
+/**
+ * Parsed frontmatter. A value with an unquoted ": " is a common authoring slip
+ * the client guide says to recover from by quoting it, so that is retried once.
+ */
+declare function frontmatterObject(source: string): Record<string, unknown> | null;
+declare const NAME_MAX = 64;
+declare const DESCRIPTION_MAX = 1024;
+declare const COMPATIBILITY_MAX = 500;
+/**
+ * What the specification requires of one SKILL.md, as messages; empty when valid.
+ * directory is the name of the folder holding it.
+ */
+declare function specProblems(front: Record<string, unknown> | null, directory: string): string[];
+
+/**
+ * The skills the installed packages brought with them.
+ *
+ * Derived from `node_modules` at read time rather than from a list somebody
+ * maintains: installing a package is how its skill arrives and uninstalling it
+ * is how the skill leaves, so the catalog is always true of the project.
+ */
+
+interface SkillEntry {
+    /** `<package>/<slug>`. Unique, and stable while the package is installed. */
+    readonly name: string;
+    readonly package: string;
+    readonly slug: string;
+    /** Frontmatter description. The only text `find` ranks against. */
+    readonly description: string;
+    /** Absolute path to the SKILL.md. `call` reads the body from here. */
+    readonly path: string;
+    /** open, free or paid. Set for marketplace skills, absent for packages. */
+    readonly tier?: string;
+    /** The frontmatter `metadata:` block; maps such as `requires` are kept one level down. */
+    readonly metadata?: Readonly<Record<string, MetadataValue>>;
+    /** Extra search terms. Ranked with the description, never used as triggers. */
+    readonly keywords?: readonly string[];
+    /** What the entry is. Absent means a skill. */
+    readonly kind?: AssetKind;
+    /**
+     * What describe and read may open: a directory, or one file for an asset
+     * that is a single file. Absent means the directory holding `path`.
+     */
+    readonly root?: string;
+}
+/** Everything the catalog serves. Commands are skills; workflows have no kind of their own. */
+declare const ASSET_KINDS: readonly ["skill", "agent", "hook", "mcp"];
+type AssetKind = (typeof ASSET_KINDS)[number];
+declare const kindOf: (entry: Pick<SkillEntry, "kind">) => AssetKind;
+interface CatalogOptions {
+    /** Directories to walk. Each is a `node_modules` root, not a package root. */
+    readonly roots: readonly string[];
+    /** Package name prefixes to consider. Empty means every package. */
+    readonly scopes?: readonly string[];
+    /** Marketplace directories, each holding .claude-plugin/marketplace.json. */
+    readonly marketplaces?: readonly string[];
+    /** Package directories read directly, for a package no node_modules links. */
+    readonly packages?: readonly string[];
+    /** Workspace roots: the root and every member its workspaces globs name. */
+    readonly workspaces?: readonly string[];
+    /** Told about every marketplace skill left out, and why. */
+    readonly onReject?: (rejection: {
+        path: string;
+        reason: string;
+    }) => void;
+    /**
+     * Told about a skill that is served but breaks the Agent Skills specification,
+     * or that lost a name collision. Loading stays lenient, as the client guide asks.
+     */
+    readonly onWarning?: (warning: {
+        path: string;
+        reason: string;
+    }) => void;
+}
+/**
+ * Directories a walk does not enter. Kept as short as the evidence allows: a
+ * name here is a package whose skill will never be found, and the cost of one
+ * extra readdir is far below the cost of missing a skill. Measured 20260906 --
+ * `lib` was on this list and hid playwright's `lib/skill/SKILL.md`, which is
+ * the most widely installed skill in the real world.
+ */
+declare const SKIPPED_DIRS: ReadonlySet<string>;
+/**
+ * How deep below a package root a SKILL.md is looked for. Three reaches every
+ * convention in use (skills, .agent/skills, .claude/skills, .gemini/skills,
+ * .codex/skills); four was measured to find nothing more.
+ */
+declare const MAX_SKILL_DEPTH = 3;
+/**
+ * Top-level scalar fields of a SKILL.md frontmatter, parsed as YAML, so a folded
+ * `description: >-` arrives as its text rather than as the indicator.
+ */
+declare function readFrontmatter(source: string): Record<string, string>;
+/** The body after the frontmatter, or the whole file when there is none. */
+declare function readBody(source: string): string;
+/**
+ * Every skill reachable from the given roots, sorted by name.
+ *
+ * A package with no skills directory contributes nothing and costs one
+ * `existsSync` per convention. A skill with no description is skipped rather
+ * than listed:
+ * `find` ranks descriptions, so one without a description can only ever be
+ * found by already knowing its name, and listing it would spend a session's
+ * tokens on an entry that cannot answer.
+ */
+declare function readCatalog(options: CatalogOptions): SkillEntry[];
+/** A catalog entry without its body, which is what `catalog` returns. */
+declare function withoutBody({ path, ...rest }: SkillEntry): Omit<SkillEntry, "path">;
+/** Path relative to a root, for a message a reader can act on. */
+declare function displayPath(root: string, entry: SkillEntry): string;
+
 /**
  * The intent key and the cache contract.
  *
@@ -56,6 +175,7 @@ interface FindResult {
  */
 interface Embedder {
     readonly modelId: string;
+    readonly indexKey?: string;
     readonly dims: number;
     /** Encodes an intent, the query side. */
     embed(text: string): Promise<Float32Array>;
@@ -421,4 +541,4 @@ declare function createSkillTools(options: SkillServerOptions): {
 };
 type SkillTools = ReturnType<typeof createSkillTools>;
 
-export { detectRuntime as A, type BundleFile as B, CATALOG_PAGE_MAX as C, DEFAULT_FIND_LIMIT as D, type Embedder as E, type FileKind as F, find as G, findResultSchema as H, type IntentCache as I, isUtf8Text as J, type KindFilter as K, lexicalScore as L, type Match as M, listSkillFiles as N, mimeOf as O, normaliseIntent as P, readSkillFile as Q, READ_BUDGET_BYTES as R, type SkillServerOptions as S, runtimeOfClient as T, verifiedRuntimesOf as U, type SkillTools as a, CATALOG_PAGE_SIZE as b, type CallResponse as c, type CatalogItem as d, type CatalogResponse as e, type Classified as f, DESCRIBE_FILE_LIMIT as g, type FindOptions as h, type FindResult as i, type IntentCacheStats as j, RUNTIMES as k, type Ranking as l, type ReadResult as m, type Runtime as n, type SkillBundle as o, type SkillFile as p, type SkillFileContent as q, type SkillFileListing as r, type SkillFilters as s, bundleResponseSchema as t, bundleSkill as u, catalogResponseSchema as v, classify as w, cosine as x, createSkillTools as y, describeResponseSchema as z };
+export { lexicalScore as $, ASSET_KINDS as A, type BundleFile as B, type CatalogOptions as C, DEFAULT_FIND_LIMIT as D, type Embedder as E, type FileKind as F, type SkillFileListing as G, type SkillFilters as H, type IntentCache as I, bundleResponseSchema as J, type KindFilter as K, bundleSkill as L, type MetadataValue as M, NAME_MAX as N, catalogResponseSchema as O, classify as P, cosine as Q, type Ranking as R, type SkillServerOptions as S, createSkillTools as T, describeResponseSchema as U, detectRuntime as V, displayPath as W, find as X, findResultSchema as Y, isUtf8Text as Z, kindOf as _, type SkillEntry as a, listSkillFiles as a0, mimeOf as a1, normaliseIntent as a2, frontmatterObject as a3, readBody as a4, readCatalog as a5, readFrontmatter as a6, readSkillFile as a7, runtimeOfClient as a8, specProblems as a9, verifiedRuntimesOf as aa, withoutBody as ab, type SkillTools as b, type AssetKind as c, CATALOG_PAGE_MAX as d, CATALOG_PAGE_SIZE as e, COMPATIBILITY_MAX as f, type CallResponse as g, type CatalogItem as h, type CatalogResponse as i, type Classified as j, DESCRIBE_FILE_LIMIT as k, DESCRIPTION_MAX as l, type FindOptions as m, type FindResult as n, type IntentCacheStats as o, MAX_SKILL_DEPTH as p, type Match as q, type MetadataLeaf as r, READ_BUDGET_BYTES as s, RUNTIMES as t, type ReadResult as u, type Runtime as v, SKIPPED_DIRS as w, type SkillBundle as x, type SkillFile as y, type SkillFileContent as z };

package/dist/service-qpCsOXkQ.d.ts

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+
+declare const operationSchema: z.ZodEnum<{
+    read: "read";
+    send: "send";
+    inbox: "inbox";
+    ack: "ack";
+    sessions: "sessions";
+}>;
+type MailboxOperation = z.output<typeof operationSchema>;
+declare const sessionsSchema: z.ZodObject<{}, z.core.$strict>;
+declare const sendSchema: z.ZodObject<{
+    recipients: z.ZodArray<z.ZodObject<{
+        actorId: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodUUID>;
+    }, z.core.$strict>>;
+    body: z.ZodString;
+    idempotencyKey: z.ZodString;
+    replyToId: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strict>;
+declare const inboxSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    state: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        unread: "unread";
+        unacknowledged: "unacknowledged";
+    }>>;
+    threadId: z.ZodOptional<z.ZodUUID>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const messageSchema: z.ZodObject<{
+    messageId: z.ZodUUID;
+}, z.core.$strict>;
+
+type SqlValue = string | number | null;
+type Row = Record<string, unknown>;
+interface Database {
+    exec(sql: string): void;
+    get(sql: string, ...values: SqlValue[]): Row | undefined;
+    all(sql: string, ...values: SqlValue[]): Row[];
+    run(sql: string, ...values: SqlValue[]): void;
+    close(): void;
+}
+interface ActorCredential {
+    projectId: string;
+    actorId: string;
+    secret: string;
+}
+interface Binding {
+    projectId: string;
+    actorId: string;
+    sessionId: string;
+    generation: number;
+    secret: string;
+}
+interface MailboxConfig {
+    projectId: string;
+    databasePath: string;
+    enabled: boolean;
+}
+type Result<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        retryable: boolean;
+    };
+};
+declare class MailboxError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(code: string, message: string, retryable?: boolean);
+}
+declare function failure(error: unknown): Result<never>;
+
+declare const PRESENCE_TTL_MS = 120000;
+declare const HEARTBEAT_INTERVAL_MS = 30000;
+declare class MailboxStore {
+    private pending;
+    private closed;
+    readonly config: MailboxConfig;
+    readonly database: Database;
+    readonly now: () => number;
+    private constructor();
+    static open(config: MailboxConfig, now?: () => number): Promise<MailboxStore>;
+    checkSchema(): void;
+    run<T>(operation: () => T, write?: boolean): Promise<T>;
+    registerActor(actorId: string, parentActorId?: string, persist?: (credential: ActorCredential) => void, authorityTtlMs?: number, parentBinding?: Binding): Promise<ActorCredential>;
+    registerChild(parent: Binding, actorId: string, ttlMs?: number): Promise<ActorCredential>;
+    attach(credential: ActorCredential, runtime: string, replaceSessionId?: string, nativeSessionId?: string): Promise<Binding>;
+    assertBinding(binding: Binding): Row;
+    rotateActor(actorId: string, persist?: (credential: ActorCredential) => void): Promise<ActorCredential>;
+    heartbeat(binding: Binding): Promise<void>;
+    detach(binding: Binding): Promise<void>;
+    exportRecords(actorId?: string): Promise<object[]>;
+    backup(destination: string): Promise<void>;
+    close(): Promise<void>;
+}
+declare function restoreBackup(source: string, config: MailboxConfig): Promise<void>;
+
+declare class MailboxService {
+    readonly store: MailboxStore;
+    readonly binding: Binding;
+    constructor(store: MailboxStore, binding: Binding);
+    call(operation: MailboxOperation, input: unknown): Promise<Result<object>>;
+    private send;
+    private visibleMessage;
+    private inbox;
+    private receipt;
+    private sessions;
+}
+
+export { type ActorCredential as A, type Binding as B, HEARTBEAT_INTERVAL_MS as H, MailboxService as M, PRESENCE_TTL_MS as P, type Row as R, type MailboxConfig as a, MailboxStore as b, MailboxError as c, type MailboxOperation as d, type Result as e, failure as f, sessionsSchema as g, inboxSchema as i, messageSchema as m, operationSchema as o, restoreBackup as r, sendSchema as s };

package/dist/stdio.d.ts

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
-import { C as CatalogOptions } from './catalog-BU5VLLyd.js';
+import { serveStdio } from '@modelcontextprotocol/server/stdio';
+import { S as SkillServerOptions, C as CatalogOptions } from './server-CwWcRjqz.js';
+import { M as MailboxService } from './service-qpCsOXkQ.js';
+import { M as MailboxAttachmentOptions } from './attachment-tU5FZrgZ.js';
+import 'zod';
 
 /**
  * The stdio entry a host launches.
@@ -11,11 +15,13 @@ import { C as CatalogOptions } from './catalog-BU5VLLyd.js';
 
 /** `node_modules` roots to walk, from argv or from the working directory. */
 declare function resolveRoots(argv: readonly string[], cwd: string): string[];
-interface ServeOptions {
+interface ServeOptions extends Pick<SkillServerOptions, "embedder" | "vectors" | "loadCatalog"> {
+    readonly mailbox?: MailboxService;
     /** One prompt per skill, for hosts that offer prompts as commands. */
     readonly prompts?: boolean;
 }
-declare function serve(catalog: CatalogOptions, serving?: ServeOptions): void;
+declare function serve(catalog: CatalogOptions, serving?: ServeOptions): ReturnType<typeof serveStdio>;
+declare function serveWithMailbox(catalog: CatalogOptions, mailbox: MailboxAttachmentOptions, serving?: ServeOptions): Promise<() => Promise<void>>;
 declare function main(argv?: readonly string[]): void;
 
-export { type ServeOptions, main, resolveRoots, serve };
+export { type ServeOptions, main, resolveRoots, serve, serveWithMailbox };

package/dist/stdio.js

@@ -2,12 +2,17 @@
 import {
   main,
   resolveRoots,
-  serve
-} from "./chunk-EIHMCKY5.js";
-import "./chunk-A5NOHVHN.js";
+  serve,
+  serveWithMailbox
+} from "./chunk-JRSR4JBR.js";
+import "./chunk-VRZFM2M5.js";
+import "./chunk-HNAVQG6R.js";
+import "./chunk-MSTKY33C.js";
+import "./chunk-XOH2CW6P.js";
 export {
   main,
   resolveRoots,
-  serve
+  serve,
+  serveWithMailbox
 };
 //# sourceMappingURL=stdio.js.map