@relayfile/sdk 0.6.0 → 0.6.2

package/README.md

@@ -8,7 +8,68 @@ TypeScript SDK for relayfile — real-time filesystem for humans and agents.
 npm install @relayfile/sdk
 ```
 
-## Quick Example
+## Agent Workspace — Golden Path
+
+The recommended way to use `@relayfile/sdk` in an agent workflow is through
+`RelayfileSetup`. This handles workspace creation, Notion authorization,
+environment variable generation for `relayfile-mount`, and agent invites.
+
+```ts
+import { RelayfileSetup } from '@relayfile/sdk'
+
+const setup = await RelayfileSetup.login({
+  onLoginUrl: (url) => console.log(`Sign in to Relayfile Cloud: ${url}`),
+})
+
+// Create or resume a workspace
+const workspace = await setup.createWorkspace({
+  name: 'notion-research-room',
+  agentName: 'lead-agent',
+})
+
+// Connect Notion — returns a link for the human to open
+const notion = await workspace.connectNotion()
+if (notion.connectLink) {
+  console.log(`Connect Notion: ${notion.connectLink}`)
+  await workspace.waitForNotion({ timeoutMs: 5 * 60_000 })
+}
+
+// Env vars for relayfile-mount (local dir or cloud sandbox)
+const mountEnv = workspace.mountEnv({
+  localDir: '/workspace/notion',
+  remotePath: '/notion',
+})
+
+// Secret invite payload for a trusted co-worker agent
+const invite = workspace.agentInvite({
+  agentName: 'review-agent',
+  scopes: ['fs:read', 'relaycast:write'],
+})
+// Never log invite — it contains credential material
+```
+
+For the full end-to-end journey, failure modes, and acceptance criteria see
+[`docs/agent-workspace-golden-path.md`](../../../docs/agent-workspace-golden-path.md).
+
+Run the demo locally:
+
+```bash
+npm run demo:agent-workspace --workspace=packages/sdk/typescript
+```
+
+The demo defaults to in-process mock cloud and relayfile servers, seeds a `/notion`
+file, mounts it through the deterministic harness, and proves read-only invited-agent
+behavior without requiring real Notion, Relaycast, or cloud credentials. For a real
+deployment, use `RelayfileSetup.login()` to send the human one Cloud sign-in URL,
+or use `RelayfileSetup.fromCloudTokens()` with previously persisted Cloud tokens.
+You can still pass `accessToken` directly to `new RelayfileSetup()` in CI or
+advanced hosts that already provide a valid Cloud bearer token. After Cloud auth,
+complete the Notion OAuth flow as described in
+[`docs/agent-workspace-golden-path.md`](../../../docs/agent-workspace-golden-path.md).
+
+---
+
+## Low-Level Client Example
 
 ```ts
 import { RelayFileClient } from "@relayfile/sdk";

package/dist/cloud-login.d.ts

@@ -0,0 +1,27 @@
+import type { AccessTokenProvider } from "./client.js";
+import type { RelayfileSetupOptions } from "./setup-types.js";
+export interface RelayfileCloudTokenSet {
+    apiUrl?: string;
+    accessToken: string;
+    refreshToken: string;
+    accessTokenExpiresAt: string;
+    refreshTokenExpiresAt?: string;
+}
+export interface RelayfileCloudTokenSetupOptions extends Omit<RelayfileSetupOptions, "accessToken" | "cloudApiUrl"> {
+    cloudApiUrl?: string;
+    refreshWindowMs?: number;
+    onTokens?: (tokens: RelayfileCloudTokenSet) => void | Promise<void>;
+}
+export interface RelayfileCloudLoginOptions extends RelayfileCloudTokenSetupOptions {
+    redirectHost?: string;
+    redirectPort?: number;
+    redirectPath?: string;
+    timeoutMs?: number;
+    state?: string;
+    signal?: AbortSignal;
+    openBrowser?: boolean;
+    onLoginUrl?: (url: string) => void | Promise<void>;
+    successMessage?: string;
+}
+export declare function runRelayfileCloudLogin(options?: RelayfileCloudLoginOptions): Promise<RelayfileCloudTokenSet>;
+export declare function createRelayfileCloudAccessTokenProvider(initialTokens: RelayfileCloudTokenSet, options?: RelayfileCloudTokenSetupOptions): AccessTokenProvider;

package/dist/cloud-login.js

