@caplets/core 0.18.9 → 0.20.0

package/dist/{generated-tool-input-schema--kVuUNc5.js → schemas-BZ6BBrh7.js}

@@ -4557,164 +4557,4 @@ function preprocess(fn, schema) {
 	});
 }
 //#endregion
-//#region src/generated-tool-input-schema.ts
-const operations = [
-	"inspect",
-	"check_backend",
-	"list_tools",
-	"search_tools",
-	"get_tool",
-	"call_tool"
-];
-const mcpOperations = [
-	...operations,
-	"list_resources",
-	"search_resources",
-	"list_resource_templates",
-	"read_resource",
-	"list_prompts",
-	"search_prompts",
-	"get_prompt",
-	"complete"
-];
-const generatedToolInputDescriptions = {
-	operation: "Wrapper operation: inspect, check_backend, list_tools, search_tools, get_tool, call_tool. MCP Caplets also expose resources, prompts, and completions.",
-	query: "Required for search operations only.",
-	limit: "Optional list/search result limit.",
-	tool: "Exact downstream tool name for get_tool or call_tool.",
-	arguments: "JSON object for call_tool arguments/downstream inputs or get_prompt arguments.",
-	fields: "Optional call_tool structured output paths when outputSchema allows it.",
-	uri: "Exact downstream resource URI for read_resource.",
-	prompt: "Exact downstream prompt name for get_prompt.",
-	ref: "Completion target reference for complete.",
-	argument: "Completion argument object for complete."
-};
-const completionRefSchema = union([object({
-	type: literal("prompt"),
-	name: string().min(1)
-}).strict(), object({
-	type: literal("resourceTemplate"),
-	uri: string().min(1)
-}).strict()]);
-const completionArgumentSchema = object({
-	name: string().min(1),
-	value: string()
-}).strict();
-const baseShape = {
-	query: string().optional().describe(generatedToolInputDescriptions.query),
-	limit: number().int().positive().optional().describe(generatedToolInputDescriptions.limit),
-	tool: string().optional().describe(generatedToolInputDescriptions.tool),
-	arguments: object({}).catchall(any()).optional().describe(generatedToolInputDescriptions.arguments),
-	fields: array(string().min(1)).min(1).optional().describe(generatedToolInputDescriptions.fields)
-};
-function generatedToolInputSchemaForCaplet(caplet) {
-	return object({
-		operation: (caplet.backend === "mcp" ? _enum(mcpOperations) : _enum(operations)).describe(generatedToolInputDescriptions.operation),
-		...baseShape,
-		...caplet.backend === "mcp" ? {
-			uri: string().optional().describe(generatedToolInputDescriptions.uri),
-			prompt: string().optional().describe(generatedToolInputDescriptions.prompt),
-			ref: completionRefSchema.optional().describe(generatedToolInputDescriptions.ref),
-			argument: completionArgumentSchema.optional().describe(generatedToolInputDescriptions.argument)
-		} : {}
-	}).strict();
-}
-const generatedToolInputSchema = object({
-	operation: _enum(operations).describe(generatedToolInputDescriptions.operation),
-	...baseShape
-}).strict();
-function generatedToolInputJsonSchemaForCaplet(caplet) {
-	const mcp = caplet.backend === "mcp";
-	return {
-		type: "object",
-		properties: {
-			operation: {
-				type: "string",
-				enum: mcp ? mcpOperations : operations,
-				description: generatedToolInputDescriptions.operation
-			},
-			query: {
-				type: "string",
-				description: generatedToolInputDescriptions.query
-			},
-			limit: {
-				type: "integer",
-				minimum: 1,
-				description: generatedToolInputDescriptions.limit
-			},
-			tool: {
-				type: "string",
-				description: generatedToolInputDescriptions.tool
-			},
-			arguments: {
-				type: "object",
-				description: generatedToolInputDescriptions.arguments
-			},
-			fields: {
-				type: "array",
-				items: {
-					type: "string",
-					minLength: 1
-				},
-				minItems: 1,
-				description: generatedToolInputDescriptions.fields
-			},
-			...mcp ? {
-				uri: {
-					type: "string",
-					description: generatedToolInputDescriptions.uri
-				},
-				prompt: {
-					type: "string",
-					description: generatedToolInputDescriptions.prompt
-				},
-				ref: {
-					oneOf: [{
-						type: "object",
-						properties: {
-							type: { const: "prompt" },
-							name: {
-								type: "string",
-								minLength: 1
-							}
-						},
-						required: ["type", "name"],
-						additionalProperties: false
-					}, {
-						type: "object",
-						properties: {
-							type: { const: "resourceTemplate" },
-							uri: {
-								type: "string",
-								minLength: 1
-							}
-						},
-						required: ["type", "uri"],
-						additionalProperties: false
-					}],
-					description: generatedToolInputDescriptions.ref
-				},
-				argument: {
-					type: "object",
-					properties: {
-						name: {
-							type: "string",
-							minLength: 1
-						},
-						value: { type: "string" }
-					},
-					required: ["name", "value"],
-					additionalProperties: false,
-					description: generatedToolInputDescriptions.argument
-				}
-			} : {}
-		},
-		required: ["operation"],
-		additionalProperties: false
-	};
-}
-function generatedToolInputJsonSchema() {
-	return generatedToolInputJsonSchemaForCaplet({ backend: "tool" });
-}
-//#endregion
-export { url as A, clone as B, object as C, string as D, record as E, $ZodType as F, normalizeParams as H, parse$1 as I, parseAsync$1 as L, toJSONSchema as M, _coercedNumber as N, union as O, $ZodObject as P, safeParse$1 as R, number as S, preprocess as T, $constructor as U, defineLazy as V, NEVER as W, custom as _, generatedToolInputJsonSchemaForCaplet as a, literal as b, mcpOperations as c, ZodOptional as d, _enum as f, boolean as g, array as h, generatedToolInputJsonSchema as i, datetime as j, unknown as k, operations as l, any as m, completionRefSchema as n, generatedToolInputSchema as o, _null as p, generatedToolInputDescriptions as r, generatedToolInputSchemaForCaplet as s, completionArgumentSchema as t, ZodNumber as u, discriminatedUnion as v, optional as w, looseObject as x, intersection as y, safeParseAsync$1 as z };
+export { safeParseAsync$1 as A, toJSONSchema as C, parse$1 as D, $ZodType as E, NEVER as F, defineLazy as M, normalizeParams as N, parseAsync$1 as O, $constructor as P, datetime as S, $ZodObject as T, record as _, any as a, unknown as b, custom as c, literal as d, looseObject as f, preprocess as g, optional as h, _null as i, clone as j, safeParse$1 as k, discriminatedUnion as l, object as m, ZodOptional as n, array as o, number as p, _enum as r, boolean as s, ZodNumber as t, intersection as u, string as v, _coercedNumber as w, url as x, union as y };

