@messenger-agent/client 0.24.0-alpha.2

package/dist/index.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { parseCliArgs, UsageError, usage } from "./args.js";
+import { installClient } from "./install.js";
+import { currentPackageVersion, installRuntime, normalizeUpgradeVersion } from "./runtime.js";
+import { darwinCommands, linuxCommands, serviceName, uninstallService } from "./service.js";
+import { runSupervisor } from "./supervisor.js";
+import { runCommand } from "./exec.js";
+import { defaultConfigPath } from "./paths.js";
+import { writeUpgradeChannel } from "./config-file.js";
+import { requestAgentRestart, requestClientActivity, requestMaintenanceCancel, requestMaintenanceStatus, requestScheduleMaintenance, } from "./control.js";
+async function main() {
+    const args = parseCliArgs(process.argv.slice(2));
+    if (args.command === "version") {
+        console.log(`coding-agent ${await currentPackageVersion()}`);
+        return;
+    }
+    if (args.command === "run-service") {
+        await runSupervisor(args.configPath ?? process.env.AGENT_CONFIG_PATH ?? defaultConfigPath);
+        return;
+    }
+    if (args.command === "install") {
+        const result = await installClient(args);
+        console.log(`Installed ${serviceName}`);
+        console.log(`Config: ${result.configPath}`);
+        console.log(`Data: ${result.dataDir}`);
+        console.log(`Runtime: ${result.runtime.currentLink}`);
+        console.log(`Command: ${result.runtime.cliWrapperPath}`);
+        console.log(`Service file: ${result.service.servicePath}`);
+        console.log(`Upgrade: ${result.runtime.cliWrapperPath} upgrade`);
+        console.log(`Restart: ${result.runtime.cliWrapperPath} restart`);
+        console.log(`Status: ${result.runtime.cliWrapperPath} status`);
+        console.log(`Logs: ${result.service.commands.logs}`);
+        for (const warning of result.service.warnings)
+            console.warn(`Warning: ${warning}`);
+        return;
+    }
+    if (args.command === "upgrade") {
+        const { version, channel } = normalizeUpgradeVersion(args.version, args.channel);
+        if (channel) {
+            await writeUpgradeChannel(args.configPath, channel);
+            console.log(`Auto-upgrade channel: ${channel}`);
+        }
+        if (args.delaySeconds !== undefined) {
+            await scheduleMaintenance(args.configPath, { type: "upgrade", version }, args.delaySeconds, args.allowWaiting);
+            return;
+        }
+        const runtime = await installRuntime({ version, configPath: args.configPath });
+        const commands = process.platform === "darwin" ? darwinCommands() : linuxCommands();
+        await runShellCommand(commands.restart);
+        console.log(`Upgraded runtime to ${runtime.version}`);
+        console.log(`Runtime: ${runtime.currentLink}`);
+        console.log(`Command: ${runtime.cliWrapperPath}`);
+        console.log(`Status: ${runtime.cliWrapperPath} status`);
+        return;
+    }
+    if (args.command === "sessions") {
+        const activity = await requestClientActivity(args.configPath);
+        console.log(args.json ? JSON.stringify(activity) : formatActivity(activity));
+        return;
+    }
+    if (args.command === "maintenance") {
+        const task = args.action === "cancel"
+            ? await requestMaintenanceCancel(args.configPath)
+            : await requestMaintenanceStatus(args.configPath);
+        console.log(args.json ? JSON.stringify(task ?? null) : formatMaintenanceTask(task));
+        return;
+    }
+    if (args.command === "restart" && args.agent) {
+        if (args.delaySeconds !== undefined) {
+            await scheduleMaintenance(process.env.AGENT_CONFIG_PATH ?? defaultConfigPath, { type: "restart", agent: args.agent }, args.delaySeconds, args.allowWaiting);
+            return;
+        }
+        await requestAgentRestart(process.env.AGENT_CONFIG_PATH ?? defaultConfigPath, args.agent);
+        console.log(`Restarted ${args.agent} agent`);
+        return;
+    }
+    if (args.command === "status" || args.command === "start" || args.command === "restart" || args.command === "stop") {
+        if ((args.command === "restart" || args.command === "stop") && args.delaySeconds !== undefined) {
+            await scheduleMaintenance(process.env.AGENT_CONFIG_PATH ?? defaultConfigPath, { type: args.command }, args.delaySeconds, args.allowWaiting);
+            return;
+        }
+        const commands = process.platform === "darwin" ? darwinCommands() : linuxCommands();
+        const command = args.command === "status"
+            ? commands.status
+            : args.command === "start"
+                ? commands.start
+                : args.command === "restart"
+                    ? commands.restart
+                    : commands.stop;
+        await runShellCommand(command);
+        return;
+    }
+    if (args.command === "uninstall") {
+        if (args.delaySeconds !== undefined) {
+            await scheduleMaintenance(process.env.AGENT_CONFIG_PATH ?? defaultConfigPath, { type: "uninstall" }, args.delaySeconds, args.allowWaiting);
+            return;
+        }
+        await uninstallService();
+        console.log(`Uninstalled ${serviceName}`);
+        return;
+    }
+}
+async function scheduleMaintenance(configPath, operation, delaySeconds, allowWaiting) {
+    const task = await requestScheduleMaintenance(configPath, { operation, delaySeconds, allowWaiting });
+    console.log(`Scheduled maintenance task ${task.id}`);
+    console.log(`Operation: ${formatOperation(task.operation)}`);
+    console.log(`Not before: ${task.notBefore}`);
+}
+function formatActivity(activity) {
+    const lines = [`Active sessions: ${activity.active}`, `Waiting sessions: ${activity.waiting}`];
+    for (const name of ["codex", "claude"]) {
+        const status = activity.agents[name];
+        lines.push(status.available
+            ? `${capitalize(name)}: active=${status.active}, waiting=${status.waiting}`
+            : `${capitalize(name)}: unavailable (${status.error})`);
+    }
+    return lines.join("\n");
+}
+function formatMaintenanceTask(task) {
+    if (!task)
+        return "No maintenance task has been scheduled";
+    return [
+        `Task: ${task.id}`,
+        `Operation: ${formatOperation(task.operation)}`,
+        `Status: ${task.status}`,
+        `Not before: ${task.notBefore}`,
+        ...(task.message ? [`Message: ${task.message}`] : []),
+    ].join("\n");
+}
+function formatOperation(operation) {
+    if (operation.type === "upgrade")
+        return `upgrade to ${operation.version}`;
+    if (operation.type === "restart")
+        return operation.agent ? `restart ${operation.agent}` : "restart client";
+    return operation.type;
+}
+function capitalize(value) {
+    return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+async function runShellCommand(command) {
+    const result = await runCommand("/bin/sh", ["-lc", command], { allowFailure: true });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    if (result.status !== 0)
+        process.exit(result.status ?? 1);
+}
+main().catch((err) => {
+    if (err instanceof UsageError) {
+        const message = err.message === usage() ? err.message : `${err.message}\n\n${usage()}`;
+        console.error(message);
+        process.exit(2);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(message);
+    process.exit(1);
+});

package/dist/install.d.ts

@@ -0,0 +1,26 @@
+import { type RuntimeInstallResult } from "./runtime.js";
+import { type ServiceInstallResult } from "./service.js";
+import { type InstallArgs } from "./args.js";
+export type InstallResult = {
+    configPath: string;
+    dataDir: string;
+    workspacePath: string;
+    runtime: RuntimeInstallResult;
+    service: ServiceInstallResult;
+};
+type ResolvedInstallArgs = Omit<InstallArgs, "tunnelId" | "token" | "workspace" | "workspaceId" | "workspaceName"> & {
+    tunnelId: string;
+    token: string;
+    workspace: string;
+    workspaceId: string;
+    workspaceName: string;
+    preserveWorkspaces: boolean;
+    createWorkspace: boolean;
+};
+export declare function assertSupportedPlatform(platform?: NodeJS.Platform): void;
+export declare function assertNodeVersion(version?: string): void;
+export declare function validateInstallArgs(args: InstallArgs): void;
+export declare function resolveWorkspacePath(path: string, createIfMissing?: boolean): Promise<string>;
+export declare function installClient(args: InstallArgs): Promise<InstallResult>;
+export declare function resolveInstallArgs(args: InstallArgs): Promise<ResolvedInstallArgs>;
+export {};

package/dist/install.js

@@ -0,0 +1,142 @@
+import { mkdir, realpath, stat } from "node:fs/promises";
+import { readConfigYaml, updateClientConfig, writeUpgradeChannel } from "./config-file.js";
+import { installRuntime } from "./runtime.js";
+import { installService } from "./service.js";
+import { UsageError } from "./args.js";
+import { defaultWorkspacePath } from "./paths.js";
+export function assertSupportedPlatform(platform = process.platform) {
+    if (platform !== "linux" && platform !== "darwin") {
+        throw new Error("Only Linux and macOS are supported");
+    }
+}
+export function assertNodeVersion(version = process.versions.node) {
+    const major = Number.parseInt(version.split(".")[0] ?? "", 10);
+    if (!Number.isInteger(major) || major < 24) {
+        throw new Error("Node.js 24 or newer is required");
+    }
+}
+export function validateInstallArgs(args) {
+    if (args.tunnelId && !/^[A-Za-z0-9._:-]+$/.test(args.tunnelId)) {
+        throw new Error("--tunnel-id may only contain letters, numbers, '.', '_', ':', and '-'");
+    }
+    if (args.workspaceId && !/^[A-Za-z0-9._:-]+$/.test(args.workspaceId)) {
+        throw new Error("--workspace-id may only contain letters, numbers, '.', '_', ':', and '-'");
+    }
+    if (args.workspaceName && (args.workspaceName.trim().length === 0 || args.workspaceName.trim().length > 128)) {
+        throw new Error("--workspace-name must be between 1 and 128 characters");
+    }
+}
+export async function resolveWorkspacePath(path, createIfMissing = false) {
+    if (createIfMissing)
+        await mkdir(path, { recursive: true });
+    const resolved = await realpath(path);
+    const stats = await stat(resolved);
+    if (!stats.isDirectory()) {
+        throw new Error("--workspace must point to an existing directory");
+    }
+    return resolved;
+}
+export async function installClient(args) {
+    assertSupportedPlatform();
+    assertNodeVersion();
+    const resolvedArgs = await resolveInstallArgs(args);
+    validateInstallArgs(resolvedArgs);
+    const workspacePath = await resolveWorkspacePath(resolvedArgs.workspace, resolvedArgs.createWorkspace);
+    await updateClientConfig({
+        configPath: resolvedArgs.configPath,
+        dataDir: resolvedArgs.dataDir,
+        workspacePath,
+        workspaceId: resolvedArgs.workspaceId,
+        workspaceName: resolvedArgs.workspaceName,
+        tunnelId: resolvedArgs.tunnelId,
+        token: resolvedArgs.token,
+        serverUrl: resolvedArgs.serverUrl,
+        preserveWorkspaces: resolvedArgs.preserveWorkspaces,
+    });
+    if (args.channel)
+        await writeUpgradeChannel(resolvedArgs.configPath, args.channel);
+    const runtime = await installRuntime({ version: "current", configPath: resolvedArgs.configPath });
+    const service = await installService({
+        configPath: resolvedArgs.configPath,
+        dataDir: resolvedArgs.dataDir,
+        workspacePath,
+        serviceCommandPath: runtime.wrapperPath,
+    });
+    return {
+        configPath: resolvedArgs.configPath,
+        dataDir: resolvedArgs.dataDir,
+        workspacePath,
+        runtime,
+        service,
+    };
+}
+export async function resolveInstallArgs(args) {
+    const existing = await readConfigYaml(args.configPath);
+    const existingTunnel = objectAt(existing, "tunnel");
+    const tunnelId = args.tunnelId ?? stringAt(existingTunnel, "tunnel_id");
+    const token = args.token ?? stringAt(existingTunnel, "token");
+    const configuredWorkspace = findConfiguredWorkspace(existing, args.workspaceId, tunnelId);
+    const workspace = args.workspace ?? configuredWorkspace?.path ?? defaultWorkspacePath;
+    const workspaceId = args.workspaceId ?? configuredWorkspace?.id ?? (tunnelId ? `${tunnelId}--default` : undefined);
+    const workspaceName = args.workspaceName ?? configuredWorkspace?.name ?? (tunnelId ? `${tunnelId} Default` : undefined);
+    const usesDefaultWorkspace = workspace === defaultWorkspacePath;
+    if (!tunnelId)
+        throw new UsageError("Missing required option: --tunnel-id");
+    if (!token)
+        throw new UsageError("Missing required option: --token");
+    if (!workspaceId)
+        throw new UsageError("Missing required option: --workspace-id");
+    if (!workspaceName)
+        throw new UsageError("Missing required option: --workspace-name");
+    return {
+        ...args,
+        tunnelId,
+        token,
+        workspace,
+        workspaceId,
+        workspaceName,
+        preserveWorkspaces: !args.workspace && !!configuredWorkspace,
+        createWorkspace: usesDefaultWorkspace,
+    };
+}
+function findConfiguredWorkspace(config, requestedWorkspaceId, tunnelId) {
+    const workspaces = config.workspaces;
+    if (!Array.isArray(workspaces))
+        return undefined;
+    const candidates = workspaces.filter((workspace) => !!workspace && typeof workspace === "object" && !Array.isArray(workspace) && typeof workspace.path === "string");
+    if (requestedWorkspaceId) {
+        const requested = candidates.find((workspace) => workspace.id === requestedWorkspaceId);
+        if (!requested || typeof requested.path !== "string")
+            return undefined;
+        return {
+            id: requestedWorkspaceId,
+            name: typeof requested.name === "string" && requested.name
+                ? requested.name
+                : `${tunnelId ?? requestedWorkspaceId} Default`,
+            path: requested.path,
+        };
+    }
+    const preferredId = requestedWorkspaceId ?? (tunnelId ? `${tunnelId}--default` : undefined);
+    const configured = (preferredId ? candidates.find((workspace) => workspace.id === preferredId) : undefined) ??
+        candidates.find((workspace) => workspace.id === "default") ??
+        candidates[0];
+    if (!configured || typeof configured.path !== "string")
+        return undefined;
+    return {
+        id: typeof configured.id === "string" && configured.id ? configured.id : (preferredId ?? "default"),
+        name: typeof configured.name === "string" && configured.name
+            ? configured.name
+            : `${tunnelId ?? preferredId ?? "default"} Default`,
+        path: configured.path,
+    };
+}
+function objectAt(config, key) {
+    const value = config[key];
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function stringAt(config, key) {
+    const value = config?.[key];
+    return typeof value === "string" && value ? value : undefined;
+}

package/dist/maintenance.d.ts

@@ -0,0 +1,63 @@
+import type { ClientActivityStatus, ManagedAgentName } from "./supervisor.js";
+export type MaintenanceOperation = {
+    type: "upgrade";
+    version: string;
+} | {
+    type: "restart";
+    agent?: ManagedAgentName;
+} | {
+    type: "stop";
+} | {
+    type: "uninstall";
+};
+export type MaintenanceTaskStatus = "scheduled" | "waiting" | "running" | "restarting" | "stopping" | "completed" | "failed" | "cancelled";
+export type MaintenanceTask = {
+    id: string;
+    operation: MaintenanceOperation;
+    status: MaintenanceTaskStatus;
+    allowWaiting: boolean;
+    createdAt: string;
+    notBefore: string;
+    updatedAt: string;
+    completedAt?: string;
+    message?: string;
+    source?: "manual" | "automatic";
+};
+export type ScheduleMaintenanceOptions = {
+    operation: MaintenanceOperation;
+    delaySeconds: number;
+    allowWaiting: boolean;
+    source?: "manual" | "automatic";
+};
+type MaintenanceSchedulerOptions = {
+    statePath: string;
+    getActivity: () => Promise<ClientActivityStatus>;
+    execute: (operation: MaintenanceOperation, markServiceExit: (status: "restarting" | "stopping") => Promise<void>) => Promise<void>;
+    pollIntervalMs?: number;
+    maxWaitMs?: number;
+    now?: () => number;
+};
+export declare class MaintenanceScheduler {
+    private readonly options;
+    private task;
+    private timer;
+    private readonly pollIntervalMs;
+    private readonly maxWaitMs;
+    private readonly now;
+    constructor(options: MaintenanceSchedulerOptions);
+    start(): Promise<void>;
+    schedule(options: ScheduleMaintenanceOptions): Promise<MaintenanceTask>;
+    getTask(): MaintenanceTask | undefined;
+    cancel(): Promise<MaintenanceTask>;
+    stop(): void;
+    checkNow(): Promise<void>;
+    private arm;
+    private tick;
+    private updateWaiting;
+    private markServiceExit;
+    private finish;
+    private isoNow;
+    private readState;
+    private writeState;
+}
+export {};

package/dist/maintenance.js

@@ -0,0 +1,194 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+const activeStatuses = new Set(["scheduled", "waiting", "running", "restarting", "stopping"]);
+export class MaintenanceScheduler {
+    options;
+    task;
+    timer;
+    pollIntervalMs;
+    maxWaitMs;
+    now;
+    constructor(options) {
+        this.options = options;
+        this.pollIntervalMs = options.pollIntervalMs ?? 1000;
+        this.maxWaitMs = options.maxWaitMs ?? 60 * 60 * 1000;
+        this.now = options.now ?? Date.now;
+    }
+    async start() {
+        this.task = await this.readState();
+        if (!this.task)
+            return;
+        if (this.task.status === "restarting" || this.task.status === "stopping") {
+            const now = this.isoNow();
+            this.task = {
+                ...this.task,
+                status: "completed",
+                updatedAt: now,
+                completedAt: now,
+                message: "Client service completed the maintenance operation",
+            };
+            await this.writeState();
+            return;
+        }
+        if (this.task.status === "running") {
+            await this.finish("failed", "Client service exited before the maintenance operation completed");
+            return;
+        }
+        if (this.task.status === "scheduled" || this.task.status === "waiting")
+            this.arm();
+    }
+    async schedule(options) {
+        if (!Number.isInteger(options.delaySeconds) || options.delaySeconds < 1 || options.delaySeconds > 86_400) {
+            throw new Error("--delay must be an integer between 1 and 86400 seconds");
+        }
+        if (this.task &&
+            activeStatuses.has(this.task.status) &&
+            !(options.source !== "automatic" && this.task.source === "automatic" && isPending(this.task))) {
+            throw new Error(`Maintenance task ${this.task.id} is already ${this.task.status}`);
+        }
+        const nowMs = this.now();
+        const now = new Date(nowMs).toISOString();
+        this.task = {
+            id: randomUUID(),
+            operation: options.operation,
+            status: "scheduled",
+            allowWaiting: options.allowWaiting,
+            createdAt: now,
+            notBefore: new Date(nowMs + options.delaySeconds * 1000).toISOString(),
+            updatedAt: now,
+            source: options.source ?? "manual",
+        };
+        await this.writeState();
+        this.arm();
+        return this.task;
+    }
+    getTask() {
+        return this.task ? structuredClone(this.task) : undefined;
+    }
+    async cancel() {
+        if (!this.task || (this.task.status !== "scheduled" && this.task.status !== "waiting")) {
+            throw new Error("No cancellable maintenance task");
+        }
+        if (this.timer)
+            clearTimeout(this.timer);
+        const now = this.isoNow();
+        this.task = {
+            ...this.task,
+            status: "cancelled",
+            updatedAt: now,
+            completedAt: now,
+            message: "Cancelled by user",
+        };
+        await this.writeState();
+        return this.task;
+    }
+    stop() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+    async checkNow() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        await this.tick();
+    }
+    arm(delayMs) {
+        if (!this.task || (this.task.status !== "scheduled" && this.task.status !== "waiting"))
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        const untilNotBefore = Math.max(0, Date.parse(this.task.notBefore) - this.now());
+        this.timer = setTimeout(() => this.tick(), delayMs ?? untilNotBefore);
+        this.timer.unref();
+    }
+    async tick() {
+        this.timer = undefined;
+        const task = this.task;
+        if (!task || (task.status !== "scheduled" && task.status !== "waiting"))
+            return;
+        if (this.now() < Date.parse(task.notBefore)) {
+            this.arm();
+            return;
+        }
+        try {
+            const activity = await this.options.getActivity();
+            const unavailable = Object.entries(activity.agents)
+                .filter(([, status]) => !status.available)
+                .map(([name]) => name);
+            const blockers = [];
+            if (unavailable.length > 0)
+                blockers.push(`unavailable agents: ${unavailable.join(", ")}`);
+            if (activity.active > 0)
+                blockers.push(`${activity.active} active session(s)`);
+            if (!task.allowWaiting && activity.waiting > 0)
+                blockers.push(`${activity.waiting} waiting session(s)`);
+            if (blockers.length > 0) {
+                if (task.source !== "automatic" && this.now() - Date.parse(task.notBefore) >= this.maxWaitMs) {
+                    await this.finish("failed", `Timed out waiting for an idle client: ${blockers.join("; ")}`);
+                    return;
+                }
+                await this.updateWaiting(`Waiting for an idle client: ${blockers.join("; ")}`);
+                this.arm(this.pollIntervalMs);
+                return;
+            }
+            const now = this.isoNow();
+            this.task = { ...task, status: "running", updatedAt: now, message: "Maintenance operation is running" };
+            await this.writeState();
+            await this.options.execute(task.operation, (status) => this.markServiceExit(status));
+            await this.finish("completed", "Maintenance operation completed");
+        }
+        catch (err) {
+            await this.finish("failed", err instanceof Error ? err.message : String(err));
+        }
+    }
+    async updateWaiting(message) {
+        if (!this.task)
+            return;
+        this.task = { ...this.task, status: "waiting", updatedAt: this.isoNow(), message };
+        await this.writeState();
+    }
+    async markServiceExit(status) {
+        if (!this.task || this.task.status !== "running")
+            return;
+        this.task = {
+            ...this.task,
+            status,
+            updatedAt: this.isoNow(),
+            message: `Maintenance operation is ${status === "restarting" ? "restarting" : "stopping"} the client service`,
+        };
+        await this.writeState();
+    }
+    async finish(status, message) {
+        if (!this.task)
+            return;
+        const now = this.isoNow();
+        this.task = { ...this.task, status, updatedAt: now, completedAt: now, message };
+        await this.writeState();
+    }
+    isoNow() {
+        return new Date(this.now()).toISOString();
+    }
+    async readState() {
+        try {
+            return JSON.parse(await readFile(this.options.statePath, "utf8"));
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return undefined;
+            throw err;
+        }
+    }
+    async writeState() {
+        if (!this.task)
+            return;
+        await mkdir(dirname(this.options.statePath), { recursive: true, mode: 0o700 });
+        const temporaryPath = `${this.options.statePath}.tmp`;
+        await writeFile(temporaryPath, `${JSON.stringify(this.task, null, 2)}\n`, { mode: 0o600 });
+        await rename(temporaryPath, this.options.statePath);
+    }
+}
+function isPending(task) {
+    return task.status === "scheduled" || task.status === "waiting";
+}

package/dist/paths.d.ts

@@ -0,0 +1,8 @@
+export declare const defaultConfigPath: string;
+export declare const defaultDataDir: string;
+export declare const defaultRuntimeDir: string;
+export declare const defaultBinDir: string;
+export declare const defaultWorkspacePath: string;
+export declare function expandHome(path: string): string;
+export declare function resolvePath(path: string): string;
+export declare function configBaseDir(configPath: string): string;

package/dist/paths.js

@@ -0,0 +1,20 @@
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+export const defaultConfigPath = join(homedir(), ".coding-agent", "config.yaml");
+export const defaultDataDir = join(homedir(), ".coding-agent", "data");
+export const defaultRuntimeDir = join(homedir(), ".coding-agent", "runtime");
+export const defaultBinDir = join(homedir(), ".coding-agent", "bin");
+export const defaultWorkspacePath = join(homedir(), "messenger-workspace");
+export function expandHome(path) {
+    if (path === "~")
+        return homedir();
+    if (path.startsWith("~/"))
+        return join(homedir(), path.slice(2));
+    return path;
+}
+export function resolvePath(path) {
+    return resolve(expandHome(path));
+}
+export function configBaseDir(configPath) {
+    return dirname(configPath);
+}

package/dist/runtime.d.ts

@@ -0,0 +1,34 @@
+export type RuntimeInstallOptions = {
+    version: string;
+    configPath: string;
+    runtimeDir?: string;
+    binDir?: string;
+    skillsSourceDir?: string;
+    codexHome?: string;
+    claudeHome?: string;
+};
+export type RuntimeInstallResult = {
+    releaseDir: string;
+    currentLink: string;
+    wrapperPath: string;
+    cliWrapperPath: string;
+    version: string;
+};
+export type ReleaseChannel = "latest" | "beta" | "alpha";
+export declare const releaseChannels: ReleaseChannel[];
+export declare function normalizeReleaseChannel(value: unknown): ReleaseChannel | undefined;
+export declare function parseReleaseChannel(value: unknown): ReleaseChannel | undefined;
+export declare function normalizeUpgradeVersion(version: string, explicitChannel?: ReleaseChannel): {
+    version: string;
+    channel?: ReleaseChannel;
+};
+export declare function isPrereleaseVersion(version: string): boolean;
+export declare function compareSemverVersions(left: string, right: string): number;
+export declare function currentPackageVersion(): Promise<string>;
+export declare function npmExecutablePath(nodeExecutable?: string): string;
+export declare function npmProcessPath(nodeExecutable?: string, currentPath?: string | undefined): string;
+export declare function currentBundledSkillsDir(moduleUrl?: string): string;
+export declare function defaultAgentHomes(): [string, string];
+export declare function installRuntime(options: RuntimeInstallOptions): Promise<RuntimeInstallResult>;
+export declare function resolveChannelPackageVersion(channel: ReleaseChannel): Promise<string>;
+export declare function syncBundledSkills(skillsSourceDir: string, agentHomes: string[]): Promise<void>;