@chatcode/chatcode-cli-test 1.0.47 → 3.0.2

package/lib/chatcode-home-B93iESZd.js

@@ -0,0 +1,48 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+//#region lib/types/chatcode-home.js
+/**
+* ChatCode CLI home resolution owned by the public launcher package.
+* @module @chatcode/chatcode-cli/chatcode-home
+*/
+/** Canonical ChatCode CLI home environment variable. */
+const CHATCODE_CLI_HOME_ENV = "CHATCODE_CLI_HOME";
+/** Legacy Harness home variable accepted as a compatibility input. */
+const LEGACY_DSH_HOME_ENV = "DSH_HOME";
+/** Resolve the default writable ChatCode CLI home. */
+function defaultChatCodeCliHome() {
+	return join(homedir(), ".chatcode-cli");
+}
+/** Expand the supported current-user tilde forms in a configured path.
+* @param path - path that may begin with `~`, `~/`, or `~\`.
+* @returns the path with its current-user tilde expanded.
+*/
+function expandHomePath(path) {
+	if (path === "~") return homedir();
+	if (path.startsWith("~/") || path.startsWith("~\\")) return join(homedir(), path.slice(2));
+	return path;
+}
+/** Resolve the writable ChatCode CLI home with canonical-before-legacy precedence.
+* @param configured - explicit home override with highest precedence.
+* @param env - environment used for canonical and legacy inputs.
+* @returns the normalized absolute home path.
+*/
+function resolveChatCodeCliHome(configured, env = process.env) {
+	const canonical = env[CHATCODE_CLI_HOME_ENV]?.trim();
+	const legacy = env[LEGACY_DSH_HOME_ENV]?.trim();
+	return resolve(expandHomePath(configured ?? (canonical === void 0 || canonical === "" ? legacy === void 0 || legacy === "" ? defaultChatCodeCliHome() : legacy : canonical)));
+}
+/**
+* Point legacy ABI packages at the launcher-selected ChatCode CLI home.
+* Published Harness packages still read `DSH_HOME`; this internal bridge keeps
+* their storage under the canonical home without requiring republished ABI packages.
+* @param env - mutable process environment supplied to legacy packages.
+* @returns the resolved canonical home written to the legacy variable.
+*/
+function synchronizeLegacyHomeEnvironment(env = process.env) {
+	const home = resolveChatCodeCliHome(void 0, env);
+	env[LEGACY_DSH_HOME_ENV] = home;
+	return home;
+}
+//#endregion
+export { synchronizeLegacyHomeEnvironment as i, expandHomePath as n, resolveChatCodeCliHome as r, defaultChatCodeCliHome as t };

package/lib/dump-config-WbxM4B3p.js

@@ -0,0 +1,53 @@
+import { i as homePatchPath, o as prepareProfile, r as PROFILE_ROOT_FILENAME } from "./profile-boot-CCxnpvy7.js";
+import { existsSync } from "node:fs";
+import { loadOptionalPatches, loadOverlayPatches, renderConfigDump } from "@deepseek-ai/dsh-app-boot";
+import { join, resolve } from "node:path";
+//#region lib/types/dump-config.js
+/**
+* Config-dump entry for `dsh --profile <name> --dump-config`: compose the
+* profile's patch layers through the include plugin's patch algorithm without
+* booting or evaluating `!!js`, with one source layer per bundle, the
+* profile's own patch file, and each `--patch` overlay.
+* @module @deepseek-ai/dsh/dump-config
+*/
+const NAME = "ChatCode CLI";
+/* v8 ignore start -- built-bin acceptance drives this boot-free dispatch */
+/**
+* Print a profile composition with comments naming each source file and patch layer.
+* @param profile - the profile name.
+* @param defaultOnly - omit the profile's user layer and `--patch` overlays
+* (the recovery diagnostic for a broken `cordis.patch.yml`, which is then
+* never parsed).
+* @param patches - `--patch` overlay paths, in argv order.
+* @param fromDefaultProfile - shipped template used once to initialize a missing profile.
+*/
+function runDumpConfig(profile, defaultOnly, patches, fromDefaultProfile) {
+	const loaded = prepareProfile(profile, !defaultOnly, fromDefaultProfile);
+	const layers = loaded.layers.map((layer) => ({
+		label: layer.packageName,
+		patches: layer.patches
+	}));
+	if (!defaultOnly) {
+		if (existsSync(loaded.patchPath)) layers.push({
+			label: loaded.patchPath,
+			patches: loaded.patches
+		});
+		const homePatchFile = homePatchPath();
+		const homePatches = loadOptionalPatches(NAME, homePatchFile);
+		if (homePatches !== void 0) layers.push({
+			label: homePatchFile,
+			patches: homePatches
+		});
+		for (const file of patches) {
+			const absolute = resolve(file);
+			layers.push({
+				label: absolute,
+				patches: loadOverlayPatches(NAME, absolute)
+			});
+		}
+	}
+	process.stdout.write(renderConfigDump(NAME, join(loaded.dir, PROFILE_ROOT_FILENAME), layers));
+}
+/* v8 ignore stop */
+//#endregion
+export { runDumpConfig };

