@someonegg/agent-hub 0.0.0-stage → 0.7.0

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

@@ -0,0 +1,112 @@
+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);
+        if (this.#waiters.size >= MAX_CATALOG_WAITERS)
+            throw new CatalogCapacityError("Too many catalog requests are waiting; retry shortly");
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const cleanup = () => {
+                settled = true;
+                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) => {
+                    if (!settled) {
+                        cleanup();
+                        resolve(result);
+                    }
+                },
+                fail: (reason) => {
+                    if (!settled) {
+                        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 });
+            void this.#read().then((initial) => {
+                if (settled)
+                    return;
+                if (initial.revision !== after)
+                    waiter.finish(initial);
+                else
+                    this.#schedule();
+            }, waiter.fail);
+        });
+    }
+    #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/cli/command-error.js

@@ -0,0 +1,27 @@
+export class CommandError extends Error {
+    code;
+    exitCode;
+    diagnostics;
+    constructor(code, message, exitCode = 1, diagnostics) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.diagnostics = diagnostics;
+    }
+}
+export function commandFailure(error, mutationSubmitted) {
+    if (error instanceof CommandError)
+        return error;
+    if (mutationSubmitted)
+        return new CommandError("operation_result_unknown", "Operation result unknown; the backend operation was not retried or canceled. Use list, inspect, or terminal to check the current state.", 2);
+    return new CommandError("query_failed", `Query failed: ${error instanceof Error ? error.message : String(error)}`);
+}
+export function httpFailure(status, method, error, mutationSubmitted) {
+    const unknown = (mutationSubmitted && (method === "GET" || error?.code === "operation_result_unknown")) ||
+        (status >= 500 && method !== "GET" && error?.code !== "interaction_failed");
+    if (unknown)
+        return new CommandError("operation_result_unknown", error?.message ??
+            "Operation result unknown; use list, inspect, or terminal to check the current state.", 2);
+    return new CommandError(error?.code === "after_out_of_range" ? error.code : "request_failed", error?.message ?? `HTTP ${status}`);
+}
+//# sourceMappingURL=command-error.js.map

package/dist/server/server/cli/main.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { packageVersion } from "../version.js";
+import { CommandError } from "./command-error.js";
+import { outputFailure } from "./output.js";
+const help = `Usage: ahub-cli <command> [options]
+  page      Publish, list, or delete local hosted pages
+  diff      Publish, list, or delete local review diffs
+  skill     Locate bundled skills
+  session   Manage sessions through an existing Hub HTTP server
+  version   Show the current version (alias: --version)
+Run ahub-cli <command> --help for details.`;
+async function main() {
+    const [command, ...args] = process.argv.slice(2);
+    if (!command || command === "--help") {
+        console.log(help);
+        return;
+    }
+    if (command === "version" || command === "--version") {
+        if (args.length > 0)
+            throw new CommandError("invalid_arguments", "Usage: ahub-cli version");
+        console.log(await packageVersion());
+    }
+    else if (command === "skill") {
+        const { runSkillCommand } = await import("./skill.js");
+        await runSkillCommand(args);
+    }
+    else if (command === "session") {
+        const { runSessionCommand } = await import("./session.js");
+        await runSessionCommand(args);
+    }
+    else if (command === "page" || command === "diff") {
+        const { runResourceCommand } = await import("./resource.js");
+        await runResourceCommand(command, args[0], args.slice(1));
+    }
+    else {
+        throw new CommandError("invalid_arguments", `Unknown command: ${command}\n${help}`);
+    }
+}
+main().catch((error) => {
+    outputFailure(error, process.argv.slice(2).includes("--json"));
+});
+//# sourceMappingURL=main.js.map

package/dist/server/server/cli/output.js

