kojee-mcp 0.5.11 → 0.5.13

package/dist/{hook-server-37E2LUKJ.js → hook-server-T2Z444OV.js}

@@ -3,8 +3,8 @@ import {
   httpStatusForEnvelope,
   parseSendRequest,
   sendFailure
-} from "./chunk-HIZ4NDWN.js";
-import "./chunk-LDZXU3DW.js";
+} from "./chunk-DXJ6QLSJ.js";
+import "./chunk-2OLXXOT3.js";
 
 // src/tandem/hook-server.ts
 import crypto from "crypto";

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { G as GatewayClient, P as ProxyConfig } from './gateway-client-93P1E0CZ.js';
+import { G as GatewayClient, P as ProxyConfig } from './gateway-client-C6yx1mfM.js';
 import 'jose';
 
 /**

package/dist/index.js

@@ -1,17 +1,18 @@
 import {
   listTandemIds,
   startProxy
-} from "./chunk-D42PZX2I.js";
-import "./chunk-X672ZN7V.js";
-import "./chunk-BJMASMKX.js";
+} from "./chunk-3H3TL34J.js";
+import "./chunk-XXFVWP6H.js";
+import "./chunk-IMOEZ4NJ.js";
 import "./chunk-JXMVZEQ7.js";
-import "./chunk-HSR3GXCL.js";
-import "./chunk-MKDMAAMN.js";
-import "./chunk-2MIISF2W.js";
+import "./chunk-NR4Y54OL.js";
 import "./chunk-CH32ELFX.js";
 import "./chunk-BLEGIR35.js";
+import "./chunk-CM3EKMDD.js";
+import "./chunk-X672ZN7V.js";
+import "./chunk-2OLXXOT3.js";
+import "./chunk-VHKPWUX7.js";
 import "./chunk-YKW54DKF.js";
-import "./chunk-LDZXU3DW.js";
 export {
   listTandemIds,
   startProxy

package/dist/lib.d.ts

@@ -1,6 +1,5 @@
 import { KeyLike, JWK } from 'jose';
-import { L as LoadedKeyPair, K as KeystoreData, G as GatewayClient } from './gateway-client-93P1E0CZ.js';
-export { P as ProxyConfig, T as ToolCallResult } from './gateway-client-93P1E0CZ.js';
+import { L as LoadedKeyPair, K as KeystoreData, G as GatewayClient, M as McpToolDefinition, T as ToolCallResult, P as ProxyConfig } from './gateway-client-C6yx1mfM.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 
 /**
@@ -271,6 +270,19 @@ interface EventStreamOptions {
      * webhook delivery, zero behavior change.
      */
     webhookSink?: WebhookSink;
+    /**
+     * Pluggable per-runtime WAKE DELIVERY (#32 Phase 1). When wired, consumeSse
+     * routes each normalized, wake-filtered TandemEvent through `delivery.deliver`
+     * INSTEAD OF the inline queue→event-log→channel→webhook fan-out below. The
+     * delivery owns the exact same per-sink isolation + ordering; this is purely
+     * WHERE the fan-out lives, not WHAT it does. When UNSET (the kojee-mcp/lib
+     * consumers — the OpenClaw plugin — and the event-stream unit/integration
+     * tests that pass `queue`/`eventLog`/`webhookSink` directly), the historical
+     * inline fan-out runs unchanged. The two paths are behaviorally identical.
+     */
+    delivery?: {
+        deliver(event: TandemEvent): Promise<void>;
+    };
     /**
      * Resubscribe-on-start hook (P0 audit item #2). Called once after each
      * successful (re)connect with the live `Response`. Implementations touch
@@ -426,4 +438,213 @@ interface ResubscribeOptions {
  */
 declare function resubscribeMemberships(opts: ResubscribeOptions): Promise<number>;
 
