@xopcai/xopc 0.0.283 → 0.0.285

package/dist/src/imports/scanner.js

@@ -0,0 +1,159 @@
+import { containsSecret } from "./secrets.js";
+import { ImportError } from "./types.js";
+import { IMPORT_LIMITS, digest, readRegularFile, readTree } from "./files.js";
+import { inspectMcp, inspectSkill } from "./compatibility.js";
+import { IMPORT_SOURCES, sourceLayout } from "./sources.js";
+import { basename, join } from "node:path";
+import { existsSync, readdirSync, realpathSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { setImmediate } from "node:timers/promises";
+import { parse as parse$1 } from "smol-toml";
+//#region src/imports/scanner.ts
+function scanResult(source) {
+	if (!IMPORT_SOURCES.some((s) => s.id === source)) throw new ImportError("unsupported_source", "Unsupported source");
+	return {
+		id: randomUUID(),
+		createdAt: Date.now(),
+		source,
+		candidates: [],
+		diagnostics: []
+	};
+}
+function base(source, scope, location, shared = false) {
+	return {
+		id: randomUUID(),
+		source,
+		scope,
+		location,
+		shared
+	};
+}
+function appendMcp(scan, raw, scope, location) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+	for (const [name, config] of Object.entries(raw)) scan.candidates.push(inspectMcp(base(scan.source, scope, location), name, config));
+}
+async function scanLocal(input) {
+	const scan = scanResult(input.source);
+	const { home, root, layout } = sourceLayout(input.source, input.home, input.root);
+	const scopes = (input.projectOnly ? [] : layout.skills).map((s) => ({
+		path: join(s.base === "home" ? home : root, s.path),
+		scope: "user",
+		shared: s.shared
+	}));
+	if (input.projectRoot) scopes.push({
+		path: join(input.projectRoot, layout.projectSkills),
+		scope: "project",
+		shared: layout.skills.some((s) => s.shared)
+	});
+	const seen = /* @__PURE__ */ new Set();
+	const budget = input.budget ?? {
+		bytes: 0,
+		files: 0
+	};
+	const consume = (bytes, files) => {
+		budget.bytes += bytes;
+		budget.files += files;
+		if (budget.bytes > IMPORT_LIMITS.total || budget.files > IMPORT_LIMITS.count) throw new ImportError("limit_exceeded", "Import exceeds batch limits", 413);
+	};
+	for (const scope of scopes) {
+		if (!existsSync(scope.path)) continue;
+		let entries;
+		try {
+			entries = readdirSync(scope.path, { withFileTypes: true });
+		} catch {
+			scan.diagnostics.push("Unable to read skills directory");
+			continue;
+		}
+		for (const entry of entries) {
+			await setImmediate();
+			if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+			const location = join(scope.path, entry.name);
+			if (!existsSync(join(location, "SKILL.md"))) continue;
+			try {
+				const real = realpathSync(location);
+				if (seen.has(real)) continue;
+				seen.add(real);
+				const files = readTree(location);
+				consume(files.reduce((n, f) => n + Buffer.byteLength(f.data, "base64"), 0), files.length);
+				scan.candidates.push(inspectSkill(base(input.source, scope.scope, real, scope.shared), files));
+			} catch (error) {
+				if (error instanceof ImportError && error.code === "limit_exceeded") throw error;
+				scan.diagnostics.push(`${entry.name}: ${error instanceof ImportError ? error.message : "Unable to read skill"}`);
+			}
+		}
+	}
+	const configs = [{
+		path: join(root, layout.config.path),
+		scope: "user"
+	}];
+	if (input.projectRoot) configs.push({
+		path: join(input.projectRoot, layout.projectConfig),
+		scope: "project"
+	});
+	for (const config of configs) {
+		if (!existsSync(config.path)) continue;
+		try {
+			const text = readRegularFile(config.path, 1024 * 1024).toString("utf8");
+			const parsed = layout.config.format === "toml" ? parse$1(text) : JSON.parse(text);
+			if (!input.projectOnly || config.scope === "project") appendMcp(scan, parsed[layout.config.mcpKey], config.scope, config.path);
+			const projects = parsed.projects;
+			if (config.scope === "user" && projects && typeof projects === "object" && !Array.isArray(projects)) {
+				scan.projectRoots = Object.keys(projects);
+				if (input.projectRoot) {
+					const project = projects[input.projectRoot];
+					appendMcp(scan, project?.[layout.config.mcpKey], "project", config.path);
+				}
+			}
+		} catch {
+			scan.diagnostics.push(`${basename(config.path)}: invalid or unreadable configuration`);
+		}
+	}
+	const addDocument = (path, scope) => {
+		if (!existsSync(path)) return;
+		try {
+			const content = readRegularFile(path, 128 * 1024).toString("utf8").trim();
+			if (!content) return;
+			consume(Buffer.byteLength(content), 1);
+			const blocked = containsSecret(content);
+			scan.candidates.push({
+				...base(input.source, scope, realpathSync(path)),
+				kind: "rule",
+				name: basename(path),
+				description: "",
+				hash: digest(content),
+				files: [],
+				compatibility: blocked ? "blocked" : "compatible",
+				findings: blocked ? ["Document contains probable credentials"] : [],
+				requiredEnv: [],
+				content: blocked ? void 0 : content
+			});
+		} catch {
+			scan.diagnostics.push(`${basename(path)}: unable to read context document`);
+		}
+	};
+	const addInstructions = (directory, groups, scope) => {
+		for (const names of groups) {
+			const path = names.map((name) => join(directory, name)).find(existsSync);
+			if (path) addDocument(path, scope);
+		}
+	};
+	const addRules = (directory, scope) => {
+		if (!existsSync(directory)) return;
+		try {
+			for (const entry of readdirSync(directory, { withFileTypes: true }).slice(0, 100)) if (entry.isFile() && entry.name.endsWith(".md")) addDocument(join(directory, entry.name), scope);
+		} catch {
+			scan.diagnostics.push("Unable to read rules directory");
+		}
+	};
+	if (!input.projectOnly) {
+		addInstructions(root, layout.instructions, "user");
+		if (layout.rules) addRules(join(root, layout.rules), "user");
+	}
+	if (input.projectRoot) {
+		addInstructions(input.projectRoot, layout.projectInstructions, "project");
+		if (layout.projectRules) addRules(join(input.projectRoot, layout.projectRules), "project");
+	}
+	return scan;
+}
+//#endregion
+export { IMPORT_SOURCES, scanLocal };

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