package/dist/serve/daemon/config.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonCommandPlan, ServeDaemonConfig, ServeDaemonPaths, ServeDaemonState, ServeDaemonStatus } from "./types";
+export declare function readDaemonConfig(paths: ServeDaemonPaths): ServeDaemonConfig | undefined;
+export declare function writeDaemonConfig(paths: ServeDaemonPaths, serve: ServeDaemonConfig["serve"], command: DaemonCommandPlan, now?: Date): ServeDaemonConfig;
+export declare function readDaemonState(paths: ServeDaemonPaths): ServeDaemonState | undefined;
+export declare function writeDaemonState(paths: ServeDaemonPaths, state: Omit<ServeDaemonState, "instance" | "updatedAt"> & {
+    updatedAt?: string;
+}, now?: Date): ServeDaemonState;
+export declare function redactDaemonStatus(status: ServeDaemonStatus): ServeDaemonStatus;

package/dist/serve/daemon/index.d.ts

@@ -0,0 +1,16 @@
+import { type RawServeOptions } from "../options";
+import type { DaemonPlatformDescriptor, ServeDaemonOperationOptions, ServeDaemonOperationResult, ServeDaemonStatus } from "./types";
+export type ServeDaemonServiceResult = {
+    enabled: boolean;
+    descriptor: DaemonPlatformDescriptor;
+    status: ServeDaemonStatus;
+};
+export declare function startDaemon(raw?: RawServeOptions, options?: ServeDaemonOperationOptions): Promise<ServeDaemonOperationResult>;
+export declare function stopDaemon(options?: ServeDaemonOperationOptions): Promise<ServeDaemonOperationResult>;
+export declare function restartDaemon(raw?: RawServeOptions, options?: ServeDaemonOperationOptions): Promise<ServeDaemonOperationResult>;
+export declare function daemonStatus(options?: ServeDaemonOperationOptions): Promise<ServeDaemonStatus>;
+export declare function enableDaemon(options?: ServeDaemonOperationOptions): Promise<ServeDaemonServiceResult>;
+export declare function disableDaemon(options?: ServeDaemonOperationOptions): Promise<ServeDaemonServiceResult>;
+export { buildDaemonPlatformDescriptor } from "./platform";
+export { resolveServeDaemonPaths } from "./paths";
+export type { DaemonPlatformDescriptor, DaemonProcessRunner, ServeDaemonConfig, ServeDaemonOperationOptions, ServeDaemonPaths, ServeDaemonState, ServeDaemonStatus, } from "./types";

