bedrock-agentcore 0.2.4 → 0.3.0

package/dist/src/runtime/shell/protocol.js

@@ -0,0 +1,99 @@
+/*
+ * Binary channel-prefix framer for InvokeAgentRuntimeCommandShell.
+ *
+ * Wire format (identical to Kubernetes v5.channel.k8s.io):
+ *   [1-byte channel ID][payload bytes]
+ *
+ * Channels:
+ *   0x00  STDIN      Raw bytes, client → shell
+ *   0x01  STDOUT     Raw bytes, shell → client
+ *   0x02  STDERR     UTF-8 text (platform diagnostics), shell → client
+ *   0x03  STATUS     metav1.Status JSON (shell → client):
+ *                      Connection confirmation: metadata.shellId present
+ *                      {"kind":"Status","apiVersion":"v1",
+ *                       "metadata":{"shellId":"…","reconnected":bool},"status":"Success"}
+ *                      Shell exit (code 0):
+ *                      {"kind":"Status","apiVersion":"v1","metadata":{},"status":"Success"}
+ *                      Shell exit (non-zero):
+ *                      {"kind":"Status","apiVersion":"v1","metadata":{},"status":"Failure",
+ *                       "reason":"NonZeroExitCode","details":{"causes":[{"reason":"ExitCode","message":"N"}]}}
+ *   0x04  RESIZE     JSON {"width":N,"height":N}, client → shell
+ *   0x05  HEARTBEAT  Empty payload, bidirectional keepalive
+ *   0xFF  CLOSE      Empty payload. Client → server: explicit session kill (SIGHUP → SIGKILL).
+ *                    Server echoes [0xFF] back, kills the shell, closes WebSocket with code 1000.
+ *                    Unlike disconnect (which detaches), 0xFF is permanent — no reconnection possible.
+ */
+import { Buffer } from 'buffer';
+/** Wire channel identifiers for the binary channel-prefix protocol. */
+export var ShellChannel;
+(function (ShellChannel) {
+    ShellChannel[ShellChannel["STDIN"] = 0] = "STDIN";
+    ShellChannel[ShellChannel["STDOUT"] = 1] = "STDOUT";
+    ShellChannel[ShellChannel["STDERR"] = 2] = "STDERR";
+    ShellChannel[ShellChannel["STATUS"] = 3] = "STATUS";
+    ShellChannel[ShellChannel["RESIZE"] = 4] = "RESIZE";
+    ShellChannel[ShellChannel["HEARTBEAT"] = 5] = "HEARTBEAT";
+    ShellChannel[ShellChannel["CLOSE"] = 255] = "CLOSE";
+    /** Sentinel for unrecognised channel bytes — not a wire value. */
+    ShellChannel[ShellChannel["UNKNOWN"] = -1] = "UNKNOWN";
+})(ShellChannel || (ShellChannel = {}));
+// Pre-built set of known wire channel bytes (excludes UNKNOWN sentinel).
+const KNOWN_CHANNEL_BYTES = new Set(Object.values(ShellChannel).filter((v) => typeof v === 'number' && v !== ShellChannel.UNKNOWN));
+/** Maximum frame size — matches DP WebSocketFlowController limit. */
+export const MAX_FRAME_SIZE = 64 * 1024;
+function makeFrame(channel, rawChannelByte, payload) {
+    return {
+        channel,
+        rawChannelByte,
+        payload,
+        get text() {
+            return payload.toString('utf8');
+        },
+        json() {
+            return JSON.parse(payload.toString('utf8'));
+        },
+    };
+}
+/**
+ * Encodes and decodes binary channel-prefix WebSocket frames.
+ * Stateless — a single instance is safe to reuse across frames.
+ */
+export class ShellFramer {
+    /** Decode one raw WebSocket binary message into a ShellFrame. */
+    decode(frame) {
+        if (frame.length === 0) {
+            throw new Error('Cannot decode empty frame');
+        }
+        const rawByte = frame[0];
+        const channel = KNOWN_CHANNEL_BYTES.has(rawByte) ? rawByte : ShellChannel.UNKNOWN;
+        return makeFrame(channel, rawByte, frame.slice(1));
+    }
+    /** Encode keyboard input or paste data as a STDIN frame. */
+    encodeStdin(data) {
+        const bytes = typeof data === 'string' ? Buffer.from(data, 'utf8') : data;
+        if (bytes.length > MAX_FRAME_SIZE - 1) {
+            throw new Error(`Payload ${bytes.length} bytes exceeds the 64 KB frame limit. Split large pastes into multiple encodeStdin() calls.`);
+        }
+        return Buffer.concat([Buffer.from([ShellChannel.STDIN]), bytes]);
+    }
+    /** Encode a terminal resize event as a RESIZE frame. */
+    encodeResize(width, height) {
+        if (!Number.isInteger(width) || !Number.isInteger(height)) {
+            throw new Error(`width and height must be integers, got ${typeof width} and ${typeof height}`);
+        }
+        if (width <= 0 || height <= 0) {
+            throw new Error(`width and height must be positive integers, got width=${width}, height=${height}`);
+        }
+        const payload = Buffer.from(JSON.stringify({ width, height }), 'utf8');
+        return Buffer.concat([Buffer.from([ShellChannel.RESIZE]), payload]);
+    }
+    /** Encode an app-level heartbeat frame (channel 0x05, empty payload). */
+    encodeHeartbeat() {
+        return Buffer.from([ShellChannel.HEARTBEAT]);
+    }
+    /** Encode a graceful-shutdown CLOSE frame (empty payload). */
+    encodeClose() {
+        return Buffer.from([ShellChannel.CLOSE]);
+    }
+}
+//# sourceMappingURL=protocol.js.map