@@ -0,0 +1,2 @@
+export declare function containsSecret(text: string): boolean;
+export declare function isCredentialPath(path: string): boolean;

package/dist/src/imports/secrets.js

@@ -0,0 +1,9 @@
+//#region src/imports/secrets.ts
+function containsSecret(text) {
+	return /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----|\b(?:sk-[a-zA-Z0-9_-]{20,}|gh[pousr]_[a-zA-Z0-9]{20,}|AKIA[A-Z0-9]{16})\b/i.test(text) || /(?:api[_-]?key|access[_-]?token|client[_-]?secret|password|authorization)\s*[=:]\s*["']?(?!\$|<|\{|process\.env|os\.environ)[a-zA-Z0-9_+/.-]{12,}/i.test(text);
+}
+function isCredentialPath(path) {
+	return /(^|\/)(\.env(?:\..*)?|auth\.json|credentials[^/]*|id_rsa|id_ed25519)$/i.test(path);
+}
+//#endregion
+export { containsSecret, isCredentialPath };

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

@@ -0,0 +1,37 @@
+import { type ImportSource } from './types.js';
+interface SourceLayout {
+    id: ImportSource;
+    name: string;
+    directory: string;
+    environment: string;
+    skills: Array<{
+        base: 'home' | 'root';
+        path: string;
+        shared: boolean;
+    }>;
+    projectSkills: string;
+    instructions: string[][];
+    projectInstructions: string[][];
+    rules?: string;
+    projectRules?: string;
+    config: {
+        path: string;
+        format: 'json' | 'toml';
+        mcpKey: string;
+    };
+    projectConfig: string;
+}
+/** Product differences live here; readers and destination writers are shared. */
+export declare const IMPORT_SOURCES: readonly SourceLayout[];
+export declare function sourceLayout(source: ImportSource, home?: string, root?: string): {
+    layout: SourceLayout;
+    home: string;
+    root: string;
+};
+export declare function detectImportSources(): {
+    id: ImportSource;
+    name: string;
+    detected: boolean;
+}[];
+export declare function isImportSource(value: string): value is ImportSource;
+export {};

package/dist/src/imports/sources.js

@@ -0,0 +1,75 @@
+import { ImportError } from "./types.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+//#region src/imports/sources.ts
+/** Product differences live here; readers and destination writers are shared. */
+const IMPORT_SOURCES = [{
+	id: "codex",
+	name: "Codex",
+	directory: ".codex",
+	environment: "CODEX_HOME",
+	skills: [{
+		base: "home",
+		path: ".agents/skills",
+		shared: true
+	}],
+	projectSkills: ".agents/skills",
+	instructions: [["AGENTS.override.md", "AGENTS.md"]],
+	projectInstructions: [["AGENTS.override.md", "AGENTS.md"]],
+	config: {
+		path: "config.toml",
+		format: "toml",
+		mcpKey: "mcp_servers"
+	},
+	projectConfig: ".codex/config.toml"
+}, {
+	id: "claude-code",
+	name: "Claude Code",
+	directory: ".claude",
+	environment: "CLAUDE_CONFIG_DIR",
+	skills: [{
+		base: "root",
+		path: "skills",
+		shared: false
+	}],
+	projectSkills: ".claude/skills",
+	instructions: [["CLAUDE.md"]],
+	projectInstructions: [
+		["CLAUDE.md"],
+		[".claude/CLAUDE.md"],
+		["CLAUDE.local.md"]
+	],
+	rules: "rules",
+	projectRules: ".claude/rules",
+	config: {
+		path: "../.claude.json",
+		format: "json",
+		mcpKey: "mcpServers"
+	},
+	projectConfig: ".mcp.json"
+}];
+function sourceLayout(source, home, root) {
+	const layout = IMPORT_SOURCES.find((s) => s.id === source);
+	if (!layout) throw new ImportError("unsupported_source", "Unsupported source");
+	return {
+		layout,
+		home: home ?? homedir(),
+		root: root ?? (home ? void 0 : process.env[layout.environment]) ?? join(home ?? homedir(), layout.directory)
+	};
+}
+function detectImportSources() {
+	return IMPORT_SOURCES.map((s) => {
+		const { root } = sourceLayout(s.id);
+		return {
+			id: s.id,
+			name: s.name,
+			detected: existsSync(root) || existsSync(join(root, s.config.path))
+		};
+	});
+}
+function isImportSource(value) {
+	return IMPORT_SOURCES.some((source) => source.id === value);
+}
+//#endregion
+export { IMPORT_SOURCES, detectImportSources, isImportSource, sourceLayout };

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

@@ -0,0 +1,144 @@
+export type ImportSource = 'codex' | 'claude-code';
+export type ImportScope = 'user' | 'project';
+export type Compatibility = 'compatible' | 'needs_setup' | 'blocked' | 'unsupported';
+export interface ImportFile {
+    path: string;
+    data: string;
+    executable: boolean;
+}
+export interface ImportCandidate {
+    id: string;
+    source: ImportSource;
+    kind: 'skill' | 'mcp' | 'rule';
+    name: string;
+    description: string;
+    scope: ImportScope;
+    location: string;
+    hash: string;
+    compatibility: Compatibility;
+    findings: string[];
+    files: ImportFile[];
+    content?: string;
+    mcp?: Record<string, unknown>;
+    requiredEnv: string[];
+    shared: boolean;
+    connected?: boolean;
+}
+export interface ImportScan {
+    id: string;
+    createdAt: number;
+    source: ImportSource;
+    candidates: ImportCandidate[];
+    diagnostics: string[];
+    projectRoots?: string[];
+}
+export interface ImportTarget {
+    projectId?: string;
+    root: string;
+}
+export interface ImportAction {
+    candidateId: string;
+    operation: 'skip' | 'create' | 'rename' | 'replace';
+    name: string;
+    beforeHash: string | null;
+}
+export interface ImportPlan {
+    id: string;
+    scanId: string;
+    createdAt: number;
+    expiresAt: number;
+    target: ImportTarget;
+    targetRevision: string;
+    actions: ImportAction[];
+}
+export interface ImportJobItem {
+    action: ImportAction;
+    status: 'staged' | 'skipped' | 'publishing' | 'active' | 'rolling_back' | 'rolled_back' | 'failed';
+    error?: string;
+    afterHash?: string;
+    backupPath?: string;
+}
+export interface ImportJob {
+    id: string;
+    plan: ImportPlan;
+    createdAt: number;
+    expiresAt: number;
+    items: ImportJobItem[];
+}
+export declare class ImportError extends Error {
+    readonly code: string;
+    readonly status: 400 | 403 | 404 | 409 | 413;
+    constructor(code: string, message: string, status?: 400 | 403 | 404 | 409 | 413);
+}
+export type InventoryStatus = 'ready' | 'existing' | 'conflict' | 'blocked';
+export interface InventoryItem {
+    id: string;
+    kind: 'skill' | 'context' | 'project';
+    parentId?: string;
+    name: string;
+    description: string;
+    displayPath: string;
+    scope: ImportScope;
+    status: InventoryStatus;
+    reason?: string;
+    suggested: boolean;
+    targetName?: string;
+}
+export interface ImportInventory {
+    id: string;
+    source: ImportSource;
+    createdAt: number;
+    expiresAt: number;
+    candidates: InventoryItem[];
+    notices: string[];
+    complete: boolean;
+}
+export interface StoredInventoryItem extends InventoryItem {
+    location: string;
+    scanId?: string;
+    candidate?: ImportCandidate;
+    targetRoot?: string;
+    projectId?: string;
+}
+export interface StoredInventory extends Omit<ImportInventory, 'candidates'> {
+    candidates: StoredInventoryItem[];
+    scanIds: string[];
+}
+export interface ImportSelection {
+    inventoryId: string;
+    candidateIds: string[];
+    requestId: string;
+    retryOf?: string;
+}
+export interface ImportRunItem {
+    candidateId: string;
+    kind: InventoryItem['kind'];
+    name: string;
+    status: 'pending' | 'imported' | 'existing' | 'failed';
+    targetId?: string;
+    jobId?: string;
+    error?: string;
+}
+export interface ProductImportResult {
+    id: string;
+    source: ImportSource;
+    createdAt: number;
+    inventoryId: string;
+    selectionHash: string;
+    status: 'running' | 'completed' | 'partial';
+    items: ImportRunItem[];
+    skills: number;
+    context: number;
+    projects: number;
+    skipped: number;
+    issues: Array<{
+        name: string;
+        reason: string;
+    }>;
+}
+export interface DetectedImportSource {
+    id: ImportSource;
+    name: string;
+    detected: boolean;
+    lastImport?: ProductImportResult;
+}

package/dist/src/imports/types.js

@@ -0,0 +1,11 @@
+//#region src/imports/types.ts
+var ImportError = class extends Error {
+	constructor(code, message, status = 400) {
+		super(message);
+		this.code = code;
+		this.status = status;
+		this.name = "ImportError";
+	}
+};
+//#endregion
+export { ImportError };

package/dist/src/infra/background-task.d.ts

@@ -0,0 +1,2 @@
+/** Run one background tick at a time, reporting once per consecutive failure period. */
+export declare function createBackgroundTask(run: () => void | Promise<void>, onError: (error: unknown) => void): () => void;

package/dist/src/infra/background-task.js

@@ -0,0 +1,25 @@
+//#region src/infra/background-task.ts
+/** Run one background tick at a time, reporting once per consecutive failure period. */
+function createBackgroundTask(run, onError) {
+	let running = false;
+	let failed = false;
+	return () => {
+		if (running) return;
+		running = true;
+		(async () => {
+			try {
+				await run();
+				failed = false;
+			} catch (error) {
+				if (!failed) {
+					failed = true;
+					onError(error);
+				}
+			} finally {
+				running = false;
+			}
+		})();
+	};
+}
+//#endregion
+export { createBackgroundTask };

package/dist/src/infra/process-diagnostics.d.ts

@@ -0,0 +1,5 @@
+export declare function recordProcessDiagnostic(event: string, detail: unknown): void;
+/** Independent of SQLite and async logger transports; safe to use during process failure. */
+export declare function createProcessDiagnosticWriter(path: string): (event: string, detail: unknown) => void;
+/** Observe fatal exceptions without resuming execution in an unknown process state. */
+export declare function installProcessDiagnostics(path: string): () => void;

package/dist/src/infra/process-diagnostics.js

@@ -0,0 +1,97 @@
+import { init_redact, redactObject, redactSensitiveInfo } from "../utils/logger/redact.js";
+import { dirname } from "node:path";
+import { appendFileSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { inspect } from "node:util";
+//#region src/infra/process-diagnostics.ts
+init_redact();
+const MAX_LOG_BYTES = 2 * 1024 * 1024;
+const MAX_DETAIL_CHARS = 64 * 1024;
+function diagnosticValue(value, depth = 0) {
+	if (depth > 5) return "[MaxDepth]";
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message,
+		stack: value.stack,
+		...value.cause === void 0 ? {} : { cause: diagnosticValue(value.cause, depth + 1) }
+	};
+	if (Array.isArray(value)) return value.slice(0, 30).map((item) => diagnosticValue(item, depth + 1));
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).slice(0, 30).map(([key, item]) => [key, diagnosticValue(item, depth + 1)]));
+	return value;
+}
+let activeWriter;
+function recordProcessDiagnostic(event, detail) {
+	activeWriter?.(event, detail);
+}
+/** Independent of SQLite and async logger transports; safe to use during process failure. */
+function createProcessDiagnosticWriter(path) {
+	return (event, detail) => {
+		try {
+			const text = typeof detail === "string" ? detail : inspect(redactObject(diagnosticValue(detail)), {
+				depth: 5,
+				maxArrayLength: 30,
+				maxStringLength: MAX_DETAIL_CHARS,
+				customInspect: false,
+				getters: false
+			});
+			const line = JSON.stringify({
+				time: (/* @__PURE__ */ new Date()).toISOString(),
+				pid: process.pid,
+				event,
+				detail: redactSensitiveInfo(text).slice(-MAX_DETAIL_CHARS)
+			}) + "\n";
+			mkdirSync(dirname(path), {
+				recursive: true,
+				mode: 448
+			});
+			let size = 0;
+			try {
+				size = statSync(path).size;
+			} catch (err) {
+				if (err.code !== "ENOENT") throw err;
+			}
+			if (size + Buffer.byteLength(line) > MAX_LOG_BYTES) {
+				rmSync(`${path}.2`, { force: true });
+				try {
+					renameSync(`${path}.1`, `${path}.2`);
+				} catch (err) {
+					if (err.code !== "ENOENT") throw err;
+				}
+				renameSync(path, `${path}.1`);
+			}
+			appendFileSync(path, line, {
+				encoding: "utf8",
+				mode: 384
+			});
+		} catch {}
+	};
+}
+/** Observe fatal exceptions without resuming execution in an unknown process state. */
+function installProcessDiagnostics(path) {
+	const write = createProcessDiagnosticWriter(path);
+	const previousWriter = activeWriter;
+	activeWriter = write;
+	const onFatal = (error, origin) => write("uncaught_exception", {
+		origin,
+		error,
+		uptimeSeconds: process.uptime(),
+		memory: process.memoryUsage()
+	});
+	const onExit = (code) => write("process_exit", {
+		code,
+		uptimeSeconds: process.uptime()
+	});
+	process.on("uncaughtExceptionMonitor", onFatal);
+	process.on("exit", onExit);
+	write("process_start", {
+		node: process.version,
+		platform: process.platform,
+		arch: process.arch
+	});
+	return () => {
+		if (activeWriter === write) activeWriter = previousWriter;
+		process.removeListener("uncaughtExceptionMonitor", onFatal);
+		process.removeListener("exit", onExit);
+	};
+}
+//#endregion
+export { createProcessDiagnosticWriter, installProcessDiagnostics, recordProcessDiagnostic };

