@messenger-agent/client 0.24.0-alpha.2

package/dist/runtime.js

@@ -0,0 +1,241 @@
+import { access, cp, lstat, mkdir, readFile, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, delimiter, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runCommand } from "./exec.js";
+import { defaultBinDir, defaultRuntimeDir } from "./paths.js";
+const packageName = "@messenger-agent/client";
+export const releaseChannels = ["latest", "beta", "alpha"];
+export function normalizeReleaseChannel(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (value === "stable")
+        return "latest";
+    if (value === "latest" || value === "beta" || value === "alpha")
+        return value;
+    throw new Error(`Unknown release channel: ${String(value)} (expected latest, beta, or alpha)`);
+}
+export function parseReleaseChannel(value) {
+    return value === "stable" ? "latest" : value === "latest" || value === "beta" || value === "alpha" ? value : undefined;
+}
+export function normalizeUpgradeVersion(version, explicitChannel) {
+    const versionChannel = parseReleaseChannel(version);
+    const channel = explicitChannel ?? versionChannel;
+    return { version: versionChannel ? (channel ?? versionChannel) : version, channel };
+}
+export function isPrereleaseVersion(version) {
+    return /^\d+\.\d+\.\d+-/.test(version);
+}
+export function compareSemverVersions(left, right) {
+    const [leftVersion] = left.split("+", 1);
+    const [rightVersion] = right.split("+", 1);
+    const leftMatch = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(leftVersion ?? "");
+    const rightMatch = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(rightVersion ?? "");
+    if (!leftMatch || !rightMatch) {
+        throw new Error(`Automatic upgrades require semantic versions, received: ${left} and ${right}`);
+    }
+    for (let index = 1; index <= 3; index += 1) {
+        const difference = Number(leftMatch[index]) - Number(rightMatch[index]);
+        if (difference !== 0)
+            return Math.sign(difference);
+    }
+    return comparePrereleaseIdentifiers(leftMatch[4], rightMatch[4]);
+}
+function comparePrereleaseIdentifiers(left, right) {
+    if (!left && !right)
+        return 0;
+    if (!left)
+        return 1;
+    if (!right)
+        return -1;
+    const leftParts = left.split(".");
+    const rightParts = right.split(".");
+    for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+        const leftPart = leftParts[index];
+        const rightPart = rightParts[index];
+        if (leftPart === undefined)
+            return -1;
+        if (rightPart === undefined)
+            return 1;
+        const leftNumeric = /^\d+$/.test(leftPart);
+        const rightNumeric = /^\d+$/.test(rightPart);
+        if (leftNumeric && rightNumeric) {
+            const difference = Number(leftPart) - Number(rightPart);
+            if (difference !== 0)
+                return Math.sign(difference);
+            continue;
+        }
+        if (leftNumeric)
+            return -1;
+        if (rightNumeric)
+            return 1;
+        if (leftPart !== rightPart)
+            return leftPart < rightPart ? -1 : 1;
+    }
+    return 0;
+}
+export async function currentPackageVersion() {
+    const packagePath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const packageJson = JSON.parse(await readFile(packagePath, "utf8"));
+    return packageJson.version ?? "latest";
+}
+export function npmExecutablePath(nodeExecutable = process.execPath) {
+    return join(dirname(nodeExecutable), "npm");
+}
+export function npmProcessPath(nodeExecutable = process.execPath, currentPath = process.env.PATH) {
+    const nodeDirectory = dirname(nodeExecutable);
+    return currentPath ? `${nodeDirectory}${delimiter}${currentPath}` : nodeDirectory;
+}
+export function currentBundledSkillsDir(moduleUrl = import.meta.url) {
+    const moduleDir = dirname(fileURLToPath(moduleUrl));
+    return basename(moduleDir) === "src" ? join(moduleDir, "..", "assets", "skills") : join(moduleDir, "assets", "skills");
+}
+export function defaultAgentHomes() {
+    return [
+        process.env.CODEX_HOME ?? join(homedir(), ".codex"),
+        process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"),
+    ];
+}
+async function removePath(path) {
+    await rm(path, { recursive: true, force: true });
+}
+async function replaceSymlink(target, linkPath) {
+    const temporaryLink = `${linkPath}.tmp-${process.pid}`;
+    await removePath(temporaryLink);
+    await symlink(target, temporaryLink, "dir");
+    await rename(temporaryLink, linkPath);
+}
+async function isSymlink(path) {
+    try {
+        return (await lstat(path)).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export async function installRuntime(options) {
+    const runtimeDir = options.runtimeDir ?? defaultRuntimeDir;
+    const binDir = options.binDir ?? defaultBinDir;
+    const channel = parseReleaseChannel(options.version);
+    const version = options.version === "current"
+        ? await currentPackageVersion()
+        : channel
+            ? await resolveChannelPackageVersion(channel)
+            : options.version;
+    const releaseName = version.replaceAll("/", "_").replaceAll(":", "_");
+    const releasesDir = join(runtimeDir, "releases");
+    const releaseDir = join(releasesDir, releaseName);
+    const currentLink = join(runtimeDir, "current");
+    const packageEntry = join(releaseDir, "node_modules", "@messenger-agent", "client", "dist", "index.js");
+    const currentPackageEntry = join(currentLink, "node_modules", "@messenger-agent", "client", "dist", "index.js");
+    const skillsSourceDir = options.skillsSourceDir ??
+        join(releaseDir, "node_modules", "@messenger-agent", "client", "dist", "assets", "skills");
+    const wrapperPath = join(binDir, "coding-agent-client-service");
+    const cliWrapperPath = join(binDir, "coding-agent");
+    await mkdir(releasesDir, { recursive: true, mode: 0o700 });
+    await mkdir(binDir, { recursive: true, mode: 0o700 });
+    if (!(await pathExists(packageEntry))) {
+        const temporaryReleaseDir = `${releaseDir}.tmp-${process.pid}`;
+        await removePath(temporaryReleaseDir);
+        await mkdir(temporaryReleaseDir, { recursive: true, mode: 0o700 });
+        try {
+            await runCommand(npmExecutablePath(), ["install", "--prefix", temporaryReleaseDir, "--omit=dev", "--verbose", `${packageName}@${version}`], { env: { PATH: npmProcessPath() } });
+            await removePath(releaseDir);
+            await rename(temporaryReleaseDir, releaseDir);
+        }
+        catch (err) {
+            await removePath(temporaryReleaseDir);
+            throw err;
+        }
+    }
+    const [defaultCodexHome, defaultClaudeHome] = defaultAgentHomes();
+    await syncBundledSkills(skillsSourceDir, [
+        options.codexHome ?? defaultCodexHome,
+        options.claudeHome ?? defaultClaudeHome,
+    ]);
+    if (!(await isSymlink(currentLink))) {
+        await removePath(currentLink);
+    }
+    await replaceSymlink(releaseDir, currentLink);
+    await writeFile(wrapperPath, [
+        "#!/bin/sh",
+        "set -eu",
+        `export AGENT_CONFIG_PATH=${shellSingleQuote(options.configPath)}`,
+        `exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(packageEntry)} run-service --config ${shellSingleQuote(options.configPath)}`,
+        "",
+    ].join("\n"), { mode: 0o700 });
+    await writeFile(cliWrapperPath, [
+        "#!/bin/sh",
+        "set -eu",
+        `export AGENT_CONFIG_PATH=${shellSingleQuote(options.configPath)}`,
+        `exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(currentPackageEntry)} "$@"`,
+        "",
+    ].join("\n"), { mode: 0o700 });
+    return { releaseDir, currentLink, wrapperPath, cliWrapperPath, version };
+}
+export async function resolveChannelPackageVersion(channel) {
+    const result = await runCommand(npmExecutablePath(), ["view", `${packageName}@${channel}`, "version", "--json"], {
+        allowFailure: true,
+        env: { PATH: npmProcessPath() },
+    });
+    if (result.status !== 0) {
+        throw new Error(`Unable to resolve the ${channel} coding-agent version: ${result.stderr || result.stdout}`);
+    }
+    const value = JSON.parse(result.stdout);
+    if (typeof value !== "string" || !value)
+        throw new Error("Registry returned an invalid coding-agent version");
+    return value;
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function syncBundledSkills(skillsSourceDir, agentHomes) {
+    const skillName = "manage-coding-agent-client";
+    const source = join(skillsSourceDir, skillName);
+    const sourceExists = await isDirectory(source);
+    for (const home of new Set(agentHomes)) {
+        const skillsDir = join(home, "skills");
+        const target = join(skillsDir, skillName);
+        const temporary = join(skillsDir, `.${skillName}.tmp-${process.pid}`);
+        const backup = join(skillsDir, `.${skillName}.old-${process.pid}`);
+        await rm(temporary, { recursive: true, force: true });
+        await rm(backup, { recursive: true, force: true });
+        if (!sourceExists) {
+            await rm(target, { recursive: true, force: true });
+            continue;
+        }
+        await mkdir(skillsDir, { recursive: true, mode: 0o700 });
+        await cp(source, temporary, { recursive: true });
+        await rename(target, backup).catch((err) => {
+            if (err.code !== "ENOENT")
+                throw err;
+        });
+        try {
+            await rename(temporary, target);
+            await rm(backup, { recursive: true, force: true });
+        }
+        catch (err) {
+            await rename(backup, target).catch(() => undefined);
+            throw err;
+        }
+    }
+}
+async function isDirectory(path) {
+    try {
+        return (await lstat(path)).isDirectory();
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return false;
+        throw err;
+    }
+}
+function shellSingleQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/dist/service.d.ts

@@ -0,0 +1,41 @@
+import { type CommandResult } from "./exec.js";
+export declare const serviceName = "coding-agent-client";
+export declare const launchdLabel = "vip.elevo.coding-agent.client";
+export type ServiceInstallOptions = {
+    configPath: string;
+    dataDir: string;
+    workspacePath: string;
+    serviceCommandPath: string;
+    platform?: NodeJS.Platform;
+    uid?: number;
+    user?: string;
+};
+export type ServiceCommands = {
+    status: string;
+    logs: string;
+    start: string;
+    restart: string;
+    stop: string;
+    uninstall: string;
+};
+export type ServiceInstallResult = {
+    servicePath: string;
+    commands: ServiceCommands;
+    warnings: string[];
+};
+export declare function shellEscape(value: string): string;
+export declare function createSystemdService(options: ServiceInstallOptions): string;
+export declare function createLaunchdPlist(options: ServiceInstallOptions): string;
+type LingerDependencies = {
+    commandExists: (command: string) => Promise<boolean>;
+    runCommand: (command: string, args: string[], options?: {
+        allowFailure?: boolean;
+        interactive?: boolean;
+    }) => Promise<CommandResult>;
+};
+export declare function ensureSystemdUserLinger(user: string, dependencies?: LingerDependencies): Promise<void>;
+export declare function installService(options: ServiceInstallOptions): Promise<ServiceInstallResult>;
+export declare function linuxCommands(): ServiceCommands;
+export declare function darwinCommands(): ServiceCommands;
+export declare function uninstallService(platform?: NodeJS.Platform): Promise<void>;
+export {};

package/dist/service.js

@@ -0,0 +1,208 @@
+import { access, chmod, mkdir, unlink, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { dirname, join } from "node:path";
+import { runCommand } from "./exec.js";
+export const serviceName = "coding-agent-client";
+export const launchdLabel = "vip.elevo.coding-agent.client";
+export function shellEscape(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+export function createSystemdService(options) {
+    return [
+        "[Unit]",
+        "Description=Coding Agent Client",
+        "After=network-online.target",
+        "",
+        "[Service]",
+        "Type=simple",
+        `ExecStart=${systemdEscape(options.serviceCommandPath)}`,
+        "Restart=always",
+        "RestartSec=5",
+        `WorkingDirectory=${systemdEscape(options.workspacePath)}`,
+        `Environment=${systemdEnv("AGENT_CONFIG_PATH", options.configPath)}`,
+        "",
+        "[Install]",
+        "WantedBy=default.target",
+        "",
+    ].join("\n");
+}
+function systemdEscape(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll(" ", "\\x20");
+}
+function systemdEnv(name, value) {
+    return `${name}=${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}`;
+}
+function xmlEscape(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
+}
+export function createLaunchdPlist(options) {
+    const stdoutPath = join(options.dataDir, "logs", "client-service.out.log");
+    const stderrPath = join(options.dataDir, "logs", "client-service.err.log");
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        '<plist version="1.0">',
+        "<dict>",
+        "  <key>Label</key>",
+        `  <string>${xmlEscape(launchdLabel)}</string>`,
+        "  <key>ProgramArguments</key>",
+        "  <array>",
+        `    <string>${xmlEscape(options.serviceCommandPath)}</string>`,
+        "  </array>",
+        "  <key>WorkingDirectory</key>",
+        `  <string>${xmlEscape(options.workspacePath)}</string>`,
+        "  <key>EnvironmentVariables</key>",
+        "  <dict>",
+        "    <key>AGENT_CONFIG_PATH</key>",
+        `    <string>${xmlEscape(options.configPath)}</string>`,
+        "  </dict>",
+        "  <key>RunAtLoad</key>",
+        "  <true/>",
+        "  <key>KeepAlive</key>",
+        "  <true/>",
+        "  <key>StandardOutPath</key>",
+        `  <string>${xmlEscape(stdoutPath)}</string>`,
+        "  <key>StandardErrorPath</key>",
+        `  <string>${xmlEscape(stderrPath)}</string>`,
+        "</dict>",
+        "</plist>",
+        "",
+    ].join("\n");
+}
+async function commandExists(command) {
+    const pathDirs = (process.env.PATH ?? "").split(":").filter(Boolean);
+    for (const pathDir of pathDirs) {
+        try {
+            await access(join(pathDir, command));
+            return true;
+        }
+        catch {
+            // continue
+        }
+    }
+    return false;
+}
+const defaultLingerDependencies = { commandExists, runCommand };
+export async function ensureSystemdUserLinger(user, dependencies = defaultLingerDependencies) {
+    if (!(await dependencies.commandExists("loginctl"))) {
+        throw new Error(`loginctl is required to keep the user service running after logout. Enable linger for ${user} and retry installation.`);
+    }
+    if (await isLingerEnabled(user, dependencies.runCommand))
+        return;
+    console.log(`Enabling login persistence for ${user}`);
+    const enable = await dependencies.runCommand("loginctl", ["enable-linger", user], {
+        allowFailure: true,
+        interactive: true,
+    });
+    if (enable.status !== 0) {
+        throw new Error(`Unable to enable login persistence for ${user}. Run 'sudo loginctl enable-linger ${user}' and retry installation.`);
+    }
+    if (!(await isLingerEnabled(user, dependencies.runCommand))) {
+        throw new Error(`Login persistence is still disabled for ${user}. Run 'sudo loginctl enable-linger ${user}' and retry installation.`);
+    }
+}
+async function isLingerEnabled(user, command) {
+    const result = await command("loginctl", ["show-user", user, "-p", "Linger"], { allowFailure: true });
+    return result.status === 0 && result.stdout.trim() === "Linger=yes";
+}
+export async function installService(options) {
+    const platform = options.platform ?? process.platform;
+    if (platform === "linux")
+        return installSystemdService(options);
+    if (platform === "darwin")
+        return installLaunchdService(options);
+    throw new Error("Only Linux and macOS are supported");
+}
+async function installSystemdService(options) {
+    if (!(await commandExists("systemctl"))) {
+        throw new Error("systemctl is required to install the user service");
+    }
+    const user = options.user ?? process.env.USER ?? userInfo().username;
+    await ensureSystemdUserLinger(user);
+    const servicePath = join(process.env.HOME ?? "", ".config", "systemd", "user", `${serviceName}.service`);
+    await mkdir(dirname(servicePath), { recursive: true, mode: 0o700 });
+    await writeFile(servicePath, createSystemdService(options), { mode: 0o600 });
+    await chmod(servicePath, 0o600);
+    await runCommand("systemctl", ["--user", "daemon-reload"]);
+    await runCommand("systemctl", ["--user", "enable", "--now", `${serviceName}.service`]);
+    await runCommand("systemctl", ["--user", "restart", `${serviceName}.service`]);
+    return {
+        servicePath,
+        commands: linuxCommands(),
+        warnings: [],
+    };
+}
+async function installLaunchdService(options) {
+    if (!(await commandExists("launchctl"))) {
+        throw new Error("launchctl is required to install the LaunchAgent");
+    }
+    const servicePath = join(process.env.HOME ?? "", "Library", "LaunchAgents", `${launchdLabel}.plist`);
+    await mkdir(dirname(servicePath), { recursive: true, mode: 0o700 });
+    await writeFile(servicePath, createLaunchdPlist(options), { mode: 0o600 });
+    await chmod(servicePath, 0o600);
+    const uid = options.uid ?? process.getuid?.();
+    if (uid === undefined) {
+        throw new Error("Unable to determine current uid for launchctl");
+    }
+    const domain = `gui/${uid}`;
+    await runCommand("launchctl", ["bootout", domain, servicePath], { allowFailure: true });
+    await runCommand("launchctl", ["bootstrap", domain, servicePath]);
+    await runCommand("launchctl", ["kickstart", "-k", `${domain}/${launchdLabel}`]);
+    return {
+        servicePath,
+        commands: darwinCommands(),
+        warnings: [],
+    };
+}
+export function linuxCommands() {
+    return {
+        status: `systemctl --user status ${serviceName}.service`,
+        logs: `journalctl --user -u ${serviceName}.service -n 100 -f`,
+        start: `systemctl --user start ${serviceName}.service`,
+        restart: `systemctl --user restart ${serviceName}.service`,
+        stop: `systemctl --user stop ${serviceName}.service`,
+        uninstall: `systemctl --user disable --now ${serviceName}.service && rm -f ~/.config/systemd/user/${serviceName}.service && systemctl --user daemon-reload`,
+    };
+}
+export function darwinCommands() {
+    const domain = "gui/$(id -u)";
+    const servicePath = `~/Library/LaunchAgents/${launchdLabel}.plist`;
+    return {
+        status: `launchctl print ${domain}/${launchdLabel}`,
+        logs: "tail -f ~/.coding-agent/data/logs/client-service.out.log ~/.coding-agent/data/logs/client-service.err.log",
+        start: `launchctl bootstrap ${domain} ${servicePath}`,
+        restart: `launchctl bootout ${domain} ${servicePath} 2>/dev/null || true; launchctl bootstrap ${domain} ${servicePath}`,
+        stop: `launchctl bootout ${domain} ${servicePath}`,
+        uninstall: `launchctl bootout ${domain} ${servicePath}; rm -f ${servicePath}`,
+    };
+}
+export async function uninstallService(platform = process.platform) {
+    if (platform === "linux") {
+        await runCommand("systemctl", ["--user", "disable", "--now", `${serviceName}.service`], { allowFailure: true });
+        await unlink(join(process.env.HOME ?? "", ".config", "systemd", "user", `${serviceName}.service`)).catch((err) => {
+            if (err.code !== "ENOENT")
+                throw err;
+        });
+        await runCommand("systemctl", ["--user", "daemon-reload"], { allowFailure: true });
+        return;
+    }
+    if (platform === "darwin") {
+        const uid = process.getuid?.();
+        if (uid === undefined) {
+            throw new Error("Unable to determine current uid for launchctl");
+        }
+        const servicePath = join(process.env.HOME ?? "", "Library", "LaunchAgents", `${launchdLabel}.plist`);
+        await runCommand("launchctl", ["bootout", `gui/${uid}`, servicePath], { allowFailure: true });
+        await unlink(servicePath).catch((err) => {
+            if (err.code !== "ENOENT")
+                throw err;
+        });
+        return;
+    }
+    throw new Error("Only Linux and macOS are supported");
+}

package/dist/supervisor.d.ts

@@ -0,0 +1,45 @@
+import { spawn } from "node:child_process";
+import { type AgentActivitySnapshot, type ManagedAgentName } from "@messenger-agent/shared/agent-activity";
+export type { ManagedAgentName } from "@messenger-agent/shared/agent-activity";
+export type AgentActivityStatus = ({
+    available: true;
+} & AgentActivitySnapshot) | {
+    available: false;
+    error: string;
+};
+export type ClientActivityStatus = {
+    active: number;
+    waiting: number;
+    agents: Record<ManagedAgentName, AgentActivityStatus>;
+};
+export type ManagedAgent = {
+    name: ManagedProcessName;
+    entry: string;
+};
+export type ManagedProcessName = ManagedAgentName | "workspace";
+export type SupervisorOptions = {
+    configPath: string;
+    workspacePath: string;
+    agents?: ManagedAgent[];
+    restartBaseMs?: number;
+    restartMaxMs?: number;
+    spawnProcess?: typeof spawn;
+};
+export declare function resolveAgentEntries(): ManagedAgent[];
+export declare function readWorkspacePathFromConfig(configPath: string): Promise<string>;
+export declare class AgentSupervisor {
+    private readonly options;
+    private stopping;
+    private readonly running;
+    private readonly restartBaseMs;
+    private readonly restartMaxMs;
+    constructor(options: SupervisorOptions);
+    start(): void;
+    stop(): Promise<void>;
+    restartAgent(name: ManagedAgentName): Promise<void>;
+    activityStatus(timeoutMs?: number): Promise<ClientActivityStatus>;
+    private agentActivityStatus;
+    private restartAgentProcess;
+    private startAgent;
+}
+export declare function runSupervisor(configPath: string): Promise<void>;