@xopcai/xopc 0.0.240 → 0.0.242

package/dist/src/extensions/install.js

@@ -8,8 +8,8 @@ import { collectExtensionPackageDependencyIssues } from "./package-contract.js";
 import { dirname, isAbsolute, join, resolve, sep } from "path";
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
 import { execFileSync } from "node:child_process";
-import AdmZip from "adm-zip";
 import semver from "semver";
+import AdmZip from "adm-zip";
 import { tmpdir } from "os";
 //#region src/extensions/install.ts
 /**

package/dist/src/gateway/hono/routes/media.js

@@ -1,12 +1,8 @@
-import { TaskRepository } from "../../../tasks/task-repository.js";
-import { parseMediaUri } from "../../../media/uri.js";
 import { mimeTypeFromMediaPath, saveMediaBuffer } from "../../../media/store.js";
 import { readMediaReference } from "../../../media/media-reference.js";
-import { TaskContextRepository } from "../../../tasks/task-context-repository.js";
-import { pendingTranscriptReferencesMediaUri } from "../../../agent/inbound/attachment-pipeline.js";
 import { MAX_WEBCHAT_ATTACHMENT_FILE_BYTES } from "../../chat-limits.js";
-import { messagesReferenceMediaUri } from "../../../media/session-references.js";
 import { createGatewayRouteLogger } from "../lib/route-logger.js";
+import { resolveScopedMediaReference } from "../../media-access.js";
 //#region src/gateway/hono/routes/media.ts
 const log = createGatewayRouteLogger("Media");
 function parseByteRange(header, size) {
@@ -30,7 +26,6 @@ function parseByteRange(header, size) {
 	};
 }
 function registerMediaRoutes(authenticated, deps) {
-	const tasks = new TaskRepository();
 	authenticated.post("/api/media", deps.strictRateLimitMiddleware, async (c) => {
 		const file = (await c.req.formData().catch(() => null))?.get("file");
 		if (!(file instanceof Blob)) return c.json({
@@ -75,14 +70,10 @@ function registerMediaRoutes(authenticated, deps) {
 			error: { message: "Missing media scope" }
 		}, 400);
 		try {
-			const parsed = parseMediaUri(uriRaw.trim());
-			const sessionReferencesUri = sessionKey ? messagesReferenceMediaUri(await deps.service.sessionIndexInstance.loadMessages(sessionKey), parsed.uri) || pendingTranscriptReferencesMediaUri(sessionKey, parsed.uri) : false;
-			const taskReferencesUri = taskId && tasks.get(taskId) ? new TaskContextRepository().list(taskId).some((edge) => edge.targetKind === "file" && edge.targetId === parsed.uri) : false;
-			if (!sessionReferencesUri && !taskReferencesUri) return c.json({
-				ok: false,
-				error: { message: "Not found" }
-			}, 404);
-			const { buffer, path } = await readMediaReference(parsed.uri);
+			const { buffer, path } = await readMediaReference((await resolveScopedMediaReference(deps.service, uriRaw.trim(), {
+				sessionKey,
+				taskId
+			})).uri);
 			const contentType = mimeTypeFromMediaPath(path);
 			const range = parseByteRange(c.req.header("Range"), buffer.byteLength);
 			const commonHeaders = {

package/dist/src/gateway/hono/routes/runtime-tools.js

@@ -1,5 +1,6 @@
 import { init_paths_state, resolveStateDir } from "../../../config/paths-state.js";
 import { RuntimeToolsConfigSchema, init_schema } from "../../../config/schema.js";
+import { normalizeRuntimeVersionRequest } from "../../../runtime-tools/probe.js";
 import { ManagedRuntimeManager } from "../../../runtime-tools/manager.js";
 import { createGatewayRouteLogger } from "../lib/route-logger.js";
 import { pruneRuntimeTools } from "../../../runtime-tools/prune.js";
@@ -82,6 +83,11 @@ function registerRuntimeToolsRoutes(authenticated, deps) {
 			}, 400);
 			const body = await readJson(c);
 			const version = typeof body.version === "string" && body.version.trim() ? body.version.trim() : void 0;
+			if (version && !normalizeRuntimeVersionRequest(version)) return c.json({
+				ok: false,
+				error: "invalid-version",
+				message: "Invalid runtime version"
+			}, 400);
 			return streamSSE(c, async (stream) => {
 				const manager = runtimeManager(service.currentConfig);
 				let writes = Promise.resolve();
@@ -97,7 +103,7 @@ function registerRuntimeToolsRoutes(authenticated, deps) {
 				};
 				manager.on("progress", onProgress);
 				try {
-					const resolved = action === "repair" ? await manager.repair(runtime) : await manager.install(runtime, version);
+					const resolved = action === "repair" ? await manager.repair(runtime, version) : await manager.install(runtime, version);
 					await writes;
 					await stream.writeSSE({
 						event: "result",

package/dist/src/gateway/hono/routes/shares.js

@@ -16,11 +16,13 @@ import { getGatewayFileSpaceService } from "../../file-space-service.js";
 import { getClientIpFromHeaders } from "../../security/loopback.js";
 import { SHARED_HTML_CSP } from "../../security/csp.js";
 import { renderFolderLandingPage, renderShareExpiredPage, renderShareLandingPage, renderSnapshotShareLandingPage } from "../../../share/share-landing.js";
+import { resolveScopedMediaReference } from "../../media-access.js";
 import { SessionShareService, SessionShareSnapshotConflictError } from "../../../share/session-share-service.js";
 import { HostedSessionShareBuilder, HostedSessionSharePublisher, HostedShareAuthorizationError, HostedShareBindingStore } from "../../../share/hosted-session-share.js";
 import { NoteShareService } from "../../../share/note-share-service.js";
 import { consumeSharePublicLimit } from "../../../share/share-rate-limit.js";
 import { createZipStream, planDirectoryFiles } from "../../../share/share-zip.js";
+import { basename, dirname } from "node:path";
 import { createReadStream } from "node:fs";
 import { createHash } from "node:crypto";
 import { stat } from "node:fs/promises";
@@ -819,18 +821,43 @@ function registerShareRoutes(authenticated, deps) {
 				error: { message: "Invalid JSON" }
 			}, 400);
 		}
-		const path = typeof body.path === "string" ? body.path.trim() : "";
-		if (!path) return c.json({
+		let path = typeof body.path === "string" ? body.path.trim() : "";
+		const fileId = typeof body.fileId === "string" ? body.fileId.trim() : "";
+		const uri = typeof body.uri === "string" ? body.uri.trim() : "";
+		if ([
+			path,
+			fileId,
+			uri
+		].filter(Boolean).length !== 1) return c.json({
 			ok: false,
-			error: { message: "Missing path" }
+			error: { message: "Provide exactly one of path, fileId or uri" }
 		}, 400);
 		const sessionKey = typeof body.sessionKey === "string" ? body.sessionKey.trim() : void 0;
 		const agentId = typeof body.agentId === "string" ? body.agentId.trim() : void 0;
-		const workspaceRoot = await resolveWorkspaceRootForShare(service, sessionKey, agentId);
-		if (!workspaceRoot) return c.json({
-			ok: false,
-			error: { message: "Workspace not configured" }
-		}, 400);
+		const taskId = typeof body.taskId === "string" ? body.taskId.trim() : void 0;
+		const fileName = typeof body.fileName === "string" ? basename(body.fileName.trim().replace(/\\/g, "/")) : void 0;
+		let workspaceRoot;
+		try {
+			if (fileId) {
+				const target = await getGatewayFileSpaceService(service).resource(fileId);
+				workspaceRoot = target.space.root;
+				path = target.resource.relativePath || ".";
+			} else if (uri) {
+				const media = await resolveScopedMediaReference(service, uri, {
+					sessionKey,
+					taskId
+				});
+				workspaceRoot = dirname(media.path);
+				path = basename(media.path);
+			} else workspaceRoot = await resolveWorkspaceRootForShare(service, sessionKey, agentId);
+			if (!workspaceRoot) throw new Error("Workspace not configured");
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return c.json({
+				ok: false,
+				error: { message }
+			}, err instanceof FileServiceError ? err.status : 400);
+		}
 		const ttlMs = typeof body.ttlMs === "number" ? body.ttlMs : void 0;
 		const maxViews = body.maxViews === null ? null : typeof body.maxViews === "number" ? body.maxViews : void 0;
 		const description = typeof body.description === "string" ? body.description.trim() || void 0 : void 0;
@@ -844,6 +871,7 @@ function registerShareRoutes(authenticated, deps) {
 			store.updateConfig(resolveShareConfig(service));
 			const record = await store.create({
 				path,
+				fileName,
 				ttlMs,
 				maxViews,
 				description,

package/dist/src/gateway/media-access.d.ts

@@ -0,0 +1,6 @@
+import type { GatewayService } from './service.js';
+/** Resolve media only when the supplied session or task references it. */
+export declare function resolveScopedMediaReference(service: GatewayService, uri: string, scope: {
+    sessionKey?: string;
+    taskId?: string;
+}): Promise<import("../media/media-reference.js").ResolvedMediaReference>;