@@ -0,0 +1,52 @@
+import stringWidth from "string-width";
+import { ResourceValidationError } from "../hosting/validation-error.js";
+import { CommandError } from "./command-error.js";
+export function singleLine(value) {
+    return value.replace(/[\r\n\t]/g, " ");
+}
+// Keep complete values (especially opaque IDs and URLs) and use deterministic
+// widths for both terminals and redirected output. Ambiguous characters are narrow.
+export function formatTable(headers, rows) {
+    const lines = [headers, ...rows].map((row) => row.map(singleLine));
+    const widths = headers.map((_, column) => lines.reduce((width, row) => Math.max(width, stringWidth(row[column] ?? "")), 0));
+    return lines
+        .map((row) => row
+        .map((cell, column) => column === headers.length - 1
+        ? cell
+        : cell + " ".repeat(widths[column] - stringWidth(cell) + 2))
+        .join("")
+        .trimEnd())
+        .join("\n");
+}
+export function formatTmux(target) {
+    if (!target)
+        return "unknown";
+    return singleLine(`${target.socketPath} ${target.sessionName}`);
+}
+export function output(result, json, human) {
+    console.log(json ? JSON.stringify(result) : human);
+}
+export function outputFailure(error, json) {
+    let failure;
+    if (error instanceof CommandError) {
+        failure = error;
+    }
+    else {
+        const code = error instanceof ResourceValidationError ? "invalid_arguments" : "command_failed";
+        const message = error instanceof Error ? error.message : "Command failed";
+        failure = new CommandError(code, message);
+    }
+    if (json)
+        console.log(JSON.stringify({
+            error: { code: failure.code, message: failure.message, ...failure.diagnostics },
+        }));
+    else {
+        const lines = [failure.message];
+        if (failure.diagnostics) {
+            lines.push(`Session: ${failure.diagnostics.sessionId ?? "unknown"}`, `Tmux: ${formatTmux(failure.diagnostics.tmux)}`);
+        }
+        console.error(lines.join("\n"));
+    }
+    process.exitCode = failure.exitCode;
+}
+//# sourceMappingURL=output.js.map

package/dist/server/server/cli/resource.js

@@ -0,0 +1,104 @@
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { resolveHomeDirectory } from "../config.js";
+import { DiffStore } from "../hosting/diff-store.js";
+import { HostingStore } from "../hosting/store.js";
+import { CommandError } from "./command-error.js";
+import { formatTable, output } from "./output.js";
+function resourceHelp(resource) {
+    const publishUsage = resource === "page"
+        ? "page publish <directory> --project <directory> [--name <name>]"
+        : `${resource} publish <file>`;
+    return `Usage: ahub-cli ${resource} <command> [options]
+  ${publishUsage} [--title <title>]
+  ${resource} list
+  ${resource} delete <id>
+Options: --home-dir <directory> --json --help
+Commands operate on local Hub storage (default: ~/.agent-hub).`;
+}
+export async function runResourceCommand(resource, action, args) {
+    const { values, positionals, help } = parseResourceArguments(resource, action, args);
+    if (help) {
+        console.log(resourceHelp(resource));
+        return;
+    }
+    const directory = join(resolveHomeDirectory(values["home-dir"]), "hosting");
+    const pages = new HostingStore(directory);
+    const diffs = new DiffStore(directory);
+    if (action === "publish") {
+        validateResourcePublish(resource, values.project);
+        const entry = resource === "page"
+            ? await pages.publish(positionals[0], values.project, values.name, values.title)
+            : await diffs.publish(positionals[0], values.title);
+        const title = entry.title.replace(/[\\[\]]/g, "\\$&").replace(/[\r\n]/g, " ");
+        console.log(values.json ? JSON.stringify(entry) : `${entry.url}\n[${title}](${entry.url})`);
+        return;
+    }
+    if (action === "list") {
+        const entries = resource === "page"
+            ? (await pages.entries()).map(({ artifact }) => artifact)
+            : await diffs.list();
+        output(entries, values.json ?? false, formatResourceList(resource, entries));
+        return;
+    }
+    if (resource === "page")
+        await pages.delete(positionals[0]);
+    else
+        await diffs.delete(positionals[0]);
+    output({ id: positionals[0], deleted: true }, values.json ?? false, `Deleted ${resource} ${positionals[0]}`);
+}
+function formatResourceList(resource, entries) {
+    const table = formatTable(resource === "page" ? ["ID", "PROJECT", "TITLE", "URL"] : ["ID", "TITLE", "URL"], entries.map((entry) => [
+        entry.id,
+        ...(resource === "page" ? [entry.project ?? ""] : []),
+        entry.title,
+        entry.url,
+    ]));
+    return table + (entries.length ? "" : `\nNo ${resource === "page" ? "pages" : "diffs"}.`);
+}
+function parseResourceArgs(args) {
+    try {
+        return parseArgs({
+            args,
+            allowPositionals: true,
+            options: {
+                project: { type: "string" },
+                name: { type: "string" },
+                title: { type: "string" },
+                "home-dir": { type: "string" },
+                json: { type: "boolean" },
+                help: { type: "boolean" },
+            },
+        });
+    }
+    catch (error) {
+        throw new CommandError("invalid_arguments", error instanceof Error ? error.message : "Invalid arguments");
+    }
+}
+export function parseResourceArguments(resource, action, args) {
+    const { values, positionals } = parseResourceArgs(args);
+    if (values.help || action === "--help" || action === undefined) {
+        return { values, positionals, help: true };
+    }
+    if (!["publish", "list", "delete"].includes(action) ||
+        positionals.length !== (action === "list" ? 0 : 1))
+        throw new CommandError("invalid_arguments", "Expected page/diff publish <source>, list, or delete <id>");
+    const allowed = new Set(["home-dir", "json", "help"]);
+    if (action === "publish") {
+        allowed.add("title");
+        if (resource === "page") {
+            allowed.add("project");
+            allowed.add("name");
+        }
+    }
+    for (const option of Object.keys(values)) {
+        if (!allowed.has(option))
+            throw new CommandError("invalid_arguments", `Option --${option} is not supported for ${resource} ${action}`);
+    }
+    return { values, positionals, help: false };
+}
+export function validateResourcePublish(resource, project) {
+    if (resource === "page" && !project)
+        throw new CommandError("invalid_arguments", "page publish requires --project");
+}
+//# sourceMappingURL=resource.js.map

