@holon-run/agentinbox 0.1.0

package/dist/src/client.js

@@ -0,0 +1,279 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentInboxClient = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+class AgentInboxClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async request(endpoint, body, method = "POST") {
+        if (this.transport.kind === "socket") {
+            return requestViaSocket(this.transport.socketPath, endpoint, body, method);
+        }
+        return requestViaUrl(this.transport.baseUrl, endpoint, body, method);
+    }
+    watchInbox(agentId, options = {}) {
+        const query = new URLSearchParams();
+        if (options.afterItemId) {
+            query.set("after_item_id", options.afterItemId);
+        }
+        if (options.includeAcked) {
+            query.set("include_acked", "true");
+        }
+        if (options.heartbeatMs) {
+            query.set("heartbeat_ms", String(options.heartbeatMs));
+        }
+        const endpoint = `/agents/${encodeURIComponent(agentId)}/inbox/watch${query.size > 0 ? `?${query.toString()}` : ""}`;
+        if (this.transport.kind === "socket") {
+            return watchViaSocket(this.transport.socketPath, endpoint);
+        }
+        return watchViaUrl(this.transport.baseUrl, endpoint);
+    }
+}
+exports.AgentInboxClient = AgentInboxClient;
+function requestViaSocket(socketPath, endpoint, body, method) {
+    return new Promise((resolve, reject) => {
+        const payload = body ? JSON.stringify(body) : undefined;
+        const req = node_http_1.default.request({
+            socketPath,
+            path: normalizeEndpoint(endpoint),
+            method,
+            headers: payload
+                ? {
+                    "content-type": "application/json",
+                    "content-length": Buffer.byteLength(payload),
+                }
+                : undefined,
+        }, (res) => {
+            void collectResponse(res).then(resolve, reject);
+        });
+        req.on("error", reject);
+        if (payload) {
+            req.write(payload);
+        }
+        req.end();
+    });
+}
+function requestViaUrl(baseUrl, endpoint, body, method) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(normalizeEndpoint(endpoint), baseUrl);
+        const payload = body ? JSON.stringify(body) : undefined;
+        const transport = url.protocol === "https:" ? node_https_1.default : node_http_1.default;
+        const req = transport.request({
+            protocol: url.protocol,
+            hostname: url.hostname,
+            port: url.port,
+            path: `${url.pathname}${url.search}`,
+            method,
+            headers: payload
+                ? {
+                    "content-type": "application/json",
+                    "content-length": Buffer.byteLength(payload),
+                }
+                : undefined,
+        }, (res) => {
+            void collectResponse(res).then(resolve, reject);
+        });
+        req.on("error", reject);
+        if (payload) {
+            req.write(payload);
+        }
+        req.end();
+    });
+}
+function watchViaSocket(socketPath, endpoint) {
+    return createSseStream((handleResponse) => {
+        const req = node_http_1.default.request({
+            socketPath,
+            path: normalizeEndpoint(endpoint),
+            method: "GET",
+            headers: {
+                accept: "text/event-stream",
+            },
+        }, handleResponse);
+        req.end();
+        return req;
+    });
+}
+function watchViaUrl(baseUrl, endpoint) {
+    return createSseStream((handleResponse) => {
+        const url = new URL(normalizeEndpoint(endpoint), baseUrl);
+        const transport = url.protocol === "https:" ? node_https_1.default : node_http_1.default;
+        const req = transport.request({
+            protocol: url.protocol,
+            hostname: url.hostname,
+            port: url.port,
+            path: `${url.pathname}${url.search}`,
+            method: "GET",
+            headers: {
+                accept: "text/event-stream",
+            },
+        }, handleResponse);
+        req.end();
+        return req;
+    });
+}
+function collectResponse(res) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        res.on("data", (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        res.on("end", () => {
+            try {
+                const raw = Buffer.concat(chunks).toString("utf8");
+                const parsed = raw ? JSON.parse(raw) : {};
+                resolve({
+                    statusCode: res.statusCode ?? 500,
+                    data: parsed,
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        res.on("error", reject);
+    });
+}
+function normalizeEndpoint(endpoint) {
+    return endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+}
+function createSseStream(openRequest) {
+    const queue = [];
+    const waiters = [];
+    let done = false;
+    let failure = null;
+    let request = null;
+    let response = null;
+    const push = (event) => {
+        if (done) {
+            return;
+        }
+        const waiter = waiters.shift();
+        if (waiter) {
+            waiter({ value: event, done: false });
+            return;
+        }
+        queue.push(event);
+    };
+    const finish = (error) => {
+        if (done) {
+            return;
+        }
+        done = true;
+        failure = error ?? null;
+        request?.destroy();
+        response?.destroy();
+        while (waiters.length > 0) {
+            const waiter = waiters.shift();
+            if (!waiter) {
+                continue;
+            }
+            waiter({ value: undefined, done: true });
+        }
+    };
+    request = openRequest((res) => {
+        response = res;
+        if ((res.statusCode ?? 500) < 200 || (res.statusCode ?? 500) >= 300) {
+            const chunks = [];
+            res.on("data", (chunk) => {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            res.on("end", () => {
+                const body = Buffer.concat(chunks).toString("utf8");
+                finish(new Error(body || `watch failed with status ${res.statusCode ?? 500}`));
+            });
+            return;
+        }
+        let buffer = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+            try {
+                buffer += chunk;
+                let separatorIndex = buffer.indexOf("\n\n");
+                while (separatorIndex >= 0) {
+                    const frame = buffer.slice(0, separatorIndex);
+                    buffer = buffer.slice(separatorIndex + 2);
+                    const event = parseSseFrame(frame);
+                    if (event) {
+                        push(event);
+                    }
+                    separatorIndex = buffer.indexOf("\n\n");
+                }
+            }
+            catch (error) {
+                finish(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        res.on("end", () => {
+            finish();
+        });
+        res.on("error", (error) => {
+            finish(error instanceof Error ? error : new Error(String(error)));
+        });
+    });
+    request.on("error", (error) => {
+        finish(error instanceof Error ? error : new Error(String(error)));
+    });
+    return {
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    if (queue.length > 0) {
+                        return Promise.resolve({ value: queue.shift(), done: false });
+                    }
+                    if (done) {
+                        if (failure) {
+                            return Promise.reject(failure);
+                        }
+                        return Promise.resolve({ value: undefined, done: true });
+                    }
+                    return new Promise((resolve) => {
+                        waiters.push(resolve);
+                    }).then((result) => {
+                        if (result.done && failure) {
+                            throw failure;
+                        }
+                        return result;
+                    });
+                },
+                return() {
+                    finish();
+                    return Promise.resolve({ value: undefined, done: true });
+                },
+            };
+        },
+    };
+}
+function parseSseFrame(frame) {
+    const lines = frame
+        .split(/\r?\n/)
+        .filter((line) => line.length > 0 && !line.startsWith(":"));
+    if (lines.length === 0) {
+        return null;
+    }
+    let eventName = "message";
+    const dataLines = [];
+    for (const line of lines) {
+        if (line.startsWith("event:")) {
+            eventName = line.slice("event:".length).trim();
+            continue;
+        }
+        if (line.startsWith("data:")) {
+            dataLines.push(line.slice("data:".length).trim());
+        }
+    }
+    if (dataLines.length === 0) {
+        return null;
+    }
+    const payload = JSON.parse(dataLines.join("\n"));
+    if (eventName !== payload.event) {
+        throw new Error(`unexpected SSE event name ${eventName} for payload event ${payload.event}`);
+    }
+    return payload;
+}

package/dist/src/control_server.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startControlServer = startControlServer;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_net_1 = __importDefault(require("node:net"));
+const node_path_1 = __importDefault(require("node:path"));
+async function startControlServer(server, transport) {
+    if (transport.kind === "socket") {
+        await prepareSocketPath(transport.socketPath);
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(transport.socketPath, () => {
+                server.removeListener("error", reject);
+                resolve();
+            });
+        });
+        return {
+            info: {
+                socketPath: transport.socketPath,
+            },
+            async close() {
+                await closeServer(server);
+                cleanupSocketPath(transport.socketPath);
+            },
+        };
+    }
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(transport.port, transport.host, () => {
+            server.removeListener("error", reject);
+            resolve();
+        });
+    });
+    return {
+        info: {
+            url: transport.baseUrl,
+        },
+        async close() {
+            await closeServer(server);
+        },
+    };
+}
+async function prepareSocketPath(socketPath) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(socketPath), { recursive: true });
+    if (!node_fs_1.default.existsSync(socketPath)) {
+        return;
+    }
+    if (await canConnectToSocket(socketPath)) {
+        throw new Error(`AgentInbox daemon already running at ${socketPath}`);
+    }
+    cleanupSocketPath(socketPath);
+}
+function cleanupSocketPath(socketPath) {
+    try {
+        if (node_fs_1.default.existsSync(socketPath)) {
+            node_fs_1.default.unlinkSync(socketPath);
+        }
+    }
+    catch {
+        // Best effort cleanup for stale sockets.
+    }
+}
+function canConnectToSocket(socketPath) {
+    return new Promise((resolve) => {
+        const socket = node_net_1.default.createConnection(socketPath);
+        let settled = false;
+        const finish = (connected) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            socket.destroy();
+            resolve(connected);
+        };
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+        socket.setTimeout(200, () => finish(false));
+    });
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}