package/dist/src/gateway/media-access.js

@@ -0,0 +1,19 @@
+import { TaskRepository } from "../tasks/task-repository.js";
+import { FileServiceError } from "../files/file-service.js";
+import { resolveMediaReference } from "../media/media-reference.js";
+import { TaskContextRepository } from "../tasks/task-context-repository.js";
+import { pendingTranscriptReferencesMediaUri } from "../agent/inbound/attachment-pipeline.js";
+import { messagesReferenceMediaUri } from "../media/session-references.js";
+//#region src/gateway/media-access.ts
+/** Resolve media only when the supplied session or task references it. */
+async function resolveScopedMediaReference(service, uri, scope) {
+	const { sessionKey, taskId } = scope;
+	if (!sessionKey && !taskId) throw new FileServiceError(400, "Missing media scope");
+	const media = await resolveMediaReference(uri);
+	const sessionReferencesUri = sessionKey ? messagesReferenceMediaUri(await service.sessionIndexInstance.loadMessages(sessionKey), media.uri) || pendingTranscriptReferencesMediaUri(sessionKey, media.uri) : false;
+	const taskReferencesUri = taskId && new TaskRepository().get(taskId) ? new TaskContextRepository().list(taskId).some((edge) => edge.targetKind === "file" && edge.targetId === media.uri) : false;
+	if (!sessionReferencesUri && !taskReferencesUri) throw new FileServiceError(404, "Not found");
+	return media;
+}
+//#endregion
+export { resolveScopedMediaReference };

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

