@caplets/core 0.18.8 → 0.19.0

package/dist/runtime-plan.js

@@ -0,0 +1,275 @@
+//#region src/runtime-plan/types.ts
+const HIDDEN_REASON_CODES = [
+	"setup_required",
+	"setup_running",
+	"setup_failed",
+	"verify_failed",
+	"backend_auth_required",
+	"backend_check_failed",
+	"project_binding_required",
+	"project_binding_syncing",
+	"project_binding_blocked",
+	"project_binding_stale",
+	"provider_unavailable",
+	"provider_capacity_exhausted",
+	"provider_queue_timeout",
+	"policy_denied",
+	"billing_required",
+	"subscription_past_due",
+	"usage_limit_reached",
+	"email_verification_required",
+	"docker_required",
+	"docker_denied",
+	"browser_required",
+	"browser_denied",
+	"resource_class_denied",
+	"local_only",
+	"invalid_bundle",
+	"unsupported_backend"
+];
+//#endregion
+//#region src/runtime-plan/features.ts
+function inferRuntimeFeatures(caplet) {
+	const provenance = [];
+	for (const feature of explicitFeatures(caplet)) provenance.push({
+		feature,
+		source: "explicit",
+		matched: "runtime.features"
+	});
+	for (const command of commandRecords(caplet)) {
+		const text = [command.command, ...command.args].join(" ");
+		const dockerMatch = matchDocker(command.command, command.args);
+		if (dockerMatch) provenance.push({
+			feature: "docker",
+			source: command.source,
+			matched: dockerMatch,
+			command: text
+		});
+		const browserMatch = matchBrowser(command.command, command.args);
+		if (browserMatch) provenance.push({
+			feature: "browser",
+			source: command.source,
+			matched: browserMatch,
+			command: text
+		});
+	}
+	return {
+		features: orderedFeatures([...new Set(provenance.map((entry) => entry.feature))]),
+		provenance
+	};
+}
+function explicitFeatures(caplet) {
+	const runtime = caplet.runtime;
+	if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) return [];
+	const features = runtime.features;
+	return Array.isArray(features) ? features.filter((feature) => feature === "docker" || feature === "browser") : [];
+}
+function commandRecords(caplet) {
+	return [
+		...setupCommands(caplet.setup, "setup.commands"),
+		...setupCommands(caplet.setup, "setup.verify", true),
+		...mcpCommands(caplet),
+		...cliCommands(caplet)
+	];
+}
+function setupCommands(setup, source, verify = false) {
+	if (!setup || typeof setup !== "object" || Array.isArray(setup)) return [];
+	const values = setup[verify ? "verify" : "commands"];
+	if (!Array.isArray(values)) return [];
+	return values.flatMap((value) => commandRecordFrom(value, source));
+}
+function mcpCommands(caplet) {
+	if (caplet.backend !== "mcp" || typeof caplet.command !== "string") return [];
+	return [{
+		source: "mcp.command",
+		command: caplet.command,
+		args: stringArray(caplet.args)
+	}];
+}
+function cliCommands(caplet) {
+	if (caplet.backend !== "cli") return [];
+	const records = [];
+	if (typeof caplet.command === "string") records.push({
+		source: "cli.command",
+		command: caplet.command,
+		args: stringArray(caplet.args)
+	});
+	const actions = caplet.actions;
+	if (actions && typeof actions === "object" && !Array.isArray(actions)) for (const action of Object.values(actions)) records.push(...commandRecordFrom(action, "cli.action"));
+	return records;
+}
+function commandRecordFrom(value, source) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+	const command = value.command;
+	if (typeof command !== "string") return [];
+	return [{
+		source,
+		command,
+		args: stringArray(value.args)
+	}];
+}
+function stringArray(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function matchDocker(command, args) {
+	const text = [command, ...args].join(" ").toLowerCase();
+	if (text.includes("docker-mcp")) return "docker-mcp";
+	if (/\bdocker(?:-compose)?\b/u.test(text)) return command === "docker" ? command : text;
+	return text.includes("docker mcp") ? "docker mcp" : void 0;
+}
+function matchBrowser(command, args) {
+	const text = [command, ...args].join(" ").toLowerCase();
+	if (text.includes("@playwright/mcp")) return "@playwright/mcp";
+	if (text.includes("playwright install")) return "playwright install";
+	if (text.includes("playwright")) return "playwright";
+	if (text.includes("browser-use")) return "browser-use";
+	if (text.includes("puppeteer")) return "puppeteer";
+	if (text.includes("chromium")) return "chromium";
+	return /\bchrome\b/u.test(text) ? "chrome" : void 0;
+}
+function orderedFeatures(features) {
+	return ["docker", "browser"].filter((feature) => features.includes(feature));
+}
+//#endregion
+//#region src/runtime-plan/resources.ts
+const defaults = {
+	small: {
+		class: "small",
+		cpu: 1,
+		memoryMb: 1024,
+		diskMb: 4096
+	},
+	medium: {
+		class: "medium",
+		cpu: 2,
+		memoryMb: 4096,
+		diskMb: 8192
+	},
+	standard: {
+		class: "standard",
+		cpu: 2,
+		memoryMb: 4096,
+		diskMb: 8192
+	},
+	large: {
+		class: "large",
+		cpu: 4,
+		memoryMb: 8192,
+		diskMb: 20480
+	},
+	heavy: {
+		class: "heavy",
+		cpu: 8,
+		memoryMb: 16384,
+		diskMb: 40960
+	}
+};
+const rank = {
+	small: 0,
+	standard: 1,
+	medium: 1,
+	large: 2,
+	heavy: 3
+};
+function resolveRuntimeResources(inputOrCaplet, features, policy) {
+	const caplet = inputOrCaplet;
+	const input = features === void 0 ? inputOrCaplet : {
+		backend: typeof caplet.backend === "string" ? caplet.backend : void 0,
+		features,
+		explicitClass: explicitResourceClass$1(caplet),
+		setupRequired: Boolean(caplet.setup),
+		policy
+	};
+	const requested = input.explicitClass ?? defaultResourceClass(input);
+	const capped = capClass(requested, input.policy?.maxClass);
+	return {
+		...defaults[capped] ?? defaults.standard,
+		...requested !== capped ? { cappedByPolicy: input.policy?.maxClass } : {}
+	};
+}
+function defaultResourceClass(input) {
+	const hasDocker = input.features.includes("docker");
+	const hasBrowser = input.features.includes("browser");
+	if (hasDocker && hasBrowser) return "heavy";
+	if (hasDocker || hasBrowser) return "large";
+	if (input.backend === "cli" || input.backend === "mcp" || input.setupRequired) return "medium";
+	return "small";
+}
+function explicitResourceClass$1(caplet) {
+	const runtime = caplet.runtime;
+	if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) return void 0;
+	const resources = runtime.resources;
+	if (!resources || typeof resources !== "object" || Array.isArray(resources)) return void 0;
+	const value = resources.class;
+	return typeof value === "string" ? value : void 0;
+}
+function capClass(requested, maxClass) {
+	if (!maxClass) return requested;
+	return (rank[requested] ?? 0) > (rank[maxClass] ?? 0) ? maxClass : requested;
+}
+//#endregion
+//#region src/runtime-plan/planner.ts
+function planCapletRuntimeRoutes(caplets, options = {}) {
+	return caplets.map((caplet) => planSingleCaplet(caplet, options));
+}
+function planCapletRuntimeRoute(caplet, options = {}) {
+	return planCapletRuntimeRoutes([caplet], options)[0] ?? planSingleCaplet(caplet, options);
+}
+function planSingleCaplet(caplet, options) {
+	const route = classifyCapletRuntimeRoute(caplet);
+	const setupRequired = Boolean(caplet.setup);
+	const projectBindingRequired = projectBindingRequiredFor(caplet);
+	const features = inferRuntimeFeatures(caplet);
+	const runtime = {
+		features: features.features,
+		featureProvenance: features.provenance,
+		resources: resolveRuntimeResources({
+			backend: typeof caplet.backend === "string" ? caplet.backend : void 0,
+			features: features.features,
+			explicitClass: explicitResourceClass(caplet),
+			policy: options.resourcePolicy,
+			setupRequired
+		})
+	};
+	return {
+		id: String(caplet.server ?? ""),
+		backend: typeof caplet.backend === "string" ? caplet.backend : "unknown",
+		route,
+		setupRequired,
+		authRequired: authRequired("auth" in caplet ? caplet.auth : void 0),
+		...route === "process" || route === "project_bound_process" ? { setupTarget: setupTargetFor(options.deployment) } : {},
+		projectBindingRequired,
+		runtime,
+		caplet
+	};
+}
+function classifyCapletRuntimeRoute(caplet) {
+	if (projectBindingRequiredFor(caplet)) return "project_bound_process";
+	if (caplet.setup) return "process";
+	if (caplet.backend === "cli") return "process";
+	if (caplet.backend === "mcp") return caplet.transport === "stdio" || Boolean(caplet.command) ? "process" : "worker_safe";
+	if (caplet.backend === "openapi" || caplet.backend === "graphql" || caplet.backend === "http") return "worker_safe";
+	if (caplet.backend === "caplets") return "worker_safe";
+	return "local_only";
+}
+function setupTargetFor(deployment) {
+	if (deployment === "local") return "local_host";
+	return deployment === "self_hosted" ? "remote_host" : "hosted_sandbox";
+}
+function authRequired(auth) {
+	return auth !== null && typeof auth === "object" && "type" in auth && auth.type !== "none";
+}
+function projectBindingRequiredFor(caplet) {
+	const projectBinding = caplet.projectBinding;
+	return Boolean(projectBinding) && typeof projectBinding === "object" && !Array.isArray(projectBinding) && projectBinding.required === true;
+}
+function explicitResourceClass(caplet) {
+	const runtime = caplet.runtime;
+	if (!runtime || typeof runtime !== "object" || Array.isArray(runtime)) return void 0;
+	const resources = runtime.resources;
+	if (!resources || typeof resources !== "object" || Array.isArray(resources)) return void 0;
+	const value = resources.class;
+	return value === "small" || value === "medium" || value === "standard" || value === "large" || value === "heavy" ? value : void 0;
+}
+//#endregion
+export { HIDDEN_REASON_CODES, classifyCapletRuntimeRoute, inferRuntimeFeatures, planCapletRuntimeRoute, planCapletRuntimeRoutes, resolveRuntimeResources };

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

@@ -4557,164 +4557,4 @@ function preprocess(fn, schema) {
 	});
 }
 //#endregion
-//#region src/generated-tool-input-schema.ts
-const operations = [
-	"get_caplet",
-	"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: get_caplet, 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/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;