@caplets/core 0.13.1 → 0.15.0

package/dist/auth/store.d.ts

@@ -0,0 +1,22 @@
+export type StoredOAuthTokenBundle = {
+    server: string;
+    authType?: "oauth2" | "oidc" | undefined;
+    accessToken: string;
+    refreshToken?: string | undefined;
+    tokenType?: string | undefined;
+    expiresAt?: string | undefined;
+    scope?: string | undefined;
+    idToken?: string | undefined;
+    issuer?: string | undefined;
+    subject?: string | undefined;
+    clientId?: string | undefined;
+    clientSecret?: string | undefined;
+    protectedResourceOrigin?: string | undefined;
+    metadata?: Record<string, unknown>;
+};
+export declare function authStorePath(server: string, authDir?: string): string;
+export declare function readTokenBundle(server: string, authDir?: string): StoredOAuthTokenBundle | undefined;
+export declare function listTokenBundles(authDir?: string): StoredOAuthTokenBundle[];
+export declare function deleteTokenBundle(server: string, authDir?: string): boolean;
+export declare function isTokenBundleExpired(bundle: StoredOAuthTokenBundle): boolean;
+export declare function writeTokenBundle(bundle: StoredOAuthTokenBundle, authDir?: string): void;

package/dist/auth.d.ts

