@messenger-agent/client 0.24.0-alpha.2

package/dist/auto-upgrade.js

@@ -0,0 +1,184 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { compareSemverVersions, currentPackageVersion, isPrereleaseVersion, resolveChannelPackageVersion, } from "./runtime.js";
+const activeMaintenanceStatuses = new Set(["scheduled", "waiting", "running", "restarting", "stopping"]);
+export class AutoUpgradeScheduler {
+    options;
+    state;
+    timer;
+    checkIntervalMs;
+    pendingRetryMs;
+    now;
+    getCurrentVersion;
+    getLatestVersion;
+    getChannel;
+    constructor(options) {
+        this.options = options;
+        this.checkIntervalMs = options.checkIntervalMs ?? 2 * 60 * 60 * 1000;
+        this.pendingRetryMs = options.pendingRetryMs ?? 30_000;
+        this.now = options.now ?? Date.now;
+        this.getCurrentVersion = options.getCurrentVersion ?? currentPackageVersion;
+        this.getLatestVersion = options.getLatestVersion ?? resolveChannelPackageVersion;
+        this.getChannel = options.getChannel ?? (() => Promise.resolve("latest"));
+    }
+    async start() {
+        this.state = await this.readState();
+        if (this.state?.status === "pending" || this.state?.status === "scheduled") {
+            this.arm(this.pendingRetryMs);
+            return;
+        }
+        const lastCheckedAt = this.state?.lastCheckedAt ? Date.parse(this.state.lastCheckedAt) : undefined;
+        const untilNextCheck = lastCheckedAt === undefined ? this.checkIntervalMs : this.checkIntervalMs - (this.now() - lastCheckedAt);
+        this.arm(Math.max(0, untilNextCheck));
+    }
+    stop() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+    getState() {
+        return this.state ? structuredClone(this.state) : undefined;
+    }
+    async checkNow() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        await this.tick();
+    }
+    arm(delayMs) {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => void this.tick(), delayMs);
+        this.timer.unref();
+    }
+    async tick() {
+        this.timer = undefined;
+        try {
+            const channel = await this.getChannel();
+            const currentVersion = await this.getCurrentVersion();
+            let latestVersion = this.state?.status === "pending" || this.state?.status === "scheduled" ? this.state.latestVersion : undefined;
+            let lastCheckedAt = this.state?.lastCheckedAt;
+            if (!latestVersion) {
+                latestVersion = await this.getLatestVersion(channel);
+                lastCheckedAt = this.isoNow();
+            }
+            if (compareSemverVersions(latestVersion, currentVersion) <= 0) {
+                await this.updateState({
+                    status: "up-to-date",
+                    currentVersion,
+                    channel,
+                    latestVersion,
+                    lastCheckedAt,
+                    message: `Runtime ${currentVersion} is up to date on the ${channel} channel`,
+                });
+                this.arm(this.checkIntervalMs);
+                return;
+            }
+            if (channel === "latest" && isPrereleaseVersion(currentVersion) && !isPrereleaseVersion(latestVersion)) {
+                await this.updateState({
+                    status: "up-to-date",
+                    currentVersion,
+                    channel,
+                    latestVersion,
+                    lastCheckedAt,
+                    message: `Runtime ${currentVersion} is a pre-release ahead of the latest stable ${latestVersion}`,
+                });
+                this.arm(this.checkIntervalMs);
+                return;
+            }
+            const task = this.options.maintenance.getTask();
+            if (isMatchingAutomaticUpgrade(task, latestVersion)) {
+                await this.updateState({
+                    status: "scheduled",
+                    currentVersion,
+                    channel,
+                    latestVersion,
+                    lastCheckedAt,
+                    message: `Waiting to upgrade to ${latestVersion}`,
+                });
+                this.arm(this.pendingRetryMs);
+                return;
+            }
+            if (task && activeMaintenanceStatuses.has(task.status)) {
+                await this.updateState({
+                    status: "pending",
+                    currentVersion,
+                    channel,
+                    latestVersion,
+                    lastCheckedAt,
+                    message: `Waiting for maintenance task ${task.id}`,
+                });
+                this.arm(this.pendingRetryMs);
+                return;
+            }
+            if (task?.source === "automatic" && (task.status === "failed" || task.status === "cancelled")) {
+                await this.updateState({
+                    status: "failed",
+                    currentVersion,
+                    channel,
+                    latestVersion,
+                    lastCheckedAt,
+                    message: task.message ??
+                        (task.status === "cancelled"
+                            ? `Automatic upgrade to ${latestVersion} was cancelled`
+                            : `Automatic upgrade to ${latestVersion} failed`),
+                });
+                this.arm(this.checkIntervalMs);
+                return;
+            }
+            await this.options.maintenance.schedule({
+                operation: { type: "upgrade", version: latestVersion },
+                delaySeconds: 1,
+                allowWaiting: true,
+                source: "automatic",
+            });
+            await this.updateState({
+                status: "scheduled",
+                currentVersion,
+                channel,
+                latestVersion,
+                lastCheckedAt,
+                message: `Waiting to upgrade to ${latestVersion}`,
+            });
+            this.arm(this.pendingRetryMs);
+        }
+        catch (err) {
+            const currentVersion = await this.getCurrentVersion().catch(() => "unknown");
+            await this.updateState({
+                status: "failed",
+                currentVersion,
+                channel: this.state?.channel ?? "latest",
+                latestVersion: this.state?.latestVersion,
+                lastCheckedAt: this.isoNow(),
+                message: err instanceof Error ? err.message : String(err),
+            });
+            this.arm(this.checkIntervalMs);
+        }
+    }
+    async updateState(state) {
+        this.state = { ...state, updatedAt: this.isoNow() };
+        await mkdir(dirname(this.options.statePath), { recursive: true, mode: 0o700 });
+        const temporaryPath = `${this.options.statePath}.tmp`;
+        await writeFile(temporaryPath, `${JSON.stringify(this.state, null, 2)}\n`, { mode: 0o600 });
+        await rename(temporaryPath, this.options.statePath);
+    }
+    async readState() {
+        try {
+            return JSON.parse(await readFile(this.options.statePath, "utf8"));
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return undefined;
+            throw err;
+        }
+    }
+    isoNow() {
+        return new Date(this.now()).toISOString();
+    }
+}
+function isMatchingAutomaticUpgrade(task, version) {
+    return (task?.source === "automatic" &&
+        activeMaintenanceStatuses.has(task.status) &&
+        task.operation.type === "upgrade" &&
+        task.operation.version === version);
+}

