@relayfile/sdk 0.10.62 → 0.10.64

package/dist/relay-cli/resolve-binary.js

@@ -0,0 +1,565 @@
+/**
+ * The one implementation of "find the relayfile binary".
+ *
+ * The real relayfile CLI is the Go binary (`cmd/relayfile-cli`). Both entry
+ * points into it — the `relayfile` npm package's bin shim
+ * (`packages/cli/scripts/run.js`) and the `agent-relay file` CLI surface in
+ * this directory — resolve it through this module. Nothing else in the repo
+ * may reimplement the lookup.
+ *
+ * The binary reaches a machine two different ways, and the resolver has to
+ * cope with both:
+ *
+ *  - As `@relayfile/cli-<platform>-<arch>`, an optional dependency of this
+ *    package. npm installs only the one matching the host's `os`/`cpu`, so
+ *    nothing is downloaded at install time, the install works offline and in
+ *    CI, and integrity comes from the registry. This is the only path that
+ *    exists for a consumer that depends on `@relayfile/sdk` without depending
+ *    on `relayfile` — `agent-relay` is exactly that consumer.
+ *  - Inside the `relayfile` package's own `bin/`, put there by that package's
+ *    `postinstall` (`packages/cli/scripts/install.js`), which downloads the
+ *    per-platform build from GitHub Releases.
+ */
+import { spawnSync } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const PLATFORM_MAP = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows"
+};
+const ARCH_MAP = {
+    x64: "amd64",
+    arm64: "arm64"
+};
+/**
+ * Node platform/arch pairs that have a published `@relayfile/cli-*` package.
+ *
+ * Kept in lockstep with this package's `optionalDependencies`, the target list
+ * in `packages/cli/scripts/build-binaries.js`, and the package directories
+ * under `packages/cli-*`. `platform-packages.test.ts` fails when they diverge.
+ */
+const PLATFORM_PACKAGE_TARGETS = [
+    "darwin-arm64",
+    "darwin-x64",
+    "linux-arm64",
+    "linux-x64",
+    "win32-arm64",
+    "win32-x64"
+];
+/** Environment variable that pins the binary, bypassing every other step. */
+export const RELAYFILE_CLI_BIN_ENV = "RELAYFILE_CLI_BIN";
+/**
+ * Name of the npm package carrying the prebuilt binary for a target.
+ *
+ * @param platform - Node platform id; defaults to this host's.
+ * @param arch - Node arch id; defaults to this host's.
+ * @returns The package name, or null when no package is published for the
+ *   target (nothing to suggest installing, so callers say "build from source").
+ */
+export function platformPackageName(platform = os.platform(), arch = os.arch()) {
+    const target = `${platform}-${arch}`;
+    return PLATFORM_PACKAGE_TARGETS.includes(target)
+        ? `@relayfile/cli-${target}`
+        : null;
+}
+/** Every `@relayfile/cli-*` package name, for tests and release tooling. */
+export function platformPackageNames() {
+    return PLATFORM_PACKAGE_TARGETS.map((target) => `@relayfile/cli-${target}`);
+}
+/**
+ * Name of the binary inside a `@relayfile/cli-*` package.
+ *
+ * It keeps the Go binary's own name (matching `relayfile-mount` inside the
+ * `@relayfile/mount-*` packages) rather than the `relayfile` name the CLI
+ * package installs, so the two never collide on a machine that has both.
+ *
+ * @param platform - Node platform id; defaults to this host's.
+ * @returns The file name, with `.exe` on Windows.
+ */
+export function platformPackageBinaryName(platform = os.platform()) {
+    return platform === "win32" ? "relayfile-cli.exe" : "relayfile-cli";
+}
+/** Thrown when neither a binary nor a usable source checkout was found. */
+export class RelayfileBinaryNotFoundError extends Error {
+    platform;
+    arch;
+    /** The `@relayfile/cli-*` package for this target, when one is published. */
+    platformPackage;
+    constructor(platform, arch) {
+        super(formatBinaryNotFoundMessage(platform, arch));
+        this.name = "RelayfileBinaryNotFoundError";
+        this.platform = platform;
+        this.arch = arch;
+        this.platformPackage = platformPackageName(platform, arch);
+    }
+}
+/**
+ * Explain what to install, for this exact platform.
+ *
+ * A bare ENOENT sends people looking for a bug in their PATH. The prebuilt
+ * binary is an optional dependency, so the two things that actually cause this
+ * — `--omit=optional` and an unsupported target — both need naming.
+ *
+ * @param platform - Node platform id.
+ * @param arch - Node arch id.
+ * @returns The message carried by `RelayfileBinaryNotFoundError`.
+ */
+export function formatBinaryNotFoundMessage(platform, arch) {
+    const packageName = platformPackageName(platform, arch);
+    if (!packageName) {
+        return (`relayfile has no prebuilt CLI binary for ${platform} ${arch}. ` +
+            `Prebuilt binaries exist for ${PLATFORM_PACKAGE_TARGETS.join(", ")}. ` +
+            `Build one from source with \`go build ./cmd/relayfile-cli\` and point ` +
+            `${RELAYFILE_CLI_BIN_ENV} at it.`);
+    }
+    return (`relayfile could not find a relayfile-cli binary for ${platform} ${arch}. ` +
+        `The prebuilt binary ships as ${packageName}, an optional dependency of ` +
+        `@relayfile/sdk, so it is missing when the install ran with ` +
+        `--omit=optional or could not fetch optional packages. Fix it with one of:\n` +
+        `  npm install ${packageName}\n` +
+        `  npm install @relayfile/sdk --include=optional\n` +
+        `  npm install -g relayfile   (the standalone CLI)\n` +
+        `Or set ${RELAYFILE_CLI_BIN_ENV} to a binary you built or downloaded from ` +
+        `https://github.com/AgentWorkforce/relayfile/releases.`);
+}
+/**
+ * Name of the per-platform binary shipped inside the `relayfile` package.
+ *
+ * @returns The packaged binary's file name, or null on an unsupported target.
+ */
+export function platformBinaryName(platform = os.platform(), arch = os.arch()) {
+    const goPlatform = PLATFORM_MAP[platform];
+    const goArch = ARCH_MAP[arch];
+    if (!goPlatform || !goArch) {
+        return null;
+    }
+    const extension = goPlatform === "windows" ? ".exe" : "";
+    return `relayfile-cli-${goPlatform}-${goArch}${extension}`;
+}
+/**
+ * Name of the binary the CLI package installs and runs, `bin/relayfile`.
+ *
+ * @param platform - Node platform id; defaults to this host's.
+ * @returns The file name, with `.exe` on Windows.
+ */
+export function genericBinaryName(platform = os.platform()) {
+    return platform === "win32" ? "relayfile.exe" : "relayfile";
+}
+function moduleDirectory() {
+    return path.dirname(fileURLToPath(import.meta.url));
+}
+/**
+ * Walk up from `start` looking for a directory that satisfies `matches`.
+ *
+ * @returns The matching directory, or null when the filesystem root is reached.
+ */
+function findUpward(start, matches) {
+    let current = path.resolve(start);
+    for (;;) {
+        if (matches(current)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+/**
+ * Locate the `bin` directory of the installed `relayfile` CLI package.
+ *
+ * @returns The directory, or null when the package is not installed here.
+ */
+function installedCliBinDir() {
+    try {
+        const require = createRequire(import.meta.url);
+        const manifest = require.resolve("relayfile/package.json");
+        return path.join(path.dirname(manifest), "bin");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Locate `packages/cli/bin` when running from inside this repo, where the SDK
+ * and the CLI package are siblings rather than dependencies.
+ *
+ * @returns The directory, or null outside a checkout.
+ */
+function workspaceCliBinDir(exists) {
+    const repoRoot = findUpward(moduleDirectory(), (directory) => exists(path.join(directory, "packages", "cli", "package.json")));
+    return repoRoot ? path.join(repoRoot, "packages", "cli", "bin") : null;
+}
+/**
+ * Locate a relayfile source checkout: a directory with both `go.mod` and
+ * `cmd/relayfile-cli`.
+ *
+ * @returns The checkout root, or null when there is none above `start`.
+ */
+export function findSourceCheckoutRoot(start, exists = existsSync) {
+    return findUpward(start, (directory) => exists(path.join(directory, "go.mod")) &&
+        exists(path.join(directory, "cmd", "relayfile-cli")));
+}
+/**
+ * Go's GOARCH ("amd64") differs from Node's `process.arch` ("x64"). The
+ * platform package name follows Node; `make build-all` / `make release` output
+ * file names follow Go.
+ */
+function goArch(arch) {
+    return ARCH_MAP[arch] ?? arch;
+}
+/**
+ * Locate the binary inside `@relayfile/cli-<platform>-<arch>`.
+ *
+ * Resolved by `require.resolve` from several anchors rather than a fixed
+ * relative path: the package can sit anywhere npm decides to hoist it, and the
+ * SDK itself may be nested under a consumer's `node_modules` or bundled.
+ *
+ * @returns The binary path, or null when the package is not installed here
+ *   (expected under `--omit=optional`, or on an unsupported target).
+ */
+function platformPackageBinary(platform, arch, exists, resolveFrom) {
+    const packageName = platformPackageName(platform, arch);
+    if (!packageName) {
+        return null;
+    }
+    const binaryName = platformPackageBinaryName(platform);
+    for (const anchor of resolveFrom) {
+        let manifest;
+        try {
+            manifest = createRequire(anchor).resolve(`${packageName}/package.json`);
+        }
+        catch {
+            continue;
+        }
+        const candidate = path.join(path.dirname(manifest), "bin", binaryName);
+        if (exists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Default anchors for resolving the platform package: this module, the entry
+ * script (a consumer's CLI, where the SDK lives under their `node_modules`),
+ * and the cwd.
+ */
+function defaultResolveFrom() {
+    const anchors = [path.join(moduleDirectory(), "resolve-binary.js")];
+    if (process.argv[1]) {
+        anchors.push(process.argv[1]);
+    }
+    anchors.push(path.join(process.cwd(), "package.json"));
+    return [...new Set(anchors)];
+}
+/**
+ * `make build` and `make release` outputs inside a source checkout.
+ *
+ * Both names carry `.exe` on Windows: `go build -o bin/relayfile-cli` appends
+ * it for GOOS=windows, and `scripts/build-cli-npm-packages.mjs` looks for
+ * `dist/relayfile-cli-windows-<arch>.exe`. Without the suffix a successful
+ * `make build` is invisible here and resolution falls through to `go run`.
+ *
+ * @returns Candidate binary paths, highest priority first.
+ */
+function sourceCheckoutBinaries(platform, arch, exists, searchRoots) {
+    const candidates = [];
+    const seenRoots = new Set();
+    for (const start of searchRoots) {
+        const root = findSourceCheckoutRoot(start, exists);
+        if (!root || seenRoots.has(root)) {
+            continue;
+        }
+        seenRoots.add(root);
+        const goOs = PLATFORM_MAP[platform] ?? platform;
+        const extension = goOs === "windows" ? ".exe" : "";
+        candidates.push(path.join(root, "bin", `relayfile-cli${extension}`));
+        candidates.push(path.join(root, "dist", `relayfile-cli-${goOs}-${goArch(arch)}${extension}`));
+    }
+    return candidates;
+}
+/**
+ * Last-resort `PATH` scan, for a Go binary placed outside npm.
+ *
+ * Deliberately matches `relayfile-cli` only, never the generic `relayfile`:
+ * on PATH that name is usually the npm bin shim
+ * (`packages/cli/scripts/run.js`), which resolves its binary through this
+ * module. Spawning it here would make the resolver call itself forever.
+ *
+ * @returns The first match, or null.
+ */
+function findOnPath(platform, exists, pathEntries) {
+    const name = platformPackageBinaryName(platform);
+    for (const entry of pathEntries) {
+        const candidate = path.join(entry, name);
+        if (exists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function binary(binaryPath) {
+    return { kind: "binary", command: binaryPath, args: [], binaryPath };
+}
+/**
+ * Resolve how to launch the relayfile CLI on this machine.
+ *
+ * Search order, and why it is this order:
+ *  1. `RELAYFILE_CLI_BIN` — the escape hatch, so a developer or operator can
+ *     always pin an exact binary.
+ *  2. `@relayfile/cli-<platform>-<arch>` — the prebuilt binary npm installed
+ *     for this host. First because it is the only path that exists for a
+ *     consumer of `@relayfile/sdk` that does not also depend on `relayfile`
+ *     (`agent-relay file` is that consumer), and because it needs no network.
+ *  3. The `binDirs` chain: a generic `bin/relayfile` (the `relayfile`
+ *     package's postinstall download, or a local build), then the
+ *     per-platform `bin/relayfile-cli-<os>-<arch>` that package ships.
+ *  4. `make build` / `make release` outputs in an enclosing source checkout.
+ *  5. `go run ./cmd/relayfile-cli` from that checkout.
+ *  6. `PATH`, for a binary installed outside npm.
+ *
+ * @param options - Search overrides; all are optional.
+ * @returns The command, argv prefix, and cwd to spawn.
+ * @throws {RelayfileBinaryNotFoundError} When nothing usable was found.
+ */
+export function resolveRelayfileBinary(options = {}) {
+    const exists = options.fileExists ?? existsSync;
+    const platform = options.platform ?? os.platform();
+    const arch = options.arch ?? os.arch();
+    const env = options.env ?? process.env;
+    const override = env[RELAYFILE_CLI_BIN_ENV];
+    if (override) {
+        const resolved = path.resolve(override);
+        if (exists(resolved)) {
+            return binary(resolved);
+        }
+    }
+    const fromPlatformPackage = platformPackageBinary(platform, arch, exists, options.resolveFrom ?? defaultResolveFrom());
+    if (fromPlatformPackage) {
+        return binary(fromPlatformPackage);
+    }
+    const binDirs = options.binDirs ??
+        [installedCliBinDir(), workspaceCliBinDir(exists)].filter((directory) => Boolean(directory));
+    const packagedName = platformBinaryName(platform, arch);
+    for (const binDir of binDirs) {
+        const candidates = [
+            path.join(binDir, genericBinaryName(platform)),
+            packagedName ? path.join(binDir, packagedName) : null
+        ].filter((candidate) => Boolean(candidate));
+        for (const candidate of candidates) {
+            if (exists(candidate)) {
+                return binary(candidate);
+            }
+        }
+    }
+    const searchRoots = [...(options.searchFrom ?? []), moduleDirectory(), process.cwd()];
+    for (const candidate of sourceCheckoutBinaries(platform, arch, exists, searchRoots)) {
+        if (exists(candidate)) {
+            return binary(candidate);
+        }
+    }
+    for (const root of searchRoots) {
+        const checkout = findSourceCheckoutRoot(root, exists);
+        if (checkout) {
+            return {
+                kind: "go-run",
+                command: "go",
+                args: ["run", "./cmd/relayfile-cli"],
+                cwd: checkout
+            };
+        }
+    }
+    const pathEntries = options.pathEntries ?? (env.PATH ?? "").split(path.delimiter).filter(Boolean);
+    const onPath = findOnPath(platform, exists, pathEntries);
+    if (onPath) {
+        return binary(onPath);
+    }
+    throw new RelayfileBinaryNotFoundError(platform, arch);
+}
+/** Message shown when a source checkout was found but Go is not installed. */
+export const GO_TOOLCHAIN_MISSING_MESSAGE = "relayfile binary not found and Go is not installed to run from source. " +
+    "Install Go or run `npm run build --workspace=packages/cli`.";
+/** Thrown by `buildGoRunBinary` when there is no `go` on PATH. */
+export class GoToolchainMissingError extends Error {
+    constructor() {
+        super(GO_TOOLCHAIN_MISSING_MESSAGE);
+        this.name = "GoToolchainMissingError";
+    }
+}
+/** Thrown by `buildGoRunBinary` when `go build` itself fails. */
+export class GoBuildFailedError extends Error {
+    /** `go build`'s exit code, or null when it was killed by a signal. */
+    exitCode;
+    constructor(exitCode, stderr) {
+        super(`building relayfile from source failed (go build exited ${exitCode})` +
+            (stderr.trim() ? `\n${stderr.trim()}` : ""));
+        this.name = "GoBuildFailedError";
+        this.exitCode = exitCode;
+    }
+}
+/**
+ * Where a source-checkout build is cached: outside the checkout, keyed by it.
+ *
+ * Not `<checkout>/bin`, which is `make build`'s output — a fallback launch
+ * must not write into someone's working tree, and a read-only checkout still
+ * has to work.
+ *
+ * @param checkout - The source checkout root.
+ * @param platform - Node platform id; defaults to this host's.
+ * @returns The absolute path to build to.
+ */
+export function goRunBinaryPath(checkout, platform = os.platform()) {
+    const key = createHash("sha256").update(path.resolve(checkout)).digest("hex").slice(0, 16);
+    return path.join(os.tmpdir(), "relayfile-go-run", key, platformPackageBinaryName(platform));
+}
+/**
+ * Turn a `go-run` resolution into an executable binary.
+ *
+ * `go run` cannot be used directly, because the program it launches inherits
+ * the `go` command's own working directory — and `go` only finds the module
+ * from that directory, so it has to be the checkout. Every relative path in
+ * the caller's argv would then resolve against the repository instead of the
+ * directory the caller actually ran in (`--output report.json` writing into
+ * the checkout root). `go -C <checkout> run` has the same effect, and passing
+ * an absolute package path fails outright outside a module.
+ *
+ * Building first and spawning the result separates the two: the build runs in
+ * the checkout, where the module is, and the binary runs wherever the caller
+ * asked for. Go's build cache makes the repeat cost a relink.
+ *
+ * The build never writes the shared path directly. That path is keyed by the
+ * checkout alone, so every process that falls back to source aims at the same
+ * file — and a `listen` or `mount` launched from it keeps running for hours.
+ * Writing it in place would mean overwriting a binary that is executing
+ * (impossible on Windows, and on Unix a window in which a concurrent build has
+ * replaced it with a partial file). So `go build` writes a private sibling and
+ * the result is published with one rename: atomic on POSIX, and an already
+ * running process keeps the inode it started from. If the rename cannot
+ * happen — Windows refuses to replace a running `.exe` — the caller gets the
+ * private path instead, which is just as runnable.
+ *
+ * @param resolution - The `go-run` resolution to materialize.
+ * @param options - Environment and output overrides.
+ * @returns The absolute path of the built binary.
+ * @throws {GoToolchainMissingError} When `go` is not on PATH.
+ * @throws {GoBuildFailedError} When `go build` exits non-zero.
+ */
+export function buildGoRunBinary(resolution, options = {}) {
+    const output = options.outputPath ?? goRunBinaryPath(resolution.cwd);
+    mkdirSync(path.dirname(output), { recursive: true });
+    sweepStaleBuildArtifacts(output);
+    // Same directory as the destination, so the publish below is a rename
+    // within one filesystem rather than a copy. pid plus random bytes: two
+    // builds in one process must not share it either. The destination's
+    // extension is kept last, because on Windows the fallback below hands this
+    // very path to the host to execute and that has to stay an `.exe`.
+    const staged = `${buildArtifactPrefix(output)}${process.pid}-${randomBytes(6).toString("hex")}` +
+        path.extname(output);
+    const result = spawnSync("go", ["build", "-o", staged, "./cmd/relayfile-cli"], {
+        cwd: resolution.cwd,
+        env: options.env ?? process.env,
+        encoding: "utf8"
+    });
+    if (result.error) {
+        discardBuildArtifact(staged);
+        if (result.error.code === "ENOENT") {
+            throw new GoToolchainMissingError();
+        }
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        discardBuildArtifact(staged);
+        throw new GoBuildFailedError(result.status, result.stderr ?? "");
+    }
+    try {
+        renameSync(staged, output);
+    }
+    catch {
+        // The shared name is held by something that cannot be replaced — a
+        // running binary on Windows. The staged build is a complete binary, so
+        // run that instead of failing the command. sweepStaleBuildArtifacts
+        // collects it later.
+        return staged;
+    }
+    return output;
+}
+/**
+ * Prefix that marks a file in the build directory as a staged build.
+ *
+ * Inserted before the destination's extension rather than after it, so a
+ * staged `relayfile-cli.exe` is still named `...exe`.
+ *
+ * @param output - The shared build path.
+ * @returns The absolute path prefix every staged build starts with.
+ */
+function buildArtifactPrefix(output) {
+    const extension = path.extname(output);
+    return path.join(path.dirname(output), `${path.basename(output, extension)}.build-`);
+}
+/** How long an unpublished staged build is left alone before it is swept. */
+const STALE_BUILD_ARTIFACT_MS = 24 * 60 * 60 * 1000;
+/**
+ * Drop a staged build that was never published.
+ *
+ * Best effort throughout: a leftover artifact is wasted disk, never an error
+ * worth failing a command over.
+ *
+ * @param staged - The staged build path.
+ */
+function discardBuildArtifact(staged) {
+    try {
+        rmSync(staged, { force: true });
+    }
+    catch {
+        // Ignore.
+    }
+}
+/**
+ * Collect staged builds that were left behind.
+ *
+ * A staged build normally disappears into the rename that publishes it, and a
+ * failed build is removed on the spot. What is left is the case the rename
+ * could not happen (Windows, shared name in use) and the case a process died
+ * mid-build — neither of which cleans up after itself, and both of which
+ * would otherwise grow a binary-sized file per invocation forever.
+ *
+ * The age cutoff is what keeps this safe: a returned fallback binary may be
+ * executing right now, and only artifacts far older than any plausible build
+ * are removed. On Unix unlinking a running binary is harmless anyway; on
+ * Windows the delete simply fails and is ignored.
+ *
+ * @param output - The shared build path whose directory is swept.
+ */
+function sweepStaleBuildArtifacts(output) {
+    const prefix = path.basename(buildArtifactPrefix(output));
+    const directory = path.dirname(output);
+    let entries;
+    try {
+        entries = readdirSync(directory);
+    }
+    catch {
+        return;
+    }
+    const cutoff = Date.now() - STALE_BUILD_ARTIFACT_MS;
+    for (const entry of entries) {
+        if (!entry.startsWith(prefix)) {
+            continue;
+        }
+        const candidate = path.join(directory, entry);
+        try {
+            if (statSync(candidate).mtimeMs > cutoff) {
+                continue;
+            }
+            rmSync(candidate, { force: true });
+        }
+        catch {
+            // Ignore.
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relayfile/sdk",
-  "version": "0.10.62",
+  "version": "0.10.64",
   "description": "TypeScript SDK for relayfile — real-time filesystem for humans and agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,6 +14,10 @@
       "types": "./dist/cli/index.d.ts",
       "default": "./dist/cli/index.js"
     },
+    "./relay-cli": {
+      "types": "./dist/relay-cli/index.d.ts",
+      "default": "./dist/relay-cli/index.js"
+    },
     "./cloud-login": {
       "types": "./dist/cloud-login.d.ts",
       "default": "./dist/cloud-login.js"
@@ -46,7 +50,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "node scripts/sync-package-version.mjs && tsc",
+    "build": "node scripts/sync-package-version.mjs && tsc && node scripts/copy-relay-cli-assets.mjs",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:bundle:bun": "node scripts/verify-bun-workspace-mount.mjs",
@@ -57,20 +61,29 @@
     "test:e2e:golden-path": "node scripts/agent-workspace-golden-path-e2e.mjs",
     "demo:agent-workspace": "npm run build && node scripts/agent-workspace-demo.mjs",
     "setup:e2e": "node scripts/setup-e2e.mjs",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "gen:command-spec": "node scripts/gen-command-spec.mjs",
+    "check:command-spec": "node scripts/gen-command-spec.mjs --check"
   },
   "dependencies": {
-    "@relayfile/core": "0.10.62",
+    "@relayfile/core": "0.10.64",
     "ignore": "^7.0.5",
     "tar": "^7.5.10"
   },
   "optionalDependencies": {
-    "@relayfile/mount-darwin-arm64": "0.10.62",
-    "@relayfile/mount-darwin-x64": "0.10.62",
-    "@relayfile/mount-linux-arm64": "0.10.62",
-    "@relayfile/mount-linux-x64": "0.10.62"
+    "@relayfile/cli-darwin-arm64": "0.10.64",
+    "@relayfile/cli-darwin-x64": "0.10.64",
+    "@relayfile/cli-linux-arm64": "0.10.64",
+    "@relayfile/cli-linux-x64": "0.10.64",
+    "@relayfile/cli-win32-arm64": "0.10.64",
+    "@relayfile/cli-win32-x64": "0.10.64",
+    "@relayfile/mount-darwin-arm64": "0.10.64",
+    "@relayfile/mount-darwin-x64": "0.10.64",
+    "@relayfile/mount-linux-arm64": "0.10.64",
+    "@relayfile/mount-linux-x64": "0.10.64"
   },
   "devDependencies": {
+    "@agent-relay/cli-surface": "^12.2.4",
     "typescript": "^5.7.3",
     "vitest": "^3.0.0"
   },