agentroam 0.2.0-preview.14 → 0.2.0-preview.16

package/README.md

@@ -20,20 +20,20 @@ npx agentroam@preview
 Or install from tarball:
 
 ```bash
-npm install ./agentroam-cloudflared-darwin-arm64-0.2.0-preview.14.tgz \
-  ./agentroam-runtime-darwin-arm64-0.2.0-preview.14.tgz \
-  ./agentroam-tui-darwin-arm64-0.2.0-preview.14.tgz \
-  ./agentroam-0.2.0-preview.14.tgz
+npm install ./agentroam-cloudflared-darwin-arm64-0.2.0-preview.16.tgz \
+  ./agentroam-runtime-darwin-arm64-0.2.0-preview.16.tgz \
+  ./agentroam-tui-darwin-arm64-0.2.0-preview.16.tgz \
+  ./agentroam-0.2.0-preview.16.tgz
 npx agentroam
 ```
 
 Windows PowerShell:
 
 ```powershell
-npm install ./agentroam-cloudflared-win32-x64-0.2.0-preview.14.tgz `
-  ./agentroam-runtime-win32-x64-0.2.0-preview.14.tgz `
-  ./caoqu-agentroam-tui-win32-x64-0.2.0-preview.14.tgz `
-  ./agentroam-0.2.0-preview.14.tgz
+npm install ./agentroam-cloudflared-win32-x64-0.2.0-preview.16.tgz `
+  ./agentroam-runtime-win32-x64-0.2.0-preview.16.tgz `
+  ./caoqu-agentroam-tui-win32-x64-0.2.0-preview.16.tgz `
+  ./agentroam-0.2.0-preview.16.tgz
 npx agentroam
 ```
 

package/bin/node-preflight.mjs

@@ -7,7 +7,7 @@ import { promisify } from "node:util";
 
 const execFileAsync = promisify(execFile);
 const MANAGED_NODE_VERSION = "22.22.0";
-const RELEASE_VERSION = "0.2.0-preview.14";
+const RELEASE_VERSION = "0.2.0-preview.16";
 const RELEASE_BASE_URL = `https://gitee.com/caoqu/team-agent/releases/download/v${RELEASE_VERSION}`;
 const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
 

package/dist/args.js