package/dist/config-file.d.ts

@@ -0,0 +1,22 @@
+import { type ReleaseChannel } from "./runtime.js";
+export type ClientConfigOptions = {
+    configPath: string;
+    dataDir: string;
+    workspacePath: string;
+    workspaceId: string;
+    workspaceName?: string;
+    tunnelId: string;
+    token: string;
+    serverUrl?: string;
+    preserveWorkspaces?: boolean;
+};
+type YamlObject = Record<string, unknown>;
+export declare function ensureClientDirectories(dataDir: string, configPath: string): Promise<void>;
+export declare function readConfigYaml(configPath: string): Promise<YamlObject>;
+export declare function mergeClientConfig(existing: YamlObject, options: ClientConfigOptions): YamlObject;
+export declare function readUpgradeChannel(configPath: string): Promise<ReleaseChannel>;
+export declare function writeUpgradeChannel(configPath: string, channel: ReleaseChannel): Promise<void>;
+export declare function writeConfigYaml(configPath: string, config: YamlObject): Promise<void>;
+export declare function updateClientConfig(options: ClientConfigOptions): Promise<YamlObject>;
+export declare function assertPrivateConfig(configPath: string): Promise<void>;
+export {};

package/dist/config-file.js

@@ -0,0 +1,100 @@
+import { constants } from "node:fs";
+import { access, chmod, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { parse, stringify } from "yaml";
+import { normalizeReleaseChannel } from "./runtime.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function objectAt(config, key) {
+    const existing = config[key];
+    if (isRecord(existing))
+        return existing;
+    const next = {};
+    config[key] = next;
+    return next;
+}
+export async function ensureClientDirectories(dataDir, configPath) {
+    await mkdir(dirname(configPath), { recursive: true, mode: 0o700 });
+    await chmod(dirname(configPath), 0o700);
+    await mkdir(dataDir, { recursive: true, mode: 0o700 });
+    await mkdir(join(dataDir, "logs"), { recursive: true, mode: 0o700 });
+    await mkdir(join(dataDir, "uploads"), { recursive: true, mode: 0o700 });
+    await mkdir(join(dataDir, "runtime"), { recursive: true, mode: 0o700 });
+}
+async function fileExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function readConfigYaml(configPath) {
+    if (!(await fileExists(configPath)))
+        return {};
+    const parsed = parse(await readFile(configPath, "utf8"));
+    if (parsed === null || parsed === undefined)
+        return {};
+    if (!isRecord(parsed)) {
+        throw new Error(`Config file must contain a YAML object: ${configPath}`);
+    }
+    return parsed;
+}
+export function mergeClientConfig(existing, options) {
+    const config = { ...existing };
+    config.log_level ??= "info";
+    if (!options.preserveWorkspaces) {
+        config.workspaces = [
+            {
+                id: options.workspaceId,
+                name: options.workspaceName ?? `${options.tunnelId} Default`,
+                path: options.workspacePath,
+            },
+        ];
+    }
+    config.data_dir = options.dataDir;
+    const fileUploads = objectAt(config, "file_uploads");
+    fileUploads.temp_dir = join(options.dataDir, "uploads");
+    const tunnel = objectAt(config, "tunnel");
+    tunnel.enabled = true;
+    if (options.serverUrl)
+        tunnel.server_url = options.serverUrl;
+    tunnel.tunnel_id = options.tunnelId;
+    tunnel.token = options.token;
+    return config;
+}
+export async function readUpgradeChannel(configPath) {
+    const config = await readConfigYaml(configPath);
+    const autoUpgrade = config.auto_upgrade;
+    const value = isRecord(autoUpgrade) ? autoUpgrade.channel : undefined;
+    return normalizeReleaseChannel(value) ?? "latest";
+}
+export async function writeUpgradeChannel(configPath, channel) {
+    const config = await readConfigYaml(configPath);
+    const autoUpgrade = objectAt(config, "auto_upgrade");
+    autoUpgrade.channel = channel;
+    await writeConfigYaml(configPath, config);
+}
+export async function writeConfigYaml(configPath, config) {
+    await mkdir(dirname(configPath), { recursive: true, mode: 0o700 });
+    const tempPath = `${configPath}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tempPath, stringify(config), { mode: 0o600 });
+    await chmod(tempPath, 0o600);
+    await rename(tempPath, configPath);
+    await chmod(configPath, 0o600);
+}
+export async function updateClientConfig(options) {
+    await ensureClientDirectories(options.dataDir, options.configPath);
+    const existing = await readConfigYaml(options.configPath);
+    const next = mergeClientConfig(existing, options);
+    await writeConfigYaml(options.configPath, next);
+    return next;
+}
+export async function assertPrivateConfig(configPath) {
+    const mode = (await stat(configPath)).mode & 0o777;
+    if ((mode & 0o077) !== 0) {
+        throw new Error(`Config file permissions are too broad: ${configPath}`);
+    }
+}

package/dist/control.d.ts

@@ -0,0 +1,17 @@
+import type { ClientActivityStatus, ManagedAgentName } from "./supervisor.js";
+import type { MaintenanceScheduler, MaintenanceTask, ScheduleMaintenanceOptions } from "./maintenance.js";
+export type ClientControlHandlers = {
+    restartAgent(agent: ManagedAgentName): Promise<void>;
+    getActivity(): Promise<ClientActivityStatus>;
+    maintenance: MaintenanceScheduler;
+};
+export type ClientControlServer = {
+    close(): Promise<void>;
+};
+export declare function readControlSocketPath(configPath: string): Promise<string>;
+export declare function startControlServer(socketPath: string, handlers: ClientControlHandlers): Promise<ClientControlServer>;
+export declare function requestAgentRestart(configPath: string, agent: ManagedAgentName): Promise<void>;
+export declare function requestClientActivity(configPath: string): Promise<ClientActivityStatus>;
+export declare function requestScheduleMaintenance(configPath: string, options: ScheduleMaintenanceOptions): Promise<MaintenanceTask>;
+export declare function requestMaintenanceStatus(configPath: string): Promise<MaintenanceTask | undefined>;
+export declare function requestMaintenanceCancel(configPath: string): Promise<MaintenanceTask>;

package/dist/control.js

@@ -0,0 +1,152 @@
+import { chmod, mkdir, rm } from "node:fs/promises";
+import { createConnection, createServer } from "node:net";
+import { dirname, join } from "node:path";
+import { readConfigYaml } from "./config-file.js";
+import { defaultDataDir } from "./paths.js";
+export async function readControlSocketPath(configPath) {
+    const config = await readConfigYaml(configPath);
+    const dataDir = typeof config.data_dir === "string" && config.data_dir.trim() ? config.data_dir : defaultDataDir;
+    return join(dataDir, "runtime", "client.sock");
+}
+export async function startControlServer(socketPath, handlers) {
+    await mkdir(dirname(socketPath), { recursive: true, mode: 0o700 });
+    await rm(socketPath, { force: true });
+    const server = createServer({ allowHalfOpen: true }, (socket) => {
+        let input = "";
+        socket.setEncoding("utf8");
+        socket.on("error", () => {
+            // A caller may disconnect while an agent is still restarting.
+        });
+        socket.on("data", (chunk) => {
+            input += chunk;
+        });
+        socket.on("end", () => {
+            void handleRequest(input, handlers).then((response) => socket.end(`${JSON.stringify(response)}\n`));
+        });
+    });
+    await listen(server, socketPath);
+    await chmod(socketPath, 0o600);
+    return {
+        async close() {
+            await closeServer(server);
+            await rm(socketPath, { force: true });
+        },
+    };
+}
+export async function requestAgentRestart(configPath, agent) {
+    const socketPath = await readControlSocketPath(configPath);
+    const response = await sendRequest(socketPath, { action: "restart", agent }).catch((err) => {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new Error(`Unable to contact the coding-agent client service: ${detail}`);
+    });
+    if (!response.ok)
+        throw new Error(response.error ?? `Failed to restart ${agent} agent`);
+}
+export async function requestClientActivity(configPath) {
+    return requestData(configPath, { action: "activity" });
+}
+export async function requestScheduleMaintenance(configPath, options) {
+    return requestData(configPath, { action: "schedule-maintenance", ...options });
+}
+export async function requestMaintenanceStatus(configPath) {
+    return requestData(configPath, { action: "maintenance-status" });
+}
+export async function requestMaintenanceCancel(configPath) {
+    return requestData(configPath, { action: "maintenance-cancel" });
+}
+async function handleRequest(input, handlers) {
+    try {
+        const request = JSON.parse(input);
+        switch (request.action) {
+            case "restart":
+                if (request.agent !== "codex" && request.agent !== "claude") {
+                    return { ok: false, error: "Invalid control request" };
+                }
+                await handlers.restartAgent(request.agent);
+                return { ok: true };
+            case "activity":
+                return { ok: true, data: await handlers.getActivity() };
+            case "schedule-maintenance":
+                if (!isMaintenanceOperation(request.operation) ||
+                    !Number.isInteger(request.delaySeconds) ||
+                    typeof request.allowWaiting !== "boolean") {
+                    return { ok: false, error: "Invalid maintenance request" };
+                }
+                return {
+                    ok: true,
+                    data: await handlers.maintenance.schedule({
+                        operation: request.operation,
+                        delaySeconds: request.delaySeconds,
+                        allowWaiting: request.allowWaiting,
+                    }),
+                };
+            case "maintenance-status":
+                return { ok: true, data: handlers.maintenance.getTask() };
+            case "maintenance-cancel":
+                return { ok: true, data: await handlers.maintenance.cancel() };
+            default:
+                return { ok: false, error: "Invalid control request" };
+        }
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function isMaintenanceOperation(operation) {
+    if (!operation || typeof operation !== "object" || !("type" in operation))
+        return false;
+    if (operation.type === "upgrade") {
+        return "version" in operation && typeof operation.version === "string" && operation.version.length > 0;
+    }
+    if (operation.type === "restart") {
+        return !("agent" in operation &&
+            operation.agent !== undefined &&
+            operation.agent !== "codex" &&
+            operation.agent !== "claude");
+    }
+    return operation.type === "stop" || operation.type === "uninstall";
+}
+async function requestData(configPath, request) {
+    const socketPath = await readControlSocketPath(configPath);
+    const response = await sendRequest(socketPath, request).catch((err) => {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new Error(`Unable to contact the coding-agent client service: ${detail}`);
+    });
+    if (!response.ok)
+        throw new Error(response.error ?? "Client control request failed");
+    return response.data;
+}
+function listen(server, socketPath) {
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(socketPath, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+    });
+}
+function sendRequest(socketPath, request) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(socketPath);
+        let output = "";
+        socket.setEncoding("utf8");
+        socket.once("error", reject);
+        socket.on("data", (chunk) => {
+            output += chunk;
+        });
+        socket.once("connect", () => socket.end(JSON.stringify(request)));
+        socket.once("end", () => {
+            try {
+                resolve(JSON.parse(output));
+            }
+            catch {
+                reject(new Error("Invalid response from the coding-agent client service"));
+            }
+        });
+    });
+}

package/dist/exec.d.ts

@@ -0,0 +1,10 @@
+export type CommandResult = {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+};
+export declare function runCommand(command: string, args: string[], options?: {
+    allowFailure?: boolean;
+    interactive?: boolean;
+    env?: NodeJS.ProcessEnv;
+}): Promise<CommandResult>;

package/dist/exec.js

@@ -0,0 +1,37 @@
+import { spawn } from "node:child_process";
+export function runCommand(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        console.log(`$ ${command} ${args.join(" ")}`);
+        const child = spawn(command, args, {
+            stdio: options.interactive ? "inherit" : ["ignore", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ...options.env,
+                NODE_OPTIONS: "--use-system-ca",
+            },
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout?.on("data", (chunk) => {
+            // console.log(chunk.toString("utf8"))
+            stdoutChunks.push(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            // console.error(chunk.toString("utf8"))
+            stderrChunks.push(chunk);
+        });
+        child.on("error", reject);
+        child.on("close", (status) => {
+            const result = {
+                status,
+                stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                stderr: Buffer.concat(stderrChunks).toString("utf8"),
+            };
+            if (!options.allowFailure && status !== 0) {
+                reject(new Error(`${command} ${args.join(" ")} failed with status ${status}\n${result.stderr || result.stdout}`));
+                return;
+            }
+            resolve(result);
+        });
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};