@xopcai/xopc 0.0.283 → 0.0.285

package/dist/src/imports/inventory.js

@@ -0,0 +1,202 @@
+import { init_paths, resolveSkillsDir } from "../config/paths.js";
+import { listKnowledgeItems } from "../knowledge-memory/repository.js";
+import "../knowledge-memory/index.js";
+import { ProjectService } from "../projects/project-service.js";
+import { resolveWorkspaceSkillsDir } from "../agent/skills/workspace-skills-dir.js";
+import { ImportError } from "./types.js";
+import { digest } from "./files.js";
+import { canonicalTarget } from "./planner.js";
+import { detectImportSources } from "./sources.js";
+import { ImportSelectionRepository } from "../storage/sqlite/import-selection-repository.js";
+import { basename, isAbsolute, parse } from "node:path";
+import { realpathSync, statSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { setImmediate } from "node:timers/promises";
+//#region src/imports/inventory.ts
+init_paths();
+function contextKey(candidate) {
+	return `product-import:${candidate.source}:${digest(candidate.location)}`;
+}
+function existingContext(candidate, projectId) {
+	return listKnowledgeItems({
+		canonicalKey: contextKey(candidate),
+		scope: projectId ? {
+			type: "project",
+			id: projectId
+		} : { type: "global" },
+		statuses: [
+			"active",
+			"candidate",
+			"needs_review",
+			"stale",
+			"archived",
+			"rejected"
+		]
+	})[0];
+}
+function publicInventory(inventory) {
+	return {
+		id: inventory.id,
+		source: inventory.source,
+		createdAt: inventory.createdAt,
+		expiresAt: inventory.expiresAt,
+		complete: inventory.complete,
+		notices: inventory.notices,
+		candidates: inventory.candidates.map(({ id, kind, parentId, name, description, displayPath, scope, status, reason, suggested, targetName }) => ({
+			id,
+			kind,
+			parentId,
+			name,
+			description,
+			displayPath,
+			scope,
+			status,
+			reason,
+			suggested,
+			targetName
+		}))
+	};
+}
+function getLiveInventory(owner, id) {
+	const inventory = new ImportSelectionRepository(owner).get("inventory", id);
+	if (Date.now() > inventory.expiresAt) throw new ImportError("inventory_stale", "This list has expired. Refresh it before importing.", 409);
+	return inventory;
+}
+async function scanProduct(service, source, owner = "gateway-owner") {
+	if (!detectImportSources().some((s) => s.id === source && s.detected)) throw new ImportError("source_not_found", "App is unavailable on the xopc device", 404);
+	const inventory = {
+		id: randomUUID(),
+		source,
+		createdAt: Date.now(),
+		expiresAt: Date.now() + 15 * 6e4,
+		candidates: [],
+		notices: [],
+		complete: true,
+		scanIds: []
+	};
+	const budget = {
+		bytes: 0,
+		files: 0
+	};
+	const projects = new ProjectService();
+	const addScan = (scan, targetRoot, parent) => {
+		inventory.scanIds.push(scan.id);
+		inventory.notices.push(...scan.diagnostics);
+		if (scan.diagnostics.length) inventory.complete = false;
+		const relevant = {
+			...scan,
+			candidates: scan.candidates.filter((c) => c.scope === (parent ? "project" : "user"))
+		};
+		const skills = service.describeSkills(relevant, {
+			root: targetRoot,
+			projectId: parent?.projectId
+		});
+		for (const candidate of relevant.candidates) {
+			if (candidate.kind === "mcp") {
+				inventory.notices.push(`${candidate.name}: reconnect this tool in Connections.`);
+				continue;
+			}
+			const item = {
+				id: candidate.id,
+				kind: candidate.kind === "rule" ? "context" : "skill",
+				parentId: parent?.id,
+				name: candidate.name,
+				description: candidate.description,
+				displayPath: candidate.location,
+				location: candidate.location,
+				scope: candidate.scope,
+				status: candidate.compatibility === "compatible" ? "ready" : "blocked",
+				suggested: false,
+				reason: candidate.findings.join("; ") || void 0,
+				scanId: scan.id,
+				candidate,
+				targetRoot,
+				projectId: parent?.projectId
+			};
+			if (item.kind === "skill") {
+				const state = skills.find((s) => s.candidate.id === candidate.id);
+				item.status = state.status;
+				item.reason = state.reason;
+				item.targetName = state.targetName;
+				if (parent && !service.isWorkspaceTrusted(parent.location) && item.status !== "existing") {
+					item.status = "blocked";
+					item.reason = "Trust this project in Projects before importing its skills.";
+				}
+				item.suggested = item.status === "ready";
+			} else if (item.status === "ready") {
+				const existing = !parent || parent.projectId ? existingContext(candidate, parent?.projectId) : void 0;
+				if (existing) {
+					item.status = existing.source.hash === candidate.hash ? "existing" : "blocked";
+					item.reason = item.status === "blocked" ? "Previously imported context has changed; existing content will be kept." : void 0;
+				}
+			}
+			inventory.candidates.push(item);
+		}
+	};
+	const scan = await service.scan({
+		source,
+		budget
+	});
+	addScan(scan, canonicalTarget(resolveSkillsDir()));
+	const seen = /* @__PURE__ */ new Set();
+	const paths = scan.projectRoots ?? [];
+	const limit = 500;
+	if (paths.length > limit) {
+		inventory.complete = false;
+		inventory.notices.push(`${paths.length - limit} project directories were not scanned (limit: ${limit}).`);
+	}
+	for (const path of paths.slice(0, limit)) {
+		await setImmediate();
+		let parent;
+		try {
+			if (!isAbsolute(path) || parse(path).root === path || !statSync(path).isDirectory()) throw new Error("Unavailable project");
+			const location = realpathSync(path);
+			if (parse(location).root === location) throw new Error("Invalid project");
+			if (seen.has(location)) continue;
+			seen.add(location);
+			const existing = projects.findByWorkspaceRoot(location);
+			parent = {
+				id: randomUUID(),
+				kind: "project",
+				name: existing?.name ?? basename(location),
+				description: "",
+				displayPath: path,
+				location,
+				scope: "project",
+				status: existing ? "existing" : "ready",
+				suggested: false,
+				projectId: existing?.id
+			};
+			inventory.candidates.push(parent);
+			addScan(await service.scan({
+				source,
+				projectRoot: location,
+				projectOnly: true,
+				budget
+			}), canonicalTarget(resolveWorkspaceSkillsDir(location)), parent);
+		} catch {
+			inventory.complete = false;
+			inventory.notices.push(`${path}: some contents could not be scanned; only listed items can be imported.`);
+		}
+	}
+	const score = (item) => inventory.candidates.some((c) => c.parentId === item.id && ["ready", "conflict"].includes(c.status)) ? 0 : item.projectId ? 1 : 2;
+	const roots = inventory.candidates.filter((c) => c.kind === "project").sort((a, b) => score(a) - score(b) || a.name.localeCompare(b.name) || a.location.localeCompare(b.location));
+	inventory.candidates = [...inventory.candidates.filter((c) => c.scope === "user"), ...roots.flatMap((p) => [p, ...inventory.candidates.filter((c) => c.parentId === p.id)])];
+	new ImportSelectionRepository(owner).save("inventory", inventory);
+	return publicInventory(inventory);
+}
+function previewInventoryItem(service, owner, inventoryId, itemId) {
+	const item = getLiveInventory(owner, inventoryId).candidates.find((c) => c.id === itemId);
+	if (!item) throw new ImportError("not_found", "Item not found", 404);
+	if (item.status === "blocked") return {
+		text: item.reason ?? "",
+		truncated: false
+	};
+	const text = item.kind === "context" ? item.candidate?.content ?? "" : item.kind === "skill" ? Buffer.from(service.readSnapshot(item.scanId, item.id).find((f) => f.path === "SKILL.md").data, "base64").toString("utf8") : item.displayPath;
+	return {
+		text: text.slice(0, 2e4),
+		truncated: text.length > 2e4
+	};
+}
+//#endregion
+export { contextKey, existingContext, getLiveInventory, previewInventoryItem, publicInventory, scanProduct };

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 ImportSelection, type ProductImportResult } from './types.js';
+export declare function listImportSources(owner: string): {
+    lastImport: ProductImportResult;
+    id: import("./types.js").ImportSource;
+    name: string;
+    detected: boolean;
+}[];
+export declare function importSelection(service: ImportService, selection: ImportSelection, owner?: string): Promise<ProductImportResult>;
+export declare function recoverSelectionRuns(service: ImportService, owner: string): Promise<void>;

