@someonegg/codex-hub 0.0.0-stage → 0.1.1

package/dist/server/server/application/session-read-service.js

@@ -0,0 +1,109 @@
+import { createHash } from "node:crypto";
+import { SessionApiMapper } from "../api/session-api-mapper.js";
+import { CatalogSnapshotStore, DEFAULT_CATALOG_FRESHNESS_MS, } from "../repository/catalog-snapshot-store.js";
+import { SessionQueries } from "../repository/session-queries.js";
+export class SessionReadService {
+    runtime;
+    #store;
+    #queries;
+    #mapper;
+    constructor(sources, freshnessMs = DEFAULT_CATALOG_FRESHNESS_MS, now = performance.now.bind(performance), dependencies = {}) {
+        const { resolveNickname, homes, ...storeDependencies } = dependencies;
+        this.#mapper = new SessionApiMapper(resolveNickname, homes);
+        this.#store = new CatalogSnapshotStore(sources, freshnessMs, now, storeDependencies);
+        this.#queries = new SessionQueries();
+    }
+    async managementSnapshot() {
+        const snapshot = await this.#store.refresh();
+        return {
+            sessions: [...snapshot.sessions.values()].map(({ normalized }) => normalized.session),
+        };
+    }
+    async refresh() {
+        await this.#store.refresh();
+    }
+    async list() {
+        const snapshot = await this.#store.current();
+        const sessions = [...snapshot.sessions.values()].map(({ normalized }) => normalized.session);
+        const result = this.#mapper.list(sessions);
+        if (!this.runtime)
+            return result;
+        const states = await Promise.all(sessions.map((session) => this.runtime.evaluate(session, sessions, false)));
+        const byId = new Map(sessions.map((session, index) => [session.id, states[index].status]));
+        result.sessions.forEach((session) => {
+            session.status = byId.get(session.id);
+        });
+        result.revision = createHash("sha256")
+            .update(JSON.stringify([result.revision, result.sessions.map(({ id, status }) => [id, status])]))
+            .digest("base64url");
+        return result;
+    }
+    async getSession(id) {
+        const snapshot = await this.#store.current();
+        const result = this.#queries.session(snapshot, id);
+        if (result === null)
+            return null;
+        const response = this.#mapper.detail(result);
+        await this.#runtimeDetail(response.session, snapshot);
+        return response;
+    }
+    async getItems(id, query) {
+        const snapshot = await this.#store.current();
+        const result = this.#queries.items(snapshot, id, query);
+        if (result === null)
+            return null;
+        const response = this.#mapper.itemPage(result);
+        await this.#runtimeDetail(response.session, snapshot);
+        return response;
+    }
+    async getSessionUpdates(id, cursor) {
+        const snapshot = await this.#store.current();
+        const context = this.#queries.updates(snapshot, id, cursor);
+        if (context === null)
+            return null;
+        const normalized = snapshot.sessions.get(id).normalized;
+        const session = this.#mapper.sessionDetail(context.session);
+        await this.#runtimeDetail(session, snapshot);
+        return {
+            session,
+            cursor: context.cursor,
+            hasMore: context.hasMore,
+            interactionSession: {
+                archived: normalized.session.archived,
+                interaction: normalized.interaction ?? null,
+            },
+        };
+    }
+    async getToolDetail(id, itemId, query) {
+        const snapshot = await this.#store.current();
+        const result = this.#queries.toolDetail(snapshot, id, itemId, query);
+        return result === null ? null : this.#mapper.toolDetail(result);
+    }
+    async getDirectiveDetail(id, itemId, query) {
+        const snapshot = await this.#store.current();
+        const result = this.#queries.directiveDetail(snapshot, id, itemId, query);
+        return result === null ? null : this.#mapper.directiveDetail(result);
+    }
+    async getInternalDetail(id, itemId, query) {
+        const snapshot = await this.#store.current();
+        const result = this.#queries.internalDetail(snapshot, id, itemId, query);
+        return result === null ? null : this.#mapper.internalDetail(result);
+    }
+    async #runtimeDetail(detail, snapshot) {
+        if (!this.runtime)
+            return;
+        const sessions = [...snapshot.sessions.values()].map(({ normalized }) => normalized.session);
+        Object.assign(detail, await this.runtime.evaluate(snapshot.sessions.get(detail.id).normalized.session, sessions));
+    }
+    async getInteractionSession(id) {
+        const snapshot = await this.#store.current();
+        const normalized = snapshot.sessions.get(id)?.normalized;
+        return normalized === undefined
+            ? null
+            : {
+                archived: normalized.session.archived,
+                interaction: normalized.interaction ?? null,
+            };
+    }
+}
+//# sourceMappingURL=session-read-service.js.map