@@ -0,0 +1,77 @@
+import { type AuthResult, type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import { type StoredOAuthTokenBundle } from "./auth/store";
+import type { CapletServerConfig } from "./config";
+import { CapletsError } from "./errors";
+export { authStorePath, deleteTokenBundle, isTokenBundleExpired, listTokenBundles, readTokenBundle, writeTokenBundle, type StoredOAuthTokenBundle, } from "./auth/store";
+type OAuthLikeAuthConfig = {
+    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 GenericAuthTarget = {
+    server: string;
+    backend: "openapi" | "graphql" | "http";
+    url?: string | undefined;
+    baseUrl?: string | undefined;
+    specUrl?: string | undefined;
+    auth?: OAuthLikeAuthConfig | {
+        type: string;
+    } | undefined;
+    requestTimeoutMs?: number | undefined;
+};
+export declare function staticRemoteHeaders(server: CapletServerConfig): Record<string, string>;
+export declare function oauthHeaders(server: CapletServerConfig, authDir?: string): Record<string, string>;
+export declare function genericOAuthHeaders(target: GenericAuthTarget, authDir?: string): Record<string, string>;
+export declare class FileOAuthProvider implements OAuthClientProvider {
+    readonly server: CapletServerConfig;
+    readonly redirectUrl: string;
+    private readonly onRedirect;
+    private readonly authDir?;
+    private verifier;
+    private readonly stateValue;
+    private clientInfo?;
+    readonly clientMetadataUrl?: string;
+    constructor(server: CapletServerConfig, redirectUrl: string, onRedirect: (url: URL) => void, authDir?: string | undefined);
+    get clientMetadata(): OAuthClientMetadata;
+    state(): string;
+    clientInformation(): OAuthClientInformationMixed | undefined;
+    saveClientInformation(clientInformation: OAuthClientInformationMixed): void;
+    tokens(): OAuthTokens | undefined;
+    saveTokens(tokens: OAuthTokens): void;
+    redirectToAuthorization(authorizationUrl: URL): void;
+    saveCodeVerifier(codeVerifier: string): void;
+    codeVerifier(): string;
+    addClientAuthentication: (headers: Headers, params: URLSearchParams) => Promise<void>;
+}
+export declare function runOAuthFlow(server: CapletServerConfig, options?: {
+    noOpen?: boolean;
+    authDir?: string;
+    manualInput?: string;
+    readManualInput?: () => Promise<string | undefined>;
+    open?: (url: string) => Promise<void>;
+    print?: (line: string) => void;
+}): Promise<AuthResult>;
+export declare function runGenericOAuthFlow(target: GenericAuthTarget, options?: {
+    noOpen?: boolean;
+    authDir?: string;
+    manualInput?: string;
+    readManualInput?: () => Promise<string | undefined>;
+    open?: (url: string) => Promise<void>;
+    print?: (line: string) => void;
+}): Promise<StoredOAuthTokenBundle>;
+export declare function extractCompletion(input: string): {
+    code: string;
+    state?: string;
+};
+export declare function classifyRemoteAuthError(server: CapletServerConfig, response: Response): CapletsError | undefined;
+export declare function pkceChallenge(verifier: string): string;

package/dist/capability-description.d.ts

@@ -0,0 +1,2 @@
+import type { CapletConfig } from "./config";
+export declare function capabilityDescription(server: CapletConfig): string;

package/dist/caplet-files.d.ts

@@ -0,0 +1,266 @@
+import { z } from "zod";
+export declare const capletFileSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mcpServer: z.ZodOptional<z.ZodObject<{
+        transport: z.ZodOptional<z.ZodEnum<{
+            stdio: "stdio";
+            http: "http";
+            sse: "sse";
+        }>>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        cwd: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        auth: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"none">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"bearer">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"headers">;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"oauth2">;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            tokenUrl: z.ZodOptional<z.ZodString>;
+            issuer: z.ZodOptional<z.ZodString>;
+            resourceMetadataUrl: z.ZodOptional<z.ZodString>;
+            authorizationServerMetadataUrl: z.ZodOptional<z.ZodString>;
+            openidConfigurationUrl: z.ZodOptional<z.ZodString>;
+            clientMetadataUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientSecret: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            redirectUri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"oidc">;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            tokenUrl: z.ZodOptional<z.ZodString>;
+            issuer: z.ZodOptional<z.ZodString>;
+            resourceMetadataUrl: z.ZodOptional<z.ZodString>;
+            authorizationServerMetadataUrl: z.ZodOptional<z.ZodString>;
+            openidConfigurationUrl: z.ZodOptional<z.ZodString>;
+            clientMetadataUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientSecret: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            redirectUri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">>;
+        startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        callTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        toolCacheTtlMs: z.ZodOptional<z.ZodNumber>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    openapiEndpoint: z.ZodOptional<z.ZodObject<{
+        specPath: z.ZodOptional<z.ZodString>;
+        specUrl: z.ZodOptional<z.ZodString>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        auth: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"none">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"bearer">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"headers">;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"oauth2">;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            tokenUrl: z.ZodOptional<z.ZodString>;
+            issuer: z.ZodOptional<z.ZodString>;
+            resourceMetadataUrl: z.ZodOptional<z.ZodString>;
+            authorizationServerMetadataUrl: z.ZodOptional<z.ZodString>;
+            openidConfigurationUrl: z.ZodOptional<z.ZodString>;
+            clientMetadataUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientSecret: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            redirectUri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"oidc">;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            tokenUrl: z.ZodOptional<z.ZodString>;
+            issuer: z.ZodOptional<z.ZodString>;
+            resourceMetadataUrl: z.ZodOptional<z.ZodString>;
+            authorizationServerMetadataUrl: z.ZodOptional<z.ZodString>;
+            openidConfigurationUrl: z.ZodOptional<z.ZodString>;
+            clientMetadataUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientSecret: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            redirectUri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">;
+        requestTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        operationCacheTtlMs: z.ZodOptional<z.ZodNumber>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    graphqlEndpoint: z.ZodOptional<z.ZodObject<{
+        endpointUrl: z.ZodString;
+        schemaPath: z.ZodOptional<z.ZodString>;
+        schemaUrl: z.ZodOptional<z.ZodString>;
+        introspection: z.ZodOptional<z.ZodLiteral<true>>;
+        operations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            document: z.ZodOptional<z.ZodString>;
+            documentPath: z.ZodOptional<z.ZodString>;
+            operationName: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        auth: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"none">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"bearer">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"headers">;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"oauth2">;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            tokenUrl: z.ZodOptional<z.ZodString>;
+            issuer: z.ZodOptional<z.ZodString>;
+            resourceMetadataUrl: z.ZodOptional<z.ZodString>;
+            authorizationServerMetadataUrl: z.ZodOptional<z.ZodString>;
+            openidConfigurationUrl: z.ZodOptional<z.ZodString>;
+            clientMetadataUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientSecret: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            redirectUri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"oidc">;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            tokenUrl: z.ZodOptional<z.ZodString>;
+            issuer: z.ZodOptional<z.ZodString>;
+            resourceMetadataUrl: z.ZodOptional<z.ZodString>;
+            authorizationServerMetadataUrl: z.ZodOptional<z.ZodString>;
+            openidConfigurationUrl: z.ZodOptional<z.ZodString>;
+            clientMetadataUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientSecret: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            redirectUri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">;
+        requestTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        operationCacheTtlMs: z.ZodOptional<z.ZodNumber>;
+        selectionDepth: z.ZodOptional<z.ZodNumber>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    httpApi: z.ZodOptional<z.ZodObject<{
+        baseUrl: z.ZodString;
+        auth: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"none">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"bearer">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"headers">;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"oauth2">;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            tokenUrl: z.ZodOptional<z.ZodString>;
+            issuer: z.ZodOptional<z.ZodString>;
+            resourceMetadataUrl: z.ZodOptional<z.ZodString>;
+            authorizationServerMetadataUrl: z.ZodOptional<z.ZodString>;
+            openidConfigurationUrl: z.ZodOptional<z.ZodString>;
+            clientMetadataUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientSecret: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            redirectUri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"oidc">;
+            authorizationUrl: z.ZodOptional<z.ZodString>;
+            tokenUrl: z.ZodOptional<z.ZodString>;
+            issuer: z.ZodOptional<z.ZodString>;
+            resourceMetadataUrl: z.ZodOptional<z.ZodString>;
+            authorizationServerMetadataUrl: z.ZodOptional<z.ZodString>;
+            openidConfigurationUrl: z.ZodOptional<z.ZodString>;
+            clientMetadataUrl: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientSecret: z.ZodOptional<z.ZodString>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            redirectUri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">;
+        actions: z.ZodRecord<z.ZodString, z.ZodObject<{
+            method: z.ZodEnum<{
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+            }>;
+            path: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            jsonBody: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>>;
+        requestTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxResponseBytes: z.ZodOptional<z.ZodNumber>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    cliTools: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            maxOutputBytes: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodObject<{
+                type: z.ZodOptional<z.ZodEnum<{
+                    text: "text";
+                    json: "json";
+                }>>;
+            }, z.core.$strict>>;
+            annotations: z.ZodOptional<z.ZodObject<{
+                readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+                destructiveHint: z.ZodOptional<z.ZodBoolean>;
+                idempotentHint: z.ZodOptional<z.ZodBoolean>;
+                openWorldHint: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        cwd: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxOutputBytes: z.ZodOptional<z.ZodNumber>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    capletSet: z.ZodOptional<z.ZodObject<{
+        configPath: z.ZodOptional<z.ZodString>;
+        capletsRoot: z.ZodOptional<z.ZodString>;
+        defaultSearchLimit: z.ZodOptional<z.ZodNumber>;
+        maxSearchLimit: z.ZodOptional<z.ZodNumber>;
+        toolCacheTtlMs: z.ZodOptional<z.ZodNumber>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare function capletJsonSchema(): unknown;
+export type CapletFileConfig = {
+    mcpServers?: Record<string, unknown>;
+    openapiEndpoints?: Record<string, unknown>;
+    graphqlEndpoints?: Record<string, unknown>;
+    httpApis?: Record<string, unknown>;
+    cliTools?: Record<string, unknown>;
+    capletSets?: Record<string, unknown>;
+};
+export type CapletFileLoadResult = {
+    config: CapletFileConfig;
+    paths: Record<string, string>;
+};
+export declare function loadCapletFiles(root: string): CapletFileConfig | undefined;
+export declare function loadCapletFilesWithPaths(root: string): CapletFileLoadResult | undefined;
+export declare function discoverCapletFiles(root: string): Array<{
+    id: string;
+    path: string;
+}>;
+export declare function validateCapletFile(path: string): void;

package/dist/caplet-sets.d.ts

@@ -0,0 +1,33 @@
+import type { CompatibilityCallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
+import { type CapletSetConfig } from "./config";
+import { type CompactTool } from "./downstream";
+import { ServerRegistry } from "./registry";
+export declare class CapletSetManager {
+    private registry;
+    private readonly options;
+    private readonly children;
+    private readonly childRefreshLocks;
+    constructor(registry: ServerRegistry, options?: {
+        authDir?: string;
+        ancestry?: Set<string>;
+    });
+    updateRegistry(registry: ServerRegistry): void;
+    invalidate(serverId: string): void;
+    close(): Promise<void>;
+    checkSet(config: CapletSetConfig): Promise<{
+        id: string;
+        status: string;
+        toolCount?: number;
+        elapsedMs: number;
+        error?: unknown;
+    }>;
+    listTools(config: CapletSetConfig): Promise<Tool[]>;
+    getTool(config: CapletSetConfig, toolName: string): Promise<Tool>;
+    callTool(config: CapletSetConfig, toolName: string, args: Record<string, unknown>): Promise<CompatibilityCallToolResult>;
+    compact(config: CapletSetConfig, tool: Tool): CompactTool;
+    search(config: CapletSetConfig, tools: Tool[], query: string, limit: number): CompactTool[];
+    private childRuntime;
+    private loadChildRuntime;
+    private closeChild;
+    private toTool;
+}

package/dist/cli/add.d.ts

@@ -0,0 +1,62 @@
+type AddCliOptions = {
+    repo?: string;
+    include?: string;
+    command?: string;
+    output?: string;
+    print?: boolean;
+    force?: boolean;
+    destinationRoot: string;
+};
+type AddDestinationOptions = {
+    output?: string;
+    print?: boolean;
+    force?: boolean;
+    destinationRoot: string;
+};
+type AddMcpOptions = AddDestinationOptions & {
+    command?: string;
+    arg?: string[];
+    cwd?: string;
+    env?: string[];
+    url?: string;
+    transport?: string;
+    tokenEnv?: string;
+};
+type AddOpenApiOptions = AddDestinationOptions & {
+    spec?: string;
+    baseUrl?: string;
+    tokenEnv?: string;
+};
+type AddGraphqlOptions = AddDestinationOptions & {
+    endpointUrl?: string;
+    schema?: string;
+    introspection?: boolean;
+    tokenEnv?: string;
+};
+type AddHttpOptions = AddDestinationOptions & {
+    baseUrl?: string;
+    action?: string[];
+    tokenEnv?: string;
+};
+export declare function addCliCaplet(id: string, options: AddCliOptions): {
+    path?: string;
+    text: string;
+};
+export declare function addMcpCaplet(id: string, options: AddMcpOptions): {
+    path?: string;
+    text: string;
+};
+export declare function addOpenApiCaplet(id: string, options: AddOpenApiOptions): {
+    path?: string;
+    text: string;
+};
+export declare function addGraphqlCaplet(id: string, options: AddGraphqlOptions): {
+    path?: string;
+    text: string;
+};
+export declare function addHttpCaplet(id: string, options: AddHttpOptions): {
+    path?: string;
+    text: string;
+};
+export declare function assertValidCapletId(id: string): void;
+export {};

package/dist/cli/auth.d.ts

@@ -0,0 +1,20 @@
+type AuthListFormat = "plain" | "markdown" | "json";
+export declare function loginAuth(serverId: string, options: {
+    configPath?: string;
+    noOpen: boolean;
+    writeOut: (value: string) => void;
+    writeErr: (value: string) => void;
+    authDir?: string;
+}): Promise<void>;
+export declare function logoutAuth(serverId: string, options: {
+    authDir?: string;
+    configPath?: string;
+    writeOut: (value: string) => void;
+}): void;
+export declare function listAuth(options: {
+    authDir?: string;
+    configPath?: string;
+    writeOut: (value: string) => void;
+    format?: AuthListFormat;
+}): void;
+export {};

package/dist/cli/author.d.ts

@@ -0,0 +1,11 @@
+type AuthorCliOptions = {
+    repo?: string;
+    include?: string;
+    command?: string;
+    output?: string;
+};
+export declare function authorCliCaplet(id: string, options?: AuthorCliOptions): {
+    path?: string;
+    text: string;
+};
+export {};

package/dist/cli/init.d.ts

@@ -0,0 +1,5 @@
+export declare function initConfig(options?: {
+    path?: string;
+    force?: boolean;
+}): string;
+export declare function starterConfig(): string;

package/dist/cli/inspection.d.ts

@@ -0,0 +1,30 @@
+import { type CapletConfig, type ConfigSource, type ConfigWithSources } from "../config";
+import type { ServerStatus } from "../registry";
+type CapletListRow = {
+    server: string;
+    backend: CapletConfig["backend"];
+    name: string;
+    description: string;
+    disabled: boolean;
+    status: ServerStatus;
+    source: ConfigSource["kind"] | "unknown";
+    path: string | null;
+    shadows: ConfigSource[];
+};
+type ConfigPaths = {
+    userConfig: string;
+    projectConfig: string;
+    userRoot: string;
+    stateRoot: string;
+    projectRoot: string;
+    authDir: string;
+    envConfig: string | null;
+};
+export declare function listCaplets(configWithSources: ConfigWithSources, options: {
+    includeDisabled: boolean;
+}): CapletListRow[];
+type CliOutputFormat = "markdown" | "plain" | "json";
+export declare function formatCapletList(rows: CapletListRow[], format?: Exclude<CliOutputFormat, "json">): string;
+export declare function resolveCliConfigPaths(envConfigPath: string | undefined, authDir?: string): ConfigPaths;
+export declare function formatConfigPaths(paths: ConfigPaths, format?: Exclude<CliOutputFormat, "json">): string;
+export {};

package/dist/cli/install.d.ts

@@ -0,0 +1,15 @@
+type InstallableCaplet = {
+    id: string;
+    source: string;
+    destination: string;
+    kind: "file" | "directory";
+};
+export declare function installCaplets(repo: string, options?: {
+    capletIds?: string[];
+    destinationRoot?: string;
+    force?: boolean;
+}): {
+    installed: InstallableCaplet[];
+};
+export declare function normalizeGitRepo(repo: string): string;
+export {};

package/dist/cli-tools.d.ts

@@ -0,0 +1,23 @@
+import type { CompatibilityCallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { CliToolsConfig } from "./config";
+import type { CompactTool } from "./downstream";
+import type { ServerRegistry } from "./registry";
+export declare class CliToolsManager {
+    private registry;
+    constructor(registry: ServerRegistry);
+    updateRegistry(registry: ServerRegistry): void;
+    invalidate(_serverId: string): void;
+    checkTools(config: CliToolsConfig): Promise<{
+        id: string;
+        status: string;
+        toolCount?: number;
+        elapsedMs: number;
+        error?: unknown;
+    }>;
+    listTools(config: CliToolsConfig): Promise<Tool[]>;
+    getTool(config: CliToolsConfig, toolName: string): Promise<Tool>;
+    callTool(config: CliToolsConfig, toolName: string, args: Record<string, unknown>): Promise<CompatibilityCallToolResult>;
+    compact(config: CliToolsConfig, tool: Tool): CompactTool;
+    search(config: CliToolsConfig, tools: Tool[], query: string, limit: number): CompactTool[];
+    private toTool;
+}

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "commander";
+export { initConfig, starterConfig } from "./cli/init";
+export { installCaplets, normalizeGitRepo } from "./cli/install";
+export { addCliCaplet, addGraphqlCaplet, addHttpCaplet, addMcpCaplet, addOpenApiCaplet, } from "./cli/add";
+type CliIO = {
+    writeOut?: (value: string) => void;
+    writeErr?: (value: string) => void;
+    authDir?: string;
+    version?: string;
+    setExitCode?: (code: number) => void;
+};
+export declare function runCli(args: string[], io?: CliIO): Promise<void>;
+export declare function createProgram(io?: CliIO): Command;

package/dist/config/paths.d.ts

@@ -0,0 +1,14 @@
+type Platform = NodeJS.Platform;
+type PathEnv = NodeJS.ProcessEnv;
+export declare function defaultConfigBaseDir(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultStateBaseDir(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultConfigPath(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultAuthDir(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare const DEFAULT_CONFIG_PATH: string;
+export declare const DEFAULT_AUTH_DIR: string;
+export declare const PROJECT_CONFIG_FILE: string;
+export declare function resolveConfigPath(path?: string): string;
+export declare function resolveProjectConfigPath(cwd?: string): string;
+export declare function resolveCapletsRoot(configPath?: string): string;
+export declare function resolveProjectCapletsRoot(cwd?: string): string;
+export {};

package/dist/config/validation.d.ts

@@ -0,0 +1,16 @@
+export declare const SERVER_ID_PATTERN: RegExp;
+export declare const HEADER_NAME_PATTERN: RegExp;
+export declare const HTTP_BASE_URL_PATTERN: RegExp;
+export declare const FORBIDDEN_HEADERS: Set<string>;
+type ValidationIssueSink = {
+    addIssue(issue: {
+        code: "custom";
+        path: Array<string>;
+        message: string;
+    }): void;
+};
+export declare function validateHttpActionHeaders(headers: Record<string, unknown>, ctx: ValidationIssueSink, path: Array<string>): void;
+export declare function isAllowedRemoteUrl(value: string): boolean;
+export declare function isAllowedHttpBaseUrl(value: string): boolean;
+export declare function isUrl(value: string): boolean;
+export {};