package/lib/home-migration-DLaSvmfn.js

@@ -0,0 +1,307 @@
+import { n as expandHomePath, t as defaultChatCodeCliHome } from "./chatcode-home-B93iESZd.js";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, copyFile, link, lstat, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+const LEGACY_HOME_DIRECTORY = ".dsh";
+const LEGACY_TUI_HOME_DIRECTORY = ".dsh-tui";
+const MIGRATION_RECORD_DIRECTORY = "migration/chatcode-cli-home-v1";
+const TRANSIENT_DIRECTORY_NAMES = new Set([
+	"cache",
+	"caches",
+	"tmp",
+	"temp",
+	"run",
+	"inject",
+	"sockets",
+	"locks"
+]);
+const TRANSIENT_FILE_NAMES = new Set(["lock", "pid"]);
+const TRANSIENT_FILE_SUFFIXES = [
+	".pid",
+	".sock",
+	".socket",
+	".lock",
+	".tmp",
+	".temp"
+];
+const TRANSIENT_ENTRY_PREFIXES = [".chatcode-migrate-"];
+function pathParts(relativePath) {
+	return relativePath.split(/[\\/]/u).filter(Boolean);
+}
+/** Classify state that must never be migrated because it is runtime-local or transient. */
+function isTransientMigrationPath(relativePath, kind) {
+	const parts = pathParts(relativePath);
+	if (parts.some((part) => TRANSIENT_DIRECTORY_NAMES.has(part.toLowerCase()))) return true;
+	if (parts.some((part) => TRANSIENT_ENTRY_PREFIXES.some((prefix) => part.toLowerCase().startsWith(prefix)))) return true;
+	if (kind === "directory") return false;
+	const name = parts.at(-1)?.toLowerCase() ?? "";
+	return TRANSIENT_FILE_NAMES.has(name) || TRANSIENT_FILE_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+async function fingerprintFile(path) {
+	return createHash("sha256").update(await readFile(path)).digest("hex");
+}
+function safeRelativePath(relativePath) {
+	return relativePath !== "" && !isAbsolute(relativePath) && !pathParts(relativePath).some((part) => part === "." || part === "..");
+}
+async function pathKind(path) {
+	try {
+		const info = await lstat(path);
+		if (info.isSymbolicLink()) return "symlink";
+		if (info.isFile()) return "file";
+		if (info.isDirectory()) return "directory";
+		return "other";
+	} catch (error) {
+		if (error.code === "ENOENT") return "missing";
+		throw error;
+	}
+}
+/** Resolve the fixed legacy source and the canonical migration destination. */
+function resolveHomeMigrationRoots(env = process.env) {
+	const canonical = env.CHATCODE_CLI_HOME?.trim();
+	const destination = canonical === void 0 || canonical === "" ? defaultChatCodeCliHome() : resolve(expandHomePath(canonical));
+	return {
+		source: join(homedir(), LEGACY_HOME_DIRECTORY),
+		destination,
+		tuiSource: join(homedir(), LEGACY_TUI_HOME_DIRECTORY),
+		tuiDestination: join(destination, "tui")
+	};
+}
+/** Find legacy trees with durable entries that are still absent from the canonical home. */
+async function detectPendingHomeMigrations(roots) {
+	return (await Promise.all([planHomeMigration(roots.source, roots.destination), planHomeMigration(roots.tuiSource, roots.tuiDestination)])).filter((plan) => plan.entries.some((entry) => entry.action === "copy-file" || entry.action === "create-directory"));
+}
+function createPlanId(plan) {
+	return createHash("sha256").update(JSON.stringify(plan)).digest("hex").slice(0, 24);
+}
+/** Inspect both trees and return a deterministic, side-effect-free migration plan. */
+async function planHomeMigration(source, destination) {
+	const resolvedSource = resolve(source);
+	const resolvedDestination = resolve(destination);
+	if (resolvedSource === resolvedDestination) throw new Error("ChatCode CLI migration source and destination must be different directories");
+	const sourceKind = await pathKind(resolvedSource);
+	if (sourceKind !== "missing" && sourceKind !== "directory") throw new Error(`ChatCode CLI migration source is not a directory: ${resolvedSource}`);
+	const entries = [];
+	const conflicts = [];
+	const excluded = [];
+	const visit = async (relativeDirectory) => {
+		const children = await readdir(relativeDirectory === "" ? resolvedSource : join(resolvedSource, relativeDirectory), { withFileTypes: true });
+		children.sort((left, right) => left.name.localeCompare(right.name, "en"));
+		for (const child of children) {
+			const relativePath = relativeDirectory === "" ? child.name : join(relativeDirectory, child.name);
+			const sourcePath = join(resolvedSource, relativePath);
+			const kind = await pathKind(sourcePath);
+			if (kind === "missing") continue;
+			if (kind === "symlink") {
+				entries.push({
+					relativePath,
+					action: "skip-unsafe",
+					kind,
+					reason: "symbolic links are never followed"
+				});
+				excluded.push(relativePath);
+				continue;
+			}
+			if (isTransientMigrationPath(relativePath, kind)) {
+				entries.push({
+					relativePath,
+					action: "exclude-transient",
+					kind,
+					reason: "transient runtime state"
+				});
+				excluded.push(relativePath);
+				continue;
+			}
+			const destinationKind = await pathKind(join(resolvedDestination, relativePath));
+			if (kind === "directory" && (destinationKind === "missing" || destinationKind === "directory")) {
+				if (destinationKind === "missing") entries.push({
+					relativePath,
+					action: "create-directory",
+					kind
+				});
+				await visit(relativePath);
+				continue;
+			}
+			if (destinationKind !== "missing") {
+				entries.push({
+					relativePath,
+					action: "skip-existing",
+					kind,
+					reason: `destination already contains ${destinationKind}`
+				});
+				conflicts.push(relativePath);
+				continue;
+			}
+			if (kind === "file") {
+				try {
+					const info = await stat(sourcePath);
+					const fingerprint = await fingerprintFile(sourcePath);
+					entries.push({
+						relativePath,
+						action: "copy-file",
+						kind,
+						size: info.size,
+						mtimeMs: info.mtimeMs,
+						fingerprint
+					});
+				} catch (error) {
+					const code = error.code ?? "unknown error";
+					entries.push({
+						relativePath,
+						action: "skip-unreadable",
+						kind,
+						reason: `source could not be read (${code})`
+					});
+					excluded.push(relativePath);
+				}
+				continue;
+			}
+			entries.push({
+				relativePath,
+				action: "skip-unsafe",
+				kind,
+				reason: "unsupported filesystem entry"
+			});
+			excluded.push(relativePath);
+		}
+	};
+	if (sourceKind === "directory") await visit("");
+	const base = {
+		version: 1,
+		source: resolvedSource,
+		destination: resolvedDestination,
+		sourceExists: sourceKind === "directory",
+		entries,
+		conflicts,
+		excluded
+	};
+	return {
+		...base,
+		planId: createPlanId(base)
+	};
+}
+async function assertSafeDestinationDirectory(root, directory) {
+	const rel = relative(root, directory);
+	if (rel.startsWith("..") || isAbsolute(rel)) throw new Error(`migration destination escapes root: ${directory}`);
+	const segments = rel === "" ? [] : rel.split(sep);
+	let current = root;
+	const ensureRealDirectory = async (path, label) => {
+		const kind = await pathKind(path);
+		if (kind === "directory") return;
+		if (kind !== "missing") throw new Error(`migration ${label} is not a real directory: ${path}`);
+		const parent = dirname(path);
+		if (parent === path) throw new Error(`migration ${label} cannot be created: ${path}`);
+		await ensureRealDirectory(parent, "destination parent");
+		try {
+			await mkdir(path);
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			if (await pathKind(path) !== "directory") throw new Error(`migration ${label} is not a real directory: ${path}`);
+		}
+	};
+	await ensureRealDirectory(root, "destination root");
+	for (const segment of segments) {
+		current = join(current, segment);
+		const kind = await pathKind(current);
+		if (kind === "missing") try {
+			await mkdir(current);
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			if (await pathKind(current) !== "directory") throw new Error(`migration destination parent is not a real directory: ${current}`);
+		}
+		else if (kind !== "directory") throw new Error(`migration destination parent is not a real directory: ${current}`);
+	}
+}
+async function copyFileExclusively(plan, entry) {
+	if (!safeRelativePath(entry.relativePath)) throw new Error(`invalid migration path: ${entry.relativePath}`);
+	const source = join(plan.source, entry.relativePath);
+	const destination = join(plan.destination, entry.relativePath);
+	const sourceBefore = await lstat(source);
+	if (!sourceBefore.isFile() || sourceBefore.isSymbolicLink()) return "source changed type after planning";
+	if (entry.size !== sourceBefore.size || entry.mtimeMs !== sourceBefore.mtimeMs || entry.fingerprint !== await fingerprintFile(source)) return "source changed after planning";
+	await assertSafeDestinationDirectory(plan.destination, dirname(destination));
+	if (await pathKind(destination) !== "missing") return "destination appeared after planning";
+	const staging = join(dirname(destination), `.chatcode-migrate-${randomUUID()}.tmp`);
+	try {
+		await copyFile(source, staging, constants.COPYFILE_EXCL);
+		await chmod(staging, sourceBefore.mode);
+		const sourceAfter = await lstat(source);
+		if (!sourceAfter.isFile() || sourceAfter.isSymbolicLink() || sourceAfter.size !== sourceBefore.size || sourceAfter.mtimeMs !== sourceBefore.mtimeMs || entry.fingerprint !== await fingerprintFile(source)) return "source changed while copying";
+		try {
+			await link(staging, destination);
+		} catch (error) {
+			if (error.code === "EEXIST") return "destination appeared while copying";
+			throw error;
+		}
+		return;
+	} finally {
+		await rm(staging, { force: true });
+	}
+}
+/** Apply exactly one reviewed plan without overwriting destinations or removing legacy data. */
+async function applyHomeMigration(plan) {
+	if ((await planHomeMigration(plan.source, plan.destination)).planId !== plan.planId) throw new Error("ChatCode CLI migration plan is stale; run the dry-run again before applying");
+	const result = {
+		plan,
+		copied: [],
+		createdDirectories: [],
+		skipped: []
+	};
+	if (!plan.sourceExists) return result;
+	await assertSafeDestinationDirectory(plan.destination, plan.destination);
+	for (const entry of plan.entries) if (entry.action === "create-directory") {
+		const directory = join(plan.destination, entry.relativePath);
+		await assertSafeDestinationDirectory(plan.destination, directory);
+		result.createdDirectories.push(entry.relativePath);
+	} else if (entry.action === "copy-file") {
+		const reason = await copyFileExclusively(plan, entry);
+		if (reason === void 0) result.copied.push(entry.relativePath);
+		else result.skipped.push({
+			relativePath: entry.relativePath,
+			reason
+		});
+	} else result.skipped.push({
+		relativePath: entry.relativePath,
+		reason: entry.reason ?? entry.action
+	});
+	const recordDirectory = join(plan.destination, MIGRATION_RECORD_DIRECTORY);
+	await assertSafeDestinationDirectory(plan.destination, recordDirectory);
+	const recordPath = join(recordDirectory, `${plan.planId}.json`);
+	const record = `${JSON.stringify({
+		...result,
+		recordPath,
+		appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2)}\n`;
+	try {
+		await writeFile(recordPath, record, { flag: "wx" });
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		const existing = await readFile(recordPath, "utf8");
+		const parsed = JSON.parse(existing);
+		const recordedPlan = typeof parsed === "object" && parsed !== null && "plan" in parsed ? parsed.plan : void 0;
+		if ((typeof recordedPlan === "object" && recordedPlan !== null && "planId" in recordedPlan ? recordedPlan.planId : void 0) !== plan.planId) throw error;
+	}
+	result.recordPath = recordPath;
+	return result;
+}
+/** Human-readable review output shared by dry-run and apply. */
+function formatHomeMigrationPlan(plan) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const entry of plan.entries) counts.set(entry.action, (counts.get(entry.action) ?? 0) + 1);
+	return [
+		"ChatCode CLI home migration plan",
+		`Source (preserved): ${plan.source}`,
+		`Destination: ${plan.destination}`,
+		`Source exists: ${plan.sourceExists ? "yes" : "no"}`,
+		`Plan: ${plan.planId}`,
+		`Copy files: ${counts.get("copy-file") ?? 0}`,
+		`Create directories: ${counts.get("create-directory") ?? 0}`,
+		`Conflicts (destination wins): ${plan.conflicts.length}`,
+		`Excluded transient or unsafe entries: ${plan.excluded.length}`,
+		...plan.conflicts.map((path) => `  conflict: ${path}`),
+		...plan.excluded.map((path) => `  excluded: ${path}`)
+	].join("\n");
+}
+//#endregion
+export { applyHomeMigration, detectPendingHomeMigrations, formatHomeMigrationPlan, planHomeMigration, resolveHomeMigrationRoots };

