@relayfile/sdk 0.5.3 → 0.6.1

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-errors.d.ts

@@ -0,0 +1,44 @@
+import type { WorkspaceIntegrationProvider } from "./setup-types.js";
+export declare class RelayfileSetupError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare class CloudApiError extends RelayfileSetupError {
+    readonly httpStatus: number;
+    readonly httpBody: unknown;
+    constructor(httpStatus: number, httpBody: unknown, message?: string);
+}
+export declare class MalformedCloudResponseError extends RelayfileSetupError {
+    readonly field: string;
+    readonly response: unknown;
+    constructor(field: string, response: unknown);
+}
+export declare class CloudTimeoutError extends RelayfileSetupError {
+    readonly operation: string;
+    readonly timeoutMs: number;
+    constructor(operation: string, timeoutMs: number);
+}
+export declare class IntegrationConnectionTimeoutError extends RelayfileSetupError {
+    readonly provider: WorkspaceIntegrationProvider;
+    readonly connectionId: string;
+    readonly elapsedMs: number;
+    readonly timeoutMs: number;
+    constructor(input: {
+        provider: WorkspaceIntegrationProvider;
+        connectionId: string;
+        elapsedMs: number;
+        timeoutMs: number;
+    });
+}
+export declare class CloudAbortError extends RelayfileSetupError {
+    readonly operation: string;
+    constructor(operation: string);
+}
+export declare class UnknownProviderError extends RelayfileSetupError {
+    readonly provider: string;
+    constructor(provider: string);
+}
+export declare class MissingConnectionIdError extends RelayfileSetupError {
+    readonly provider: WorkspaceIntegrationProvider;
+    constructor(provider: WorkspaceIntegrationProvider);
+}

package/dist/setup-errors.js

@@ -0,0 +1,79 @@
+export class RelayfileSetupError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = new.target.name;
+        this.code = code;
+    }
+}
+export class CloudApiError extends RelayfileSetupError {
+    httpStatus;
+    httpBody;
+    constructor(httpStatus, httpBody, message) {
+        super(message ??
+            readCloudErrorMessage(httpBody) ??
+            `Cloud API request failed with status ${httpStatus}.`, "cloud_api_error");
+        this.httpStatus = httpStatus;
+        this.httpBody = httpBody;
+    }
+}
+export class MalformedCloudResponseError extends RelayfileSetupError {
+    field;
+    response;
+    constructor(field, response) {
+        super(`Cloud API response is missing required field "${field}".`, "malformed_cloud_response");
+        this.field = field;
+        this.response = response;
+    }
+}
+export class CloudTimeoutError extends RelayfileSetupError {
+    operation;
+    timeoutMs;
+    constructor(operation, timeoutMs) {
+        super(`Timed out while waiting for ${operation} after ${timeoutMs}ms.`, "cloud_timeout_error");
+        this.operation = operation;
+        this.timeoutMs = timeoutMs;
+    }
+}
+export class IntegrationConnectionTimeoutError extends RelayfileSetupError {
+    provider;
+    connectionId;
+    elapsedMs;
+    timeoutMs;
+    constructor(input) {
+        super(`Timed out waiting for ${input.provider} connection "${input.connectionId}" after ${input.elapsedMs}ms.`, "integration_connection_timeout");
+        this.provider = input.provider;
+        this.connectionId = input.connectionId;
+        this.elapsedMs = input.elapsedMs;
+        this.timeoutMs = input.timeoutMs;
+    }
+}
+export class CloudAbortError extends RelayfileSetupError {
+    operation;
+    constructor(operation) {
+        super(`Aborted while waiting for ${operation}.`, "cloud_abort_error");
+        this.operation = operation;
+    }
+}
+export class UnknownProviderError extends RelayfileSetupError {
+    provider;
+    constructor(provider) {
+        super(`Unknown workspace integration provider "${provider}".`, "unknown_provider");
+        this.provider = provider;
+    }
+}
+export class MissingConnectionIdError extends RelayfileSetupError {
+    provider;
+    constructor(provider) {
+        super(`No connectionId is available for provider "${provider}".`, "missing_connection_id");
+        this.provider = provider;
+    }
+}
+function readCloudErrorMessage(httpBody) {
+    if (!httpBody || typeof httpBody !== "object" || Array.isArray(httpBody)) {
+        return undefined;
+    }
+    const data = httpBody;
+    const message = data.message ?? data.error;
+    return typeof message === "string" && message.trim() !== "" ? message : undefined;
+}