-export { AuthModule, type EventLog, type EventStreamOptions, GatewayClient, type HarnessAdapter, type PairedConfig, type Runtime, type StreamHandle, type StreamState, type TandemEvent, type WebhookSink, createDPoPProof, defaultPairedKeystorePath, deriveKeystorePath, generateES256KeyPair, loadKeystore, loadPairedConfig, normalizeBackendEvent, pairedConfigPath, resubscribeMemberships, sanitizeDisplayname, saveKeystore, startEventStream };
+interface StableSessionDeps {
+    /**
+     * The Claude Code ancestor PID, when the caller already has it (the daemon).
+     * Pass `null` to SKIP the ancestry read (non-CC contexts, tests) — resolution
+     * then falls to KOJEE_INSTANCE → working-dir hash. Omit to resolve ancestry.
+     */
+    ccPid?: number | null;
+    /**
+     * An explicit instanceKey — bypasses ancestry AND resolveInstanceKey entirely.
+     * Used where the window identity is known out-of-band (an embedder's account
+     * key, tests).
+     */
+    instanceKey?: string;
+}
+/**
+ * §7 — install the STABLE Mcp-Session-Id (D1) for THIS process, the one DRY way
+ * every outbound construction site does it: the daemon (index.ts), the `send`
+ * sub-command, and embedding plugins (OpenClaw). Same (token, instanceKey) →
+ * same id → the backend converges on ONE seat per (credential, window) across
+ * restarts (no phantom seats; reaper retired).
+ *
+ * instanceKey precedence: an explicit `deps.instanceKey` wins; otherwise it's
+ * resolved by {@link resolveInstanceKey} from `deps.ccPid` (or a fresh ancestry
+ * read when `ccPid` is omitted) → CC session id, else KOJEE_INSTANCE, else a
+ * working-dir hash.
+ *
+ * Returns the resolved instanceKey + the installed sessionId so callers that
+ * also need the key (room-memory, discovery) don't resolve it twice.
+ */
+declare function applyStableSessionId(token: string, deps?: StableSessionDeps): Promise<{
+    instanceKey: string;
+    sessionId: string;
+}>;
+
+/**
+ * D1 — the STABLE Mcp-Session-Id: deterministic per (token, instanceKey),
+ * one-way + opaque. Same inputs → same id across proxy restarts, so the backend
+ * resolves the SAME Session + seat (no phantom seats, reaper retired). Computed
+ * at proxy startup where the gateway token + instanceKey (resolveInstanceKey)
+ * are known, in place of the random ulid() above.
+ */
+declare function deriveStableSessionId(token: string, instanceKey: string): string;
+
+/**
+ * Flat tool registry — fetches all Kojee tools with full schemas on startup
+ * and registers them directly with the MCP server. No discovery indirection,
+ * no meta-tools, no call_tool wrapper.
+ *
+ * The agent sees each Kojee tool directly (e.g. gmail_send_email, github_list_repos)
+ * and calls it like any native MCP tool. Prompt caching handles the token cost
+ * of ~15K tokens after the first turn.
+ */
+declare class ToolRegistry {
+    private readonly gateway;
+    /** Flat map: tool name → full tool definition */
+    private tools;
+    constructor(gateway: GatewayClient);
+    /**
+     * Fetch all tools with full schemas from the gateway in a single RPC call.
+     */
+    discoverTools(): Promise<void>;
+    /**
+     * Return all registered tools for the MCP ListTools response.
+     */
+    getAllTools(): McpToolDefinition[];
+    /**
+     * Call a tool through the gateway.
+     */
+    callTool(name: string, args: Record<string, unknown>): Promise<ToolCallResult>;
+    /** Total number of registered tools. */
+    get toolCount(): number;
+}
+
+/**
+ * Side-channel hooks observed by the tool-call path (0.5.4 wake continuity).
+ */
+interface ToolCallHooks {
+    /**
+     * Fired after a SUCCESSFUL tandem_join performed through this proxy by its
+     * agent, with the joined tandem id (null if it couldn't be read from args).
+     * The proxy wires this to the debounced stream-reconnect scheduler so the
+     * event-stream's membership snapshot picks up the just-acquired seat without
+     * a daemon restart, AND (#28) records the room in this instance's local
+     * room-memory for session-faithful re-seat. A throwing hook never breaks the
+     * tool reply.
+     */
+    onTandemJoin?: (tandemId: string | null) => void;
+    /**
+     * Fired after a SUCCESSFUL tandem_leave through this proxy, with the left
+     * tandem id (#28). The proxy drops the room from this instance's local
+     * room-memory so a restart doesn't rejoin a room the agent deliberately
+     * left. A throwing hook never breaks the tool reply.
+     */
+    onTandemLeave?: (tandemId: string | null) => void;
+}
+
+/**
+ * The pluggable per-runtime WAKE-DELIVERY interface (#32 Phase 1).
+ *
+ * Historically the dispatch of a normalized TandemEvent to its wake sinks lived
+ * in two places: the THREE-WAY branch in `startProxy` (src/index.ts) that wired
+ * the event-log / webhook / hook-server / discovery surfaces per runtime, and
+ * the inline fan-out in `consumeSse` (src/tandem/event-stream.ts) that, per
+ * event, appended to the event log (Monitor wake), emitted a channel
+ * notification (claude-code only), and enqueued the webhook POST.
+ *
+ * Phase 1 extracts that into one interface so each runtime owns its own wake
+ * delivery as a composable unit, selected from a registry instead of an
+ * if/else-if/else ladder. The extraction is BEHAVIOR-PRESERVING: each runtime's
+ * `start`/`deliver`/`stop` replicate exactly what its branch did before.
+ *
+ *   - start(ctx)     — build + start this runtime's sinks/surfaces and the SSE
+ *                      stream. Returns the wired MCP `server` (so the proxy can
+ *                      drive the stdio transport) plus a stop handle.
+ *   - deliver(event) — the per-event fan-out, formerly inlined in consumeSse
+ *                      (event-stream.ts:594-642). MUST preserve per-sink
+ *                      isolation + ordering: event-log append (primary Monitor
+ *                      wake) FIRST, channel notification SECOND (claude-code
+ *                      only), webhook enqueue LAST + fire-and-forget. Each sink
+ *                      is wrapped in its own try/catch so one failing sink can
+ *                      never starve another.
+ *   - stop()         — idempotent teardown (webhook sink stop, discovery
+ *                      cleanup, event-log cleanup, hook-server stop).
+ *   - health()       — optional liveness snapshot for GET /status + doctor.
+ */
+
+/**
+ * Everything a {@link WakeDelivery.start} needs from the proxy to build its
+ * sinks/surfaces and wire the SSE stream. Assembled once in `startProxy` after
+ * auth + ensure-join, before the stream connects.
+ */
+interface WakeDeliveryContext {
+    /**
+     * This instance's stable key (#28): the CC session_id when readable, else
+     * KOJEE_INSTANCE / a working-dir hash. Used to derive the per-runtime
+     * event-log filename and other per-session artifacts.
+     */
+    instanceKey: string;
+    /** The detected runtime label (drives capability + which delivery is built). */
+    runtime: Runtime;
+    /** The selected harness adapter (channel capability + formatTandemEvent). */
+    adapter: HarnessAdapter;
+    /** Directory the event log lives in (defaults to os.tmpdir()). */
+    eventLogDir?: string;
+    /** Resolved proxy config (broker url + token + auth mode). */
+    config: ProxyConfig;
+    /** The discovered tool registry (used to build the MCP server). */
+    registry: ToolRegistry;
+    /** The authenticated gateway JSON-RPC client. */
+    gateway: GatewayClient;
+    /** The Claude Code ancestor pid, or null if none was found. */
+    ccPid: number | null;
+    /** Boot-probed membership count for the handshake instructions (-1 = unknown). */
+    tandemMembershipCount: number;
+    /** tandem_id lister for the resubscribe-on-connect touch. */
+    listTandemIds: () => Promise<string[] | null>;
+    /** join/leave side-channel hooks (stream reconnect + room-memory record). */
+    toolCallHooks: ToolCallHooks;
+    /** Called once the stream handle is armed, to flush a boot-race reconnect. */
+    onStreamReady?: (handle: StreamLike) => void;
+    /** Best-effort line sink for boot/observability logs (status sibling backed). */
+    log: (line: string) => void;
+}
+/** The subset of the SSE stream handle the proxy + scheduler depend on. */
+interface StreamLike {
+    (): void;
+    reconnect: () => void;
+    getState: () => unknown;
+}
+/** Optional liveness snapshot surfaced via GET /status + doctor. */
+interface DeliveryHealth {
+    /** Whether the SSE stream is currently connected (null = no stream). */
+    connected: boolean | null;
+    /** Implementation-specific extra state (stream state, hook-server, etc.). */
+    detail?: Record<string, unknown>;
+}
+/** The result of {@link WakeDelivery.start}: the wired server + teardown. */
+interface StartedDelivery {
+    /** The MCP server to drive over stdio. */
+    server: Server;
+    /** Synchronous teardown steps to register with the shutdown coordinator. */
+    teardown: Array<() => void | Promise<void>>;
+    /** Last-ditch synchronous cleanup for process 'exit' (cannot await). */
+    exitCleanup?: () => void;
+}
+/**
+ * A per-runtime wake-delivery unit. Built from the registry, started once, and
+ * driven per-event by consumeSse via {@link WakeDelivery.deliver}.
+ */
+interface WakeDelivery {
+    /** Stable identifier (the runtime label + variant, e.g. "claude-code"). */
+    readonly name: string;
+    /**
+     * Build + start this delivery's sinks/surfaces and the SSE stream. The stream
+     * is wired so consumeSse calls back into {@link WakeDelivery.deliver}.
+     */
+    start(ctx: WakeDeliveryContext): Promise<StartedDelivery>;
+    /**
+     * Per-event fan-out (the seam formerly inlined in consumeSse). Called for
+     * every normalized, wake-filtered TandemEvent. MUST preserve per-sink
+     * isolation + ordering and never throw.
+     */
+    deliver(event: TandemEvent): Promise<void>;
+    /** Idempotent teardown. */
+    stop(): Promise<void>;
+    /** Optional liveness snapshot. */
+    health?(): DeliveryHealth;
+}
+
+export { AuthModule, type DeliveryHealth, type EventLog, type EventStreamOptions, GatewayClient, type HarnessAdapter, type PairedConfig, ProxyConfig, type Runtime, type StableSessionDeps, type StartedDelivery, type StreamHandle, type StreamLike, type StreamState, type TandemEvent, ToolCallResult, type WakeDelivery, type WakeDeliveryContext, type WebhookSink, applyStableSessionId, createDPoPProof, defaultPairedKeystorePath, deriveKeystorePath, deriveStableSessionId, generateES256KeyPair, loadKeystore, loadPairedConfig, normalizeBackendEvent, pairedConfigPath, resubscribeMemberships, sanitizeDisplayname, saveKeystore, startEventStream };