package/dist/src/infra/unhandled-rejections.js

@@ -1,6 +1,7 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { resolveGlobalSingleton } from "../utils/global-singleton.js";
+import { recordProcessDiagnostic } from "./process-diagnostics.js";
 import { isTransientSqliteError } from "./sqlite-errors.js";
 //#region src/infra/unhandled-rejections.ts
 init_logger();
@@ -10,12 +11,14 @@ function installSqliteTransientRejectionHandler() {
 	const state = resolveGlobalSingleton(installStateKey, () => ({ installed: false }));
 	if (state.installed) return;
 	process.on("unhandledRejection", (reason) => {
-		if (!isTransientSqliteError(reason)) return;
+		recordProcessDiagnostic("unhandled_rejection", reason);
 		const em = reason instanceof Error ? reason.message : String(reason);
-		log.warn({
+		const fields = {
 			err: reason instanceof Error ? reason : void 0,
 			errorMessage: em
-		}, `Transient SQLite rejection: ${em}`);
+		};
+		if (isTransientSqliteError(reason)) log.warn(fields, `Transient SQLite rejection: ${em}`);
+		else log.error(fields, `Unhandled promise rejection: ${em}`);
 	});
 	state.installed = true;
 }

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

@@ -3,9 +3,9 @@ import { init_logger } from "../utils/logger.js";
 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 { authorizeGatewaySigusr1Restart, writeGatewayRestartIntentSync } from "./restart.js";
 import { findVerifiedGatewayListenerPidsOnPortSync, signalVerifiedGatewayPidSync } from "./gateway-processes.js";
