@caplets/core 0.18.9 → 0.19.0

package/dist/cli/commands.d.ts

@@ -4,8 +4,11 @@ export declare const cliCommands: {
     readonly completion: "completion";
     readonly completeHidden: "__complete";
     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 +29,14 @@ 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", "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 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,18 @@
+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;
+};
+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>;
+};
+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,6 +1,8 @@
+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;
@@ -14,6 +16,8 @@ export type SetupOptions = {
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     format?: SetupFormat;
     runCommand?: SetupCommandRunner;
+    yes?: boolean;
+    target?: SetupTargetOption;
 };
 export declare function formatSetupMenu(): string;
 export declare function runSetup(integration: string, options?: SetupOptions): Promise<string>;

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,10 +11,14 @@ 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;
 };
 export declare function runCli(args: string[], io?: CliIO): Promise<void>;

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,42 @@
+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 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>;
+    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,66 @@
+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 type CloudAuthScope = "project_binding:read" | "project_binding:write" | 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/{completion-RqzHpHRY.js → completion-brgziz4L.js}

@@ -1,4 +1,5 @@
-import { Ct as resolveCapletsRoot, Et as resolveProjectConfigPath, Lt as __exportAll, Pt as CapletsError, St as DEFAULT_COMPLETION_CACHE_DIR, gt as loadConfigWithSources, wt as resolveConfigPath, xt as DEFAULT_AUTH_DIR } from "./options-DnOUjft1.js";
+import { Bt as DEFAULT_COMPLETION_CACHE_DIR, Gt as resolveConfigPath, Pt as loadConfigWithSources, Wt as resolveCapletsRoot, en as __exportAll, qt as resolveProjectConfigPath, zt as DEFAULT_AUTH_DIR } from "./service-BXcE4Rv8.js";
+import { u as CapletsError } from "./validation-BBG4skZf.js";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { createHash } from "node:crypto";
@@ -14,8 +15,11 @@ const cliCommands = {
 	completion: "completion",
 	completeHidden: "__complete",
 	serve: "serve",
+	attach: "attach",
+	cloud: "cloud",
 	init: "init",
 	setup: "setup",
+	doctor: "doctor",
 	list: "list",
 	install: "install",
 	add: "add",
@@ -38,8 +42,11 @@ const cliCommands = {
 };
 const topLevelCommandNames = [
 	cliCommands.serve,
+	cliCommands.attach,
+	cliCommands.cloud,
 	cliCommands.init,
 	cliCommands.setup,
+	cliCommands.doctor,
 	cliCommands.list,
 	cliCommands.install,
 	cliCommands.add,
@@ -74,8 +81,17 @@ const cliSubcommands = {
 		"logout",
 		"list"
 	],
+	[cliCommands.cloud]: ["auth"],
 	[cliCommands.completion]: [...completionShells],
 	[cliCommands.config]: ["path", "paths"],
+	[cliCommands.serve]: [
+		"start",
+		"stop",
+		"status",
+		"restart",
+		"enable",
+		"disable"
+	],
 	[cliCommands.setup]: [
 		"codex",
 		"claude-code",

package/dist/config-runtime.d.ts

@@ -0,0 +1,174 @@
+export type RemoteAuthConfig = {
+    type: "none";
+} | {
+    type: "bearer";
+    token: string;
+} | {
+    type: "headers";
+    headers: Record<string, string>;
+} | {
+    type: "oauth2" | "oidc";
+    authorizationUrl?: string | undefined;
+    tokenUrl?: string | undefined;
+    issuer?: string | undefined;
+    resourceMetadataUrl?: string | undefined;
+    authorizationServerMetadataUrl?: string | undefined;
+    openidConfigurationUrl?: string | undefined;
+    clientMetadataUrl?: string | undefined;
+    clientId?: string | undefined;
+    clientSecret?: string | undefined;
+    scopes?: string[] | undefined;
+    redirectUri?: string | undefined;
+};
+export type CapletSetupCommandConfig = {
+    label: string;
+    command: string;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+    timeoutMs?: number | undefined;
+    maxOutputBytes?: number | undefined;
+};
+export type CapletSetupConfig = {
+    commands?: CapletSetupCommandConfig[] | undefined;
+    verify?: CapletSetupCommandConfig[] | undefined;
+};
+export type ProjectBindingConfig = {
+    required: true;
+};
+export type RuntimeFeature = "docker" | "browser";
+export type RuntimeResourceClass = "standard" | "large" | "heavy";
+export type RuntimeRequirementsConfig = {
+    features?: RuntimeFeature[] | undefined;
+    resources?: {
+        class?: RuntimeResourceClass | undefined;
+    } | undefined;
+};
+export type CapletServerConfig = CommonCapletConfig & {
+    backend: "mcp";
+    transport: "stdio" | "http" | "sse";
+    command?: string | undefined;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+    url?: string | undefined;
+    auth?: RemoteAuthConfig | undefined;
+    startupTimeoutMs: number;
+    callTimeoutMs: number;
+    toolCacheTtlMs: number;
+};
+export type OpenApiAuthConfig = RemoteAuthConfig;
+export type OpenApiEndpointConfig = CommonCapletConfig & {
+    backend: "openapi";
+    specPath?: string | undefined;
+    specUrl?: string | undefined;
+    baseUrl?: string | undefined;
+    auth: OpenApiAuthConfig;
+    requestTimeoutMs: number;
+    operationCacheTtlMs: number;
+};
+export type GraphQlOperationConfig = {
+    document?: string | undefined;
+    documentPath?: string | undefined;
+    operationName?: string | undefined;
+    description?: string | undefined;
+};
+export type GraphQlEndpointConfig = CommonCapletConfig & {
+    backend: "graphql";
+    endpointUrl: string;
+    schemaPath?: string | undefined;
+    schemaUrl?: string | undefined;
+    introspection?: true | undefined;
+    operations?: Record<string, GraphQlOperationConfig> | undefined;
+    auth: OpenApiAuthConfig;
+    requestTimeoutMs: number;
+    operationCacheTtlMs: number;
+    selectionDepth: number;
+};
+export type HttpActionConfig = {
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    path: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, unknown> | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    query?: Record<string, string | number | boolean> | undefined;
+    headers?: Record<string, string | number | boolean> | undefined;
+    jsonBody?: unknown;
+};
+export type HttpApiConfig = CommonCapletConfig & {
+    backend: "http";
+    baseUrl: string;
+    auth: OpenApiAuthConfig;
+    actions: Record<string, HttpActionConfig>;
+    requestTimeoutMs: number;
+    maxResponseBytes: number;
+};
+export type CliToolActionConfig = {
+    description?: string | undefined;
+    inputSchema?: Record<string, unknown> | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    command: string;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+    timeoutMs?: number | undefined;
+    maxOutputBytes?: number | undefined;
+    output?: {
+        type: "text" | "json";
+    } | undefined;
+    annotations?: {
+        readOnlyHint?: boolean | undefined;
+        destructiveHint?: boolean | undefined;
+        idempotentHint?: boolean | undefined;
+        openWorldHint?: boolean | undefined;
+    } | undefined;
+};
+export type CliToolsConfig = CommonCapletConfig & {
+    backend: "cli";
+    actions: Record<string, CliToolActionConfig>;
+    cwd?: string | undefined;
+    env?: Record<string, string> | undefined;
+    timeoutMs: number;
+    maxOutputBytes: number;
+};
+export type CapletSetConfig = CommonCapletConfig & {
+    backend: "caplets";
+    configPath?: string | undefined;
+    capletsRoot?: string | undefined;
+    defaultSearchLimit: number;
+    maxSearchLimit: number;
+    toolCacheTtlMs: number;
+};
+export type CapletConfig = CapletServerConfig | OpenApiEndpointConfig | GraphQlEndpointConfig | HttpApiConfig | CliToolsConfig | CapletSetConfig;
+export type CapletsConfig = {
+    version: 1;
+    options: {
+        defaultSearchLimit: number;
+        maxSearchLimit: number;
+        completion: {
+            discoveryTimeoutMs: number;
+            overallTimeoutMs: number;
+            cacheTtlMs: number;
+            negativeCacheTtlMs: number;
+        };
+    };
+    mcpServers: Record<string, CapletServerConfig>;
+    openapiEndpoints: Record<string, OpenApiEndpointConfig>;
+    graphqlEndpoints: Record<string, GraphQlEndpointConfig>;
+    httpApis: Record<string, HttpApiConfig>;
+    cliTools: Record<string, CliToolsConfig>;
+    capletSets: Record<string, CapletSetConfig>;
+};
+type CommonCapletConfig = {
+    server: string;
+    name: string;
+    description: string;
+    tags?: string[] | undefined;
+    body?: string | undefined;
+    setup?: CapletSetupConfig | undefined;
+    projectBinding?: ProjectBindingConfig | undefined;
+    runtime?: RuntimeRequirementsConfig | undefined;
+    disabled: boolean;
+};
+export declare function parseConfig(input: unknown): CapletsConfig;
+export {};