@someonegg/codex-hub 0.0.0-stage → 0.1.0

package/dist/server/server/interaction/session-runtime.js

@@ -0,0 +1,86 @@
+import { resolveResumeDirectory, } from "../management/session-manager.js";
+import { paneBindings } from "./pane-binding-manager.js";
+/** Shared, bounded observations. Errors never prove that a pane exited. */
+export class SessionRuntime {
+    transport;
+    managers;
+    bindings;
+    #pending = new Map();
+    #waiting = [];
+    #activeSockets = new Map();
+    constructor(transport, managers, bindings = paneBindings) {
+        this.transport = transport;
+        this.managers = managers;
+        this.bindings = bindings;
+    }
+    probe(attempt) {
+        if (!attempt.valid)
+            return Promise.reject(new Error("Invalid binding"));
+        const key = JSON.stringify([attempt.socketPath, attempt.paneId]);
+        const existing = this.#pending.get(key);
+        if (existing)
+            return existing;
+        const query = (async () => {
+            // Different panes on one socket must reach the transport together so they
+            // can share one list-panes query, even when there are more than eight panes.
+            while (!this.#activeSockets.has(attempt.socketPath) && this.#activeSockets.size >= 8)
+                await new Promise((resolve) => this.#waiting.push(resolve));
+            this.#activeSockets.set(attempt.socketPath, (this.#activeSockets.get(attempt.socketPath) ?? 0) + 1);
+            try {
+                return await this.transport.resolveTarget(attempt);
+            }
+            finally {
+                const remaining = this.#activeSockets.get(attempt.socketPath) - 1;
+                if (remaining > 0)
+                    this.#activeSockets.set(attempt.socketPath, remaining);
+                else {
+                    this.#activeSockets.delete(attempt.socketPath);
+                    this.#waiting.splice(0).forEach((resume) => resume());
+                }
+            }
+        })();
+        this.#pending.set(key, query);
+        void query.then(() => this.#pending.delete(key), () => this.#pending.delete(key));
+        return query;
+    }
+    async evaluate(session, sessions, detail = true) {
+        let status = session.archived ? "archived" : "normal";
+        const deny = (reason) => ({ status, resume: { allowed: false, reason } });
+        if (session.archived)
+            return deny("Archived sessions cannot be resumed");
+        const attempt = this.bindings.latest(session.id);
+        if (!attempt)
+            return deny("No pane binding has been recorded");
+        if (!attempt.valid)
+            return deny("The latest pane binding is invalid");
+        const replacement = this.bindings.replacement(session.id);
+        try {
+            const target = await this.probe(attempt);
+            if (attempt !== this.bindings.latest(session.id) ||
+                replacement !== this.bindings.replacement(session.id))
+                return deny("Pane binding changed during validation");
+            if (target && replacement === null)
+                status = "live";
+            if (!detail)
+                return deny("Resume validation required");
+            if (status === "live")
+                return deny("Session is already live");
+            if (!session.sourceId ||
+                !/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(session.sourceId))
+                return deny("Session has no valid native identity");
+            if (sessions.filter((item) => item.origin.sourceInstanceId === session.origin.sourceInstanceId &&
+                item.sourceId === session.sourceId).length !== 1)
+                return deny("Native session identity is ambiguous");
+            await resolveResumeDirectory(this.managers.get(session.origin.sourceInstanceId), session);
+            if (attempt !== this.bindings.latest(session.id) ||
+                replacement !== this.bindings.replacement(session.id))
+                return deny("Pane binding changed during validation");
+            return { status, resume: { allowed: true, reason: null } };
+        }
+        catch {
+            status = "normal";
+            return deny("Runtime or working directory validation failed");
+        }
+    }
+}
+//# sourceMappingURL=session-runtime.js.map

package/dist/server/server/interaction/terminal-preview-diff.js

@@ -0,0 +1,71 @@
+/** Bounded Myers search. Trace stores only frontiers, never historical snapshots. */
+export function diffLines(before, after) {
+    const a = before.split("\n");
+    const b = after.split("\n");
+    let work = 0;
+    let frontier = new Map([[1, 0]]);
+    const trace = [];
+    for (let d = 0; d <= 256; d++) {
+        trace.push(frontier);
+        const next = new Map();
+        for (let k = -d; k <= d; k += 2) {
+            if (++work > 1_000_000)
+                return null;
+            let x = k === -d || (k !== d && (frontier.get(k - 1) ?? -1) < (frontier.get(k + 1) ?? -1))
+                ? (frontier.get(k + 1) ?? 0)
+                : (frontier.get(k - 1) ?? 0) + 1;
+            let y = x - k;
+            while (x < a.length && y < b.length) {
+                if (++work > 1_000_000)
+                    return null;
+                if (a[x] !== b[y])
+                    break;
+                x++;
+                y++;
+            }
+            next.set(k, x);
+            if (x >= a.length && y >= b.length) {
+                const edits = [];
+                for (let depth = d; depth > 0; depth--) {
+                    const previous = trace[depth];
+                    const diagonal = x - y;
+                    const pk = diagonal === -depth ||
+                        (diagonal !== depth &&
+                            (previous.get(diagonal - 1) ?? -1) < (previous.get(diagonal + 1) ?? -1))
+                        ? diagonal + 1
+                        : diagonal - 1;
+                    const px = previous.get(pk);
+                    const py = px - pk;
+                    while (x > px && y > py) {
+                        x--;
+                        y--;
+                    }
+                    if (x === px) {
+                        y--;
+                        edits.push({ x, line: b[y] });
+                    }
+                    else {
+                        x--;
+                        edits.push({ x });
+                    }
+                }
+                const operations = [];
+                for (const edit of edits.reverse()) {
+                    let op = operations.at(-1);
+                    if (!op || edit.x !== op.startLine + op.deleteCount) {
+                        op = { startLine: edit.x, deleteCount: 0, lines: [] };
+                        operations.push(op);
+                    }
+                    if (edit.line === undefined)
+                        op.deleteCount++;
+                    else
+                        op.lines.push(edit.line);
+                }
+                return operations.reverse();
+            }
+        }
+        frontier = next;
+    }
+    return null;
+}
+//# sourceMappingURL=terminal-preview-diff.js.map

package/dist/server/server/interaction/terminal-preview-service.js

@@ -0,0 +1,194 @@
+import { createHash, randomUUID } from "node:crypto";
+import { diffLines } from "./terminal-preview-diff.js";
+import { createTmuxPreviewListener, } from "./tmux-preview-listener.js";
+import { InteractionTransportError } from "./transport.js";
+export class TerminalPreviewService {
+    capture;
+    listen;
+    resolveTarget;
+    #states = new Map();
+    #identity = randomUUID();
+    #closed = false;
+    constructor(capture, listen = createTmuxPreviewListener(), resolveTarget) {
+        this.capture = capture;
+        this.listen = listen;
+        this.resolveTarget = resolveTarget;
+    }
+    subscribe(session, binding, assertOwner, frame, fail, signal) {
+        if (this.#closed || signal.aborted)
+            throw new DOMException("Aborted", "AbortError");
+        const key = JSON.stringify([session, binding.socketPath, binding.paneId]);
+        let state = this.#states.get(key);
+        if (state && state.binding.sessionName !== binding.sessionName) {
+            this.#fail(state, new InteractionTransportError("disconnected", "The pane's tmux session changed"));
+            state = undefined;
+        }
+        const fresh = !state;
+        if (!state) {
+            state = { key, binding, viewers: new Set(), dirty: true, listening: false, disposed: false };
+            this.#states.set(key, state);
+        }
+        const current = state;
+        const close = () => {
+            signal.removeEventListener("abort", close);
+            current.viewers.delete(viewer);
+            if (!current.viewers.size)
+                this.#dispose(current);
+        };
+        const viewer = { assertOwner, frame, fail, close, initialized: false };
+        current.viewers.add(viewer);
+        signal.addEventListener("abort", close, { once: true });
+        try {
+            assertOwner();
+            if (fresh) {
+                current.subscription = this.listen(binding, (pane) => {
+                    if (!pane || pane === binding.paneId) {
+                        current.dirty = true;
+                        this.#schedule(current);
+                    }
+                }, (error) => this.#fail(current, error));
+                // A listener may fail synchronously during setup.
+                if (current.disposed)
+                    current.subscription.close();
+            }
+            void current
+                .subscription.ready.then(async () => {
+                if (current.disposed || !current.viewers.has(viewer))
+                    return;
+                current.listening = true;
+                if (!current.snapshot)
+                    await this.#capture(current);
+                if (current.disposed || !current.viewers.has(viewer))
+                    return;
+                assertOwner();
+                if (!viewer.initialized) {
+                    viewer.initialized = true;
+                    frame({ type: "snapshot", ...current.snapshot });
+                }
+            })
+                .catch((error) => this.#fail(current, error));
+        }
+        catch (error) {
+            this.#fail(current, error);
+        }
+        return close;
+    }
+    invalidate() {
+        for (const state of this.#states.values()) {
+            try {
+                this.#assertOwner(state);
+            }
+            catch (error) {
+                this.#fail(state, error);
+            }
+        }
+    }
+    close() {
+        this.#closed = true;
+        for (const state of this.#states.values())
+            this.#fail(state, new DOMException("Aborted", "AbortError"));
+    }
+    #assertOwner(state) {
+        if (state.disposed)
+            throw new DOMException("Aborted", "AbortError");
+        for (const viewer of state.viewers)
+            viewer.assertOwner();
+    }
+    #schedule(state) {
+        if (!state.listening || state.disposed || state.task || state.timer)
+            return;
+        state.timer = setTimeout(() => {
+            state.timer = undefined;
+            void this.#capture(state).catch(() => { });
+        }, 350);
+    }
+    #capture(state) {
+        if (state.task)
+            return state.task;
+        clearTimeout(state.timer);
+        state.timer = undefined;
+        state.dirty = false;
+        state.task = (async () => {
+            if (this.resolveTarget) {
+                const current = await this.resolveTarget(state.binding);
+                if (!current || current.sessionName !== state.binding.sessionName)
+                    throw new InteractionTransportError("disconnected", "The pane no longer exists in its tmux session");
+            }
+            this.#assertOwner(state);
+            const result = await this.capture(state.binding, () => this.#assertOwner(state));
+            this.#assertOwner(state);
+            const previous = state.snapshot;
+            if (previous &&
+                previous.content === result.content &&
+                previous.truncated === result.truncated)
+                return;
+            const snapshot = {
+                ...result,
+                capturedAt: new Date().toISOString(),
+                revision: createHash("sha256")
+                    .update(JSON.stringify([this.#identity, state.key, result.content, result.truncated]))
+                    .digest("base64url"),
+            };
+            state.snapshot = snapshot;
+            const full = { type: "snapshot", ...snapshot };
+            let update = full;
+            if (previous) {
+                const operations = diffLines(previous.content, snapshot.content);
+                if (operations !== null) {
+                    const delta = {
+                        type: "delta",
+                        baseRevision: previous.revision,
+                        revision: snapshot.revision,
+                        operations,
+                        truncated: snapshot.truncated,
+                        capturedAt: snapshot.capturedAt,
+                    };
+                    const size = bytes(delta);
+                    if (size <= 8192 && size < bytes(full))
+                        update = delta;
+                }
+            }
+            for (const viewer of [...state.viewers]) {
+                if (!state.viewers.has(viewer))
+                    continue;
+                viewer.assertOwner();
+                const message = viewer.initialized ? update : full;
+                viewer.initialized = true;
+                viewer.frame(message);
+            }
+        })()
+            .catch((error) => {
+            this.#fail(state, error);
+            throw error;
+        })
+            .finally(() => {
+            state.task = undefined;
+            if (state.dirty)
+                this.#schedule(state);
+        });
+        return state.task;
+    }
+    #fail(state, error) {
+        if (state.disposed)
+            return;
+        const viewers = [...state.viewers];
+        this.#dispose(state);
+        for (const viewer of viewers) {
+            viewer.close();
+            viewer.fail(error);
+        }
+    }
+    #dispose(state) {
+        if (state.disposed)
+            return;
+        state.disposed = true;
+        clearTimeout(state.timer);
+        state.subscription?.close();
+        if (this.#states.get(state.key) === state)
+            this.#states.delete(state.key);
+    }
+}
+function bytes(value) {
+    return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+//# sourceMappingURL=terminal-preview-service.js.map

package/dist/server/server/interaction/tmux-launcher.js

@@ -0,0 +1,75 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { SessionLaunchError } from "../management/session-manager.js";
+import { TmuxInteractionService } from "./tmux-service.js";
+const execute = promisify(execFile);
+export function shellQuote(value) {
+    return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+export function attachCommand(socket, session) {
+    return [
+        "tmux",
+        ...(socket ? ["-S", shellQuote(socket)] : []),
+        "attach-session",
+        "-t",
+        shellQuote(session),
+    ].join(" ");
+}
+/** Launch argv directly; user values are never interpreted by a shell. */
+export class TmuxLauncher {
+    socketPath;
+    transport = new TmuxInteractionService();
+    constructor(socketPath) {
+        this.socketPath = socketPath;
+    }
+    async launch(id, directory, command) {
+        const fallbackAttach = attachCommand(this.socketPath, `codex-hub-${id}`);
+        let stdout;
+        try {
+            ({ stdout } = await execute("tmux", [
+                ...(this.socketPath ? ["-S", this.socketPath] : []),
+                "new-session",
+                "-d",
+                "-P",
+                "-F",
+                "#{socket_path}|#{pane_id}",
+                "-s",
+                `codex-hub-${id}`,
+                "-x",
+                "120",
+                "-y",
+                "40",
+                "-c",
+                directory,
+                ...command,
+            ], { timeout: 5_000 }));
+        }
+        catch (error) {
+            const uncertain = !!error &&
+                typeof error === "object" &&
+                (("killed" in error && error.killed) ||
+                    ("code" in error && error.code === "timeout") ||
+                    ("signal" in error && error.signal != null));
+            throw new SessionLaunchError(uncertain ? "unknown" : "not_started", error instanceof Error ? error.message : String(error), uncertain ? fallbackAttach : null);
+        }
+        const output = stdout.trimEnd();
+        const separator = output.lastIndexOf("|");
+        const socketPath = output.slice(0, separator);
+        const paneId = output.slice(separator + 1);
+        if (separator < 1 ||
+            !socketPath.startsWith("/") ||
+            socketPath.includes("\n") ||
+            !/^%\d+$/.test(paneId)) {
+            throw new SessionLaunchError("unknown", "Invalid launched tmux target", fallbackAttach);
+        }
+        const target = { socketPath, paneId };
+        try {
+            await execute("tmux", ["-S", socketPath, "set-option", "-p", "-t", paneId, "remain-on-exit", "off"], { timeout: 5_000 });
+            return await this.transport.connect({ valid: true, ordinal: 0, ...target });
+        }
+        catch (error) {
+            throw new SessionLaunchError("unknown", error instanceof Error ? error.message : String(error), attachCommand(socketPath, `codex-hub-${id}`), target);
+        }
+    }
+}
+//# sourceMappingURL=tmux-launcher.js.map

package/dist/server/server/interaction/tmux-preview-listener.js

@@ -0,0 +1,101 @@
+import { spawn } from "node:child_process";
+/** One control client per socket/session; protocol payload is never interpreted as commands. */
+export function createTmuxPreviewListener() {
+    const connections = new Map();
+    return (binding, change, fail) => {
+        const key = JSON.stringify([binding.socketPath, binding.sessionName]);
+        let connection = connections.get(key);
+        if (!connection) {
+            const child = spawn("tmux", [
+                "-S",
+                binding.socketPath,
+                "-C",
+                "attach-session",
+                "-f",
+                // tmux may use this client as the context for separate send commands.
+                // Marking it read-only also prevents those commands from writing.
+                "ignore-size",
+                "-E",
+                "-t",
+                `=${binding.sessionName}`,
+            ], { stdio: ["pipe", "pipe", "pipe"] });
+            const subscribers = new Set();
+            let buffer = "";
+            let settled = false;
+            let stopped = false;
+            let resolveReady;
+            let rejectReady;
+            const ready = new Promise((resolve, reject) => {
+                resolveReady = resolve;
+                rejectReady = reject;
+            });
+            void ready.catch(() => { });
+            const timer = setTimeout(() => failure(new Error("tmux listener startup timed out")), 5000);
+            function failure(error) {
+                if (stopped)
+                    return;
+                stopped = true;
+                clearTimeout(timer);
+                connections.delete(key);
+                rejectReady(error);
+                child.kill();
+                for (const subscriber of subscribers)
+                    subscriber.fail(error);
+                subscribers.clear();
+            }
+            child.stdout.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                buffer += chunk;
+                let end;
+                while ((end = buffer.indexOf("\n")) >= 0) {
+                    const line = buffer.slice(0, end).replace(/\r$/, "");
+                    buffer = buffer.slice(end + 1);
+                    if (line.startsWith("%end ") && !settled) {
+                        settled = true;
+                        clearTimeout(timer);
+                        resolveReady();
+                    }
+                    if (line.startsWith("%error") || line.startsWith("%exit")) {
+                        failure(new Error("tmux control connection ended"));
+                        return;
+                    }
+                    const output = /^%(?:output|extended-output) (%\d+) /.exec(line);
+                    if (output)
+                        for (const subscriber of subscribers)
+                            subscriber.change(output[1]);
+                    else if (/^%(?:layout-change|window-add|window-close|unlinked-window-close|sessions-changed|session-changed|session-window-changed|window-pane-changed|pane-mode-changed)\b/.test(line))
+                        for (const subscriber of subscribers)
+                            subscriber.change();
+                }
+                if (buffer.length > 2_000_000)
+                    failure(new Error("tmux control line exceeds limit"));
+            });
+            child.stderr.resume();
+            child.on("error", failure);
+            child.stdin.on("error", failure);
+            child.on("close", () => failure(new Error("tmux control connection closed")));
+            connection = {
+                subscribe(change, fail) {
+                    const subscriber = { change, fail };
+                    subscribers.add(subscriber);
+                    return {
+                        ready,
+                        close() {
+                            subscribers.delete(subscriber);
+                            if (!subscribers.size && !stopped) {
+                                stopped = true;
+                                clearTimeout(timer);
+                                rejectReady(new Error("tmux control subscription closed"));
+                                connections.delete(key);
+                                child.kill();
+                            }
+                        },
+                    };
+                },
+            };
+            connections.set(key, connection);
+        }
+        return connection.subscribe(change, fail);
+    };
+}
+//# sourceMappingURL=tmux-preview-listener.js.map