package/dist/serve/daemon/paths.d.ts

@@ -0,0 +1,3 @@
+import type { ServeDaemonOperationOptions, ServeDaemonPaths } from "./types";
+export declare function resolveServeDaemonPaths(options?: Pick<ServeDaemonOperationOptions, "env" | "home" | "platform">): ServeDaemonPaths;
+export declare function daemonServiceDescriptorPath(paths: ServeDaemonPaths, platform: NodeJS.Platform): string;

package/dist/serve/daemon/platform-darwin.d.ts

@@ -0,0 +1,2 @@
+import type { DaemonCommandPlan, LaunchdUserAgentDescriptor, ServeDaemonPaths } from "./types";
+export declare function buildLaunchdUserAgentDescriptor(paths: ServeDaemonPaths, command: DaemonCommandPlan): LaunchdUserAgentDescriptor;

package/dist/serve/daemon/platform-linux.d.ts

@@ -0,0 +1,2 @@
+import type { DaemonCommandPlan, ManualServiceDescriptor, ServeDaemonPaths, SystemdUserServiceDescriptor } from "./types";
+export declare function buildLinuxServiceDescriptor(paths: ServeDaemonPaths, command: DaemonCommandPlan, serviceAvailable?: boolean): SystemdUserServiceDescriptor | ManualServiceDescriptor;

package/dist/serve/daemon/platform-windows.d.ts

@@ -0,0 +1,2 @@
+import type { DaemonCommandPlan, WindowsScheduledTaskDescriptor } from "./types";
+export declare function buildWindowsScheduledTaskDescriptor(command: DaemonCommandPlan): WindowsScheduledTaskDescriptor;

package/dist/serve/daemon/platform.d.ts

@@ -0,0 +1,9 @@
+import type { DaemonCommandPlan, DaemonPlatformDescriptor, ServeDaemonPaths } from "./types";
+export type BuildDaemonPlatformDescriptorOptions = {
+    platform?: NodeJS.Platform;
+    serviceAvailable?: boolean;
+    paths: ServeDaemonPaths;
+    command: DaemonCommandPlan;
+};
+export declare function buildDaemonPlatformDescriptor(options: BuildDaemonPlatformDescriptorOptions): DaemonPlatformDescriptor;
+export declare function escapeXml(value: string): string;

package/dist/serve/daemon/process.d.ts

@@ -0,0 +1,5 @@
+import type { HttpServeOptions } from "../options";
+import type { DaemonCommandPlan, DaemonProcessRunner } from "./types";
+export declare function daemonServeCommand(options: HttpServeOptions): DaemonCommandPlan;
+export declare function daemonServeArgs(options: HttpServeOptions): string[];
+export declare function createNodeDaemonProcessRunner(): DaemonProcessRunner;

package/dist/serve/daemon/types.d.ts

