@xopcai/xopc 0.0.191 → 0.0.192

package/dist/src/gateway/service/marketplace-service.d.ts

@@ -83,7 +83,7 @@ export declare class GatewayMarketplaceService {
     reloadSkills(): void;
     patchSkillEnabled(skillName: string, enabled: boolean): void;
     fetchSkillsCatalog(params: SkillsStoreListParams, provider?: string): Promise<UnifiedMarketplaceListResponse>;
-    fetchSkillsCategories(provider?: string): Promise<{
+    fetchSkillsCategories(provider?: string, locale?: string): Promise<{
         items: MarketplaceCategoryOption[];
     }>;
     fetchSkillsPackageDetail(packageName: string, provider?: string): Promise<UnifiedMarketplacePackageDetail>;

package/dist/src/gateway/service/marketplace-service.js

@@ -112,9 +112,9 @@ var GatewayMarketplaceService = class {
 		const { listMarketplacePackages } = await import("../../agent/skills/skills-marketplace.js");
 		return listMarketplacePackages(this.opts.getConfig(), params, provider);
 	}
-	async fetchSkillsCategories(provider) {
+	async fetchSkillsCategories(provider, locale) {
 		const { listMarketplaceCategories } = await import("../../agent/skills/skills-marketplace.js");
-		return listMarketplaceCategories(this.opts.getConfig(), provider);
+		return listMarketplaceCategories(this.opts.getConfig(), provider, locale);
 	}
 	async fetchSkillsPackageDetail(packageName, provider) {
 		const { getMarketplacePackageDetail } = await import("../../agent/skills/skills-marketplace.js");

package/dist/src/gateway/service.js

@@ -66,11 +66,6 @@ import { DiscussionSealer } from "../discussions/sealer.js";
 import "../discussions/index.js";
 import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
-import { scheduleGatewayUpdateCheck } from "../infra/update-startup.js";
-import { LocalAppService } from "../local-apps/service.js";
-import "../local-apps/index.js";
-import { runBootstrapMigrationsSync } from "../migrations/runner.js";
-import { MobileNotificationService } from "../mobile/notification-service.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { reconcileDreamingAutomations } from "./dreaming-automation-reconciler.js";
 import { NotesStore } from "../notes/store.js";
@@ -88,6 +83,10 @@ import { assertGatewayAuthNotKnownWeak } from "./security/known-weak-secrets.js"
 import { assertGatewayRuntimeConfig } from "./runtime-config.js";
 import { auditGatewayConfig } from "./security/audit.js";
 import { ModelCatalogSyncService } from "../providers/model-catalog-sync-service.js";
+import { runBootstrapMigrationsSync } from "../migrations/runner.js";
+import { MobileNotificationService } from "../mobile/notification-service.js";
+import { LocalAppService } from "../local-apps/service.js";
+import "../local-apps/index.js";
 import { createRuntimeBrowserRecipeService } from "../browser/recipes/runtime-service.js";
 import "../browser/recipes/index.js";
 import { mapProductEventToProactive } from "../proactive/events/product-event-bridge.js";
@@ -99,6 +98,7 @@ import { ProactiveTemporalWorker } from "../proactive/temporal/worker.js";
 import { ProactiveInboxService } from "../proactive/inbox/service.js";
 import { ProactiveInboxWorker } from "../proactive/inbox/worker.js";
 import "../proactive/index.js";
+import { scheduleGatewayUpdateCheck } from "../infra/update-startup.js";
 import { resolveChannelConnectDeferSet } from "./resolve-channel-connect-defer.js";
 import { restartGatewayProcessWithFreshPid } from "./respawn.js";
 import { GatewaySessionsApi } from "./service/sessions-api.js";

package/dist/src/heartbeat/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, shouldSilence, stripHeartbeatToken } from "./tokens.js";
+import { appendCronEventLines } from "./event-prompt.js";
 import { isWithinActiveHours } from "./active-hours.js";
 import { isHeartbeatContentEmpty } from "./content-check.js";
-import { appendCronEventLines } from "./event-prompt.js";
 import { createHeartbeatWake } from "./wake.js";
 export { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, appendCronEventLines, createHeartbeatWake, isHeartbeatContentEmpty, isWithinActiveHours, shouldSilence, stripHeartbeatToken };

package/dist/src/infra/gateway-processes.js

@@ -1,5 +1,5 @@
-import { isGatewayArgv, parseProcCmdline } from "./gateway-process-argv.js";
 import { listPortListeners } from "../gateway/ports.js";
+import { isGatewayArgv, parseProcCmdline } from "./gateway-process-argv.js";
 import fs from "node:fs";
 import { spawnSync } from "node:child_process";
 //#region src/infra/gateway-processes.ts

package/dist/src/infra/update-global.js

@@ -1,6 +1,6 @@
+import { applyPathPrepend } from "./path-prepend.js";
 import { resolveExecPathBinPrepend } from "./path-env.js";
 import { readPackageVersion } from "./package-json.js";
-import { applyPathPrepend } from "./path-prepend.js";
 import { createDefaultCommandRunner } from "./run-command.js";
 import path from "node:path";
 import fs from "node:fs";

package/dist/src/infra/update-restart.js

@@ -4,8 +4,8 @@ import { init_paths, resolveConfigPath } from "../config/paths.js";
 import { init_loader, loadConfig } from "../config/loader.js";
 import { isRestartEnabled } from "../config/commands.flags.js";
 import { resolveGatewayService } from "../daemon/service.js";
-import { findVerifiedGatewayListenerPidsOnPortSync, signalVerifiedGatewayPidSync } from "./gateway-processes.js";
 import { authorizeGatewaySigusr1Restart, writeGatewayRestartIntentSync } from "./restart.js";
+import { findVerifiedGatewayListenerPidsOnPortSync, signalVerifiedGatewayPidSync } from "./gateway-processes.js";
 import { refreshGatewayServiceAfterUpdate } from "./update-service-refresh.js";
 //#region src/infra/update-restart.ts
 init_loader();

package/dist/src/infra/update-runner.js

@@ -1,11 +1,11 @@
 import { runPostUpdateExtensionSync } from "../extensions/update.js";
+import "./update-channels.js";
+import { compareSemver, resolveNpmChannelTag } from "./update-check.js";
 import { readPackageName, readPackageVersion } from "./package-json.js";
 import { createDefaultCommandRunner, runCommandWithTimeout } from "./run-command.js";
 import { XOPC_PACKAGE_NAME, cleanupGlobalRenameDirs, createGlobalInstallEnv, detectGlobalInstallManagerForRoot, resolveGlobalInstallSpec, resolveGlobalInstallTarget } from "./update-global.js";
 import { runGlobalPackageUpdateSteps } from "./package-update-steps.js";
 import { resolveStableNodePath } from "./stable-node-path.js";
-import "./update-channels.js";
-import { compareSemver, resolveNpmChannelTag } from "./update-check.js";
 import { trimLogTail } from "./update-log.js";
 import { maybeRestartGatewayAfterUpdate } from "./update-restart.js";
 import path from "node:path";

package/dist/src/infra/update-startup.js

@@ -3,9 +3,9 @@ import { init_paths_state, resolveUpdateCheckStatePath } from "../config/paths-s
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_write_file_atomic, writeTextAtomic } from "./write-file-atomic.js";
+import { acquireUpdateLock } from "./update-lock.js";
 import { normalizeUpdateChannel } from "./update-channels.js";
 import { compareSemver, detectInstallKind, resolveNpmChannelTag, resolvePackageRoot } from "./update-check.js";
-import { acquireUpdateLock } from "./update-lock.js";
 import { createHash, randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
 //#region src/infra/update-startup.ts

package/dist/src/providers/extension-stream-bridge.js

@@ -3,6 +3,7 @@ import { init_logger } from "../utils/logger.js";
 import "./constants.js";
 import { getProviderRegistry, init_plugin_registry } from "./plugin-registry.js";
 import { init_providers } from "./index.js";
+import { stripPromptCacheBoundary } from "../agent/prompt/cache-boundary.js";
 import { createAssistantMessageEventStream, streamSimple } from "@earendil-works/pi-ai/compat";
 //#region src/providers/extension-stream-bridge.ts
 init_plugin_registry();
@@ -80,7 +81,7 @@ function createExtensionAwareStreamFn() {
 		const stream = createAssistantMessageEventStream();
 		const params = {
 			model: model.id,
-			systemPrompt: context.systemPrompt,
+			systemPrompt: context.systemPrompt ? stripPromptCacheBoundary(context.systemPrompt) : void 0,
 			messages: context.messages,
 			tools: context.tools,
 			temperature: options?.temperature,
@@ -200,15 +201,15 @@ function createExtensionAwareStreamFn() {
 								partial.usage = {
 									input: chunk.usage.input,
 									output: chunk.usage.output,
-									cacheRead: 0,
-									cacheWrite: 0,
-									totalTokens: chunk.usage.total ?? chunk.usage.input + chunk.usage.output,
+									cacheRead: chunk.usage.cacheRead ?? 0,
+									cacheWrite: chunk.usage.cacheWrite ?? 0,
+									totalTokens: chunk.usage.total ?? chunk.usage.input + chunk.usage.output + (chunk.usage.cacheRead ?? 0) + (chunk.usage.cacheWrite ?? 0),
 									cost: {
 										input: inputCost,
 										output: outputCost,
-										cacheRead: 0,
-										cacheWrite: 0,
-										total: inputCost + outputCost
+										cacheRead: (chunk.usage.cacheRead ?? 0) / 1e6 * (model.cost?.cacheRead ?? 0),
+										cacheWrite: (chunk.usage.cacheWrite ?? 0) / 1e6 * (model.cost?.cacheWrite ?? 0),
+										total: inputCost + outputCost + (chunk.usage.cacheRead ?? 0) / 1e6 * (model.cost?.cacheRead ?? 0) + (chunk.usage.cacheWrite ?? 0) / 1e6 * (model.cost?.cacheWrite ?? 0)
 									}
 								};
 							}

package/dist/src/providers/model-catalog-store.d.ts

@@ -2,10 +2,10 @@ export interface CatalogModel {
     id: string;
     name: string;
     availability: 'available' | 'unavailable';
-    kind: 'language' | 'image';
-    input: Array<'text' | 'image'>;
-    output: Array<'text' | 'image'>;
-    operations: Array<'chat.completions' | 'responses' | 'images.generate' | 'images.edit'>;
+    kind: 'language' | 'image' | 'stt' | 'tts';
+    input: Array<'text' | 'image' | 'audio'>;
+    output: Array<'text' | 'image' | 'audio'>;
+    operations: Array<'chat.completions' | 'responses' | 'images.generate' | 'images.edit' | 'audio.transcription' | 'audio.speech'>;
     reasoning: boolean;
     contextWindow: number;
     maxOutputTokens: number | null;
@@ -18,6 +18,26 @@ export interface CatalogModel {
         backgrounds: Array<'transparent' | 'opaque' | 'auto'>;
         maxInputImages: number;
     };
+    stt?: {
+        inputFormats: string[];
+        maxBytes: number;
+        maxDurationSeconds: number;
+        languages: string[];
+        languageHint: boolean;
+        prompt: boolean;
+        timestamps: Array<'segment' | 'word'>;
+        diarization: boolean;
+    };
+    tts?: {
+        maxCharacters: number;
+        languages: string[];
+        outputFormats: Array<'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm'>;
+        streaming: boolean;
+        speed: boolean;
+        pitch: boolean;
+        instructions: boolean;
+        defaultVoice?: string;
+    };
 }
 export interface CatalogSource {
     providerId: string;

package/dist/src/providers/model-catalog-store.js

@@ -65,6 +65,17 @@ var init_model_catalog_store = __esmMin((() => {
 						qualities: [...model.imageGeneration.qualities],
 						formats: [...model.imageGeneration.formats],
 						backgrounds: [...model.imageGeneration.backgrounds]
+					} } : {},
+					...model.stt ? { stt: {
+						...model.stt,
+						inputFormats: [...model.stt.inputFormats],
+						languages: [...model.stt.languages],
+						timestamps: [...model.stt.timestamps]
+					} } : {},
+					...model.tts ? { tts: {
+						...model.tts,
+						languages: [...model.tts.languages],
+						outputFormats: [...model.tts.outputFormats]
 					} } : {}
 				}))
 			};

package/dist/src/providers/model-registry.js

@@ -243,7 +243,7 @@ var init_model_registry = __esmMin((() => {
 				provider: source.providerId,
 				baseUrl: source.baseUrl,
 				reasoning: model.reasoning,
-				input: model.input,
+				input: model.input.filter((value) => value === "text" || value === "image"),
 				cost: {
 					input: 0,
 					output: 0,

package/dist/src/providers/prompt-cache-payload.d.ts

@@ -0,0 +1,13 @@
+import type { Api, Model, SimpleStreamOptions } from '@earendil-works/pi-ai';
+export declare function transformPromptCachePayload(model: Model<Api>, payload: unknown): unknown;
+export declare function buildPromptCacheKey(model: Model<Api>, context: {
+    systemPrompt?: string;
+    tools?: unknown[];
+}): string;
+export declare function preparePromptCacheContext<T extends {
+    systemPrompt?: string;
+}>(model: Model<Api>, context: T): T;
+export declare function withPromptCachePayloadTransform(model: Model<Api>, context: {
+    systemPrompt?: string;
+    tools?: unknown[];
+}, options: SimpleStreamOptions | undefined): SimpleStreamOptions | undefined;

package/dist/src/providers/prompt-cache-payload.js

@@ -0,0 +1,110 @@
+import { splitPromptCacheBoundary, stripPromptCacheBoundary } from "../agent/prompt/cache-boundary.js";
+import { createHash } from "node:crypto";
+//#region src/providers/prompt-cache-payload.ts
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function supportsPromptCacheKey(model) {
+	if (model.api === "openai-codex-responses" || model.api === "azure-openai-responses") return true;
+	if (model.api !== "openai-completions" && model.api !== "openai-responses") return false;
+	return model.provider === "openai" || model.baseUrl?.includes("api.openai.com") === true;
+}
+function splitAnthropicSystem(payload) {
+	const record = asRecord(payload);
+	if (!record || !Array.isArray(record.system)) return payload;
+	let changed = false;
+	const system = record.system.flatMap((value) => {
+		const block = asRecord(value);
+		if (!block || typeof block.text !== "string") return [value];
+		const split = splitPromptCacheBoundary(block.text);
+		if (!split) return [value];
+		changed = true;
+		const { text: _text, ...rest } = block;
+		return [{
+			...rest,
+			type: block.type ?? "text",
+			text: split.stablePrefix
+		}, ...split.dynamicSuffix ? [{
+			type: block.type ?? "text",
+			text: split.dynamicSuffix
+		}] : []];
+	});
+	return changed ? {
+		...record,
+		system
+	} : payload;
+}
+function splitBedrockSystem(payload) {
+	const record = asRecord(payload);
+	if (!record || !Array.isArray(record.system)) return payload;
+	let changed = false;
+	const system = [];
+	for (let index = 0; index < record.system.length; index += 1) {
+		const value = record.system[index];
+		const block = asRecord(value);
+		const split = block && typeof block.text === "string" ? splitPromptCacheBoundary(block.text) : void 0;
+		if (!split) {
+			system.push(value);
+			continue;
+		}
+		changed = true;
+		system.push({
+			...block,
+			text: split.stablePrefix
+		});
+		const next = asRecord(record.system[index + 1]);
+		if (next?.cachePoint) {
+			system.push(next);
+			index += 1;
+		}
+		if (split.dynamicSuffix) system.push({ text: split.dynamicSuffix });
+	}
+	return changed ? {
+		...record,
+		system
+	} : payload;
+}
+function transformPromptCachePayload(model, payload) {
+	if (model.api === "anthropic-messages") return splitAnthropicSystem(payload);
+	if (model.api === "bedrock-converse-stream") return splitBedrockSystem(payload);
+	return payload;
+}
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	const record = asRecord(value);
+	if (record) return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+	return JSON.stringify(value) ?? "null";
+}
+function buildPromptCacheKey(model, context) {
+	const stablePrompt = context.systemPrompt ? splitPromptCacheBoundary(context.systemPrompt)?.stablePrefix ?? stripPromptCacheBoundary(context.systemPrompt) : "";
+	return `xopc-${createHash("sha256").update(`${model.provider}\0${model.id}\0${stablePrompt}\0${canonicalJson(context.tools ?? [])}`).digest("base64url")}`;
+}
+function preparePromptCacheContext(model, context) {
+	if (model.api === "anthropic-messages" || model.api === "bedrock-converse-stream") return context;
+	if (!context.systemPrompt) return context;
+	return {
+		...context,
+		systemPrompt: stripPromptCacheBoundary(context.systemPrompt)
+	};
+}
+function withPromptCachePayloadTransform(model, context, options) {
+	const explicitBoundary = model.api === "anthropic-messages" || model.api === "bedrock-converse-stream";
+	const openAiCacheKey = supportsPromptCacheKey(model) && options?.cacheRetention !== "none";
+	if (!explicitBoundary && !openAiCacheKey) return options;
+	const upstream = options?.onPayload;
+	const promptCacheKey = openAiCacheKey ? buildPromptCacheKey(model, context) : void 0;
+	return {
+		...options,
+		onPayload: async (payload, payloadModel) => {
+			const upstreamPayload = await upstream?.(payload, payloadModel);
+			const transformed = transformPromptCachePayload(model, upstreamPayload === void 0 ? payload : upstreamPayload);
+			const record = asRecord(transformed);
+			return record && promptCacheKey ? {
+				...record,
+				prompt_cache_key: promptCacheKey
+			} : transformed;
+		}
+	};
+}
+//#endregion
+export { buildPromptCacheKey, preparePromptCacheContext, transformPromptCachePayload, withPromptCachePayloadTransform };

package/dist/src/providers/register-runtime-providers.js

@@ -20,7 +20,7 @@ function registerRuntimeProvider(modelRuntime, source) {
 			id: model.id,
 			name: model.name,
 			reasoning: model.reasoning,
-			input: model.input,
+			input: model.input.filter((value) => value === "text" || value === "image"),
 			cost: {
 				input: 0,
 				output: 0,

package/dist/src/providers/xopc-cloud-model-source.js

@@ -47,25 +47,30 @@ var XopcCloudModelSource = class {
 		if (!Array.isArray(body?.data)) throw new XopcCloudModelError("XOPC model discovery returned an invalid response", response.status, "invalid_response");
 		const models = [...new Map(body.data.filter((model) => typeof model.id === "string" && model.id.length > 0).map((model) => {
 			const declaredInput = model.xopc?.capabilities?.input;
-			const parsedInput = Array.isArray(declaredInput) ? declaredInput.filter((value) => value === "text" || value === "image") : [];
-			const input = parsedInput.includes("text") ? [...new Set(parsedInput)] : ["text", ...new Set(parsedInput)];
+			const parsedInput = Array.isArray(declaredInput) ? declaredInput.filter((value) => value === "text" || value === "image" || value === "audio") : [];
+			const kind = model.xopc?.kind === "image" || model.xopc?.kind === "stt" || model.xopc?.kind === "tts" ? model.xopc.kind : "language";
+			const input = kind === "stt" ? ["audio"] : kind === "tts" ? ["text"] : kind === "language" && !parsedInput.includes("text") ? ["text", ...new Set(parsedInput)] : [...new Set(parsedInput)];
 			const maxOutputTokens = model.xopc?.maxOutputTokens;
 			const declaredOutput = model.xopc?.capabilities?.output;
-			const output = Array.isArray(declaredOutput) ? declaredOutput.filter((value) => value === "text" || value === "image") : ["text"];
+			const output = kind === "stt" ? ["text"] : kind === "tts" ? ["audio"] : Array.isArray(declaredOutput) ? declaredOutput.filter((value) => value === "text" || value === "image" || value === "audio") : ["text"];
 			const declaredOperations = model.xopc?.operations ?? model.xopc?.capabilities?.operations;
-			const operations = Array.isArray(declaredOperations) ? declaredOperations.filter((value) => value === "chat.completions" || value === "responses" || value === "images.generate" || value === "images.edit") : ["chat.completions", "responses"];
+			const operations = kind === "stt" ? ["audio.transcription"] : kind === "tts" ? ["audio.speech"] : Array.isArray(declaredOperations) ? declaredOperations.filter((value) => value === "chat.completions" || value === "responses" || value === "images.generate" || value === "images.edit" || value === "audio.transcription" || value === "audio.speech") : ["chat.completions", "responses"];
 			const generation = parseImageGenerationCapabilities(model.xopc?.capabilities?.imageGeneration);
+			const stt = kind === "stt" ? parseSttCapabilities(model.xopc?.capabilities) : void 0;
+			const tts = kind === "tts" ? parseTtsCapabilities(model.xopc?.capabilities, model.xopc?.defaultVoice) : void 0;
 			return [model.id, {
 				id: model.id,
 				name: model.id,
-				kind: model.xopc?.kind === "image" ? "image" : "language",
+				kind,
 				input,
 				output,
 				operations,
 				reasoning: model.xopc?.capabilities?.reasoning === true,
 				contextWindow: 128e3,
 				maxOutputTokens: typeof maxOutputTokens === "number" && Number.isSafeInteger(maxOutputTokens) ? maxOutputTokens : null,
-				...generation ? { imageGeneration: generation } : {}
+				...generation ? { imageGeneration: generation } : {},
+				...stt ? { stt } : {},
+				...tts ? { tts } : {}
 			}];
 		})).values()];
 		this.catalogStore.replaceSourceModels("xopc-cloud", {
@@ -85,6 +90,47 @@ var XopcCloudModelSource = class {
 		};
 	}
 };
+function parseSttCapabilities(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const raw = value;
+	return {
+		inputFormats: strings(raw.inputFormats),
+		maxBytes: positiveInteger(raw.maxBytes),
+		maxDurationSeconds: positiveInteger(raw.maxDurationSeconds),
+		languages: strings(raw.languages),
+		languageHint: raw.languageHint === true,
+		prompt: raw.prompt === true,
+		timestamps: strings(raw.timestamps).filter((item) => item === "segment" || item === "word"),
+		diarization: raw.diarization === true
+	};
+}
+function parseTtsCapabilities(value, defaultVoice) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const raw = value;
+	return {
+		maxCharacters: positiveInteger(raw.maxCharacters),
+		languages: strings(raw.languages),
+		outputFormats: strings(raw.outputFormats).filter((item) => [
+			"mp3",
+			"opus",
+			"aac",
+			"flac",
+			"wav",
+			"pcm"
+		].includes(item)),
+		streaming: raw.streaming === true,
+		speed: raw.speed === true,
+		pitch: raw.pitch === true,
+		instructions: raw.instructions === true,
+		...typeof defaultVoice === "string" && defaultVoice ? { defaultVoice } : {}
+	};
+}
+function strings(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function positiveInteger(value) {
+	return Number.isSafeInteger(value) && Number(value) > 0 ? Number(value) : 0;
+}
 function parseImageGenerationCapabilities(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
 	const raw = value;

package/dist/src/runtime-tools/archive.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeKind } from './types.js';
+export declare function extractRuntimeArchive(params: {
+    runtime: RuntimeKind;
+    archivePath: string;
+    archiveType: 'zip' | 'tar.gz';
+    stagingDir: string;
+}): Promise<string>;
+export declare function atomicInstallRuntime(extractedRoot: string, installDir: string): Promise<void>;

package/dist/src/runtime-tools/archive.js

@@ -0,0 +1,99 @@
+import { RuntimeError } from "./errors.js";
+import { isAbsolute, join, posix, relative, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { lstat, mkdir, readdir, readlink, rename, rm, stat } from "node:fs/promises";
+import AdmZip from "adm-zip";
+//#region src/runtime-tools/archive.ts
+const MAX_ARCHIVE_ENTRIES = 5e4;
+function validateMemberPath(memberPath) {
+	const portablePath = memberPath.replaceAll("\\", "/");
+	const normalized = posix.normalize(portablePath);
+	if (!memberPath || isAbsolute(memberPath) || portablePath.startsWith("/") || normalized === ".." || normalized.startsWith("../")) throw new Error(`Unsafe archive member: ${memberPath}`);
+}
+async function validateExtractedTree(root, current = root) {
+	for (const entry of await readdir(current)) {
+		const entryPath = join(current, entry);
+		const details = await lstat(entryPath);
+		if (details.isSymbolicLink()) {
+			const relativeTarget = relative(root, resolve(current, await readlink(entryPath)));
+			if (relativeTarget.split(/[\\/]/)[0] === ".." || isAbsolute(relativeTarget)) throw new Error(`Archive symlink escapes extraction root: ${entryPath}`);
+			continue;
+		}
+		if (details.isDirectory()) await validateExtractedTree(root, entryPath);
+	}
+}
+async function runTar(args) {
+	return await new Promise((resolvePromise, reject) => {
+		let stdout = "";
+		let stderr = "";
+		const child = spawn("tar", args, {
+			shell: false,
+			windowsHide: true
+		});
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.once("error", reject);
+		child.once("close", (code) => {
+			if (code === 0) resolvePromise(stdout);
+			else reject(new Error(stderr.trim() || `tar exited with code ${code}`));
+		});
+	});
+}
+async function extractZip(archivePath, destination) {
+	const zip = new AdmZip(archivePath);
+	const entries = zip.getEntries();
+	if (entries.length > MAX_ARCHIVE_ENTRIES) throw new Error("Archive contains too many entries");
+	for (const entry of entries) validateMemberPath(entry.entryName);
+	zip.extractAllTo(destination, true, false);
+}
+async function extractTarGz(archivePath, destination) {
+	const entries = (await runTar(["-tzf", archivePath])).split(/\r?\n/).filter(Boolean);
+	if (entries.length > MAX_ARCHIVE_ENTRIES) throw new Error("Archive contains too many entries");
+	for (const entry of entries) validateMemberPath(entry);
+	await runTar([
+		"-xzf",
+		archivePath,
+		"-C",
+		destination
+	]);
+}
+async function singleArchiveRoot(destination) {
+	const entries = (await readdir(destination)).filter((entry) => entry !== "__MACOSX");
+	if (entries.length !== 1) throw new Error("Archive must contain one top-level directory");
+	const root = join(destination, entries[0]);
+	if (!(await stat(root)).isDirectory()) throw new Error("Archive root is not a directory");
+	return root;
+}
+async function extractRuntimeArchive(params) {
+	await rm(params.stagingDir, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(params.stagingDir, { recursive: true });
+	try {
+		if (params.archiveType === "zip") await extractZip(params.archivePath, params.stagingDir);
+		else await extractTarGz(params.archivePath, params.stagingDir);
+		await validateExtractedTree(params.stagingDir);
+		return await singleArchiveRoot(params.stagingDir);
+	} catch (error) {
+		await rm(params.stagingDir, {
+			recursive: true,
+			force: true
+		});
+		throw new RuntimeError(`Invalid ${params.runtime} archive: ${error instanceof Error ? error.message : String(error)}`, "RUNTIME_ARCHIVE_INVALID", params.runtime, "extract", true, [], { cause: error });
+	}
+}
+async function atomicInstallRuntime(extractedRoot, installDir) {
+	await mkdir(resolve(installDir, ".."), { recursive: true });
+	await rm(installDir, {
+		recursive: true,
+		force: true
+	});
+	await rename(extractedRoot, installDir);
+}
+//#endregion
+export { atomicInstallRuntime, extractRuntimeArchive };

package/dist/src/runtime-tools/bootstrap.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeToolsConfig } from '../config/schema.js';
+import { ManagedRuntimeManager } from './manager.js';
+import type { ResolvedRuntime, RuntimeKind } from './types.js';
+export type RuntimeBootstrapResult = {
+    runtime: RuntimeKind;
+    ok: boolean;
+    resolved?: ResolvedRuntime;
+    error?: string;
+};
+type RuntimeResolver = Pick<ManagedRuntimeManager, 'resolve'>;
+export declare function provisionEagerRuntimes(params: {
+    stateDir: string;
+    config: RuntimeToolsConfig;
+    manager?: RuntimeResolver;
+}): Promise<RuntimeBootstrapResult[]>;
+export {};

package/dist/src/runtime-tools/bootstrap.js

@@ -0,0 +1,33 @@
+import { ManagedRuntimeManager } from "./manager.js";
+//#region src/runtime-tools/bootstrap.ts
+async function provisionEagerRuntimes(params) {
+	if (!params.config.enabled) return [];
+	const manager = params.manager ?? new ManagedRuntimeManager({
+		stateDir: params.stateDir,
+		config: params.config
+	});
+	const requested = [];
+	if (params.config.node.enabled && params.config.node.provision === "eager") requested.push("node");
+	if (params.config.python.enabled && params.config.python.provision === "eager") requested.push("python");
+	const results = [];
+	for (const runtime of requested) try {
+		const resolved = await manager.resolve({
+			runtime,
+			allowProvision: true
+		});
+		results.push({
+			runtime,
+			ok: true,
+			resolved
+		});
+	} catch (error) {
+		results.push({
+			runtime,
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return results;
+}
+//#endregion
+export { provisionEagerRuntimes };

package/dist/src/runtime-tools/catalog.d.ts

@@ -0,0 +1,19 @@
+import type { RuntimeKind } from './types.js';
+export declare const RUNTIME_CATALOG_VERSION = "2026-08-23";
+export declare const DEFAULT_RUNTIME_VERSIONS: Record<RuntimeKind, string>;
+export type RuntimePlatform = 'darwin-arm64' | 'darwin-x64' | 'win32-x64' | 'linux-x64-gnu' | 'linux-arm64-gnu';
+export interface RuntimeAsset {
+    runtime: 'node' | 'uv';
+    version: string;
+    platform: RuntimePlatform;
+    archiveFile: string;
+    url: string;
+    checksumUrl: string;
+    archiveType: 'zip' | 'tar.gz';
+}
+export declare function detectRuntimePlatform(platform?: NodeJS.Platform, arch?: string): RuntimePlatform | null;
+export declare function resolveRuntimeAsset(params: {
+    runtime: 'node' | 'uv';
+    version: string;
+    platform: RuntimePlatform;
+}): RuntimeAsset;