package/dist/src/runtime/shell/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../../../src/runtime/shell/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,uEAAuE;AACvE,MAAM,CAAN,IAAY,YAUX;AAVD,WAAY,YAAY;IACtB,iDAAY,CAAA;IACZ,mDAAa,CAAA;IACb,mDAAa,CAAA;IACb,mDAAa,CAAA;IACb,mDAAa,CAAA;IACb,yDAAgB,CAAA;IAChB,mDAAY,CAAA;IACZ,kEAAkE;IAClE,sDAAY,CAAA;AACd,CAAC,EAVW,YAAY,KAAZ,YAAY,QAUvB;AAED,yEAAyE;AACzE,MAAM,mBAAmB,GAAG,IAAI,GAAG,CACjC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAqB,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,CAClH,CAAA;AAgBD,qEAAqE;AACrE,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,GAAG,IAAI,CAAA;AAEvC,SAAS,SAAS,CAAC,OAAqB,EAAE,cAAsB,EAAE,OAAe;IAC/E,OAAO;QACL,OAAO;QACP,cAAc;QACd,OAAO;QACP,IAAI,IAAI;YACN,OAAO,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;QACjC,CAAC;QACD,IAAI;YACF,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAA4B,CAAA;QACxE,CAAC;KACF,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,OAAO,WAAW;IACtB,iEAAiE;IACjE,MAAM,CAAC,KAAa;QAClB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAA;QAC9C,CAAC;QACD,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAE,CAAA;QACzB,MAAM,OAAO,GAAG,mBAAmB,CAAC,GAAG,CAAC,OAAuB,CAAC,CAAC,CAAC,CAAE,OAAwB,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAA;QACnH,OAAO,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;IACpD,CAAC;IAED,4DAA4D;IAC5D,WAAW,CAAC,IAAqB;QAC/B,MAAM,KAAK,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;QACzE,IAAI,KAAK,CAAC,MAAM,GAAG,cAAc,GAAG,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CACb,WAAW,KAAK,CAAC,MAAM,6FAA6F,CACrH,CAAA;QACH,CAAC;QACD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAA;IAClE,CAAC;IAED,wDAAwD;IACxD,YAAY,CAAC,KAAa,EAAE,MAAc;QACxC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1D,MAAM,IAAI,KAAK,CAAC,0CAA0C,OAAO,KAAK,QAAQ,OAAO,MAAM,EAAE,CAAC,CAAA;QAChG,CAAC;QACD,IAAI,KAAK,IAAI,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,yDAAyD,KAAK,YAAY,MAAM,EAAE,CAAC,CAAA;QACrG,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,CAAA;QACtE,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAA;IACrE,CAAC;IAED,yEAAyE;IACzE,eAAe;QACb,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAA;IAC9C,CAAC;IAED,8DAA8D;IAC9D,WAAW;QACT,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAA;IAC1C,CAAC;CACF"}

