@intentic/sandbox-contract 1.126.0 → 1.133.0

package/src/sse.ts

@@ -0,0 +1,43 @@
+// Low-level SSE framing for the daemon's streamed routes (oRPC eventIterator over HTTP): frames separated by
+// a blank line, each carrying one `data: <JSON>` line. Protocol-only (no domain shapes) — shared by every
+// consumer of the wire: the web's chat/intentic streams and the ACP bridge's daemon client.
+
+// Yields each raw SSE frame (the text between blank-line separators) as it arrives, reassembling frames split
+// across network chunks.
+export async function* sseFrames(body: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (;;) {
+        // oxlint-disable-next-line eslint/no-await-in-loop -- streaming reader; each chunk must be awaited in order as it arrives
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        let separator = buffer.indexOf("\n\n");
+        while (separator !== -1) {
+            yield buffer.slice(0, separator);
+            buffer = buffer.slice(separator + 2);
+            separator = buffer.indexOf("\n\n");
+        }
+    }
+}
+
+// The parsed JSON payload of a frame's `data:` line, or undefined for a frame with no data line, an empty
+// payload, or malformed JSON (all cases the callers skip).
+export const sseData = (frame: string): unknown => {
+    const dataLine = frame.split("\n").find((line) => line.startsWith("data:"));
+    if (dataLine === undefined) {
+        return undefined;
+    }
+    const payload = dataLine.slice(5).trim();
+    if (payload.length === 0) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(payload);
+    } catch {
+        return undefined; // Skip a malformed frame.
+    }
+};

package/src/terminal-protocol.ts

@@ -0,0 +1,16 @@
+// The /system/terminal WebSocket wire protocol — JSON text frames both ways (xterm speaks strings), shared by
+// the daemon's terminal route and the browser's terminal session so the two can't drift. Plain types, not zod
+// schemas: `data` is the per-pty-chunk hot path between two mutually authenticated endpoints, and no oRPC
+// eventIterator validates these frames (which is why events.ts uses schemas).
+
+// `ping` is the client's 30s keepalive against tunnel idle-reaping; the server answers with `pong`, so a
+// healthy idle connection always sees a frame within the ping interval — silence beyond it means half-open.
+export type TerminalClientMessage =
+    | { readonly type: "input"; readonly data: string }
+    | { readonly type: "resize"; readonly cols: number; readonly rows: number }
+    | { readonly type: "ping" };
+
+// `data` is raw pty output; `exit` fires when the tmux client ends (shell exited, or an attach-only session
+// doesn't exist) and is terminal — the client never reconnects after it.
+export type TerminalServerMessage =
+    { readonly type: "data"; readonly data: string } | { readonly type: "exit"; readonly code: number } | { readonly type: "pong" };

package/src/tunnel-ids.ts

@@ -0,0 +1,19 @@
+import { createHash } from "node:crypto";
+
+// The one sha256-hex digest every stable content/token identity derives from: the tunnel ids below, the
+// platform's token lookup digest, the sandbox's bridge-token hashes and environment-overlay hash, hashline
+// anchors. node:crypto → this subpath is node-only.
+export const sha256Hex = (value: string): string => createHash("sha256").update(value).digest("hex");
+
+// The sandbox's stable 12-hex id, digested from the connect token. Used by:
+//   • the CLI's sandbox-tunnel bootstrap (sandbox-tunnel.ts) to name the tunnel + DNS
+//   • the sandbox daemon's preview hostname builder (preview-hostname.ts)
+//   • the sandbox daemon's sync SSH hostname derivation (sync.ts)
+// All three MUST agree on the digest, so it lives in the contract they share.
+export const sandboxIdFromToken = (connectToken: string): string | undefined =>
+    connectToken === "" ? undefined : sha256Hex(connectToken).slice(0, 12);
+
+// A per-host SSH tunnel's stable 12-hex id, salted with the host name so each enrolled deploy target gets its
+// own ssh-<id>.<zone> (no collision across hosts). Shared by the CLI (createHostSshTunnel) and the platform API
+// (provisionHostSshTunnel), which MUST derive the identical id.
+export const hostSshIdFromToken = (connectToken: string, hostName: string): string => sha256Hex(`${connectToken}:${hostName}`).slice(0, 12);