@someonegg/agent-hub 0.0.0-stage → 0.7.0

package/dist/server/server/management/session-manager.js

@@ -0,0 +1,64 @@
+import { validProjectDirectory } from "../domain/project-directory.js";
+/** Time before startup needs terminal access, including adapter prompt readiness. */
+export const LAUNCH_ATTACH_DELAY_MS = 30_000;
+/** A launch failure records whether a process may already be running. */
+export class SessionLaunchError extends Error {
+    outcome;
+    attachCommand;
+    target;
+    constructor(outcome, message, attachCommand = null, target) {
+        super(message);
+        this.outcome = outcome;
+        this.attachCommand = attachCommand;
+        this.target = target;
+    }
+}
+export class SessionManagerRegistry {
+    defaultAgent;
+    #managers = new Map();
+    constructor(defaultAgent) {
+        this.defaultAgent = defaultAgent;
+    }
+    register(agent, manager) {
+        if (!agent.trim())
+            throw new Error("Empty agent nickname");
+        if (this.#managers.has(agent))
+            throw new Error(`Duplicate agent nickname: ${agent}`);
+        this.#managers.set(agent, manager);
+        return this;
+    }
+    resolveCreateAgent(agent) {
+        const selected = agent ?? this.defaultAgent;
+        if (!this.#managers.has(selected))
+            throw new Error("Unknown agent nickname");
+        return selected;
+    }
+    get(agent) {
+        const manager = this.#managers.get(agent);
+        if (!manager) {
+            throw new Error(`Session source has no management capability: ${agent}`);
+        }
+        return manager;
+    }
+}
+export async function resolveResumeDirectory(manager, session) {
+    for (const candidate of new Set([session.workingDirectory, session.projectDirectory])) {
+        if (!validProjectDirectory(candidate))
+            continue;
+        try {
+            return await manager.resolveDirectory(candidate);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT" && code !== "ENOTDIR")
+                throw error;
+        }
+    }
+    throw new Error("Session has no available working or project directory");
+}
+export function managementCapabilities(manager) {
+    return {
+        archive: typeof manager.archive === "function",
+    };
+}
+//# sourceMappingURL=session-manager.js.map

package/dist/server/server/repository/catalog-snapshot-store.js

@@ -0,0 +1,318 @@
+import { encodeStringTuple, opaqueIdForParts } from "../security/opaque-id.js";
+import { RefreshDiagnosticLogger, } from "./diagnostic-logger.js";
+import { RefreshCoordinator } from "./refresh-coordinator.js";
+export const DEFAULT_CATALOG_FRESHNESS_MS = 1_500;
+export const MAX_CATALOG_DIAGNOSTICS = 50;
+export class CatalogSnapshotStore {
+    freshnessMs;
+    now;
+    #coordinator = new RefreshCoordinator();
+    #diagnosticLogger;
+    #sources;
+    #snapshot = null;
+    #observedSources = new Map();
+    #pendingBindings = new Map();
+    #publishBindings;
+    #aggregate = null;
+    #aggregateDiagnostics = new Map();
+    #lastDiscoveryAt = Number.NEGATIVE_INFINITY;
+    constructor(sources, freshnessMs = DEFAULT_CATALOG_FRESHNESS_MS, now = performance.now.bind(performance), dependencies = {}) {
+        this.freshnessMs = freshnessMs;
+        this.now = now;
+        assertUniqueSources(sources);
+        this.#publishBindings = dependencies.publishBindings ?? (() => { });
+        this.#diagnosticLogger = new RefreshDiagnosticLogger(dependencies.diagnosticLogger);
+        this.#sources = [...sources];
+    }
+    async current() {
+        const snapshot = this.#snapshot;
+        if (snapshot !== null && this.now() - this.#lastDiscoveryAt < this.freshnessMs) {
+            return snapshot;
+        }
+        return this.#coordinator.run(() => this.#discover());
+    }
+    async refresh() {
+        return this.#coordinator.run(() => this.#discover());
+    }
+    async #discover() {
+        const snapshot = await this.#rebuild();
+        const bindings = [...this.#pendingBindings].flatMap(([source, events]) => [...events].map(({ localId, ...event }) => ({
+            ...event,
+            sessionId: opaqueIdForParts(source.descriptor.instanceKey, localId),
+        })));
+        this.#publishBindings(bindings);
+        this.#pendingBindings.clear();
+        this.#lastDiscoveryAt = this.now();
+        return snapshot;
+    }
+    async #rebuild() {
+        // Wait for every source even on failure, so retries cannot overlap an unfinished refresh.
+        const results = await Promise.allSettled(this.#sources.map(async (source) => {
+            const snapshot = await source.refresh();
+            if (this.#observedSources.get(source) !== snapshot) {
+                const pending = this.#pendingBindings.get(source) ?? new Set();
+                for (const event of snapshot.bindings ?? [])
+                    pending.add(event);
+                this.#pendingBindings.set(source, pending);
+                this.#observedSources.set(source, snapshot);
+            }
+            return { descriptor: source.descriptor, snapshot };
+        }));
+        const loadedSources = results.map((result) => {
+            if (result.status === "rejected")
+                throw result.reason;
+            return result.value;
+        });
+        const signature = aggregateSignature(loadedSources);
+        const previous = this.#snapshot;
+        if (previous?.signature === signature) {
+            this.#diagnosticLogger.update(loadedSources, this.#aggregateDiagnostics);
+            return previous;
+        }
+        const sourceDiagnostics = [];
+        for (const { snapshot } of loadedSources) {
+            if (sourceDiagnostics.length >= MAX_CATALOG_DIAGNOSTICS)
+                break;
+            for (const item of snapshot.diagnostics) {
+                if (sourceDiagnostics.length >= MAX_CATALOG_DIAGNOSTICS)
+                    break;
+                sourceDiagnostics.push({ ...item });
+            }
+        }
+        const linked = linkRelationships(loadedSources, this.#aggregate, MAX_CATALOG_DIAGNOSTICS - sourceDiagnostics.length);
+        const diagnostics = [...sourceDiagnostics, ...linked.diagnostics];
+        const normalizedSessions = linked.sessions;
+        const snapshot = {
+            signature,
+            diagnostics,
+            sessions: normalizedSessions,
+        };
+        this.#aggregate = {
+            inputs: linked.inputs,
+            nativeBuckets: linked.nativeBuckets,
+            parentNativeDependents: linked.parentNativeDependents,
+            resolvedParents: linked.resolvedParents,
+            sessions: normalizedSessions,
+        };
+        this.#snapshot = snapshot;
+        this.#aggregateDiagnostics = linked.aggregateDiagnostics;
+        this.#diagnosticLogger.update(loadedSources, linked.aggregateDiagnostics);
+        return snapshot;
+    }
+}
+function assertUniqueSources(sources) {
+    for (const field of ["instanceKey", "agent"]) {
+        const keys = new Set();
+        for (const { descriptor } of sources) {
+            const key = descriptor[field];
+            if (!key.trim())
+                throw new Error(`Empty session source ${field}`);
+            if (keys.has(key)) {
+                const label = field === "instanceKey" ? "instance key" : field;
+                throw new Error(`Duplicate session source ${label}: ${key}`);
+            }
+            keys.add(key);
+        }
+    }
+}
+function aggregateSignature(sources) {
+    return JSON.stringify([...sources]
+        .sort((left, right) => left.descriptor.instanceKey.localeCompare(right.descriptor.instanceKey))
+        .map(({ descriptor, snapshot }) => ({
+        source: descriptor.instanceKey,
+        signature: snapshot.signature,
+    })));
+}
+function linkRelationships(sources, previous, diagnosticLimit) {
+    const diagnostics = [];
+    const aggregateDiagnostics = new Map();
+    const inputs = new Map();
+    const nativeBuckets = new Map();
+    const parentNativeDependents = new Map();
+    for (const { descriptor, snapshot } of sources) {
+        const localIds = new Set();
+        for (const entry of snapshot.sessions) {
+            if (localIds.has(entry.localId)) {
+                const diagnostic = {
+                    code: "duplicate_source_session_id",
+                    severity: "error",
+                    message: "A source returned duplicate stable session identities.",
+                    ordinal: null,
+                };
+                if (diagnostics.length < diagnosticLimit)
+                    diagnostics.push(diagnostic);
+                const group = aggregateDiagnostics.get(descriptor.agent) ?? [];
+                const sessionId = opaqueIdForParts(descriptor.instanceKey, entry.localId);
+                if (group.length < MAX_CATALOG_DIAGNOSTICS &&
+                    !group.some((item) => item.sessionId === sessionId)) {
+                    group.push({ sessionId, diagnostic });
+                    aggregateDiagnostics.set(descriptor.agent, group);
+                }
+                continue;
+            }
+            localIds.add(entry.localId);
+            const id = opaqueIdForParts(descriptor.instanceKey, entry.localId);
+            const input = {
+                descriptor,
+                id,
+                nativeSessionId: entry.nativeSessionId,
+                parentNativeSessionId: entry.parentNativeSessionId,
+                origin: entry.origin,
+                normalized: entry.normalized,
+            };
+            inputs.set(id, input);
+            if (entry.nativeSessionId !== null) {
+                const nativeKey = identityKey(descriptor.instanceKey, entry.nativeSessionId);
+                const bucket = nativeBuckets.get(nativeKey);
+                if (bucket === undefined)
+                    nativeBuckets.set(nativeKey, [id]);
+                else
+                    bucket.push(id);
+            }
+            if (entry.parentNativeSessionId !== null) {
+                const parentKey = identityKey(descriptor.instanceKey, entry.parentNativeSessionId);
+                const dependents = parentNativeDependents.get(parentKey);
+                if (dependents === undefined) {
+                    parentNativeDependents.set(parentKey, new Set([id]));
+                }
+                else {
+                    dependents.add(id);
+                }
+            }
+        }
+    }
+    const resolvedParents = new Map();
+    const children = new Map();
+    for (const item of inputs.values()) {
+        const parentId = item.parentNativeSessionId === null
+            ? null
+            : uniqueIdentity(nativeBuckets.get(identityKey(item.descriptor.instanceKey, item.parentNativeSessionId)));
+        resolvedParents.set(item.id, parentId);
+        if (parentId !== null) {
+            const childIds = children.get(parentId);
+            if (childIds === undefined)
+                children.set(parentId, [item.id]);
+            else
+                childIds.push(item.id);
+        }
+    }
+    const dirtyIds = findDirtyIds(inputs, nativeBuckets, parentNativeDependents, resolvedParents, previous);
+    const sessions = new Map();
+    for (const [id, item] of inputs) {
+        const cached = previous?.sessions.get(id);
+        if (cached !== undefined && !dirtyIds.has(id)) {
+            sessions.set(id, cached);
+            continue;
+        }
+        const source = item.normalized.session;
+        sessions.set(id, {
+            session: {
+                ...source,
+                id,
+                sourceId: item.nativeSessionId,
+                origin: {
+                    ...item.origin,
+                    sourceType: item.descriptor.sourceType,
+                    agent: item.descriptor.agent,
+                    runtimeName: item.descriptor.displayName,
+                },
+                isChild: item.parentNativeSessionId !== null,
+                parentId: resolvedParents.get(id) ?? null,
+                childIds: [...(children.get(id) ?? [])].sort(compareCodeUnits),
+            },
+            timeline: item.normalized.timeline,
+            interaction: item.normalized.interaction ?? null,
+        });
+    }
+    return {
+        sessions,
+        diagnostics,
+        aggregateDiagnostics,
+        dirtyIds,
+        inputs,
+        nativeBuckets,
+        parentNativeDependents,
+        resolvedParents,
+    };
+}
+function findDirtyIds(inputs, nativeBuckets, parentNativeDependents, resolvedParents, previous) {
+    const dirty = new Set();
+    if (previous === null) {
+        for (const id of inputs.keys())
+            dirty.add(id);
+        return dirty;
+    }
+    for (const [id, input] of inputs) {
+        const oldInput = previous.inputs.get(id);
+        // SourceSessionEntry wrappers may be rebuilt on every refresh. The Codex
+        // adapter reuses unchanged immutable NormalizedSession objects, so identity
+        // is only a safe optimization hint: a new object means "recompute", never
+        // that the public revision must change. The final-view digest decides that.
+        if (oldInput === undefined || !sameSourceInput(oldInput, input)) {
+            dirty.add(id);
+        }
+        const oldParent = previous.resolvedParents.get(id) ?? null;
+        const newParent = resolvedParents.get(id) ?? null;
+        if (oldInput === undefined || oldParent !== newParent) {
+            dirty.add(id);
+            if (oldParent !== null && inputs.has(oldParent))
+                dirty.add(oldParent);
+            if (newParent !== null)
+                dirty.add(newParent);
+        }
+    }
+    for (const [id] of previous.inputs) {
+        if (inputs.has(id))
+            continue;
+        const oldParent = previous.resolvedParents.get(id) ?? null;
+        if (oldParent !== null && inputs.has(oldParent))
+            dirty.add(oldParent);
+    }
+    const identityKeys = new Set([...previous.nativeBuckets.keys(), ...nativeBuckets.keys()]);
+    for (const key of identityKeys) {
+        if (uniqueIdentity(previous.nativeBuckets.get(key)) === uniqueIdentity(nativeBuckets.get(key))) {
+            continue;
+        }
+        const dependents = new Set([
+            ...(previous.parentNativeDependents.get(key) ?? []),
+            ...(parentNativeDependents.get(key) ?? []),
+        ]);
+        for (const id of dependents) {
+            if (!inputs.has(id))
+                continue;
+            dirty.add(id);
+            const oldParent = previous.resolvedParents.get(id) ?? null;
+            const newParent = resolvedParents.get(id) ?? null;
+            if (oldParent !== null && inputs.has(oldParent))
+                dirty.add(oldParent);
+            if (newParent !== null)
+                dirty.add(newParent);
+        }
+    }
+    return dirty;
+}
+function sameSourceInput(left, right) {
+    return (left.normalized === right.normalized &&
+        left.nativeSessionId === right.nativeSessionId &&
+        left.parentNativeSessionId === right.parentNativeSessionId &&
+        sameOrigin(left.origin, right.origin) &&
+        left.descriptor.sourceType === right.descriptor.sourceType &&
+        left.descriptor.agent === right.descriptor.agent &&
+        left.descriptor.displayName === right.descriptor.displayName);
+}
+function sameOrigin(left, right) {
+    return (left.sourceType === right.sourceType &&
+        left.agent === right.agent &&
+        left.runtimeName === right.runtimeName &&
+        left.runtimeVersion === right.runtimeVersion);
+}
+function uniqueIdentity(bucket) {
+    return bucket?.length === 1 ? bucket[0] : null;
+}
+function identityKey(sourceKey, nativeId) {
+    return encodeStringTuple(sourceKey, nativeId);
+}
+function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+//# sourceMappingURL=catalog-snapshot-store.js.map

