@someonegg/agent-hub 0.0.0-stage → 0.7.0

package/dist/server/server/create-hub.js

@@ -0,0 +1,91 @@
+import { createClaudeSessionSource } from "./adapters/claude/claude-session-source.js";
+import { createClaudeSessionManager } from "./adapters/claude/session-manager.js";
+import { createCodexSessionSource } from "./adapters/codex/codex-session-source.js";
+import { createCodexSessionManager } from "./adapters/codex/session-manager.js";
+import { CatalogInteractionSessionReader } from "./application/interaction-session-reader.js";
+import { SessionReadService } from "./application/session-read-service.js";
+import { SessionCatalogService } from "./catalog/session-catalog-service.js";
+import { SessionInteractionService } from "./interaction/interaction-service.js";
+import { PaneBindingManager } from "./interaction/pane-binding-manager.js";
+import { SessionRuntime } from "./interaction/session-runtime.js";
+import { TmuxInteractionService } from "./interaction/tmux-service.js";
+import { OperationService } from "./management/operation-service.js";
+import { managementCapabilities, SessionManagerRegistry, } from "./management/session-manager.js";
+import { CatalogSnapshotStore } from "./repository/catalog-snapshot-store.js";
+import { SessionUpdatesService } from "./updates/session-updates-service.js";
+/** Compose reading and management using the adapter's published Agent nickname. */
+export async function createAhub({ agents, socket, claudeReadyScript, interactionEnabled = true, uploads, }) {
+    const paneBindings = new PaneBindingManager();
+    const adapters = await Promise.all(agents.map((agent) => createAdapter(agent, socket, claudeReadyScript)));
+    const sources = adapters.map((adapter) => adapter.source);
+    const managers = new SessionManagerRegistry(sources[0].descriptor.agent);
+    for (const { source, manager } of adapters)
+        managers.register(source.descriptor.agent, manager);
+    const transport = new TmuxInteractionService();
+    const runtime = new SessionRuntime(transport, managers, paneBindings);
+    const store = new CatalogSnapshotStore(sources, undefined, undefined, {
+        publishBindings: (events) => {
+            for (const event of events)
+                paneBindings.submit(event);
+        },
+    });
+    const interaction = new SessionInteractionService(new CatalogInteractionSessionReader(store), transport, {
+        enabled: interactionEnabled,
+        bindings: paneBindings,
+        runtime,
+    });
+    const sessions = new SessionReadService(sources, {
+        runtime,
+        store,
+        interaction,
+        resolveDisplayTitle: (session) => sources
+            .find((source) => source.descriptor.agent === session.origin.agent)
+            ?.displayTitleFor?.(session) ?? null,
+        agents: sources.map((source) => ({
+            nickname: source.descriptor.agent,
+            runtimeName: source.descriptor.displayName,
+            management: managementCapabilities(managers.get(source.descriptor.agent)),
+        })),
+    });
+    const cleanup = [() => interaction.close()];
+    let closed = false;
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        for (const release of cleanup)
+            release();
+    };
+    try {
+        const catalog = new SessionCatalogService(sessions);
+        cleanup.push(() => catalog.close());
+        const updates = new SessionUpdatesService(sessions);
+        cleanup.push(() => updates.close());
+        const operations = new OperationService(sessions, interaction, managers, {
+            bindings: paneBindings,
+            runtime,
+            uploads,
+        });
+        cleanup.push(() => operations.close());
+        return { sessions, managers, interaction, catalog, updates, operations, close };
+    }
+    catch (error) {
+        close();
+        throw error;
+    }
+}
+async function createAdapter(agent, socket, claudeReadyScript) {
+    switch (agent.adapter ?? "codex") {
+        case "claude":
+            return {
+                source: await createClaudeSessionSource(agent.path, { agent: agent.nickname }),
+                manager: createClaudeSessionManager(agent.path, socket, claudeReadyScript),
+            };
+        case "codex":
+            return {
+                source: await createCodexSessionSource(agent.path, { agent: agent.nickname }),
+                manager: createCodexSessionManager(agent.path, socket),
+            };
+    }
+}
+//# sourceMappingURL=create-hub.js.map

package/dist/server/server/directory-lock.js