package/dist/src/imports/productImport.js

@@ -0,0 +1,241 @@
+import { resolveStateDir } from "../config/paths-state.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { init_paths } from "../config/paths.js";
+import { ProjectService } from "../projects/project-service.js";
+import { ImportError } from "./types.js";
+import { digest, fileHash, readRegularFile, readTree } from "./files.js";
+import { importContextDocument } from "./contextImport.js";
+import { canonicalTarget, targetInventory } from "./planner.js";
+import { detectImportSources } from "./sources.js";
+import { ImportSelectionRepository } from "../storage/sqlite/import-selection-repository.js";
+import { existingContext, getLiveInventory } from "./inventory.js";
+import { join } from "node:path";
+import { mkdirSync, realpathSync, statSync } from "node:fs";
+import { setImmediate } from "node:timers/promises";
+import lockfile from "proper-lockfile";
+//#region src/imports/productImport.ts
+init_paths();
+function listImportSources(owner) {
+	const runs = new ImportSelectionRepository(owner).list("run");
+	return detectImportSources().map((source) => ({
+		...source,
+		lastImport: runs.find((r) => r.source === source.id)
+	}));
+}
+function stale() {
+	throw new ImportError("inventory_stale", "Selected content or its destination changed. Refresh the list before importing.", 409);
+}
+function selectedItems(inventory, ids) {
+	if (!ids.length || new Set(ids).size !== ids.length) throw new ImportError("invalid_selection", "Select at least one item; duplicate selections are not allowed");
+	return ids.map((id) => {
+		const item = inventory.candidates.find((c) => c.id === id);
+		if (!item || item.status === "blocked" || item.status === "existing" && item.kind !== "project") throw new ImportError("invalid_selection", "Select available items from this list");
+		if (item.parentId && !ids.includes(item.parentId)) throw new ImportError("missing_parent", "Select the project entry along with its contents");
+		return item;
+	}).sort((a, b) => Number(b.kind === "project") - Number(a.kind === "project"));
+}
+async function preflight(service, inventory, items, retry) {
+	const projects = new ProjectService();
+	const names = /* @__PURE__ */ new Set();
+	for (const item of items) {
+		await setImmediate();
+		try {
+			if (realpathSync(item.location) !== item.location) stale();
+			if (item.kind === "project") {
+				if (!statSync(item.location).isDirectory()) stale();
+				const existing = projects.findByWorkspaceRoot(item.location);
+				const expectedId = item.projectId ?? retry?.items.find((i) => i.candidateId === item.id)?.targetId;
+				if (existing?.id !== expectedId) stale();
+				continue;
+			}
+			const candidate = item.candidate;
+			const parent = item.parentId ? inventory.candidates.find((c) => c.id === item.parentId) : void 0;
+			if (item.kind === "context") {
+				if (digest(readRegularFile(item.location, 128 * 1024).toString("utf8").trim()) !== candidate.hash) stale();
+				const projectId = parent ? projects.findByWorkspaceRoot(parent.location)?.id : void 0;
+				if ((!parent || projectId) && existingContext(candidate, projectId)) stale();
+			} else {
+				if (parent && !service.isWorkspaceTrusted(parent.location)) stale();
+				if (fileHash(readTree(item.location)) !== candidate.hash) stale();
+				service.readSnapshot(item.scanId, candidate.id);
+				if (canonicalTarget(item.targetRoot) !== item.targetRoot) stale();
+				const key = `${item.targetRoot}:${item.targetName.toLowerCase()}`;
+				if (names.has(key)) stale();
+				names.add(key);
+				const existing = targetInventory(item.targetRoot);
+				const reserved = service.reservedNames({
+					root: item.targetRoot,
+					projectId: parent?.projectId
+				});
+				if ([...existing.flatMap((e) => [e.name, e.directory]), ...reserved].some((n) => n.toLowerCase() === item.targetName.toLowerCase())) stale();
+			}
+		} catch (error) {
+			if (error instanceof ImportError && error.code === "inventory_stale") throw error;
+			stale();
+		}
+	}
+}
+function summarize(run) {
+	run.skills = run.items.filter((i) => i.kind === "skill" && i.status === "imported").length;
+	run.context = run.items.filter((i) => i.kind === "context" && i.status === "imported").length;
+	run.projects = run.items.filter((i) => i.kind === "project" && i.status === "imported").length;
+	run.skipped = run.items.filter((i) => i.status === "existing").length;
+	run.issues = run.items.filter((i) => i.status === "failed").map((i) => ({
+		name: i.name,
+		reason: i.error
+	}));
+}
+async function execute(service, repo, inventory, run) {
+	const projects = new ProjectService();
+	const persist = () => {
+		summarize(run);
+		repo.save("run", run);
+	};
+	for (const entry of run.items.filter((i) => i.status === "pending")) {
+		await setImmediate();
+		const item = inventory.candidates.find((c) => c.id === entry.candidateId);
+		try {
+			if (Date.now() - run.createdAt > 720 * 60 * 6e4) throw new ImportError("expired", "Import recovery period expired. Scan again.");
+			const parent = item.parentId ? run.items.find((i) => i.candidateId === item.parentId) : void 0;
+			if (parent?.status === "failed") throw new ImportError("parent_failed", "The project could not be imported. Retry the project and its contents.");
+			if (item.kind === "project") {
+				if (realpathSync(item.location) !== item.location || !statSync(item.location).isDirectory()) stale();
+				runSqliteWriteTransaction(() => {
+					const existing = projects.findByWorkspaceRoot(item.location);
+					entry.targetId = (existing ?? projects.create({ workspaceRoot: item.location })).id;
+					entry.status = existing ? "existing" : "imported";
+					persist();
+				});
+			} else if (item.kind === "context") runSqliteWriteTransaction(() => {
+				if (parent && projects.get(parent.targetId)?.workspaceRoot !== inventory.candidates.find((c) => c.id === item.parentId).location) stale();
+				const status = importContextDocument(item.candidate, parent?.targetId);
+				if (status === "kept") throw new ImportError("conflict", "Existing context was kept. Refresh before importing.");
+				entry.targetId = existingContext(item.candidate, parent?.targetId)?.id;
+				entry.status = status === "created" ? "imported" : "existing";
+				persist();
+			});
+			else {
+				const key = `${run.id}:${item.id}`;
+				let job = service.jobByKey(key);
+				if (!job) {
+					const plan = service.plan(item.scanId, {
+						root: item.targetRoot,
+						projectId: parent?.targetId
+					}, [{
+						candidateId: item.id,
+						operation: item.targetName === item.candidate.name ? "create" : "rename",
+						name: item.targetName
+					}]);
+					job = service.apply(plan.id, key);
+				}
+				entry.jobId = job.id;
+				persist();
+				job = service.getJob(job.id);
+				const pending = job.items.filter((i) => ["staged", "failed"].includes(i.status));
+				if (pending.length) try {
+					job = await service.activate(job.id, pending.map((i) => i.action.candidateId));
+				} catch (error) {
+					job = service.getJob(job.id);
+					if (!job.items.every((i) => i.status === "active" || i.status === "skipped")) throw error;
+				}
+				const published = job.items[0];
+				if (!["active", "skipped"].includes(published.status)) throw new ImportError("publish_failed", published.error ?? "Could not publish the skill. Retry this item.");
+				entry.targetId = join(item.targetRoot, item.targetName);
+				entry.status = published.status === "active" ? "imported" : "existing";
+			}
+		} catch (error) {
+			entry.status = "failed";
+			delete entry.targetId;
+			entry.error = error instanceof ImportError ? error.message : "This item could not be imported. Check access and retry.";
+		}
+		persist();
+	}
+	run.status = run.items.some((i) => i.status === "failed") ? "partial" : "completed";
+	persist();
+	return run;
+}
+async function withImportLock(fn) {
+	const path = join(resolveStateDir(), "imports", "selection-lock");
+	mkdirSync(path, {
+		recursive: true,
+		mode: 448
+	});
+	const release = await lockfile.lock(path, {
+		realpath: false,
+		stale: 6e4,
+		retries: {
+			retries: 15,
+			minTimeout: 100,
+			maxTimeout: 500
+		}
+	});
+	try {
+		return await fn();
+	} finally {
+		await release();
+	}
+}
+async function importSelection(service, selection, owner = "gateway-owner") {
+	return withImportLock(async () => {
+		const repo = new ImportSelectionRepository(owner);
+		const selectionHash = digest({
+			inventoryId: selection.inventoryId,
+			ids: [...selection.candidateIds].sort(),
+			retryOf: selection.retryOf
+		});
+		let previous;
+		try {
+			previous = repo.get("run", selection.requestId);
+		} catch (error) {
+			if (!(error instanceof ImportError) || error.code !== "not_found") throw error;
+		}
+		if (previous) {
+			if (previous.selectionHash !== selectionHash) throw new ImportError("conflict", "Request ID belongs to a different selection", 409);
+			return previous.status === "running" ? execute(service, repo, repo.get("inventory", previous.inventoryId), previous) : previous;
+		}
+		const inventory = getLiveInventory(owner, selection.inventoryId);
+		const items = selectedItems(inventory, selection.candidateIds);
+		const retry = selection.retryOf ? repo.get("run", selection.retryOf) : void 0;
+		if (retry) {
+			if (retry.status !== "partial" || retry.inventoryId !== inventory.id) throw new ImportError("invalid_selection", "Select failed items from the original import");
+			const failed = new Set(retry.items.filter((i) => i.status === "failed").map((i) => i.candidateId));
+			const parents = new Set(items.filter((i) => failed.has(i.id)).map((i) => i.parentId));
+			if (!items.some((i) => failed.has(i.id)) || items.some((i) => !failed.has(i.id) && !parents.has(i.id))) throw new ImportError("invalid_selection", "Retry can only include failed items and their project entries");
+		}
+		await preflight(service, inventory, items, retry);
+		const run = {
+			id: selection.requestId,
+			inventoryId: inventory.id,
+			selectionHash,
+			source: inventory.source,
+			createdAt: Date.now(),
+			status: "running",
+			skills: 0,
+			context: 0,
+			projects: 0,
+			skipped: 0,
+			issues: [],
+			items: items.map((item) => ({
+				candidateId: item.id,
+				kind: item.kind,
+				name: item.name,
+				status: "pending"
+			}))
+		};
+		repo.save("run", run);
+		return execute(service, repo, inventory, run);
+	});
+}
+async function recoverSelectionRuns(service, owner) {
+	await withImportLock(async () => {
+		const repo = new ImportSelectionRepository(owner);
+		for (const run of repo.list("run").filter((r) => r.status === "running")) await execute(service, repo, repo.get("inventory", run.inventoryId), run);
+		const referenced = new Set(repo.list("run").map((r) => r.inventoryId));
+		for (const inventory of repo.list("inventory")) if (!referenced.has(inventory.id) && inventory.expiresAt < Date.now() || inventory.createdAt < Date.now() - 744 * 60 * 6e4) {
+			for (const scanId of inventory.scanIds) service.discardUnusedScan(scanId);
+			repo.deleteInventory(inventory.id);
+		}
+	});
+}
+//#endregion
+export { importSelection, listImportSources, recoverSelectionRuns };

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

