@caplets/core 0.24.1 → 0.25.1

package/dist/native/options.d.ts

@@ -1,7 +1,10 @@
-import { type CapletsRemoteEnv, type CapletsRemoteInput } from "../remote/options";
+import { type CapletsRemoteEnv } from "../remote/options";
 type CapletsMode = "auto" | "local" | "remote" | "cloud";
 export type NativeCapletsMode = CapletsMode;
-export type NativeRemoteCapletsOptions = CapletsRemoteInput & {
+export type NativeRemoteCapletsOptions = {
+    url?: string;
+    workspace?: string;
+    fetch?: typeof fetch;
     pollIntervalMs?: number;
     cloud?: NativeCloudPresenceInput;
 };

package/dist/native/remote.d.ts

@@ -23,6 +23,11 @@ export type RemoteCapletsClient = {
 export type RemoteCapletsClientOptions = ResolvedNativeCapletsServiceOptions & {
     mode: "remote" | "cloud";
 };
+export type SdkRemoteCapletsClientOptions = RemoteCapletsClientOptions["remote"] & {
+    resolveRuntimeOptions?: () => Promise<RemoteCapletsClientOptions["remote"]>;
+    authKind?: "self_hosted_remote" | "hosted_cloud";
+    writeErr?: (value: string) => void;
+};
 export type RemoteNativeCapletsServiceOptions = {
     client: RemoteCapletsClient;
     clientFactory?: () => RemoteCapletsClient;
@@ -30,7 +35,7 @@ export type RemoteNativeCapletsServiceOptions = {
     authKind?: "self_hosted_remote" | "hosted_cloud";
     writeErr?: (value: string) => void;
 };
-export declare function createSdkRemoteCapletsClient(options: RemoteCapletsClientOptions["remote"]): RemoteCapletsClient;
+export declare function createSdkRemoteCapletsClient(options: SdkRemoteCapletsClientOptions): RemoteCapletsClient;
 export declare class RemoteNativeCapletsService implements NativeCapletsService {
     private readonly options;
     private tools;

package/dist/native.js

@@ -1,4 +1,4 @@
-import { C as nativeCapletToolDescription, D as nativeCodeModeToolName, E as nativeCodeModeToolId, S as nativeCapletPromptGuidance, T as nativeCapletsSystemGuidance, f as RemoteNativeCapletsService, h as resolveNativeCapletsServiceOptions, p as createSdkRemoteCapletsClient, t as createNativeCapletsService, w as nativeCapletToolName } from "./service-Cvnuu9wr.js";
+import { A as nativeCapletToolDescription, M as nativeCapletsSystemGuidance, N as nativeCodeModeToolId, P as nativeCodeModeToolName, _ as resolveNativeCapletsServiceOptions, h as createSdkRemoteCapletsClient, j as nativeCapletToolName, k as nativeCapletPromptGuidance, m as RemoteNativeCapletsService, t as createNativeCapletsService } from "./service-Ut6dN9M8.js";
 import { generatedToolInputJsonSchema, generatedToolInputSchema } from "./generated-tool-input-schema.js";
 //#region src/native/process-cleanup.ts
 function registerNativeCapletsProcessCleanup(service, options = {}) {

package/dist/observed-output-shapes/pure.js

@@ -24,7 +24,7 @@ function mergeJsonShapes(left, right) {
 }
 function mergeObjects(left, right) {
 	const fields = {};
-	const keys = [...new Set([...Object.keys(left.fields), ...Object.keys(right.fields)])].sort();
+	const keys = [.../* @__PURE__ */ new Set([...Object.keys(left.fields), ...Object.keys(right.fields)])].sort();
 	let truncated = left.truncated === true || right.truncated === true;
 	const selected = keys.slice(0, OBSERVED_OUTPUT_SHAPE_LIMITS.maxObjectFields);
 	truncated = truncated || keys.length > selected.length;

package/dist/{observed-output-shapes-D2k2-q8K.js → observed-output-shapes-DuP7mJQf.js}

@@ -277,7 +277,7 @@ function mergeJsonShapes(left, right) {
 }
 function mergeObjects(left, right) {
 	const fields = {};
-	const keys = [...new Set([...Object.keys(left.fields), ...Object.keys(right.fields)])].sort();
+	const keys = [.../* @__PURE__ */ new Set([...Object.keys(left.fields), ...Object.keys(right.fields)])].sort();
 	let truncated = left.truncated === true || right.truncated === true;
 	const selected = keys.slice(0, OBSERVED_OUTPUT_SHAPE_LIMITS.maxObjectFields);
 	truncated = truncated || keys.length > selected.length;

package/dist/observed-output-shapes.js

@@ -1,2 +1,2 @@
-import { _ as OBSERVED_OUTPUT_SHAPE_LIMITS, a as parseShapeableJsonText, c as shapeType, d as backendFingerprint, f as observedOutputShapeKey, i as observeOutputShape, l as mergeJsonShapes, m as stableHash, n as extractJsonShape, o as hasTruncatedShape, p as observedOutputShapeStorageKey, r as normalizedObservableValue, s as shapeToTypeScript, t as usefulOutputSchema, u as FileObservedOutputShapeStore, v as OBSERVED_OUTPUT_SHAPE_VERSION } from "./observed-output-shapes-D2k2-q8K.js";
+import { _ as OBSERVED_OUTPUT_SHAPE_LIMITS, a as parseShapeableJsonText, c as shapeType, d as backendFingerprint, f as observedOutputShapeKey, i as observeOutputShape, l as mergeJsonShapes, m as stableHash, n as extractJsonShape, o as hasTruncatedShape, p as observedOutputShapeStorageKey, r as normalizedObservableValue, s as shapeToTypeScript, t as usefulOutputSchema, u as FileObservedOutputShapeStore, v as OBSERVED_OUTPUT_SHAPE_VERSION } from "./observed-output-shapes-DuP7mJQf.js";
 export { FileObservedOutputShapeStore, OBSERVED_OUTPUT_SHAPE_LIMITS, OBSERVED_OUTPUT_SHAPE_VERSION, backendFingerprint, extractJsonShape, hasTruncatedShape, mergeJsonShapes, normalizedObservableValue, observeOutputShape, observedOutputShapeKey, observedOutputShapeStorageKey, parseShapeableJsonText, shapeToTypeScript, shapeType, stableHash, usefulOutputSchema };

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

@@ -3,15 +3,13 @@ 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;
+    authDir?: string;
 };
 export type ResolvedAttachOptions = {
     projectRoot: string;

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

@@ -65,6 +65,7 @@ export type ProjectBindingSocketClientMessage = {
 export type RunProjectBindingSessionInput = {
     projectRoot: string;
     remote: ResolvedCapletsRemote;
+    remoteResolver?: (() => Promise<ResolvedCapletsRemote>) | undefined;
     fetch?: typeof fetch | undefined;
     webSocketFactory?: ProjectBindingWebSocketFactory | undefined;
     signal?: AbortSignal | undefined;

package/dist/remote/credential-store.d.ts

@@ -0,0 +1,12 @@
+import type { RemoteProfileCredential } from "./profiles";
+export type RemoteCredentialStoreOptions = {
+    root?: string | undefined;
+};
+export declare class FileRemoteCredentialStore {
+    readonly root: string;
+    constructor(options?: RemoteCredentialStoreOptions);
+    pathForKey(key: string): string;
+    load(key: string): Promise<RemoteProfileCredential | undefined>;
+    save(key: string, credential: RemoteProfileCredential): Promise<void>;
+    delete(key: string): Promise<boolean>;
+}

package/dist/remote/options.d.ts

@@ -1,4 +1,4 @@
-export type CapletsRemoteEnv = Partial<Record<"CAPLETS_MODE" | "CAPLETS_REMOTE_URL" | "CAPLETS_REMOTE_USER" | "CAPLETS_REMOTE_PASSWORD" | "CAPLETS_REMOTE_TOKEN" | "CAPLETS_REMOTE_WORKSPACE", string>>;
+export type CapletsRemoteEnv = Partial<Record<"CAPLETS_MODE" | "CAPLETS_REMOTE_URL" | "CAPLETS_REMOTE_WORKSPACE", string>>;
 export type CapletsRemoteModeInput = {
     mode?: string;
     remoteUrl?: string;
@@ -6,8 +6,6 @@ export type CapletsRemoteModeInput = {
 export type CapletsRemoteMode = "local" | "remote" | "cloud";
 export type CapletsRemoteInput = {
     url?: string;
-    user?: string;
-    password?: string;
     token?: string;
     workspace?: string;
     fetch?: typeof fetch;
@@ -15,10 +13,6 @@ export type CapletsRemoteInput = {
 export type CapletsRemoteAuth = {
     type: "none";
     user: string;
-} | {
-    type: "basic";
-    user: string;
-    password: string;
 } | {
     type: "bearer";
     token: string;
@@ -41,5 +35,6 @@ export declare function resolveRemoteMode(input?: CapletsRemoteModeInput, env?:
 export declare function resolveCapletsRemote(input?: CapletsRemoteInput, env?: CapletsRemoteEnv): ResolvedCapletsRemote;
 export declare function resolveHostedCloudRemote(input?: CapletsRemoteInput, env?: CapletsRemoteEnv): ResolvedCapletsRemote;
 export declare function hostedCloudWorkspaceFromRemoteUrl(value: string): string | undefined;
+export declare function normalizeRemoteProfileHostUrl(value: string): string;
 export declare function projectBindingWebSocketUrlForBase(baseUrl: URL): URL;
 export declare function isCapletsCloudUrl(value: string): boolean;

package/dist/remote/pairing.d.ts

@@ -0,0 +1,13 @@
+export type ParsedPairingCode = {
+    codeId: string;
+    secret: string;
+};
+export declare function createPairingCode(): {
+    codeId: string;
+    code: string;
+    secret: string;
+};
+export declare function createPairingCodeVerifier(codeId: string, secret: string): string;
+export declare function parsePairingCode(value: string): ParsedPairingCode | undefined;
+export declare function isPairingCodeFormat(value: string): boolean;
+export declare function randomToken(bytes?: number): string;

package/dist/remote/profile-store.d.ts

@@ -0,0 +1,94 @@
+import { CloudAuthStore } from "../cloud-auth/store";
+import type { CloudAuthCredentials } from "../cloud-auth/store";
+import { FileRemoteCredentialStore } from "./credential-store";
+import { type RemoteProfileCredential, type RemoteProfileStatus } from "./profiles";
+export type SaveCloudProfileInput = {
+    hostUrl: string;
+    workspaceId: string;
+    workspaceSlug?: string | undefined;
+    clientLabel?: string | undefined;
+    credentials: RemoteProfileCredential;
+    now?: Date | undefined;
+};
+export type CloudProfileLookup = {
+    hostUrl: string;
+    workspace?: string | undefined;
+};
+export type SaveSelfHostedProfileInput = {
+    hostUrl: string;
+    clientId: string;
+    clientLabel?: string | undefined;
+    credentials: RemoteProfileCredential;
+    now?: Date | undefined;
+};
+export type SelfHostedProfileLookup = {
+    hostUrl: string;
+};
+export type RefreshSelfHostedProfileInput = SelfHostedProfileLookup & {
+    needsRefresh: (credential: RemoteProfileCredential) => boolean;
+    refresh: (status: RemoteProfileStatus, credential: RemoteProfileCredential) => Promise<SaveSelfHostedProfileInput>;
+};
+export type RefreshCloudProfileInput = CloudProfileLookup & {
+    needsRefresh: (credential: RemoteProfileCredential) => boolean;
+    refresh: (status: RemoteProfileStatus, credential: RemoteProfileCredential) => Promise<SaveCloudProfileInput>;
+};
+export type RemoteProfileStoreOptions = {
+    root?: string | undefined;
+    credentials?: FileRemoteCredentialStore | undefined;
+    legacyCloudAuthStore?: CloudAuthStore | undefined;
+};
+export type CreateRemoteProfileStoreOptions = {
+    authDir?: string | undefined;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined> | undefined;
+    legacyCloudAuthStore?: CloudAuthStore | undefined;
+};
+export declare function createRemoteProfileStore(options?: CreateRemoteProfileStoreOptions): FileRemoteProfileStore;
+export declare function cloudCredentialsFromRemoteProfile(status: RemoteProfileStatus, credential: RemoteProfileCredential): CloudAuthCredentials;
+export declare class FileRemoteProfileStore {
+    readonly root: string;
+    readonly credentials: FileRemoteCredentialStore;
+    readonly legacyCloudAuthStore?: CloudAuthStore | undefined;
+    constructor(options?: RemoteProfileStoreOptions);
+    saveSelfHostedProfile(input: SaveSelfHostedProfileInput): Promise<RemoteProfileStatus>;
+    getSelfHostedProfileStatus(input: SelfHostedProfileLookup): Promise<RemoteProfileStatus | undefined>;
+    logoutSelfHostedProfile(input: SelfHostedProfileLookup): Promise<boolean>;
+    refreshSelfHostedProfileIfNeeded(input: RefreshSelfHostedProfileInput): Promise<{
+        status: RemoteProfileStatus;
+        credential: RemoteProfileCredential;
+    } | undefined>;
+    refreshCloudProfileIfNeeded(input: RefreshCloudProfileInput): Promise<{
+        status: RemoteProfileStatus;
+        credential: RemoteProfileCredential;
+    } | undefined>;
+    saveCloudProfile(input: SaveCloudProfileInput): Promise<RemoteProfileStatus>;
+    getCloudProfileStatus(input: CloudProfileLookup): Promise<RemoteProfileStatus | undefined>;
+    listCloudProfileStatuses(hostUrlInput: string): Promise<RemoteProfileStatus[]>;
+    listProfileStatuses(): Promise<RemoteProfileStatus[]>;
+    logoutCloudProfile(input: CloudProfileLookup): Promise<boolean>;
+    clearSelectedCloudWorkspace(hostUrlInput: string): Promise<boolean>;
+    private selfHostedRefreshSnapshot;
+    private cloudRefreshSnapshot;
+    private findCloudStatus;
+    private migrateLegacyCloudProfile;
+    private clearMatchingLegacyCloudAuth;
+    private statusByKey;
+    private statusFor;
+    private writeSelfHostedProfile;
+    private writeCloudProfile;
+    private listProfilesForHost;
+    private readProfile;
+    private readProfileFile;
+    private readSelectedWorkspace;
+    private profilePath;
+    private selectedWorkspacePath;
+    private profilesDir;
+    private selectionsDir;
+    private writeJson;
+    private withMutationLock;
+    private withRefreshLock;
+    private acquireLock;
+    private releaseLock;
+    private clearStaleLock;
+    private lockPath;
+    private refreshLockPath;
+}

package/dist/remote/profiles.d.ts

@@ -0,0 +1,47 @@
+export type RemoteProfileKind = "cloud" | "self-hosted";
+export type RemoteProfileKeyInput = {
+    kind: RemoteProfileKind;
+    hostUrl: string;
+    workspace?: string | undefined;
+};
+export type RemoteProfileCredential = {
+    accessToken?: string | undefined;
+    refreshToken?: string | undefined;
+    tokenType?: string | undefined;
+    expiresAt?: string | undefined;
+    scope?: string[] | undefined;
+    clientSecret?: string | undefined;
+    pairingCode?: string | undefined;
+};
+export type RemoteProfileStatusInput = {
+    kind: RemoteProfileKind;
+    hostUrl: string;
+    key?: string | undefined;
+    workspaceId?: string | undefined;
+    workspaceSlug?: string | undefined;
+    clientId?: string | undefined;
+    selected?: boolean | undefined;
+    clientLabel?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    credential?: RemoteProfileCredential | undefined;
+};
+export type RemoteProfileStatus = {
+    authenticated: boolean;
+    kind: RemoteProfileKind;
+    key: string;
+    hostUrl: string;
+    workspaceId?: string | undefined;
+    workspaceSlug?: string | undefined;
+    clientId?: string | undefined;
+    selected: boolean;
+    clientLabel?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    expiresAt?: string | undefined;
+    scope?: string[] | undefined;
+    tokenType?: string | undefined;
+};
+export declare function remoteProfileKey(input: RemoteProfileKeyInput): string;
+export declare function selectedWorkspaceKey(hostUrl: string): string;
+export declare function remoteProfileStatus(input: RemoteProfileStatusInput): RemoteProfileStatus;

package/dist/remote/selection.d.ts

@@ -1,22 +1,22 @@
-import { type CloudAuthCredentials } from "../cloud-auth/store";
+import type { CloudAuthCredentials } from "../cloud-auth/store";
 import { type ResolvedCapletsRemote } from "./options";
 export type RemoteSelectionInput = {
     mode?: string;
     remoteUrl?: string;
-    user?: string;
-    password?: string;
-    token?: string;
     workspace?: string;
     fetch?: typeof fetch;
+    authDir?: string;
 };
 export type ResolvedRemoteSelection = {
     kind: "self_hosted_remote";
     remote: ResolvedCapletsRemote;
+    credentialExpiresAt?: string | undefined;
 } | {
     kind: "hosted_cloud";
     remote: ResolvedCapletsRemote;
     selectedWorkspace: string;
     credentials: CloudAuthCredentials;
+    credentialExpiresAt?: string | undefined;
     cloudPresence: {
         url: URL;
         accessToken: string;

package/dist/remote/server-credential-store.d.ts

@@ -0,0 +1,84 @@
+import type { IssuedRemoteClientCredentials, RemoteClientStatus, ValidatedRemoteClient } from "./server-credentials";
+export type RemoteServerCredentialStoreOptions = {
+    dir: string;
+};
+export type CreatePairingCodeInput = {
+    hostUrl: string;
+    clientLabel?: string | undefined;
+    ttlMs?: number | undefined;
+    maxAttempts?: number | undefined;
+    now?: Date | undefined;
+};
+export type ExchangePairingCodeInput = {
+    hostUrl: string;
+    code: string;
+    clientLabel?: string | undefined;
+    now?: Date | undefined;
+};
+export type ValidateAccessTokenInput = {
+    hostUrl: string;
+    accessToken: string;
+    now?: Date | undefined;
+};
+export type RefreshClientCredentialsInput = {
+    hostUrl: string;
+    refreshToken: string;
+    now?: Date | undefined;
+};
+type StoredPairingCode = {
+    codeId: string;
+    hostUrl: string;
+    secretHash: string;
+    clientLabel?: string | undefined;
+    createdAt: string;
+    expiresAt: string;
+    attempts: number;
+    maxAttempts: number;
+    usedAt?: string | undefined;
+};
+type StoredRemoteClient = {
+    clientId: string;
+    clientLabel: string;
+    hostUrl: string;
+    accessTokenHash: string;
+    accessExpiresAt: string;
+    refreshTokenHash: string;
+    supersededRefreshTokenHashes: SupersededRefreshToken[];
+    refreshFamilyId: string;
+    createdAt: string;
+    lastUsedAt?: string | undefined;
+    revokedAt?: string | undefined;
+};
+type SupersededRefreshToken = {
+    hash: string;
+    supersededAt: string;
+};
+type RemoteServerCredentialState = {
+    version: 1;
+    pairingCodes: StoredPairingCode[];
+    clients: StoredRemoteClient[];
+};
+export declare class RemoteServerCredentialStore {
+    readonly dir: string;
+    constructor(options: RemoteServerCredentialStoreOptions);
+    createPairingCode(input: CreatePairingCodeInput): {
+        codeId: string;
+        code: string;
+        expiresAt: string;
+    };
+    exchangePairingCode(input: ExchangePairingCodeInput): IssuedRemoteClientCredentials;
+    listClients(): RemoteClientStatus[];
+    revokeClient(clientId: string, now?: Date): boolean;
+    validateAccessToken(input: ValidateAccessTokenInput): ValidatedRemoteClient;
+    refreshClientCredentials(input: RefreshClientCredentialsInput): IssuedRemoteClientCredentials;
+    dumpForTest(): RemoteServerCredentialState;
+    private loadState;
+    private saveState;
+    private statePath;
+    private lockPath;
+    private withStateLock;
+    private acquireLock;
+    private releaseLock;
+    private clearStaleLock;
+}
+export {};

package/dist/remote/server-credentials.d.ts

@@ -0,0 +1,21 @@
+export type IssuedRemoteClientCredentials = {
+    hostUrl: string;
+    clientId: string;
+    clientLabel: string;
+    accessToken: string;
+    refreshToken: string;
+    tokenType: "Bearer";
+    expiresAt: string;
+    createdAt: string;
+};
+export type RemoteClientStatus = {
+    clientId: string;
+    clientLabel: string;
+    hostUrl: string;
+    createdAt: string;
+    lastUsedAt?: string | undefined;
+    revokedAt?: string | undefined;
+};
+export type ValidatedRemoteClient = RemoteClientStatus & {
+    tokenType: "Bearer";
+};

package/dist/remote-control/client.d.ts

@@ -4,8 +4,11 @@ export type RemoteControlClientOptions = {
     requestInit: RequestInit;
     fetch?: typeof fetch;
 };
+export type ResolvedRemoteControlClientOptions = RemoteControlClientOptions;
 export declare class RemoteControlClient {
     #private;
-    constructor(options: RemoteControlClientOptions);
+    constructor(options: RemoteControlClientOptions | {
+        resolve: () => Promise<ResolvedRemoteControlClientOptions>;
+    });
     request(command: RemoteCliCommand, args: RemoteCliRequest["arguments"]): Promise<unknown>;
 }

package/dist/{schemas-C0PNPwjS.js → schemas-BoqMu4MG.js}

@@ -121,7 +121,10 @@ function assignProp(target, prop, value) {
 }
 function mergeDefs(...defs) {
 	const mergedDescriptors = {};
-	for (const def of defs) Object.assign(mergedDescriptors, Object.getOwnPropertyDescriptors(def));
+	for (const def of defs) {
+		const descriptors = Object.getOwnPropertyDescriptors(def);
+		Object.assign(mergedDescriptors, descriptors);
+	}
 	return Object.defineProperties({}, mergedDescriptors);
 }
 function esc(str) {
@@ -1424,7 +1427,7 @@ const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
 const $ZodNull = /*@__PURE__*/ $constructor("$ZodNull", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.pattern = _null$2;
-	inst._zod.values = new Set([null]);
+	inst._zod.values = /* @__PURE__ */ new Set([null]);
 	inst._zod.parse = (payload, _ctx) => {
 		const input = payload.value;
 		if (input === null) return payload;
@@ -1575,13 +1578,13 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
 		}
 		return propValues;
 	});
-	const isObject$1 = isObject;
+	const isObject$2 = isObject;
 	const catchall = def.catchall;
 	let value;
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$1(input)) {
+		if (!isObject$2(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -1704,7 +1707,7 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) =>
 		return (payload, ctx) => fn(shape, payload, ctx);
 	};
 	let fastpass;
-	const isObject$2 = isObject;
+	const isObject$1 = isObject;
 	const jit = !globalConfig.jitless;
 	const fastEnabled = jit && allowsEval.value;
 	const catchall = def.catchall;
@@ -1712,7 +1715,7 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) =>
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$2(input)) {
+		if (!isObject$1(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -2114,7 +2117,7 @@ const $ZodOptional = /*@__PURE__*/ $constructor("$ZodOptional", (inst, def) => {
 	inst._zod.optin = "optional";
 	inst._zod.optout = "optional";
 	defineLazy(inst._zod, "values", () => {
-		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, void 0]) : void 0;
+		return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
 	});
 	defineLazy(inst._zod, "pattern", () => {
 		const pattern = def.innerType._zod.pattern;
@@ -2148,7 +2151,7 @@ const $ZodNullable = /*@__PURE__*/ $constructor("$ZodNullable", (inst, def) => {
 		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
 	});
 	defineLazy(inst._zod, "values", () => {
-		return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : void 0;
+		return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
 	});
 	inst._zod.parse = (payload, ctx) => {
 		if (payload.value === null) return payload;

package/dist/serve/http.d.ts

@@ -3,6 +3,7 @@ import { Hono } from "hono";
 import { CapletsEngine, type CapletsEngineOptions } from "../engine";
 import { type RemoteControlDispatchContext } from "../remote-control/dispatch";
 import { RemoteAuthFlowStore } from "../remote-control/auth-flow";
+import { RemoteServerCredentialStore } from "../remote/server-credential-store";
 import type { HttpServeOptions } from "./options";
 type HttpServeIo = {
     writeErr?: (value: string) => void;
@@ -10,6 +11,7 @@ type HttpServeIo = {
     authFlowStore?: RemoteAuthFlowStore;
     sessionFactory?: HttpMcpSessionFactory;
     exposeAttach?: boolean;
+    remoteCredentialStore?: RemoteServerCredentialStore;
 };
 type HttpMcpSession = {
     connect(transport: StreamableHTTPTransport): Promise<void>;
@@ -32,6 +34,9 @@ export declare function servicePaths(base: string): {
     attachEvents: string;
     attachInvoke: string;
     projectBindings: string;
+    pairingExchange: string;
+    remoteRefresh: string;
+    remoteClient: string;
     health: string;
 };
 export {};

package/dist/serve/index.d.ts

@@ -1,13 +1,11 @@
 import type { CapletsEngineOptions } from "../engine";
 import { type RawServeOptions, type ServeOptions } from "./options";
 export { serveHttp } from "./http";
-export { resolveDaemonServeOptions, resolveServeOptions } from "./options";
+export { resolveServeOptions } from "./options";
 export type { HttpServeOptions, RawServeOptions, ServeOptions, StdioServeOptions } from "./options";
 export { NativeCapletsMcpSession } from "./native-session";
 export type { NativeCapletsMcpSessionOptions, NativeToolServer } from "./native-session";
 export { serveStdio } from "./stdio";
-export { buildDaemonPlatformDescriptor, daemonStatus, disableDaemon, enableDaemon, resolveServeDaemonPaths, restartDaemon, startDaemon, stopDaemon, } from "./daemon";
-export type { DaemonPlatformDescriptor, DaemonProcessRunner, ServeDaemonConfig, ServeDaemonOperationOptions, ServeDaemonPaths, ServeDaemonState, ServeDaemonStatus, } from "./daemon";
 export type ServeCapletsOptions = {
     raw: RawServeOptions;
     engine?: CapletsEngineOptions;

package/dist/serve/options.d.ts

@@ -4,8 +4,7 @@ export type RawServeOptions = {
     host?: string;
     port?: string | number;
     path?: string;
-    user?: string;
-    password?: string;
+    remoteStatePath?: string;
     allowUnauthenticatedHttp?: boolean;
     trustProxy?: boolean;
 };
@@ -18,22 +17,18 @@ export type HttpServeOptions = {
     port: number;
     path: string;
     publicOrigin?: string | undefined;
-    auth: HttpBasicAuthOptions;
+    auth: HttpServeAuthOptions;
+    remoteCredentialStateDir?: string | undefined;
     allowUnauthenticatedHttp: boolean;
     warnUnauthenticatedNetwork: boolean;
     loopback: boolean;
     trustProxy: boolean;
 };
-export type HttpBasicAuthOptions = {
-    enabled: false;
-    user: string;
+export type HttpServeAuthOptions = {
+    type: "remote_credentials";
 } | {
-    enabled: true;
-    user: string;
-    password: string;
+    type: "development_unauthenticated";
 };
 export type ServeOptions = StdioServeOptions | HttpServeOptions;
-export type ServeEnv = Partial<Record<"CAPLETS_SERVER_URL" | "CAPLETS_SERVER_USER" | "CAPLETS_SERVER_PASSWORD", string>>;
+export type ServeEnv = Partial<Record<"CAPLETS_SERVER_URL" | "CAPLETS_REMOTE_SERVER_STATE_DIR", string>>;
 export declare function resolveServeOptions(raw: RawServeOptions, env?: ServeEnv): ServeOptions;
-export declare function resolveDaemonServeOptions(raw: RawServeOptions, env?: ServeEnv): HttpServeOptions;
-export declare function isLoopbackHost(host: string): boolean;

package/dist/server/options.d.ts

@@ -1,22 +1,15 @@
 export type CapletsMode = "auto" | "local" | "remote";
-export type CapletsServerEnv = Partial<Record<"CAPLETS_MODE" | "CAPLETS_SERVER_URL" | "CAPLETS_SERVER_USER" | "CAPLETS_SERVER_PASSWORD" | "CAPLETS_CLOUD_URL" | "CAPLETS_CLOUD_TOKEN" | "CAPLETS_CLOUD_WORKSPACE_ID" | "CAPLETS_PROJECT_ROOT", string>>;
+export type CapletsServerEnv = Partial<Record<"CAPLETS_MODE" | "CAPLETS_SERVER_URL" | "CAPLETS_CLOUD_URL" | "CAPLETS_CLOUD_TOKEN" | "CAPLETS_CLOUD_WORKSPACE_ID" | "CAPLETS_PROJECT_ROOT", string>>;
 export type CapletsModeInput = {
     mode?: string;
     serverUrl?: string;
 };
 export type CapletsServerInput = {
     url?: string;
-    user?: string;
-    password?: string;
     fetch?: typeof fetch;
 };
 export type CapletsServerAuth = {
-    enabled: false;
-    user: string;
-} | {
-    enabled: true;
-    user: string;
-    password: string;
+    type: "none";
 };
 export type ResolvedCapletsServer = {
     baseUrl: URL;