@@ -3,7 +3,7 @@ import { resolve } from "node:path";
 export function parseArgs(argv) {
     const values = [...argv];
     let command = "start";
-    if (values[0] && ["start", "doctor", "version", "service"].includes(values[0])) {
+    if (values[0] && ["start", "doctor", "version", "service", "update", "update-worker"].includes(values[0])) {
         command = values.shift();
     }
     let serviceAction = null;
@@ -17,6 +17,16 @@ export function parseArgs(argv) {
             throw cliError(`service ${serviceAction} does not accept options`);
         }
     }
+    let updateVersion = null;
+    let updateStateFile = null;
+    if (command === "update" && values[0] && !values[0].startsWith("--"))
+        updateVersion = values.shift();
+    if (command === "update-worker") {
+        const stateFile = values.shift();
+        if (!stateFile || values.length > 0)
+            throw cliError("update-worker requires one state file");
+        updateStateFile = resolve(stateFile);
+    }
     const options = {
         command,
         serviceAction,
@@ -27,8 +37,10 @@ export function parseArgs(argv) {
         localOnly: false,
         qr: true,
         dataDir: resolve(homedir(), ".agentroam"),
+        updateVersion,
+        updateStateFile,
     };
-    for (let index = 0; index < values.length; index++) {
+    for (let index = 0; index < values.length && command !== "update-worker"; index++) {
         const arg = values[index];
         const next = () => {
             const value = values[++index];
@@ -64,6 +76,9 @@ export function parseArgs(argv) {
         else
             throw cliError(`unknown argument: ${arg}`);
     }
+    if (command === "update" && updateVersion && !/^\d+\.\d+\.\d+$/.test(updateVersion)) {
+        throw cliError("update version must be an exact stable X.Y.Z version");
+    }
     if (!options.roots.length)
         options.roots = [process.cwd()];
     if (options.relay === "custom" && !options.tunnelCommand)

package/dist/args.test.js

@@ -51,4 +51,9 @@ describe("parseArgs", () => {
         expect(() => parseArgs(["service", "start", "--port", "3000"])).toThrow("does not accept options");
         expect(() => parseArgs(["service", "stop", "--local-only"])).toThrow("does not accept options");
     });
+    it("parses update with an optional exact stable version", () => {
+        expect(parseArgs(["update"]).updateVersion).toBeNull();
+        expect(parseArgs(["update", "1.2.3", "--data-dir", "./data"])).toMatchObject({ command: "update", updateVersion: "1.2.3" });
+        expect(() => parseArgs(["update", "1.2.3-preview.1"])).toThrow("exact stable");
+    });
 });

package/dist/cli.js

@@ -15,9 +15,15 @@ import { ServiceRuntimeReporter } from "./service/runtime-state.js";
 import { runServiceCommand } from "./service/service-command.js";
 import { resolveServicePaths } from "./service/service-files.js";
 import { selectRelay } from "./tunnel/relay-orchestrator.js";
+import { currentCliPath, startUpdate } from "./update/update-command.js";
+import { runUpdateWorker } from "./update/update-worker.js";
 const VERSION = AGENTROAM_VERSION;
 export async function main(argv) {
     const options = parseArgs(argv);
+    if (options.command === "update-worker") {
+        await runUpdateWorker(options.updateStateFile);
+        return;
+    }
     if (options.command === "service") {
         await runServiceCommand(options, {
             nodePath: process.execPath,
@@ -27,6 +33,13 @@ export async function main(argv) {
         return;
     }
     const target = detectPlatform();
+    if (options.command === "update") {
+        if (target !== "darwin-arm64" && target !== "windows-amd64")
+            throw new Error(`updates are unavailable for ${target}`);
+        const state = await startUpdate({ currentVersion: VERSION, requestedVersion: options.updateVersion ?? null, dataDir: options.dataDir, target, cliPath: currentCliPath() });
+        console.log(`AgentRoam ${state.targetVersion} update started in the background.`);
+        return;
+    }
     if (options.command === "version") {
         console.log(`agentroam ${VERSION}`);
         return;

package/dist/platform-packages.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname } from "node:path";
-export const AGENTROAM_VERSION = "0.2.0-preview.14";
+export const AGENTROAM_VERSION = "0.2.0-preview.16";
 export const PLATFORM_PACKAGES = {
     "darwin-arm64": {
         runtime: "agentroam-runtime-darwin-arm64",

package/dist/runtime-manager.js

@@ -1,5 +1,6 @@
 import { mkdir } from "node:fs/promises";
 import { delimiter, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { resolveCodexRuntime, } from "./codex-runtime-manager.js";
 import { repairNativeRuntimePermissions } from "./native-runtime.js";
 import { resolveOpenCodeRuntime, } from "./opencode-runtime-manager.js";
@@ -39,6 +40,9 @@ export class RuntimeManager {
                 AGENT_TRUST_TUNNEL_PROXY: "1",
                 AGENT_PAIRING_HASH: pairing?.hashHex || "",
                 AGENT_PAIRING_EXPIRES_AT: pairing?.expiresAt || "",
+                AGENTROAM_VERSION: resolvePlatformRuntime(target).manifest.packageVersion,
+                AGENTROAM_DATA_DIR: dataDir,
+                AGENTROAM_CLI_PATH: fileURLToPath(new URL("../bin/agentroam.mjs", import.meta.url)),
             },
         });
         const log = (stream) => stream?.on("data", (chunk) => process.stderr.write(chunk));

package/dist/tunnel/public-readiness.js

@@ -22,7 +22,7 @@ export async function waitForPublicReadiness(publicUrl, options = {}) {
             try {
                 const response = await fetchImpl(endpoint, {
                     cache: "no-store",
-                    headers: { "user-agent": "agentroam-readiness/0.2.0-preview.14" },
+                    headers: { "user-agent": "agentroam-readiness/0.2.0-preview.16" },
                     signal: options.signal,
                 });
                 if (response.ok) {

package/dist/update/update-channel.js

@@ -0,0 +1,38 @@
+const VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-preview\.(0|[1-9]\d*))?$/;
+export function parseAgentRoamVersion(value) {
+    const match = VERSION.exec(value);
+    if (!match)
+        return null;
+    return {
+        core: [Number(match[1]), Number(match[2]), Number(match[3])],
+        preview: match[4] === undefined ? null : Number(match[4]),
+    };
+}
+// A prerelease installation follows the preview channel; a stable installation
+// follows latest. Preview users are also offered a newer stable release so they
+// can migrate to the stable track without reinstalling.
+export function resolveUpdateChannel(currentVersion) {
+    const parsed = parseAgentRoamVersion(currentVersion);
+    if (!parsed)
+        throw new Error("invalid AgentRoam version");
+    return parsed.preview === null ? "latest" : "preview";
+}
+export function resolveReleaseChannel(version) {
+    const parsed = parseAgentRoamVersion(version);
+    if (!parsed)
+        throw new Error("invalid AgentRoam version");
+    return parsed.preview === null ? "latest" : "preview";
+}
+export function registryUrlsForChannel(channel, registryBase) {
+    return channel === "preview" ? [`${registryBase}/latest`, `${registryBase}/preview`] : [`${registryBase}/latest`];
+}
+export function parseChannelVersion(value, channel) {
+    if (typeof value !== "string")
+        return null;
+    const parsed = parseAgentRoamVersion(value);
+    if (!parsed)
+        return null;
+    if (parsed.preview === null)
+        return value;
+    return channel === "preview" ? value : null;
+}

package/dist/update/update-command.js

@@ -0,0 +1,102 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { updatePaths, writeUpdateState } from "./update-state.js";
+import { parseChannelVersion, registryUrlsForChannel, resolveReleaseChannel, resolveUpdateChannel, } from "./update-channel.js";
+const REGISTRY_BASE = "https://registry.npmjs.org/agentroam";
+const RELEASE_BASE = "https://gitee.com/caoqu/team-agent/releases/download";
+const SHA = /^[a-f0-9]{64}$/;
+export async function resolveUpdate(options, fetchImpl = fetch) {
+    const channel = resolveUpdateChannel(options.currentVersion);
+    const target = await readRegistryCandidate(fetchImpl, channel);
+    if (!target)
+        throw new Error("unable to check the npm release channel");
+    if (options.requestedVersion && options.requestedVersion !== target)
+        throw new Error("requested version is not the current npm candidate");
+    if (compare(target, options.currentVersion) <= 0)
+        throw new Error("AgentRoam is already up to date");
+    const response = await fetchWithTimeout(fetchImpl, `${RELEASE_BASE}/v${target}/release-manifest.json`);
+    if (!response.ok)
+        throw new Error("release manifest is unavailable");
+    const manifest = await response.json();
+    const asset = manifest?.installers?.cli?.[options.target];
+    const fileName = options.target === "darwin-arm64" ? "install-agentroam.sh" : "install-agentroam.ps1";
+    if (manifest?.schemaVersion !== 2 || manifest.version !== target || manifest.channel !== resolveReleaseChannel(target) || asset?.fileName !== fileName || !SHA.test(asset?.sha256 ?? "")) {
+        throw new Error("release manifest is invalid for this platform");
+    }
+    return { targetVersion: target, fileName, sha256: asset.sha256 };
+}
+// Preview installations follow the higher of the preview and latest npm
+// dist-tags so a newer stable release can move them onto the stable track.
+async function readRegistryCandidate(fetchImpl, channel) {
+    let best = null;
+    for (const url of registryUrlsForChannel(channel, REGISTRY_BASE)) {
+        const response = await fetchWithTimeout(fetchImpl, url).catch(() => null);
+        if (!response?.ok)
+            continue;
+        const candidate = parseChannelVersion((await response.json()).version, channel);
+        if (!candidate)
+            continue;
+        if (!best || compare(candidate, best) > 0)
+            best = candidate;
+    }
+    return best;
+}
+export async function startUpdate(options) {
+    const release = await resolveUpdate(options);
+    const paths = updatePaths(options.dataDir);
+    const service = await readServiceConfig();
+    const state = {
+        schemaVersion: 1,
+        phase: "downloading",
+        currentVersion: options.currentVersion,
+        ...release,
+        dataDir: resolve(options.dataDir),
+        roots: service?.roots?.length ? service.roots : [process.cwd()],
+        port: service?.port ?? null,
+        relay: service?.relay ?? "auto",
+        tunnelCommand: service?.tunnelCommand ?? null,
+        localOnly: service?.localOnly ?? false,
+        cliPath: resolve(options.cliPath),
+        updatedAt: Date.now(),
+    };
+    await writeUpdateState(paths.stateFile, state);
+    const child = spawn(process.execPath, [options.cliPath, "update-worker", paths.stateFile], { detached: true, stdio: "ignore", windowsHide: true });
+    child.unref();
+    return state;
+}
+async function readServiceConfig() {
+    try {
+        return JSON.parse(await readFile(resolve(homedir(), ".agentroam", "service", "config.json"), "utf8"));
+    }
+    catch { }
+    return null;
+}
+async function fetchWithTimeout(fetchImpl, url) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 4_000);
+    timer.unref?.();
+    try {
+        return await fetchImpl(url, { headers: { accept: "application/json" }, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function compare(left, right) {
+    const parse = (value) => {
+        const match = /^(\d+)\.(\d+)\.(\d+)(?:-preview\.(\d+))?$/.exec(value);
+        if (!match)
+            throw new Error("invalid AgentRoam version");
+        return [...match.slice(1, 4).map(Number), match[4] === undefined ? Number.MAX_SAFE_INTEGER : Number(match[4])];
+    };
+    const a = parse(left);
+    const b = parse(right);
+    for (let i = 0; i < a.length; i += 1)
+        if (a[i] !== b[i])
+            return a[i] > b[i] ? 1 : -1;
+    return 0;
+}
+export const currentCliPath = () => fileURLToPath(new URL("../../bin/agentroam.mjs", import.meta.url));

package/dist/update/update-command.test.js

@@ -0,0 +1,70 @@
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { resolveUpdate } from "./update-command.js";
+import { acquireUpdateLock, readUpdateState, updatePaths, writeUpdateState } from "./update-state.js";
+const sha256 = "c".repeat(64);
+const response = (body) => new Response(JSON.stringify(body), { status: 200 });
+describe("resolveUpdate", () => {
+    it("accepts only npm latest with an audited Gitee installer", async () => {
+        const fetcher = vi.fn()
+            .mockResolvedValueOnce(response({ version: "1.2.3" }))
+            .mockResolvedValueOnce(response({ schemaVersion: 2, version: "1.2.3", channel: "latest", installers: { cli: { "windows-amd64": { fileName: "install-agentroam.ps1", sha256 } } } }));
+        await expect(resolveUpdate({ currentVersion: "1.2.2", requestedVersion: null, dataDir: "data", target: "windows-amd64", cliPath: "cli" }, fetcher))
+            .resolves.toEqual({ targetVersion: "1.2.3", fileName: "install-agentroam.ps1", sha256 });
+    });
+    it("rejects a requested version that is not npm latest", async () => {
+        const fetcher = vi.fn().mockResolvedValue(response({ version: "1.2.3" }));
+        await expect(resolveUpdate({ currentVersion: "1.0.0", requestedVersion: "1.2.2", dataDir: "data", target: "darwin-arm64", cliPath: "cli" }, fetcher)).rejects.toThrow("not the current npm candidate");
+    });
+    it("follows the preview channel and offers a higher preview", async () => {
+        const fetcher = vi.fn((url) => {
+            const u = String(url);
+            if (u.endsWith("/preview"))
+                return Promise.resolve(response({ version: "1.2.3-preview.4" }));
+            if (u.endsWith("/latest"))
+                return Promise.resolve(response({ version: "1.2.2" }));
+            return Promise.resolve(response({ schemaVersion: 2, version: "1.2.3-preview.4", channel: "preview", installers: { cli: { "darwin-arm64": { fileName: "install-agentroam.sh", sha256 } } } }));
+        });
+        await expect(resolveUpdate({ currentVersion: "1.2.3-preview.3", requestedVersion: null, dataDir: "data", target: "darwin-arm64", cliPath: "cli" }, fetcher))
+            .resolves.toEqual({ targetVersion: "1.2.3-preview.4", fileName: "install-agentroam.sh", sha256 });
+    });
+    it("offers a newer stable release to preview users", async () => {
+        const fetcher = vi.fn((url) => {
+            const u = String(url);
+            if (u.endsWith("/preview"))
+                return Promise.resolve(response({ version: "1.2.3-preview.4" }));
+            if (u.endsWith("/latest"))
+                return Promise.resolve(response({ version: "1.2.4" }));
+            return Promise.resolve(response({ schemaVersion: 2, version: "1.2.4", channel: "latest", installers: { cli: { "darwin-arm64": { fileName: "install-agentroam.sh", sha256 } } } }));
+        });
+        await expect(resolveUpdate({ currentVersion: "1.2.3-preview.4", requestedVersion: null, dataDir: "data", target: "darwin-arm64", cliPath: "cli" }, fetcher))
+            .resolves.toEqual({ targetVersion: "1.2.4", fileName: "install-agentroam.sh", sha256 });
+    });
+    it("stable channel never queries the preview tag", async () => {
+        const fetcher = vi.fn((url) => {
+            const u = String(url);
+            expect(u).not.toContain("/preview");
+            if (u.endsWith("/latest"))
+                return Promise.resolve(response({ version: "1.2.4" }));
+            return Promise.resolve(response({ schemaVersion: 2, version: "1.2.4", channel: "latest", installers: { cli: { "darwin-arm64": { fileName: "install-agentroam.sh", sha256 } } } }));
+        });
+        await resolveUpdate({ currentVersion: "1.2.3", requestedVersion: null, dataDir: "data", target: "darwin-arm64", cliPath: "cli" }, fetcher);
+        expect(fetcher.mock.calls.map((call) => String(call[0])).some((url) => url.includes("/preview"))).toBe(false);
+    });
+    it("writes durable state atomically and excludes concurrent workers", async () => {
+        const dataDir = await mkdtemp(resolve(tmpdir(), "agentroam-update-state-"));
+        const paths = updatePaths(dataDir);
+        const state = {
+            schemaVersion: 1, phase: "downloading", currentVersion: "1.0.0", targetVersion: "1.1.0",
+            dataDir, roots: ["D:\\project"], port: 3000, relay: "auto", tunnelCommand: null,
+            localOnly: false, fileName: "install-agentroam.ps1", sha256, cliPath: "C:\\agentroam.mjs", updatedAt: 1,
+        };
+        await writeUpdateState(paths.stateFile, state);
+        await expect(readUpdateState(paths.stateFile)).resolves.toEqual(state);
+        const release = await acquireUpdateLock(paths.lockFile);
+        await expect(acquireUpdateLock(paths.lockFile)).rejects.toThrow("already running");
+        await release();
+    });
+});

package/dist/update/update-state.js

@@ -0,0 +1,43 @@
+import { mkdir, open, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+export function updatePaths(dataDir) {
+    const directory = resolve(dataDir, "updates");
+    return { directory, stateFile: resolve(directory, "state.json"), lockFile: resolve(directory, "update.lock") };
+}
+export async function readUpdateState(path) {
+    try {
+        const value = JSON.parse(await readFile(path, "utf8"));
+        return value?.schemaVersion === 1 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeUpdateState(path, state) {
+    await mkdir(dirname(path), { recursive: true });
+    const temp = `${path}.${process.pid}.tmp`;
+    await writeFile(temp, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    await rename(temp, path);
+}
+export async function acquireUpdateLock(path, now = Date.now()) {
+    await mkdir(dirname(path), { recursive: true });
+    try {
+        const handle = await open(path, "wx", 0o600);
+        await handle.writeFile(`${process.pid}\n${now}\n`);
+        await handle.close();
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        const age = now - (await stat(path)).mtimeMs;
+        if (age <= 30 * 60 * 1_000)
+            throw new Error("an AgentRoam update is already running");
+        await unlink(path);
+        return acquireUpdateLock(path, now);
+    }
+    return async () => { await unlink(path).catch(() => undefined); };
+}
+export function sanitizeUpdateError(error) {
+    const value = error instanceof Error ? error.message : String(error);
+    return value.replace(/[A-Za-z]:\\[^\s]+|\/(?:Users|home|var|tmp)\/[^\s]+/g, "<path>").slice(0, 300);
+}

package/dist/update/update-worker.js

@@ -0,0 +1,71 @@
+import { createHash } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { chmod, readFile, unlink } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import { spawn } from "node:child_process";
+import { acquireUpdateLock, readUpdateState, sanitizeUpdateError, updatePaths, writeUpdateState } from "./update-state.js";
+const RELEASE_BASE = "https://gitee.com/caoqu/team-agent/releases/download";
+export async function runUpdateWorker(stateFile, fetchImpl = fetch) {
+    const initial = await readUpdateState(stateFile);
+    if (!initial)
+        throw new Error("update state is missing");
+    const paths = updatePaths(initial.dataDir);
+    if (resolve(stateFile) !== paths.stateFile)
+        throw new Error("update state is outside the data directory");
+    const releaseLock = await acquireUpdateLock(paths.lockFile);
+    const partial = resolve(paths.directory, `${basename(initial.fileName)}.partial`);
+    let state = initial;
+    const update = async (next) => {
+        state = { ...state, ...next, updatedAt: Date.now() };
+        await writeUpdateState(stateFile, state);
+    };
+    try {
+        const response = await fetchImpl(`${RELEASE_BASE}/v${state.targetVersion}/${encodeURIComponent(state.fileName)}`);
+        if (!response.ok || !response.body)
+            throw new Error("installer download failed");
+        await pipeline(Readable.fromWeb(response.body), createWriteStream(partial, { mode: 0o700 }));
+        const actual = createHash("sha256").update(await readFile(partial)).digest("hex");
+        if (actual !== state.sha256)
+            throw new Error("installer checksum mismatch");
+        await chmod(partial, 0o700).catch(() => undefined);
+        await update({ phase: "installing" });
+        const command = process.platform === "win32" ? "powershell.exe" : "/bin/sh";
+        const args = process.platform === "win32" ? ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", partial] : [partial];
+        const code = await run(command, args, { ...process.env, AGENTROAM_DATA_DIR: state.dataDir, AGENTROAM_ROOT: state.roots[0], AGENTROAM_INSTALL_SKIP_SERVICE: "1" });
+        if (code !== 0)
+            throw new Error(`installer exited with code ${code}`);
+        const nextEntry = resolve(state.dataDir, "launcher", state.targetVersion, "node_modules", "agentroam", "bin", "agentroam.mjs");
+        const serviceArgs = [nextEntry, "service", "install"];
+        for (const root of state.roots)
+            serviceArgs.push("--root", root);
+        serviceArgs.push("--data-dir", state.dataDir, "--relay", state.relay, "--no-qr");
+        if (state.port)
+            serviceArgs.push("--port", String(state.port));
+        if (state.tunnelCommand)
+            serviceArgs.push("--tunnel-command", state.tunnelCommand);
+        if (state.localOnly)
+            serviceArgs.push("--local-only");
+        await update({ phase: "reconnecting" });
+        const serviceCode = await run(process.execPath, serviceArgs, process.env);
+        if (serviceCode !== 0)
+            throw new Error(`service activation exited with code ${serviceCode}`);
+        await update({ phase: "complete", message: `AgentRoam ${state.targetVersion} installed` });
+    }
+    catch (error) {
+        await update({ phase: "failed", message: sanitizeUpdateError(error) });
+        throw error;
+    }
+    finally {
+        await unlink(partial).catch(() => undefined);
+        await releaseLock();
+    }
+}
+function run(command, args, env) {
+    return new Promise((resolveRun, reject) => {
+        const child = spawn(command, args, { env, stdio: "ignore", windowsHide: true });
+        child.once("error", reject);
+        child.once("exit", resolveRun);
+    });
+}

package/install/README.md

@@ -5,7 +5,7 @@ These versioned installers support macOS Apple Silicon and Windows x64. They reu
 ## macOS Apple Silicon
 
 ```sh
-curl -fsSL https://gitee.com/caoqu/team-agent/releases/download/v0.2.0-preview.14/install-agentroam.sh | sh
+curl -fsSL https://gitee.com/caoqu/team-agent/releases/download/v0.2.0-preview.16/install-agentroam.sh | sh
 ```
 
 The command installs the wrapper at `~/.local/bin/agentroam`. If that directory is not already in `PATH`, the installer prints the required shell setting without editing shell profiles.
@@ -13,7 +13,7 @@ The command installs the wrapper at `~/.local/bin/agentroam`. If that directory
 ## Windows x64
 
 ```powershell
-irm https://gitee.com/caoqu/team-agent/releases/download/v0.2.0-preview.14/install-agentroam.ps1 | iex
+irm https://gitee.com/caoqu/team-agent/releases/download/v0.2.0-preview.16/install-agentroam.ps1 | iex
 ```
 
 The command installs `%USERPROFILE%\.agentroam\bin\agentroam.cmd` and adds only that user directory to the user-level `PATH`. It does not require administrator access or change the machine-level `PATH`.
@@ -40,7 +40,7 @@ agentroam service uninstall
 
 ## Data and updates
 
-Set `AGENTROAM_DATA_DIR` before running either installer to override the default `~/.agentroam` data directory. Node is stored at `<data-dir>/runtimes/node/22.22.0`, and the launcher is stored at `<data-dir>/launcher/0.2.0-preview.14`.
+Set `AGENTROAM_DATA_DIR` before running either installer to override the default `~/.agentroam` data directory. Node is stored at `<data-dir>/runtimes/node/22.22.0`, and the launcher is stored at `<data-dir>/launcher/0.2.0-preview.16`.
 
 Each AgentRoam release pins its own Node patch and installer assets. Updates happen only by running a newer versioned installer or installing a newer AgentRoam release; startup never follows a moving Node.js release channel.
 

package/install/install-agentroam.ps1

@@ -2,7 +2,7 @@ $ErrorActionPreference = "Stop"
 $ProgressPreference = "SilentlyContinue"
 
 $NodeVersion = "22.22.0"
-$AgentRoamVersion = "0.2.0-preview.14"
+$AgentRoamVersion = "0.2.0-preview.16"
 $NodeArchive = "node-v22.22.0-win-x64.zip"
 $NodeSha256 = "c97fa376d2becdc8863fcd3ca2dd9a83a9f3468ee7ccf7a6d076ec66a645c77a"
 $NodeUrl = "https://nodejs.org/dist/v22.22.0/$NodeArchive"

package/install/install-agentroam.sh

@@ -2,7 +2,7 @@
 set -eu
 
 NODE_VERSION="22.22.0"
-AGENTROAM_VERSION="0.2.0-preview.14"
+AGENTROAM_VERSION="0.2.0-preview.16"
 NODE_ARCHIVE="node-v22.22.0-darwin-arm64.tar.xz"
 NODE_SHA256="2bd596bbfc4a275ceb8721a5954ee97daea5ebe673e96a185ebd732f6fb023ac"
 NODE_URL="https://nodejs.org/dist/v22.22.0/$NODE_ARCHIVE"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentroam",
-  "version": "0.2.0-preview.14",
+  "version": "0.2.0-preview.16",
   "description": "Zero-install mobile remote terminal and file console",
   "type": "module",
   "bin": {
@@ -26,12 +26,12 @@
     "undici": "^6.25.0"
   },
   "optionalDependencies": {
-    "agentroam-runtime-darwin-arm64": "0.2.0-preview.14",
-    "agentroam-runtime-win32-x64": "0.2.0-preview.14",
-    "agentroam-cloudflared-darwin-arm64": "0.2.0-preview.14",
-    "agentroam-cloudflared-win32-x64": "0.2.0-preview.14",
-    "agentroam-tui-darwin-arm64": "0.2.0-preview.14",
-    "@caoqu/agentroam-tui-win32-x64": "0.2.0-preview.14"
+    "agentroam-runtime-darwin-arm64": "0.2.0-preview.16",
+    "agentroam-runtime-win32-x64": "0.2.0-preview.16",
+    "agentroam-cloudflared-darwin-arm64": "0.2.0-preview.16",
+    "agentroam-cloudflared-win32-x64": "0.2.0-preview.16",
+    "agentroam-tui-darwin-arm64": "0.2.0-preview.16",
+    "@caoqu/agentroam-tui-win32-x64": "0.2.0-preview.16"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",