@@ -5,12 +5,15 @@ import { lstat, mkdir, readdir, readlink, rename, rm, stat } from "node:fs/promi
 import AdmZip from "adm-zip";
 //#region src/runtime-tools/archive.ts
 const MAX_ARCHIVE_ENTRIES = 5e4;
+const MAX_TAR_OUTPUT_BYTES = 16 * 1024 * 1024;
+const MAX_EXTRACTED_BYTES = 2 * 1024 * 1024 * 1024;
 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) {
+	let totalBytes = 0;
 	for (const entry of await readdir(current)) {
 		const entryPath = join(current, entry);
 		const details = await lstat(entryPath);
@@ -19,8 +22,10 @@ async function validateExtractedTree(root, current = root) {
 			if (relativeTarget.split(/[\\/]/)[0] === ".." || isAbsolute(relativeTarget)) throw new Error(`Archive symlink escapes extraction root: ${entryPath}`);
 			continue;
 		}
-		if (details.isDirectory()) await validateExtractedTree(root, entryPath);
+		totalBytes += details.isDirectory() ? await validateExtractedTree(root, entryPath) : details.size;
+		if (totalBytes > MAX_EXTRACTED_BYTES) throw new Error("Extracted archive exceeds size limit");
 	}
+	return totalBytes;
 }
 async function runTar(args) {
 	return await new Promise((resolvePromise, reject) => {
@@ -30,11 +35,19 @@ async function runTar(args) {
 			shell: false,
 			windowsHide: true
 		});
+		const append = (current, chunk) => {
+			if (Buffer.byteLength(current) + chunk.byteLength > MAX_TAR_OUTPUT_BYTES) {
+				child.kill("SIGKILL");
+				reject(/* @__PURE__ */ new Error("tar output exceeds size limit"));
+				return current;
+			}
+			return current + chunk.toString();
+		};
 		child.stdout?.on("data", (chunk) => {
-			stdout += chunk.toString();
+			stdout = append(stdout, chunk);
 		});
 		child.stderr?.on("data", (chunk) => {
-			stderr += chunk.toString();
+			stderr = append(stderr, chunk);
 		});
 		child.once("error", reject);
 		child.once("close", (code) => {
@@ -47,6 +60,7 @@ 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");
+	if (entries.reduce((total, entry) => total + entry.header.size, 0) > MAX_EXTRACTED_BYTES) throw new Error("Extracted archive exceeds size limit");
 	for (const entry of entries) validateMemberPath(entry.entryName);
 	zip.extractAllTo(destination, true, false);
 }

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

@@ -5,6 +5,7 @@ export interface RuntimeCommandResult {
     exitCode: number | null;
     timedOut: boolean;
     aborted: boolean;
+    outputTruncated: boolean;
 }
 export declare function runRuntimeCommand(params: {
     command: string;

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

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 //#region src/runtime-tools/command.ts
 const DEFAULT_COMMAND_TIMEOUT_MS = 5e3;
+const MAX_COMMAND_OUTPUT_BYTES = 1024 * 1024;
 async function runRuntimeCommand(params) {
 	return await new Promise((resolve) => {
 		let stdout = "";
@@ -8,7 +9,10 @@ async function runRuntimeCommand(params) {
 		let settled = false;
 		let timedOut = false;
 		let aborted = false;
+		let outputTruncated = false;
+		let timeout;
 		const child = spawn(params.command, params.args, {
+			detached: process.platform !== "win32",
 			env: params.env,
 			shell: false,
 			windowsHide: process.platform === "win32",
@@ -18,36 +22,53 @@ async function runRuntimeCommand(params) {
 				"pipe"
 			]
 		});
+		const killChild = () => {
+			if (process.platform !== "win32" && child.pid) try {
+				process.kill(-child.pid, "SIGKILL");
+				return;
+			} catch {}
+			child.kill("SIGKILL");
+		};
 		const finish = (exitCode) => {
 			if (settled) return;
 			settled = true;
-			clearTimeout(timeout);
+			if (timeout) clearTimeout(timeout);
 			params.signal?.removeEventListener("abort", abort);
 			resolve({
-				ok: exitCode === 0 && !timedOut && !aborted,
+				ok: exitCode === 0 && !timedOut && !aborted && !outputTruncated,
 				stdout: stdout.trim(),
 				stderr: stderr.trim(),
 				exitCode,
 				timedOut,
-				aborted
+				aborted,
+				outputTruncated
 			});
 		};
 		const abort = () => {
 			aborted = true;
-			child.kill("SIGKILL");
+			killChild();
 			finish(null);
 		};
+		const appendOutput = (current, chunk) => {
+			const remaining = MAX_COMMAND_OUTPUT_BYTES - Buffer.byteLength(current);
+			if (remaining <= 0 || chunk.byteLength > remaining) {
+				outputTruncated = true;
+				killChild();
+				return remaining > 0 ? current + chunk.subarray(0, remaining).toString() : current;
+			}
+			return current + chunk.toString();
+		};
 		child.stdout?.on("data", (chunk) => {
-			stdout += chunk.toString();
+			stdout = appendOutput(stdout, chunk);
 		});
 		child.stderr?.on("data", (chunk) => {
-			stderr += chunk.toString();
+			stderr = appendOutput(stderr, chunk);
 		});
 		child.once("error", () => finish(null));
 		child.once("close", finish);
-		const timeout = setTimeout(() => {
+		timeout = setTimeout(() => {
 			timedOut = true;
-			child.kill("SIGKILL");
+			killChild();
 			finish(null);
 		}, params.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS);
 		timeout.unref();

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

@@ -6,6 +6,7 @@ export interface RuntimeEnvironmentOptions {
     baseEnv: Record<string, string>;
     runtimes?: RuntimeKind[];
     extraBinDirs?: string[];
+    skillEnvironmentIds?: string[];
 }
 export interface RuntimeEnvironmentResult {
     env: Record<string, string>;

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

@@ -1,7 +1,7 @@
-import { applyPathPrepend } from "../infra/path-prepend.js";
+import { applyPathPrepend, findPathKey, normalizePathPrepend } from "../infra/path-prepend.js";
 import { ManagedRuntimeManager } from "./manager.js";
-import { dirname, join } from "node:path";
-import { access, readdir } from "node:fs/promises";
+import { delimiter, dirname, join } from "node:path";
+import { access } from "node:fs/promises";
 //#region src/runtime-tools/environment.ts
 const POLLUTING_ENV_KEYS = [
 	"NODE_OPTIONS",
@@ -19,14 +19,8 @@ const POLLUTING_ENV_KEYS = [
 	"UV_CACHE_DIR",
 	"UV_PYTHON_INSTALL_MIRROR"
 ];
-async function skillEnvironmentBinDirs(stateDir) {
+async function skillEnvironmentBinDirs(stateDir, environmentIds) {
 	const root = join(stateDir, "tools", "environments", "skills");
-	let environmentIds;
-	try {
-		environmentIds = await readdir(root);
-	} catch {
-		return [];
-	}
 	const candidates = environmentIds.flatMap((id) => [join(root, id, "bin"), join(root, id, "node_modules", ".bin")]);
 	return (await Promise.all(candidates.map(async (candidate) => {
 		try {
@@ -37,6 +31,10 @@ async function skillEnvironmentBinDirs(stateDir) {
 		}
 	}))).filter((candidate) => candidate !== null);
 }
+function appendPathEntries(env, entries) {
+	const pathKey = findPathKey(env);
+	env[pathKey] = normalizePathPrepend([...(env[pathKey] ?? "").split(delimiter).filter(Boolean), ...entries]).join(delimiter);
+}
 async function buildRuntimeEnvironment(options) {
 	const env = { ...options.baseEnv };
 	for (const key of POLLUTING_ENV_KEYS) delete env[key];
@@ -60,12 +58,9 @@ async function buildRuntimeEnvironment(options) {
 		}
 	}))).filter((item) => item !== null);
 	const managedBinDirs = resolved.filter((item) => item.source === "managed").map((item) => dirname(item.executable));
-	const skillBinDirs = await skillEnvironmentBinDirs(options.stateDir);
-	applyPathPrepend(env, [
-		...managedBinDirs,
-		...skillBinDirs,
-		...options.extraBinDirs ?? []
-	]);
+	const skillBinDirs = await skillEnvironmentBinDirs(options.stateDir, options.skillEnvironmentIds ?? []);
+	applyPathPrepend(env, [...managedBinDirs, ...options.extraBinDirs ?? []]);
+	appendPathEntries(env, skillBinDirs);
 	if (resolved.some((item) => item.runtime === "python")) {
 		env.PYTHONNOUSERSITE = "1";
 		env.PIP_REQUIRE_VIRTUALENV = "1";

package/dist/src/runtime-tools/install-lock.d.ts

@@ -1 +1 @@
-export declare function withInstallLock<T>(path: string, metadata: Record<string, unknown>, fn: () => Promise<T>): Promise<T>;
+export declare function withInstallLock<T>(path: string, metadata: Record<string, unknown>, fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;

package/dist/src/runtime-tools/install-lock.js

@@ -7,38 +7,51 @@ function isProcessAlive(pid) {
 	try {
 		process.kill(pid, 0);
 		return true;
-	} catch {
-		return false;
+	} catch (error) {
+		return error.code === "EPERM";
 	}
 }
 async function staleLock(path) {
 	try {
 		const value = JSON.parse(await readFile(path, "utf8"));
-		const pid = typeof value.pid === "number" ? value.pid : 0;
-		const createdAt = typeof value.createdAt === "number" ? value.createdAt : 0;
-		return !isProcessAlive(pid) && Date.now() - createdAt > LOCK_STALE_MS;
+		return !isProcessAlive(typeof value.pid === "number" ? value.pid : 0);
 	} catch {
 		return true;
 	}
 }
-async function withInstallLock(path, metadata, fn) {
+async function withInstallLock(path, metadata, fn, signal) {
 	await mkdir(dirname(path), { recursive: true });
-	while (true) try {
-		const handle = await open(path, "wx", 384);
-		await handle.writeFile(JSON.stringify({
-			pid: process.pid,
-			createdAt: Date.now(),
-			...metadata
-		}));
-		await handle.close();
-		break;
-	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
-		if (await staleLock(path)) {
-			await unlink(path).catch(() => void 0);
-			continue;
+	const waitStartedAt = Date.now();
+	while (true) {
+		if (signal?.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("Runtime installation was aborted");
+		try {
+			const handle = await open(path, "wx", 384);
+			await handle.writeFile(JSON.stringify({
+				pid: process.pid,
+				createdAt: Date.now(),
+				...metadata
+			}));
+			await handle.close();
+			break;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			if (await staleLock(path)) {
+				await unlink(path).catch(() => void 0);
+				continue;
+			}
+			if (Date.now() - waitStartedAt > LOCK_STALE_MS) throw new Error(`Timed out waiting for runtime installation lock: ${path}`);
+			await new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					signal?.removeEventListener("abort", abort);
+					resolve();
+				}, LOCK_WAIT_MS);
+				const abort = () => {
+					clearTimeout(timeout);
+					reject(signal?.reason ?? /* @__PURE__ */ new Error("Runtime installation was aborted"));
+				};
+				signal?.addEventListener("abort", abort, { once: true });
+			});
 		}
-		await new Promise((resolve) => setTimeout(resolve, LOCK_WAIT_MS));
 	}
 	try {
 		return await fn();

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

@@ -15,6 +15,6 @@ export declare class ManagedRuntimeManager extends EventEmitter {
     private uvEnvironment;
     status(runtime: RuntimeKind): Promise<RuntimeStatus>;
     statusAll(): Promise<RuntimeStatus[]>;
-    repair(runtime: RuntimeKind): Promise<ResolvedRuntime>;
+    repair(runtime: RuntimeKind, requestedVersion?: string): Promise<ResolvedRuntime>;
     private progress;
 }