@someonegg/agent-hub 0.0.0-stage → 0.7.0

package/dist/server/server/adapters/codex/value-readers.js

@@ -0,0 +1,4 @@
+export function nonEmptyString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+//# sourceMappingURL=value-readers.js.map

package/dist/server/server/adapters/shared/binding-protocol.js

@@ -0,0 +1,54 @@
+import { isAbsolute } from "node:path";
+import { validTaskName } from "../../../shared/task-name.js";
+import { validProjectDirectory } from "../../domain/project-directory.js";
+import { validTmuxSessionName } from "../../interaction/tmux-target.js";
+/** Parse protocol fields only after the adapter has established native provenance. */
+export function bindingAttempts(lines, ordinal, validOperationId) {
+    const found = [];
+    for (let index = 0; index < lines.length; index++) {
+        if (lines[index] !== "AHUB_TMUX_BIND_V3")
+            continue;
+        const socketPath = lines[index + 1] ?? "";
+        const sessionName = lines[index + 2] ?? "";
+        const operationId = lines[index + 3] ?? "";
+        const projectDirectory = lines[index + 4];
+        let taskName;
+        try {
+            const value = JSON.parse(lines[index + 5] ?? "");
+            if (validTaskName(value))
+                taskName = value.trim() || undefined;
+        }
+        catch {
+            /* Optional metadata cannot invalidate a binding. */
+        }
+        if (!isAbsolute(socketPath) ||
+            !validTmuxSessionName(sessionName) ||
+            (operationId && !validOperationId(operationId))) {
+            found.push({ ordinal, valid: false });
+            continue;
+        }
+        found.push({
+            ordinal,
+            valid: true,
+            socketPath,
+            sessionName,
+            ...(operationId ? { operationId } : {}),
+            ...(validProjectDirectory(projectDirectory) ? { projectDirectory } : {}),
+            ...(taskName ? { taskName } : {}),
+        });
+    }
+    return found;
+}
+export function mergeBindingMetadata(previous, attempts) {
+    let { projectDirectory, taskName } = previous;
+    for (const attempt of attempts) {
+        if (!attempt.valid)
+            continue;
+        if (validProjectDirectory(attempt.projectDirectory))
+            projectDirectory = attempt.projectDirectory;
+        if (validTaskName(attempt.taskName) && attempt.taskName.trim())
+            taskName = attempt.taskName.trim();
+    }
+    return { projectDirectory, taskName };
+}
+//# sourceMappingURL=binding-protocol.js.map

package/dist/server/server/adapters/shared/io-errors.js

@@ -0,0 +1,13 @@
+const EXPECTED_IO_ERRORS = new Set([
+    "ENOENT",
+    "EACCES",
+    "EPERM",
+    "ESTALE",
+    "EISDIR",
+    "ENOTDIR",
+    "ELOOP",
+]);
+export function isExpectedIoError(error) {
+    return error instanceof Error && "code" in error && EXPECTED_IO_ERRORS.has(String(error.code));
+}
+//# sourceMappingURL=io-errors.js.map

package/dist/server/server/adapters/shared/jsonl-decoder.js

