@caplets/core 0.18.8 → 0.19.0

package/dist/filesystem-Kkg32TOJ.js

@@ -0,0 +1,66 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+//#region src/caplet-source/types.ts
+function normalizeCapletSourcePath(path) {
+	const normalized = path.trim().replace(/\\/g, "/").replace(/^\.\//u, "");
+	if (!normalized || normalized.startsWith("/") || /^[A-Za-z]:\//u.test(normalized)) return;
+	const stack = [];
+	for (const segment of normalized.split("/")) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (stack.length === 0) return;
+			stack.pop();
+			continue;
+		}
+		stack.push(segment);
+	}
+	return stack.length > 0 ? stack.join("/") : void 0;
+}
+//#endregion
+//#region src/caplet-source/filesystem.ts
+var FilesystemCapletSource = class {
+	root;
+	constructor(root) {
+		this.root = resolve(root);
+	}
+	async listFiles() {
+		if (!existsSync(this.root) || !statSync(this.root).isDirectory()) return [];
+		return walkFiles(this.root, this.root).sort((left, right) => left.path.localeCompare(right.path));
+	}
+	async readFile(path) {
+		const normalized = normalizeCapletSourcePath(path);
+		if (!normalized) return;
+		const absolute = resolve(this.root, normalized);
+		if (!isWithinRoot(this.root, absolute) || !existsSync(absolute) || !statSync(absolute).isFile()) return;
+		return {
+			path: normalized,
+			content: readFileSync(absolute, "utf8")
+		};
+	}
+};
+function walkFiles(root, dir) {
+	const files = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true }).sort(compareDirents)) {
+		const absolute = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...walkFiles(root, absolute));
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		const normalized = normalizeCapletSourcePath(relative(root, absolute));
+		if (normalized) files.push({
+			path: normalized,
+			content: readFileSync(absolute, "utf8")
+		});
+	}
+	return files;
+}
+function compareDirents(left, right) {
+	return left.name.localeCompare(right.name);
+}
+function isWithinRoot(root, absolute) {
+	const rel = relative(root, absolute);
+	return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+//#endregion
+export { normalizeCapletSourcePath as n, FilesystemCapletSource as t };

package/dist/generated-tool-input-schema.d.ts

@@ -1,13 +1,13 @@
 import { z } from "zod";
-export declare const operations: readonly ["get_caplet", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"];
-export declare const mcpOperations: readonly ["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"];
+export declare const operations: readonly ["inspect", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"];
+export declare const mcpOperations: readonly ["inspect", "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"];
 export type GeneratedOperation = (typeof operations)[number];
 export type GeneratedMcpOperation = (typeof mcpOperations)[number];
 export type CapletSchemaBackend = {
     backend: string;
 };
 export declare const generatedToolInputDescriptions: {
-    readonly operation: "Wrapper operation: get_caplet, check_backend, list_tools, search_tools, get_tool, call_tool. MCP Caplets also expose resources, prompts, and completions.";
+    readonly operation: "Wrapper operation: inspect, check_backend, list_tools, search_tools, get_tool, call_tool. MCP Caplets also expose resources, prompts, and completions.";
     readonly query: "Required for search operations only.";
     readonly limit: "Optional list/search result limit.";
     readonly tool: "Exact downstream tool name for get_tool or call_tool.";
@@ -53,7 +53,7 @@ export declare function generatedToolInputSchemaForCaplet(caplet: CapletSchemaBa
         search_tools: "search_tools";
         get_tool: "get_tool";
         check_backend: "check_backend";
-        get_caplet: "get_caplet";
+        inspect: "inspect";
         call_tool: "call_tool";
     }>;
 }, z.core.$strict>;
@@ -68,7 +68,7 @@ export declare const generatedToolInputSchema: z.ZodObject<{
         search_tools: "search_tools";
         get_tool: "get_tool";
         check_backend: "check_backend";
-        get_caplet: "get_caplet";
+        inspect: "inspect";
         call_tool: "call_tool";
     }>;
 }, z.core.$strict>;
@@ -132,8 +132,8 @@ export declare function generatedToolInputJsonSchemaForCaplet(caplet: CapletSche
         };
         readonly operation: {
             readonly type: "string";
-            readonly enum: readonly ["get_caplet", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"] | readonly ["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"];
-            readonly description: "Wrapper operation: get_caplet, check_backend, list_tools, search_tools, get_tool, call_tool. MCP Caplets also expose resources, prompts, and completions.";
+            readonly enum: readonly ["inspect", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"] | readonly ["inspect", "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"];
+            readonly description: "Wrapper operation: inspect, check_backend, list_tools, search_tools, get_tool, call_tool. MCP Caplets also expose resources, prompts, and completions.";
         };
         readonly query: {
             readonly type: "string";
@@ -225,8 +225,8 @@ export declare function generatedToolInputJsonSchema(): {
         };
         readonly operation: {
             readonly type: "string";
-            readonly enum: readonly ["get_caplet", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"] | readonly ["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"];
-            readonly description: "Wrapper operation: get_caplet, check_backend, list_tools, search_tools, get_tool, call_tool. MCP Caplets also expose resources, prompts, and completions.";
+            readonly enum: readonly ["inspect", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"] | readonly ["inspect", "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"];
+            readonly description: "Wrapper operation: inspect, check_backend, list_tools, search_tools, get_tool, call_tool. MCP Caplets also expose resources, prompts, and completions.";
         };
         readonly query: {
             readonly type: "string";

package/dist/generated-tool-input-schema.js

@@ -1,2 +1,162 @@
-import { a as generatedToolInputJsonSchemaForCaplet, c as mcpOperations, i as generatedToolInputJsonSchema, l as operations, n as completionRefSchema, o as generatedToolInputSchema, r as generatedToolInputDescriptions, s as generatedToolInputSchemaForCaplet, t as completionArgumentSchema } from "./generated-tool-input-schema-MbYF5jMW.js";
+import { a as any, d as literal, m as object, o as array, p as number, r as _enum, v as string, y as union } from "./schemas-BZ6BBrh7.js";
+//#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 { completionArgumentSchema, completionRefSchema, generatedToolInputDescriptions, generatedToolInputJsonSchema, generatedToolInputJsonSchemaForCaplet, generatedToolInputSchema, generatedToolInputSchemaForCaplet, mcpOperations, operations };

package/dist/index.d.ts

@@ -1,9 +1,44 @@
 export { CapletsRuntime } from "./runtime";
 export { runCli, createProgram } from "./cli";
 export { parseConfig, loadConfig } from "./config";
+export { BundleCapletSource, parseCapletSource } from "./caplet-source";
+export { FilesystemCapletSource } from "./caplet-source/filesystem";
+export { classifyCapletRuntimeRoute, planCapletRuntimeRoute, planCapletRuntimeRoutes, } from "./runtime-plan";
+export type { CapletSource, CapletSourceFile, CapletSourceParseMessage, CapletSourceParseResult, CapletSourceReference, ParsedCapletSourceCaplet, } from "./caplet-source";
+export type { CapletRuntimePlan, RuntimePlanDeployment, RuntimePlanOptions, RuntimeRouteKind, SetupTargetKind as RuntimePlanSetupTargetKind, } from "./runtime-plan";
 export { capabilityDescription, ServerRegistry } from "./registry";
 export { generatedToolInputSchema, handleServerTool } from "./tools";
+export type { CapletExecutionMetadata, CapletResultMetadata } from "./tools";
+export type { CapletSetupCommandConfig, CapletSetupConfig } from "./config";
+export { capletSetupContentHash, stableJson } from "./setup/hash";
+export { LocalSetupStore } from "./setup/local-store";
+export { runCapletSetup } from "./setup/runner";
+export { CloudAuthClient } from "./cloud-auth/client";
+export { openBrowserUrl } from "./cloud-auth/open-url";
+export { CloudAuthStore, cloudAuthPath, migrateCredentials, redactedCloudAuthStatus, } from "./cloud-auth/store";
+export type { CloudAuthCredentials, CloudAuthStoreOptions } from "./cloud-auth/store";
+export type { CloudAuthLoginPollResult, CloudAuthLoginStart, CloudAuthScope, CloudAuthState, CloudAuthTokenResponse, CloudAuthWorkspace, RedactedCloudAuthStatus, } from "./cloud-auth/types";
+export type { SetupActor, SetupApproval, SetupAttempt, SetupAttemptStatus, SetupPlan, SetupTargetKind, } from "./setup/types";
 export { hasRenderableStructuredContent, markdownCallToolResultContent, markdownStructuredContent, } from "./result-content";
 export type { ResultMarkdownContext } from "./result-content";
 export { serveCaplets, serveHttp, serveResolvedCaplets, serveStdio } from "./serve";
 export type { HttpServeOptions, RawServeOptions, ServeOptions, StdioServeOptions } from "./serve";
+export { PROJECT_BINDING_STATES, PROJECT_BINDING_SYNC_STATES } from "./project-binding/types";
+export type { BindingTerminalReason, ProjectBindingLease, ProjectBindingSetupReceipt, ProjectBindingState, ProjectBindingSyncState, ProjectBindingWorkspaceMetadata, } from "./project-binding/types";
+export { PROJECT_BINDING_ERROR_CODES, ProjectBindingError, projectBindingError, projectBindingRecovery, } from "./project-binding/errors";
+export type { ProjectBindingErrorCode, ProjectBindingRecovery } from "./project-binding/errors";
+export { buildProjectSyncManifest } from "./project-binding/sync-filter";
+export type { ProjectSyncExclusionSource, ProjectSyncExclusionSummary, ProjectSyncManifest, ProjectSyncManifestFile, } from "./project-binding/sync-filter";
+export { DEFAULT_SYNC_LIMITS, enforceProjectSyncSizeLimits } from "./project-binding/sync-size";
+export type { ProjectSyncLimits, ProjectSyncSizeResult, ProjectSyncTier, } from "./project-binding/sync-size";
+export { PROJECT_BINDING_CONNECT_PATH, PROJECT_BINDINGS_CONTROL_PATH, projectBindingConnectPath, projectBindingConnectUrl, projectBindingStatusPath, projectBindingStatusUrl, } from "./project-binding/routes";
+export { attachProjectOnce, attachProjectSession, resolveAttachOptions, } from "./project-binding/attach";
+export type { AttachSessionEvent, RawAttachOptions, ResolvedAttachOptions, } from "./project-binding/attach";
+export { runProjectBindingSession } from "./project-binding/session";
+export type { ProjectBindingSessionEvent, ProjectBindingSocketClientMessage, ProjectBindingSocketServerMessage, RunProjectBindingSessionInput, } from "./project-binding/session";
+export { defaultProjectBindingWebSocketFactory } from "./project-binding/transport";
+export type { ProjectBindingWebSocket, ProjectBindingWebSocketFactory, } from "./project-binding/transport";
+export { ProjectBindingWorkspaceStore, projectBindingWorkspacePaths, projectBindingWorkspaceRoot, } from "./project-binding/workspaces";
+export type { EnsureProjectBindingWorkspaceInput, ProjectBindingCleanupResult, ProjectBindingWorkspacePaths, ProjectBindingWorkspaceRootOptions, ProjectBindingWorkspaceStoreOptions, } from "./project-binding/workspaces";
+export { ManagedMutagenProjectSync, mutagenProjectSyncDoctorData, mutagenSyncName, parseMutagenVersionOutput as parseManagedMutagenVersionOutput, planMutagenSyncCreateCommand, planMutagenSyncListCommand, planMutagenSyncTerminateCommand, planMutagenVersionCommand, } from "./project-binding/mutagen";
+export type { ManagedMutagenProjectSyncOptions, ManagedSyncDiagnosticCode, ManagedSyncState, ManagedSyncStateSnapshot, MutagenCommandPlan, MutagenLastCommandStatus, MutagenProcessResult, MutagenProcessRunner, MutagenProjectSyncBindingInput, MutagenProjectSyncDoctorData, StartMutagenProjectSyncInput, } from "./project-binding/mutagen";