@xopcai/xopc 0.0.188 → 0.0.190

package/dist/src/agent/code-intelligence/binary.d.ts

@@ -1,15 +0,0 @@
-type FetchImplementation = typeof fetch;
-export interface DownloadCodebaseMemoryBinaryOptions {
-    fetchImplementation?: FetchImplementation;
-    timeoutMs?: number;
-}
-/** Resolve an explicit, shared, or bundled binary synchronously when already present. */
-export declare function resolveCodebaseMemoryBinary(explicitPath?: string): string;
-/** Download and checksum-verify the CBM executable into a caller-provided path. */
-export declare function downloadCodebaseMemoryBinary(destination: string, options?: DownloadCodebaseMemoryBinaryOptions): Promise<string>;
-/**
- * Resolve a shared, versioned user cache. Electron seeds it from its bundled binary;
- * CLI seeds it from a verified release download. This keeps both surfaces on one binary.
- */
-export declare function ensureCodebaseMemoryBinary(explicitPath?: string): Promise<string>;
-export {};

package/dist/src/agent/code-intelligence/binary.js

@@ -1,372 +0,0 @@
-import { resolveStateDir } from "../../config/paths-state.js";
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { init_paths, resolveBinDir } from "../../config/paths.js";
-import { createRequire } from "node:module";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { accessSync, chmodSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { execFile } from "node:child_process";
-import { createHash, randomBytes } from "node:crypto";
-import { Readable } from "node:stream";
-import { promisify } from "node:util";
-import { pipeline } from "node:stream/promises";
-import lockfile from "proper-lockfile";
-//#region src/agent/code-intelligence/binary.ts
-init_paths();
-init_logger();
-const require = createRequire(import.meta.url);
-const log = createLogger("CodeIntelligenceBinary");
-const CBM_VERSION = "0.9.0";
-const CACHE_SCHEMA_VERSION = 1;
-const DOWNLOAD_TIMEOUT_MS = 2 * 6e4;
-const RELEASE_BASE_URL = `https://github.com/DeusData/codebase-memory-mcp/releases/download/v${CBM_VERSION}`;
-const execFileAsync = promisify(execFile);
-function binaryName() {
-	return process.platform === "win32" ? "codebase-memory-mcp.exe" : "codebase-memory-mcp";
-}
-function platformName() {
-	switch (process.platform) {
-		case "darwin": return "darwin";
-		case "linux": return "linux";
-		case "win32": return "windows";
-		default: throw new Error(`Code intelligence is not supported on ${process.platform}`);
-	}
-}
-function architectureName() {
-	switch (process.arch) {
-		case "arm64": return "arm64";
-		case "x64": return "amd64";
-		default: throw new Error(`Code intelligence is not supported on ${process.arch}`);
-	}
-}
-function platformKey() {
-	return `${platformName()}-${architectureName()}`;
-}
-function archiveName() {
-	const platform = platformName();
-	const extension = platform === "windows" ? "zip" : "tar.gz";
-	const linuxPortable = platform === "linux" ? "-portable" : "";
-	return `codebase-memory-mcp-${platform}-${architectureName()}${linuxPortable}.${extension}`;
-}
-function releaseUrl() {
-	return `${RELEASE_BASE_URL}/${archiveName()}`;
-}
-function archiveExtension() {
-	return platformName() === "windows" ? "zip" : "tar.gz";
-}
-function cacheVersionRoot() {
-	return join(resolveBinDir(), "codebase-memory-mcp", `v${CBM_VERSION}`);
-}
-function cacheDir() {
-	return join(cacheVersionRoot(), platformKey());
-}
-function cacheBinaryPath() {
-	return join(cacheDir(), binaryName());
-}
-function cacheManifestPath(dir = cacheDir()) {
-	return join(dir, "manifest.json");
-}
-function legacyManagedBinaryPath() {
-	return join(resolveStateDir(), "code-intelligence", "bin", `v${CBM_VERSION}`, platformKey(), binaryName());
-}
-function isUsableBinary(path) {
-	if (!existsSync(path)) return false;
-	try {
-		accessSync(path, process.platform === "win32" ? constants.F_OK : constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function expectedSha256(checksums, filename) {
-	for (const line of checksums.split(/\r?\n/)) {
-		const match = /^([a-f0-9]{64})\s+\*?(.+)$/i.exec(line.trim());
-		if (match?.[2] === filename) return match[1].toLowerCase();
-	}
-	throw new Error(`checksums.txt does not contain ${filename}`);
-}
-async function sha256(path) {
-	const hash = createHash("sha256");
-	await new Promise((resolvePromise, reject) => {
-		const input = createReadStream(path);
-		input.on("data", (chunk) => hash.update(chunk));
-		input.once("error", reject);
-		input.once("end", resolvePromise);
-	});
-	return hash.digest("hex");
-}
-function readManagedManifest(dir = cacheDir()) {
-	try {
-		const parsed = JSON.parse(readFileSync(cacheManifestPath(dir), "utf8"));
-		if (parsed.schemaVersion !== CACHE_SCHEMA_VERSION || parsed.component !== "codebase-memory-mcp" || parsed.cbmVersion !== CBM_VERSION || parsed.platform !== platformName() || parsed.arch !== architectureName() || parsed.binaryName !== binaryName() || typeof parsed.binarySha256 !== "string" || typeof parsed.binarySize !== "number") return;
-		return parsed;
-	} catch {
-		return;
-	}
-}
-function resolveSharedCachedBinary() {
-	const binary = cacheBinaryPath();
-	const manifest = readManagedManifest();
-	if (!manifest || !isUsableBinary(binary)) return void 0;
-	try {
-		return statSync(binary).size === manifest.binarySize ? realpathSync(binary) : void 0;
-	} catch {
-		return;
-	}
-}
-async function verifySharedCachedBinary() {
-	const binary = resolveSharedCachedBinary();
-	const manifest = readManagedManifest();
-	if (!binary || !manifest) return void 0;
-	try {
-		return await sha256(binary) === manifest.binarySha256 ? binary : void 0;
-	} catch {
-		return;
-	}
-}
-function packageBinaryPath() {
-	try {
-		return join(dirname(require.resolve("codebase-memory-mcp/package.json")), "bin", binaryName());
-	} catch {
-		return;
-	}
-}
-function overrideBinaryPath(explicitPath) {
-	for (const candidate of [explicitPath, process.env.XOPC_CBM_BINARY]) {
-		if (!candidate?.trim()) continue;
-		const absolute = resolve(candidate);
-		if (isUsableBinary(absolute)) return realpathSync(absolute);
-	}
-}
-function bundledBinaryCandidates() {
-	const bundledPath = process.env.XOPC_CBM_BUNDLED_PATH?.trim();
-	const bundledManifestPath = process.env.XOPC_CBM_BUNDLED_MANIFEST_PATH?.trim();
-	const resourcesPath = process.resourcesPath;
-	const resourcePath = resourcesPath ? join(resourcesPath, "bin", binaryName()) : void 0;
-	const packagePath = packageBinaryPath();
-	const candidates = [];
-	if (bundledPath) candidates.push({
-		path: bundledPath,
-		source: "electron-bundle",
-		manifestPath: bundledManifestPath || join(dirname(bundledPath), "codebase-memory-mcp.manifest.json")
-	});
-	if (resourcePath && resourcePath !== bundledPath) candidates.push({
-		path: resourcePath,
-		source: "electron-bundle",
-		manifestPath: join(dirname(resourcePath), "codebase-memory-mcp.manifest.json")
-	});
-	if (packagePath) candidates.push({
-		path: packagePath,
-		source: "package-bundle"
-	});
-	candidates.push({
-		path: legacyManagedBinaryPath(),
-		source: "legacy-cache"
-	});
-	return candidates;
-}
-async function verifyBundledSource(candidate) {
-	if (!isUsableBinary(candidate.path)) throw new Error(`source binary is unavailable at ${candidate.path}`);
-	if (candidate.source !== "electron-bundle") return;
-	if (!candidate.manifestPath) throw new Error("Electron CBM manifest path is missing");
-	let manifest;
-	try {
-		manifest = JSON.parse(readFileSync(candidate.manifestPath, "utf8"));
-	} catch (error) {
-		throw new Error(`Electron CBM manifest is unreadable: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (manifest.cbmVersion !== CBM_VERSION || manifest.platform !== platformName() || manifest.arch !== architectureName() || !/^[a-f0-9]{64}$/i.test(manifest.binarySha256)) throw new Error("Electron CBM manifest does not match this runtime");
-	const actual = await sha256(candidate.path);
-	if (actual !== manifest.binarySha256.toLowerCase()) throw new Error(`Electron CBM checksum mismatch: expected ${manifest.binarySha256}, got ${actual}`);
-}
-async function withCacheLock(fn) {
-	const versionRoot = cacheVersionRoot();
-	mkdirSync(versionRoot, { recursive: true });
-	const release = await lockfile.lock(versionRoot, {
-		realpath: false,
-		lockfilePath: join(versionRoot, `.${platformKey()}.install.lock`),
-		stale: 10 * 6e4,
-		retries: {
-			retries: 30,
-			factor: 1.2,
-			minTimeout: 100,
-			maxTimeout: 1e3
-		}
-	});
-	try {
-		return await fn();
-	} finally {
-		await release();
-	}
-}
-function cleanupStaleStaging(versionRoot) {
-	const prefix = `.${platformKey()}.staging-`;
-	const cutoff = Date.now() - 60 * 6e4;
-	try {
-		for (const entry of readdirSync(versionRoot)) {
-			if (!entry.startsWith(prefix)) continue;
-			const path = join(versionRoot, entry);
-			if (statSync(path).mtimeMs < cutoff) rmSync(path, {
-				recursive: true,
-				force: true
-			});
-		}
-	} catch {}
-}
-async function installInSharedCache(source, populate) {
-	const versionRoot = cacheVersionRoot();
-	const targetDir = cacheDir();
-	const stagingDir = join(versionRoot, `.${platformKey()}.staging-${process.pid}-${randomBytes(6).toString("hex")}`);
-	const stagingBinary = join(stagingDir, binaryName());
-	mkdirSync(stagingDir, { recursive: true });
-	try {
-		await populate(stagingBinary);
-		if (!isUsableBinary(stagingBinary)) throw new Error("staged codebase-memory-mcp binary is not executable");
-		if (process.platform !== "win32") chmodSync(stagingBinary, 493);
-		const binarySha256 = await sha256(stagingBinary);
-		const manifest = {
-			schemaVersion: CACHE_SCHEMA_VERSION,
-			component: "codebase-memory-mcp",
-			cbmVersion: CBM_VERSION,
-			platform: platformName(),
-			arch: architectureName(),
-			binaryName: binaryName(),
-			binarySha256,
-			binarySize: statSync(stagingBinary).size,
-			source,
-			installedAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		writeFileSync(cacheManifestPath(stagingDir), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
-		rmSync(targetDir, {
-			recursive: true,
-			force: true
-		});
-		renameSync(stagingDir, targetDir);
-		return realpathSync(cacheBinaryPath());
-	} catch (error) {
-		rmSync(stagingDir, {
-			recursive: true,
-			force: true
-		});
-		throw error;
-	}
-}
-/** Resolve an explicit, shared, or bundled binary synchronously when already present. */
-function resolveCodebaseMemoryBinary(explicitPath) {
-	const overridden = overrideBinaryPath(explicitPath);
-	if (overridden) return overridden;
-	const shared = resolveSharedCachedBinary();
-	if (shared) return shared;
-	for (const candidate of bundledBinaryCandidates()) {
-		const absolute = resolve(candidate.path);
-		if (isUsableBinary(absolute)) return realpathSync(absolute);
-	}
-	throw new Error("codebase-memory-mcp binary is unavailable");
-}
-/** Download and checksum-verify the CBM executable into a caller-provided path. */
-async function downloadCodebaseMemoryBinary(destination, options = {}) {
-	const fetchImplementation = options.fetchImplementation ?? fetch;
-	const timeoutMs = options.timeoutMs ?? DOWNLOAD_TIMEOUT_MS;
-	const temporaryPath = `${destination}.${process.pid}.part`;
-	const abortController = new AbortController();
-	const tempDir = mkdtempSync(join(tmpdir(), "xopc-cbm-"));
-	const archivePath = join(tempDir, `cbm.${archiveExtension()}`);
-	let timedOut = false;
-	let rejectTimeout;
-	const timeoutPromise = new Promise((_resolve, reject) => {
-		rejectTimeout = reject;
-	});
-	const timer = setTimeout(() => {
-		timedOut = true;
-		abortController.abort();
-		rejectTimeout?.(/* @__PURE__ */ new Error(`download timed out after ${timeoutMs}ms`));
-	}, timeoutMs);
-	try {
-		mkdirSync(dirname(destination), { recursive: true });
-		rmSync(temporaryPath, { force: true });
-		await Promise.race([(async () => {
-			const checksumsResponse = await fetchImplementation(`${RELEASE_BASE_URL}/checksums.txt`, {
-				redirect: "follow",
-				signal: abortController.signal
-			});
-			if (!checksumsResponse.ok) throw new Error(`GitHub Releases returned HTTP ${checksumsResponse.status} for checksums.txt`);
-			const expectedChecksum = expectedSha256(await checksumsResponse.text(), archiveName());
-			const response = await fetchImplementation(releaseUrl(), {
-				redirect: "follow",
-				signal: abortController.signal
-			});
-			if (!response.ok) throw new Error(`GitHub Releases returned HTTP ${response.status}`);
-			if (!response.body) throw new Error("GitHub Releases returned an empty response body");
-			await pipeline(Readable.fromWeb(response.body), createWriteStream(archivePath, { mode: 384 }));
-			const actualChecksum = await sha256(archivePath);
-			if (actualChecksum !== expectedChecksum) throw new Error(`checksum mismatch for ${archiveName()}: expected ${expectedChecksum}, got ${actualChecksum}`);
-			if (archiveExtension() === "tar.gz") await execFileAsync("tar", [
-				"-xzf",
-				archivePath,
-				"-C",
-				tempDir,
-				"--no-same-owner"
-			]);
-			else await execFileAsync("powershell", [
-				"-NoProfile",
-				"-Command",
-				`Expand-Archive -Path '${archivePath}' -DestinationPath '${tempDir}' -Force`
-			]);
-			const extracted = join(tempDir, binaryName());
-			if (!isUsableBinary(extracted)) throw new Error(`binary was not present after extracting ${archiveExtension()} archive`);
-			copyFileSync(extracted, temporaryPath);
-		})(), timeoutPromise]);
-		if (timedOut) throw new Error(`download timed out after ${timeoutMs}ms`);
-		if (process.platform !== "win32") chmodSync(temporaryPath, 493);
-		renameSync(temporaryPath, destination);
-		return realpathSync(destination);
-	} catch (error) {
-		const reason = timedOut ? `download timed out after ${timeoutMs}ms` : error instanceof Error ? error.message : String(error);
-		throw new Error(`Unable to download codebase-memory-mcp from GitHub Releases: ${reason}. Check network access or set XOPC_CBM_BINARY to a trusted executable.`);
-	} finally {
-		clearTimeout(timer);
-		rmSync(temporaryPath, { force: true });
-		rmSync(tempDir, {
-			recursive: true,
-			force: true
-		});
-	}
-}
-/**
-* Resolve a shared, versioned user cache. Electron seeds it from its bundled binary;
-* CLI seeds it from a verified release download. This keeps both surfaces on one binary.
-*/
-async function ensureCodebaseMemoryBinary(explicitPath) {
-	const overridden = overrideBinaryPath(explicitPath);
-	if (overridden) return overridden;
-	const cached = await verifySharedCachedBinary();
-	if (cached) return cached;
-	return withCacheLock(async () => {
-		cleanupStaleStaging(cacheVersionRoot());
-		const afterLock = await verifySharedCachedBinary();
-		if (afterLock) return afterLock;
-		for (const candidate of bundledBinaryCandidates()) try {
-			await verifyBundledSource(candidate);
-			return await installInSharedCache(candidate.source, async (destination) => {
-				copyFileSync(candidate.path, destination);
-			});
-		} catch (error) {
-			log.warn({
-				err: error,
-				source: candidate.source,
-				path: candidate.path
-			}, "Code intelligence binary source was not usable");
-		}
-		log.info({
-			destination: cacheBinaryPath(),
-			version: CBM_VERSION,
-			timeoutMs: DOWNLOAD_TIMEOUT_MS
-		}, "Downloading code intelligence binary into shared cache");
-		return installInSharedCache("github-release", async (destination) => {
-			await downloadCodebaseMemoryBinary(destination);
-		});
-	});
-}
-//#endregion
-export { downloadCodebaseMemoryBinary, ensureCodebaseMemoryBinary, resolveCodebaseMemoryBinary };

package/dist/src/agent/code-intelligence/index.d.ts

@@ -1,4 +0,0 @@
-export { downloadCodebaseMemoryBinary, ensureCodebaseMemoryBinary, resolveCodebaseMemoryBinary, } from './binary.js';
-export { CodeIntelligenceRuntime } from './runtime.js';
-export { createCodeIntelligenceTools, type CodeIntelligenceToolDeps } from './tools.js';
-export type { CodeIntelligenceRuntimeLike, CodeIntelligenceState, CodeIntelligenceStatus, CodeIntelligenceToolResult, } from './types.js';

package/dist/src/agent/code-intelligence/index.js

@@ -1,4 +0,0 @@
-import { createCodeIntelligenceTools } from "./tools.js";
-import { downloadCodebaseMemoryBinary, ensureCodebaseMemoryBinary, resolveCodebaseMemoryBinary } from "./binary.js";
-import { CodeIntelligenceRuntime } from "./runtime.js";
-export { CodeIntelligenceRuntime, createCodeIntelligenceTools, downloadCodebaseMemoryBinary, ensureCodebaseMemoryBinary, resolveCodebaseMemoryBinary };

package/dist/src/agent/code-intelligence/runtime.d.ts

@@ -1,34 +0,0 @@
-import type { Config } from '../../config/schema.js';
-import type { CodeIntelligenceRuntimeLike, CodeIntelligenceStatus, CodeIntelligenceToolResult } from './types.js';
-export declare class CodeIntelligenceRuntime implements CodeIntelligenceRuntimeLike {
-    private readonly workspace;
-    private readonly project;
-    private readonly getConfig;
-    private state;
-    private coverage;
-    private indexedAt;
-    private errorMessage;
-    private dirtyPaths;
-    private dirtyVersion;
-    private refreshTimer;
-    private connectionPromise;
-    private indexPromise;
-    private client;
-    private transport;
-    private availableTools;
-    private disposed;
-    constructor(options: {
-        workspace: string;
-        getConfig: () => Config;
-    });
-    getStatus(): CodeIntelligenceStatus;
-    supportsTool(name: string): boolean;
-    prime(): Promise<void>;
-    markDirty(paths: readonly string[]): void;
-    callTool(toolNames: string | readonly string[], input: Record<string, unknown>, signal?: AbortSignal): Promise<CodeIntelligenceToolResult>;
-    private ensureConnected;
-    private refreshIndex;
-    private callRaw;
-    private resetConnection;
-    dispose(): Promise<void>;
-}