@caplets/core 0.18.9 → 0.20.0

package/dist/runtime-plan.js

@@ -0,0 +1,281 @@
+//#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 resourceClassRank(value) {
+	return rank[value] ?? 0;
+}
+function isRuntimeResourceClassAllowed(requested, maximum) {
+	return resourceClassRank(requested) <= resourceClassRank(maximum);
+}
+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 isRuntimeResourceClassAllowed(requested, maxClass) ? requested : maxClass;
+}
+//#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, isRuntimeResourceClassAllowed, planCapletRuntimeRoute, planCapletRuntimeRoutes, resolveRuntimeResources, resourceClassRank };