@@ -0,0 +1,86 @@
+import type { HttpServeOptions, RawServeOptions } from "../options";
+export type ServeDaemonInstance = "default";
+export type ServeDaemonPaths = {
+    instance: ServeDaemonInstance;
+    stateDir: string;
+    logDir: string;
+    stateFile: string;
+    pidFile: string;
+    stdoutLog: string;
+    stderrLog: string;
+    configFile: string;
+};
+export type ServeDaemonConfig = {
+    instance: ServeDaemonInstance;
+    serve: HttpServeOptions;
+    command: DaemonCommandPlan;
+    paths: ServeDaemonPaths;
+    updatedAt: string;
+};
+export type ServeDaemonState = {
+    instance: ServeDaemonInstance;
+    running: boolean;
+    pid?: number;
+    startedAt?: string;
+    updatedAt: string;
+    enabled: boolean;
+};
+export type ServeDaemonStatus = ServeDaemonState & {
+    paths: ServeDaemonPaths;
+    config?: ServeDaemonConfig;
+};
+export type DaemonCommandPlan = {
+    executable: string;
+    args: string[];
+};
+export type DaemonProcessStart = {
+    args: string[];
+    stdoutLog: string;
+    stderrLog: string;
+    configFile: string;
+};
+export type DaemonProcessRunner = {
+    isRunning(pid: number): Promise<boolean>;
+    start(command: DaemonProcessStart): Promise<number>;
+    stop(pid: number): Promise<void>;
+};
+export type ServeDaemonOperationOptions = {
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    home?: string;
+    platform?: NodeJS.Platform;
+    process?: DaemonProcessRunner;
+    serviceAvailable?: boolean;
+};
+export type ServeDaemonStartOptions = ServeDaemonOperationOptions & {
+    raw?: RawServeOptions;
+};
+export type ServeDaemonOperationResult = {
+    status: ServeDaemonStatus;
+};
+export type LaunchdUserAgentDescriptor = {
+    kind: "launchd-user-agent";
+    label: string;
+    path: string;
+    plist: string;
+};
+export type SystemdUserServiceDescriptor = {
+    kind: "systemd-user";
+    unitName: string;
+    path: string;
+    unit: string;
+};
+export type ManualServiceDescriptor = {
+    kind: "manual";
+    reason: string;
+    command: DaemonCommandPlan;
+};
+export type WindowsScheduledTaskDescriptor = {
+    kind: "windows-scheduled-task";
+    taskName: string;
+    commands: {
+        register: string;
+        unregister: string;
+        query: string;
+    };
+};
+export type DaemonPlatformDescriptor = LaunchdUserAgentDescriptor | SystemdUserServiceDescriptor | ManualServiceDescriptor | WindowsScheduledTaskDescriptor;

package/dist/serve/http.d.ts

@@ -1,3 +1,4 @@
+import { StreamableHTTPTransport } from "@hono/mcp";
 import { Hono } from "hono";
 import { CapletsEngine, type CapletsEngineOptions } from "../engine";
 import { type RemoteControlDispatchContext } from "../remote-control/dispatch";
@@ -7,12 +8,19 @@ type HttpServeIo = {
     writeErr?: (value: string) => void;
     control?: Omit<RemoteControlDispatchContext, "writeErr">;
     authFlowStore?: RemoteAuthFlowStore;
+    sessionFactory?: HttpMcpSessionFactory;
 };