package/dist/server/server/repository/diagnostic-logger.js

@@ -0,0 +1,70 @@
+import { opaqueIdForParts } from "../security/opaque-id.js";
+const stderrLogger = {
+    log(record) {
+        console.error("Session diagnostic", record);
+    },
+};
+/** Refresh-only state: bounded by the current sources and sessions. */
+export class RefreshDiagnosticLogger {
+    logger;
+    #sources = new Map();
+    constructor(logger = stderrLogger) {
+        this.logger = logger;
+    }
+    update(sources, aggregates = new Map()) {
+        const next = new Map();
+        for (const { descriptor, snapshot } of sources) {
+            const agent = descriptor.agent;
+            const previous = this.#sources.get(agent);
+            if (previous?.snapshot === snapshot) {
+                next.set(agent, previous);
+                continue;
+            }
+            const diagnostics = new Map();
+            const record = (key, items, scope, sessionId) => {
+                const prior = previous?.diagnostics.get(key);
+                if (prior?.reference === items) {
+                    diagnostics.set(key, prior);
+                    return;
+                }
+                const signatures = new Set();
+                for (const item of items.slice(0, 50)) {
+                    const signature = JSON.stringify([item.severity, item.code, item.message, item.ordinal]);
+                    if (!signatures.has(signature) && !prior?.signatures.has(signature)) {
+                        try {
+                            this.logger.log({
+                                agent,
+                                sessionId,
+                                scope,
+                                severity: item.severity,
+                                code: item.code,
+                                message: item.message,
+                                ordinal: item.ordinal,
+                            });
+                        }
+                        catch {
+                            /* Logging must never affect reading or management. */
+                        }
+                    }
+                    signatures.add(signature);
+                }
+                diagnostics.set(key, { reference: items, signatures });
+            };
+            record("source", snapshot.diagnostics, "source", null);
+            const ids = new Set();
+            for (const entry of snapshot.sessions) {
+                const sessionId = opaqueIdForParts(descriptor.instanceKey, entry.localId);
+                if (ids.has(entry.localId))
+                    continue;
+                record(`session:${sessionId}`, entry.normalized.session.diagnostics, "session", sessionId);
+                ids.add(entry.localId);
+            }
+            for (const { sessionId, diagnostic } of aggregates.get(agent) ?? []) {
+                record(`aggregate:${sessionId}`, [diagnostic], "aggregate", sessionId);
+            }
+            next.set(agent, { snapshot, diagnostics });
+        }
+        this.#sources = next;
+    }
+}
+//# sourceMappingURL=diagnostic-logger.js.map