@@ -0,0 +1,263 @@
+import { createHash } from "node:crypto";
+import { open } from "node:fs/promises";
+import { MAX_JSONL_LINE_BYTES, MAX_SESSION_DIAGNOSTICS } from "./limits.js";
+export const PROBE_BYTES = 4 * 1024;
+export class CheckpointedJsonlDecoder {
+    async decode(descriptor, checkpoint) {
+        const handle = await open(descriptor.path, "r");
+        try {
+            const info = await handle.stat();
+            const observedEof = info.size;
+            let probeBytes = 0;
+            let appendCheckpoint = null;
+            let validatedWindows = [];
+            if (isCompatibleCheckpoint(checkpoint, observedEof)) {
+                const validation = await validateProbes(handle, checkpoint);
+                probeBytes += validation.bytesRead;
+                if (validation.matches) {
+                    appendCheckpoint = checkpoint;
+                    validatedWindows = validation.windows;
+                }
+            }
+            const start = appendCheckpoint?.committedOffset ?? 0;
+            const baseOrdinal = appendCheckpoint?.physicalLineCount ?? 0;
+            const priorDiagnostics = appendCheckpoint?.diagnostics ?? [];
+            const decoded = await decodeRange(handle, start, observedEof, baseOrdinal, priorDiagnostics);
+            const probes = createProbes(observedEof, [
+                ...validatedWindows,
+                { offset: start, contents: decoded.headBytes },
+                { offset: decoded.tailOffset, contents: decoded.tailBytes },
+            ]);
+            const checkpointDiagnostics = decoded.diagnostics.map(cloneDiagnostic);
+            const nextCheckpoint = {
+                observedEof,
+                committedOffset: decoded.committedOffset,
+                physicalLineCount: decoded.physicalLineCount,
+                diagnostics: checkpointDiagnostics,
+                headProbe: probes.head,
+                tailProbe: probes.tail,
+            };
+            return {
+                descriptor,
+                records: decoded.records,
+                diagnostics: checkpointDiagnostics.map(cloneDiagnostic),
+                batchDiagnostics: decoded.batchDiagnostics.map(cloneDiagnostic),
+                mode: appendCheckpoint === null ? "full" : "append",
+                checkpoint: nextCheckpoint,
+                telemetry: {
+                    probeBytes,
+                    decodeBytes: decoded.bytesRead,
+                    totalBytes: probeBytes + decoded.bytesRead,
+                },
+            };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+}
+async function decodeRange(handle, start, observedEof, baseOrdinal, priorDiagnostics) {
+    const records = [];
+    const diagnostics = priorDiagnostics.slice(0, MAX_SESSION_DIAGNOSTICS).map(cloneDiagnostic);
+    const batchDiagnostics = [];
+    const lineChunks = [];
+    let lineBytes = 0;
+    let ordinal = baseOrdinal;
+    let committedOffset = start;
+    let bytesRead = 0;
+    let droppingOversizedLine = false;
+    const headParts = [];
+    let headLength = 0;
+    let tailBytes = Buffer.alloc(0);
+    if (start < observedEof) {
+        const stream = handle.createReadStream({
+            autoClose: false,
+            start,
+            end: observedEof - 1,
+        });
+        for await (const rawChunk of stream) {
+            const chunk = rawChunk;
+            bytesRead += chunk.length;
+            if (headLength < PROBE_BYTES) {
+                const part = chunk.subarray(0, PROBE_BYTES - headLength);
+                headParts.push(part);
+                headLength += part.length;
+            }
+            tailBytes = tailWindow(tailBytes, chunk);
+            let cursor = 0;
+            while (cursor < chunk.length) {
+                const newline = chunk.indexOf(0x0a, cursor);
+                const end = newline < 0 ? chunk.length : newline;
+                if (!droppingOversizedLine && end > cursor) {
+                    const part = chunk.subarray(cursor, end);
+                    lineBytes += part.length;
+                    // Keep one possible trailing CR until the newline decides whether it
+                    // is part of a CRLF terminator. decodeLine applies the final limit
+                    // after stripping that CR.
+                    if (lineBytes > MAX_JSONL_LINE_BYTES + 1) {
+                        lineChunks.length = 0;
+                        droppingOversizedLine = true;
+                    }
+                    else {
+                        lineChunks.push(part);
+                    }
+                }
+                if (newline < 0)
+                    break;
+                ordinal += 1;
+                committedOffset = start + bytesRead - (chunk.length - newline - 1);
+                if (droppingOversizedLine) {
+                    retainDiagnostic(diagnostics, batchDiagnostics, lineTooLargeDiagnostic(ordinal));
+                }
+                else {
+                    decodeLine(lineBuffer(lineChunks, lineBytes), ordinal, records, diagnostics, batchDiagnostics);
+                }
+                lineChunks.length = 0;
+                lineBytes = 0;
+                droppingOversizedLine = false;
+                cursor = newline + 1;
+            }
+        }
+    }
+    return {
+        records,
+        diagnostics,
+        batchDiagnostics,
+        committedOffset,
+        physicalLineCount: ordinal,
+        bytesRead,
+        headBytes: Buffer.concat(headParts, headLength),
+        tailBytes,
+        tailOffset: observedEof - tailBytes.length,
+    };
+}
+function lineBuffer(chunks, length) {
+    if (chunks.length === 0)
+        return Buffer.alloc(0);
+    if (chunks.length === 1)
+        return chunks[0];
+    return Buffer.concat(chunks, length);
+}
+function decodeLine(rawLine, ordinal, records, diagnostics, batchDiagnostics) {
+    const line = rawLine.at(-1) === 0x0d ? rawLine.subarray(0, -1) : rawLine;
+    if (line.length === 0)
+        return;
+    if (line.length > MAX_JSONL_LINE_BYTES) {
+        retainDiagnostic(diagnostics, batchDiagnostics, lineTooLargeDiagnostic(ordinal));
+        return;
+    }
+    try {
+        const value = JSON.parse(line.toString("utf8"));
+        if (!isObject(value)) {
+            retainDiagnostic(diagnostics, batchDiagnostics, {
+                code: "invalid_record",
+                severity: "warning",
+                message: "A JSONL line was not a JSON object and was skipped.",
+                ordinal,
+            });
+            return;
+        }
+        records.push({ ordinal, value });
+    }
+    catch {
+        retainDiagnostic(diagnostics, batchDiagnostics, {
+            code: "malformed_json",
+            severity: "warning",
+            message: "A malformed JSONL line was skipped.",
+            ordinal,
+        });
+    }
+}
+function lineTooLargeDiagnostic(ordinal) {
+    return {
+        code: "line_too_large",
+        severity: "warning",
+        message: "A JSONL record exceeded the decode limit and was skipped.",
+        ordinal,
+    };
+}
+function retainDiagnostic(diagnostics, batchDiagnostics, diagnostic) {
+    if (diagnostics.length < MAX_SESSION_DIAGNOSTICS) {
+        diagnostics.push(cloneDiagnostic(diagnostic));
+        batchDiagnostics.push(cloneDiagnostic(diagnostic));
+    }
+}
+function isCompatibleCheckpoint(checkpoint, observedEof) {
+    return checkpoint !== undefined && observedEof > checkpoint.observedEof;
+}
+async function validateProbes(handle, checkpoint) {
+    const head = await readProbe(handle, checkpoint.headProbe);
+    const tail = await readProbe(handle, checkpoint.tailProbe);
+    return {
+        matches: head.matches && tail.matches,
+        bytesRead: head.bytesRead + tail.bytesRead,
+        windows: [
+            { offset: checkpoint.headProbe.offset, contents: head.contents },
+            { offset: checkpoint.tailProbe.offset, contents: tail.contents },
+        ],
+    };
+}
+function createProbes(observedEof, windows) {
+    const headLength = Math.min(PROBE_BYTES, observedEof);
+    const tailOffset = Math.max(0, observedEof - PROBE_BYTES);
+    return {
+        head: probeFromWindows(0, headLength, windows),
+        tail: probeFromWindows(tailOffset, observedEof - tailOffset, windows),
+    };
+}
+async function probeAt(handle, offset, length) {
+    const buffer = Buffer.alloc(length);
+    let bytesRead = 0;
+    if (length > 0) {
+        ({ bytesRead } = await handle.read(buffer, 0, length, offset));
+    }
+    const contents = buffer.subarray(0, bytesRead);
+    return {
+        probe: {
+            offset,
+            length: bytesRead,
+            sha256: sha256(contents),
+        },
+        bytesRead,
+        contents,
+    };
+}
+async function readProbe(handle, expected) {
+    const actual = await probeAt(handle, expected.offset, expected.length);
+    const contents = actual.contents;
+    return {
+        matches: actual.probe.length === expected.length && actual.probe.sha256 === expected.sha256,
+        bytesRead: actual.bytesRead,
+        contents,
+    };
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function tailWindow(previous, chunk) {
+    if (chunk.length >= PROBE_BYTES)
+        return chunk.subarray(chunk.length - PROBE_BYTES);
+    const keep = Math.min(previous.length, PROBE_BYTES - chunk.length);
+    return Buffer.concat([previous.subarray(previous.length - keep), chunk], keep + chunk.length);
+}
+function probeFromWindows(offset, length, windows) {
+    const contents = Buffer.alloc(length);
+    let cursor = offset;
+    while (cursor < offset + length) {
+        const window = windows.find(({ offset: windowOffset, contents: value }) => cursor >= windowOffset && cursor < windowOffset + value.length);
+        if (window === undefined) {
+            throw new Error("Decoder probe bytes were not retained");
+        }
+        const sourceStart = cursor - window.offset;
+        const copied = window.contents.copy(contents, cursor - offset, sourceStart, Math.min(window.contents.length, sourceStart + offset + length - cursor));
+        cursor += copied;
+    }
+    return { offset, length, sha256: sha256(contents) };
+}
+function cloneDiagnostic(value) {
+    return { ...value };
+}
+export function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=jsonl-decoder.js.map

package/dist/server/server/adapters/shared/limits.js

@@ -0,0 +1,4 @@
+export const MAX_JSONL_LINE_BYTES = 8 * 1024 * 1024;
+export const MAX_SESSION_DIAGNOSTICS = 50;
+export const MAX_MESSAGE_CHARS = 1_000_000;
+//# sourceMappingURL=limits.js.map

package/dist/server/server/adapters/shared/session-management.js

@@ -0,0 +1,43 @@
+import { realpath, stat } from "node:fs/promises";
+import { validProjectDirectory } from "../../domain/project-directory.js";
+export async function resolveDirectory(input) {
+    if (!validProjectDirectory(input))
+        throw new Error("Directory must be an absolute local path");
+    const directory = await realpath(input);
+    if (!(await stat(directory)).isDirectory())
+        throw Object.assign(new Error("Path is not a directory"), { code: "ENOTDIR" });
+    return { directory };
+}
+export const DEFAULT_KEY_BINDINGS = {
+    enter: "Enter",
+    up: "Up",
+    down: "Down",
+    left: "Left",
+    right: "Right",
+    BTab: "BTab",
+    "0": "0",
+    "1": "1",
+    "2": "2",
+    "3": "3",
+    "4": "4",
+    "5": "5",
+    "6": "6",
+    "7": "7",
+    "8": "8",
+    "9": "9",
+};
+export function interruptSteps() {
+    return [
+        { keys: ["C-u"], delayMs: 0 },
+        { keys: ["Escape"], delayMs: 100 },
+    ];
+}
+export function exitSteps() {
+    return [
+        { keys: ["C-c"], delayMs: 0 },
+        { keys: ["C-c"], delayMs: 200 },
+        { keys: ["C-c"], delayMs: 2400 },
+        { keys: ["C-c"], delayMs: 200 },
+    ];
+}
+//# sourceMappingURL=session-management.js.map

package/dist/server/server/adapters/shared/source-cache.js

@@ -0,0 +1,23 @@
+export function fingerprintOf(value) {
+    return { sourceRelativePath: value.sourceRelativePath, size: value.size, mtimeMs: value.mtimeMs };
+}
+export function sameFingerprint(left, right) {
+    return (left.sourceRelativePath === right.sourceRelativePath &&
+        left.size === right.size &&
+        left.mtimeMs === right.mtimeMs);
+}
+export function mutableTelemetry() {
+    return {
+        fullFiles: 0,
+        appendFiles: 0,
+        probeBytes: 0,
+        decodeBytes: 0,
+        decodeMs: 0,
+        normalizeMs: 0,
+    };
+}
+/** Accepted paths win; logical path order resolves initial and replacement ties. */
+export function acceptedPathOrder(accepted, left, right) {
+    return Number(accepted.has(right)) - Number(accepted.has(left)) || left.localeCompare(right);
+}
+//# sourceMappingURL=source-cache.js.map

package/dist/server/server/api/session-api-mapper.js

@@ -0,0 +1,65 @@
+import { createHash } from "node:crypto";
+export class SessionApiMapper {
+    resolveDisplayTitle;
+    agents;
+    constructor(resolveDisplayTitle = () => null, agents = []) {
+        this.resolveDisplayTitle = resolveDisplayTitle;
+        this.agents = agents;
+    }
+    list(sessions, effectiveStates) {
+        const projectDirectories = new Set();
+        const summaries = sessions
+            .map((session) => {
+            const projectDirectory = session.projectDirectory;
+            const isChild = session.isChild ?? session.parentId !== null;
+            if (!isChild && projectDirectory !== null)
+                projectDirectories.add(projectDirectory);
+            return {
+                id: session.id,
+                agent: session.origin.agent,
+                title: this.resolveDisplayTitle(session) ?? session.title,
+                projectDirectory,
+                ...(session.taskName ? { taskName: session.taskName } : {}),
+                status: effectiveStates?.get(session.id) ??
+                    (session.archived ? "archived" : "normal"),
+                parentId: session.parentId,
+                isChild,
+                updatedAt: session.updatedAt,
+            };
+        })
+            .sort((a, b) => compareIds(a.id, b.id));
+        const structure = {
+            agents: [...this.agents],
+            projects: [...projectDirectories].sort(compareIds).map((directory) => ({ directory })),
+            sessions: summaries.map(({ updatedAt, ...summary }) => summary),
+        };
+        return {
+            revision: createHash("sha256").update(JSON.stringify(structure)).digest("base64url"),
+            agents: structure.agents,
+            projects: structure.projects,
+            sessions: summaries,
+        };
+    }
+    sessionDetail(session) {
+        return {
+            resume: { allowed: false, reason: "Runtime validation unavailable" },
+            id: session.id,
+            origin: { ...session.origin },
+            title: this.resolveDisplayTitle(session) ?? session.title,
+            workingDirectory: session.workingDirectory,
+            projectDirectory: session.projectDirectory,
+            ...(session.taskName ? { taskName: session.taskName } : {}),
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            status: session.archived ? "archived" : "normal",
+            parentId: session.parentId,
+            childIds: [...session.childIds],
+            subagent: session.subagent === null ? null : { ...session.subagent },
+            sourceId: session.sourceId,
+        };
+    }
+}
+function compareIds(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+//# sourceMappingURL=session-api-mapper.js.map

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

@@ -0,0 +1,17 @@
+/** Read internal interaction facts without assembling public session responses. */
+export class CatalogInteractionSessionReader {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async getInteractionSession(id) {
+        const normalized = (await this.store.current()).sessions.get(id);
+        return normalized === undefined
+            ? null
+            : {
+                archived: normalized.session.archived,
+                interaction: normalized.interaction ?? null,
+            };
+    }
+}
+//# sourceMappingURL=interaction-session-reader.js.map

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

@@ -0,0 +1,86 @@
+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";
+import { createUpdateRevision } from "../updates/update-revision.js";
+import { CatalogInteractionSessionReader } from "./interaction-session-reader.js";
+import { assembleSessionResponse } from "./session-response.js";
+export class SessionReadService {
+    runtime;
+    #store;
+    #queries;
+    #mapper;
+    #interaction;
+    #interactionSessions;
+    constructor(sources, options = {}) {
+        const { store, interaction, resolveDisplayTitle, agents, freshnessMs = DEFAULT_CATALOG_FRESHNESS_MS, now = performance.now.bind(performance), runtime, ...storeDependencies } = options;
+        this.runtime = runtime;
+        this.#mapper = new SessionApiMapper(resolveDisplayTitle, agents);
+        this.#store = store ?? new CatalogSnapshotStore(sources, freshnessMs, now, storeDependencies);
+        this.#interaction = interaction;
+        this.#interactionSessions = new CatalogInteractionSessionReader(this.#store);
+        this.#queries = new SessionQueries();
+    }
+    async managementSnapshot() {
+        const snapshot = await this.#store.refresh();
+        const byId = new Map([...snapshot.sessions].map(([id, value]) => [id, value.session]));
+        return { sessions: [...byId.values()], byId };
+    }
+    async refresh() {
+        await this.#store.refresh();
+    }
+    async list() {
+        const snapshot = await this.#store.current();
+        const sessions = [...snapshot.sessions.values()].map(({ session }) => session);
+        if (!this.runtime)
+            return this.#mapper.list(sessions);
+        const states = await Promise.all(sessions.map((session) => this.runtime.evaluate(session, false)));
+        const byId = new Map(sessions.map((session, index) => [session.id, states[index].status]));
+        return this.#mapper.list(sessions, byId);
+    }
+    async getSession(id) {
+        return (await this.readMessages(id))?.state ?? null;
+    }
+    async messages(id, query) {
+        return (await this.readMessages(id))?.page(query) ?? null;
+    }
+    async readMessages(id) {
+        const snapshot = await this.#store.current();
+        const source = this.#queries.session(snapshot, id);
+        if (!source)
+            return null;
+        const session = this.#mapper.sessionDetail(source);
+        const interactionSession = await this.#runtimeDetail(session, snapshot);
+        const state = await assembleSessionResponse({ session, interactionSession }, this.#interaction, createUpdateRevision);
+        return {
+            state,
+            page: (query) => {
+                const result = this.#queries.messages(snapshot, id, query);
+                return {
+                    ...state,
+                    items: result.items,
+                    nextAfter: result.nextAfter,
+                    hasMore: result.hasMore,
+                };
+            },
+        };
+    }
+    async #runtimeDetail(detail, snapshot) {
+        const normalized = snapshot.sessions.get(detail.id);
+        const interactionSession = {
+            archived: normalized.session.archived,
+            interaction: normalized.interaction ?? null,
+        };
+        if (!this.runtime)
+            return interactionSession;
+        const observation = normalized.session.archived
+            ? undefined
+            : await this.runtime.observe(detail.id);
+        const { status, resume } = await this.runtime.evaluate(normalized.session, true, observation);
+        Object.assign(detail, { status, resume });
+        return { ...interactionSession, observation };
+    }
+    getInteractionSession(id) {
+        return this.#interactionSessions.getInteractionSession(id);
+    }
+}
+//# 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/application/session-response.js

@@ -0,0 +1,11 @@
+import { reconcileSessionState } from "../interaction/reconcile-session-state.js";
+import { withUpdateRevision } from "../updates/update-revision.js";
+/** Assemble public reader state from one source snapshot and its runtime observation. */
+export async function assembleSessionResponse(input, interaction, revision) {
+    const { interactionSession, ...response } = input;
+    const description = interaction
+        ? await interaction.describeSnapshot(input.session.id, interactionSession)
+        : { supported: false, attachCommand: null };
+    return withUpdateRevision(reconcileSessionState({ ...response, interaction: description }), revision);
+}
+//# sourceMappingURL=session-response.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