@@ -0,0 +1,65 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/** A complete owner directory is atomically installed; stale owners move to permanent tombstones.
+ * Keeping tombstones prevents a second reclaimer from renaming a new owner's lock. */
+export class DirectoryLock {
+    token = randomUUID();
+    attempt;
+    target;
+    held = false;
+    constructor(root, name) {
+        mkdirSync(root, { recursive: true });
+        this.target = join(root, name);
+        this.attempt = join(root, `${name}-attempt-${this.token}`);
+        mkdirSync(this.attempt);
+        writeFileSync(join(this.attempt, "owner.json"), JSON.stringify({ pid: process.pid, token: this.token }));
+    }
+    acquire() {
+        for (;;) {
+            try {
+                renameSync(this.attempt, this.target);
+                this.held = true;
+                return true;
+            }
+            catch (error) {
+                if (!["EEXIST", "ENOTEMPTY"].includes(String(error.code)))
+                    throw error;
+            }
+            let owner;
+            try {
+                owner = JSON.parse(readFileSync(join(this.target, "owner.json"), "utf8"));
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            if (!Number.isInteger(owner.pid) || owner.pid <= 0 || !/^[a-f0-9-]{36}$/.test(owner.token))
+                throw new Error("Invalid directory lock owner");
+            try {
+                process.kill(owner.pid, 0);
+                return false;
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    throw error;
+            }
+            try {
+                renameSync(this.target, `${this.target}-dead-${owner.token}`);
+            }
+            catch (error) {
+                if (!["ENOENT", "EEXIST", "ENOTEMPTY"].includes(String(error.code)))
+                    throw error;
+            }
+        }
+    }
+    close() {
+        if (this.held) {
+            renameSync(this.target, this.attempt);
+            this.held = false;
+        }
+        rmSync(this.attempt, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=directory-lock.js.map

package/dist/server/server/domain/project-directory.js

@@ -0,0 +1,5 @@
+import { isAbsolute } from "node:path";
+export function validProjectDirectory(value) {
+    return typeof value === "string" && isAbsolute(value) && !/[\0\r\n]/.test(value);
+}
+//# sourceMappingURL=project-directory.js.map

package/dist/server/server/domain/session-domain.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-domain.js.map

package/dist/server/server/domain/session-text.js

@@ -0,0 +1,45 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toString } from "mdast-util-to-string";
+export const MAX_PREVIEW_CHARS = 256;
+export const MAX_SESSION_TITLE_CHARS = 80;
+const MAX_TITLE_HEADING_DEPTH = 64;
+export function truncateText(value, limit) {
+    if (value.length <= limit)
+        return { text: value, truncated: false };
+    let end = limit;
+    const previous = value.charCodeAt(end - 1);
+    const next = value.charCodeAt(end);
+    const splitsSurrogatePair = previous >= 0xd800 && previous <= 0xdbff && next >= 0xdc00 && next <= 0xdfff;
+    if (splitsSurrogatePair)
+        end -= 1;
+    return { text: value.slice(0, end), truncated: true };
+}
+export function normalizeSessionTitle(value) {
+    if (value === null)
+        return null;
+    const firstLine = value
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+    return firstLine === undefined ? null : truncateText(firstLine, MAX_SESSION_TITLE_CHARS).text;
+}
+export function sessionTitleFromMarkdown(value) {
+    const heading = firstTitleHeading(fromMarkdown(value), 0);
+    return normalizeSessionTitle(heading ?? value);
+}
+function firstTitleHeading(node, depth) {
+    if (node.type === "heading" && (node.depth === 1 || node.depth === 2)) {
+        const text = toString(node).trim();
+        if (text.length > 0)
+            return text;
+    }
+    if (depth >= MAX_TITLE_HEADING_DEPTH || !("children" in node))
+        return null;
+    for (const child of node.children) {
+        const heading = firstTitleHeading(child, depth + 1);
+        if (heading !== null)
+            return heading;
+    }
+    return null;
+}
+//# sourceMappingURL=session-text.js.map

package/dist/server/server/hosting/diff-store.js

@@ -0,0 +1,103 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { HostingStore } from "./store.js";
+import { ResourceValidationError } from "./validation-error.js";
+export const DIFF_ID = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/;
+export class DiffStore {
+    hosting;
+    constructor(root) {
+        this.hosting = new HostingStore(root);
+    }
+    directory(id) {
+        return join(this.hosting.root, "diffs", id);
+    }
+    async metadata(id) {
+        if (!DIFF_ID.test(id))
+            return null;
+        try {
+            const directory = this.directory(id);
+            const metadata = JSON.parse(await readFile(join(directory, "metadata.json"), "utf8"));
+            if (metadata.id !== id ||
+                metadata.url !== `/diffs/${id}` ||
+                typeof metadata.title !== "string" ||
+                !Number.isFinite(Date.parse(metadata.createdAt)))
+                throw new Error("Invalid diff metadata");
+            return metadata;
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+    }
+    async exists(id) {
+        if (!(await this.metadata(id)))
+            return false;
+        try {
+            return (await lstat(join(this.directory(id), "raw.diff"))).isFile();
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return false;
+            throw error;
+        }
+    }
+    async get(id) {
+        const metadata = await this.metadata(id);
+        if (!metadata)
+            return null;
+        try {
+            return { ...metadata, raw: await readFile(join(this.directory(id), "raw.diff"), "utf8") };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+    }
+    async list() {
+        let names;
+        try {
+            names = await readdir(join(this.hosting.root, "diffs"));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        const entries = await Promise.all(names.filter((id) => DIFF_ID.test(id)).map((id) => this.metadata(id)));
+        return entries.filter((entry) => entry !== null);
+    }
+    async publish(file, title) {
+        if (!(await lstat(file)).isFile())
+            throw new ResourceValidationError("Diff source must be a regular file");
+        const raw = await readFile(file);
+        return this.hosting.locked(async () => {
+            const id = randomUUID();
+            const metadata = {
+                id,
+                title: title ?? basename(file),
+                createdAt: new Date().toISOString(),
+                url: `/diffs/${id}`,
+            };
+            const temporary = this.directory(`.tmp-${id}`);
+            await mkdir(temporary, { recursive: true });
+            try {
+                await writeFile(join(temporary, "raw.diff"), raw);
+                await writeFile(join(temporary, "metadata.json"), JSON.stringify(metadata));
+                await rename(temporary, this.directory(id));
+            }
+            finally {
+                await rm(temporary, { recursive: true, force: true });
+            }
+            return metadata;
+        });
+    }
+    async delete(id) {
+        if (!DIFF_ID.test(id))
+            throw new ResourceValidationError("Invalid diff UUID");
+        await this.hosting.locked(() => rm(this.directory(id), { recursive: true, force: true }));
+    }
+}
+//# sourceMappingURL=diff-store.js.map

package/dist/server/server/hosting/routes.js

@@ -0,0 +1,168 @@
+import { createReadStream } from "node:fs";
+import { realpath, stat } from "node:fs/promises";
+import { extname, join, resolve, sep } from "node:path";
+import { decodePath, isMissingFile, reportRequestError, requestUrl, } from "../http/request-errors.js";
+import { sendJson } from "../http/router.js";
+import { DiffStore } from "./diff-store.js";
+import { HostingStore } from "./store.js";
+const types = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".json": "application/json",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".avif": "image/avif",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".wasm": "application/wasm",
+    ".xml": "application/xml",
+    ".pdf": "application/pdf",
+    ".webmanifest": "application/manifest+json",
+    ".wav": "audio/wav",
+    ".txt": "text/plain; charset=utf-8",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mp3": "audio/mpeg",
+};
+export function hostingRoutes(directory, options = {}) {
+    const store = directory === undefined ? undefined : new HostingStore(directory);
+    const diffs = directory === undefined ? undefined : new DiffStore(directory);
+    return async (request, response) => {
+        const url = requestUrl(request);
+        const path = url.pathname;
+        const head = request.method === "HEAD";
+        if (path === "/api/v1/capabilities" && request.method === "GET") {
+            sendJson(response, 200, { hosting: !!store });
+            return true;
+        }
+        if (path.startsWith("/api/v1/diffs")) {
+            response.setHeader("Cache-Control", "private, no-store");
+            const match = /^\/api\/v1\/diffs\/([^/]+)$/.exec(path);
+            const entry = diffs && match && request.method === "GET" ? await diffs.get(match[1]) : null;
+            if (entry) {
+                sendJson(response, 200, entry);
+            }
+            else if (diffs && match && request.method === "DELETE" && (await diffs.exists(match[1]))) {
+                await diffs.delete(match[1]);
+                response.statusCode = 204;
+                response.end();
+            }
+            else {
+                sendJson(response, 404, {
+                    error: { code: "not_found", message: "Diff not found or already cleaned up" },
+                });
+            }
+            return true;
+        }
+        if (!path.startsWith("/web/") && !path.startsWith("/api/v1/artifacts"))
+            return false;
+        const missing = () => sendJson(response, 404, { error: { code: "not_found", message: "Artifact not found" } }, head);
+        if (!store) {
+            missing();
+            return true;
+        }
+        if (path === "/api/v1/artifacts" && request.method === "GET") {
+            const groups = new Map();
+            for (const { artifact } of await store.entries()) {
+                const list = groups.get(artifact.project) ?? [];
+                list.push(artifact);
+                groups.set(artifact.project, list);
+            }
+            sendJson(response, 200, {
+                projects: [...groups].map(([directory, artifacts]) => ({ directory, artifacts })),
+            });
+            return true;
+        }
+        const deletion = /^\/api\/v1\/artifacts\/([a-f0-9]{32})$/.exec(path);
+        if (deletion && request.method === "DELETE") {
+            if (await store.delete(deletion[1])) {
+                response.statusCode = 204;
+                response.end();
+            }
+            else
+                missing();
+            return true;
+        }
+        const match = /^\/web\/([a-f0-9]{32})\/(?:([a-f0-9]{32})\/(.*))?$/.exec(path);
+        if (!match || (request.method !== "GET" && !head)) {
+            missing();
+            return true;
+        }
+        response.removeHeader("Content-Security-Policy");
+        response.setHeader("Cache-Control", "private, no-store");
+        const entry = await store.get(match[1]);
+        if (!entry) {
+            missing();
+            return true;
+        }
+        if (!match[2]) {
+            response.statusCode = 302;
+            response.setHeader("Location", `/web/${entry.artifact.id}/${entry.artifact.snapshotId}/${url.search}`);
+            response.end();
+            return true;
+        }
+        try {
+            const relative = decodePath(match[3]);
+            if (relative.split(/[\\/]/).some((part) => part === "..") || relative.includes("\0")) {
+                missing();
+                return true;
+            }
+            const snapshotRoot = resolve(entry.directory, "snapshots", match[2]);
+            const root = await realpath(snapshotRoot);
+            if (root !== snapshotRoot) {
+                missing();
+                return true;
+            }
+            let file = await realpath(resolve(root, relative || "index.html"));
+            if (!file.startsWith(root + sep)) {
+                missing();
+                return true;
+            }
+            if ((await stat(file)).isDirectory()) {
+                if (!path.endsWith("/")) {
+                    response.statusCode = 302;
+                    response.setHeader("Location", path + "/" + url.search);
+                    response.end();
+                    return true;
+                }
+                file = await realpath(join(file, "index.html"));
+            }
+            if (!file.startsWith(root + sep)) {
+                missing();
+                return true;
+            }
+            const info = await stat(file);
+            if (!info.isFile()) {
+                missing();
+                return true;
+            }
+            response.setHeader("Content-Type", types[extname(file).toLowerCase()] ?? "application/octet-stream");
+            response.setHeader("Content-Length", info.size);
+            if (head)
+                response.end();
+            else
+                createReadStream(file)
+                    .on("error", (error) => {
+                    response.destroy();
+                    reportRequestError(request, response, error, options);
+                })
+                    .pipe(response);
+        }
+        catch (error) {
+            if (!isMissingFile(error))
+                throw error;
+            missing();
+        }
+        return true;
+    };
+}
+//# sourceMappingURL=routes.js.map

package/dist/server/server/hosting/store.js

@@ -0,0 +1,162 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { copyFile, lstat, mkdir, readdir, readFile, realpath, rename, rm, writeFile, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join, resolve, sep } from "node:path";
+import { DirectoryLock } from "../directory-lock.js";
+import { ResourceValidationError } from "./validation-error.js";
+export const ID = /^[a-f0-9]{32}$/;
+export const defaultHostingDirectory = join(homedir(), ".agent-hub", "hosting");
+function parseArtifact(json) {
+    const value = JSON.parse(json);
+    if (!value ||
+        !ID.test(value.id) ||
+        !ID.test(value.snapshotId) ||
+        typeof value.project !== "string" ||
+        typeof value.source !== "string" ||
+        typeof value.name !== "string" ||
+        typeof value.title !== "string" ||
+        !Number.isFinite(Date.parse(value.createdAt)) ||
+        !Number.isFinite(Date.parse(value.updatedAt)) ||
+        value.url !== `/web/${value.id}/`)
+        throw new Error("Invalid artifact metadata");
+    return value;
+}
+async function copySnapshot(from, to) {
+    const info = await lstat(from);
+    if (info.isDirectory()) {
+        await mkdir(to);
+        for (const item of await readdir(from)) {
+            await copySnapshot(join(from, item), join(to, item));
+        }
+        return;
+    }
+    if (!info.isFile())
+        throw new ResourceValidationError(`Only regular files and directories can be published: ${from}`);
+    await copyFile(from, to, constants.COPYFILE_EXCL);
+}
+function inside(child, parent) {
+    return child === parent || child.startsWith(parent.endsWith(sep) ? parent : parent + sep);
+}
+export class HostingStore {
+    root;
+    constructor(root = defaultHostingDirectory) {
+        if (!root.trim())
+            throw new ResourceValidationError("Hosting directory must not be empty");
+        this.root = resolve(root.startsWith("~/") ? join(homedir(), root.slice(2)) : root);
+    }
+    async locked(action) {
+        const lock = new DirectoryLock(this.root, ".write-lock");
+        try {
+            while (!lock.acquire())
+                await new Promise((done) => setTimeout(done, 30));
+            return await action();
+        }
+        finally {
+            lock.close();
+        }
+    }
+    async get(id) {
+        if (!ID.test(id))
+            return undefined;
+        const directory = join(this.root, "artifacts", id);
+        let directoryExists = false;
+        try {
+            const canonicalDirectory = join(await realpath(this.root), "artifacts", id);
+            if ((await realpath(directory)) !== canonicalDirectory)
+                throw new Error("Artifact aliases are not allowed");
+            if (!(await lstat(directory)).isDirectory())
+                throw new Error("Invalid artifact directory");
+            directoryExists = true;
+            const artifact = parseArtifact(await readFile(join(directory, "artifact.json"), "utf8"));
+            if (artifact.id !== id)
+                throw new Error("Artifact identity does not match directory");
+            return { artifact, directory: canonicalDirectory };
+        }
+        catch (error) {
+            const code = error.code;
+            if (code && code !== "ENOENT" && code !== "ENOTDIR" && code !== "ELOOP")
+                throw error;
+            if (directoryExists || error.code !== "ENOENT")
+                console.warn(`Skipping damaged hosting entry ${directory}: ${String(error)}`);
+            return undefined;
+        }
+    }
+    async entries() {
+        let children;
+        try {
+            children = await readdir(join(this.root, "artifacts"), { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        const results = [];
+        for (const child of children) {
+            if (!child.isDirectory() || !ID.test(child.name))
+                continue;
+            const entry = await this.get(child.name);
+            if (entry)
+                results.push(entry);
+        }
+        return results;
+    }
+    async publish(sourcePath, projectPathInput, nameInput, title) {
+        const source = await realpath(resolve(sourcePath));
+        const project = await realpath(resolve(projectPathInput));
+        if (!(await lstat(source)).isDirectory() || !(await lstat(project)).isDirectory())
+            throw new ResourceValidationError("Source and project must be directories");
+        await mkdir(this.root, { recursive: true });
+        const root = await realpath(this.root);
+        if (inside(source, root) || inside(root, source))
+            throw new ResourceValidationError("Source must not overlap hosting storage");
+        const name = nameInput ?? basename(source);
+        if (!name.trim())
+            throw new ResourceValidationError("Artifact name must not be empty");
+        if (!(await lstat(join(source, "index.html"))).isFile())
+            throw new ResourceValidationError("Source requires index.html");
+        return this.locked(async () => {
+            const previous = (await this.entries()).find(({ artifact }) => artifact.project === project && artifact.name === name)?.artifact;
+            const id = previous?.id ?? randomUUID().replaceAll("-", "");
+            const directory = join(root, "artifacts", id);
+            await mkdir(join(directory, "snapshots"), { recursive: true });
+            const snapshotId = randomUUID().replaceAll("-", "");
+            const temp = join(directory, "snapshots", `.tmp-${snapshotId}`);
+            const metadataTemp = join(directory, `.artifact-${snapshotId}.json`);
+            try {
+                await copySnapshot(source, temp);
+                await rename(temp, join(directory, "snapshots", snapshotId));
+                const now = new Date().toISOString();
+                const artifact = {
+                    id,
+                    name,
+                    title: title ?? previous?.title ?? name,
+                    project,
+                    source,
+                    snapshotId,
+                    createdAt: previous?.createdAt ?? now,
+                    updatedAt: now,
+                    url: `/web/${id}/`,
+                };
+                await writeFile(metadataTemp, JSON.stringify(artifact));
+                await rename(metadataTemp, join(directory, "artifact.json"));
+                return artifact;
+            }
+            finally {
+                await rm(temp, { recursive: true, force: true });
+                await rm(metadataTemp, { force: true });
+            }
+        });
+    }
+    async delete(id) {
+        return this.locked(async () => {
+            const entry = await this.get(id);
+            if (!entry)
+                return false;
+            await rm(entry.directory, { recursive: true });
+            return true;
+        });
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/server/server/hosting/validation-error.js

@@ -0,0 +1,4 @@
+/** Invalid caller-supplied resource input, independent of transport. */
+export class ResourceValidationError extends Error {
+}
+//# sourceMappingURL=validation-error.js.map

package/dist/server/server/http/api-route-handler.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=api-route-handler.js.map