@messenger-agent/client 0.24.0-alpha.2

package/dist/supervisor.js

@@ -0,0 +1,282 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { parse } from "yaml";
+import { readFile, unlink } from "node:fs/promises";
+import { readControlSocketPath, startControlServer } from "./control.js";
+import { MaintenanceScheduler } from "./maintenance.js";
+import { readUpgradeChannel } from "./config-file.js";
+import { currentBundledSkillsDir, defaultAgentHomes, installRuntime, syncBundledSkills } from "./runtime.js";
+import { darwinCommands, launchdLabel, linuxCommands, serviceName } from "./service.js";
+import { runCommand } from "./exec.js";
+import { AutoUpgradeScheduler } from "./auto-upgrade.js";
+import { isAgentActivityResponse, } from "@messenger-agent/shared/agent-activity";
+const require = createRequire(import.meta.url);
+export function resolveAgentEntries() {
+    return [
+        { name: "codex", entry: require.resolve("@messenger-agent/codex-agent") },
+        { name: "claude", entry: require.resolve("@messenger-agent/claude-agent") },
+        { name: "workspace", entry: require.resolve("@messenger-agent/messenger-agent") },
+    ];
+}
+function getByPath(root, path) {
+    let value = root;
+    for (const key of path) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return undefined;
+        value = value[key];
+    }
+    return value;
+}
+export async function readWorkspacePathFromConfig(configPath) {
+    const config = parse(await readFile(configPath, "utf8"));
+    const workspaces = getByPath(config, ["workspaces"]);
+    if (Array.isArray(workspaces)) {
+        const firstWorkspace = workspaces.find((workspace) => !!workspace && typeof workspace === "object" && !Array.isArray(workspace) && typeof workspace.path === "string");
+        if (typeof firstWorkspace?.path === "string" && firstWorkspace.path.trim())
+            return firstWorkspace.path;
+    }
+    return dirname(configPath);
+}
+export class AgentSupervisor {
+    options;
+    stopping = false;
+    running;
+    restartBaseMs;
+    restartMaxMs;
+    constructor(options) {
+        this.options = options;
+        this.running = (options.agents ?? resolveAgentEntries()).map((definition) => ({
+            definition,
+            restartAttempts: 0,
+        }));
+        this.restartBaseMs = options.restartBaseMs ?? 1000;
+        this.restartMaxMs = options.restartMaxMs ?? 30000;
+    }
+    start() {
+        for (const agent of this.running)
+            this.startAgent(agent);
+    }
+    async stop() {
+        this.stopping = true;
+        for (const agent of this.running) {
+            if (agent.restartTimer)
+                clearTimeout(agent.restartTimer);
+            agent.process?.kill("SIGTERM");
+        }
+        await Promise.all(this.running
+            .map((agent) => agent.process)
+            .filter((child) => !!child && child.exitCode === null && !child.killed)
+            .map((child) => new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                child.kill("SIGKILL");
+                resolve();
+            }, 8000);
+            child.once("exit", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        })));
+    }
+    restartAgent(name) {
+        const agent = this.running.find(({ definition }) => definition.name === name);
+        if (!agent)
+            return Promise.reject(new Error(`Agent is not managed by this client: ${name}`));
+        if (agent.restartPromise)
+            return agent.restartPromise;
+        agent.restartPromise = this.restartAgentProcess(agent).finally(() => {
+            agent.restartPromise = undefined;
+        });
+        return agent.restartPromise;
+    }
+    async activityStatus(timeoutMs = 1000) {
+        const [codex, claude] = await Promise.all([
+            this.agentActivityStatus("codex", timeoutMs),
+            this.agentActivityStatus("claude", timeoutMs),
+        ]);
+        const available = [codex, claude].filter((status) => status.available);
+        return {
+            active: available.reduce((sum, status) => sum + status.active, 0),
+            waiting: available.reduce((sum, status) => sum + status.waiting, 0),
+            agents: { codex, claude },
+        };
+    }
+    agentActivityStatus(name, timeoutMs) {
+        const child = this.running.find(({ definition }) => definition.name === name)?.process;
+        if (!child || !child.connected || !child.send) {
+            return Promise.resolve({ available: false, error: `${name} agent is not connected` });
+        }
+        return new Promise((resolve) => {
+            const requestId = randomUUID();
+            const request = { type: "client.activity.request", requestId };
+            let settled = false;
+            const finish = (status) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                child.off("message", onMessage);
+                resolve(status);
+            };
+            const onMessage = (message) => {
+                if (!isAgentActivityResponse(message) || message.requestId !== requestId || message.agent !== name)
+                    return;
+                finish({ available: true, ...message.snapshot });
+            };
+            const timer = setTimeout(() => finish({ available: false, error: `${name} agent did not respond` }), timeoutMs);
+            child.on("message", onMessage);
+            child.send(request, (err) => {
+                if (err)
+                    finish({ available: false, error: err.message });
+            });
+        });
+    }
+    async restartAgentProcess(agent) {
+        if (agent.restartTimer) {
+            clearTimeout(agent.restartTimer);
+            agent.restartTimer = undefined;
+        }
+        const child = agent.process;
+        if (child && child.exitCode === null && !child.killed) {
+            child.kill("SIGTERM");
+            await waitForExit(child);
+        }
+        if (this.stopping)
+            throw new Error("Client service is stopping");
+        agent.restartAttempts = 0;
+        this.startAgent(agent);
+    }
+    startAgent(agent) {
+        const env = {
+            ...process.env,
+            AGENT_CONFIG_PATH: this.options.configPath,
+        };
+        if (agent.definition.name === "workspace") {
+            delete env.OPENAI_API_KEY;
+            delete env.CODEX_API_KEY;
+            delete env.ANTHROPIC_API_KEY;
+        }
+        const child = (this.options.spawnProcess ?? spawn)(process.execPath, [agent.definition.entry], {
+            cwd: this.options.workspacePath,
+            env,
+            stdio: ["inherit", "inherit", "inherit", "ipc"],
+        });
+        agent.process = child;
+        console.log(`[client] started ${agent.definition.name}-agent pid=${child.pid}`);
+        child.once("exit", (code, signal) => {
+            agent.process = undefined;
+            if (this.stopping || agent.restartPromise)
+                return;
+            const delay = Math.min(this.restartBaseMs * 2 ** agent.restartAttempts, this.restartMaxMs);
+            agent.restartAttempts += 1;
+            console.error(`[client] ${agent.definition.name}-agent exited with code=${code ?? "null"} signal=${signal ?? "null"}; restarting in ${delay}ms`);
+            agent.restartTimer = setTimeout(() => {
+                agent.restartTimer = undefined;
+                this.startAgent(agent);
+            }, delay);
+        });
+    }
+}
+export async function runSupervisor(configPath) {
+    await syncBundledSkills(currentBundledSkillsDir(), defaultAgentHomes());
+    const workspacePath = await readWorkspacePathFromConfig(configPath);
+    const supervisor = new AgentSupervisor({ configPath, workspacePath });
+    const socketPath = await readControlSocketPath(configPath);
+    const maintenance = new MaintenanceScheduler({
+        statePath: join(dirname(socketPath), "maintenance.json"),
+        getActivity: () => supervisor.activityStatus(),
+        execute: (operation, markServiceExit) => executeMaintenanceOperation(operation, configPath, supervisor, markServiceExit),
+    });
+    await maintenance.start();
+    const autoUpgrade = new AutoUpgradeScheduler({
+        statePath: join(dirname(socketPath), "auto-upgrade.json"),
+        maintenance,
+        getChannel: () => readUpgradeChannel(configPath),
+    });
+    await autoUpgrade.start();
+    const controlServer = await startControlServer(socketPath, {
+        restartAgent: (agent) => supervisor.restartAgent(agent),
+        getActivity: () => supervisor.activityStatus(),
+        maintenance,
+    });
+    supervisor.start();
+    const stop = async () => {
+        autoUpgrade.stop();
+        maintenance.stop();
+        await controlServer.close();
+        await supervisor.stop();
+        process.exit(0);
+    };
+    process.once("SIGINT", () => void stop());
+    process.once("SIGTERM", () => void stop());
+}
+async function executeMaintenanceOperation(operation, configPath, supervisor, markServiceExit) {
+    if (operation.type === "upgrade") {
+        await installRuntime({ version: operation.version, configPath });
+        await markServiceExit("restarting");
+        await runServiceCommand(serviceCommands().restart);
+        return;
+    }
+    if (operation.type === "restart" && operation.agent) {
+        await supervisor.restartAgent(operation.agent);
+        return;
+    }
+    if (operation.type === "restart") {
+        await markServiceExit("restarting");
+        await runServiceCommand(serviceCommands().restart);
+        return;
+    }
+    if (operation.type === "stop") {
+        await markServiceExit("stopping");
+        await runServiceCommand(serviceCommands().stop);
+        return;
+    }
+    await markServiceExit("stopping");
+    await uninstallRunningService();
+}
+function serviceCommands() {
+    return process.platform === "darwin" ? darwinCommands() : linuxCommands();
+}
+async function runServiceCommand(command) {
+    const result = await runCommand("/bin/sh", ["-lc", command], { allowFailure: true });
+    if (result.status !== 0)
+        throw new Error(result.stderr || result.stdout || `Service command failed: ${command}`);
+}
+async function uninstallRunningService() {
+    const home = process.env.HOME ?? "";
+    if (process.platform === "linux") {
+        await runCommand("systemctl", ["--user", "disable", `${serviceName}.service`], { allowFailure: true });
+        await unlink(join(home, ".config", "systemd", "user", `${serviceName}.service`)).catch((err) => {
+            if (err.code !== "ENOENT")
+                throw err;
+        });
+        await runCommand("systemctl", ["--user", "daemon-reload"], { allowFailure: true });
+        await runCommand("systemctl", ["--user", "stop", `${serviceName}.service`], { allowFailure: true });
+        return;
+    }
+    if (process.platform === "darwin") {
+        const uid = process.getuid?.();
+        if (uid === undefined)
+            throw new Error("Unable to determine current uid for launchctl");
+        const servicePath = join(home, "Library", "LaunchAgents", `${launchdLabel}.plist`);
+        await unlink(servicePath).catch((err) => {
+            if (err.code !== "ENOENT")
+                throw err;
+        });
+        await runCommand("launchctl", ["bootout", `gui/${uid}/${launchdLabel}`], { allowFailure: true });
+        return;
+    }
+    throw new Error("Only Linux and macOS are supported");
+}
+function waitForExit(child) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+        }, 8000);
+        child.once("exit", () => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@messenger-agent/client",
+  "version": "0.24.0-alpha.2",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "coding-agent": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "cac": "^7.0.0",
+    "yaml": "^2.9.0",
+    "@messenger-agent/claude-agent": "0.24.0-alpha.2",
+    "@messenger-agent/messenger-agent": "0.24.0-alpha.2",
+    "@messenger-agent/codex-agent": "0.24.0-alpha.2",
+    "@messenger-agent/shared": "0.24.0-alpha.2"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && node ../../scripts/copy-client-assets.mjs && chmod +x dist/index.js",
+    "build:sourcemap": "rm -rf dist && tsc -p tsconfig.json --sourceMap && node ../../scripts/copy-client-assets.mjs && chmod +x dist/index.js",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  }
+}