package/dist/server/server/application/session-reader.js

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

package/dist/server/server/catalog/config.js

@@ -0,0 +1,4 @@
+export const CATALOG_PROBE_INTERVAL_MS = 1_500;
+export const CATALOG_WAIT_TIMEOUT_MS = 25_000;
+export const MAX_CATALOG_WAITERS = 100;
+//# sourceMappingURL=config.js.map

package/dist/server/server/catalog/session-catalog-service.js

@@ -0,0 +1,103 @@
+import { CATALOG_PROBE_INTERVAL_MS, CATALOG_WAIT_TIMEOUT_MS, MAX_CATALOG_WAITERS, } from "./config.js";
+export class CatalogCapacityError extends Error {
+}
+/** One probe loop for every waiting directory request. No loop when idle. */
+export class SessionCatalogService {
+    sessions;
+    #waiters = new Set();
+    #timer;
+    #probe = null;
+    #closed = false;
+    #probing = false;
+    constructor(sessions) {
+        this.sessions = sessions;
+    }
+    async wait(after, signal) {
+        this.#assertOpen(signal);
+        const initial = await this.#read();
+        this.#assertOpen(signal);
+        if (initial.revision !== after)
+            return initial;
+        if (this.#waiters.size >= MAX_CATALOG_WAITERS)
+            throw new CatalogCapacityError("Too many catalog requests are waiting; retry shortly");
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                clearTimeout(timeout);
+                signal?.removeEventListener("abort", abort);
+                this.#waiters.delete(waiter);
+                if (this.#waiters.size === 0) {
+                    clearTimeout(this.#timer);
+                    this.#timer = undefined;
+                }
+            };
+            const waiter = {
+                after,
+                finish: (result) => {
+                    cleanup();
+                    resolve(result);
+                },
+                fail: (reason) => {
+                    cleanup();
+                    reject(reason);
+                },
+            };
+            const abort = () => waiter.fail(new DOMException("Aborted", "AbortError"));
+            const timeout = setTimeout(() => waiter.finish(null), CATALOG_WAIT_TIMEOUT_MS);
+            this.#waiters.add(waiter);
+            signal?.addEventListener("abort", abort, { once: true });
+            this.#schedule();
+        });
+    }
+    #assertOpen(signal) {
+        if (this.#closed || signal?.aborted)
+            throw new DOMException("Aborted", "AbortError");
+    }
+    #read(refresh = false) {
+        if (this.#probe !== null)
+            return this.#probe;
+        this.#probe = (async () => {
+            if (refresh)
+                await this.sessions.refresh();
+            return this.sessions.list();
+        })();
+        const probe = this.#probe;
+        void probe.then(() => {
+            if (this.#probe === probe)
+                this.#probe = null;
+        }, () => {
+            if (this.#probe === probe)
+                this.#probe = null;
+        });
+        return probe;
+    }
+    #schedule() {
+        if (this.#closed || this.#probing || this.#timer !== undefined || this.#waiters.size === 0)
+            return;
+        this.#timer = setTimeout(async () => {
+            this.#timer = undefined;
+            this.#probing = true;
+            try {
+                const snapshot = await this.#read(true);
+                for (const waiter of this.#waiters)
+                    if (waiter.after !== snapshot.revision)
+                        waiter.finish(snapshot);
+            }
+            catch (reason) {
+                for (const waiter of this.#waiters)
+                    waiter.fail(reason);
+            }
+            finally {
+                this.#probing = false;
+                this.#schedule();
+            }
+        }, CATALOG_PROBE_INTERVAL_MS);
+    }
+    close() {
+        this.#closed = true;
+        clearTimeout(this.#timer);
+        this.#timer = undefined;
+        for (const waiter of this.#waiters)
+            waiter.finish(null);
+    }
+}
+//# sourceMappingURL=session-catalog-service.js.map

package/dist/server/server/config.js

@@ -0,0 +1,145 @@
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+export const LOOPBACK_HOST = "127.0.0.1";
+function nonEmptyOption(name, value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        throw new Error(`--${name} must not be empty`);
+    }
+    return normalized;
+}
+function parsePort(value) {
+    if (value === undefined)
+        return 4173;
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+        throw new Error("--port must be an integer between 0 and 65535");
+    }
+    return port;
+}
+export function loadConfig(args = process.argv.slice(2)) {
+    const { values } = parseArgs({
+        args: [...args],
+        allowPositionals: false,
+        strict: true,
+        options: {
+            "codex-home": { type: "string", multiple: true },
+            host: { type: "string" },
+            port: { type: "string" },
+            ssl: { type: "boolean" },
+            "ssl-cert": { type: "string" },
+            "ssl-key": { type: "string" },
+            "ssl-ca": { type: "string" },
+            help: { type: "boolean" },
+            "tmux-socket": { type: "string" },
+            "upload-dir": { type: "string" },
+        },
+    });
+    if (values.help)
+        return { kind: "help" };
+    const host = nonEmptyOption("host", values.host) ?? LOOPBACK_HOST;
+    const homes = parseHomes(values["codex-home"] ?? ["default=~/.codex"]);
+    const certificatePath = nonEmptyOption("ssl-cert", values["ssl-cert"]);
+    const privateKeyPath = nonEmptyOption("ssl-key", values["ssl-key"]);
+    const certificateAuthorityPath = nonEmptyOption("ssl-ca", values["ssl-ca"]);
+    let tls;
+    if (values.ssl) {
+        if (!certificatePath || !privateKeyPath) {
+            throw new Error("--ssl requires both --ssl-cert and --ssl-key");
+        }
+        tls = {
+            enabled: true,
+            certificatePath: resolve(certificatePath),
+            privateKeyPath: resolve(privateKeyPath),
+            ...(certificateAuthorityPath
+                ? { certificateAuthorityPath: resolve(certificateAuthorityPath) }
+                : {}),
+        };
+    }
+    else {
+        if (certificatePath || privateKeyPath || certificateAuthorityPath) {
+            throw new Error("--ssl-cert, --ssl-key, and --ssl-ca require --ssl");
+        }
+        tls = { enabled: false };
+    }
+    return {
+        kind: "run",
+        config: {
+            host,
+            port: parsePort(values.port),
+            homes,
+            clientDirectory: fileURLToPath(new URL("../../client/", import.meta.url)),
+            tls,
+            interactionEnabled: true,
+            ...(values["upload-dir"] !== undefined
+                ? { uploadDirectory: resolveUploadDirectory(values["upload-dir"]) }
+                : {}),
+            ...(values["tmux-socket"] !== undefined
+                ? { tmuxSocket: resolve(nonEmptyOption("tmux-socket", values["tmux-socket"])) }
+                : {}),
+        },
+    };
+}
+export function commandLineHelp() {
+    return `Usage: codex-hub [options]
+
+Options:
+  --codex-home <nickname=path>
+                       Codex home; repeat for multiple homes (default: default=~/.codex)
+  --host <host>        Listen host (default: 127.0.0.1)
+  --port <port>        Listen port, or 0 for a free port (default: 4173)
+  --ssl                Enable TLS; the port will accept HTTPS only
+  --ssl-cert <path>    PEM server certificate or certificate chain
+  --ssl-key <path>     PEM server private key
+  --ssl-ca <path>      PEM CA bundle; enables mandatory client certificates
+  --tmux-socket <path> tmux socket (default: tmux default selection)
+  --upload-dir <path>  Store uploads here (default: a persistent process temporary directory)
+  --help               Show this help
+
+TLS example:
+  codex-hub --ssl --ssl-cert server.crt --ssl-key server.key
+
+mTLS example:
+  codex-hub --ssl --ssl-cert server.crt --ssl-key server.key --ssl-ca ca.crt`;
+}
+function parseHomes(values) {
+    const names = new Set();
+    const paths = new Set();
+    return values.map((value) => {
+        const separator = value.indexOf("=");
+        const nickname = value.slice(0, separator).trim();
+        const homePath = value.slice(separator + 1).trim();
+        if (separator < 0 || !nickname || !homePath) {
+            throw new Error("--codex-home requires nickname=path with a non-empty nickname and path");
+        }
+        const path = resolve(homePath.startsWith("~/") ? resolve(homedir(), homePath.slice(2)) : homePath);
+        let canonical = path;
+        try {
+            canonical = realpathSync(path);
+        }
+        catch (error) {
+            if (!(error &&
+                typeof error === "object" &&
+                "code" in error &&
+                ["ENOENT", "EACCES", "EPERM"].includes(String(error.code))))
+                throw error;
+        }
+        if (names.has(nickname))
+            throw new Error(`Duplicate home nickname: ${nickname}`);
+        if (paths.has(canonical))
+            throw new Error("Duplicate home path");
+        names.add(nickname);
+        paths.add(canonical);
+        return { nickname, path };
+    });
+}
+function resolveUploadDirectory(value) {
+    const path = nonEmptyOption("upload-dir", value);
+    return resolve(path.startsWith("~/") ? resolve(homedir(), path.slice(2)) : path);
+}
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,64 @@
+import { createCodexSessionSource } from "./adapters/codex/codex-session-source.js";
+import { createCodexSessionManager } from "./adapters/codex/session-manager.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 { paneBindings } 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 { SessionManagerRegistry } from "./management/session-manager.js";
+import { SessionUpdatesService } from "./updates/session-updates-service.js";
+function createSessionReadService(sources, dependencies) {
+    return new SessionReadService(sources, undefined, undefined, dependencies);
+}
+export async function createCodexSessionReadService(codexHome) {
+    const source = await createCodexSessionSource(codexHome, paneBindings);
+    return createSessionReadService([source], {
+        resolveNickname: (session) => source.nicknameFor(session),
+        homes: [{ sourceInstanceId: source.descriptor.sourceInstanceId, nickname: "default" }],
+    });
+}
+/** Compose reading and management using the adapter's published source identity. */
+export async function createCodexHub(homes, socket, interactionEnabled = true) {
+    const sources = await Promise.all(homes.map((home) => createCodexSessionSource(home.path, paneBindings)));
+    const sessions = createSessionReadService(sources, {
+        resolveNickname: (session) => sources
+            .find((source) => source.descriptor.sourceInstanceId === session.origin.sourceInstanceId)
+            ?.nicknameFor(session) ?? null,
+        homes: sources.map((source, index) => ({
+            sourceInstanceId: source.descriptor.sourceInstanceId,
+            nickname: homes[index].nickname,
+        })),
+    });
+    const managers = new SessionManagerRegistry(sources[0].descriptor.sourceInstanceId);
+    sources.forEach((source, index) => managers.register(source.descriptor.sourceInstanceId, createCodexSessionManager(homes[index].path, socket)));
+    const transport = new TmuxInteractionService();
+    const interaction = new SessionInteractionService(sessions, interactionEnabled, transport, paneBindings);
+    const runtime = new SessionRuntime(transport, managers, paneBindings);
+    sessions.runtime = runtime;
+    interaction.runtime = runtime;
+    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, { interaction });
+        cleanup.push(() => updates.close());
+        const operations = new OperationService(sessions, interaction, managers, undefined, undefined, paneBindings, runtime);
+        cleanup.push(() => operations.close());
+        return { sessions, managers, interaction, catalog, updates, operations, close };
+    }
+    catch (error) {
+        close();
+        throw error;
+    }
+}
+//# sourceMappingURL=create-hub.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/http/api-route-handler.js

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

