@caplets/core 0.18.9 → 0.20.0

package/dist/cli/auth.d.ts

@@ -1,5 +1,5 @@
 import { type GenericAuthTarget } from "../auth";
-import { loadConfig, type CapletsConfig, type GraphQlEndpointConfig, type HttpApiConfig } from "../config";
+import { loadConfig, type CapletsConfig } from "../config";
 type AuthTarget = ReturnType<typeof authTargets>[number];
 type AuthListFormat = "plain" | "markdown" | "json";
 export type AuthSource = "project" | "global" | "remote";
@@ -63,6 +63,44 @@ export declare function localAuthConfigForTarget(options: {
 }): CapletsConfig;
 export declare function formatAuthRows(rows: AuthStatusRow[], format: Exclude<AuthListFormat, "json">): string;
 export declare function findAuthTarget(serverId: string, config?: CapletsConfig): AuthTarget | undefined;
-declare function authTargets(config: ReturnType<typeof loadConfig>): (import("../config").CapletServerConfig | import("../config").OpenApiEndpointConfig | (GraphQlEndpointConfig & GenericAuthTarget) | (HttpApiConfig & GenericAuthTarget))[];
+declare function authTargets(config: ReturnType<typeof loadConfig>): (import("../config").CapletServerConfig | import("../config").OpenApiEndpointConfig | (import("../config").AgentSelectionHintsConfig & {
+    server: string;
+    backend: "graphql";
+    name: string;
+    description: string;
+    exposure?: import("../config").CapletExposure | undefined;
+    tags?: string[] | undefined;
+    body?: string | undefined;
+    endpointUrl: string;
+    schemaPath?: string | undefined;
+    schemaUrl?: string | undefined;
+    introspection?: true | undefined;
+    operations?: Record<string, import("../config").GraphQlOperationConfig> | undefined;
+    auth: import("../config").OpenApiAuthConfig;
+    requestTimeoutMs: number;
+    operationCacheTtlMs: number;
+    selectionDepth: number;
+    disabled: boolean;
+    setup?: import("..").CapletSetupConfig | undefined;
+    projectBinding?: import("../config").ProjectBindingConfig | undefined;
+    runtime?: import("../config").RuntimeRequirementsConfig | undefined;
+} & GenericAuthTarget) | (import("../config").AgentSelectionHintsConfig & {
+    server: string;
+    backend: "http";
+    name: string;
+    description: string;
+    exposure?: import("../config").CapletExposure | undefined;
+    tags?: string[] | undefined;
+    body?: string | undefined;
+    baseUrl: string;
+    auth: import("../config").OpenApiAuthConfig;
+    actions: Record<string, import("../config").HttpActionConfig>;
+    requestTimeoutMs: number;
+    maxResponseBytes: number;
+    disabled: boolean;
+    setup?: import("..").CapletSetupConfig | undefined;
+    projectBinding?: import("../config").ProjectBindingConfig | undefined;
+    runtime?: import("../config").RuntimeRequirementsConfig | undefined;
+} & GenericAuthTarget))[];
 export declare function assertLoginTarget(target: AuthTarget | undefined, serverId: string): asserts target is AuthTarget;
 export {};

package/dist/cli/cloud-add.d.ts

@@ -0,0 +1,8 @@
+export type CloudCapletBundleFile = {
+    path: string;
+    content: string;
+};
+export type CloudCapletBundle = {
+    files: CloudCapletBundleFile[];
+};
+export declare function buildCloudCapletBundle(rootInput: string): CloudCapletBundle;

package/dist/cli/code-mode.d.ts

