@someonegg/agent-hub 0.0.0-stage → 0.7.0

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

@@ -0,0 +1,44 @@
+import { CommandError } from "./command-error.js";
+export const pauseSessionPolling = (signal, milliseconds = 500) => new Promise((accept, reject) => {
+    if (signal.aborted) {
+        reject(new Error("Command interrupted or timed out"));
+        return;
+    }
+    const stop = () => {
+        clearTimeout(wait);
+        signal.removeEventListener("abort", stop);
+        reject(new Error("Command interrupted or timed out"));
+    };
+    const wait = setTimeout(() => {
+        signal.removeEventListener("abort", stop);
+        accept();
+    }, milliseconds);
+    signal.addEventListener("abort", stop, { once: true });
+});
+export async function waitForOperation(operation, api, signal, observe = () => { }) {
+    observe(operation);
+    while (operation.status === "pending") {
+        await pauseSessionPolling(signal);
+        operation = await api(`/api/v1/operations/${encodeURIComponent(operation.operationId)}`);
+        observe(operation);
+    }
+    if (operation.status === "unknown")
+        throw new CommandError("operation_result_unknown", operation.error ?? "Operation result unknown; check the current session state.", 2);
+    if (operation.status !== "succeeded")
+        throw new CommandError("operation_failed", operation.error ?? "Operation failed; check the server diagnostics.");
+    return operation;
+}
+export async function waitForLaunch(sessionId, api, signal) {
+    if (!sessionId)
+        throw new Error("Launch response has no session");
+    for (;;) {
+        const observed = await api(`/api/v1/sessions/${encodeURIComponent(sessionId)}/messages?limit=1`);
+        if (observed.session.status === "live" &&
+            observed.interaction.supported &&
+            observed.interaction.state === "connected" &&
+            observed.interaction.activity === "idle")
+            break;
+        await pauseSessionPolling(signal);
+    }
+}
+//# sourceMappingURL=session-wait.js.map

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