package/dist/server/server/cli/session-client.js

@@ -0,0 +1,64 @@
+import { request } from "node:http";
+import { request as secureRequest } from "node:https";
+import { CommandError, httpFailure } from "./command-error.js";
+/** Invocation-scoped HTTP state; submitted writes are never retried. */
+export class SessionClient {
+    base;
+    signal;
+    mutationSubmitted = false;
+    constructor(base, signal) {
+        this.base = base;
+        this.signal = signal;
+    }
+    request = async (path, method = "GET", body) => {
+        if (this.signal.aborted)
+            throw new Error("Command interrupted or timed out");
+        const payload = body === undefined ? undefined : JSON.stringify(body);
+        return new Promise((accept, reject) => {
+            const sendRequest = this.base.protocol === "https:" ? secureRequest : request;
+            const req = sendRequest(new URL(path, this.base), {
+                method,
+                signal: this.signal,
+                headers: payload === undefined
+                    ? {}
+                    : {
+                        "Content-Type": "application/json",
+                        "Content-Length": Buffer.byteLength(payload),
+                    },
+            }, (res) => {
+                const chunks = [];
+                res.on("data", (chunk) => chunks.push(chunk));
+                res.on("error", reject);
+                res.on("end", () => {
+                    try {
+                        const text = Buffer.concat(chunks).toString("utf8");
+                        const data = text ? JSON.parse(text) : undefined;
+                        const status = res.statusCode ?? 500;
+                        if (status >= 400) {
+                            reject(httpFailure(status, method, data?.error, this.mutationSubmitted));
+                        }
+                        else
+                            accept(data);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+            req.on("error", reject);
+            if (method !== "GET")
+                this.mutationSubmitted = true;
+            req.end(payload);
+        });
+    };
+}
+/** Reset an invalidated message cursor before the caller's single recovery attempt. */
+export function recoverMessageQuery(error, query) {
+    if (!(error instanceof CommandError) || error.code !== "after_out_of_range")
+        return false;
+    query.set("after", "0");
+    query.delete("stateRevision");
+    query.delete("wait");
+    return true;
+}
+//# sourceMappingURL=session-client.js.map

package/dist/server/server/cli/session-follow.js

@@ -0,0 +1,58 @@
+import { CommandError } from "./command-error.js";
+import { output } from "./output.js";
+import { recoverMessageQuery, SessionClient } from "./session-client.js";
+import { formatResult, mapInspect } from "./session-output.js";
+/** Each round drains backlog before the next bounded tail wait. */
+export async function followInspect(options) {
+    const { path, query, base, signal, timeoutMs, count, json } = options;
+    let previousState;
+    let emitted = false;
+    let recovered = false;
+    for (let round = 0; count === undefined || round < count; round++) {
+        for (;;) {
+            signal.throwIfAborted();
+            const controller = new AbortController();
+            const stop = () => controller.abort();
+            signal.addEventListener("abort", stop, { once: true });
+            const timer = setTimeout(stop, timeoutMs);
+            let observed;
+            try {
+                const client = new SessionClient(base, controller.signal);
+                observed = await client.request(`${path}/messages?${query}`);
+            }
+            catch (error) {
+                if (!recovered && recoverMessageQuery(error, query)) {
+                    recovered = true;
+                    continue;
+                }
+                throw error;
+            }
+            finally {
+                clearTimeout(timer);
+                signal.removeEventListener("abort", stop);
+            }
+            if (!observed)
+                break;
+            query.set("stateRevision", observed.stateRevision);
+            const result = mapInspect(observed);
+            const { updatedAt, ...sessionState } = result.session;
+            const state = JSON.stringify([sessionState, result.interaction]);
+            if (!emitted || result.items.length > 0 || previousState !== state) {
+                const text = formatResult("inspect", result, { emptyItemsText: "No new messages." });
+                output(result, json, (emitted ? "========================================\n" : "") + text);
+                emitted = true;
+            }
+            previousState = state;
+            const after = query.get("after");
+            if (result.hasMore && result.nextAfter <= Number(after ?? 0))
+                throw new CommandError("pagination_stalled", "Inspect pagination made no progress");
+            query.set("after", String(result.nextAfter));
+            if (!result.hasMore) {
+                query.set("wait", "true");
+                break;
+            }
+            query.delete("wait");
+        }
+    }
+}
+//# sourceMappingURL=session-follow.js.map

package/dist/server/server/cli/session-output.js

@@ -0,0 +1,184 @@
+import { formatTable, formatTmux, singleLine } from "./output.js";
+export function mapList(list, project, includeArchived = false) {
+    return {
+        sessions: list.sessions
+            .filter((s) => !s.isChild && (includeArchived || s.status !== "archived"))
+            .map((s) => ({
+            id: s.id,
+            title: s.title,
+            status: s.status,
+            agent: s.agent,
+            projectDirectory: s.projectDirectory,
+            ...(s.taskName ? { taskName: s.taskName } : {}),
+            updatedAt: s.updatedAt,
+        }))
+            .filter((s) => project === undefined || s.projectDirectory === project),
+    };
+}
+function inputHint(sessionId) {
+    return `Wait for connected and idle, then run session terminal ${sessionId} to check the current prompt and session keys ${sessionId} <key...> to select.`;
+}
+export function mapInspect(value) {
+    const s = value.session;
+    const i = value.interaction;
+    return {
+        session: {
+            id: s.id,
+            title: s.title,
+            status: s.status,
+            agent: s.origin.agent,
+            runtimeName: s.origin.runtimeName,
+            workingDirectory: s.workingDirectory,
+            projectDirectory: s.projectDirectory,
+            ...(s.taskName ? { taskName: s.taskName } : {}),
+            createdAt: s.createdAt,
+            updatedAt: s.updatedAt,
+            resume: { allowed: s.resume.allowed, reason: s.resume.reason },
+        },
+        interaction: i.supported
+            ? {
+                supported: true,
+                tmux: i.tmux
+                    ? {
+                        socketPath: i.tmux.socketPath,
+                        sessionName: i.tmux.sessionName,
+                    }
+                    : null,
+                state: i.state,
+                activity: i.activity,
+                supersededBySessionId: i.supersededBySessionId,
+            }
+            : { supported: false, tmux: null },
+        items: value.items.flatMap((item) => {
+            const base = { id: item.id, ordinal: item.ordinal, timestamp: item.timestamp };
+            if (item.kind === "message")
+                return [
+                    {
+                        ...base,
+                        kind: "message",
+                        role: item.role,
+                        phase: item.phase,
+                        itemType: item.itemType,
+                        markdown: item.markdown,
+                        ...(item.role === "assistant" && item.phase === "response" && item.itemType === "plan"
+                            ? { inputHint: inputHint(s.id) }
+                            : {}),
+                    },
+                ];
+            if (item.kind !== "user_input")
+                return [];
+            const input = { ...base, kind: "user_input" };
+            if (item.stage === "request")
+                return [
+                    {
+                        ...input,
+                        stage: "request",
+                        questions: item.questions.map((question) => ({
+                            header: question.header,
+                            question: question.question,
+                            options: question.options.map((option) => ({
+                                label: option.label,
+                                description: option.description,
+                            })),
+                        })),
+                        inputHint: inputHint(s.id),
+                    },
+                ];
+            if (item.outcome === "answered")
+                return [
+                    {
+                        ...input,
+                        stage: "response",
+                        outcome: "answered",
+                        answers: item.answers.flatMap((a) => a.answers),
+                    },
+                ];
+            if (item.outcome === "unavailable")
+                return [{ ...input, stage: "response", outcome: "unavailable", summary: item.summary }];
+            if (item.outcome === "aborted")
+                return [{ ...input, stage: "response", outcome: "aborted" }];
+            return [];
+        }),
+        nextAfter: value.nextAfter,
+        hasMore: value.hasMore,
+    };
+}
+export function mapTerminal(s) {
+    return { content: s.content, truncated: s.truncated, capturedAt: s.capturedAt };
+}
+export function formatResult(command, result, options = {}) {
+    if ("content" in result)
+        return `${singleLine(result.capturedAt)}${result.truncated ? " (truncated)" : ""}\n${result.content}`;
+    if ("sessions" in result) {
+        const showTask = result.sessions.some((s) => Boolean(s.taskName));
+        return (formatTable(["ID", "STATUS", "AGENT", "PROJECT", ...(showTask ? ["TASK"] : []), "TITLE"], result.sessions.map((s) => [
+            s.id,
+            s.status,
+            s.agent ?? "",
+            s.projectDirectory ?? "",
+            ...(showTask ? [s.taskName ?? ""] : []),
+            s.title,
+        ])) + (result.sessions.length ? "" : "\nNo sessions."));
+    }
+    if (!("session" in result)) {
+        const lines = [`${command} ${singleLine(String(result.sessionId))}: ${result.status}`];
+        if (result.tmux)
+            lines.push(`Tmux: ${formatTmux(result.tmux)}`);
+        return lines.join("\n");
+    }
+    return formatInspect(result, options.emptyItemsText ?? "No visible items.");
+}
+function formatInspect(result, emptyItemsText) {
+    const { session, interaction } = result;
+    const summary = [
+        `Session: ${session.id}`,
+        `Title: ${session.title}`,
+        `Status: ${session.status}`,
+        `Interaction: ${interaction.supported ? interaction.state : "unsupported"}`,
+    ];
+    if (interaction.supported) {
+        if (interaction.tmux)
+            summary.push(`Tmux: ${formatTmux(interaction.tmux)}`);
+        summary.push(`Activity: ${interaction.activity ?? "unknown"}`);
+        if (interaction.supersededBySessionId)
+            summary.push(`Superseded by: ${interaction.supersededBySessionId}`);
+    }
+    summary.push(`Agent: ${session.agent ?? ""}`, `Project: ${session.projectDirectory ?? ""}`, ...(session.taskName ? [`Task: ${session.taskName}`] : []), `Working directory: ${session.workingDirectory ?? ""}`);
+    const header = summary.map(singleLine).join("\n");
+    const items = result.items.map(formatHistoryItem).join("\n\n");
+    return `${header}\n\n${items || emptyItemsText}\n\nNext after: ${result.nextAfter}\nHas more: ${result.hasMore ? "yes" : "no"}`;
+}
+function formatHistoryItem(item) {
+    if (item.kind === "message") {
+        const phase = [item.phase, item.itemType].filter(Boolean).join(" · ");
+        const title = `--- #${item.ordinal} ${item.role === "assistant" ? "Assistant" : "User"}${phase ? ` · ${singleLine(phase)}` : ""} ---`;
+        const body = item.inputHint ? `${item.markdown}\n\n${item.inputHint}` : item.markdown;
+        return `${title}\n${body}`;
+    }
+    if (item.stage === "request") {
+        const questions = item.questions
+            .map((question) => [
+            question.header,
+            question.question,
+            ...question.options.map((option, index) => `${index + 1}. ${option.label}\n   ${option.description}`),
+        ].join("\n"))
+            .join("\n\n");
+        return [`--- #${item.ordinal} Question ---`, questions, item.inputHint]
+            .filter(Boolean)
+            .join("\n\n");
+    }
+    let body;
+    switch (item.outcome) {
+        case "answered":
+            body = item.answers.map((answer) => `- ${answer}`).join("\n");
+            break;
+        case "aborted":
+            body = "Cancelled.";
+            break;
+        case "unavailable":
+            body = `Unavailable: ${item.summary}`;
+            break;
+    }
+    return `--- #${item.ordinal} Answer ---\n${body}`;
+}
+//# sourceMappingURL=session-output.js.map