@caplets/core 0.18.8 → 0.19.0

package/dist/native/options.d.ts

@@ -1,15 +1,25 @@
-import { type CapletsMode, type CapletsServerEnv, type CapletsServerInput } from "../server/options";
+import { type CapletsServerEnv, type CapletsServerInput } from "../server/options";
+import { type CapletsRemoteEnv } from "../remote/options";
+type CapletsMode = "auto" | "local" | "remote" | "cloud";
 export type NativeCapletsMode = CapletsMode;
 export type NativeRemoteCapletsOptions = {
     pollIntervalMs?: number;
     fetch?: typeof fetch;
+    cloud?: NativeCloudPresenceInput;
+};
+export type NativeCloudPresenceInput = {
+    url?: string;
+    accessToken?: string;
+    workspaceId?: string;
+    projectRoot?: string;
+    heartbeatIntervalMs?: number;
 };
 export type NativeCapletsServiceResolutionInput = {
     mode?: NativeCapletsMode;
     server?: CapletsServerInput;
     remote?: NativeRemoteCapletsOptions;
 };
-export type NativeCapletsEnv = CapletsServerEnv;
+export type NativeCapletsEnv = CapletsServerEnv & CapletsRemoteEnv;
 export type NativeRemoteAuthOptions = {
     enabled: false;
     user: string;
@@ -21,13 +31,22 @@ export type NativeRemoteAuthOptions = {
 export type ResolvedNativeCapletsServiceOptions = {
     mode: "local";
 } | {
-    mode: "remote";
+    mode: "remote" | "cloud";
     remote: {
         url: URL;
         auth: NativeRemoteAuthOptions;
         pollIntervalMs: number;
         requestInit: RequestInit;
+        cloud?: ResolvedNativeCloudPresenceOptions;
         fetch?: typeof fetch;
     };
 };
 export declare function resolveNativeCapletsServiceOptions(input?: NativeCapletsServiceResolutionInput, env?: NativeCapletsEnv): ResolvedNativeCapletsServiceOptions;
+export type ResolvedNativeCloudPresenceOptions = {
+    url: URL;
+    accessToken: string;
+    workspaceId: string;
+    projectRoot?: string;
+    heartbeatIntervalMs: number;
+};
+export {};

package/dist/native/remote.d.ts

@@ -13,12 +13,13 @@ export type RemoteCapletsClient = {
     close(): Promise<void>;
 };
 export type RemoteCapletsClientOptions = ResolvedNativeCapletsServiceOptions & {
-    mode: "remote";
+    mode: "remote" | "cloud";
 };
 export type RemoteNativeCapletsServiceOptions = {
     client: RemoteCapletsClient;
     clientFactory?: () => RemoteCapletsClient;
     pollIntervalMs: number;
+    authKind?: "self_hosted_remote" | "hosted_cloud";
     writeErr?: (value: string) => void;
 };
 export declare function createSdkRemoteCapletsClient(options: RemoteCapletsClientOptions["remote"]): RemoteCapletsClient;

package/dist/native/service.d.ts

@@ -10,9 +10,7 @@ export type NativeCapletsServiceOptions = NativeCapletsServiceResolutionInput &
     watchDebounceMs?: number;
     watch?: boolean;
     writeErr?: (value: string) => void;
-    remoteClientFactory?: (options: Extract<ReturnType<typeof resolveNativeCapletsServiceOptions>, {
-        mode: "remote";
-    }>["remote"]) => RemoteCapletsClient;
+    remoteClientFactory?: (options: ResolvedNativeRemoteOptions) => RemoteCapletsClient;
     localServiceFactory?: (options: LocalNativeCapletsServiceOptions) => NativeCapletsService;
 };
 export type NativeCapletTool = {
@@ -33,7 +31,13 @@ export type NativeCapletsService = {
     close(): Promise<void>;
 };
 export declare function createNativeCapletsService(options?: NativeCapletsServiceOptions): NativeCapletsService;
+export declare function resetNativeProjectBindingFallbackWarningForTests(): void;
 type LocalNativeCapletsServiceOptions = NativeCapletsServiceOptions & {
     configLoader?: (configPath: string, projectConfigPath: string) => CapletsConfig;
 };
+type ResolvedNativeRemoteOptions = Extract<Exclude<ReturnType<typeof resolveNativeCapletsServiceOptions>, {
+    mode: "local";
+}>, {
+    remote: unknown;
+}>["remote"];
 export {};

package/dist/native.js

@@ -1,433 +1,5 @@
-import { Pt as CapletsError, Q as ToolListChangedNotificationSchema, _ as StreamableHTTPClientTransport, a as resolveCapletsServer, b as Client, bt as parseConfig, i as resolveCapletsMode, l as capabilityDescription, n as mcpUrlForBase, o as CapletsEngine, vt as loadLocalOverlayConfigWithSources } from "./options--RoZwWjs.js";
-import { a as generatedToolInputJsonSchemaForCaplet, i as generatedToolInputJsonSchema, l as operations, o as generatedToolInputSchema } from "./generated-tool-input-schema-MbYF5jMW.js";
-//#region src/native/options.ts
-const DEFAULT_POLL_INTERVAL_MS = 3e4;
-function resolveNativeCapletsServiceOptions(input = {}, env = process.env) {
-	if (resolveCapletsMode({
-		...input.mode ? { mode: input.mode } : {},
-		...input.server?.url ? { serverUrl: input.server.url } : {}
-	}, env).mode === "local") return { mode: "local" };
-	const serverFetch = input.remote?.fetch ?? input.server?.fetch;
-	const server = resolveCapletsServer({
-		...input.server,
-		...serverFetch ? { fetch: serverFetch } : {}
-	}, env);
-	return {
-		mode: "remote",
-		remote: {
-			url: mcpUrlForBase(server.baseUrl),
-			auth: server.auth,
-			pollIntervalMs: parsePollInterval(input.remote?.pollIntervalMs),
-			requestInit: server.requestInit,
-			...server.fetch ? { fetch: server.fetch } : {}
-		}
-	};
-}
-function parsePollInterval(value) {
-	if (value === void 0) return DEFAULT_POLL_INTERVAL_MS;
-	if (!Number.isInteger(value) || value < 1e3) throw new CapletsError("REQUEST_INVALID", "remote.pollIntervalMs must be an integer >= 1000.");
-	return value;
-}
-//#endregion
-//#region src/native/tools.ts
-function nativeCapletToolName(capletId) {
-	return `caplets_${capletId.replace(/_/g, "__").replace(/-/g, "_")}`;
-}
-function nativeCapletsSystemGuidance(toolNames) {
-	return [
-		"## Caplets Native Tools",
-		"",
-		"Caplets tools expose configured capability domains through progressive discovery.",
-		"",
-		"Available Caplets native tools:",
-		toolNames.length > 0 ? toolNames.map((tool) => `- ${tool}`).join("\n") : "- none",
-		"",
-		"Flow: get_caplet when the domain is unfamiliar; use search_tools/list_tools for actions; MCP-backed Caplets may also expose resources, prompts, and completions in their tool schema.",
-		"Use fields on call_tool when a non-GraphQL downstream outputSchema allows selecting only needed structured paths."
-	].join("\n");
-}
-function nativeCapletPromptGuidance(toolName, caplet) {
-	return caplet.backend === "mcp" ? [`Use ${toolName} for the ${caplet.name} Caplet capability domain.`, "Prefer resources for readable context, prompts for reusable workflows, and tools for actions."] : [`Use ${toolName} for the ${caplet.name} Caplet capability domain.`];
-}
-function nativeCapletToolDescription(toolName, caplet) {
-	return [
-		capabilityDescription(caplet),
-		"",
-		`Native tool name: ${toolName}`,
-		`Original Caplet ID: ${caplet.server}`
-	].join("\n");
-}
-//#endregion
-//#region src/native/remote.ts
-function createSdkRemoteCapletsClient(options) {
-	const client = new Client({
-		name: "caplets-native",
-		version: "1.0.0"
-	}, { capabilities: {} });
-	const transport = new StreamableHTTPClientTransport(options.url, {
-		requestInit: options.requestInit,
-		...options.fetch ? { fetch: options.fetch } : {}
-	});
-	const ready = client.connect(transport);
-	const readyObserved = ready.catch(() => void 0);
-	const listeners = /* @__PURE__ */ new Set();
-	client.setNotificationHandler(ToolListChangedNotificationSchema, () => {
-		for (const listener of listeners) listener();
-	});
-	return {
-		async listTools() {
-			await ready;
-			return ((await client.listTools()).tools ?? []).map((tool) => ({
-				name: tool.name,
-				...tool.title ? { title: tool.title } : {},
-				...tool.description ? { description: tool.description } : {},
-				...tool.inputSchema ? { inputSchema: tool.inputSchema } : {}
-			}));
-		},
-		async callTool(name, args) {
-			await ready;
-			const toolArguments = args && typeof args === "object" && !Array.isArray(args) ? args : void 0;
-			return await client.callTool({
-				name,
-				arguments: toolArguments
-			});
-		},
-		onToolsChanged(listener) {
-			listeners.add(listener);
-			return () => listeners.delete(listener);
-		},
-		async close() {
-			listeners.clear();
-			await readyObserved;
-			await transport.terminateSession().catch(() => void 0);
-			await client.close();
-		}
-	};
-}
-var RemoteNativeCapletsService = class {
-	options;
-	tools = [];
-	listeners = /* @__PURE__ */ new Set();
-	clientFactory;
-	client;
-	unsubscribeRemote;
-	pollTimer;
-	closed = false;
-	resetInFlight;
-	constructor(options) {
-		this.options = options;
-		this.client = options.client;
-		this.clientFactory = options.clientFactory ?? (() => options.client);
-		this.unsubscribeRemote = this.subscribeRemote(this.client);
-		this.pollTimer = setInterval(() => {
-			this.reload();
-		}, options.pollIntervalMs);
-		this.pollTimer.unref?.();
-	}
-	listTools() {
-		return [...this.tools];
-	}
-	async execute(capletId, request) {
-		try {
-			return await this.client.callTool(capletId, request);
-		} catch (error) {
-			if (isAuthFailure(error)) throw remoteAuthError();
-			if (isSessionFailure(error)) {
-				if (!await this.resetClient() || this.closed) throw error;
-				try {
-					return await this.client.callTool(capletId, request);
-				} catch (retryError) {
-					if (isAuthFailure(retryError)) throw remoteAuthError();
-					throw retryError;
-				}
-			}
-			throw error;
-		}
-	}
-	async reload() {
-		if (this.closed) return false;
-		try {
-			await this.reloadFromClient();
-			return true;
-		} catch (error) {
-			if (isSessionFailure(error)) try {
-				if (!await this.resetClient() || this.closed) return false;
-				await this.reloadFromClient();
-				return !this.closed;
-			} catch (retryError) {
-				this.warn(`Could not reload remote Caplets tools: ${errorMessage$2(retryError)}\n`);
-				return false;
-			}
-			this.warn(`Could not reload remote Caplets tools: ${errorMessage$2(error)}\n`);
-			return false;
-		}
-	}
-	onToolsChanged(listener) {
-		this.listeners.add(listener);
-		return () => this.listeners.delete(listener);
-	}
-	async close() {
-		if (this.closed) return;
-		this.closed = true;
-		clearInterval(this.pollTimer);
-		this.unsubscribeRemote();
-		this.listeners.clear();
-		await this.client.close();
-	}
-	async reloadFromClient() {
-		const tools = (await this.client.listTools()).map(remoteToolToNativeTool);
-		const changed = JSON.stringify(tools) !== JSON.stringify(this.tools);
-		this.tools = tools;
-		if (changed) this.emitToolsChanged();
-	}
-	subscribeRemote(client) {
-		return client.onToolsChanged(() => {
-			this.reload();
-		});
-	}
-	async resetClient() {
-		if (this.resetInFlight) return await this.resetInFlight;
-		this.resetInFlight = this.doResetClient();
-		try {
-			return await this.resetInFlight;
-		} finally {
-			this.resetInFlight = void 0;
-		}
-	}
-	async doResetClient() {
-		if (this.closed) return false;
-		this.unsubscribeRemote();
-		await this.client.close().catch(() => void 0);
-		if (this.closed) return false;
-		const nextClient = this.clientFactory();
-		if (this.closed) {
-			await nextClient.close().catch(() => void 0);
-			return false;
-		}
-		this.client = nextClient;
-		this.unsubscribeRemote = this.subscribeRemote(this.client);
-		return true;
-	}
-	emitToolsChanged() {
-		const tools = this.listTools();
-		for (const listener of this.listeners) listener(tools);
-	}
-	warn(message) {
-		this.options.writeErr?.(message);
-	}
-};
-function remoteToolToNativeTool(tool) {
-	const toolName = nativeCapletToolName(tool.name);
-	const inputSchema = isPlainObject(tool.inputSchema) ? tool.inputSchema : generatedToolInputJsonSchemaForCaplet({ backend: "tool" });
-	return {
-		caplet: tool.name,
-		toolName,
-		title: tool.title ?? tool.name,
-		description: [
-			tool.description ?? "Remote Caplets tool.",
-			"",
-			`Native tool name: ${toolName}`,
-			`Remote Caplet ID: ${tool.name}`
-		].join("\n"),
-		promptGuidance: [`Use ${toolName} through the remote Caplets service.`],
-		inputSchema,
-		operationNames: operationNamesFromSchema(inputSchema)
-	};
-}
-function operationNamesFromSchema(schema) {
-	const properties = schema.properties;
-	if (!isPlainObject(properties)) return [...operations];
-	const operation = properties.operation;
-	if (!isPlainObject(operation) || !Array.isArray(operation.enum)) return [...operations];
-	return operation.enum.filter((value) => typeof value === "string");
-}
-function isPlainObject(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function errorMessage$2(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function remoteAuthError() {
-	return new CapletsError("AUTH_FAILED", "Remote Caplets authentication failed; check CAPLETS_SERVER_USER and CAPLETS_SERVER_PASSWORD.");
-}
-function isSessionFailure(error) {
-	const message = errorMessage$2(error).toLowerCase();
-	return /session|transport|connection|connect|closed|invalid/u.test(message);
-}
-function isAuthFailure(error) {
-	const candidate = error;
-	const status = typeof candidate?.status === "number" ? candidate.status : void 0;
-	const statusCode = typeof candidate?.statusCode === "number" ? candidate.statusCode : void 0;
-	const code = typeof candidate?.code === "number" ? candidate.code : void 0;
-	if (status === 401 || status === 403 || statusCode === 401 || statusCode === 403 || code === 401 || code === 403) return true;
-	return /\b(401|403|unauthorized|forbidden)\b/iu.test(errorMessage$2(error));
-}
-//#endregion
-//#region src/native/service.ts
-function createNativeCapletsService(options = {}) {
-	const resolved = resolveNativeCapletsServiceOptions(options);
-	if (resolved.mode === "remote") {
-		const localOptions = {
-			...options,
-			mode: "local",
-			configLoader: createLocalOverlayConfigLoader(options)
-		};
-		const local = (options.localServiceFactory ?? createDefaultNativeCapletsService)(localOptions);
-		try {
-			return new CompositeNativeCapletsService(new RemoteNativeCapletsService({
-				client: (options.remoteClientFactory ?? createSdkRemoteCapletsClient)(resolved.remote),
-				clientFactory: () => (options.remoteClientFactory ?? createSdkRemoteCapletsClient)(resolved.remote),
-				pollIntervalMs: resolved.remote.pollIntervalMs,
-				...options.writeErr ? { writeErr: options.writeErr } : {}
-			}), local, options);
-		} catch (error) {
-			local.close().catch((closeError) => {
-				writeErr(options, `Could not close local overlay Caplets service: ${errorMessage$1(closeError)}\n`);
-			});
-			throw error;
-		}
-	}
-	return new DefaultNativeCapletsService(options);
-}
-var DefaultNativeCapletsService = class {
-	engine;
-	constructor(options) {
-		this.engine = new CapletsEngine({
-			...options,
-			writeErr: options.writeErr ?? (() => void 0)
-		});
-	}
-	listTools() {
-		return this.engine.enabledServers().map((caplet) => {
-			const toolName = nativeCapletToolName(caplet.server);
-			const inputSchema = generatedToolInputJsonSchemaForCaplet(caplet);
-			return {
-				caplet: caplet.server,
-				toolName,
-				title: caplet.name,
-				description: nativeCapletToolDescription(toolName, caplet),
-				promptGuidance: nativeCapletPromptGuidance(toolName, caplet),
-				inputSchema,
-				operationNames: [...inputSchema.properties.operation.enum]
-			};
-		});
-	}
-	async execute(capletId, request) {
-		return await this.engine.execute(capletId, request);
-	}
-	async reload() {
-		return await this.engine.reload();
-	}
-	onToolsChanged(listener) {
-		return this.engine.onReload(() => listener(this.listTools()));
-	}
-	async close() {
-		await this.engine.close();
-	}
-};
-function createDefaultNativeCapletsService(options) {
-	return new DefaultNativeCapletsService(options);
-}
-var CompositeNativeCapletsService = class {
-	remote;
-	local;
-	options;
-	listeners = /* @__PURE__ */ new Set();
-	unsubscribers;
-	tools = [];
-	closed = false;
-	batchingReload = false;
-	constructor(remote, local, options) {
-		this.remote = remote;
-		this.local = local;
-		this.options = options;
-		this.unsubscribers = [this.remote.onToolsChanged(() => this.updateMergedTools()), this.local.onToolsChanged(() => this.updateMergedTools())];
-		this.tools = this.mergeTools();
-	}
-	listTools() {
-		return [...this.tools];
-	}
-	async execute(capletId, request) {
-		if (this.local.listTools().some((tool) => tool.caplet === capletId)) return await this.local.execute(capletId, request);
-		return await this.remote.execute(capletId, request);
-	}
-	async reload() {
-		if (this.closed) return false;
-		this.batchingReload = true;
-		const remoteReloaded = await this.reloadChild(this.remote, "remote");
-		const localReloaded = await this.reloadChild(this.local, "local overlay");
-		this.batchingReload = false;
-		if (remoteReloaded === void 0 || localReloaded === void 0) return false;
-		this.updateMergedTools();
-		return remoteReloaded || localReloaded;
-	}
-	onToolsChanged(listener) {
-		this.listeners.add(listener);
-		return () => this.listeners.delete(listener);
-	}
-	async close() {
-		if (this.closed) return;
-		this.closed = true;
-		for (const unsubscribe of this.unsubscribers.splice(0)) unsubscribe();
-		this.listeners.clear();
-		await Promise.all([this.remote.close(), this.local.close()]);
-	}
-	updateMergedTools() {
-		if (this.closed || this.batchingReload) return;
-		const tools = this.mergeTools();
-		if (JSON.stringify(tools) === JSON.stringify(this.tools)) return;
-		this.tools = tools;
-		for (const listener of this.listeners) try {
-			listener(this.listTools());
-		} catch (error) {
-			writeErr(this.options, `Caplets tools-changed listener failed: ${errorMessage$1(error)}\n`);
-		}
-	}
-	mergeTools() {
-		const localTools = this.local.listTools();
-		const localIds = new Set(localTools.map((tool) => tool.caplet));
-		return [...this.remote.listTools().filter((tool) => !localIds.has(tool.caplet)), ...localTools];
-	}
-	async reloadChild(service, label) {
-		try {
-			return await service.reload();
-		} catch (error) {
-			writeErr(this.options, `Could not reload composite Caplets tools from ${label}: ${errorMessage$1(error)}\n`);
-			return;
-		}
-	}
-};
-function createLocalOverlayConfigLoader(options) {
-	let hasLoaded = false;
-	let previousWarnings = /* @__PURE__ */ new Set();
-	return (configPath, projectConfigPath) => {
-		let result;
-		try {
-			result = loadLocalOverlayConfigWithSources(configPath, projectConfigPath);
-		} catch (error) {
-			writeErr(options, `Caplets local overlay warning: Could not load local overlay config: ${errorMessage$1(error)}\n`);
-			if (hasLoaded) throw new CapletsError("CONFIG_INVALID", "Caplets local overlay reload failed; keeping last known-good config.", error);
-			hasLoaded = true;
-			return parseConfig({});
-		}
-		for (const warning of result.warnings) writeErr(options, `Caplets local overlay warning${typeof warning.path === "string" ? ` at ${warning.path}` : ""}: ${warning.message}\n`);
-		const warnings = new Set(result.warnings.map(warningKey));
-		if (hasLoaded && [...warnings].some((warning) => !previousWarnings.has(warning))) throw new CapletsError("CONFIG_INVALID", "Caplets local overlay reload produced new warnings; keeping last known-good config.");
-		previousWarnings = warnings;
-		hasLoaded = true;
-		return result.config;
-	};
-}
-function warningKey(warning) {
-	return `${warning.kind}\0${warning.path}\0${warning.message}`;
-}
-function writeErr(options, message) {
-	options.writeErr?.(message);
-}
-function errorMessage$1(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-//#endregion
+import { a as createSdkRemoteCapletsClient, c as nativeCapletToolName, i as RemoteNativeCapletsService, l as nativeCapletsSystemGuidance, o as nativeCapletPromptGuidance, r as resolveNativeCapletsServiceOptions, s as nativeCapletToolDescription, t as createNativeCapletsService } from "./service-BXcE4Rv8.js";
+import { generatedToolInputJsonSchema, generatedToolInputSchema } from "./generated-tool-input-schema.js";
 //#region src/native/process-cleanup.ts
 function registerNativeCapletsProcessCleanup(service, options = {}) {
 	let closed = false;

package/dist/project-binding/attach.d.ts

@@ -0,0 +1,46 @@
+import type { ResolvedCapletsRemote } from "../remote/options";
+import { type ProjectBindingSessionEvent } from "./session";
+import type { ProjectBindingWebSocketFactory } from "./transport";
+export type RawAttachOptions = {
+    remoteUrl?: string;
+    user?: string;
+    password?: string;
+    token?: string;
+    workspace?: string;
+    json?: boolean;
+    verbose?: boolean;
+    once?: boolean;
+    projectRoot?: string;
+    fetch?: typeof fetch;
+};
+export type ResolvedAttachOptions = {
+    projectRoot: string;
+    json: boolean;
+    verbose: boolean;
+    once: boolean;
+    remote: ResolvedCapletsRemote;
+    authMode: "self_hosted_remote" | "hosted_cloud";
+    selectedWorkspace?: string | undefined;
+};
+export declare function resolveAttachOptions(raw?: RawAttachOptions, env?: Record<string, string | undefined>): Promise<ResolvedAttachOptions>;
+export declare function resolveAttachOptionsForRun(raw?: RawAttachOptions, env?: Record<string, string | undefined>): Promise<ResolvedAttachOptions>;
+export declare function attachProjectOnce(raw?: RawAttachOptions, env?: Record<string, string | undefined>): Promise<{
+    ok: true;
+    projectRoot: string;
+    webSocketUrl: string;
+}>;
+export type AttachSessionEvent = ProjectBindingSessionEvent;
+export declare function attachProjectSession(raw?: RawAttachOptions, env?: Record<string, string | undefined>, options?: {
+    heartbeatIntervalMs?: number | undefined;
+    signal?: AbortSignal | undefined;
+    webSocketFactory?: ProjectBindingWebSocketFactory | undefined;
+    onEvent?: (event: AttachSessionEvent) => void;
+}): Promise<{
+    ok: true;
+    bindingId: string;
+    sessionId: string;
+    projectRoot: string;
+    projectFingerprint: string;
+    webSocketUrl: string;
+    ended: true;
+}>;

package/dist/project-binding/errors.d.ts

@@ -0,0 +1,17 @@
+import { CapletsError } from "../errors";
+export declare const PROJECT_BINDING_ERROR_CODES: readonly ["cloud_auth_required", "cloud_auth_expired", "cloud_auth_revoked", "workspace_selection_required", "workspace_switch_required", "workspace_forbidden", "project_binding_forbidden", "endpoint_unavailable", "websocket_upgrade_required", "sync_required", "sync_failed", "sync_size_limit_exceeded", "lease_conflict", "lease_expired", "policy_denied", "usage_limit_reached", "billing_required", "subscription_past_due", "email_verification_required", "remote_credentials_required", "remote_auth_failed"];
+export type ProjectBindingErrorCode = (typeof PROJECT_BINDING_ERROR_CODES)[number];
+export type ProjectBindingRecovery = {
+    code: ProjectBindingErrorCode;
+    message: string;
+    recoveryCommand?: string | undefined;
+    requestId?: string | undefined;
+};
+export declare class ProjectBindingError extends CapletsError {
+    readonly projectBindingCode: ProjectBindingErrorCode;
+    readonly recoveryCommand?: string | undefined;
+    readonly requestId?: string | undefined;
+    constructor(input: ProjectBindingRecovery);
+}
+export declare function projectBindingRecovery(code: ProjectBindingErrorCode, message?: string): ProjectBindingRecovery;
+export declare function projectBindingError(code: ProjectBindingErrorCode, message?: string): ProjectBindingError;

package/dist/project-binding/gitignore.d.ts

@@ -0,0 +1,5 @@
+export type ProjectBindingGitignoreBootstrap = {
+    path: string;
+    changed: boolean;
+};
+export declare function bootstrapProjectBindingGitignore(projectRoot: string): ProjectBindingGitignoreBootstrap;

package/dist/project-binding/mutagen.d.ts

@@ -0,0 +1,65 @@
+export type ManagedSyncState = "idle" | "starting" | "syncing" | "ready" | "blocked" | "stopped";
+export type ManagedSyncDiagnosticCode = "project_sync_binary_missing" | "project_sync_auth_failed" | "project_sync_conflict" | "project_sync_process_exit" | "project_sync_status_unavailable";
+export type MutagenCommandPlan = {
+    command: string;
+    args: string[];
+};
+export type MutagenProcessResult = {
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+};
+export type MutagenProcessRunner = (command: string, args: string[]) => Promise<MutagenProcessResult>;
+export type MutagenLastCommandStatus = MutagenCommandPlan & {
+    stdout: string;
+    stderr: string;
+    exitCode?: number;
+};
+export type ManagedSyncStateSnapshot = {
+    state: ManagedSyncState;
+    publicMessage: string;
+    bindingId?: string;
+    diagnosticCode?: ManagedSyncDiagnosticCode;
+    mutagenBinary?: string;
+    mutagenVersion?: string;
+    lastCommand?: MutagenLastCommandStatus;
+};
+export type MutagenProjectSyncDoctorData = {
+    state: ManagedSyncState;
+    diagnosticCode?: ManagedSyncDiagnosticCode;
+    mutagenBinary?: string;
+    mutagenVersion?: string;
+    lastCommand?: MutagenLastCommandStatus;
+};
+export type StartMutagenProjectSyncInput = {
+    bindingId: string;
+    localProjectRoot: string;
+    serverProjectRoot: string;
+};
+export type MutagenProjectSyncBindingInput = {
+    bindingId: string;
+};
+export type ManagedMutagenProjectSyncOptions = {
+    mutagenBinary?: string;
+    runner?: MutagenProcessRunner;
+};
+type MutagenVersionInfo = {
+    version: string;
+};
+export declare function planMutagenVersionCommand(mutagenBinary?: string): MutagenCommandPlan;
+export declare function planMutagenSyncCreateCommand(input: StartMutagenProjectSyncInput, mutagenBinary?: string): MutagenCommandPlan;
+export declare function planMutagenSyncListCommand(mutagenBinary?: string): MutagenCommandPlan;
+export declare function planMutagenSyncTerminateCommand(bindingId: string, mutagenBinary?: string): MutagenCommandPlan;
+export declare function mutagenSyncName(bindingId: string): string;
+export declare class ManagedMutagenProjectSync {
+    #private;
+    readonly mutagenBinary: string;
+    constructor(options?: ManagedMutagenProjectSyncOptions);
+    start(input: StartMutagenProjectSyncInput): Promise<ManagedSyncStateSnapshot>;
+    refresh(input: MutagenProjectSyncBindingInput): Promise<ManagedSyncStateSnapshot>;
+    stop(input: MutagenProjectSyncBindingInput): Promise<ManagedSyncStateSnapshot>;
+    snapshot(): ManagedSyncStateSnapshot;
+}
+export declare function mutagenProjectSyncDoctorData(snapshot: ManagedSyncStateSnapshot): MutagenProjectSyncDoctorData;
+export declare function parseMutagenVersionOutput(output: string): MutagenVersionInfo;
+export {};

package/dist/project-binding/routes.d.ts

@@ -0,0 +1,9 @@
+import { PROJECT_BINDING_STATES, type ProjectBindingState } from "./types";
+export { PROJECT_BINDING_STATES };
+export type { ProjectBindingState };
+export declare const PROJECT_BINDINGS_CONTROL_PATH = "/control/project-bindings";
+export declare const PROJECT_BINDING_CONNECT_PATH = "/control/project-bindings/connect";
+export declare function projectBindingConnectPath(): string;
+export declare function projectBindingStatusPath(bindingId: string): string;
+export declare function projectBindingConnectUrl(baseUrl: string | URL): string;
+export declare function projectBindingStatusUrl(baseUrl: string | URL, bindingId: string): string;