@xopcai/xopc 0.0.282 → 0.0.284

package/dist/src/imports/importService.js

@@ -0,0 +1,417 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { init_write_file_atomic, writeTextAtomicSync } from "../infra/write-file-atomic.js";
+import { prepareManagedSkillTempDir } from "../agent/skills/managed-store.js";
+import { ImportError } from "./types.js";
+import { fileHash, readTree } from "./files.js";
+import { parseSkill } from "./compatibility.js";
+import { ImportRepository } from "../storage/sqlite/import-repository.js";
+import { canonicalTarget, createImportPlan, targetInventory, targetRevision } from "./planner.js";
+import { scanLocal } from "./scanner.js";
+import { dirname, join } from "node:path";
+import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import yaml from "js-yaml";
+import lockfile from "proper-lockfile";
+//#region src/imports/importService.ts
+init_write_file_atomic();
+init_logger();
+const log = createLogger("ImportService");
+const RETENTION_MS = 720 * 60 * 60 * 1e3;
+var ImportService = class {
+	repo;
+	root;
+	constructor(options) {
+		this.options = options;
+		this.repo = new ImportRepository(options.owner);
+		this.root = join(canonicalTarget(options.stateDir), "imports");
+		mkdirSync(this.root, {
+			recursive: true,
+			mode: 448
+		});
+	}
+	scan(input) {
+		return this.storeScan(scanLocal(input));
+	}
+	getScan(id) {
+		return this.repo.get("scan", id);
+	}
+	storeScan(scan) {
+		const dir = join(this.root, scan.id);
+		mkdirSync(dir, { mode: 448 });
+		for (const item of scan.candidates) if (item.kind === "skill" && item.compatibility === "compatible") writeTextAtomicSync(join(dir, `${item.id}.json`), JSON.stringify(item.files));
+		const manifest = {
+			...scan,
+			candidates: scan.candidates.map((c) => ({
+				...c,
+				connected: this.options.isConnected?.(c) ?? false,
+				files: c.files.map((f) => ({
+					...f,
+					data: ""
+				}))
+			}))
+		};
+		this.repo.save("scan", manifest);
+		return manifest;
+	}
+	plan(scanId, target, choices) {
+		this.options.validateTarget?.(target);
+		const plan = createImportPlan(this.getScan(scanId), target, choices, this.options.reservedNames?.(target));
+		this.repo.save("plan", plan);
+		return plan;
+	}
+	async importSkills(scan, target) {
+		const inventory = targetInventory(target.root);
+		const names = new Set([...this.options.reservedNames?.(target) ?? [], ...inventory.flatMap((i) => [i.directory, i.name])].map((n) => n.toLowerCase()));
+		const choices = [];
+		const result = {
+			imported: 0,
+			skipped: 0,
+			issues: []
+		};
+		const previous = /* @__PURE__ */ new Map();
+		for (const job of this.repo.jobs(-1)) {
+			if (job.plan.target.root !== canonicalTarget(target.root)) continue;
+			const origin = this.getScan(job.plan.scanId);
+			for (const item of job.items.filter((i) => i.status === "active")) {
+				const candidate = origin.candidates.find((c) => c.id === item.action.candidateId);
+				if (candidate?.source === scan.source && !previous.has(candidate.location)) previous.set(candidate.location, { name: item.action.name });
+			}
+		}
+		for (const candidate of scan.candidates.filter((c) => c.kind === "skill")) {
+			if (candidate.connected) {
+				result.skipped++;
+				continue;
+			}
+			if (candidate.compatibility !== "compatible") {
+				result.issues.push({
+					name: candidate.name,
+					reason: candidate.findings.join("; ")
+				});
+				continue;
+			}
+			const prior = previous.get(candidate.location);
+			const priorTarget = prior && inventory.find((i) => i.directory === prior.name);
+			if (prior && priorTarget) {
+				const files = JSON.parse(readFileSync(join(this.root, scan.id, `${candidate.id}.json`), "utf8"));
+				if (fileHash(this.renameSkill(files, prior.name)) === priorTarget.hash) result.skipped++;
+				else result.issues.push({
+					name: candidate.name,
+					reason: "The previously imported skill has changed. Existing content was kept."
+				});
+				continue;
+			}
+			if (inventory.find((i) => i.name.toLowerCase() === candidate.name.toLowerCase())?.hash === candidate.hash) {
+				result.skipped++;
+				continue;
+			}
+			let name = candidate.name;
+			if (names.has(name.toLowerCase())) name = `${candidate.source}-${candidate.name}`.slice(0, 63);
+			const files = JSON.parse(readFileSync(join(this.root, scan.id, `${candidate.id}.json`), "utf8"));
+			const hash = fileHash(this.renameSkill(files, name));
+			if (inventory.some((i) => i.name === name && i.hash === hash)) {
+				result.skipped++;
+				continue;
+			}
+			if (names.has(name.toLowerCase())) {
+				result.issues.push({
+					name: candidate.name,
+					reason: "An existing skill was kept. Manage it in Skills to make changes."
+				});
+				continue;
+			}
+			names.add(name.toLowerCase());
+			choices.push({
+				candidateId: candidate.id,
+				operation: name === candidate.name ? "create" : "rename",
+				name
+			});
+		}
+		if (!choices.length) return result;
+		const plan = this.plan(scan.id, target, choices);
+		const staged = this.apply(plan.id, plan.id);
+		const job = await this.activate(staged.id, staged.items.filter((i) => i.status === "staged").map((i) => i.action.candidateId));
+		for (const item of job.items) if (item.status === "active") result.imported++;
+		else if (item.status === "skipped") result.skipped++;
+		else result.issues.push({
+			name: item.action.name,
+			reason: item.error ?? "Could not import this skill. Try again."
+		});
+		return result;
+	}
+	getPlan(id) {
+		return this.repo.get("plan", id);
+	}
+	apply(planId, key) {
+		if (!key || key.length > 128) throw new ImportError("invalid_key", "An idempotency key is required");
+		return this.lock(() => {
+			const previous = this.repo.byKey(key);
+			if (previous) {
+				if (previous.plan.id !== planId) throw new ImportError("conflict", "Idempotency key belongs to a different plan", 409);
+				return previous;
+			}
+			const plan = this.getPlan(planId);
+			this.options.validateTarget?.(plan.target);
+			if (Date.now() > plan.expiresAt || canonicalTarget(plan.target.root) !== plan.target.root || targetRevision(plan.target.root) !== plan.targetRevision) throw new ImportError("plan_stale", "Target changed or plan expired; preview again", 409);
+			const job = {
+				id: randomUUID(),
+				plan,
+				createdAt: Date.now(),
+				expiresAt: Date.now() + RETENTION_MS,
+				items: plan.actions.map((action) => ({
+					action,
+					status: action.operation === "skip" ? "skipped" : "staged"
+				}))
+			};
+			const dir = join(this.root, job.id);
+			mkdirSync(dir, { mode: 448 });
+			const scan = this.getScan(plan.scanId);
+			try {
+				for (const item of job.items) {
+					if (item.status === "skipped") continue;
+					const candidate = scan.candidates.find((c) => c.id === item.action.candidateId);
+					if (candidate.kind !== "skill") continue;
+					const files = JSON.parse(readFileSync(join(this.root, scan.id, `${candidate.id}.json`), "utf8"));
+					if (fileHash(files) !== candidate.hash) throw new ImportError("source_changed", "Snapshot changed; scan again", 409);
+					const rewritten = this.renameSkill(files, item.action.name);
+					item.afterHash = fileHash(rewritten);
+					writeTextAtomicSync(join(dir, `${candidate.id}.json`), JSON.stringify(rewritten));
+				}
+				this.repo.save("job", job, key);
+			} catch (error) {
+				rmSync(dir, {
+					recursive: true,
+					force: true
+				});
+				throw error;
+			}
+			log.info({
+				jobId: job.id,
+				count: job.items.length
+			}, "Import staged");
+			return job;
+		});
+	}
+	renameSkill(files, name) {
+		return files.map((file) => {
+			if (file.path !== "SKILL.md") return file;
+			const { metadata, body } = parseSkill(Buffer.from(file.data, "base64").toString("utf8"));
+			if (metadata.name === name) return file;
+			return {
+				...file,
+				data: Buffer.from(`---\n${yaml.dump({
+					...metadata,
+					name
+				})}---\n${body}`).toString("base64")
+			};
+		});
+	}
+	getJob(id) {
+		return this.lock(() => this.recover(this.repo.get("job", id)));
+	}
+	async recoverAndClean() {
+		const release = await lockfile.lock(this.root, {
+			realpath: false,
+			retries: {
+				retries: 15,
+				minTimeout: 250,
+				maxTimeout: 1e3
+			}
+		});
+		try {
+			for (const saved of this.repo.jobs(-1)) {
+				const job = this.recover(saved);
+				if (Date.now() <= job.expiresAt || canonicalTarget(job.plan.target.root) !== job.plan.target.root) continue;
+				for (const item of job.items) if (item.backupPath && existsSync(item.backupPath) && this.targetHash(item.backupPath) === item.action.beforeHash) rmSync(item.backupPath, {
+					recursive: true,
+					force: true
+				});
+				rmSync(join(this.root, job.id), {
+					recursive: true,
+					force: true
+				});
+			}
+			for (const scan of this.repo.scansBefore(Date.now() - RETENTION_MS - 1440 * 60 * 1e3)) rmSync(join(this.root, scan.id), {
+				recursive: true,
+				force: true
+			});
+		} finally {
+			await release();
+		}
+	}
+	history() {
+		return this.lock(() => this.repo.jobs().map((job) => this.recover(job)));
+	}
+	async activate(id, candidateIds) {
+		const job = this.lock(() => {
+			const current = this.recover(this.repo.get("job", id));
+			this.assertLive(current);
+			this.options.validateTarget?.(current.plan.target);
+			const scan = this.getScan(current.plan.scanId);
+			this.checkSelection(current, candidateIds);
+			for (const candidateId of candidateIds) {
+				const item = current.items.find((i) => i.action.candidateId === candidateId);
+				if (item.status === "active") continue;
+				if (!["staged", "failed"].includes(item.status)) throw new ImportError("invalid_state", "Item cannot be activated");
+				if (scan.candidates.find((c) => c.id === candidateId).kind !== "skill") throw new ImportError("needs_setup", "Review the MCP draft in connection settings before configuring it");
+				try {
+					this.publish(current, item);
+				} catch (error) {
+					if (item.status !== "publishing") item.status = "failed";
+					item.error = error instanceof ImportError ? error.message : "Publishing failed; retry after checking target permissions";
+				}
+				this.repo.save("job", current);
+			}
+			return current;
+		});
+		await this.options.refreshSkills?.();
+		return job;
+	}
+	publish(job, item) {
+		const root = job.plan.target.root;
+		if (canonicalTarget(root) !== root) throw new ImportError("unsafe_target", "Target location changed", 409);
+		const dest = join(root, item.action.name);
+		if (this.targetHash(dest) !== item.action.beforeHash) throw new ImportError("plan_stale", "Target changed after preview", 409);
+		const others = this.options.reservedNames?.(job.plan.target) ?? [];
+		if (item.action.operation !== "replace" && others.some((name) => name.toLowerCase() === item.action.name.toLowerCase())) throw new ImportError("conflict", "Skill name is now in use", 409);
+		const files = JSON.parse(readFileSync(join(this.root, job.id, `${item.action.candidateId}.json`), "utf8"));
+		if (fileHash(files) !== item.afterHash) throw new ImportError("source_changed", "Staged files changed", 409);
+		const { tempDir } = prepareManagedSkillTempDir(item.action.name, root);
+		try {
+			for (const file of files) {
+				const path = join(tempDir, file.path);
+				mkdirSync(dirname(path), {
+					recursive: true,
+					mode: 448
+				});
+				writeFileSync(path, Buffer.from(file.data, "base64"), {
+					mode: file.executable ? 448 : 384,
+					flag: "wx"
+				});
+			}
+			if (fileHash(readTree(tempDir)) !== item.afterHash) throw new ImportError("source_changed", "Staged verification failed", 409);
+			item.backupPath = join(root, `.tmp-import-backup-${job.id}-${item.action.candidateId}`);
+			item.status = "publishing";
+			delete item.error;
+			this.repo.save("job", job);
+			if (existsSync(dest)) renameSync(dest, item.backupPath);
+			renameSync(tempDir, dest);
+			item.status = "active";
+		} catch (error) {
+			if (item.backupPath && existsSync(item.backupPath) && !existsSync(dest)) renameSync(item.backupPath, dest);
+			throw error;
+		} finally {
+			rmSync(tempDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	async rollback(id, candidateIds) {
+		const job = this.lock(() => {
+			const current = this.recover(this.repo.get("job", id));
+			this.assertLive(current);
+			this.checkSelection(current, candidateIds);
+			for (const candidateId of candidateIds) {
+				const item = current.items.find((i) => i.action.candidateId === candidateId);
+				if (["rolled_back", "skipped"].includes(item.status)) continue;
+				if (item.status === "staged" || item.status === "failed") {
+					item.status = "rolled_back";
+					this.repo.save("job", current);
+					continue;
+				}
+				const dest = join(current.plan.target.root, item.action.name);
+				if (canonicalTarget(current.plan.target.root) !== current.plan.target.root || this.targetHash(dest) !== item.afterHash) {
+					item.error = "Target changed after import; rollback would overwrite your edits";
+					this.repo.save("job", current);
+					continue;
+				}
+				if (item.action.beforeHash !== null && (!item.backupPath || this.targetHash(item.backupPath) !== item.action.beforeHash)) {
+					item.error = "Backup is missing or changed; manual review required";
+					this.repo.save("job", current);
+					continue;
+				}
+				item.status = "rolling_back";
+				this.repo.save("job", current);
+				const trash = this.trashPath(current, item);
+				renameSync(dest, trash);
+				if (item.backupPath && existsSync(item.backupPath)) {
+					if (this.targetHash(item.backupPath) !== item.action.beforeHash) throw new ImportError("rollback_conflict", "Backup changed; manual review required", 409);
+					renameSync(item.backupPath, dest);
+				}
+				item.status = "rolled_back";
+				delete item.error;
+				this.repo.save("job", current);
+				rmSync(trash, {
+					recursive: true,
+					force: true
+				});
+			}
+			return current;
+		});
+		await this.options.refreshSkills?.();
+		return job;
+	}
+	trashPath(job, item) {
+		return join(job.plan.target.root, `.tmp-import-undo-${job.id}-${item.action.candidateId}`);
+	}
+	recover(job) {
+		for (const item of job.items) {
+			if (!["publishing", "rolling_back"].includes(item.status)) continue;
+			const root = job.plan.target.root;
+			if (canonicalTarget(root) !== root) throw new ImportError("unsafe_target", "Target location changed", 409);
+			const dest = join(root, item.action.name);
+			const hash = this.targetHash(dest);
+			if (item.status === "publishing") if (hash === item.afterHash) item.status = "active";
+			else if (hash === item.action.beforeHash) item.status = "staged";
+			else if (!hash && item.action.beforeHash !== null && item.backupPath && this.targetHash(item.backupPath) === item.action.beforeHash) {
+				renameSync(item.backupPath, dest);
+				item.status = "staged";
+			} else {
+				item.status = "failed";
+				item.error = "Publication interrupted and target changed; manual review required";
+			}
+			else {
+				const trash = this.trashPath(job, item);
+				if (!hash && item.action.beforeHash !== null && item.backupPath && this.targetHash(item.backupPath) === item.action.beforeHash) renameSync(item.backupPath, dest);
+				else if (hash === item.afterHash && !existsSync(trash)) {
+					item.status = "active";
+					this.repo.save("job", job);
+					continue;
+				} else if (hash !== item.action.beforeHash) {
+					item.error = "Rollback interrupted; target needs review";
+					this.repo.save("job", job);
+					continue;
+				}
+				item.status = "rolled_back";
+				rmSync(trash, {
+					recursive: true,
+					force: true
+				});
+			}
+			this.repo.save("job", job);
+		}
+		return job;
+	}
+	targetHash(path) {
+		if (!existsSync(path)) return null;
+		if (canonicalTarget(path) !== path || lstatSync(path).isSymbolicLink()) throw new ImportError("unsafe_target", "Target is a symbolic link", 409);
+		return fileHash(readTree(path));
+	}
+	assertLive(job) {
+		if (Date.now() > job.expiresAt) throw new ImportError("expired", "Import recovery period has expired", 409);
+	}
+	checkSelection(job, ids) {
+		if (!ids.length || new Set(ids).size !== ids.length || ids.some((id) => !job.items.some((i) => i.action.candidateId === id))) throw new ImportError("invalid_selection", "Select valid import items");
+	}
+	lock(run) {
+		const release = lockfile.lockSync(this.root, { realpath: false });
+		try {
+			return run();
+		} finally {
+			release();
+		}
+	}
+};
+//#endregion
+export { ImportService };

package/dist/src/imports/planner.d.ts

@@ -0,0 +1,11 @@
+import { type ImportAction, type ImportPlan, type ImportScan, type ImportTarget } from './types.js';
+export declare function targetInventory(root: string): Array<{
+    directory: string;
+    name: string;
+    hash: string;
+}>;
+export declare function targetRevision(root: string): string;
+export declare function canonicalTarget(root: string): string;
+export declare function createImportPlan(scan: ImportScan, target: ImportTarget, choices: Array<Pick<ImportAction, 'candidateId' | 'operation'> & {
+    name?: string;
+}>, reservedNames?: string[]): ImportPlan;

package/dist/src/imports/planner.js

@@ -0,0 +1,98 @@
+import { isValidSkillId } from "../agent/skills/managed-store.js";
+import { ImportError } from "./types.js";
+import { IMPORT_LIMITS, digest, fileHash, readTree } from "./files.js";
+import { parseSkill } from "./compatibility.js";
+import { join, relative, resolve } from "node:path";
+import { existsSync, readdirSync, realpathSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+//#region src/imports/planner.ts
+function targetInventory(root) {
+	if (!existsSync(root)) return [];
+	let bytes = 0;
+	let count = 0;
+	return readdirSync(root, { withFileTypes: true }).filter((e) => !e.name.startsWith(".")).map((entry) => {
+		if (!entry.isDirectory() || entry.isSymbolicLink()) throw new ImportError("unsafe_target", "Target contains a link or non-directory item", 409);
+		const files = readTree(join(root, entry.name));
+		bytes += files.reduce((n, f) => n + Buffer.byteLength(f.data, "base64"), 0);
+		count += files.length;
+		if (bytes > IMPORT_LIMITS.total || count > IMPORT_LIMITS.count) throw new ImportError("limit_exceeded", "Target inventory exceeds import limits", 413);
+		const primary = files.find((f) => f.path === "SKILL.md");
+		let name = entry.name;
+		try {
+			if (primary) name = String(parseSkill(Buffer.from(primary.data, "base64").toString("utf8")).metadata.name);
+		} catch {}
+		return {
+			directory: entry.name,
+			name,
+			hash: fileHash(files)
+		};
+	}).sort((a, b) => a.directory.localeCompare(b.directory));
+}
+function targetRevision(root) {
+	return digest(targetInventory(root));
+}
+function canonicalTarget(root) {
+	let current = resolve(root);
+	while (!existsSync(current)) {
+		const parent = resolve(current, "..");
+		if (parent === current) break;
+		current = parent;
+	}
+	return join(realpathSync(current), relative(current, resolve(root)));
+}
+function createImportPlan(scan, target, choices, reservedNames = []) {
+	if (Date.now() - scan.createdAt > 1440 * 60 * 1e3) throw new ImportError("plan_stale", "Scan expired; scan again", 409);
+	target = {
+		...target,
+		root: canonicalTarget(target.root)
+	};
+	const inventory = targetInventory(target.root);
+	const used = /* @__PURE__ */ new Set();
+	const candidates = /* @__PURE__ */ new Set();
+	const normalize = (s) => s.normalize("NFC").toLowerCase();
+	const actions = choices.map((choice) => {
+		const item = scan.candidates.find((c) => c.id === choice.candidateId);
+		if (!item || candidates.has(item.id)) throw new ImportError("invalid_selection", "Invalid or duplicate candidate");
+		candidates.add(item.id);
+		const name = choice.name ?? item.name;
+		if (!isValidSkillId(name)) throw new ImportError("invalid_name", "Choose a name using letters, numbers, dot, dash or underscore");
+		if (choice.operation !== "skip" && !["compatible", "needs_setup"].includes(item.compatibility)) throw new ImportError("incompatible", "Selected item requires manual adaptation");
+		if (item.scope === "project" && !target.projectId && choice.operation !== "skip") throw new ImportError("scope_mismatch", "Project capabilities must remain project-scoped");
+		if (item.kind !== "skill" && choice.operation !== "skip" && choice.operation !== "create") throw new ImportError("invalid_operation", "MCP drafts only support create");
+		const existing = item.kind === "skill" ? inventory.find((e) => normalize(e.directory) === normalize(name) || normalize(e.name) === normalize(name)) : void 0;
+		const hash = existing?.hash ?? null;
+		if (choice.operation !== "skip") {
+			const key = `${item.kind}:${normalize(name)}`;
+			if (used.has(key)) throw new ImportError("conflict", "Two selected items have the same target name", 409);
+			used.add(key);
+			if (existing?.hash === item.hash && choice.operation === "create") return {
+				candidateId: item.id,
+				operation: "skip",
+				name,
+				beforeHash: hash
+			};
+			if (choice.operation === "replace") {
+				if (!existing || existing.directory !== name || existing.name !== name) throw new ImportError("conflict", "Replace requires an exact managed directory and skill name match", 409);
+			} else if (existing || item.kind === "skill" && reservedNames.some((n) => normalize(n) === normalize(name))) throw new ImportError("conflict", "Name is already used; choose another name or explicitly replace a managed skill", 409);
+			if (choice.operation === "create" && name !== item.name) throw new ImportError("invalid_operation", "Use rename when changing the skill name");
+		}
+		return {
+			candidateId: item.id,
+			operation: choice.operation,
+			name,
+			beforeHash: hash
+		};
+	});
+	if (!actions.length) throw new ImportError("invalid_selection", "Select at least one item");
+	return {
+		id: randomUUID(),
+		scanId: scan.id,
+		createdAt: Date.now(),
+		expiresAt: Date.now() + 1440 * 60 * 1e3,
+		target,
+		targetRevision: digest(inventory),
+		actions
+	};
+}
+//#endregion
+export { canonicalTarget, createImportPlan, targetInventory, targetRevision };

package/dist/src/imports/productImport.d.ts

@@ -0,0 +1,10 @@
+import type { ImportService } from './importService.js';
+import { type ImportSource, type ProductImportResult } from './types.js';
+export declare function listImportSources(owner: string): {
+    lastImport: ProductImportResult;
+    id: ImportSource;
+    name: string;
+    detected: boolean;
+}[];
+/** One product action. Destination services retain their existing scope and trust policies. */
+export declare function importProduct(service: ImportService, source: ImportSource, requestId?: string, owner?: string): Promise<ProductImportResult>;

package/dist/src/imports/productImport.js

@@ -0,0 +1,148 @@
+import { resolveStateDir } from "../config/paths-state.js";
+import { init_paths } from "../config/paths.js";
+import { ProjectService } from "../projects/project-service.js";
+import { ImportError } from "./types.js";
+import { importContextDocument } from "./contextImport.js";
+import { ImportRepository } from "../storage/sqlite/import-repository.js";
+import { detectImportSources } from "./sources.js";
+import { resolveImportTarget } from "./runtime.js";
+import { isAbsolute, join, parse } from "node:path";
+import { mkdirSync, realpathSync, statSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import lockfile from "proper-lockfile";
+//#region src/imports/productImport.ts
+init_paths();
+function listImportSources(owner) {
+	const runs = new ImportRepository(owner).latestRuns();
+	return detectImportSources().map((source) => ({
+		...source,
+		lastImport: runs.find((r) => r.source === source.id)
+	}));
+}
+/** One product action. Destination services retain their existing scope and trust policies. */
+async function importProduct(service, source, requestId = randomUUID(), owner = "gateway-owner") {
+	const root = join(resolveStateDir(), "imports", "product-import");
+	mkdirSync(root, {
+		recursive: true,
+		mode: 448
+	});
+	const release = await lockfile.lock(root, {
+		realpath: false,
+		retries: {
+			retries: 10,
+			minTimeout: 100,
+			maxTimeout: 500
+		}
+	});
+	const repo = new ImportRepository(owner);
+	try {
+		try {
+			const previous = repo.get("run", requestId);
+			if (previous.source !== source) throw new ImportError("conflict", "Request belongs to another product", 409);
+			return previous;
+		} catch (error) {
+			if (!(error instanceof ImportError) || error.code !== "not_found") throw error;
+		}
+		if (!detectImportSources().some((s) => s.id === source && s.detected)) throw new ImportError("source_not_found", "This app is no longer available on the xopc device", 404);
+		const result = {
+			id: requestId,
+			source,
+			createdAt: Date.now(),
+			skills: 0,
+			context: 0,
+			projects: 0,
+			skipped: 0,
+			issues: []
+		};
+		const budget = {
+			bytes: 0,
+			files: 0
+		};
+		const scan = service.scan({
+			source,
+			budget
+		});
+		const saveContext = (items, projectId) => {
+			for (const item of items.filter((c) => c.kind === "rule" && c.scope === (projectId ? "project" : "user"))) {
+				if (!item.content || item.compatibility !== "compatible") {
+					result.issues.push({
+						name: item.name,
+						reason: item.findings.join("; ")
+					});
+					continue;
+				}
+				try {
+					const status = importContextDocument(item, projectId);
+					if (status === "created") result.context++;
+					else if (status === "unchanged") result.skipped++;
+					else result.issues.push({
+						name: item.name,
+						reason: "Existing context was kept. The source document has changed."
+					});
+				} catch {
+					result.issues.push({
+						name: item.name,
+						reason: "Unable to save this context document. Try again."
+					});
+				}
+			}
+		};
+		const importScope = async (scopeScan, projectId) => {
+			const scoped = {
+				...scopeScan,
+				candidates: scopeScan.candidates.filter((c) => c.scope === (projectId ? "project" : "user"))
+			};
+			result.issues.push(...scopeScan.diagnostics.map((reason) => ({
+				name: source,
+				reason
+			})));
+			saveContext(scoped.candidates, projectId);
+			for (const item of scoped.candidates.filter((c) => c.kind === "mcp")) result.issues.push({
+				name: item.name,
+				reason: "Reconnect this tool in Connections; credentials and executable settings are not transferred."
+			});
+			try {
+				const skills = await service.importSkills(scoped, resolveImportTarget(projectId));
+				result.skills += skills.imported;
+				result.skipped += skills.skipped;
+				result.issues.push(...skills.issues);
+			} catch (error) {
+				result.issues.push({
+					name: projectId ? "Project skills" : "Skills",
+					reason: error instanceof ImportError ? error.message : "Unable to import skills. Try again."
+				});
+			}
+		};
+		await importScope(scan);
+		const projects = new ProjectService();
+		const seen = /* @__PURE__ */ new Set();
+		for (const path of scan.projectRoots ?? []) try {
+			if (!isAbsolute(path) || parse(path).root === path || !statSync(path).isDirectory()) throw new Error("Invalid project");
+			const workspaceRoot = realpathSync(path);
+			if (seen.has(workspaceRoot)) continue;
+			seen.add(workspaceRoot);
+			let project = projects.findByWorkspaceRoot(workspaceRoot);
+			if (!project) {
+				project = projects.create({ workspaceRoot });
+				result.projects++;
+			} else result.skipped++;
+			await importScope(service.scan({
+				source,
+				projectRoot: workspaceRoot,
+				projectOnly: true,
+				budget
+			}), project.id);
+		} catch {
+			result.issues.push({
+				name: path,
+				reason: "Project unavailable; existing content was kept."
+			});
+		}
+		repo.save("run", result);
+		return result;
+	} finally {
+		await release();
+	}
+}
+//#endregion
+export { importProduct, listImportSources };