package/dist/src/daemon.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDaemonForClient = ensureDaemonForClient;
+exports.startDaemon = startDaemon;
+exports.stopDaemon = stopDaemon;
+exports.daemonStatus = daemonStatus;
+exports.writePidFile = writePidFile;
+exports.removePidFile = removePidFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const client_1 = require("./client");
+const paths_1 = require("./paths");
+const START_TIMEOUT_MS = 15_000;
+async function ensureDaemonForClient(options = {}) {
+    const transport = resolveDaemonClientTransport(options);
+    if (options.noAutoStart || transport.kind !== "socket") {
+        return transport;
+    }
+    if (await canReachHealthz(transport)) {
+        return transport;
+    }
+    await startDaemon(options);
+    return transport;
+}
+async function startDaemon(options = {}) {
+    const env = options.env ?? process.env;
+    const transport = requireSocketTransport(resolveDaemonClientTransport(options), "daemon start");
+    const homeDir = (0, paths_1.resolveAgentInboxHome)(env, options.homeDirOverride);
+    const { pidPath, logPath } = (0, paths_1.resolveDaemonPaths)(env, options.homeDirOverride);
+    node_fs_1.default.mkdirSync(homeDir, { recursive: true });
+    cleanupStalePidFile(pidPath);
+    if (await canReachHealthz(transport)) {
+        const pid = readPidFile(pidPath);
+        return {
+            started: false,
+            pid: pid ?? -1,
+            pidPath,
+            logPath,
+            transport,
+        };
+    }
+    const logFd = openLogFile(logPath);
+    let child;
+    try {
+        child = (0, node_child_process_1.spawn)(process.execPath, daemonChildArgs(), {
+            cwd: process.cwd(),
+            env: {
+                ...env,
+                AGENTINBOX_HOME: homeDir,
+                AGENTINBOX_SOCKET: transport.socketPath,
+                AGENTINBOX_URL: "",
+            },
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+        });
+    }
+    finally {
+        node_fs_1.default.closeSync(logFd);
+    }
+    child.unref();
+    await waitForHealthz(transport, START_TIMEOUT_MS);
+    return {
+        started: true,
+        pid: child.pid ?? -1,
+        pidPath,
+        logPath,
+        transport,
+    };
+}
+async function stopDaemon(options = {}) {
+    const env = options.env ?? process.env;
+    const transport = requireSocketTransport(resolveDaemonClientTransport(options), "daemon stop");
+    const { pidPath, logPath } = (0, paths_1.resolveDaemonPaths)(env, options.homeDirOverride);
+    const pid = readPidFile(pidPath);
+    if (pid != null && isProcessAlive(pid)) {
+        process.kill(pid, "SIGTERM");
+        await waitForProcessExit(pid, 3_000);
+    }
+    cleanupStalePidFile(pidPath, true);
+    cleanupFile(transport.socketPath);
+    return daemonStatus(options);
+}
+async function daemonStatus(options = {}) {
+    const env = options.env ?? process.env;
+    const transport = requireSocketTransport(resolveDaemonClientTransport(options), "daemon status");
+    const { pidPath, logPath } = (0, paths_1.resolveDaemonPaths)(env, options.homeDirOverride);
+    const pid = readPidFile(pidPath);
+    if (pid != null && !isProcessAlive(pid)) {
+        cleanupStalePidFile(pidPath, true);
+        cleanupFile(transport.socketPath);
+        return {
+            running: false,
+            pid: null,
+            pidPath,
+            logPath,
+            transport,
+        };
+    }
+    return {
+        running: await canReachHealthz(transport),
+        pid,
+        pidPath,
+        logPath,
+        transport,
+    };
+}
+function writePidFile(pidPath, pid) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(pidPath), { recursive: true });
+    node_fs_1.default.writeFileSync(pidPath, `${pid}\n`, "utf8");
+}
+function removePidFile(pidPath) {
+    cleanupFile(pidPath);
+}
+function daemonChildArgs() {
+    const execArgv = [...process.execArgv];
+    return [...execArgv, process.argv[1], "serve"];
+}
+function requireSocketTransport(transport, commandName) {
+    if (transport.kind !== "socket") {
+        throw new Error(`${commandName} requires a local socket transport`);
+    }
+    return transport;
+}
+function resolveDaemonClientTransport(options) {
+    const env = options.env ?? process.env;
+    const homeDir = (0, paths_1.resolveAgentInboxHome)(env, options.homeDirOverride);
+    if (options.socketPathOverride && options.baseUrlOverride) {
+        throw new Error("client accepts either --socket or --url, not both");
+    }
+    if (options.socketPathOverride) {
+        return {
+            kind: "socket",
+            socketPath: node_path_1.default.resolve(options.socketPathOverride),
+            source: "flag",
+        };
+    }
+    if (options.baseUrlOverride) {
+        return {
+            kind: "url",
+            baseUrl: options.baseUrlOverride,
+            source: "flag",
+        };
+    }
+    if (env.AGENTINBOX_SOCKET) {
+        return {
+            kind: "socket",
+            socketPath: node_path_1.default.resolve(env.AGENTINBOX_SOCKET),
+            source: "env",
+        };
+    }
+    if (env.AGENTINBOX_URL) {
+        return {
+            kind: "url",
+            baseUrl: env.AGENTINBOX_URL,
+            source: "env",
+        };
+    }
+    return {
+        kind: "socket",
+        socketPath: node_path_1.default.join(homeDir, "agentinbox.sock"),
+        source: "default",
+    };
+}
+function openLogFile(logPath) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(logPath), { recursive: true });
+    return node_fs_1.default.openSync(logPath, "a");
+}
+async function canReachHealthz(transport) {
+    try {
+        const client = new client_1.AgentInboxClient(transport);
+        const response = await client.request("/healthz", undefined, "GET");
+        return response.statusCode === 200 && response.data.ok === true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForHealthz(transport, timeoutMs) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        if (await canReachHealthz(transport)) {
+            return;
+        }
+        await sleep(100);
+    }
+    throw new Error("timed out waiting for AgentInbox daemon to become ready");
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        if (!isProcessAlive(pid)) {
+            return;
+        }
+        await sleep(100);
+    }
+    throw new Error(`timed out waiting for process ${pid} to exit`);
+}
+function cleanupStalePidFile(pidPath, force = false) {
+    const pid = readPidFile(pidPath);
+    if (pid == null) {
+        cleanupFile(pidPath);
+        return;
+    }
+    if (force || !isProcessAlive(pid)) {
+        cleanupFile(pidPath);
+    }
+}
+function readPidFile(pidPath) {
+    try {
+        const raw = node_fs_1.default.readFileSync(pidPath, "utf8").trim();
+        if (!raw) {
+            return null;
+        }
+        const pid = Number.parseInt(raw, 10);
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function cleanupFile(filePath) {
+    try {
+        if (node_fs_1.default.existsSync(filePath)) {
+            node_fs_1.default.unlinkSync(filePath);
+        }
+    }
+    catch {
+        // Best effort cleanup.
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}