package/lib/plugin-CMMvQgyR.js

@@ -0,0 +1,31 @@
+import { n as INSTALL_ANCHOR } from "./profile-boot-CCxnpvy7.js";
+import { resolveProfileDir } from "@deepseek-ai/dsh-app-boot";
+import { join } from "node:path";
+import { runPluginCommand } from "@deepseek-ai/dsh-plugin-manager/operations";
+//#region lib/types/plugin.js
+/** ChatCode CLI plugin management forwards pnpm through the shared profile package operations. */
+/** Run package management for a profile.
+* @param profile Profile name.
+* @param args Pnpm arguments relative to the invoking directory.
+* @returns Pnpm exit code.
+*/
+async function runPlugin(profile, args) {
+	const result = await runPluginCommand({
+		profile,
+		installAnchor: INSTALL_ANCHOR,
+		cwd: process.cwd()
+	}, args, {
+		execution: "cli",
+		outputBytes: 16384,
+		lockWaitMs: 12e4,
+		onOutput: (text, stream) => {
+			process[stream].write(text);
+		}
+	});
+	if (result.exitCode === 127) process.stderr.write("ChatCode CLI: pnpm was not found; install pnpm and make it available on PATH.\n");
+	if (result.exitCode !== 0) process.stderr.write(`ChatCode CLI: pnpm failed; diagnostics: ${result.logPath}\n`);
+	if (result.exitCode !== 0 && args.some((argument) => /^git\+|^github:|\.git(?:#|$)/.test(argument))) process.stderr.write(`ChatCode CLI: git-hosted plugins build on install via their prepare script, which pnpm blocks until allowed — add the exact key pnpm printed above under allowBuilds in ${join(resolveProfileDir(profile), "pnpm-workspace.yaml")}, then re-run\n`);
+	return result.exitCode;
+}
+//#endregion
+export { runPlugin };