@someonegg/agent-hub 0.0.0-stage → 0.7.0

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

@@ -0,0 +1,184 @@
+import { createHash, randomUUID } from "node:crypto";
+import { diffLines } from "./terminal-preview-diff.js";
+import { createTmuxPreviewListener, } from "./tmux-preview-listener.js";
+export class TerminalPreviewService {
+    capture;
+    listen;
+    #states = new Map();
+    #identity = randomUUID();
+    #closed = false;
+    constructor(capture, listen = createTmuxPreviewListener()) {
+        this.capture = capture;
+        this.listen = listen;
+    }
+    async captureFresh(binding, assertOwner) {
+        assertOwner();
+        const result = await this.capture(binding, assertOwner);
+        assertOwner();
+        return { ...result, capturedAt: new Date().toISOString() };
+    }
+    subscribe(binding, assertOwner, frame, fail, signal) {
+        if (this.#closed || signal.aborted)
+            throw new DOMException("Aborted", "AbortError");
+        const key = JSON.stringify([binding.socketPath, binding.sessionName]);
+        let state = this.#states.get(key);
+        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, () => {
+                    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 () => {
+            const result = await this.captureFresh(state.binding, () => this.#assertOwner(state));
+            const previous = state.snapshot;
+            if (previous &&
+                previous.content === result.content &&
+                previous.truncated === result.truncated)
+                return;
+            const snapshot = {
+                ...result,
+                capturedAt: result.capturedAt,
+                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,84 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { SessionLaunchError } from "../management/session-manager.js";
+import { TmuxInteractionService } from "./tmux-service.js";
+import { tmuxTarget, validTmuxSessionName } from "./tmux-target.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(tmuxTarget(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 sessionName = `ahub-${id}`;
+        if (!validTmuxSessionName(sessionName))
+            throw new SessionLaunchError("not_started", "Invalid tmux session name", null);
+        const fallbackAttach = attachCommand(this.socketPath, sessionName);
+        let stdout;
+        try {
+            ({ stdout } = await execute("tmux", [
+                ...(this.socketPath ? ["-S", this.socketPath] : []),
+                "new-session",
+                "-d",
+                "-P",
+                "-F",
+                "#{socket_path}",
+                "-s",
+                sessionName,
+                "-e",
+                `AHUB_TMUX_SESSION_NAME=${sessionName}`,
+                "-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 socketPath = stdout.replace(/\n$/, "");
+        if (!socketPath.startsWith("/") || socketPath.includes("\n")) {
+            throw new SessionLaunchError("unknown", "Invalid launched tmux target", fallbackAttach);
+        }
+        const target = { socketPath, sessionName };
+        try {
+            await execute("tmux", [
+                "-S",
+                socketPath,
+                "set-option",
+                "-p",
+                "-t",
+                tmuxTarget(sessionName),
+                "remain-on-exit",
+                "off",
+            ], { timeout: 5_000 });
+            return target;
+        }
+        catch (error) {
+            throw new SessionLaunchError("unknown", error instanceof Error ? error.message : String(error), attachCommand(socketPath, sessionName), target);
+        }
+    }
+}
+//# sourceMappingURL=tmux-launcher.js.map

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

@@ -0,0 +1,107 @@
+import { spawn } from "node:child_process";
+import { lstatSync } from "node:fs";
+import { ownedSocket, tmuxTarget, validTmuxSessionName } from "./tmux-target.js";
+/** One control client per socket/session; protocol payload is never interpreted as commands. */
+export function createTmuxPreviewListener() {
+    const connections = new Map();
+    return (binding, change, fail) => {
+        if (!binding.socketPath.startsWith("/") || !validTmuxSessionName(binding.sessionName))
+            throw new Error("Invalid tmux binding");
+        const key = JSON.stringify([binding.socketPath, binding.sessionName]);
+        let connection = connections.get(key);
+        if (!connection) {
+            if (!ownedSocket(lstatSync(binding.socketPath)))
+                throw new Error("Unsafe tmux socket");
+            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",
+                tmuxTarget(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) /.test(line);
+                    if (output)
+                        for (const subscriber of subscribers)
+                            subscriber.change(true);
+                    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(false);
+                }
+                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