@caplets/core 0.16.0 → 0.18.0

package/dist/remote-control/auth-flow.d.ts

@@ -0,0 +1,22 @@
+export type RemoteAuthFlow = {
+    id: string;
+    server: string;
+    authorizationUrl: string;
+    createdAt: number;
+    complete(callbackUrl: string): Promise<void>;
+};
+export type RemoteAuthFlowStoreOptions = {
+    ttlMs?: number;
+    now?: () => number;
+};
+export declare class RemoteAuthFlowStore {
+    private readonly options;
+    private readonly flows;
+    constructor(options?: RemoteAuthFlowStoreOptions);
+    create(flow: Omit<RemoteAuthFlow, "id" | "createdAt">, id?: string): RemoteAuthFlow;
+    get(id: string): RemoteAuthFlow | undefined;
+    delete(id: string): void;
+    private pruneExpired;
+    private isExpired;
+    private now;
+}

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

@@ -0,0 +1,11 @@
+import type { RemoteCliCommand, RemoteCliRequest } from "./types";
+export type RemoteControlClientOptions = {
+    baseUrl: URL;
+    requestInit: RequestInit;
+    fetch?: typeof fetch;
+};
+export declare class RemoteControlClient {
+    #private;
+    constructor(options: RemoteControlClientOptions);
+    request(command: RemoteCliCommand, args: RemoteCliRequest["arguments"]): Promise<unknown>;
+}

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

@@ -0,0 +1,9 @@
+import { type CapletsEngineOptions } from "../engine";
+import type { RemoteAuthFlowStore } from "./auth-flow";
+import type { RemoteCliRequest, RemoteCliResponse } from "./types";
+export type RemoteControlDispatchContext = CapletsEngineOptions & {
+    projectCapletsRoot: string;
+    authFlowStore?: RemoteAuthFlowStore;
+    controlCallbackBaseUrl?: string;
+};
+export declare function dispatchRemoteCliRequest(request: RemoteCliRequest, context: RemoteControlDispatchContext): Promise<RemoteCliResponse>;

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

@@ -0,0 +1,17 @@
+import type { CapletsErrorCode } from "../errors";
+export type RemoteCliCommand = "list" | "get_caplet" | "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" | "init" | "add" | "install" | "complete_cli" | "auth_login_start" | "auth_login_complete" | "auth_logout" | "auth_list";
+export type RemoteCliRequest = {
+    command: RemoteCliCommand;
+    arguments: Record<string, unknown>;
+};
+export type RemoteCliResponse = {
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    error: {
+        code: CapletsErrorCode;
+        message: string;
+        nextAction?: string;
+    };
+};

package/dist/serve/http.d.ts

@@ -1,12 +1,23 @@
 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 type { HttpServeOptions } from "./options";
 type HttpServeIo = {
     writeErr?: (value: string) => void;
+    control?: Omit<RemoteControlDispatchContext, "writeErr">;
+    authFlowStore?: RemoteAuthFlowStore;
 };
 export type CapletsHttpApp = Hono & {
     closeCapletsSessions: () => Promise<void>;
 };
 export declare function createHttpServeApp(options: HttpServeOptions, engine: CapletsEngine, io?: HttpServeIo): CapletsHttpApp;
 export declare function serveHttp(options: HttpServeOptions, engineOptions?: CapletsEngineOptions, writeErr?: (value: string) => void): Promise<void>;
+export declare function routePath(base: string, path: string): string;
+export declare function servicePaths(base: string): {
+    base: string;
+    mcp: string;
+    control: string;
+    health: string;
+};
 export {};

package/dist/serve/options.d.ts