package/dist/setup-types.d.ts

@@ -0,0 +1,85 @@
+import type { AccessTokenProvider } from "./client.js";
+export declare const WORKSPACE_INTEGRATION_PROVIDERS: readonly ["github", "slack-sage", "slack-my-senior-dev", "slack-nightcto", "notion", "linear"];
+export type WorkspaceIntegrationProvider = (typeof WORKSPACE_INTEGRATION_PROVIDERS)[number];
+export interface WorkspacePermissions {
+    readonly?: string[];
+    ignored?: string[];
+}
+export interface RelayfileSetupRetryOptions {
+    maxRetries: number;
+    baseDelayMs: number;
+}
+export interface RelayfileSetupOptions {
+    cloudApiUrl?: string;
+    accessToken?: AccessTokenProvider;
+    requestTimeoutMs?: number;
+    retry?: RelayfileSetupRetryOptions;
+}
+export interface CreateWorkspaceOptions {
+    name?: string;
+    permissions?: WorkspacePermissions;
+    agentName?: string;
+    scopes?: string[];
+}
+export interface JoinWorkspaceOptions {
+    agentName?: string;
+    scopes?: string[];
+    permissions?: WorkspacePermissions;
+}
+export interface WorkspaceInfo {
+    workspaceId: string;
+    relayfileUrl: string;
+    relaycastApiKey: string;
+    relaycastBaseUrl?: string;
+    createdAt?: string;
+    name?: string;
+    wsUrl?: string;
+}
+export interface ConnectIntegrationOptions {
+    connectionId?: string;
+    allowedIntegrations?: string[];
+}
+export interface ConnectIntegrationResult {
+    connectLink: string | null;
+    sessionToken: string | null;
+    expiresAt: string | null;
+    alreadyConnected: boolean;
+    connectionId: string;
+}
+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?: (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-types.js

@@ -0,0 +1,8 @@
+export const WORKSPACE_INTEGRATION_PROVIDERS = [
+    "github",
+    "slack-sage",
+    "slack-my-senior-dev",
+    "slack-nightcto",
+    "notion",
+    "linear"
+];

package/dist/setup.d.ts

@@ -0,0 +1,75 @@
+import { RelayFileClient, type AccessTokenProvider } from "./client.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[];
+    permissions?: WorkspacePermissions;
+}
+interface CloudRequestOptions {
+    operation: string;
+    method: string;
+    path: string;
+    body?: unknown;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    tokenProvider?: AccessTokenProvider;
+}
+interface WorkspaceHandleOptions {
+    setup: RelayfileSetup;
+    info: WorkspaceInfo;
+    token: string;
+    joinOptions: NormalizedJoinWorkspaceOptions;
+}
+export declare class RelayfileSetup {
+    private readonly cloudApiUrl;
+    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<ValidatedJoinWorkspaceResponse>;
+    requestJson(options: CloudRequestOptions): Promise<unknown>;
+    getCloudApiUrl(): string;
+}
+export declare class WorkspaceHandle {
+    readonly info: WorkspaceInfo;
+    readonly workspaceId: string;
+    private readonly _setup;
+    private readonly _joinOptions;
+    private readonly _pendingConnections;
+    private _token;
+    private _tokenIssuedAt;
+    private _client?;
+    private _refreshPromise?;
+    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;
+}