@@ -0,0 +1,290 @@
+import { CloudAbortError, CloudApiError, CloudTimeoutError, MalformedCloudResponseError } from "./setup-errors.js";
+import { RELAYFILE_SDK_VERSION } from "./version.js";
+const DEFAULT_CLOUD_API_URL = "https://agentrelay.com/cloud";
+const DEFAULT_LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_REDIRECT_HOST = "127.0.0.1";
+const DEFAULT_REDIRECT_PATH = "/callback";
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+const DEFAULT_REFRESH_WINDOW_MS = 60_000;
+export async function runRelayfileCloudLogin(options = {}) {
+    const cloudApiUrl = normalizeNonEmptyString(options.cloudApiUrl) ?? DEFAULT_CLOUD_API_URL;
+    const redirectHost = normalizeNonEmptyString(options.redirectHost) ?? DEFAULT_REDIRECT_HOST;
+    const redirectPort = Math.max(0, Math.floor(options.redirectPort ?? 0));
+    const redirectPath = normalizeRedirectPath(options.redirectPath);
+    const timeoutMs = Math.max(1, Math.floor(options.timeoutMs ?? DEFAULT_LOGIN_TIMEOUT_MS));
+    const state = normalizeNonEmptyString(options.state) ?? await createRandomState();
+    const http = await import("node:http");
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let loginUrlSent = false;
+        let timer;
+        const server = http.createServer((request, response) => {
+            if (!request.url) {
+                response.writeHead(400, { "content-type": "text/plain" });
+                response.end("Missing callback URL");
+                return;
+            }
+            const callbackUrl = new URL(request.url, `http://${redirectHost}:${readServerPort(server, redirectPort)}`);
+            if (callbackUrl.pathname !== redirectPath) {
+                response.writeHead(404, { "content-type": "text/plain" });
+                response.end("Not found");
+                return;
+            }
+            const error = callbackUrl.searchParams.get("error");
+            if (error) {
+                response.writeHead(400, { "content-type": "text/plain" });
+                response.end("Relayfile Cloud login failed");
+                finish(reject, new Error(`Relayfile Cloud login failed: ${error}`));
+                return;
+            }
+            const returnedState = callbackUrl.searchParams.get("state");
+            if (returnedState !== state) {
+                response.writeHead(400, { "content-type": "text/plain" });
+                response.end("Relayfile Cloud login state mismatch");
+                finish(reject, new Error("Relayfile Cloud login state mismatch"));
+                return;
+            }
+            let tokens;
+            try {
+                tokens = readTokenSetFromSearchParams(callbackUrl.searchParams, cloudApiUrl);
+            }
+            catch (error) {
+                response.writeHead(400, { "content-type": "text/plain" });
+                response.end("Relayfile Cloud login callback was missing token fields");
+                finish(reject, error);
+                return;
+            }
+            response.writeHead(200, { "content-type": "text/plain" });
+            response.end(options.successMessage ?? "Relayfile Cloud login complete. You can close this tab.");
+            finish(resolve, tokens);
+        });
+        const abort = () => {
+            finish(reject, new CloudAbortError("cloudLogin"));
+        };
+        const finish = (settle, value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+            options.signal?.removeEventListener("abort", abort);
+            server.close();
+            settle(value);
+        };
+        if (options.signal?.aborted) {
+            finish(reject, new CloudAbortError("cloudLogin"));
+            return;
+        }
+        timer = setTimeout(() => {
+            finish(reject, new CloudTimeoutError("cloudLogin", timeoutMs));
+        }, timeoutMs);
+        options.signal?.addEventListener("abort", abort, { once: true });
+        server.once("error", (error) => {
+            finish(reject, error);
+        });
+        server.listen(redirectPort, redirectHost, () => {
+            const port = readServerPort(server, redirectPort);
+            const redirectUri = `http://${redirectHost}:${port}${redirectPath}`;
+            const loginUrl = buildCloudUrl(cloudApiUrl, "api/v1/cli/login");
+            loginUrl.searchParams.set("redirect_uri", redirectUri);
+            loginUrl.searchParams.set("state", state);
+            Promise.resolve(deliverLoginUrl(loginUrl.toString(), options.onLoginUrl))
+                .then(async () => {
+                loginUrlSent = true;
+                if (options.openBrowser) {
+                    await openBrowser(loginUrl.toString());
+                }
+            })
+                .catch((error) => {
+                finish(reject, error);
+            });
+        });
+        server.once("close", () => {
+            if (!settled && !loginUrlSent) {
+                finish(reject, new Error("Relayfile Cloud login server closed before login URL was delivered"));
+            }
+        });
+    });
+}
+export function createRelayfileCloudAccessTokenProvider(initialTokens, options = {}) {
+    const cloudApiUrl = normalizeNonEmptyString(options.cloudApiUrl) ??
+        normalizeNonEmptyString(initialTokens.apiUrl) ??
+        DEFAULT_CLOUD_API_URL;
+    const requestTimeoutMs = Math.max(1, Math.floor(options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS));
+    const refreshWindowMs = Math.max(0, Math.floor(options.refreshWindowMs ?? DEFAULT_REFRESH_WINDOW_MS));
+    let tokens = {
+        ...initialTokens,
+        apiUrl: normalizeNonEmptyString(initialTokens.apiUrl) ?? cloudApiUrl
+    };
+    let refreshPromise;
+    return async () => {
+        if (shouldRefresh(tokens, refreshWindowMs)) {
+            if (!refreshPromise) {
+                refreshPromise = refresh();
+            }
+            try {
+                await refreshPromise;
+            }
+            finally {
+                refreshPromise = undefined;
+            }
+        }
+        return tokens.accessToken;
+    };
+    async function refresh() {
+        const response = await fetchWithTimeout(buildCloudUrl(cloudApiUrl, "api/v1/auth/token/refresh").toString(), {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Relayfile-SDK-Version": RELAYFILE_SDK_VERSION
+            },
+            body: JSON.stringify({ refreshToken: tokens.refreshToken })
+        }, requestTimeoutMs);
+        const payload = await readResponseBody(response);
+        if (!response.ok) {
+            throw new CloudApiError(response.status, payload);
+        }
+        tokens = readTokenSetFromPayload(payload, cloudApiUrl);
+        await options.onTokens?.({ ...tokens });
+    }
+}
+function shouldRefresh(tokens, refreshWindowMs) {
+    const expiresAt = Date.parse(tokens.accessTokenExpiresAt);
+    if (Number.isNaN(expiresAt)) {
+        return true;
+    }
+    return expiresAt - Date.now() <= refreshWindowMs;
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            throw new CloudTimeoutError("refreshCloudAccessToken", timeoutMs);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function readTokenSetFromSearchParams(params, fallbackApiUrl) {
+    return {
+        apiUrl: normalizeNonEmptyString(params.get("api_url") ?? undefined) ?? fallbackApiUrl,
+        accessToken: requireSearchParam(params, "access_token"),
+        refreshToken: requireSearchParam(params, "refresh_token"),
+        accessTokenExpiresAt: requireSearchParam(params, "access_token_expires_at"),
+        refreshTokenExpiresAt: normalizeNonEmptyString(params.get("refresh_token_expires_at") ?? undefined)
+    };
+}
+function readTokenSetFromPayload(payload, fallbackApiUrl) {
+    return {
+        apiUrl: readOptionalStringField(payload, "apiUrl") ?? fallbackApiUrl,
+        accessToken: requireStringField(payload, "accessToken"),
+        refreshToken: requireStringField(payload, "refreshToken"),
+        accessTokenExpiresAt: requireStringField(payload, "accessTokenExpiresAt"),
+        refreshTokenExpiresAt: readOptionalStringField(payload, "refreshTokenExpiresAt")
+    };
+}
+function requireSearchParam(params, field) {
+    const value = normalizeNonEmptyString(params.get(field) ?? undefined);
+    if (!value) {
+        throw new MalformedCloudResponseError(field, Object.fromEntries(params));
+    }
+    return value;
+}
+async function readResponseBody(response) {
+    const text = await response.text();
+    if (text === "") {
+        return null;
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    return text;
+}
+function requireStringField(payload, field) {
+    const value = readField(payload, field);
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new MalformedCloudResponseError(field, payload);
+    }
+    return value;
+}
+function readOptionalStringField(payload, field) {
+    const value = readField(payload, field);
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new MalformedCloudResponseError(field, payload);
+    }
+    return value;
+}
+function readField(payload, field) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return undefined;
+    }
+    return payload[field];
+}
+function buildCloudUrl(baseUrl, path) {
+    const base = new URL(baseUrl);
+    if (!base.pathname.endsWith("/")) {
+        base.pathname = `${base.pathname}/`;
+    }
+    return new URL(path.replace(/^\/+/, ""), base);
+}
+function normalizeRedirectPath(path) {
+    const normalized = normalizeNonEmptyString(path) ?? DEFAULT_REDIRECT_PATH;
+    return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+function normalizeNonEmptyString(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
+}
+async function createRandomState() {
+    const crypto = await import("node:crypto");
+    return crypto.randomBytes(24).toString("base64url");
+}
+function readServerPort(server, fallback) {
+    const address = server.address();
+    return typeof address === "object" && address !== null ? address.port : fallback;
+}
+async function openBrowser(url) {
+    const childProcess = await import("node:child_process");
+    const command = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "cmd"
+            : "xdg-open";
+    const args = process.platform === "win32"
+        ? ["/c", "start", "", url]
+        : [url];
+    await new Promise((resolve) => {
+        const child = childProcess.spawn(command, args, {
+            detached: true,
+            stdio: "ignore"
+        });
+        child.once("error", () => resolve());
+        child.once("spawn", () => {
+            child.unref();
+            resolve();
+        });
+    });
+}
+function deliverLoginUrl(url, onLoginUrl) {
+    if (onLoginUrl) {
+        return onLoginUrl(url);
+    }
+    console.log(`Sign in to Relayfile Cloud: ${url}`);
+}

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 export { RelayFileClient, DEFAULT_RELAYFILE_BASE_URL, type AccessTokenProvider, type ConnectWebSocketOptions, type RelayFileClientOptions, type RelayFileRetryOptions, type WebSocketConnection } from "./client.js";
-export { RelayfileSetup, WorkspaceHandle } from "./setup.js";
+export { RelayfileSetup, RELAYFILE_SDK_VERSION, WorkspaceHandle } from "./setup.js";
+export { type RelayfileCloudLoginOptions, type RelayfileCloudTokenSet, type RelayfileCloudTokenSetupOptions } from "./cloud-login.js";
 export { CloudAbortError, CloudApiError, CloudTimeoutError, IntegrationConnectionTimeoutError, MalformedCloudResponseError, MissingConnectionIdError, RelayfileSetupError, UnknownProviderError } from "./setup-errors.js";
-export { WORKSPACE_INTEGRATION_PROVIDERS, type ConnectIntegrationOptions, type ConnectIntegrationResult, type CreateWorkspaceOptions, type JoinWorkspaceOptions, type RelayfileSetupOptions, type RelayfileSetupRetryOptions, type WaitForConnectionOptions, type WorkspaceInfo, type WorkspaceIntegrationProvider, type WorkspacePermissions } from "./setup-types.js";
+export { WORKSPACE_INTEGRATION_PROVIDERS, type AgentWorkspaceInvite, type AgentWorkspaceInviteOptions, type ConnectIntegrationOptions, type ConnectIntegrationResult, type CreateWorkspaceOptions, type JoinWorkspaceOptions, type RelayfileSetupOptions, type RelayfileSetupRetryOptions, type WaitForConnectionOptions, type WorkspaceInfo, type WorkspaceIntegrationProvider, type WorkspaceMountEnv, type WorkspaceMountEnvOptions, type WorkspacePermissions } from "./setup-types.js";
 export { RelayFileSync, type RelayFileSyncOptions, type RelayFileSyncPong, type RelayFileSyncReconnectOptions, type RelayFileSyncSocket, type RelayFileSyncState } from "./sync.js";
 export { InvalidStateError, PayloadTooLargeError, QueueFullError, RelayFileApiError, RevisionConflictError } from "./errors.js";
 export { IntegrationProvider, computeCanonicalPath } from "./provider.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { RelayFileClient, DEFAULT_RELAYFILE_BASE_URL } from "./client.js";
-export { RelayfileSetup, WorkspaceHandle } from "./setup.js";
+export { RelayfileSetup, RELAYFILE_SDK_VERSION, WorkspaceHandle } from "./setup.js";
 export { CloudAbortError, CloudApiError, CloudTimeoutError, IntegrationConnectionTimeoutError, MalformedCloudResponseError, MissingConnectionIdError, RelayfileSetupError, UnknownProviderError } from "./setup-errors.js";
 export { WORKSPACE_INTEGRATION_PROVIDERS } from "./setup-types.js";
 export { RelayFileSync } from "./sync.js";

package/dist/mount-harness.d.ts

@@ -0,0 +1,52 @@
+import { RelayFileClient } from "./client.js";
+export interface RelayfileMountHarnessConfig {
+    baseUrl: string;
+    token: string;
+    workspaceId: string;
+    remotePath: string;
+    localDir: string;
+    mode: "poll" | "fuse";
+}
+export interface RelayfileMountHarnessOptions {
+    env?: NodeJS.ProcessEnv | Record<string, string>;
+    pollIntervalMs?: number;
+    scopes?: string[];
+    onEvent?: (event: RelayfileMountHarnessEvent) => void;
+    client?: RelayFileClient;
+}
+export type RelayfileMountHarnessEvent = {
+    type: "started";
+    localDir: string;
+    remotePath: string;
+    workspaceId: string;
+} | {
+    type: "sync.completed";
+    localDir: string;
+    remotePath: string;
+    files: number;
+    directories: number;
+} | {
+    type: "permission.denied";
+    path: string;
+    scopes: string[];
+} | {
+    type: "stopped";
+    localDir: string;
+    remotePath: string;
+};
+export interface RelayfileMountHarnessHandle {
+    readonly config: RelayfileMountHarnessConfig;
+    readonly localDir: string;
+    syncOnce(): Promise<void>;
+    writeLocalFile(relativePath: string, content: string): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare class MountHarnessPermissionError extends Error {
+    readonly code = "permission_denied";
+    readonly path: string;
+    readonly scopes: string[];
+    constructor(targetPath: string, scopes: string[]);
+}
+export declare function readMountHarnessConfig(env?: NodeJS.ProcessEnv | Record<string, string>): RelayfileMountHarnessConfig;
+export declare function startMountHarness(options?: RelayfileMountHarnessOptions): Promise<RelayfileMountHarnessHandle>;
+export declare function runMountHarnessCli(argv?: string[], env?: NodeJS.ProcessEnv | Record<string, string>): Promise<void>;

package/dist/mount-harness.js

@@ -0,0 +1,394 @@
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { RelayFileApiError } from "./errors.js";
+import { RelayFileClient } from "./client.js";
+const DEFAULT_POLL_INTERVAL_MS = 1_000;
+export class MountHarnessPermissionError extends Error {
+    code = "permission_denied";
+    path;
+    scopes;
+    constructor(targetPath, scopes) {
+        super(`Write denied for ${targetPath}: invited agent is read-only in the harness.`);
+        this.name = "MountHarnessPermissionError";
+        this.path = targetPath;
+        this.scopes = [...scopes];
+    }
+}
+export function readMountHarnessConfig(env = process.env) {
+    const baseUrl = readRequiredEnv(env, "RELAYFILE_BASE_URL");
+    const token = readRequiredEnv(env, "RELAYFILE_TOKEN");
+    const workspaceId = readRequiredEnv(env, "RELAYFILE_WORKSPACE");
+    const localDir = readRequiredEnv(env, "RELAYFILE_LOCAL_DIR");
+    const remotePath = normalizeRemotePath(env.RELAYFILE_REMOTE_PATH ?? "/");
+    const mode = env.RELAYFILE_MOUNT_MODE === "fuse" ? "fuse" : "poll";
+    return {
+        baseUrl,
+        token,
+        workspaceId,
+        remotePath,
+        localDir: path.resolve(localDir),
+        mode,
+    };
+}
+export async function startMountHarness(options = {}) {
+    const harness = new RelayfileMountHarness(options);
+    await harness.start();
+    return harness;
+}
+class RelayfileMountHarness {
+    config;
+    localDir;
+    client;
+    pollIntervalMs;
+    scopes;
+    onEvent;
+    timer;
+    stopped = false;
+    syncInFlight;
+    constructor(options) {
+        this.config = readMountHarnessConfig(options.env);
+        this.localDir = this.config.localDir;
+        this.pollIntervalMs = normalizePollIntervalMs(options.pollIntervalMs);
+        this.scopes = [...(options.scopes ?? [])];
+        this.onEvent = options.onEvent;
+        this.client =
+            options.client ??
+                new RelayFileClient({
+                    baseUrl: this.config.baseUrl,
+                    token: this.config.token,
+                });
+    }
+    async start() {
+        await mkdir(this.localDir, { recursive: true });
+        this.emit({
+            type: "started",
+            localDir: this.localDir,
+            remotePath: this.config.remotePath,
+            workspaceId: this.config.workspaceId,
+        });
+        await this.syncOnce();
+        this.scheduleNextSync();
+    }
+    async syncOnce() {
+        if (this.stopped) {
+            return;
+        }
+        if (!this.syncInFlight) {
+            this.syncInFlight = this.performSyncOnce().finally(() => {
+                this.syncInFlight = undefined;
+            });
+        }
+        await this.syncInFlight;
+    }
+    async writeLocalFile(relativePath, content) {
+        const normalizedRelativePath = normalizeRelativePath(relativePath);
+        const scopedTargetPath = joinRemotePath(this.config.remotePath, normalizedRelativePath);
+        if (!this.scopes.includes("fs:write")) {
+            const error = new MountHarnessPermissionError(scopedTargetPath, this.scopes);
+            this.emit({
+                type: "permission.denied",
+                path: scopedTargetPath,
+                scopes: [...this.scopes],
+            });
+            throw error;
+        }
+        const localPath = path.join(this.localDir, normalizedRelativePath);
+        await mkdir(path.dirname(localPath), { recursive: true });
+        await writeFile(localPath, content, "utf8");
+    }
+    async stop() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        if (this.syncInFlight) {
+            await this.syncInFlight;
+        }
+        this.emit({
+            type: "stopped",
+            localDir: this.localDir,
+            remotePath: this.config.remotePath,
+        });
+    }
+    async performSyncOnce() {
+        await mkdir(this.localDir, { recursive: true });
+        const desiredFiles = new Map();
+        const desiredDirectories = new Set([""]);
+        await this.collectRemoteTree(this.config.remotePath, desiredFiles, desiredDirectories);
+        for (const relativeDir of [...desiredDirectories].sort((left, right) => left.localeCompare(right))) {
+            if (relativeDir === "") {
+                continue;
+            }
+            await mkdir(path.join(this.localDir, relativeDir), { recursive: true });
+        }
+        for (const [relativePath, content] of [...desiredFiles.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+            const localPath = path.join(this.localDir, relativePath);
+            await mkdir(path.dirname(localPath), { recursive: true });
+            const currentContent = await readUtf8IfExists(localPath);
+            if (currentContent !== content) {
+                await writeFile(localPath, content, "utf8");
+            }
+        }
+        await pruneLocalEntries(this.localDir, desiredFiles, desiredDirectories);
+        this.emit({
+            type: "sync.completed",
+            localDir: this.localDir,
+            remotePath: this.config.remotePath,
+            files: desiredFiles.size,
+            directories: desiredDirectories.size,
+        });
+    }
+    async collectRemoteTree(remotePath, desiredFiles, desiredDirectories) {
+        const tree = await this.client.listTree(this.config.workspaceId, {
+            path: remotePath,
+            depth: 1,
+        });
+        for (const entry of tree.entries) {
+            const relativePath = relativeRemotePath(this.config.remotePath, entry.path);
+            if (relativePath === "") {
+                continue;
+            }
+            if (entry.type === "dir") {
+                desiredDirectories.add(relativePath);
+                await this.collectRemoteTree(entry.path, desiredFiles, desiredDirectories);
+                continue;
+            }
+            desiredDirectories.add(path.posix.dirname(relativePath) === "." ? "" : path.posix.dirname(relativePath));
+            const file = await this.client.readFile(this.config.workspaceId, entry.path);
+            desiredFiles.set(relativePath, decodeContent(file.content, file.encoding));
+        }
+    }
+    scheduleNextSync() {
+        if (this.stopped) {
+            return;
+        }
+        this.timer = setTimeout(() => {
+            void this.syncOnce()
+                .catch((error) => {
+                console.error(`mount-harness sync failed: ${formatErrorMessage(error)}`);
+            })
+                .finally(() => {
+                this.scheduleNextSync();
+            });
+        }, this.pollIntervalMs);
+    }
+    emit(event) {
+        this.onEvent?.(event);
+    }
+}
+async function pruneLocalEntries(rootDir, desiredFiles, desiredDirectories) {
+    if (!(await exists(rootDir))) {
+        return;
+    }
+    const entries = await walkLocalTree(rootDir);
+    for (const entry of entries.sort((left, right) => right.relativePath.localeCompare(left.relativePath))) {
+        if (entry.relativePath === "") {
+            continue;
+        }
+        const absolutePath = path.join(rootDir, entry.relativePath);
+        if (entry.kind === "file") {
+            if (!desiredFiles.has(entry.relativePath)) {
+                await rm(absolutePath, { force: true });
+            }
+            continue;
+        }
+        if (!desiredDirectories.has(entry.relativePath)) {
+            await rm(absolutePath, { recursive: true, force: true });
+        }
+    }
+}
+async function walkLocalTree(rootDir, currentDir = rootDir, entries = []) {
+    const children = await readdir(currentDir, { withFileTypes: true });
+    for (const child of children) {
+        const absolutePath = path.join(currentDir, child.name);
+        const relativePath = normalizeRelativePath(path.relative(rootDir, absolutePath));
+        if (child.isDirectory()) {
+            entries.push({ relativePath, kind: "dir" });
+            await walkLocalTree(rootDir, absolutePath, entries);
+            continue;
+        }
+        entries.push({ relativePath, kind: "file" });
+    }
+    return entries;
+}
+async function readUtf8IfExists(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function exists(targetPath) {
+    try {
+        await stat(targetPath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+function decodeContent(content, encoding) {
+    if (encoding === "base64") {
+        return Buffer.from(content, "base64").toString("utf8");
+    }
+    return content;
+}
+function joinRemotePath(rootPath, relativePath) {
+    return normalizeRemotePath(`${normalizeRemotePath(rootPath).replace(/\/$/, "")}/${relativePath}`.replace(/\/{2,}/g, "/"));
+}
+function relativeRemotePath(rootPath, targetPath) {
+    const normalizedRoot = normalizeRemotePath(rootPath);
+    const normalizedTarget = normalizeRemotePath(targetPath);
+    if (normalizedRoot === normalizedTarget) {
+        return "";
+    }
+    if (normalizedRoot === "/") {
+        return normalizeRelativePath(normalizedTarget.slice(1));
+    }
+    if (!normalizedTarget.startsWith(`${normalizedRoot}/`)) {
+        throw new Error(`Remote path ${normalizedTarget} is outside root ${normalizedRoot}.`);
+    }
+    return normalizeRelativePath(normalizedTarget.slice(normalizedRoot.length + 1));
+}
+function normalizeRemotePath(input) {
+    const trimmed = input.trim();
+    const normalized = path.posix.normalize(trimmed === "" ? "/" : trimmed);
+    return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+function normalizeRelativePath(input) {
+    const normalized = path.posix.normalize(input.replace(/\\/g, "/"));
+    if (normalized === "." || normalized === "") {
+        return "";
+    }
+    return normalized.replace(/^\/+/, "");
+}
+function normalizePollIntervalMs(value) {
+    if (value === undefined || !Number.isFinite(value) || value <= 0) {
+        return DEFAULT_POLL_INTERVAL_MS;
+    }
+    return Math.floor(value);
+}
+function readRequiredEnv(env, key) {
+    const value = env[key];
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`Missing required mount env: ${key}`);
+    }
+    return value.trim();
+}
+function formatErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+export async function runMountHarnessCli(argv = process.argv.slice(2), env = process.env) {
+    const options = parseCliArgs(argv);
+    const harness = await startMountHarness({
+        env,
+        pollIntervalMs: options.pollIntervalMs,
+        scopes: options.scopes,
+        onEvent: (event) => {
+            console.log(JSON.stringify(event));
+        },
+    });
+    if (options.once) {
+        await harness.stop();
+        return;
+    }
+    const stopAndExit = async () => {
+        await harness.stop();
+    };
+    const signalHandler = () => {
+        void stopAndExit()
+            .then(() => {
+            process.exitCode = 0;
+        })
+            .finally(() => {
+            process.removeListener("SIGINT", signalHandler);
+            process.removeListener("SIGTERM", signalHandler);
+        });
+    };
+    process.on("SIGINT", signalHandler);
+    process.on("SIGTERM", signalHandler);
+    await new Promise((resolve) => {
+        process.on("beforeExit", () => {
+            resolve();
+        });
+    });
+}
+function parseCliArgs(argv) {
+    const parsed = {
+        once: false,
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--once") {
+            parsed.once = true;
+            continue;
+        }
+        if (arg === "--poll-interval-ms") {
+            const rawValue = argv[index + 1];
+            if (!rawValue) {
+                throw new Error("Missing value for --poll-interval-ms");
+            }
+            parsed.pollIntervalMs = Number.parseInt(rawValue, 10);
+            index += 1;
+            continue;
+        }
+        if (arg === "--scopes") {
+            const rawValue = argv[index + 1];
+            if (!rawValue) {
+                throw new Error("Missing value for --scopes");
+            }
+            parsed.scopes = rawValue
+                .split(",")
+                .map((scope) => scope.trim())
+                .filter(Boolean);
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    return parsed;
+}
+function isDirectExecution() {
+    const entry = process.argv[1];
+    if (!entry) {
+        return false;
+    }
+    return import.meta.url === pathToFileURL(entry).href;
+}
+if (isDirectExecution()) {
+    void runMountHarnessCli().catch((error) => {
+        const status = error instanceof MountHarnessPermissionError
+            ? {
+                code: error.code,
+                path: error.path,
+                scopes: error.scopes,
+            }
+            : error instanceof RelayFileApiError
+                ? {
+                    code: error.code,
+                    status: error.status,
+                    message: error.message,
+                }
+                : {
+                    message: formatErrorMessage(error),
+                };
+        console.error(JSON.stringify({ type: "error", ...status }));
+        process.exitCode = 1;
+    });
+}

package/dist/setup-types.d.ts

@@ -30,6 +30,7 @@ export interface WorkspaceInfo {
     workspaceId: string;
     relayfileUrl: string;
     relaycastApiKey: string;
+    relaycastBaseUrl?: string;
     createdAt?: string;
     name?: string;
     wsUrl?: string;
@@ -47,8 +48,38 @@ export interface ConnectIntegrationResult {
 }
 export interface WaitForConnectionOptions {
     connectionId?: string;
+    pollIntervalMs?: number;
+    /**
+     * @deprecated Use pollIntervalMs. This alias will be removed in a future
+     * minor release.
+     */
     intervalMs?: number;
     timeoutMs?: number;
     signal?: AbortSignal;
-    onPoll?: (attempt: number, ready: boolean) => void;
+    onPoll?: (elapsed: number) => void;
+}
+export interface WorkspaceMountEnvOptions {
+    localDir?: string;
+    remotePath?: string;
+    mode?: "poll" | "fuse";
+    relaycastBaseUrl?: string;
+}
+export type WorkspaceMountEnv = Record<string, string>;
+export interface AgentWorkspaceInviteOptions {
+    agentName?: string;
+    scopes?: string[];
+    relaycastBaseUrl?: string;
+    includeRelayfileToken?: boolean;
+}
+export interface AgentWorkspaceInvite {
+    workspaceId: string;
+    cloudApiUrl: string;
+    relayfileUrl: string;
+    relaycastApiKey: string;
+    relaycastBaseUrl: string;
+    agentName: string;
+    scopes: string[];
+    relayfileToken?: string;
+    createdAt?: string;
+    name?: string;
 }

package/dist/setup.d.ts

@@ -1,12 +1,16 @@
 import { RelayFileClient, type AccessTokenProvider } from "./client.js";
-import { type ConnectIntegrationOptions, type ConnectIntegrationResult, type CreateWorkspaceOptions, type JoinWorkspaceOptions, type RelayfileSetupOptions, type WaitForConnectionOptions, type WorkspaceInfo, type WorkspaceIntegrationProvider, type WorkspacePermissions } from "./setup-types.js";
+import { type RelayfileCloudLoginOptions, type RelayfileCloudTokenSet, type RelayfileCloudTokenSetupOptions } from "./cloud-login.js";
+import { type AgentWorkspaceInvite, type AgentWorkspaceInviteOptions, type ConnectIntegrationOptions, type ConnectIntegrationResult, type CreateWorkspaceOptions, type JoinWorkspaceOptions, type RelayfileSetupOptions, type WaitForConnectionOptions, type WorkspaceMountEnv, type WorkspaceMountEnvOptions, type WorkspaceInfo, type WorkspaceIntegrationProvider, type WorkspacePermissions } from "./setup-types.js";
+export { RELAYFILE_SDK_VERSION } from "./version.js";
 interface JoinWorkspaceResponse {
     workspaceId?: string;
     token?: string;
     relayfileUrl?: string;
     wsUrl?: string;
     relaycastApiKey?: string;
+    relaycastBaseUrl?: string;
 }
+type ValidatedJoinWorkspaceResponse = Required<Pick<JoinWorkspaceResponse, "workspaceId" | "token" | "relayfileUrl" | "wsUrl" | "relaycastApiKey">> & Pick<JoinWorkspaceResponse, "relaycastBaseUrl">;
 interface NormalizedJoinWorkspaceOptions {
     agentName: string;
     scopes: string[];
@@ -32,11 +36,14 @@ export declare class RelayfileSetup {
     private readonly accessToken?;
     private readonly requestTimeoutMs;
     private readonly retryOptions;
+    static login(options?: RelayfileCloudLoginOptions): Promise<RelayfileSetup>;
+    static fromCloudTokens(tokens: RelayfileCloudTokenSet, options?: RelayfileCloudTokenSetupOptions): RelayfileSetup;
     constructor(options?: RelayfileSetupOptions);
     createWorkspace(options?: CreateWorkspaceOptions): Promise<WorkspaceHandle>;
     joinWorkspace(workspaceId: string, options?: JoinWorkspaceOptions): Promise<WorkspaceHandle>;
-    joinWorkspaceResponse(workspaceId: string, options: NormalizedJoinWorkspaceOptions): Promise<Required<JoinWorkspaceResponse>>;
+    joinWorkspaceResponse(workspaceId: string, options: NormalizedJoinWorkspaceOptions): Promise<ValidatedJoinWorkspaceResponse>;
     requestJson(options: CloudRequestOptions): Promise<unknown>;
+    getCloudApiUrl(): string;
 }
 export declare class WorkspaceHandle {
     readonly info: WorkspaceInfo;
@@ -51,14 +58,18 @@ export declare class WorkspaceHandle {
     constructor(options: WorkspaceHandleOptions);
     client(): RelayFileClient;
     connectIntegration(provider: WorkspaceIntegrationProvider, options?: ConnectIntegrationOptions): Promise<ConnectIntegrationResult>;
+    connectNotion(options?: Omit<ConnectIntegrationOptions, "allowedIntegrations">): Promise<ConnectIntegrationResult>;
     waitForConnection(provider: WorkspaceIntegrationProvider, options?: WaitForConnectionOptions): Promise<void>;
+    waitForNotion(options?: WaitForConnectionOptions): Promise<void>;
     isConnected(provider: WorkspaceIntegrationProvider, connectionId: string): Promise<boolean>;
     disconnectIntegration(provider: WorkspaceIntegrationProvider, _connectionId?: string): Promise<void>;
     getToken(): string;
+    mountEnv(options?: WorkspaceMountEnvOptions): WorkspaceMountEnv;
+    agentInvite(options?: AgentWorkspaceInviteOptions): AgentWorkspaceInvite;
     refreshToken(): Promise<void>;
     private performRefreshToken;
     private getOrRefreshToken;
     private resolveConnectionId;
     private getConnectionStatus;
+    private resolveRelaycastBaseUrl;
 }
-export {};

package/dist/setup.js

@@ -1,7 +1,11 @@
 import { RelayFileClient } from "./client.js";
+import { createRelayfileCloudAccessTokenProvider, runRelayfileCloudLogin } from "./cloud-login.js";
 import { CloudAbortError, CloudApiError, CloudTimeoutError, IntegrationConnectionTimeoutError, MalformedCloudResponseError, MissingConnectionIdError, UnknownProviderError } from "./setup-errors.js";
 import { WORKSPACE_INTEGRATION_PROVIDERS } from "./setup-types.js";
+import { RELAYFILE_SDK_VERSION } from "./version.js";
+export { RELAYFILE_SDK_VERSION } from "./version.js";
 const DEFAULT_CLOUD_API_URL = "https://agentrelay.com/cloud";
+const DEFAULT_RELAYCAST_BASE_URL = "https://api.relaycast.dev";
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 const DEFAULT_RETRY_BASE_DELAY_MS = 500;
 const DEFAULT_RETRY_MAX_DELAY_MS = 5_000;
@@ -16,6 +20,32 @@ export class RelayfileSetup {
     accessToken;
     requestTimeoutMs;
     retryOptions;
+    static async login(options = {}) {
+        const cloudApiUrl = options.cloudApiUrl ?? DEFAULT_CLOUD_API_URL;
+        const tokens = await runRelayfileCloudLogin({
+            ...options,
+            cloudApiUrl
+        });
+        await options.onTokens?.({ ...tokens });
+        return RelayfileSetup.fromCloudTokens(tokens, {
+            ...options,
+            cloudApiUrl: tokens.apiUrl ?? cloudApiUrl
+        });
+    }
+    static fromCloudTokens(tokens, options = {}) {
+        const cloudApiUrl = options.cloudApiUrl ?? tokens.apiUrl ?? DEFAULT_CLOUD_API_URL;
+        return new RelayfileSetup({
+            ...options,
+            cloudApiUrl,
+            accessToken: createRelayfileCloudAccessTokenProvider({
+                ...tokens,
+                apiUrl: tokens.apiUrl ?? cloudApiUrl
+            }, {
+                ...options,
+                cloudApiUrl
+            })
+        });
+    }
     constructor(options = {}) {
         this.cloudApiUrl = options.cloudApiUrl ?? DEFAULT_CLOUD_API_URL;
         this.accessToken = options.accessToken;
@@ -44,6 +74,7 @@ export class RelayfileSetup {
                 workspaceId: createResponse.workspaceId,
                 relayfileUrl: joinResponse.relayfileUrl,
                 relaycastApiKey: joinResponse.relaycastApiKey,
+                relaycastBaseUrl: joinResponse.relaycastBaseUrl,
                 createdAt: createResponse.createdAt,
                 name: createResponse.name,
                 wsUrl: joinResponse.wsUrl
@@ -61,6 +92,7 @@ export class RelayfileSetup {
                 workspaceId: joinResponse.workspaceId,
                 relayfileUrl: joinResponse.relayfileUrl,
                 relaycastApiKey: joinResponse.relaycastApiKey,
+                relaycastBaseUrl: joinResponse.relaycastBaseUrl,
                 wsUrl: joinResponse.wsUrl
             },
             token: joinResponse.token,
@@ -85,7 +117,9 @@ export class RelayfileSetup {
         let retries = 0;
         for (;;) {
             const token = await resolveToken(options.tokenProvider ?? this.accessToken);
-            const headers = {};
+            const headers = {
+                "X-Relayfile-SDK-Version": RELAYFILE_SDK_VERSION
+            };
             if (token) {
                 headers.Authorization = `Bearer ${token}`;
             }
@@ -125,6 +159,9 @@ export class RelayfileSetup {
             throw new CloudApiError(response.status, payload);
         }
     }
+    getCloudApiUrl() {
+        return this.cloudApiUrl;
+    }
 }
 export class WorkspaceHandle {
     info;
@@ -194,16 +231,22 @@ export class WorkspaceHandle {
             connectionId
         };
     }
+    async connectNotion(options = {}) {
+        return this.connectIntegration("notion", {
+            ...options,
+            allowedIntegrations: ["notion"]
+        });
+    }
     async waitForConnection(provider, options = {}) {
         assertProvider(provider);
         const connectionId = this.resolveConnectionId(provider, options.connectionId);
-        const intervalMs = Math.max(0, Math.floor(options.intervalMs ?? DEFAULT_WAIT_INTERVAL_MS));
+        const pollIntervalMs = Math.max(0, Math.floor(options.pollIntervalMs ?? options.intervalMs ?? DEFAULT_WAIT_INTERVAL_MS));
         const timeoutMs = Math.max(1, Math.floor(options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS));
         const startedAt = Date.now();
-        let attempt = 0;
         for (;;) {
             throwIfAborted(options.signal, "waitForConnection");
             const elapsedMs = Date.now() - startedAt;
+            options.onPoll?.(elapsedMs);
             if (elapsedMs >= timeoutMs) {
                 throw new IntegrationConnectionTimeoutError({
                     provider,
@@ -212,7 +255,6 @@ export class WorkspaceHandle {
                     timeoutMs
                 });
             }
-            attempt += 1;
             const remainingMs = timeoutMs - elapsedMs;
             let ready;
             try {
@@ -232,14 +274,16 @@ export class WorkspaceHandle {
                 }
                 throw error;
             }
-            options.onPoll?.(attempt, ready);
             if (ready) {
                 return;
             }
-            const sleepMs = Math.min(intervalMs, Math.max(0, timeoutMs - (Date.now() - startedAt)));
+            const sleepMs = Math.min(pollIntervalMs, Math.max(0, timeoutMs - (Date.now() - startedAt)));
             await sleep(sleepMs, options.signal, "waitForConnection");
         }
     }
+    async waitForNotion(options = {}) {
+        return this.waitForConnection("notion", options);
+    }
     async isConnected(provider, connectionId) {
         assertProvider(provider);
         return this.getConnectionStatus(provider, this.resolveConnectionId(provider, connectionId));
@@ -257,6 +301,38 @@ export class WorkspaceHandle {
     getToken() {
         return this._token;
     }
+    mountEnv(options = {}) {
+        const relaycastBaseUrl = this.resolveRelaycastBaseUrl(options.relaycastBaseUrl);
+        return compactStringRecord({
+            RELAYFILE_BASE_URL: this.info.relayfileUrl,
+            RELAYFILE_TOKEN: this.getToken(),
+            RELAYFILE_WORKSPACE: this.workspaceId,
+            RELAYFILE_REMOTE_PATH: options.remotePath ?? "/",
+            RELAYFILE_LOCAL_DIR: options.localDir,
+            RELAYFILE_MOUNT_MODE: options.mode,
+            RELAYCAST_API_KEY: this.info.relaycastApiKey,
+            RELAY_API_KEY: this.info.relaycastApiKey,
+            RELAYCAST_BASE_URL: relaycastBaseUrl,
+            RELAY_BASE_URL: relaycastBaseUrl
+        });
+    }
+    agentInvite(options = {}) {
+        const relaycastBaseUrl = this.resolveRelaycastBaseUrl(options.relaycastBaseUrl);
+        return compactObject({
+            workspaceId: this.workspaceId,
+            cloudApiUrl: this._setup.getCloudApiUrl(),
+            relayfileUrl: this.info.relayfileUrl,
+            relaycastApiKey: this.info.relaycastApiKey,
+            relaycastBaseUrl,
+            agentName: options.agentName ?? this._joinOptions.agentName,
+            scopes: options.scopes && options.scopes.length > 0
+                ? [...options.scopes]
+                : [...this._joinOptions.scopes],
+            relayfileToken: options.includeRelayfileToken === false ? undefined : this.getToken(),
+            createdAt: this.info.createdAt,
+            name: this.info.name
+        });
+    }
     async refreshToken() {
         if (!this._refreshPromise) {
             this._refreshPromise = this.performRefreshToken();
@@ -298,6 +374,11 @@ export class WorkspaceHandle {
         }));
         return response.ready;
     }
+    resolveRelaycastBaseUrl(override) {
+        return (normalizeNonEmptyString(override) ??
+            normalizeNonEmptyString(this.info.relaycastBaseUrl) ??
+            DEFAULT_RELAYCAST_BASE_URL);
+    }
 }
 function assertProvider(provider) {
     if (!WORKSPACE_INTEGRATION_PROVIDERS.includes(provider)) {
@@ -337,7 +418,8 @@ function validateJoinWorkspaceResponse(payload) {
         token: requireStringField(payload, "token"),
         relayfileUrl: requireStringField(payload, "relayfileUrl"),
         wsUrl: requireStringField(payload, "wsUrl"),
-        relaycastApiKey: requireStringField(payload, "relaycastApiKey")
+        relaycastApiKey: requireStringField(payload, "relaycastApiKey"),
+        relaycastBaseUrl: readOptionalStringField(payload, "relaycastBaseUrl")
     };
 }
 function validateConnectSessionResponse(payload) {
@@ -402,6 +484,12 @@ function clonePermissions(permissions) {
 function compactObject(value) {
     return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
+function compactStringRecord(value) {
+    return Object.fromEntries(Object.entries(value).filter((entry) => {
+        const [, entryValue] = entry;
+        return entryValue !== undefined;
+    }));
+}
 function buildCloudUrl(baseUrl, path) {
     const base = new URL(baseUrl);
     if (!base.pathname.endsWith("/")) {

package/dist/types.d.ts

@@ -196,6 +196,7 @@ export interface SyncProviderStatus {
     failureCodes?: Record<string, number>;
     deadLetteredEnvelopes?: number;
     deadLetteredOps?: number;
+    webhookHealthy?: boolean;
 }
 export interface SyncStatusResponse {
     workspaceId: string;

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const RELAYFILE_SDK_VERSION = "0.6.0";

package/dist/version.js

@@ -0,0 +1 @@
+export const RELAYFILE_SDK_VERSION = "0.6.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relayfile/sdk",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "TypeScript SDK for relayfile — real-time filesystem for humans and agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,11 +12,15 @@
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
+    "test:e2e": "node scripts/setup-e2e.mjs",
+    "agent-workspace:e2e": "node scripts/agent-workspace-golden-path-e2e.mjs",
+    "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"
   },
   "dependencies": {
-    "@relayfile/core": "0.6.0"
+    "@relayfile/core": "0.6.2"
   },
   "devDependencies": {
     "typescript": "^5.7.3",