@@ -0,0 +1,5 @@
+import { ImportService } from './importService.js';
+import { type ImportTarget } from './types.js';
+export declare function resolveImportTarget(projectId?: string): ImportTarget;
+export declare function createRuntimeImportService(owner: string, refreshSkills?: () => void | Promise<void>, checkTrust?: (root: string) => boolean): ImportService;
+export declare function recoverCapabilityImports(): Promise<void>;

package/dist/src/imports/runtime.js

@@ -0,0 +1,61 @@
+import { resolveStateDir } from "../config/paths-state.js";
+import { init_paths, resolveBundledSkillsDir, resolveSkillsDir } from "../config/paths.js";
+import { ProjectService } from "../projects/project-service.js";
+import { resolveWorkspaceSkillsDir } from "../agent/skills/workspace-skills-dir.js";
+import { loadSkills } from "../agent/skills/index.js";
+import { ProjectTrustStore } from "../project-trust/trust-store.js";
+import { ImportError } from "./types.js";
+import { ImportRepository } from "../storage/sqlite/import-repository.js";
+import { canonicalTarget } from "./planner.js";
+import { ImportService } from "./importService.js";
+import { ImportSelectionRepository } from "../storage/sqlite/import-selection-repository.js";
+import { existsSync, realpathSync } from "node:fs";
+//#region src/imports/runtime.ts
+init_paths();
+function resolveImportTarget(projectId) {
+	if (!projectId) return { root: canonicalTarget(resolveSkillsDir()) };
+	const project = new ProjectService().get(projectId);
+	if (!project?.workspaceRoot || !existsSync(project.workspaceRoot)) throw new ImportError("invalid_project", "Project needs an existing workspace");
+	return {
+		projectId,
+		root: canonicalTarget(resolveWorkspaceSkillsDir(project.workspaceRoot))
+	};
+}
+function createRuntimeImportService(owner, refreshSkills, checkTrust) {
+	return new ImportService({
+		owner,
+		stateDir: resolveStateDir(),
+		refreshSkills,
+		isWorkspaceTrusted: (root) => checkTrust ? checkTrust(root) : new ProjectTrustStore().get(root) === true,
+		isConnected(candidate, sourceWorkspace) {
+			if (!candidate.shared) return false;
+			const project = candidate.scope === "project" ? new ProjectService().resolveForWorkspacePath(candidate.location)?.project : void 0;
+			const workspaceDir = candidate.scope === "project" ? sourceWorkspace ?? project?.workspaceRoot : void 0;
+			return loadSkills({
+				workspaceDir,
+				workspaceTrust: workspaceDir && (checkTrust ? checkTrust(workspaceDir) : new ProjectTrustStore().get(workspaceDir) === true) ? "trusted" : "untrusted"
+			}).skills.some((s) => realpathSync(s.baseDir) === candidate.location);
+		},
+		validateTarget(target) {
+			if (resolveImportTarget(target.projectId).root !== target.root) throw new ImportError("scope_mismatch", "Project target changed; preview again", 409);
+			if (target.projectId) {
+				const project = new ProjectService().get(target.projectId);
+				if (!(checkTrust ? checkTrust(project.workspaceRoot) : new ProjectTrustStore().get(project.workspaceRoot) === true)) throw new ImportError("workspace_untrusted", "Trust this project in project settings before importing", 403);
+			}
+		},
+		reservedNames(target) {
+			return loadSkills({
+				workspaceDir: target.projectId ? new ProjectService().get(target.projectId)?.workspaceRoot : void 0,
+				workspaceTrust: "trusted",
+				builtinDir: resolveBundledSkillsDir() ?? void 0
+			}).skills.map((s) => s.name);
+		}
+	});
+}
+async function recoverCapabilityImports() {
+	for (const owner of ImportRepository.owners()) await createRuntimeImportService(owner).recoverAndClean();
+	const { recoverSelectionRuns } = await import("./productImport.js");
+	for (const owner of ImportSelectionRepository.owners()) await recoverSelectionRuns(createRuntimeImportService(owner), owner);
+}
+//#endregion
+export { createRuntimeImportService, recoverCapabilityImports, resolveImportTarget };

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

@@ -0,0 +1,14 @@
+import { type ImportScan, type ImportSource } from './types.js';
+export { IMPORT_SOURCES } from './sources.js';
+export interface ScanInput {
+    source: ImportSource;
+    root?: string;
+    projectRoot?: string;
+    home?: string;
+    projectOnly?: boolean;
+    budget?: {
+        bytes: number;
+        files: number;
+    };
+}
+export declare function scanLocal(input: ScanInput): Promise<ImportScan>;