package/dist/lib.js

@@ -1,24 +1,26 @@
 import {
   resubscribeMemberships
 } from "./chunk-OT2GILXC.js";
+import {
+  normalizeBackendEvent,
+  sanitizeDisplayname,
+  startEventStream
+} from "./chunk-74XFVX6Z.js";
 import {
   loadPairedConfig,
   pairedConfigPath
 } from "./chunk-YH27B6SW.js";
+import {
+  GatewayClient,
+  applyStableSessionId
+} from "./chunk-IMOEZ4NJ.js";
 import {
   AuthModule
 } from "./chunk-JXMVZEQ7.js";
 import {
-  GatewayClient
-} from "./chunk-HSR3GXCL.js";
-import {
-  normalizeBackendEvent,
-  sanitizeDisplayname,
-  startEventStream
-} from "./chunk-MKDMAAMN.js";
-import {
-  createDPoPProof
-} from "./chunk-2MIISF2W.js";
+  createDPoPProof,
+  deriveStableSessionId
+} from "./chunk-NR4Y54OL.js";
 import {
   defaultPairedKeystorePath,
   deriveKeystorePath,
@@ -27,13 +29,16 @@ import {
   saveKeystore
 } from "./chunk-CH32ELFX.js";
 import "./chunk-BLEGIR35.js";
-import "./chunk-LDZXU3DW.js";
+import "./chunk-2OLXXOT3.js";
+import "./chunk-VHKPWUX7.js";
 export {
   AuthModule,
   GatewayClient,
+  applyStableSessionId,
   createDPoPProof,
   defaultPairedKeystorePath,
   deriveKeystorePath,
+  deriveStableSessionId,
   generateES256KeyPair,
   loadKeystore,
   loadPairedConfig,

package/dist/{parent-watchdog-RZLHYP7T.js → parent-watchdog-TLU355FB.js}

@@ -1,6 +1,6 @@
 import {
   findClaudeAncestorPid
-} from "./chunk-BJMASMKX.js";
+} from "./chunk-VHKPWUX7.js";
 
 // src/runtime/parent-watchdog.ts
 function defaultIsPidAlive(pid) {