agentgather 0.1.0

package/dist/src/cli/commands/doctor/index.js

@@ -0,0 +1,93 @@
+import { stat } from "node:fs/promises";
+import { flagBoolean, parseArgs } from "../../args.js";
+import { readCurrent, tokensPath } from "../../state.js";
+import { readRoomState, roomPaths } from "../../../storage/index.js";
+export async function runDoctorCommand(argv, context) {
+    const args = parseArgs(argv);
+    const checks = [];
+    const current = await readCurrentSafe(context.home);
+    checks.push({
+        name: "current-room",
+        ok: current !== null,
+        message: current === null ? "no current room; run agentgather room join or room start" : `room=${current.roomId} alias=${current.alias}`
+    });
+    if (current !== null) {
+        const paths = roomPaths(context.home, current.roomId);
+        checks.push(await fileCheck("room-state", paths.state));
+        checks.push(await fileCheck("messages-log", paths.messages));
+        checks.push(await fileCheck("participants", paths.participants));
+        checks.push(await fileCheck("token-store", tokensPath(context.home, current.roomId)));
+        checks.push(await lockCheck(paths.lock));
+        checks.push(await roomStateCheck(paths));
+        checks.push(await serverCheck(current.baseUrl, current.token));
+    }
+    const ok = checks.every((check) => check.ok);
+    if (flagBoolean(args, "json")) {
+        context.stdout.write(`${JSON.stringify({ ok, checks })}\n`);
+    }
+    else {
+        for (const check of checks) {
+            context.stdout.write(`${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}\n`);
+        }
+    }
+    return ok ? 0 : 1;
+}
+async function readCurrentSafe(home) {
+    try {
+        return await readCurrent(home);
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return null;
+        throw error;
+    }
+}
+async function fileCheck(name, file) {
+    try {
+        await stat(file);
+        return { name, ok: true, message: "present" };
+    }
+    catch (error) {
+        return { name, ok: false, message: isNotFound(error) ? "missing" : errorMessage(error) };
+    }
+}
+async function lockCheck(lockPath) {
+    try {
+        await stat(lockPath);
+        return { name: "writer-lock", ok: false, message: "lock file exists; another writer may be active or stale" };
+    }
+    catch (error) {
+        return { name: "writer-lock", ok: isNotFound(error), message: isNotFound(error) ? "clear" : errorMessage(error) };
+    }
+}
+async function roomStateCheck(paths) {
+    try {
+        const state = await readRoomState(paths);
+        return { name: "room-status", ok: true, message: state.status };
+    }
+    catch (error) {
+        return { name: "room-status", ok: false, message: errorMessage(error) };
+    }
+}
+async function serverCheck(baseUrl, token) {
+    try {
+        const response = await fetch(new URL("/status", baseUrl), {
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        if (!response.ok) {
+            return { name: "room-server", ok: false, message: `HTTP ${response.status}` };
+        }
+        return { name: "room-server", ok: true, message: "reachable" };
+    }
+    catch {
+        return { name: "room-server", ok: false, message: "not reachable at current baseUrl" };
+    }
+}
+function isNotFound(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/cli/commands/export/index.js

@@ -0,0 +1,42 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { flagBoolean, flagString, parseArgs } from "../../args.js";
+import { readCurrent } from "../../state.js";
+import { readBrief, readMessages, readParticipants, readRoomState, roomPaths } from "../../../storage/index.js";
+export async function runExportCommand(argv, context) {
+    const args = parseArgs(argv);
+    const current = await readCurrent(context.home);
+    const output = flagString(args, "output") ?? path.join(process.cwd(), `${current.roomId}-export.md`);
+    const paths = roomPaths(context.home, current.roomId);
+    const [state, brief, participants, messages] = await Promise.all([
+        readRoomState(paths),
+        readBrief(context.home, current.roomId),
+        readParticipants(paths),
+        readMessages(context.home, current.roomId)
+    ]);
+    const body = [
+        `# Agent Gather Room Export: ${state.id}`,
+        "",
+        `Status: ${state.status}`,
+        `Exported at: ${new Date().toISOString()}`,
+        `Brief version: ${brief.brief_version}`,
+        "",
+        "## Room Brief",
+        "",
+        brief.body || "(empty)",
+        "",
+        "## Participants",
+        "",
+        ...participants.map((participant) => `- ${participant.alias}: ${participant.kind}, ${participant.location}, ${participant.install}, ${participant.attention}, last_seen=${participant.lastSeenAt}`),
+        "",
+        "## Messages",
+        "",
+        ...messages.map((message) => `- [#${message.id}] ${message.ts} ${message.from} (${message.type}): ${message.text}`)
+    ].join("\n");
+    await writeFile(output, `${body}\n`);
+    return emit(context, flagBoolean(args, "json"), { ok: true, room: current.roomId, output, messages: messages.length }, `Exported ${messages.length} messages to ${output}\n`);
+}
+function emit(context, json, value, text) {
+    context.stdout.write(json ? `${JSON.stringify(value)}\n` : text);
+    return 0;
+}

package/dist/src/cli/commands/handoff/index.js

@@ -0,0 +1,41 @@
+import { readFile } from "node:fs/promises";
+import { flagBoolean, flagString, parseArgs } from "../../args.js";
+import { sendMessage } from "../message/transport.js";
+export const MAX_HANDOFF_SUMMARY_LENGTH = 12_000;
+export async function runHandoffCommand(argv, context) {
+    const args = parseArgs(argv);
+    const target = args.positional[0];
+    const summarySource = flagString(args, "summary");
+    if (target === undefined || summarySource === undefined) {
+        throw new Error("handoff requires <alias> and --summary");
+    }
+    const summary = await readSummary(summarySource);
+    if (summary.length > MAX_HANDOFF_SUMMARY_LENGTH) {
+        throw new Error(`handoff summary must be <= ${MAX_HANDOFF_SUMMARY_LENGTH} characters`);
+    }
+    const input = {
+        type: "handoff",
+        text: `@${target} HANDOFF\n\n${summary}`
+    };
+    const result = await sendMessage(context, input);
+    if (flagBoolean(args, "json")) {
+        context.stdout.write(`${JSON.stringify(result)}\n`);
+    }
+    else {
+        context.stdout.write(`handoff #${result.message.id} sent to @${target}\n`);
+    }
+    return 0;
+}
+async function readSummary(source) {
+    if (source.length > MAX_HANDOFF_SUMMARY_LENGTH)
+        return source;
+    try {
+        return await readFile(source, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return source;
+        }
+        throw error;
+    }
+}

package/dist/src/cli/commands/instructions/index.js

@@ -0,0 +1,7 @@
+import { parseAgentKind, renderAgentInstructions } from "../../../protocol/index.js";
+import { flagString, parseArgs } from "../../args.js";
+export async function runInstructionsCommand(argv, context) {
+    const args = parseArgs(argv);
+    context.stdout.write(`${renderAgentInstructions(parseAgentKind(flagString(args, "agent")))}\n`);
+    return 0;
+}

package/dist/src/cli/commands/message/index.js

@@ -0,0 +1,50 @@
+import { flagBoolean, flagString, parseArgs } from "../../args.js";
+import { currentSinceId, formatMessages, listMessages, parseSinceId, readAndStoreCursor, sendMessage } from "./transport.js";
+export async function runSendCommand(argv, context) {
+    const args = parseArgs(argv);
+    const target = args.positional[0];
+    const text = flagString(args, "text") ?? args.positional.slice(1).join(" ");
+    if (target === undefined || text.length === 0) {
+        throw new Error("send requires <alias> and message text");
+    }
+    const clientMsgId = flagString(args, "client-msg-id");
+    const input = {
+        text: `@${target} ${text}`,
+        ...(clientMsgId === undefined ? {} : { client_msg_id: clientMsgId })
+    };
+    const result = await sendMessage(context, input);
+    return emit(context, flagBoolean(args, "json"), result, `sent #${result.message.id} to @${target}\n`);
+}
+export async function runReplyCommand(argv, context) {
+    const args = parseArgs(argv);
+    const replyTo = args.positional[0] === undefined ? undefined : parseSinceId(args.positional[0]);
+    const text = flagString(args, "text") ?? args.positional.slice(1).join(" ");
+    if (replyTo === undefined || text.length === 0) {
+        throw new Error("reply requires <message_id> and message text");
+    }
+    const clientMsgId = flagString(args, "client-msg-id");
+    const input = {
+        type: "reply",
+        text,
+        reply_to: replyTo,
+        ...(clientMsgId === undefined ? {} : { client_msg_id: clientMsgId })
+    };
+    const result = await sendMessage(context, input);
+    return emit(context, flagBoolean(args, "json"), result, `replied #${result.message.id} to #${replyTo}\n`);
+}
+export async function runMessagesCommand(argv, context) {
+    const args = parseArgs(argv);
+    const sinceId = await currentSinceId(context, flagString(args, "since"));
+    const result = await listMessages(context, sinceId);
+    return emit(context, flagBoolean(args, "json"), result, formatMessages(result.messages));
+}
+export async function runReadCommand(argv, context) {
+    const args = parseArgs(argv);
+    const sinceId = await currentSinceId(context, flagString(args, "since"));
+    const result = await readAndStoreCursor(context, sinceId);
+    return emit(context, flagBoolean(args, "json"), result, formatMessages(result.messages));
+}
+function emit(context, json, value, text) {
+    context.stdout.write(json ? `${JSON.stringify(value)}\n` : text);
+    return 0;
+}

package/dist/src/cli/commands/message/transport.js

@@ -0,0 +1,108 @@
+import { appendMessageResult, readCursor, readMessages, writeCursor } from "../../../storage/index.js";
+import { readCurrent } from "../../state.js";
+export async function currentSinceId(context, rawSince) {
+    if (rawSince !== undefined)
+        return parseSinceId(rawSince);
+    const current = await readCurrent(context.home);
+    return readCursor(context.home, current.roomId, current.alias);
+}
+export async function sendMessage(context, input) {
+    const current = await readCurrent(context.home);
+    const sent = await requestJson(current, "/messages", "POST", input);
+    if (sent !== null)
+        return sent;
+    const result = await appendMessageResult({
+        root: context.home,
+        roomId: current.roomId,
+        from: current.alias,
+        input
+    });
+    return {
+        ok: true,
+        message: result.message,
+        ...(result.idempotent ? { idempotent: true } : {})
+    };
+}
+export async function listMessages(context, sinceId) {
+    const current = await readCurrent(context.home);
+    const path = `/messages?since_id=${sinceId}`;
+    const remote = await requestJson(current, path, "GET");
+    if (remote !== null) {
+        return {
+            ...remote,
+            next_cmd: `agentgather messages --since ${remote.next_since_id} --json`
+        };
+    }
+    const messages = (await readMessages(context.home, current.roomId)).filter((message) => message.id > sinceId);
+    return {
+        ok: true,
+        messages,
+        next_since_id: messages.at(-1)?.id ?? sinceId,
+        next_cmd: `agentgather messages --since ${messages.at(-1)?.id ?? sinceId} --json`
+    };
+}
+export async function readAndStoreCursor(context, sinceId) {
+    const current = await readCurrent(context.home);
+    const result = await listMessages(context, sinceId);
+    await writeCursor(context.home, current.roomId, current.alias, result.next_since_id);
+    return {
+        ...result,
+        next_cmd: `agentgather read --since ${result.next_since_id} --json`
+    };
+}
+export async function waitOnce(context, sinceId) {
+    const current = await readCurrent(context.home);
+    const path = `/wait?participant=${current.alias}&since_id=${sinceId}`;
+    const response = await requestJson(current, path, "GET");
+    if (response === null)
+        throw new Error("room server is not reachable for watch");
+    await writeCursor(context.home, current.roomId, current.alias, response.next_since_id);
+    return {
+        ...response,
+        cli_next_cmd: response.keep_waiting ? `agentgather watch --since ${response.next_since_id} --json` : null
+    };
+}
+export function formatMessages(messages) {
+    if (messages.length === 0)
+        return "(no messages)\n";
+    return messages.map((message) => `${message.id} ${message.ts} ${message.from}: ${message.text}`).join("\n") + "\n";
+}
+export function parseSinceId(raw) {
+    const sinceId = Number(raw);
+    if (!Number.isSafeInteger(sinceId) || sinceId < 0) {
+        throw new Error("since must be a non-negative safe integer");
+    }
+    return sinceId;
+}
+async function requestJson(current, path, method, body) {
+    try {
+        const response = await fetch(new URL(path, current.baseUrl), {
+            method,
+            headers: {
+                Authorization: `Bearer ${current.token}`,
+                "Content-Type": "application/json"
+            },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) })
+        });
+        const payload = await readResponseJson(response);
+        if (response.status === 404)
+            return null;
+        if (!response.ok) {
+            throw new Error(payload.message ?? `request failed with HTTP ${response.status}`);
+        }
+        return payload;
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return null;
+        throw error;
+    }
+}
+async function readResponseJson(response) {
+    try {
+        return JSON.parse(await response.text());
+    }
+    catch {
+        return {};
+    }
+}