+import { resolveGatewayService } from "../daemon/service.js";
 import { refreshGatewayServiceAfterUpdate } from "./update-service-refresh.js";
 //#region src/infra/update-restart.ts
 init_loader();

package/dist/src/knowledge/ingestion-service.js

@@ -89,6 +89,7 @@ var KnowledgeIngestionService = class {
 		const cursorBefore = this.state.getCursor(params.instanceId, params.collectionScope);
 		const run = startKnowledgeSyncRun({
 			sourceInstanceId: params.instanceId,
+			collectionScope: params.collectionScope,
 			cursorBefore
 		});
 		const controller = params.signal ? null : new AbortController();

package/dist/src/knowledge-memory/repository.js

@@ -142,7 +142,9 @@ function searchKnowledgeItems(input) {
 	const visible = visibilityClause(input.context);
 	const sourceParts = [];
 	const sourceValues = [];
-	if (input.sources?.includes("connector")) sourceParts.push("k.record_class = 'source_index'");
+	const importedSource = "COALESCE(json_extract(k.source_json, '$.kind'), '') = 'product_import'";
+	if (input.sources?.includes("connector")) sourceParts.push(`(k.record_class = 'source_index' AND NOT (${importedSource}))`);
+	if (input.sources?.includes("workspace")) sourceParts.push(`(k.record_class = 'source_index' AND ${importedSource})`);
 	const memoryScopes = input.sources?.filter((source) => source !== "connector") ?? [];
 	if (memoryScopes.length) {
 		sourceParts.push(`(k.record_class = 'memory' AND k.scope_type IN (${memoryScopes.map(() => "?").join(", ")}))`);
@@ -163,7 +165,7 @@ function searchKnowledgeItems(input) {
     ORDER BY rank ASC, k.importance DESC, k.updated_at DESC LIMIT ?`).all(fts, principalId, asOf, asOf, asOf, ...input.recordClass ? [input.recordClass] : [], ...sourceValues, ...visible.values, limit).map(fromRow);
 }
 function knowledgeSourceAllowed(item, sources) {
-	if (item.recordClass === "source_index") return sources.includes("connector");
+	if (item.recordClass === "source_index") return sources.includes(item.source.kind === "product_import" ? "workspace" : "connector");
 	return item.scope.type === "session" ? sources.includes("session") : item.scope.type === "workspace" ? sources.includes("workspace") : item.scope.type === "project" ? sources.includes("project") : false;
 }
 //#endregion

package/dist/src/media-shared/http/ssrf-guard.js

@@ -1,5 +1,5 @@
-import { isIP } from "node:net";
 import { promisify } from "node:util";
+import { isIP } from "node:net";
 import { lookup } from "node:dns";
 //#region src/media-shared/http/ssrf-guard.ts
 /**