@@ -0,0 +1,318 @@
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { INTERACTION_KEYS, MAX_INTERACTION_KEY_SEQUENCE_LENGTH, MAX_INTERACTION_MESSAGE_BYTES, } from "../../shared/api-contract.js";
+import { TASK_NAME_ERROR, validTaskName } from "../../shared/task-name.js";
+import { normalizeMessage } from "../interaction/message.js";
+import { CommandError, commandFailure } from "./command-error.js";
+import { output, outputFailure } from "./output.js";
+import { recoverMessageQuery, SessionClient } from "./session-client.js";
+import { followInspect } from "./session-follow.js";
+import { formatResult, mapInspect, mapList, mapTerminal, } from "./session-output.js";
+import { waitForLaunch, waitForOperation } from "./session-wait.js";
+export const sessionHelp = `Usage: ahub-cli session <command> [options]
+  list [--project <directory>] [--task <name>] [--all]
+  create --project <directory> [--task <name>] [--cwd <directory>] [--agent <nickname>] [--worktree] [--yolo]
+  resume <id> [--yolo]
+  send <id> (--message <text> | --stdin) [--force]
+  inspect <id> [--limit 1-300] [--after <number>] [--follow [--count <N>]]
+  terminal <id>
+  keys <id> <key...> [--force]
+  interrupt <id>
+  handoff <id>
+  exit <id> | archive <id> | delete <id>
+Options: --url <http(s)-url> --json --timeout <seconds> (default 15; follow: 30; create/resume/exit/archive/delete: 45)
+List: excludes archived sessions unless --all is set.
+Follow: timeout applies to each HTTP request; observation continues until stopped.
+Address: --url, AGENT_HUB_URL, http://127.0.0.1:4173
+Messages: update indicates progress; response indicates a reply, not verified task completion.
+Input: send/keys require connected and idle; --force skips the idle check, allowing input while working.
+Send: messages starting with / are rejected by the CLI; --force skips this check too.
+Keys: ${INTERACTION_KEYS.filter((key) => key !== "interrupt").join(", ")}
+Completion: idle/response do not end --follow; verify results before exit/archive/delete.`;
+export function parseSessionArguments(args, environmentUrl) {
+    const { values, positionals } = validateArguments(() => parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            url: { type: "string" },
+            json: { type: "boolean" },
+            timeout: { type: "string" },
+            project: { type: "string" },
+            task: { type: "string" },
+            all: { type: "boolean" },
+            cwd: { type: "string" },
+            agent: { type: "string" },
+            worktree: { type: "boolean" },
+            yolo: { type: "boolean" },
+            message: { type: "string" },
+            stdin: { type: "boolean" },
+            force: { type: "boolean" },
+            limit: { type: "string" },
+            after: { type: "string" },
+            follow: { type: "boolean" },
+            count: { type: "string" },
+            help: { type: "boolean" },
+        },
+    }));
+    if (values.help || positionals.length === 0) {
+        return { values, positionals, help: true };
+    }
+    const [command, id, ...keys] = positionals;
+    const allowed = {
+        list: ["project", "task", "all"],
+        create: ["task", "cwd", "project", "agent", "worktree", "yolo"],
+        resume: ["yolo"],
+        send: ["message", "stdin", "force"],
+        inspect: ["limit", "after", "follow", "count"],
+        terminal: [],
+        keys: ["force"],
+        interrupt: [],
+        handoff: [],
+        exit: [],
+        archive: [],
+        delete: [],
+    };
+    if (!Object.hasOwn(allowed, command))
+        throw new CommandError("invalid_arguments", "Unknown session command");
+    for (const key of Object.keys(values)) {
+        if (!["url", "json", "timeout", "help", ...allowed[command]].includes(key))
+            throw new CommandError("invalid_arguments", `--${key} is not supported by ${command}`);
+    }
+    if (values.task !== undefined && !validTaskName(values.task))
+        throw new CommandError("invalid_arguments", TASK_NAME_ERROR);
+    const acceptsSessionId = command !== "list" && command !== "create";
+    const invalidPositionals = acceptsSessionId
+        ? !id || (command !== "keys" && positionals.length !== 2)
+        : positionals.length !== 1;
+    if (invalidPositionals)
+        throw new CommandError("invalid_arguments", "Invalid session command arguments");
+    if (command === "create" && !values.project)
+        throw new CommandError("invalid_arguments", "create requires --project");
+    if (command === "send" &&
+        Number(values.message !== undefined) + Number(values.stdin === true) !== 1)
+        throw new CommandError("invalid_arguments", "send requires exactly one of --message and --stdin");
+    if (command === "keys" &&
+        (keys.length === 0 ||
+            keys.length > MAX_INTERACTION_KEY_SEQUENCE_LENGTH ||
+            keys.some((key) => key === "interrupt" || !INTERACTION_KEYS.includes(key))))
+        throw new CommandError("invalid_arguments", "Unsupported key sequence; use session interrupt for interruption");
+    const defaultSeconds = ["create", "resume", "exit", "archive", "delete"].includes(command)
+        ? 45
+        : values.follow
+            ? 30
+            : 15;
+    const seconds = values.timeout === undefined ? defaultSeconds : Number(values.timeout);
+    if (!Number.isFinite(seconds) || seconds <= 0 || seconds * 1000 > 2_147_483_647)
+        throw new CommandError("invalid_arguments", "timeout must be a positive number of seconds within the supported range");
+    const base = validateArguments(() => new URL(values.url ?? environmentUrl ?? "http://127.0.0.1:4173"));
+    if (base.protocol !== "http:" && base.protocol !== "https:")
+        throw new CommandError("invalid_arguments", "Only HTTP and HTTPS URLs are supported");
+    if (base.username || base.password || base.search || base.hash || base.pathname !== "/")
+        throw new CommandError("invalid_arguments", "URL must contain only an HTTP or HTTPS origin");
+    if (values.count !== undefined && !values.follow)
+        throw new CommandError("invalid_arguments", "--count requires --follow");
+    if (values.count !== undefined &&
+        (!/^\d+$/.test(values.count) ||
+            !Number.isSafeInteger(Number(values.count)) ||
+            Number(values.count) < 1))
+        throw new CommandError("invalid_arguments", "count must be a positive safe integer");
+    if (command === "inspect") {
+        for (const name of ["limit", "after"]) {
+            const value = values[name];
+            if (value === undefined)
+                continue;
+            if (!/^\d+$/.test(value) ||
+                !Number.isSafeInteger(Number(value)) ||
+                (name === "limit" && (Number(value) < 1 || Number(value) > 300)))
+                throw new CommandError("invalid_arguments", `Invalid ${name}`);
+        }
+    }
+    if (command === "send" && values.message !== undefined)
+        validateSendMessage(values.message, values.force);
+    return { values, positionals, command, id, keys, seconds, base, help: false };
+}
+/** One invocation owns one deadline and never retries a submitted mutation. */
+export async function runSessionCommand(args) {
+    let json = args.includes("--json");
+    let client;
+    let timer;
+    let following = false;
+    let launchDiagnostics;
+    const abort = new AbortController();
+    const interrupt = () => abort.abort();
+    process.once("SIGINT", interrupt);
+    process.once("SIGTERM", interrupt);
+    try {
+        const parsed = parseSessionArguments(args, process.env.AGENT_HUB_URL);
+        const { values } = parsed;
+        json = values.json ?? false;
+        if (parsed.help) {
+            console.log(sessionHelp);
+            return;
+        }
+        const { command, id, keys, seconds, base } = parsed;
+        following = values.follow === true;
+        if (!following)
+            timer = setTimeout(() => abort.abort(), seconds * 1000);
+        client = new SessionClient(base, abort.signal);
+        const api = client.request;
+        const path = `/api/v1/sessions/${encodeURIComponent(id ?? "")}`;
+        let result;
+        if (command === "list") {
+            const list = await api("/api/v1/sessions");
+            const project = values.project === undefined ? undefined : resolve(values.project);
+            const task = values.task?.trim();
+            const taskList = task === undefined
+                ? list
+                : { ...list, sessions: list.sessions.filter((session) => session.taskName === task) };
+            result = mapList(taskList, project, values.all);
+        }
+        else if (command === "inspect") {
+            const query = new URLSearchParams();
+            for (const name of ["limit", "after"]) {
+                if (values[name] !== undefined)
+                    query.set(name, values[name]);
+            }
+            if (following) {
+                await followInspect({
+                    path,
+                    query,
+                    base,
+                    signal: abort.signal,
+                    timeoutMs: seconds * 1000,
+                    count: values.count === undefined ? undefined : Number(values.count),
+                    json,
+                });
+                return;
+            }
+            try {
+                result = mapInspect(await api(`${path}/messages?${query}`));
+            }
+            catch (error) {
+                if (!recoverMessageQuery(error, query))
+                    throw error;
+                result = mapInspect(await api(`${path}/messages?${query}`));
+            }
+        }
+        else if (command === "terminal")
+            result = mapTerminal(await api(`${path}/terminal`));
+        else if (["send", "keys", "interrupt", "handoff"].includes(command)) {
+            if (command === "send") {
+                const input = values.stdin ? await readStdin(abort.signal) : values.message;
+                const message = validateSendMessage(input, values.force);
+                await api(`${path}/messages`, "POST", { message, requireIdle: !values.force });
+            }
+            else if (command === "handoff")
+                await api(`${path}/handoff-pane-binding`, "POST", {});
+            else
+                await api(`${path}/keys`, "POST", command === "interrupt" ? { keys: ["interrupt"] } : { keys, requireIdle: !values.force });
+            result = { sessionId: id, status: "sent" };
+        }
+        else {
+            const launch = command === "create" || command === "resume";
+            let operationPath = command === "delete" ? path : `${path}/${command}`;
+            let body = {};
+            if (command === "create") {
+                operationPath = "/api/v1/sessions";
+                body = {
+                    projectDirectory: resolve(values.project),
+                    taskName: values.task?.trim(),
+                    ...(values.cwd === undefined ? {} : { workingDirectory: resolve(values.cwd) }),
+                    worktree: values.worktree ?? false,
+                    yolo: values.yolo ?? false,
+                    ...(values.agent === undefined ? {} : { agent: values.agent }),
+                    requestId: randomUUID(),
+                };
+            }
+            else if (command === "resume") {
+                operationPath = "/api/v1/sessions";
+                body = { resumeSessionId: id, yolo: values.yolo ?? false, requestId: randomUUID() };
+            }
+            if (launch)
+                launchDiagnostics = { sessionId: command === "resume" ? id : null, tmux: null };
+            let operation = await api(operationPath, command === "delete" ? "DELETE" : "POST", body);
+            operation = await waitForOperation(operation, api, abort.signal, (current) => {
+                if (launchDiagnostics) {
+                    launchDiagnostics.sessionId = current.sessionId ?? launchDiagnostics.sessionId;
+                    if (current.target)
+                        launchDiagnostics.tmux = {
+                            socketPath: current.target.socketPath,
+                            sessionName: current.target.sessionName,
+                        };
+                }
+            });
+            if (launch)
+                await waitForLaunch(operation.sessionId, api, abort.signal);
+            result = {
+                sessionId: operation.sessionId,
+                status: "succeeded",
+                ...(launch ? { tmux: launchDiagnostics?.tmux ?? null } : {}),
+            };
+        }
+        output(result, json, json ? "" : formatResult(command, result));
+    }
+    catch (error) {
+        if (following && abort.signal.aborted)
+            return;
+        const failure = commandFailure(error, client?.mutationSubmitted ?? false);
+        if (launchDiagnostics)
+            failure.diagnostics = launchDiagnostics;
+        outputFailure(failure, json);
+    }
+    finally {
+        clearTimeout(timer);
+        process.removeListener("SIGINT", interrupt);
+        process.removeListener("SIGTERM", interrupt);
+    }
+}
+async function readStdin(signal) {
+    return new Promise((accept, reject) => {
+        const chunks = [];
+        let size = 0;
+        const cleanup = () => {
+            process.stdin.removeListener("data", data);
+            process.stdin.removeListener("end", end);
+            process.stdin.removeListener("error", fail);
+            signal.removeEventListener("abort", stop);
+            process.stdin.pause();
+        };
+        const fail = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const stop = () => fail(new Error("Command interrupted or timed out"));
+        const data = (chunk) => {
+            size += chunk.length;
+            if (size > MAX_INTERACTION_MESSAGE_BYTES * 2)
+                fail(new CommandError("invalid_arguments", `Message exceeds ${MAX_INTERACTION_MESSAGE_BYTES / 1024} KiB`));
+            else
+                chunks.push(chunk);
+        };
+        const end = () => {
+            cleanup();
+            accept(Buffer.concat(chunks).toString("utf8"));
+        };
+        if (signal.aborted) {
+            stop();
+            return;
+        }
+        process.stdin.on("data", data).once("end", end).once("error", fail);
+        signal.addEventListener("abort", stop, { once: true });
+    });
+}
+function validateSendMessage(input, force = false) {
+    const message = validateArguments(() => normalizeMessage(input));
+    if (!force && message.startsWith("/"))
+        throw new CommandError("invalid_arguments", "Message must not start with /; use --force to send it intentionally");
+    return message;
+}
+function validateArguments(validate) {
+    try {
+        return validate();
+    }
+    catch (error) {
+        throw new CommandError("invalid_arguments", error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/server/server/cli/skill.js

@@ -0,0 +1,37 @@
+import { readFile, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CommandError } from "./command-error.js";
+const bundledSkills = ["ahub-publish", "ahub-control"];
+const usage = `Usage: ahub-cli skill path <${bundledSkills.join(" | ")}>`;
+export async function runSkillCommand(args) {
+    if (args.length === 0 || (args.length === 1 && args[0] === "--help")) {
+        console.log(usage);
+        return;
+    }
+    const [command, skill] = args;
+    if (args.length !== 2 || command !== "path" || !skill || !bundledSkills.includes(skill))
+        throw new CommandError("invalid_arguments", usage);
+    let directory = dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        let name;
+        try {
+            name = JSON.parse(await readFile(join(directory, "package.json"), "utf8")).name;
+        }
+        catch {
+            // Continue through directories without a package manifest.
+        }
+        if (name === "@someonegg/agent-hub") {
+            const path = join(directory, "skills", skill);
+            if (!(await stat(join(path, "SKILL.md"))).isFile())
+                throw new CommandError("command_failed", "Skill file is missing");
+            console.log(path);
+            return;
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw new CommandError("command_failed", "Cannot locate the Hub package");
+        directory = parent;
+    }
+}
+//# sourceMappingURL=skill.js.map

package/dist/server/server/config.js

@@ -0,0 +1,196 @@
+import { realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+export function resolveHomeDirectory(value) {
+    return value === undefined
+        ? resolve(homedir(), ".agent-hub")
+        : resolvePathOption("home-dir", value);
+}
+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, option = "port") {
+    if (value === undefined)
+        return 4173;
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+        throw new Error(`--${option} must be an integer between 0 and 65535`);
+    }
+    return port;
+}
+export function loadConfig(args = process.argv.slice(2)) {
+    const { values, tokens } = parseArgs({
+        tokens: true,
+        args: [...args],
+        allowPositionals: false,
+        strict: true,
+        options: {
+            "codex-agent": { type: "string", multiple: true },
+            "claude-agent": { type: "string", multiple: true },
+            host: { type: "string" },
+            port: { type: "string" },
+            "local-port": { type: "string" },
+            ssl: { type: "boolean" },
+            "ssl-cert": { type: "string" },
+            "ssl-key": { type: "string" },
+            "ssl-ca": { type: "string" },
+            help: { type: "boolean" },
+            version: { type: "boolean" },
+            "tmux-socket": { type: "string" },
+            "claude-ready-script": { type: "string" },
+            "home-dir": { type: "string" },
+            hosting: { type: "boolean" },
+        },
+    });
+    if (values.help)
+        return { kind: "help" };
+    if (values.version)
+        return { kind: "version" };
+    const host = nonEmptyOption("host", values.host) ?? LOOPBACK_HOST;
+    const names = new Set();
+    const paths = new Set();
+    let entries = tokens.flatMap((token) => token.kind === "option" && (token.name === "codex-agent" || token.name === "claude-agent")
+        ? [{ option: token.name, value: token.value }]
+        : []);
+    if (entries.length === 0) {
+        entries = [
+            { option: "codex-agent", value: "codex=~/.codex" },
+            { option: "claude-agent", value: "claude=~/.claude" },
+        ];
+        try {
+            statSync(resolve(homedir(), ".codex"));
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT")
+                entries.reverse();
+            else if (code !== "EACCES" && code !== "EPERM")
+                throw error;
+        }
+    }
+    const agents = entries.map(({ option, value }) => ({
+        ...parseAgent(value, option, names, paths),
+        ...(option === "claude-agent" ? { adapter: "claude" } : {}),
+    }));
+    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: resolvePathOption("ssl-cert", certificatePath),
+            privateKeyPath: resolvePathOption("ssl-key", privateKeyPath),
+            ...(certificateAuthorityPath
+                ? { certificateAuthorityPath: resolvePathOption("ssl-ca", 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,
+            ...(values["claude-ready-script"] !== undefined
+                ? {
+                    claudeReadyScript: resolvePathOption("claude-ready-script", values["claude-ready-script"]),
+                }
+                : {}),
+            port: parsePort(values.port),
+            ...(values["local-port"] !== undefined
+                ? { localPort: parsePort(values["local-port"], "local-port") }
+                : {}),
+            agents,
+            clientDirectory: fileURLToPath(new URL("../../client/", import.meta.url)),
+            tls,
+            interactionEnabled: true,
+            uploadDirectory: resolve(resolveHomeDirectory(values["home-dir"]), "uploads"),
+            ...(values.hosting
+                ? { hostingDirectory: resolve(resolveHomeDirectory(values["home-dir"]), "hosting") }
+                : {}),
+            ...(values["tmux-socket"] !== undefined
+                ? { tmuxSocket: resolvePathOption("tmux-socket", values["tmux-socket"]) }
+                : {}),
+        },
+    };
+}
+export function commandLineHelp() {
+    return `Usage: agent-hub [options]
+
+Options:
+  --hosting            Enable trusted same-origin static web hosting
+  --home-dir <path>    Hub data root (default: ~/.agent-hub; uploads/ and hosting/)
+  --codex-agent <nickname=path>
+                       Codex agent; repeat for multiple agents
+  --claude-agent <nickname=path>
+                       Claude Code agent; repeat for multiple agents
+  Default agents: codex=~/.codex, claude=~/.claude (Claude first if ~/.codex is absent).
+  Any explicit agent replaces both defaults; argument order determines the default agent.
+  --host <host>        Listen host (default: 127.0.0.1)
+  --port <port>        Listen port, or 0 for a free port (default: 4173)
+  --local-port <port>  Additional HTTP listener on 127.0.0.1 (disabled by default)
+  --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
+  --claude-ready-script <path>
+                       Executable Claude readiness checker (all agents)
+  --tmux-socket <path> tmux socket (default: tmux default selection)
+  --help               Show this help
+  --version            Show the current version
+
+TLS example:
+  agent-hub --ssl --ssl-cert server.crt --ssl-key server.key
+
+mTLS example:
+  agent-hub --ssl --ssl-cert server.crt --ssl-key server.key --ssl-ca ca.crt`;
+}
+function parseAgent(value, option, names, paths) {
+    const separator = value.indexOf("=");
+    const nickname = value.slice(0, separator).trim();
+    const agentPath = value.slice(separator + 1).trim();
+    if (separator < 0 || !nickname || !agentPath) {
+        throw new Error(`--${option} requires nickname=path with a non-empty nickname and path`);
+    }
+    const path = resolvePathOption(option, agentPath);
+    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 agent nickname: ${nickname}`);
+    if (paths.has(canonical))
+        throw new Error("Duplicate agent path");
+    names.add(nickname);
+    paths.add(canonical);
+    return { nickname, path };
+}
+function resolvePathOption(name, value) {
+    const path = nonEmptyOption(name, value);
+    return resolve(path.startsWith("~/") ? resolve(homedir(), path.slice(2)) : path);
+}
+//# sourceMappingURL=config.js.map