@@ -7,6 +7,7 @@ export type RawServeOptions = {
     user?: string;
     password?: string;
     allowUnauthenticatedHttp?: boolean;
+    trustProxy?: boolean;
 };
 export type StdioServeOptions = {
     transport: "stdio";
@@ -19,6 +20,7 @@ export type HttpServeOptions = {
     auth: HttpBasicAuthOptions;
     warnUnauthenticatedNetwork: boolean;
     loopback: boolean;
+    trustProxy: boolean;
 };
 export type HttpBasicAuthOptions = {
     enabled: false;
@@ -29,6 +31,6 @@ export type HttpBasicAuthOptions = {
     password: string;
 };
 export type ServeOptions = StdioServeOptions | HttpServeOptions;
-export type ServeEnv = Partial<Record<"CAPLETS_SERVER_USER" | "CAPLETS_SERVER_PASSWORD", string>>;
+export type ServeEnv = Partial<Record<"CAPLETS_SERVER_URL" | "CAPLETS_SERVER_USER" | "CAPLETS_SERVER_PASSWORD", string>>;
 export declare function resolveServeOptions(raw: RawServeOptions, env?: ServeEnv): ServeOptions;
 export declare function isLoopbackHost(host: string): boolean;

package/dist/server/options.d.ts

@@ -0,0 +1,41 @@
+export type CapletsMode = "auto" | "local" | "remote";
+export type CapletsServerEnv = Partial<Record<"CAPLETS_MODE" | "CAPLETS_SERVER_URL" | "CAPLETS_SERVER_USER" | "CAPLETS_SERVER_PASSWORD", 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;
+};
+export type ResolvedCapletsServer = {
+    baseUrl: URL;
+    mcpUrl: URL;
+    controlUrl: URL;
+    healthUrl: URL;
+    auth: CapletsServerAuth;
+    requestInit: RequestInit;
+    fetch?: typeof fetch;
+};
+export declare function resolveCapletsMode(input?: CapletsModeInput, env?: CapletsServerEnv): {
+    mode: "local";
+} | {
+    mode: "remote";
+};
+export declare function resolveCapletsServer(input?: CapletsServerInput, env?: CapletsServerEnv): ResolvedCapletsServer;
+export declare function mcpUrlForBase(baseUrl: URL): URL;
+export declare function controlUrlForBase(baseUrl: URL): URL;
+export declare function healthUrlForBase(baseUrl: URL): URL;
+export declare function appendBasePath(baseUrl: URL, path: string): URL;
+export declare function parseServerBaseUrl(value: string): URL;
+export declare function isLoopbackHost(host: string): boolean;

package/dist/tools.d.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import type { CapletSetManager } from "./caplet-sets";
 import type { CapletConfig } from "./config";
@@ -8,24 +7,10 @@ import type { GraphQLManager } from "./graphql";
 import type { HttpActionManager } from "./http-actions";
 import type { OpenApiManager } from "./openapi";
 import type { ServerRegistry } from "./registry";
-export declare const generatedToolInputSchema: z.ZodObject<{
-    operation: z.ZodEnum<{
-        get_caplet: "get_caplet";
-        check_backend: "check_backend";
-        list_tools: "list_tools";
-        search_tools: "search_tools";
-        get_tool: "get_tool";
-        call_tool: "call_tool";
-    }>;
-    query: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    tool: z.ZodOptional<z.ZodString>;
-    arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export type GeneratedServerToolRequest = z.infer<typeof generatedToolInputSchema>;
+export { generatedToolInputSchema } from "./generated-tool-input-schema";
+export type GeneratedServerToolRequest = RequiredOperationRequest;
 export declare function handleServerTool(server: CapletConfig, request: unknown, registry: ServerRegistry, downstream: DownstreamManager, openapi?: OpenApiManager, graphql?: GraphQLManager, http?: HttpActionManager, cli?: CliToolsManager, caplets?: CapletSetManager): Promise<any>;
-export declare function validateOperationRequest(request: unknown, maxSearchLimit: number): RequiredOperationRequest;
+export declare function validateOperationRequest(request: unknown, maxSearchLimit: number, backend?: string): RequiredOperationRequest;
 type RequiredOperationRequest = {
     operation: "get_caplet" | "check_backend";
 } | {
@@ -43,6 +28,33 @@ type RequiredOperationRequest = {
     tool: string;
     arguments: Record<string, unknown>;
     fields?: string[];
+} | {
+    operation: "list_resources" | "list_resource_templates" | "list_prompts";
+    limit?: number;
+} | {
+    operation: "search_resources" | "search_prompts";
+    query: string;
+    limit?: number;
+} | {
+    operation: "read_resource";
+    uri: string;
+} | {
+    operation: "get_prompt";
+    prompt: string;
+    arguments: Record<string, unknown>;
+} | {
+    operation: "complete";
+    ref: {
+        type: "prompt";
+        name: string;
+    } | {
+        type: "resourceTemplate";
+        uri: string;
+    };
+    argument: {
+        name: string;
+        value: string;
+    };
 };
 export type CapletArtifact = {
     kind: "screenshot" | "snapshot" | "console-log" | "network-log" | "file";
@@ -55,13 +67,19 @@ export type CapletResultMetadata = {
     backend: string;
     operation: RequiredOperationRequest["operation"];
     tool?: string;
+    uri?: string;
+    prompt?: string;
     status: "ok" | "error";
     elapsedMs?: number;
     artifacts?: CapletArtifact[];
 };
-export declare function metadataFor(server: CapletConfig, operation: RequiredOperationRequest["operation"], tool?: string, startedAt?: number): CapletResultMetadata;
+export declare function metadataFor(server: CapletConfig, operation: RequiredOperationRequest["operation"], target?: string | {
+    tool?: string;
+    uri?: string;
+    prompt?: string;
+}, startedAt?: number): CapletResultMetadata;
+export declare function annotateMcpResult<T extends object>(result: T, metadata: CapletResultMetadata): T;
 export declare function jsonResult(value: unknown, metadata?: CapletResultMetadata): CallToolResult;
 export declare function annotateCallToolResult<T extends object>(result: T, metadata: CapletResultMetadata): T & CallToolResult;
 export declare function projectCallToolResult<T extends object>(result: T, outputSchema: unknown, fields: string[]): T & CallToolResult;
 export declare function extractArtifacts(result: unknown): CapletArtifact[];
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caplets/core",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Core runtime library for Caplets progressive disclosure gateways.",
   "keywords": [
     "caplets",