package/dist/server/server/http/api-router.js

@@ -0,0 +1,63 @@
+import { randomUUID } from "node:crypto";
+import { HttpQueryError } from "./query-params.js";
+import { RequestBodyError } from "./request-body.js";
+import { sendJson } from "./router.js";
+import { createSessionInteractionRoutes } from "./session-interaction-routes.js";
+import { createSessionManagementRoutes } from "./session-management-routes.js";
+import { createSessionReadRoutes } from "./session-read-routes.js";
+import { createSessionUpdatesRoutes } from "./session-updates-routes.js";
+import { createUploadRoutes } from "./upload-routes.js";
+const CONSOLE_ERROR_LOGGER = {
+    error(message, context) {
+        console.error(`${message} [requestId=${context.requestId}]`, context.error);
+    },
+};
+export function createApiRouter(dependencies, options = {}) {
+    const logger = options.logger ?? CONSOLE_ERROR_LOGGER;
+    const requestIdFactory = options.requestId ?? randomUUID;
+    const handlers = [
+        createUploadRoutes(dependencies.uploadDirectory),
+        createSessionManagementRoutes(dependencies.operations),
+        createSessionUpdatesRoutes(dependencies.updates),
+        createSessionInteractionRoutes(dependencies.interaction),
+        createSessionReadRoutes(dependencies),
+    ];
+    const router = async (request, response) => {
+        const url = new URL(request.url ?? "/", "http://localhost");
+        if (!url.pathname.startsWith("/api/"))
+            return false;
+        const headOnly = request.method === "HEAD";
+        const requestId = requestIdFactory();
+        for (const handler of handlers.filter((candidate) => candidate.matches(url))) {
+            try {
+                if (await handler.handle(request, response, url))
+                    return true;
+            }
+            catch (error) {
+                if (error instanceof RequestBodyError || error instanceof HttpQueryError) {
+                    sendJson(response, error instanceof RequestBodyError ? error.status : 400, {
+                        error: {
+                            code: error instanceof RequestBodyError ? error.code : "invalid_query",
+                            message: error.message,
+                        },
+                    }, headOnly);
+                    return true;
+                }
+                if (handler.mapError(error, request, response))
+                    return true;
+                logger.error("Session API request failed", { requestId, error });
+                sendJson(response, 500, {
+                    error: {
+                        code: "internal_error",
+                        message: "The local session reader could not complete the request",
+                        requestId,
+                    },
+                }, headOnly);
+                return true;
+            }
+        }
+        return false;
+    };
+    return router;
+}
+//# sourceMappingURL=api-router.js.map