+type HttpMcpSession = {
+    connect(transport: StreamableHTTPTransport): Promise<void>;
+    close(): Promise<void>;
+};
+export type HttpMcpSessionFactory = () => HttpMcpSession | Promise<HttpMcpSession>;
 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 serveHttpWithSessionFactory(options: HttpServeOptions, createSession: HttpMcpSessionFactory, writeErr?: (value: string) => void): Promise<void>;
 export declare function routePath(base: string, path: string): string;
 export declare function servicePaths(base: string): {
     base: string;

package/dist/serve/index.d.ts

@@ -1,9 +1,13 @@
 import type { CapletsEngineOptions } from "../engine";
 import { type RawServeOptions, type ServeOptions } from "./options";
 export { serveHttp } from "./http";
-export { resolveServeOptions } from "./options";
+export { resolveDaemonServeOptions, resolveServeOptions } from "./options";
 export type { HttpServeOptions, RawServeOptions, ServeOptions, StdioServeOptions } from "./options";
+export { NativeCapletsMcpSession } from "./native-session";
+export type { NativeCapletsMcpSessionOptions, NativeToolServer } from "./native-session";
 export { serveStdio } from "./stdio";
+export { buildDaemonPlatformDescriptor, daemonStatus, disableDaemon, enableDaemon, resolveServeDaemonPaths, restartDaemon, startDaemon, stopDaemon, } from "./daemon";
+export type { DaemonPlatformDescriptor, DaemonProcessRunner, ServeDaemonConfig, ServeDaemonOperationOptions, ServeDaemonPaths, ServeDaemonState, ServeDaemonStatus, } from "./daemon";
 export type ServeCapletsOptions = {
     raw: RawServeOptions;
     engine?: CapletsEngineOptions;

package/dist/serve/native-session.d.ts

@@ -0,0 +1,19 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport";
+import type { NativeCapletsService } from "../native/service";
+export type NativeToolServer = Pick<McpServer, "registerTool" | "connect" | "close">;
+export type NativeCapletsMcpSessionOptions = {
+    server?: NativeToolServer;
+};
+export declare class NativeCapletsMcpSession {
+    private readonly service;
+    readonly server: NativeToolServer;
+    private readonly tools;
+    private readonly unsubscribe;
+    private closed;
+    constructor(service: NativeCapletsService, options?: NativeCapletsMcpSessionOptions);
+    connect(transport: Transport): Promise<void>;
+    close(): Promise<void>;
+    private reconcileTools;
+    private definition;
+}

package/dist/serve/options.d.ts

@@ -34,4 +34,5 @@ export type HttpBasicAuthOptions = {
 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 resolveDaemonServeOptions(raw: RawServeOptions, env?: ServeEnv): HttpServeOptions;
 export declare function isLoopbackHost(host: string): boolean;

package/dist/serve/session.d.ts

@@ -1,7 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport";
+import type { CapletsConfig } from "../config";
 import type { CapletsEngine } from "../engine";
-export type ToolServer = Pick<McpServer, "registerTool" | "connect" | "close">;
+export type ToolServer = Pick<McpServer, "registerTool" | "connect" | "close"> & Partial<Pick<McpServer, "registerResource" | "registerPrompt">>;
 export type CapletsMcpSessionOptions = {
     server?: ToolServer;
 };
@@ -9,13 +10,24 @@ export declare class CapletsMcpSession {
     private readonly engine;
     readonly server: ToolServer;
     private readonly tools;
+    private readonly resources;
+    private readonly prompts;
+    private codeModeTool;
     private readonly unsubscribeReload;
     private closed;
     constructor(engine: CapletsEngine, options?: CapletsMcpSessionOptions);
     connect(transport: Transport): Promise<void>;
     registeredToolIds(): string[];
+    refreshExposure(_previous?: CapletsConfig | undefined, _next?: CapletsConfig): Promise<void>;
     close(): Promise<void>;
-    private reconcileTools;
+    private reconcileFromSnapshot;
+    private clearRegistrations;
+    private registerCodeModeTool;
+    private handleCodeModeRunTool;
     private registerCapletTool;
-    private handleTool;
+    private registerDirectTool;
+    private registerDirectResource;
+    private registerDirectResourceTemplate;
+    private registerDirectPrompt;
+    private directResourceResult;
 }

package/dist/server/options.d.ts

@@ -1,5 +1,5 @@
 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 CapletsServerEnv = Partial<Record<"CAPLETS_MODE" | "CAPLETS_SERVER_URL" | "CAPLETS_SERVER_USER" | "CAPLETS_SERVER_PASSWORD" | "CAPLETS_CLOUD_URL" | "CAPLETS_CLOUD_TOKEN" | "CAPLETS_CLOUD_WORKSPACE_ID" | "CAPLETS_PROJECT_ROOT", string>>;
 export type CapletsModeInput = {
     mode?: string;
     serverUrl?: string;