package/dist/server/server/repository/refresh-coordinator.js

@@ -0,0 +1,14 @@
+export class RefreshCoordinator {
+    #inFlight = null;
+    run(refresh) {
+        if (this.#inFlight !== null)
+            return this.#inFlight;
+        const pending = refresh().finally(() => {
+            if (this.#inFlight === pending)
+                this.#inFlight = null;
+        });
+        this.#inFlight = pending;
+        return pending;
+    }
+}
+//# sourceMappingURL=refresh-coordinator.js.map

package/dist/server/server/repository/session-queries.js

@@ -0,0 +1,72 @@
+export const MAX_ITEM_PAGE_BYTES = 4 * 1024 * 1024;
+export class RepositoryQueryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export class SessionQueries {
+    // Published timeline records are immutable; release cached sizes with their records.
+    #itemBytes = new WeakMap();
+    session(snapshot, id) {
+        return snapshot.sessions.get(id)?.session ?? null;
+    }
+    messages(snapshot, id, query) {
+        validateItemQuery(query);
+        if (query.after !== undefined && (!Number.isSafeInteger(query.after) || query.after < 0))
+            throw new RepositoryQueryError("invalid_query", "after must be a nonnegative safe integer");
+        const normalized = snapshot.sessions.get(id);
+        if (!normalized)
+            return null;
+        const timeline = normalized.timeline;
+        const end = timeline.at(-1)?.ordinal ?? 0;
+        if ((query.after ?? 0) > end)
+            throw new RepositoryQueryError("after_out_of_range", "after exceeds the current timeline range");
+        const limit = query.limit ?? 10;
+        let start = 0;
+        if (query.after === undefined) {
+            start = Math.max(0, timeline.length - limit);
+        }
+        else {
+            let upper = timeline.length;
+            while (start < upper) {
+                const middle = start + Math.floor((upper - start) / 2);
+                if (timeline[middle].ordinal <= query.after)
+                    start = middle + 1;
+                else
+                    upper = middle;
+            }
+        }
+        const items = [];
+        let bytes = 0;
+        let index = start;
+        for (; index < timeline.length; index++) {
+            const item = timeline[index];
+            if (items.length >= limit)
+                break;
+            let itemBytes = this.#itemBytes.get(item);
+            if (itemBytes === undefined) {
+                itemBytes = Buffer.byteLength(JSON.stringify(item), "utf8");
+                this.#itemBytes.set(item, itemBytes);
+            }
+            const size = itemBytes + (items.length ? 1 : 0);
+            if (items.length > 0 && bytes + size > MAX_ITEM_PAGE_BYTES)
+                break;
+            items.push(item);
+            bytes += size;
+        }
+        return {
+            session: normalized.session,
+            items,
+            nextAfter: items.at(-1)?.ordinal ?? end,
+            hasMore: index < timeline.length,
+        };
+    }
+}
+function validateItemQuery(query) {
+    if (query.limit !== undefined &&
+        (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 300))
+        throw new RepositoryQueryError("invalid_query", "limit must be between 1 and 300");
+}
+//# sourceMappingURL=session-queries.js.map

package/dist/server/server/security/opaque-id.js

@@ -0,0 +1,17 @@
+import { createHash } from "node:crypto";
+export function encodeStringTuple(...parts) {
+    return parts.map((part) => `${part.length}:${part}`).join("");
+}
+export function opaqueIdForParts(...parts) {
+    return createHash("sha256")
+        .update(encodeStringTuple(...parts), "utf16le")
+        .digest("base64url");
+}
+export function opaqueIdForPath(path) {
+    return createHash("sha256").update(path, "utf8").digest("base64url");
+}
+export const SESSION_ID_PATTERN = "[A-Za-z0-9_-]{20,100}";
+export function isOpaqueId(value) {
+    return new RegExp(`^${SESSION_ID_PATTERN}$`).test(value);
+}
+//# sourceMappingURL=opaque-id.js.map

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

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