@caplets/core 0.24.1 → 0.25.0

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-DjwB8aiW.js";
 import { generatedToolInputJsonSchema, generatedToolInputSchema } from "./generated-tool-input-schema.js";
 //#region src/native/process-cleanup.ts
 function registerNativeCapletsProcessCleanup(service, options = {}) {

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/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;