@caplets/core 0.15.0 → 0.17.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" | "init" | "add" | "install" | "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/runtime.d.ts

@@ -1,7 +1,6 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { type CapletsConfig } from "./config";
-type ToolServer = Pick<McpServer, "registerTool" | "connect" | "close">;
+import type { CapletsConfig } from "./config";
+import { type ToolServer } from "./serve/session";
 type CapletsRuntimeOptions = {
     configPath?: string;
     projectConfigPath?: string;
@@ -13,8 +12,7 @@ type CapletsRuntimeOptions = {
 export declare class CapletsRuntime {
     readonly server: ToolServer;
     private readonly engine;
-    private readonly tools;
-    private readonly unsubscribeReload;
+    private readonly session;
     constructor(options?: CapletsRuntimeOptions);
     connect(transport: Transport): Promise<void>;
     scheduleReload(): void;
@@ -23,8 +21,5 @@ export declare class CapletsRuntime {
     currentConfig(): CapletsConfig;
     registeredToolIds(): string[];
     watchedPaths(): string[];
-    private reconcileTools;
-    private registerCapletTool;
-    private handleTool;
 }
 export {};

package/dist/serve/http.d.ts

@@ -0,0 +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/index.d.ts

@@ -0,0 +1,14 @@
+import type { CapletsEngineOptions } from "../engine";
+import { type RawServeOptions, type ServeOptions } from "./options";
+export { serveHttp } from "./http";
+export { resolveServeOptions } from "./options";
+export type { HttpServeOptions, RawServeOptions, ServeOptions, StdioServeOptions } from "./options";
+export { serveStdio } from "./stdio";
+export type ServeCapletsOptions = {
+    raw: RawServeOptions;
+    engine?: CapletsEngineOptions;
+    env?: NodeJS.ProcessEnv;
+    writeErr?: (value: string) => void;
+};
+export declare function serveCaplets(options: ServeCapletsOptions): Promise<void>;
+export declare function serveResolvedCaplets(resolved: ServeOptions, engineOptions?: CapletsEngineOptions, writeErr?: (value: string) => void): Promise<void>;

package/dist/serve/options.d.ts

@@ -0,0 +1,36 @@
+export type ServeTransport = "stdio" | "http";
+export type RawServeOptions = {
+    transport?: string;
+    host?: string;
+    port?: string | number;
+    path?: string;
+    user?: string;
+    password?: string;
+    allowUnauthenticatedHttp?: boolean;
+    trustProxy?: boolean;
+};
+export type StdioServeOptions = {
+    transport: "stdio";
+};
+export type HttpServeOptions = {
+    transport: "http";
+    host: string;
+    port: number;
+    path: string;
+    auth: HttpBasicAuthOptions;
+    warnUnauthenticatedNetwork: boolean;
+    loopback: boolean;
+    trustProxy: boolean;
+};
+export type HttpBasicAuthOptions = {
+    enabled: false;
+    user: string;
+} | {
+    enabled: true;
+    user: string;
+    password: string;
+};
+export type ServeOptions = StdioServeOptions | HttpServeOptions;
+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/serve/session.d.ts

@@ -0,0 +1,21 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { CapletsEngine } from "../engine";
+export type ToolServer = Pick<McpServer, "registerTool" | "connect" | "close">;
+export type CapletsMcpSessionOptions = {
+    server?: ToolServer;
+};
+export declare class CapletsMcpSession {
+    private readonly engine;
+    readonly server: ToolServer;
+    private readonly tools;
+    private readonly unsubscribeReload;
+    private closed;
+    constructor(engine: CapletsEngine, options?: CapletsMcpSessionOptions);
+    connect(transport: Transport): Promise<void>;
+    registeredToolIds(): string[];
+    close(): Promise<void>;
+    private reconcileTools;
+    private registerCapletTool;
+    private handleTool;
+}

package/dist/serve/stdio.d.ts

@@ -0,0 +1,5 @@
+import { type CapletsEngineOptions } from "../engine";
+export type ServeStdioOptions = CapletsEngineOptions & {
+    signalHandling?: boolean;
+};
+export declare function serveStdio(options?: ServeStdioOptions): Promise<void>;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caplets/core",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "Core runtime library for Caplets progressive disclosure gateways.",
   "keywords": [
     "caplets",
@@ -45,9 +45,12 @@
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^12.1.0",
+    "@hono/mcp": "^0.3.0",
+    "@hono/node-server": "^1.19.14",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "commander": "^14.0.3",
     "graphql": "^16.14.0",
+    "hono": "^4.12.19",
     "vfile": "^6.0.3",
     "vfile-matter": "^5.0.1",
     "zod": "^4.4.3"