@@ -0,0 +1,16 @@
+export type CodeModeCliOptions = {
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    configPath?: string | undefined;
+    projectConfigPath?: string | undefined;
+    authDir?: string | undefined;
+    inlineCode?: string | undefined;
+    file?: string | undefined;
+    timeoutMs?: number | undefined;
+    json?: boolean | undefined;
+    readStdin?: (() => Promise<string>) | undefined;
+    writeOut: (value: string) => void;
+    setExitCode: (code: number) => void;
+};
+export declare function runCodeModeCli(options: CodeModeCliOptions): Promise<void>;
+export declare function codeModeTypesCli(options: Pick<CodeModeCliOptions, "env" | "configPath" | "projectConfigPath" | "authDir" | "json" | "writeOut">): Promise<void>;
+export declare function readCodeModeCliCode(options: Pick<CodeModeCliOptions, "inlineCode" | "file" | "readStdin">): Promise<string>;

package/dist/cli/commands.d.ts

@@ -3,9 +3,13 @@ export type CompletionShell = (typeof completionShells)[number];
 export declare const cliCommands: {
     readonly completion: "completion";
     readonly completeHidden: "__complete";
+    readonly codeMode: "code-mode";
     readonly serve: "serve";
+    readonly attach: "attach";
+    readonly cloud: "cloud";
     readonly init: "init";
     readonly setup: "setup";
+    readonly doctor: "doctor";
     readonly list: "list";
     readonly install: "install";
     readonly add: "add";
@@ -26,12 +30,15 @@ export declare const cliCommands: {
     readonly config: "config";
     readonly auth: "auth";
 };
-export declare const topLevelCommandNames: readonly ["serve", "init", "setup", "list", "install", "add", "inspect", "check-backend", "list-tools", "search-tools", "get-tool", "call-tool", "list-resources", "search-resources", "list-resource-templates", "read-resource", "list-prompts", "search-prompts", "get-prompt", "complete", "config", "auth", "completion"];
+export declare const topLevelCommandNames: readonly ["serve", "code-mode", "attach", "cloud", "init", "setup", "doctor", "list", "install", "add", "inspect", "check-backend", "list-tools", "search-tools", "get-tool", "call-tool", "list-resources", "search-resources", "list-resource-templates", "read-resource", "list-prompts", "search-prompts", "get-prompt", "complete", "config", "auth", "completion"];
 export declare const cliSubcommands: {
     readonly add: readonly ["cli", "mcp", "openapi", "graphql", "http"];
     readonly auth: readonly ["login", "logout", "list"];
+    readonly cloud: readonly ["auth"];
+    readonly "code-mode": readonly ["types"];
     readonly completion: readonly ["bash", "zsh", "fish", "powershell", "cmd"];
     readonly config: readonly ["path", "paths"];
+    readonly serve: readonly ["start", "stop", "status", "restart", "enable", "disable"];
     readonly setup: readonly ["codex", "claude-code", "opencode", "pi", "mcp-client"];
 };
 export declare const capletIdCommands: Set<string>;

package/dist/cli/doctor.d.ts

@@ -0,0 +1,21 @@
+import { CloudAuthStore } from "../cloud-auth/store";
+import type { MutagenProjectSyncDoctorData } from "../project-binding/mutagen";
+export type DoctorOptions = {
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    cwd?: string;
+    syncStatus?: MutagenProjectSyncDoctorData;
+    cloudAuthStore?: CloudAuthStore;
+    observedOutputShapeCacheDir?: string;
+};
+export type DoctorJsonReport = {
+    server: Record<string, unknown>;
+    remote: Record<string, unknown>;
+    projectBinding: Record<string, unknown>;
+    sync: Record<string, unknown>;
+    daemon: Record<string, unknown>;
+    cloudAuth: Record<string, unknown>;
+    exposure: Record<string, unknown>;
+    codeMode: Record<string, unknown>;
+};
+export declare function doctorJsonReport(options?: DoctorOptions): Promise<DoctorJsonReport>;
+export declare function formatDoctorReport(options?: DoctorOptions): Promise<string>;

package/dist/cli/setup-caplet.d.ts

@@ -0,0 +1,12 @@
+import { type SetupSpawn } from "../setup/runner";
+import type { SetupTargetKind } from "../setup/types";
+export type CapletSetupCliOptions = {
+    yes?: boolean;
+    target?: SetupTargetKind;
+    remote?: boolean;
+    configPath?: string | undefined;
+    projectConfigPath?: string | undefined;
+    baseDir?: string | undefined;
+    spawn?: SetupSpawn;
+};
+export declare function runCapletSetupCli(capletId: string, options?: CapletSetupCliOptions): Promise<string>;

package/dist/cli/setup.d.ts

@@ -1,19 +1,30 @@
+import { type SetupTargetKind } from "../setup/types";
 export declare const setupIntegrationIds: readonly ["codex", "claude-code", "opencode", "pi", "mcp-client"];
 export type SetupIntegrationId = (typeof setupIntegrationIds)[number];
 export type SetupFormat = "plain" | "json";
+export type SetupTargetOption = SetupTargetKind | "local" | "remote" | "cloud" | "hosted_worker";
 export type SetupCommandResult = {
     stdout: string;
     stderr: string;
 };
 export type SetupCommandRunner = (command: string, args: string[]) => Promise<SetupCommandResult>;
+export type SetupPromptReader = (prompt: string) => Promise<string>;
 export type SetupOptions = {
     remote?: boolean;
+    remoteUrl?: string;
     serverUrl?: string;
     output?: string;
     dryRun?: boolean;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     format?: SetupFormat;
     runCommand?: SetupCommandRunner;
+    yes?: boolean;
+    target?: SetupTargetOption;
+};
+export type InteractiveSetupOptions = SetupOptions & {
+    readPrompt: SetupPromptReader;
 };
 export declare function formatSetupMenu(): string;
+export declare function formatSetupPrompt(): string;
+export declare function runInteractiveSetup(options: InteractiveSetupOptions): Promise<string>;
 export declare function runSetup(integration: string, options?: SetupOptions): Promise<string>;

package/dist/cli-tools.d.ts

@@ -1,6 +1,6 @@
 import type { CompatibilityCallToolResult, Tool } from "@modelcontextprotocol/sdk/types";
 import type { CliToolsConfig } from "./config";
-import type { CompactTool } from "./downstream";
+import { type CompactTool } from "./downstream";
 import type { ServerRegistry } from "./registry";
 export declare class CliToolsManager {
     private registry;

package/dist/cli.d.ts

@@ -1,6 +1,8 @@
 import { Command } from "commander";
 import { type SetupCommandRunner } from "./cli/setup";
-import { type ServeOptions } from "./serve";
+import { type AttachServeOptions } from "./attach/options";
+import type { ProjectBindingWebSocketFactory } from "./project-binding/transport";
+import { type ServeDaemonOperationOptions, type ServeOptions } from "./serve";
 export { initConfig, starterConfig } from "./cli/init";
 export { installCaplets, normalizeGitRepo } from "./cli/install";
 export { addCliCaplet, addGraphqlCaplet, addHttpCaplet, addMcpCaplet, addOpenApiCaplet, } from "./cli/add";
@@ -9,11 +11,16 @@ type CliIO = {
     writeErr?: (value: string) => void;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetch?: typeof fetch;
+    signal?: AbortSignal;
+    projectBindingWebSocketFactory?: ProjectBindingWebSocketFactory;
     authDir?: string;
     version?: string;
     setExitCode?: (code: number) => void;
     serve?: (options: ServeOptions) => Promise<void>;
+    attachServe?: (options: AttachServeOptions) => Promise<void>;
+    daemon?: ServeDaemonOperationOptions;
     runSetupCommand?: SetupCommandRunner;
+    readStdin?: () => Promise<string>;
 };
 export declare function runCli(args: string[], io?: CliIO): Promise<void>;
 export declare function createProgram(io?: CliIO): Command;

package/dist/cloud/apply.d.ts

@@ -0,0 +1,36 @@
+export type ApplyReceiptInput = {
+    projectFingerprint: string;
+    filesChanged: string[];
+    skipped: string[];
+    policyWarnings: string[];
+};
+export type ApplyReceipt = ApplyReceiptInput & {
+    status: "applied";
+};
+export type ApplyConflict = {
+    path: string;
+    kind: "content" | "delete_modify" | "binary";
+    message?: string;
+};
+export type RemoteFileChange = {
+    path: string;
+    baseSha256?: string;
+    content: string;
+};
+export declare function createApplyReceipt(input: ApplyReceiptInput): ApplyReceipt;
+export declare function classifyApplyResult(input: {
+    conflicts: ApplyConflict[];
+}): {
+    status: "applied";
+    recoverable: false;
+} | {
+    status: "apply_conflict";
+    recoverable: true;
+    conflicts: ApplyConflict[];
+};
+export declare function applyRemoteFileChanges(projectRoot: string, changes: RemoteFileChange[]): ApplyReceipt | {
+    status: "apply_conflict";
+    recoverable: true;
+    conflicts: ApplyConflict[];
+};
+export declare function sha256(value: string): string;

package/dist/cloud/client.d.ts

@@ -0,0 +1,30 @@
+import type { ProjectSyncFile } from "./sync";
+export type CapletsCloudClientOptions = {
+    baseUrl: URL;
+    accessToken: string;
+    fetch?: typeof fetch;
+};
+export type RegisterPresenceInput = {
+    workspaceId: string;
+    projectRoot: string;
+    projectFingerprint: string;
+    allowedCapletIds: string[];
+    projectFiles?: ProjectSyncFile[] | undefined;
+    fallbackConsent?: "allow" | "deny" | undefined;
+};
+export type RegisterPresenceResult = {
+    presenceId: string;
+    expiresAt: string;
+};
+export type HeartbeatPresenceResult = RegisterPresenceResult;
+export declare class CapletsCloudClient {
+    private readonly options;
+    private readonly fetchImpl;
+    constructor(options: CapletsCloudClientOptions);
+    registerPresence(input: RegisterPresenceInput): Promise<RegisterPresenceResult>;
+    stopPresence(presenceId: string): Promise<void>;
+    heartbeatPresence(presenceId: string): Promise<HeartbeatPresenceResult>;
+    updatePresenceCaplets(presenceId: string, allowedCapletIds: string[]): Promise<void>;
+    private headers;
+    private endpoint;
+}

package/dist/cloud/presence.d.ts

@@ -0,0 +1,29 @@
+import type { CapletsCloudClient, RegisterPresenceInput } from "./client";
+type PresenceClient = Pick<CapletsCloudClient, "registerPresence"> & {
+    heartbeatPresence?: (presenceId: string) => Promise<unknown>;
+    stopPresence?: (presenceId: string) => Promise<void>;
+    updatePresenceCaplets?: (presenceId: string, allowedCapletIds: string[]) => Promise<void>;
+};
+export type ProjectBindingSessionManagerOptions = RegisterPresenceInput & {
+    client: PresenceClient;
+    heartbeatIntervalMs?: number;
+    setInterval?: typeof setInterval;
+    clearInterval?: typeof clearInterval;
+    onError?: (error: unknown) => void;
+};
+export declare class ProjectBindingSessionManager {
+    private readonly options;
+    private presenceId;
+    private heartbeatTimer;
+    private startPromise;
+    constructor(options: ProjectBindingSessionManagerOptions);
+    start(): Promise<void>;
+    private register;
+    close(): Promise<void>;
+    updateAllowedCapletIds(allowedCapletIds: string[]): Promise<void>;
+    private startHeartbeat;
+    private stopHeartbeat;
+}
+export type LocalPresenceManagerOptions = ProjectBindingSessionManagerOptions;
+export declare const LocalPresenceManager: typeof ProjectBindingSessionManager;
+export {};

package/dist/cloud/project-root.d.ts

@@ -0,0 +1,2 @@
+export declare function findProjectRoot(start?: string): string;
+export declare function fingerprintProjectRoot(root: string): string;

package/dist/cloud/runtime-adapter.d.ts

@@ -0,0 +1,23 @@
+import { LocalSetupStore } from "../setup/local-store";
+import type { SetupActor, SetupAttempt, SetupPlan } from "../setup/types";
+export type CloudRuntimeAdapterOptions = {
+    configPath?: string;
+    projectConfigPath?: string;
+    authDir?: string;
+    runtimeId: string;
+    sandboxId?: string;
+    executionKind: "cloud" | "local-fallback";
+    setupStore?: LocalSetupStore;
+};
+export type CloudRuntimeAdapter = {
+    listTools(): Promise<unknown>;
+    callTool(name: string, args: unknown): Promise<unknown>;
+    checkBackend(capletId: string): Promise<unknown>;
+    setupPlan(capletId: string): Promise<SetupPlan>;
+    runSetup(capletId: string, input: {
+        approved: boolean;
+        actor: SetupActor;
+    }): Promise<SetupAttempt[]>;
+    close(): Promise<void>;
+};
+export declare function createCloudRuntimeAdapter(options: CloudRuntimeAdapterOptions): CloudRuntimeAdapter;

package/dist/cloud/runtime-http.d.ts

@@ -0,0 +1,6 @@
+import { Hono } from "hono";
+import { type CloudRuntimeAdapterOptions } from "./runtime-adapter";
+export type RuntimeHttpOptions = CloudRuntimeAdapterOptions & {
+    token: string;
+};
+export declare function createRuntimeHttpApp(options: RuntimeHttpOptions): Hono;

package/dist/cloud/sync.d.ts

@@ -0,0 +1,10 @@
+export type ProjectSyncFile = {
+    path: string;
+    content: string;
+};
+export declare class ProjectSyncCoordinator {
+    private readonly queues;
+    runMutating<T>(projectId: string, task: () => Promise<T>): Promise<T>;
+}
+export declare function projectSyncManifest(projectRoot: string): string[];
+export declare function projectSyncFiles(projectRoot: string): ProjectSyncFile[];

package/dist/cloud-auth/client.d.ts

@@ -0,0 +1,57 @@
+import type { CloudAuthLoginPollResult, CloudAuthLoginStart, CloudAuthTokenResponse, CloudAuthWorkspace } from "./types";
+export type CloudAuthClientOptions = {
+    cloudUrl: string;
+    fetch?: typeof fetch;
+};
+export type StartLoginInput = {
+    requestedWorkspace?: string | undefined;
+    deviceName?: string | undefined;
+    scope?: string[] | undefined;
+};
+export type ExchangeTokenInput = {
+    loginId: string;
+    oneTimeCode: string;
+};
+export type RefreshTokenInput = {
+    refreshToken: string;
+};
+export type CloudAddCapletsInput = {
+    accessToken: string;
+    workspace: string;
+    bundle: {
+        files: Array<{
+            path: string;
+            content: string;
+        }>;
+    };
+};
+export type CloudAddCapletsResult = {
+    caplet?: unknown;
+    caplets: unknown[];
+};
+export type CloudAuthClientCredentials = Required<Pick<CloudAuthTokenResponse, "workspaceId" | "accessToken" | "expiresAt" | "tokenType" | "credentialFamilyId">> & Pick<CloudAuthTokenResponse, "workspaceSlug" | "refreshToken" | "deviceName" | "requestId"> & {
+    cloudUrl: string;
+    scope: string[];
+    redacted: Record<string, unknown>;
+};
+export declare class CloudAuthClient {
+    private readonly cloudUrl;
+    private readonly fetchImpl;
+    constructor(options: CloudAuthClientOptions);
+    startLogin(input?: StartLoginInput): Promise<CloudAuthLoginStart>;
+    pollLogin(loginId: string): Promise<CloudAuthLoginPollResult>;
+    exchangeToken(input: ExchangeTokenInput): Promise<CloudAuthClientCredentials>;
+    refresh(input: RefreshTokenInput): Promise<CloudAuthClientCredentials>;
+    logout(refreshToken: string): Promise<void>;
+    workspaces(accessToken: string): Promise<{
+        workspaces: CloudAuthWorkspace[];
+    }>;
+    switchWorkspace(input: {
+        accessToken: string;
+        workspace: string;
+        refreshToken?: string | undefined;
+        deviceName?: string | undefined;
+    }): Promise<CloudAuthClientCredentials>;
+    addCaplets(input: CloudAddCapletsInput): Promise<CloudAddCapletsResult>;
+    private requestJson;
+}

package/dist/cloud-auth/errors.d.ts

@@ -0,0 +1,11 @@
+import { CapletsError } from "../errors";
+export type CloudAuthErrorCode = "cloud_auth_required" | "cloud_auth_expired" | "cloud_auth_revoked" | "workspace_selection_required" | "workspace_switch_required" | "workspace_forbidden" | "endpoint_unavailable";
+export type CloudAuthRecovery = {
+    code: CloudAuthErrorCode;
+    message: string;
+    recoveryCommand: string;
+    requestId?: string | undefined;
+};
+export declare function redactCloudAuthSecrets(value: unknown): unknown;
+export declare function cloudAuthRecovery(code: CloudAuthErrorCode, detail?: string): CloudAuthRecovery;
+export declare function cloudAuthError(code: CloudAuthErrorCode, detail?: string): CapletsError;

package/dist/cloud-auth/open-url.d.ts

@@ -0,0 +1,7 @@
+export type OpenUrlResult = {
+    opened: boolean;
+    command?: string | undefined;
+};
+export declare function openBrowserUrl(url: string, options?: {
+    opener?: (url: string) => Promise<OpenUrlResult> | OpenUrlResult;
+}): Promise<OpenUrlResult>;

package/dist/cloud-auth/store.d.ts

@@ -0,0 +1,35 @@
+import type { RedactedCloudAuthStatus } from "./types";
+type CloudAuthPathEnv = Partial<Record<"CAPLETS_CLOUD_AUTH_PATH" | "XDG_CONFIG_HOME" | "APPDATA", string>>;
+export type CloudAuthCredentials = {
+    version?: 1 | 2 | undefined;
+    cloudUrl: string;
+    workspaceId: string;
+    workspaceSlug?: string | undefined;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: string;
+    scope?: string[] | undefined;
+    tokenType?: string | undefined;
+    credentialFamilyId?: string | undefined;
+    deviceName?: string | undefined;
+    createdAt?: string | undefined;
+    lastRefreshAt?: string | undefined;
+    selectedWorkspaceSwitchedAt?: string | undefined;
+};
+export type CloudAuthStoreOptions = {
+    path?: string;
+    env?: CloudAuthPathEnv;
+    home?: string;
+    platform?: NodeJS.Platform;
+};
+export declare class CloudAuthStore {
+    readonly path: string;
+    constructor(options?: CloudAuthStoreOptions);
+    load(): Promise<CloudAuthCredentials | undefined>;
+    save(credentials: CloudAuthCredentials): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare function migrateCredentials(value: unknown): CloudAuthCredentials;
+export declare function redactedCloudAuthStatus(credentials: CloudAuthCredentials | undefined, now?: Date): RedactedCloudAuthStatus;
+export declare function cloudAuthPath(options?: CloudAuthStoreOptions): string;
+export {};

package/dist/cloud-auth/types.d.ts

@@ -0,0 +1,67 @@
+export declare const CLOUD_AUTH_STATES: readonly ["unauthenticated", "login_pending", "workspace_selection_required", "authenticated", "refreshable", "switch_required", "expired", "revoked"];
+export type CloudAuthState = (typeof CLOUD_AUTH_STATES)[number];
+export declare const HOSTED_CLOUD_AUTH_SCOPES: readonly ["project_binding:read", "project_binding:write", "mcp:tools"];
+export type CloudAuthScope = (typeof HOSTED_CLOUD_AUTH_SCOPES)[number] | string;
+export type CloudAuthWorkspace = {
+    workspaceId: string;
+    slug?: string | undefined;
+    displayName?: string | undefined;
+    name?: string | undefined;
+    role?: string | undefined;
+    selected?: boolean | undefined;
+};
+export type CloudAuthLoginStart = {
+    loginId: string;
+    loginUrl: string;
+    userCode: string;
+    expiresAt: string;
+    requestId?: string | undefined;
+};
+export type CloudAuthLoginPollResult = {
+    status: "pending";
+    expiresAt?: string | undefined;
+    requestId?: string | undefined;
+} | {
+    status: "workspace_selection_required";
+    workspaces: CloudAuthWorkspace[];
+    expiresAt?: string | undefined;
+    requestId?: string | undefined;
+} | {
+    status: "completed";
+    selectedWorkspace?: Pick<CloudAuthWorkspace, "workspaceId" | "slug"> | undefined;
+    oneTimeCode: string;
+    requestId?: string | undefined;
+} | {
+    status: "expired" | "denied" | "consumed";
+    message?: string | undefined;
+    requestId?: string | undefined;
+};
+export type CloudAuthTokenResponse = {
+    status?: "authenticated" | undefined;
+    cloudUrl?: string | undefined;
+    workspaceId: string;
+    workspaceSlug?: string | undefined;
+    accessToken: string;
+    refreshToken?: string | undefined;
+    expiresAt: string;
+    scope?: CloudAuthScope[] | string | undefined;
+    tokenType?: "Bearer" | string | undefined;
+    credentialFamilyId?: string | undefined;
+    deviceName?: string | undefined;
+    requestId?: string | undefined;
+};
+export type RedactedCloudAuthStatus = {
+    authenticated: boolean;
+    status: CloudAuthState;
+    cloudUrl?: string | undefined;
+    workspaceId?: string | undefined;
+    workspaceSlug?: string | undefined;
+    expiresAt?: string | undefined;
+    scope?: CloudAuthScope[] | undefined;
+    tokenType?: string | undefined;
+    credentialFamilyId?: string | undefined;
+    deviceName?: string | undefined;
+    createdAt?: string | undefined;
+    lastRefreshAt?: string | undefined;
+    selectedWorkspaceSwitchedAt?: string | undefined;
+};

package/dist/code-mode/api.d.ts

@@ -0,0 +1,32 @@
+import type { NativeCapletsService } from "../native/service";
+import type { CapletsResult, CodeModeCallableCaplet, Page, PageInput, ReadLogsInput, ReadLogsResult, ToolCallResult } from "./types";
+export type CodeModeCapletHandle = {
+    readonly id: string;
+    inspect(): Promise<unknown>;
+    check(): Promise<CapletsResult<unknown>>;
+    tools(input?: PageInput): Promise<Page<unknown>>;
+    searchTools(query: string, input?: PageInput): Promise<Page<unknown>>;
+    describeTool(name: string): Promise<CapletsResult<unknown>>;
+    callTool(name: string, args?: unknown): Promise<ToolCallResult>;
+    resources(input?: PageInput): Promise<Page<unknown>>;
+    searchResources(query: string, input?: PageInput): Promise<Page<unknown>>;
+    resourceTemplates(input?: PageInput): Promise<Page<unknown>>;
+    readResource(uri: string): Promise<CapletsResult<unknown>>;
+    prompts(input?: PageInput): Promise<Page<unknown>>;
+    searchPrompts(query: string, input?: PageInput): Promise<Page<unknown>>;
+    getPrompt(name: string, args?: unknown): Promise<CapletsResult<unknown>>;
+    complete(input: unknown): Promise<CapletsResult<unknown>>;
+};
+export type CodeModeDebugApi = {
+    readLogs(input: ReadLogsInput): Promise<ReadLogsResult>;
+};
+export type CodeModeCapletsApi = {
+    [capletId: string]: CodeModeCapletHandle | CodeModeDebugApi | (CodeModeCapletHandle & CodeModeDebugApi);
+    debug: CodeModeDebugApi | (CodeModeCapletHandle & CodeModeDebugApi);
+};
+export type CreateCodeModeCapletsApiInput = {
+    service: NativeCapletsService;
+    readLogs?: (input: ReadLogsInput) => Promise<ReadLogsResult>;
+};
+export declare function listCodeModeCallableCaplets(service: NativeCapletsService): CodeModeCallableCaplet[];
+export declare function createCodeModeCapletsApi(input: CreateCodeModeCapletsApiInput): CodeModeCapletsApi;

package/dist/code-mode/declarations.d.ts

@@ -0,0 +1,5 @@
+import type { CodeModeDeclarationInput } from "./types";
+export declare function generateCodeModeDeclarations(input: CodeModeDeclarationInput): string;
+export declare function generateCodeModeRunToolDescription(declaration: string): string;
+export declare function minifyCodeModeDeclarationText(value: string): string;
+export declare function codeModeDeclarationHash(declaration: string): string;

package/dist/code-mode/diagnostics.d.ts

@@ -0,0 +1,8 @@
+import type { CodeModeDiagnostic } from "./types";
+export type DiagnoseCodeModeTypeScriptInput = {
+    code: string;
+    declaration: string;
+    maxDiagnostics?: number;
+    timeoutMs?: number;
+};
+export declare function diagnoseCodeModeTypeScript(input: DiagnoseCodeModeTypeScriptInput): CodeModeDiagnostic[];

package/dist/code-mode/index.d.ts

@@ -0,0 +1,4 @@
+export { codeModeDeclarationHash, generateCodeModeDeclarations, generateCodeModeRunToolDescription, minifyCodeModeDeclarationText, } from "./declarations";
+export { codeModeRunInputJsonSchema, codeModeRunInputSchema, codeModeRunParamsSchema, isCodeModeRunRequest, } from "./tool";
+export { hasDirectFetchCall, hasExecutableImport } from "./static-analysis";
+export type { CodeModeCallableCaplet, CodeModeDeclarationInput, CodeModeDiagnostic, CodeModeLogEntry, CodeModeLogs, CodeModeRunEnvelope, CodeModeRunError, CodeModeRunMeta, CodeModeTypesJson, JsonPrimitive, JsonValue, ReadLogsInput, ReadLogsResult, ToolCallError, ToolCallMeta, ToolCallResult, } from "./types";

package/dist/code-mode/logs.d.ts

@@ -0,0 +1,21 @@
+import type { CodeModeLogEntry, ReadLogsInput, ReadLogsResult } from "./types";
+export type CodeModeLogStoreOptions = {
+    stateDir?: string;
+    now?: () => Date;
+    logRefTtlMs?: number;
+};
+export type StoreCodeModeLogsResult = {
+    logRef: string;
+    expiresAt: string;
+};
+export declare class CodeModeLogStore {
+    private readonly stateDir;
+    private readonly now;
+    private readonly logRefTtlMs;
+    constructor(options?: CodeModeLogStoreOptions);
+    store(entries: CodeModeLogEntry[]): Promise<StoreCodeModeLogsResult>;
+    read(input: ReadLogsInput): Promise<ReadLogsResult>;
+    private logsDir;
+    private logPath;
+}
+export declare function redactCodeModeLogText(text: string): string;

package/dist/code-mode/runner.d.ts

@@ -0,0 +1,15 @@
+import type { NativeCapletsService } from "../native/service";
+import { CodeModeLogStore } from "./logs";
+import { type CodeModeSandbox } from "./sandbox";
+import type { CodeModeRunEnvelope } from "./types";
+export type RunCodeModeInput = {
+    code: string;
+    service: NativeCapletsService;
+    timeoutMs?: number;
+    maxTimeoutMs?: number;
+    runtimeScope?: string;
+    logStore?: CodeModeLogStore;
+    sandbox?: CodeModeSandbox;
+    returnedLogBytes?: number;
+};
+export declare function runCodeMode(input: RunCodeModeInput): Promise<CodeModeRunEnvelope>;