package/dist/src/runtime/shell/session.d.ts

@@ -0,0 +1,240 @@
+/**
+ * ShellSession — async-iterable interactive PTY WebSocket session.
+ *
+ * Connects on `connect()`, reads the initial STATUS confirmation frame, and exposes
+ * typed `send()` / `resize()` / `[Symbol.asyncIterator]()` / `close()`.
+ *
+ * When `reconnectConfig` is provided, transparently reconnects on unexpected disconnects
+ * using the same `shellId` so the shell's working directory, environment, background jobs,
+ * and up to 256 KB of buffered output are preserved on the server.
+ *
+ * Reconnect restores the *connection* on its own (it is driven by the socket close event,
+ * not by your read loop, and `send()`/`resize()` wait for it). However, on reattach the
+ * server replays the buffered output as inbound frames — to receive that replay (and to see
+ * `bytesDropped` updated and `exitCode` set) you must be consuming the session with
+ * `for await (const frame of shell)`. A write-only caller that never iterates stays
+ * connected across drops but will not observe the replayed output. Keep a `for await` loop
+ * running for the life of the session.
+ *
+ * @example
+ * ```typescript
+ * const shell = await client.openShell({ runtimeArn })
+ * try {
+ *   await shell.send('cat /etc/os-release\n')
+ *   for await (const frame of shell) {
+ *     if (frame.channel === ShellChannel.STDOUT) process.stdout.write(frame.text)
+ *   }
+ * } finally {
+ *   await shell.close()
+ * }
+ * ```
+ */
+import WebSocket from 'ws';
+import type { ClientOptions } from 'ws';
+import { Buffer } from 'buffer';
+import { type ShellFrame } from './protocol.js';
+import { type Logger, type ReconnectConfig } from './config.js';
+/**
+ * Callback that produces connection params for a new WebSocket.
+ * Receives the current `shellId` and `sessionId` so both can be embedded in the
+ * signed URL/headers. Both values are server-confirmed and may differ from the
+ * values originally passed to `openShell` after the first connection.
+ */
+export type ConnectFn = (shellId: string, sessionId: string) => Promise<{
+    url: string;
+    headers: Record<string, string>;
+    /** WebSocket subprotocols — used by OAuth auth (base64UrlBearerAuthorization). */
+    protocols?: string[];
+}>;
+/** Options for constructing a ShellSession. */
+export interface ShellSessionOptions {
+    connectFn: ConnectFn;
+    shellId?: string | undefined;
+    sessionId?: string | undefined;
+    reconnectConfig?: ReconnectConfig | undefined;
+    /**
+     * Interval in milliseconds between RFC 6455 Ping frames sent to keep the connection
+     * alive through the KARP proxy (~60s idle timeout). Defaults to 30000ms.
+     * Set to 0 to disable keepalive (e.g. when the caller manages pings externally).
+     */
+    keepaliveIntervalMs?: number | undefined;
+    /**
+     * Optional logger for diagnostic output. When omitted, all logging is silent.
+     * Pass `console` to enable, or any object implementing `{ debug, info, warn }`.
+     */
+    logger?: Logger | undefined;
+    /**
+     * Optional WebSocket factory for testing — overrides `new WebSocket(...)`.
+     * @internal
+     */
+    _wsFactory?: ((url: string, protocols?: string[], options?: ClientOptions) => WebSocket) | undefined;
+}
+/**
+ * Async-iterable shell session wrapping a live PTY WebSocket.
+ *
+ * Read-only observable attributes (updated by the session as events arrive):
+ * - `shellId`      — Server-confirmed shell identifier. Preserve to reconnect to the same PTY.
+ * - `sessionId`    — Runtime session ID routing to the VM.
+ * - `reconnected`  — True when the most recent connect reattached an existing PTY.
+ * - `kicked`       — True when another client connected with the same shellId (close 4000).
+ *                    Check this after the `for await` loop exits to distinguish a kick from
+ *                    a clean shell exit.
+ * - `bytesDropped` — PTY ring-buffer bytes lost during the most recent disconnect, as
+ *                    reported by the server in the reconnect confirmation frame.
+ *                    Zero if no overflow occurred or on a fresh connection.
+ * - `exitCode`     — Shell process exit code. `null` until the shell exits; `0` for a clean
+ *                    exit. Check this after the `for await` loop exits alongside `kicked`.
+ */
+export declare class ShellSession implements AsyncIterable<ShellFrame> {
+    private _shellId;
+    private _sessionId;
+    private _reconnected;
+    private _kicked;
+    private _bytesDropped;
+    private _exitCode;
+    /** Server-confirmed shell identifier. */
+    get shellId(): string;
+    /** Runtime session ID routing to the VM. */
+    get sessionId(): string;
+    /** True when the most recent connect reattached an existing PTY. */
+    get reconnected(): boolean;
+    /**
+     * True when another client connected with the same shellId (close 4000).
+     * Check after the `for await` loop exits to distinguish a kick from a clean exit.
+     */
+    get kicked(): boolean;
+    /**
+     * PTY ring-buffer bytes lost during the most recent disconnect.
+     * Zero when no overflow occurred or on a fresh connection.
+     */
+    get bytesDropped(): number;
+    /**
+     * Shell process exit code. `null` until the shell exits; `0` for a clean exit.
+     * Check after the `for await` loop exits alongside `kicked`.
+     */
+    get exitCode(): number | null;
+    private readonly connectFn;
+    private readonly reconnectConfig;
+    private readonly keepaliveIntervalMs;
+    private readonly log;
+    private readonly framer;
+    private readonly _wsFactory;
+    private _state;
+    private _abortController;
+    private readonly _sessionController;
+    private _closeError;
+    /**
+     * Set while a reconnect is in flight, cleared when it settles. Shared so that the
+     * iterator, the close/dead-detection handler, and send()/resize() all await the same
+     * attempt rather than racing or each starting their own. Resolves to the reconnect
+     * outcome (true = recovered, false = gave up). This is what makes *connection* recovery
+     * iterator-independent — the socket is restored without a `for await` loop. Consuming the
+     * replayed output still requires an active iterator (see the class docstring).
+     */
+    private _reconnectPromise;
+    constructor(opts: ShellSessionOptions);
+    /** Connect and read the initial STATUS metadata frame. */
+    connect(): Promise<this>;
+    /**
+     * Send text or raw bytes to the shell's stdin.
+     * Pass a string for text commands; pass a Buffer for binary/escape sequences.
+     *
+     * If a reconnect is in flight, this waits for it and sends on the recovered
+     * connection. Throws a descriptive `Error` (never the raw `ws` "readyState 3"
+     * error) when the session is closed or could not be recovered.
+     */
+    send(data: string | Buffer): Promise<void>;
+    /** Send a HEARTBEAT frame (0x05) to the server. */
+    sendHeartbeat(): Promise<void>;
+    /** Resize the terminal PTY. */
+    resize(width: number, height: number): Promise<void>;
+    /**
+     * Resolve the live socket for a write, healing first if needed. Awaits an in-flight
+     * reconnect (transparent recovery) and validates the *real* socket
+     * readyState — not just the `_state` flag, which can lag a silently-dropped socket.
+     * Throws a descriptive `Error` instead of leaking the raw `ws`
+     * "readyState 3 (CLOSED)" error.
+     */
+    private _writableSocket;
+    /** Send a CLOSE frame (0xFF) to permanently kill the shell, then close the WebSocket.
+     *  The server kills the shell process (SIGHUP → SIGKILL) and responds with its own [0xFF].
+     *  Unlike dropping the WebSocket (which detaches and allows reconnection), this is permanent. */
+    close(): Promise<void>;
+    /**
+     * Forcibly terminates the underlying WebSocket without a clean handshake.
+     * Useful in tests to simulate an abrupt network drop and trigger the reconnect path.
+     * Has no effect if the session is not currently open.
+     * @internal
+     */
+    _terminateConnection(): void;
+    /**
+     * Async iterator — yields inbound ShellFrames, reconnecting on drop if configured.
+     *
+     * The loop exits silently (no throw) in three cases: shell exit, kicked by a new
+     * client, or reconnect budget exhausted. Check `exitCode`, `kicked`, and
+     * `bytesDropped` after the loop to distinguish them:
+     *
+     * ```typescript
+     * for await (const frame of shell) { ... }
+     * if (shell.kicked) { ... }          // another client took over
+     * if (shell.exitCode !== null) { ... } // shell process exited
+     * if (shell.bytesDropped > 0) { ... } // ring-buffer overflow on reconnect
+     * ```
+     */
+    [Symbol.asyncIterator](): AsyncIterator<ShellFrame>;
+    private _startKeepalive;
+    private _stopKeepalive;
+    private _wsSend;
+    /** Open WebSocket, capture 101 upgrade headers, then read metadata frame. */
+    private _connectWithUpgrade;
+    /** Receive one raw binary message from the WebSocket. */
+    private _recvRaw;
+    /**
+     * Consume frames until a STATUS confirmation is found, stashing others in pendingFrames.
+     * Returns the accumulated pending frames to be stored in the 'open' state.
+     */
+    private _readMetadataFrame;
+    private _isConfirmationStatus;
+    /**
+     * Record `bytesDropped` from a reconnection confirmation frame's metadata, if present.
+     * `bytesDropped` reports PTY output lost from ring-buffer overflow during THIS disconnect
+     * (per-disconnect, not session-cumulative — assign, don't accumulate). Present
+     * only when greater than 0; absent on a clean reconnect.
+     */
+    private _recordBytesDropped;
+    private _isTerminationStatus;
+    private _parseExitCode;
+    private _iterate;
+    /** Returns true when close() has been called. Used after await points to guard
+     *  against close() firing while the method was suspended. A method call prevents
+     *  TypeScript from narrowing away 'closed' comparisons after state assignments. */
+    private _isClosed;
+    private _extractCloseCode;
+    /**
+     * Wait for the socket's authoritative 'close' to land after an 'error' woke the read
+     * loop early. The 'close' handler sets `_closeError` (carrying the real close code) and
+     * makes the reconnect decision, so this resolves as soon as `_closeError` is populated.
+     * Bounded by a short timeout in case 'close' never follows (it always does on a
+     * connected `ws`, but we must not hang the iterator on a misbehaving socket).
+     */
+    private _waitForClose;
+    /**
+     * Decide whether a close code is auto-reconnectable, then start-or-join a reconnect.
+     *
+     * This is the single entry point for triggering reconnection. It is called from
+     * wherever a disconnect is observed — the iterator's read error, the `ws.on('close')`
+     * handler (dead-detection / silent drop while no one is iterating), or the keepalive
+     * pong-timeout — so restoring the *connection* no longer depends on an active `for await`
+     * loop. (Receiving the server's replayed output after reattach still requires iterating;
+     * see the class docstring.)
+     *
+     * Returns a promise that resolves to the reconnect outcome (true = recovered).
+     * Returns immediately with `false` for terminal close codes (4000 kicked, 1003 text,
+     * 1000 normal) or when no `reconnectConfig` is set. Concurrent callers share one
+     * in-flight attempt via `_reconnectPromise`.
+     */
+    private _ensureReconnect;
+    private _reconnectWithBackoff;
+    private _runInnerRetryLoop;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/src/runtime/shell/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../src/runtime/shell/session.ts"],"names":[],"mappings":"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"}