boxdown 1.0.0 → 1.2.1

package/dist/main-BuEptwlL.cjs

@@ -1,1707 +0,0 @@
-let node_fs = require("node:fs");
-let node_module = require("node:module");
-let node_path = require("node:path");
-let node_child_process = require("node:child_process");
-let node_crypto = require("node:crypto");
-let node_os = require("node:os");
-let node_url = require("node:url");
-
-//#region src/coding-agents.ts
-const CODING_AGENT_ALIASES = {
-	codex: "codex",
-	opencode: "opencode",
-	claude: "claude",
-	cc: "claude",
-	antigravity: "antigravity"
-};
-function codingAgentFromCommand(command) {
-	return CODING_AGENT_ALIASES[command];
-}
-function codingAgentBinary(agent) {
-	if (agent === "antigravity") {
-		return "agy";
-	}
-	return agent;
-}
-
-//#endregion
-//#region src/constants.ts
-const DEVCONTAINER_CLI_VERSION = "0.84.1";
-const BOXDOWN_CONTAINER_DEVCONTAINER_DIR = "/opt/boxdown/devcontainer";
-const BOXDOWN_CONTAINER_STATE_DIR = "/opt/boxdown/state";
-const BOXDOWN_CONTAINER_SSH_DIR = `${BOXDOWN_CONTAINER_STATE_DIR}/ssh`;
-const BOXDOWN_CONTAINER_SSH_PUBLIC_KEY_PATH = `${BOXDOWN_CONTAINER_SSH_DIR}/id_ed25519.pub`;
-const PACKAGE_NAME = "boxdown";
-
-//#endregion
-//#region src/devcontainer-cli.ts
-function devcontainerBinFromPackageJson(packageJson) {
-	return typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.devcontainer;
-}
-function resolveDevcontainerCli(context) {
-	const requireFromBoxdown = (0, node_module.createRequire)((0, node_path.join)(context.packageRoot, "package.json"));
-	let packageJsonPath;
-	try {
-		packageJsonPath = requireFromBoxdown.resolve("@devcontainers/cli/package.json");
-	} catch (error) {
-		throw new Error(`Boxdown's packaged @devcontainers/cli dependency is missing. Reinstall boxdown so @devcontainers/cli@${DEVCONTAINER_CLI_VERSION} is available.`, { cause: error });
-	}
-	const packageJson = JSON.parse((0, node_fs.readFileSync)(packageJsonPath, "utf8"));
-	const bin = devcontainerBinFromPackageJson(packageJson);
-	if (packageJson.version !== "0.84.1") {
-		throw new Error(`Boxdown expected @devcontainers/cli@${DEVCONTAINER_CLI_VERSION} but resolved ${packageJson.version ?? "an unknown version"}.`);
-	}
-	if (bin === undefined) {
-		throw new Error("Boxdown resolved @devcontainers/cli, but the package does not expose a devcontainer binary.");
-	}
-	const cliPath = (0, node_path.resolve)((0, node_path.dirname)(packageJsonPath), bin);
-	if (!(0, node_fs.existsSync)(cliPath)) {
-		throw new Error(`Boxdown resolved @devcontainers/cli, but its devcontainer binary is missing: ${cliPath}`);
-	}
-	return {
-		command: process.execPath,
-		argsPrefix: [cliPath],
-		path: cliPath,
-		version: packageJson.version
-	};
-}
-
-//#endregion
-//#region src/process.ts
-function mergedEnv(env) {
-	return {
-		...process.env,
-		...env ?? {}
-	};
-}
-function writeChunk(target, chunk) {
-	if (target === "stdout") {
-		process.stdout.write(chunk);
-	} else if (target === "stderr") {
-		process.stderr.write(chunk);
-	}
-}
-function runBuffered(command, args, options = {}) {
-	return new Promise((resolve) => {
-		const child = (0, node_child_process.spawn)(command, args, {
-			cwd: options.cwd,
-			env: mergedEnv(options.env),
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		});
-		const stdoutChunks = [];
-		const stderrChunks = [];
-		child.stdout.on("data", (chunk) => {
-			stdoutChunks.push(chunk);
-			writeChunk(options.mirrorStdout ?? "stdout", chunk);
-		});
-		child.stderr.on("data", (chunk) => {
-			stderrChunks.push(chunk);
-			writeChunk(options.mirrorStderr ?? "stderr", chunk);
-		});
-		child.on("error", (error) => {
-			resolve({
-				code: 127,
-				stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-				stderr: `${Buffer.concat(stderrChunks).toString("utf8")}${error.message}\n`
-			});
-		});
-		child.on("close", (code) => {
-			resolve({
-				code: code ?? 1,
-				stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-				stderr: Buffer.concat(stderrChunks).toString("utf8")
-			});
-		});
-		if (options.input !== undefined) {
-			child.stdin.end(options.input);
-		} else {
-			child.stdin.end();
-		}
-	});
-}
-function runInteractive(command, args, options = {}) {
-	return new Promise((resolve) => {
-		const child = (0, node_child_process.spawn)(command, args, {
-			cwd: options.cwd,
-			env: mergedEnv(options.env),
-			stdio: "inherit"
-		});
-		child.on("error", (error) => {
-			process.stderr.write(`${error.message}\n`);
-			resolve(127);
-		});
-		child.on("close", (code) => {
-			resolve(code ?? 1);
-		});
-	});
-}
-
-//#endregion
-//#region src/doctor.ts
-function nodeVersionPasses(version) {
-	const major = Number.parseInt(version.split(".")[0] ?? "", 10);
-	return Number.isInteger(major) && major >= 24;
-}
-function check(name, pass, okMessage, failMessage) {
-	return {
-		name,
-		level: pass ? "ok" : "fail",
-		message: pass ? okMessage : failMessage
-	};
-}
-async function commandWorks(command, args) {
-	const result = await runBuffered(command, args, {
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	return result.code === 0;
-}
-async function commandExists(command, args) {
-	const result = await runBuffered(command, args, {
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	return result.code !== 127;
-}
-async function runDoctorChecks(context) {
-	const checks = [];
-	const nodeVersion = process.versions.node;
-	checks.push(check("node", nodeVersionPasses(nodeVersion), `Node ${nodeVersion}`, `Node ${nodeVersion}; expected >=24.0.0`));
-	checks.push(check("devcontainers-cli", await packagedDevcontainerCliWorks(context), "Packaged @devcontainers/cli is available", "Packaged @devcontainers/cli is required but was not available"));
-	checks.push(check("docker-cli", await commandWorks("docker", ["--version"]), "Docker CLI is available", "Docker CLI is required but was not available"));
-	checks.push(check("docker-daemon", await commandWorks("docker", ["info"]), "Docker daemon is reachable", "Docker daemon is required but was not reachable"));
-	checks.push(check("ssh", await commandExists("ssh", ["-V"]), "ssh is available", "ssh is required but was not available"));
-	checks.push(check("ssh-keygen", await commandExists("ssh-keygen", ["-?"]), "ssh-keygen is available", "ssh-keygen is required but was not available"));
-	checks.push(check("assets", (0, node_fs.existsSync)(context.assetsDevcontainerDir), `Devcontainer assets found at ${context.assetsDevcontainerDir}`, `Missing Boxdown devcontainer assets: ${context.assetsDevcontainerDir}`));
-	if (await commandWorks("gh", ["--version"])) {
-		const ghAuth = await commandWorks("gh", [
-			"auth",
-			"status",
-			"--hostname",
-			"github.com"
-		]);
-		checks.push({
-			name: "gh-auth",
-			level: ghAuth ? "ok" : "warn",
-			message: ghAuth ? "GitHub CLI auth is available" : "GitHub CLI is available but not authenticated"
-		});
-	} else {
-		checks.push({
-			name: "gh",
-			level: "warn",
-			message: "GitHub CLI is optional and was not available"
-		});
-	}
-	return checks;
-}
-async function packagedDevcontainerCliWorks(context) {
-	try {
-		const cli = resolveDevcontainerCli(context);
-		return await commandWorks(cli.command, [...cli.argsPrefix, "--version"]);
-	} catch {
-		return false;
-	}
-}
-function doctorHasFailures(checks) {
-	return checks.some((item) => item.level === "fail");
-}
-function formatDoctorText(checks) {
-	const lines = ["Boxdown doctor", ""];
-	for (const item of checks) {
-		lines.push(`[${item.level}] ${item.name}: ${item.message}`);
-	}
-	lines.push("", doctorHasFailures(checks) ? "Result: failed" : "Result: ok");
-	return `${lines.join("\n")}\n`;
-}
-
-//#endregion
-//#region src/jsonc.ts
-function stripJsonComments(input) {
-	let output = "";
-	let inString = false;
-	let escaped = false;
-	for (let index = 0; index < input.length; index += 1) {
-		const char = input[index];
-		const next = input[index + 1];
-		if (char === undefined) {
-			break;
-		}
-		if (inString) {
-			output += char;
-			if (escaped) {
-				escaped = false;
-			} else if (char === "\\") {
-				escaped = true;
-			} else if (char === "\"") {
-				inString = false;
-			}
-			continue;
-		}
-		if (char === "\"") {
-			inString = true;
-			output += char;
-			continue;
-		}
-		if (char === "/" && next === "/") {
-			while (index < input.length && input[index] !== "\n") {
-				index += 1;
-			}
-			if (input[index] === "\n") {
-				output += "\n";
-			}
-			continue;
-		}
-		if (char === "/" && next === "*") {
-			index += 2;
-			while (index < input.length) {
-				if (input[index] === "\n") {
-					output += "\n";
-				}
-				if (input[index] === "*" && input[index + 1] === "/") {
-					index += 1;
-					break;
-				}
-				index += 1;
-			}
-			continue;
-		}
-		output += char;
-	}
-	return output;
-}
-function stripTrailingCommas(input) {
-	let output = "";
-	let inString = false;
-	let escaped = false;
-	for (let index = 0; index < input.length; index += 1) {
-		const char = input[index];
-		if (char === undefined) {
-			break;
-		}
-		if (inString) {
-			output += char;
-			if (escaped) {
-				escaped = false;
-			} else if (char === "\\") {
-				escaped = true;
-			} else if (char === "\"") {
-				inString = false;
-			}
-			continue;
-		}
-		if (char === "\"") {
-			inString = true;
-			output += char;
-			continue;
-		}
-		if (char === ",") {
-			let nextIndex = index + 1;
-			while (/\s/.test(input[nextIndex] ?? "")) {
-				nextIndex += 1;
-			}
-			if (input[nextIndex] === "}" || input[nextIndex] === "]") {
-				continue;
-			}
-		}
-		output += char;
-	}
-	return output;
-}
-function parseJsonc(input) {
-	return JSON.parse(stripTrailingCommas(stripJsonComments(input)));
-}
-
-//#endregion
-//#region src/shell.ts
-function shellQuote(value) {
-	if (value.length === 0) {
-		return "''";
-	}
-	return `'${value.replaceAll("'", "'\\''")}'`;
-}
-function sshConfigQuote(value) {
-	return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
-}
-const DEFAULT_TTY_MAX_COLUMNS = 120;
-function interactiveShellEnvArgs(env = process.env) {
-	return [
-		`TERM=${env.TERM ?? "xterm-256color"}`,
-		"COLORTERM=truecolor",
-		`BOXDOWN_TTY_NORMALIZE=${env.BOXDOWN_TTY_NORMALIZE ?? "1"}`,
-		`BOXDOWN_TTY_MAX_COLUMNS=${env.BOXDOWN_TTY_MAX_COLUMNS ?? String(120)}`
-	];
-}
-function interactiveTtySetupScript() {
-	return [
-		"if [ -t 0 ]; then",
-		"  case \"${BOXDOWN_TTY_NORMALIZE:-1}\" in",
-		"    0|false|FALSE|no|NO|off|OFF) ;;",
-		"    *)",
-		"      max_columns=\"${BOXDOWN_TTY_MAX_COLUMNS:-120}\"",
-		"      if [ \"$max_columns\" -gt 0 ] 2>/dev/null; then",
-		"        set -- $(stty size 2>/dev/null || true)",
-		"        rows=\"${1:-}\"",
-		"        columns=\"${2:-}\"",
-		"        if [ -n \"$columns\" ] && [ \"$columns\" -gt \"$max_columns\" ] 2>/dev/null; then",
-		"          stty cols \"$max_columns\" 2>/dev/null || true",
-		"          export COLUMNS=\"$max_columns\"",
-		"          if [ -n \"$rows\" ]; then export LINES=\"$rows\"; fi",
-		"          printf \"Boxdown: terminal width clamped to %s columns (was %s). Set BOXDOWN_TTY_NORMALIZE=0 to disable.\\n\" \"$max_columns\" \"$columns\" >&2",
-		"        fi",
-		"      fi",
-		"      ;;",
-		"  esac",
-		"fi"
-	].join("\n");
-}
-function interactiveShellScript() {
-	return [interactiveTtySetupScript(), "exec bash -i"].join("\n");
-}
-function interactiveCommandScript() {
-	return [interactiveTtySetupScript(), "exec \"$@\""].join("\n");
-}
-
-//#endregion
-//#region src/config.ts
-function readBaseDevcontainerConfig(assetsDevcontainerDir) {
-	const configPath = (0, node_path.join)(assetsDevcontainerDir, "devcontainer.json");
-	return parseJsonc((0, node_fs.readFileSync)(configPath, "utf8"));
-}
-function buildGeneratedDevcontainerConfig(context) {
-	const baseConfig = readBaseDevcontainerConfig(context.assetsDevcontainerDir);
-	const mounts = Array.isArray(baseConfig.mounts) ? baseConfig.mounts.filter((mount) => typeof mount === "string") : [];
-	const boxdownMounts = [`type=bind,source=${context.assetsDevcontainerDir},target=${BOXDOWN_CONTAINER_DEVCONTAINER_DIR},readonly`, `type=bind,source=${context.sshPublicKeyRuntimeDir},target=${BOXDOWN_CONTAINER_SSH_DIR},readonly`];
-	return {
-		...baseConfig,
-		name: `Boxdown: ${context.workspaceBasename}`,
-		mounts: [...mounts, ...boxdownMounts],
-		initializeCommand: `BOXDOWN_WORKSPACE_FOLDER=${shellQuote(context.workspaceFolder)} bash ${shellQuote((0, node_path.join)(context.assetsDevcontainerDir, "hooks", "initialize.sh"))}`,
-		postCreateCommand: `bash ${shellQuote(`${BOXDOWN_CONTAINER_DEVCONTAINER_DIR}/hooks/post-create.sh`)}`,
-		postStartCommand: `bash ${shellQuote(`${BOXDOWN_CONTAINER_DEVCONTAINER_DIR}/hooks/post-start.sh`)}`,
-		containerEnv: {
-			...baseConfig.containerEnv ?? {},
-			BOXDOWN_CONTAINER_WORKSPACE_FOLDER: "/workspaces/${localWorkspaceFolderBasename}",
-			BOXDOWN_WORKSPACE_BASENAME: "${localWorkspaceFolderBasename}",
-			DEVCONTAINER_SSH_PUBLIC_KEY_FILE: BOXDOWN_CONTAINER_SSH_PUBLIC_KEY_PATH
-		}
-	};
-}
-function writeGeneratedDevcontainerConfig(context) {
-	const config = buildGeneratedDevcontainerConfig(context);
-	(0, node_fs.mkdirSync)(context.workspaceCacheDir, { recursive: true });
-	(0, node_fs.writeFileSync)(context.generatedConfigPath, `${JSON.stringify(config, null, 2)}\n`);
-	return config;
-}
-function publishContainerPortFromConfig(config) {
-	return config.runArgs?.find((arg) => /^[0-9.]+::[0-9]+$/.test(arg))?.split("::")[1];
-}
-
-//#endregion
-//#region src/github-git-auth.ts
-function canonicalGithubRemoteUrl(remoteUrl) {
-	const trimmed = remoteUrl.trim();
-	const scpLike = /^git@github\.com:([^/]+)\/(.+)$/i.exec(trimmed);
-	if (scpLike !== null) {
-		return canonicalGithubUrlFromParts(scpLike[1], scpLike[2]);
-	}
-	try {
-		const parsed = new URL(trimmed);
-		const protocol = parsed.protocol.toLowerCase();
-		const host = parsed.hostname.toLowerCase();
-		if (host !== "github.com") {
-			return undefined;
-		}
-		if (protocol === "ssh:" && parsed.username !== "git") {
-			return undefined;
-		}
-		if (protocol !== "https:" && protocol !== "ssh:") {
-			return undefined;
-		}
-		const parts = parsed.pathname.split("/").filter((part) => part.length > 0);
-		if (parts.length !== 2) {
-			return undefined;
-		}
-		const [owner, repo] = parts;
-		return canonicalGithubUrlFromParts(owner, repo);
-	} catch {
-		return undefined;
-	}
-}
-function canonicalGithubUrlFromParts(owner, repo) {
-	if (owner === undefined || repo === undefined) {
-		return undefined;
-	}
-	const normalizedOwner = owner.trim();
-	const normalizedRepo = repo.trim().replace(/\/+$/, "").replace(/\.git$/i, "");
-	if (normalizedOwner.length === 0 || normalizedRepo.length === 0 || normalizedOwner.includes("/") || normalizedRepo.includes("/")) {
-		return undefined;
-	}
-	return `https://github.com/${normalizedOwner}/${normalizedRepo}.git`;
-}
-async function configureWorkspaceGithubGitAuth(workspaceFolder) {
-	const insideWorkTree = await runWorkspaceGit(workspaceFolder, ["rev-parse", "--is-inside-work-tree"]);
-	if (insideWorkTree.code !== 0 || insideWorkTree.stdout.trim() !== "true") {
-		return false;
-	}
-	const remoteConfig = await runWorkspaceGit(workspaceFolder, [
-		"config",
-		"--local",
-		"--get-regexp",
-		"^remote\\..*\\.url$"
-	]);
-	if (remoteConfig.code !== 0) {
-		return false;
-	}
-	const githubRemotes = parseGithubRemoteConfig(remoteConfig.stdout);
-	if (githubRemotes.length === 0) {
-		return false;
-	}
-	for (const remote of githubRemotes) {
-		const fetchUrl = await runWorkspaceGit(workspaceFolder, [
-			"remote",
-			"set-url",
-			remote.name,
-			remote.url
-		]);
-		if (fetchUrl.code !== 0) {
-			return false;
-		}
-		const pushUrl = await runWorkspaceGit(workspaceFolder, [
-			"remote",
-			"set-url",
-			"--push",
-			remote.name,
-			remote.url
-		]);
-		if (pushUrl.code !== 0) {
-			return false;
-		}
-	}
-	await runWorkspaceGit(workspaceFolder, [
-		"config",
-		"--local",
-		"--unset-all",
-		"credential.https://github.com.helper"
-	]);
-	const resetHelper = await runWorkspaceGit(workspaceFolder, [
-		"config",
-		"--local",
-		"--add",
-		"credential.https://github.com.helper",
-		""
-	]);
-	if (resetHelper.code !== 0) {
-		return false;
-	}
-	const ghHelper = await runWorkspaceGit(workspaceFolder, [
-		"config",
-		"--local",
-		"--add",
-		"credential.https://github.com.helper",
-		"!gh auth git-credential"
-	]);
-	if (ghHelper.code !== 0) {
-		return false;
-	}
-	for (const remoteUrl of new Set(githubRemotes.map((remote) => remote.url))) {
-		const rewrite = await runWorkspaceGit(workspaceFolder, [
-			"config",
-			"--local",
-			"--replace-all",
-			`url.${remoteUrl}.insteadOf`,
-			remoteUrl
-		]);
-		if (rewrite.code !== 0) {
-			return false;
-		}
-	}
-	return true;
-}
-function parseGithubRemoteConfig(configOutput) {
-	const remotes = [];
-	for (const line of configOutput.split(/\r?\n/)) {
-		const match = /^remote\.(.+)\.url\s+(.+)$/.exec(line);
-		if (match === null) {
-			continue;
-		}
-		const name = match[1];
-		const rawUrl = match[2];
-		if (name === undefined || rawUrl === undefined) {
-			continue;
-		}
-		const url = canonicalGithubRemoteUrl(rawUrl);
-		if (url !== undefined) {
-			remotes.push({
-				name,
-				url
-			});
-		}
-	}
-	return remotes;
-}
-async function runWorkspaceGit(workspaceFolder, args) {
-	return runBuffered("git", args, {
-		cwd: workspaceFolder,
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-}
-
-//#endregion
-//#region src/ssh-key.ts
-async function ensureHostSshKey(context, quiet = false) {
-	(0, node_fs.mkdirSync)(context.sshKeyDir, {
-		recursive: true,
-		mode: 448
-	});
-	if (!(0, node_fs.existsSync)(context.sshKeyPath)) {
-		if (!quiet) {
-			process.stderr.write(`Generating Boxdown SSH identity: ${context.sshKeyPath}\n`);
-		}
-		const result = await runBuffered("ssh-keygen", [
-			"-t",
-			"ed25519",
-			"-f",
-			context.sshKeyPath,
-			"-N",
-			"",
-			"-C",
-			`${context.workspaceBasename}-devcontainer`
-		], {
-			mirrorStdout: quiet ? false : "stderr",
-			mirrorStderr: "stderr"
-		});
-		if (result.code !== 0) {
-			throw new Error(`ssh-keygen failed while creating ${context.sshKeyPath}`);
-		}
-	}
-	if (!(0, node_fs.existsSync)(context.sshPublicKeyPath)) {
-		const result = await runBuffered("ssh-keygen", [
-			"-y",
-			"-f",
-			context.sshKeyPath
-		], {
-			mirrorStdout: false,
-			mirrorStderr: "stderr"
-		});
-		if (result.code !== 0) {
-			throw new Error(`ssh-keygen failed while deriving ${context.sshPublicKeyPath}`);
-		}
-		(0, node_fs.writeFileSync)(context.sshPublicKeyPath, result.stdout);
-	}
-	(0, node_fs.mkdirSync)(context.sshPublicKeyRuntimeDir, {
-		recursive: true,
-		mode: 493
-	});
-	(0, node_fs.writeFileSync)(context.sshPublicKeyRuntimePath, (0, node_fs.readFileSync)(context.sshPublicKeyPath, "utf8"));
-	(0, node_fs.chmodSync)(context.sshKeyPath, 384);
-	(0, node_fs.chmodSync)(context.sshPublicKeyPath, 420);
-	(0, node_fs.chmodSync)(context.sshPublicKeyRuntimePath, 420);
-}
-
-//#endregion
-//#region src/ssh-config.ts
-function defaultSshAlias(workspaceBasename) {
-	return `${workspaceBasename}-devcontainer`;
-}
-function validateSshAlias(alias) {
-	if (!/^[A-Za-z0-9_.-]+$/.test(alias)) {
-		throw new Error(`SSH alias contains unsupported characters: ${alias}`);
-	}
-}
-function defaultSshConfigPath(env = process.env) {
-	return env.BOXDOWN_SSH_CONFIG ?? env.DEVCONTAINER_SSH_CONFIG ?? (0, node_path.join)(env.HOME ?? "", ".ssh", "config");
-}
-function buildProxyCommand(context, alias) {
-	const cliPath = (0, node_path.join)(context.packageRoot, "dist", "bin", "cli.cjs");
-	return `${shellQuote(process.execPath)} ${shellQuote(cliPath)} ssh-proxy --workspace ${shellQuote(context.workspaceFolder)} --alias ${shellQuote(alias)}`;
-}
-function buildSshConfigBlock(context, alias) {
-	validateSshAlias(alias);
-	return [
-		`# BEGIN ${alias} boxdown devcontainer ssh`,
-		`Host ${alias}`,
-		`  HostName ${alias}`,
-		"  User node",
-		"  IdentityFile none",
-		`  IdentityFile ${sshConfigQuote(context.sshKeyPath)}`,
-		"  IdentitiesOnly yes",
-		`  ProxyCommand ${buildProxyCommand(context, alias)}`,
-		"  StrictHostKeyChecking no",
-		"  UserKnownHostsFile /dev/null",
-		"  LogLevel ERROR",
-		`# END ${alias} boxdown devcontainer ssh`,
-		""
-	].join("\n");
-}
-function replaceSshConfigBlock(existingConfig, alias, block) {
-	const begin = `# BEGIN ${alias} boxdown devcontainer ssh`;
-	const end = `# END ${alias} boxdown devcontainer ssh`;
-	const lines = existingConfig.split(/\r?\n/);
-	const nextLines = [];
-	let skipping = false;
-	for (const line of lines) {
-		if (line === begin) {
-			skipping = true;
-			continue;
-		}
-		if (line === end) {
-			skipping = false;
-			continue;
-		}
-		if (!skipping) {
-			nextLines.push(line);
-		}
-	}
-	while (nextLines.length > 0 && nextLines[nextLines.length - 1] === "") {
-		nextLines.pop();
-	}
-	return `${nextLines.join("\n")}${nextLines.length > 0 ? "\n\n" : ""}${block}`;
-}
-async function installSshConfig(context, alias, options = {}) {
-	validateSshAlias(alias);
-	await ensureHostSshKey(context, options.quiet ?? false);
-	const sshConfigPath = options.configPath ?? defaultSshConfigPath();
-	const sshConfigDir = (0, node_path.dirname)(sshConfigPath);
-	(0, node_fs.mkdirSync)(sshConfigDir, {
-		recursive: true,
-		mode: 448
-	});
-	if (!(0, node_fs.existsSync)(sshConfigPath)) {
-		(0, node_fs.writeFileSync)(sshConfigPath, "");
-	}
-	(0, node_fs.chmodSync)(sshConfigDir, 448);
-	(0, node_fs.chmodSync)(sshConfigPath, 384);
-	const existingConfig = (0, node_fs.readFileSync)(sshConfigPath, "utf8");
-	const block = buildSshConfigBlock(context, alias);
-	const nextConfig = replaceSshConfigBlock(existingConfig, alias, block);
-	if (nextConfig !== existingConfig) {
-		(0, node_fs.writeFileSync)(sshConfigPath, nextConfig);
-		if (!options.quiet) {
-			process.stdout.write(`Installed SSH alias: ${alias}\n`);
-		}
-	} else if (!options.quiet) {
-		process.stdout.write(`SSH alias already up to date: ${alias}\n`);
-	}
-	(0, node_fs.chmodSync)(sshConfigPath, 384);
-	if (!options.quiet) {
-		process.stdout.write(`SSH config: ${sshConfigPath}\n`);
-		process.stdout.write(`Identity file: ${context.sshKeyPath}\n\n`);
-		process.stdout.write(`Validate with:\n  ssh ${alias} 'whoami && pwd'\n`);
-	}
-}
-
-//#endregion
-//#region src/status.ts
-function dockerLabelsFromString(labels) {
-	return Object.fromEntries(labels.split(",").map((label) => label.trim()).filter((label) => label.length > 0).map((label) => {
-		const separator = label.indexOf("=");
-		return separator === -1 ? [label, ""] : [label.slice(0, separator), label.slice(separator + 1)];
-	}));
-}
-function parseDockerPsJsonLines(output) {
-	const lines = output.split(/\r?\n/).filter((line) => line.trim().length > 0);
-	return lines.map((line) => {
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch {
-			throw new Error(`Could not parse docker ps output: ${line}`);
-		}
-		if (typeof parsed.ID !== "string" || parsed.ID.length === 0) {
-			throw new Error(`Docker ps output is missing container ID: ${line}`);
-		}
-		return {
-			id: parsed.ID,
-			name: typeof parsed.Names === "string" && parsed.Names.length > 0 ? parsed.Names : undefined,
-			state: typeof parsed.State === "string" && parsed.State.length > 0 ? parsed.State : undefined,
-			status: typeof parsed.Status === "string" && parsed.Status.length > 0 ? parsed.Status : undefined,
-			localFolder: typeof parsed.Labels === "string" ? dockerLabelsFromString(parsed.Labels)["devcontainer.local_folder"] : undefined
-		};
-	});
-}
-function readFileUtf8(path) {
-	return (0, node_fs.readFileSync)(path, "utf8");
-}
-function managedSshBlockMarkers(alias) {
-	return {
-		begin: `# BEGIN ${alias} boxdown devcontainer ssh`,
-		end: `# END ${alias} boxdown devcontainer ssh`
-	};
-}
-function findManagedSshConfigBlock(config, alias) {
-	const { begin, end } = managedSshBlockMarkers(alias);
-	const beginIndex = config.indexOf(begin);
-	if (beginIndex === -1) {
-		return undefined;
-	}
-	const endIndex = config.indexOf(end, beginIndex);
-	if (endIndex === -1) {
-		return "";
-	}
-	const afterEndMarkerIndex = endIndex + end.length;
-	const afterEndLineIndex = config[afterEndMarkerIndex] === "\n" ? afterEndMarkerIndex + 1 : afterEndMarkerIndex;
-	return config.slice(beginIndex, afterEndLineIndex);
-}
-function inspectSshConfigStatus(context, alias, configPath, exists, readFile = readFileUtf8) {
-	const configExists = exists(configPath);
-	if (!configExists) {
-		return {
-			configPath,
-			configExists,
-			managedBlockState: "missing"
-		};
-	}
-	const config = readFile(configPath);
-	const managedBlock = findManagedSshConfigBlock(config, alias);
-	if (managedBlock === undefined) {
-		return {
-			configPath,
-			configExists,
-			managedBlockState: "missing"
-		};
-	}
-	return {
-		configPath,
-		configExists,
-		managedBlockState: managedBlock === buildSshConfigBlock(context, alias) ? "installed" : "outdated"
-	};
-}
-function createStatusInfo(context, alias, container, exists, options = {}) {
-	const state = container?.state?.toLowerCase();
-	const sshConfig = inspectSshConfigStatus(context, alias, options.sshConfigPath ?? defaultSshConfigPath(), exists, options.readFile);
-	return {
-		workspace: {
-			folder: context.workspaceFolder,
-			basename: context.workspaceBasename,
-			id: context.workspaceId
-		},
-		ssh: {
-			alias,
-			aliasSource: options.aliasSource ?? "provided",
-			configPath: sshConfig.configPath,
-			configExists: sshConfig.configExists,
-			managedBlockState: sshConfig.managedBlockState,
-			keyPath: context.sshKeyPath,
-			keyExists: exists(context.sshKeyPath),
-			publicKeyPath: context.sshPublicKeyPath,
-			publicKeyExists: exists(context.sshPublicKeyPath),
-			publicKeyRuntimePath: context.sshPublicKeyRuntimePath,
-			publicKeyRuntimeExists: exists(context.sshPublicKeyRuntimePath)
-		},
-		paths: {
-			cacheRoot: context.cacheRoot,
-			dataRoot: context.dataRoot,
-			workspaceCacheDir: context.workspaceCacheDir,
-			workspaceDataDir: context.workspaceDataDir,
-			generatedConfigPath: context.generatedConfigPath,
-			generatedConfigExists: exists(context.generatedConfigPath),
-			assetsDevcontainerDir: context.assetsDevcontainerDir,
-			assetsDevcontainerExists: exists(context.assetsDevcontainerDir)
-		},
-		container: {
-			found: container !== undefined,
-			running: state === "running",
-			id: container?.id,
-			name: container?.name,
-			state: container?.state,
-			status: container?.status
-		}
-	};
-}
-function statusIsHealthy(status) {
-	return status.paths.generatedConfigExists && status.paths.assetsDevcontainerExists && status.ssh.keyExists && status.ssh.publicKeyExists && status.ssh.publicKeyRuntimeExists && status.container.found && status.container.running;
-}
-const color = {
-	green: "\x1B[32m",
-	red: "\x1B[31m",
-	reset: "\x1B[0m"
-};
-function colorize(value, colorName, enabled) {
-	if (!enabled) {
-		return value;
-	}
-	return `${color[colorName]}${value}${color.reset}`;
-}
-function existenceText(value, colorEnabled) {
-	return colorize(value ? "exists" : "missing", value ? "green" : "red", colorEnabled);
-}
-function runningText(value, colorEnabled) {
-	return colorize(value ? "yes" : "no", value ? "green" : "red", colorEnabled);
-}
-function managedBlockText(state, colorEnabled) {
-	return colorize(state, state === "installed" ? "green" : "red", colorEnabled);
-}
-function aliasSourceText(source) {
-	return source === "default" ? "computed default" : "provided";
-}
-function installedText(state) {
-	return state === "installed" ? "installed" : "not installed";
-}
-function stateText(state, healthy, colorEnabled) {
-	return colorize(state, healthy ? "green" : "red", colorEnabled);
-}
-function formatStatusText(status, options = {}) {
-	const colorEnabled = options.color ?? false;
-	const containerState = status.container.found ? status.container.state ?? "unknown" : "absent";
-	const healthy = statusIsHealthy(status);
-	const lines = [
-		"Boxdown status",
-		"",
-		"Workspace:",
-		`  Path: ${status.workspace.folder}`,
-		`  Name: ${status.workspace.basename}`,
-		`  ID: ${status.workspace.id}`,
-		`  SSH alias: ${status.ssh.alias} (${aliasSourceText(status.ssh.aliasSource)}; ${installedText(status.ssh.managedBlockState)})`,
-		"",
-		"Paths:",
-		`  Cache root: ${status.paths.cacheRoot}`,
-		`  Data root: ${status.paths.dataRoot}`,
-		`  Workspace cache: ${status.paths.workspaceCacheDir}`,
-		`  Workspace data: ${status.paths.workspaceDataDir}`,
-		`  Generated config: ${status.paths.generatedConfigPath} (${existenceText(status.paths.generatedConfigExists, colorEnabled)})`,
-		`  Devcontainer assets: ${status.paths.assetsDevcontainerDir} (${existenceText(status.paths.assetsDevcontainerExists, colorEnabled)})`,
-		"",
-		"SSH:",
-		`  SSH config: ${status.ssh.configPath} (${existenceText(status.ssh.configExists, colorEnabled)})`,
-		`  Boxdown SSH block: ${managedBlockText(status.ssh.managedBlockState, colorEnabled)}`,
-		`  Private key: ${status.ssh.keyPath} (${existenceText(status.ssh.keyExists, colorEnabled)})`,
-		`  Public key: ${status.ssh.publicKeyPath} (${existenceText(status.ssh.publicKeyExists, colorEnabled)})`,
-		`  Runtime public key: ${status.ssh.publicKeyRuntimePath} (${existenceText(status.ssh.publicKeyRuntimeExists, colorEnabled)})`,
-		"",
-		"Container:",
-		`  State: ${stateText(containerState, healthy, colorEnabled)}`,
-		`  Running: ${runningText(status.container.running, colorEnabled)}`
-	];
-	if (status.container.id !== undefined) {
-		lines.push(`  ID: ${status.container.id}`);
-	}
-	if (status.container.name !== undefined) {
-		lines.push(`  Name: ${status.container.name}`);
-	}
-	if (status.container.status !== undefined) {
-		lines.push(`  Docker status: ${status.container.status}`);
-	}
-	return `${lines.join("\n")}\n`;
-}
-
-//#endregion
-//#region src/devcontainer.ts
-function devcontainerWorkspaceArgs(context) {
-	return [
-		"--workspace-folder",
-		context.workspaceFolder,
-		"--override-config",
-		context.generatedConfigPath
-	];
-}
-function log(message, proxyMode = false) {
-	if (proxyMode) {
-		process.stderr.write(`${message}\n`);
-	} else {
-		process.stdout.write(`${message}\n`);
-	}
-}
-function parseContainerIdFromUpOutput(output) {
-	return /"containerId"\s*:\s*"([^"]+)"/.exec(output)?.[1];
-}
-async function findWorkspaceContainer(context) {
-	const result = await runBuffered("docker", [
-		"ps",
-		"-a",
-		"--filter",
-		`label=devcontainer.local_folder=${context.workspaceFolder}`,
-		"--format",
-		"{{json .}}"
-	], {
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	if (result.code !== 0) {
-		throw new Error(`Could not inspect devcontainer for ${context.workspaceFolder}`);
-	}
-	return parseDockerPsJsonLines(result.stdout)[0];
-}
-async function listWorkspaceContainers() {
-	const result = await runBuffered("docker", [
-		"ps",
-		"-a",
-		"--filter",
-		"label=devcontainer.local_folder",
-		"--format",
-		"{{json .}}"
-	], {
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	if (result.code !== 0) {
-		return undefined;
-	}
-	return parseDockerPsJsonLines(result.stdout);
-}
-async function findRunningContainerId(context) {
-	const result = await runBuffered("docker", [
-		"ps",
-		"--filter",
-		`label=devcontainer.local_folder=${context.workspaceFolder}`,
-		"--format",
-		"{{.ID}}"
-	], {
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	if (result.code !== 0) {
-		return undefined;
-	}
-	return result.stdout.split(/\r?\n/).find((line) => line.length > 0);
-}
-async function stopWorkspaceContainer(context) {
-	const container = await findWorkspaceContainer(context);
-	if (container === undefined) {
-		process.stdout.write(`No devcontainer found for: ${context.workspaceFolder}\n`);
-		return;
-	}
-	if (container.state?.toLowerCase() !== "running") {
-		process.stdout.write(`Devcontainer is not running for: ${context.workspaceFolder}\n`);
-		return;
-	}
-	const result = await runBuffered("docker", ["stop", container.id], {
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	if (result.code !== 0) {
-		throw new Error(`Could not stop devcontainer ${container.id}`);
-	}
-	process.stdout.write(`Stopped devcontainer: ${container.id}\n`);
-}
-async function removeWorkspaceContainer(context) {
-	const container = await findWorkspaceContainer(context);
-	if (container === undefined) {
-		process.stdout.write(`No devcontainer found for: ${context.workspaceFolder}\n`);
-		return;
-	}
-	const result = await runBuffered("docker", [
-		"rm",
-		"-f",
-		container.id
-	], {
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	if (result.code !== 0) {
-		throw new Error(`Could not remove devcontainer ${container.id}`);
-	}
-	process.stdout.write(`Removed devcontainer: ${container.id}\n`);
-}
-async function startDevcontainer(context, options = {}) {
-	await ensureHostSshKey(context, options.proxyMode ?? false);
-	writeGeneratedDevcontainerConfig(context);
-	if (options.reuseRunning === true && options.recreate !== true) {
-		const runningContainerId = await findRunningContainerId(context);
-		if (runningContainerId !== undefined) {
-			log(`Using running devcontainer for: ${context.workspaceFolder}`, options.proxyMode);
-			return runningContainerId;
-		}
-	}
-	const cli = resolveDevcontainerCli(context);
-	log(`Starting devcontainer for: ${context.workspaceFolder}`, options.proxyMode);
-	const args = ["up", ...devcontainerWorkspaceArgs(context)];
-	if (options.recreate === true) {
-		args.push("--remove-existing-container");
-		log("Removing existing dev container so create-time settings apply.", options.proxyMode);
-	}
-	const result = await runBuffered(cli.command, [...cli.argsPrefix, ...args], {
-		mirrorStdout: options.proxyMode === true ? "stderr" : "stdout",
-		mirrorStderr: "stderr"
-	});
-	if (result.code !== 0) {
-		throw new Error(`devcontainer up failed for ${context.workspaceFolder}`);
-	}
-	const containerId = parseContainerIdFromUpOutput(`${result.stdout}\n${result.stderr}`) ?? await findRunningContainerId(context);
-	if (containerId === undefined) {
-		throw new Error(`Could not resolve devcontainer ID for ${context.workspaceFolder}`);
-	}
-	return containerId;
-}
-async function printPortHint(context, containerId) {
-	const config = buildGeneratedDevcontainerConfig(context);
-	const containerPort = publishContainerPortFromConfig(config);
-	if (containerPort === undefined) {
-		process.stderr.write("Warning: could not find a runArgs publish port.\n");
-		return;
-	}
-	const result = await runBuffered("docker", [
-		"port",
-		containerId,
-		`${containerPort}/tcp`
-	], {
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	const hostBinding = result.stdout.split(/\r?\n/).find((line) => line.length > 0);
-	if (result.code === 0 && hostBinding !== undefined) {
-		process.stdout.write(`\nDev server available at: http://${hostBinding}\n\n`);
-	} else {
-		process.stderr.write(`Warning: container is running but port ${containerPort}/tcp is not mapped.\n`);
-	}
-}
-async function openShell(context) {
-	const cli = resolveDevcontainerCli(context);
-	process.stdout.write("Dropping into container shell...\n");
-	return runInteractive(cli.command, [
-		...cli.argsPrefix,
-		"exec",
-		...devcontainerWorkspaceArgs(context),
-		"--",
-		"env",
-		...interactiveShellEnvArgs(),
-		"bash",
-		"-c",
-		interactiveShellScript()
-	]);
-}
-function codingAgentDevcontainerExecArgs(context, agent, agentArgs = []) {
-	return [
-		"exec",
-		...devcontainerWorkspaceArgs(context),
-		"--",
-		"env",
-		...interactiveShellEnvArgs(),
-		"bash",
-		"-c",
-		interactiveCommandScript(),
-		"boxdown-agent",
-		codingAgentBinary(agent),
-		...agentArgs
-	];
-}
-async function openCodingAgentCli(context, agent, agentArgs = []) {
-	const cli = resolveDevcontainerCli(context);
-	process.stdout.write(`Dropping into ${codingAgentBinary(agent)} inside the devcontainer...\n`);
-	return runInteractive(cli.command, [...cli.argsPrefix, ...codingAgentDevcontainerExecArgs(context, agent, agentArgs)]);
-}
-async function ensureContainerSshRuntime(context) {
-	const cli = resolveDevcontainerCli(context);
-	const result = await runBuffered(cli.command, [
-		...cli.argsPrefix,
-		"exec",
-		...devcontainerWorkspaceArgs(context),
-		"--",
-		"bash",
-		`${BOXDOWN_CONTAINER_DEVCONTAINER_DIR}/utils/ssh-bootstrap.sh`,
-		"runtime"
-	], {
-		mirrorStdout: "stderr",
-		mirrorStderr: "stderr"
-	});
-	if (result.code !== 0) {
-		throw new Error("Failed to prepare devcontainer SSH runtime");
-	}
-}
-async function refreshContainerCodingAgentClis(context, proxyMode = false, agents = []) {
-	const cli = resolveDevcontainerCli(context);
-	const result = await runBuffered(cli.command, [
-		...cli.argsPrefix,
-		"exec",
-		...devcontainerWorkspaceArgs(context),
-		"--",
-		"bash",
-		`${BOXDOWN_CONTAINER_DEVCONTAINER_DIR}/utils/coding-agent-cli-update.sh`,
-		"maybe-update",
-		...agents
-	], {
-		mirrorStdout: proxyMode ? "stderr" : "stdout",
-		mirrorStderr: "stderr"
-	});
-	if (result.code !== 0) {
-		process.stderr.write("Warning: could not refresh one or more coding-agent CLIs inside the devcontainer.\n");
-	}
-}
-async function runSshdProxy(containerId) {
-	return runInteractive("docker", [
-		"exec",
-		"-i",
-		containerId,
-		"/usr/sbin/sshd",
-		"-i",
-		"-o",
-		"LogLevel=QUIET",
-		"-o",
-		"PubkeyAuthentication=yes",
-		"-o",
-		"PasswordAuthentication=no",
-		"-o",
-		"KbdInteractiveAuthentication=no",
-		"-o",
-		"AllowTcpForwarding=yes",
-		"-o",
-		"AllowStreamLocalForwarding=yes",
-		"-o",
-		"PermitTTY=yes"
-	]);
-}
-async function hostGhTokenOrEmpty() {
-	const result = await runBuffered("gh", ["auth", "token"], {
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	if (result.code !== 0) {
-		return "";
-	}
-	return result.stdout.trim();
-}
-async function refreshContainerGhAuth(context) {
-	await ensureHostSshKey(context, true);
-	writeGeneratedDevcontainerConfig(context);
-	const token = await hostGhTokenOrEmpty();
-	if (token.length === 0) {
-		return;
-	}
-	const cli = resolveDevcontainerCli(context);
-	const login = await runBuffered(cli.command, [
-		...cli.argsPrefix,
-		"exec",
-		...devcontainerWorkspaceArgs(context),
-		"--",
-		"gh",
-		"auth",
-		"login",
-		"--hostname",
-		"github.com",
-		"--git-protocol",
-		"https",
-		"--with-token",
-		"--insecure-storage"
-	], {
-		input: `${token}\n`,
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	if (login.code !== 0) {
-		process.stderr.write("Warning: could not refresh GitHub CLI auth inside the devcontainer.\n");
-		return;
-	}
-	const gitAuthConfigured = await configureWorkspaceGithubGitAuth(context.workspaceFolder);
-	if (!gitAuthConfigured) {
-		process.stderr.write("Warning: GitHub CLI auth refreshed, but GitHub Git auth was not configured for this workspace.\n");
-	}
-	const verify = await runBuffered(cli.command, [
-		...cli.argsPrefix,
-		"exec",
-		...devcontainerWorkspaceArgs(context),
-		"--",
-		"gh",
-		"auth",
-		"status",
-		"--hostname",
-		"github.com"
-	], {
-		mirrorStdout: false,
-		mirrorStderr: false
-	});
-	if (verify.code === 0) {
-		process.stdout.write("GitHub CLI auth refreshed inside the devcontainer.\n");
-	} else {
-		process.stderr.write("Warning: GitHub CLI auth refresh completed, but verification failed.\n");
-	}
-}
-
-//#endregion
-//#region src/list.ts
-function containerState(container, dockerAvailable) {
-	if (!dockerAvailable) {
-		return "unknown";
-	}
-	return container?.state?.toLowerCase() ?? "absent";
-}
-function displayState(repoExists, container, dockerAvailable) {
-	if (!repoExists) {
-		return "missing";
-	}
-	return containerState(container, dockerAvailable);
-}
-function createWorkspaceListEntries(metadata, containers, exists) {
-	const dockerAvailable = containers !== undefined;
-	const containersByWorkspace = new Map((containers ?? []).filter((container) => container.localFolder !== undefined).map((container) => [container.localFolder, container]));
-	return metadata.map((item) => {
-		const container = containersByWorkspace.get(item.workspaceFolder);
-		const repoExists = exists(item.workspaceFolder);
-		const state = displayState(repoExists, container, dockerAvailable);
-		return {
-			...item,
-			repoExists,
-			state,
-			container: {
-				found: container !== undefined,
-				running: container?.state?.toLowerCase() === "running",
-				id: container?.id,
-				name: container?.name,
-				state: container?.state ?? (dockerAvailable ? undefined : "unknown"),
-				status: container?.status
-			}
-		};
-	}).sort((a, b) => a.workspaceBasename.localeCompare(b.workspaceBasename) || a.workspaceFolder.localeCompare(b.workspaceFolder));
-}
-function pad(value, width) {
-	return value.padEnd(width, " ");
-}
-function containerLabel(entry) {
-	if (!entry.container.found) {
-		return "-";
-	}
-	return entry.container.name ?? entry.container.id ?? "-";
-}
-function formatWorkspaceListText(entries) {
-	if (entries.length === 0) {
-		return "Boxdown list\n\nNo Boxdown workspaces found.\n";
-	}
-	const rows = entries.map((entry) => [
-		entry.state,
-		entry.workspaceBasename,
-		entry.workspaceFolder,
-		entry.sshAlias,
-		containerLabel(entry)
-	]);
-	const headers = [
-		"STATE",
-		"REPO",
-		"PATH",
-		"SSH ALIAS",
-		"CONTAINER"
-	];
-	const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0)));
-	const lines = [
-		"Boxdown list",
-		"",
-		headers.map((header, index) => pad(header, widths[index] ?? header.length)).join("  "),
-		rows.map((row) => row.map((value, index) => pad(value, widths[index] ?? value.length)).join("  ")).join("\n")
-	];
-	return `${lines.join("\n")}\n`;
-}
-
-//#endregion
-//#region src/metadata.ts
-const WORKSPACE_METADATA_VERSION = 1;
-function isWorkspaceMetadata(value) {
-	if (value === null || typeof value !== "object") {
-		return false;
-	}
-	const candidate = value;
-	return candidate.version === 1 && typeof candidate.workspaceId === "string" && typeof candidate.workspaceFolder === "string" && typeof candidate.workspaceBasename === "string" && typeof candidate.sshAlias === "string" && typeof candidate.firstSeenAt === "string" && typeof candidate.lastSeenAt === "string";
-}
-function workspaceMetadataPath(context) {
-	return (0, node_path.join)(context.workspaceDataDir, "metadata.json");
-}
-function readWorkspaceMetadataFile(path) {
-	const parsed = JSON.parse((0, node_fs.readFileSync)(path, "utf8"));
-	if (!isWorkspaceMetadata(parsed)) {
-		throw new Error(`Invalid Boxdown workspace metadata: ${path}`);
-	}
-	return parsed;
-}
-function writeWorkspaceMetadata(context, sshAlias, now = new Date()) {
-	const metadataPath = workspaceMetadataPath(context);
-	const timestamp = now.toISOString();
-	let firstSeenAt = timestamp;
-	if ((0, node_fs.existsSync)(metadataPath)) {
-		firstSeenAt = readWorkspaceMetadataFile(metadataPath).firstSeenAt;
-	}
-	const metadata = {
-		version: 1,
-		workspaceId: context.workspaceId,
-		workspaceFolder: context.workspaceFolder,
-		workspaceBasename: context.workspaceBasename,
-		sshAlias,
-		firstSeenAt,
-		lastSeenAt: timestamp
-	};
-	(0, node_fs.mkdirSync)(context.workspaceDataDir, { recursive: true });
-	(0, node_fs.writeFileSync)(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`);
-	return metadata;
-}
-function listWorkspaceMetadata(dataRoot) {
-	const workspacesDir = (0, node_path.join)(dataRoot, "workspaces");
-	if (!(0, node_fs.existsSync)(workspacesDir)) {
-		return [];
-	}
-	return (0, node_fs.readdirSync)(workspacesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => (0, node_path.join)(workspacesDir, entry.name, "metadata.json")).filter((metadataPath) => (0, node_fs.existsSync)(metadataPath)).map((metadataPath) => readWorkspaceMetadataFile(metadataPath));
-}
-
-//#endregion
-//#region src/paths.ts
-function packageRootFromImportMeta(importMetaUrl = require("url").pathToFileURL(__filename).href) {
-	return (0, node_path.dirname)((0, node_path.dirname)((0, node_url.fileURLToPath)(importMetaUrl)));
-}
-function workspaceIdFor(workspaceFolder) {
-	return (0, node_crypto.createHash)("sha256").update(workspaceFolder).digest("hex").slice(0, 16);
-}
-function resolveWorkspaceFolder(workspace, cwd = process.cwd()) {
-	const candidate = (0, node_path.resolve)(cwd, workspace ?? ".");
-	if (!(0, node_fs.existsSync)(candidate)) {
-		throw new Error(`Workspace does not exist: ${candidate}`);
-	}
-	if (!(0, node_fs.statSync)(candidate).isDirectory()) {
-		throw new Error(`Workspace is not a directory: ${candidate}`);
-	}
-	return (0, node_fs.realpathSync)(candidate);
-}
-function defaultCacheRoot(env = process.env) {
-	if (env.BOXDOWN_CACHE_HOME) {
-		return env.BOXDOWN_CACHE_HOME;
-	}
-	if (env.XDG_CACHE_HOME) {
-		return (0, node_path.join)(env.XDG_CACHE_HOME, PACKAGE_NAME);
-	}
-	return (0, node_path.join)((0, node_os.homedir)(), ".cache", PACKAGE_NAME);
-}
-function defaultDataRoot(env = process.env) {
-	if (env.BOXDOWN_DATA_HOME) {
-		return env.BOXDOWN_DATA_HOME;
-	}
-	if (env.XDG_DATA_HOME) {
-		return (0, node_path.join)(env.XDG_DATA_HOME, PACKAGE_NAME);
-	}
-	return (0, node_path.join)((0, node_os.homedir)(), ".local", "share", PACKAGE_NAME);
-}
-function createWorkspaceContext(options = {}) {
-	const env = options.env ?? process.env;
-	const workspaceFolder = resolveWorkspaceFolder(options.workspace, options.cwd);
-	const workspaceBasename = (0, node_path.basename)(workspaceFolder);
-	const workspaceId = workspaceIdFor(workspaceFolder);
-	const packageRoot = options.packageRoot ?? packageRootFromImportMeta();
-	const assetsDevcontainerDir = options.assetsDevcontainerDir ?? env.BOXDOWN_DEVCONTAINER_ASSETS_DIR ?? (0, node_path.join)(packageRoot, "assets", "devcontainer");
-	const cacheRoot = defaultCacheRoot(env);
-	const dataRoot = defaultDataRoot(env);
-	const workspaceCacheDir = (0, node_path.join)(cacheRoot, "workspaces", workspaceId);
-	const workspaceDataDir = (0, node_path.join)(dataRoot, "workspaces", workspaceId);
-	return {
-		workspaceFolder,
-		workspaceBasename,
-		workspaceId,
-		packageRoot,
-		assetsDevcontainerDir,
-		cacheRoot,
-		dataRoot,
-		workspaceCacheDir,
-		workspaceDataDir,
-		generatedConfigPath: (0, node_path.join)(workspaceCacheDir, "devcontainer.json"),
-		sshKeyDir: (0, node_path.join)(workspaceDataDir, "ssh"),
-		sshKeyPath: (0, node_path.join)(workspaceDataDir, "ssh", "id_ed25519"),
-		sshPublicKeyPath: (0, node_path.join)(workspaceDataDir, "ssh", "id_ed25519.pub"),
-		sshPublicKeyRuntimeDir: (0, node_path.join)(workspaceDataDir, "ssh-public"),
-		sshPublicKeyRuntimePath: (0, node_path.join)(workspaceDataDir, "ssh-public", "id_ed25519.pub")
-	};
-}
-
-//#endregion
-//#region src/main.ts
-const USAGE = `Usage:
-  boxdown start [--workspace <path>] [--recreate]
-  boxdown codex [--workspace <path>] [--recreate] [-- <codex args...>]
-  boxdown claude [--workspace <path>] [--recreate] [-- <claude args...>]
-  boxdown cc [--workspace <path>] [--recreate] [-- <claude args...>]
-  boxdown opencode [--workspace <path>] [--recreate] [-- <opencode args...>]
-  boxdown antigravity [--workspace <path>] [--recreate] [-- <agy args...>]
-  boxdown list [--json]
-  boxdown status [--workspace <path>] [--alias <name>] [--json]
-  boxdown stop [--workspace <path>]
-  boxdown down [--workspace <path>]
-  boxdown doctor [--workspace <path>]
-  boxdown ssh-config install [--workspace <path>] [--alias <name>]
-  boxdown ssh-proxy [--workspace <path>] [--alias <name>]
-  boxdown refresh-gh-token [--workspace <path>]
-  boxdown refresh-gh-token-running [--workspace <path>]
-
-Commands:
-  start                     Start or reuse the workspace devcontainer, then open
-                            an interactive shell inside it. Alias: shell.
-  codex                     Start or reuse the devcontainer, then launch Codex.
-  claude                    Start or reuse the devcontainer, then launch Claude
-                            Code. Alias: cc.
-  opencode                  Start or reuse the devcontainer, then launch
-                            OpenCode.
-  antigravity               Start or reuse the devcontainer, then launch
-                            Antigravity CLI (agy).
-  list                      List Boxdown-known devcontainer workspaces from any
-                            directory.
-  status                    Show workspace state, generated paths, SSH key paths,
-                            and the matching devcontainer state.
-  stop                      Stop the workspace devcontainer if it is running.
-  down                      Remove the workspace devcontainer. Keeps Boxdown
-                            cache, generated config, data, and SSH keys.
-  doctor                    Check required host tools and Boxdown assets.
-  ssh-config install        Install or update an SSH host alias for the workspace
-                            devcontainer.
-  ssh-proxy                 Internal command used by the generated SSH
-                            ProxyCommand. Starts or reuses the devcontainer and
-                            bridges SSH over docker exec.
-  refresh-gh-token          Start or reuse the devcontainer, then copy host
-                            GitHub CLI auth into the container when available.
-  refresh-gh-token-running  Refresh GitHub CLI auth only if the workspace
-                            devcontainer is already running.
-
-Options:
-  --workspace <path>  Target project directory. Defaults to the current directory.
-  --alias <name>      SSH host alias. Defaults to <repo-name>-devcontainer.
-  --recreate          Remove the existing devcontainer before starting.
-  --json              Print JSON output. Supported by status and list.
-  --help, -h          Show help.
-`;
-function commandWritesWorkspaceMetadata(command) {
-	return [
-		"start",
-		"ssh-config-install",
-		"ssh-proxy",
-		"refresh-gh-token",
-		"refresh-gh-token-running",
-		"coding-agent"
-	].includes(command);
-}
-function parseCliArgs(argv) {
-	const args = [...argv];
-	let workspace;
-	let alias;
-	let recreate = false;
-	let json = false;
-	let passthroughArgs;
-	const positional = [];
-	function parsed(command) {
-		if (json && command !== "status" && command !== "list") {
-			throw new Error("--json is only supported with status and list");
-		}
-		if (passthroughArgs !== undefined) {
-			throw new Error("-- passthrough is only supported with coding-agent commands");
-		}
-		return {
-			command,
-			workspace,
-			alias,
-			recreate,
-			json
-		};
-	}
-	function parsedCodingAgent(agent) {
-		if (json) {
-			throw new Error("--json is only supported with status and list");
-		}
-		return {
-			command: "coding-agent",
-			agent,
-			agentArgs: passthroughArgs ?? [],
-			workspace,
-			alias,
-			recreate,
-			json
-		};
-	}
-	while (args.length > 0) {
-		const arg = args.shift();
-		if (arg === undefined) {
-			break;
-		}
-		if (arg === "--") {
-			passthroughArgs = args.splice(0);
-			break;
-		}
-		if (arg === "--help" || arg === "-h") {
-			return parsed("help");
-		}
-		if (arg === "--workspace") {
-			const value = args.shift();
-			if (value === undefined) {
-				throw new Error("--workspace requires a value");
-			}
-			workspace = value;
-			continue;
-		}
-		if (arg === "--alias") {
-			const value = args.shift();
-			if (value === undefined) {
-				throw new Error("--alias requires a value");
-			}
-			alias = value;
-			continue;
-		}
-		if (arg === "--recreate") {
-			recreate = true;
-			continue;
-		}
-		if (arg === "--json") {
-			json = true;
-			continue;
-		}
-		if (arg.startsWith("-")) {
-			throw new Error(`Unknown option: ${arg}`);
-		}
-		positional.push(arg);
-	}
-	if (positional.length === 0) {
-		return parsed("help");
-	}
-	if (positional[0] === "start" || positional[0] === "shell") {
-		return parsed("start");
-	}
-	const codingAgent = codingAgentFromCommand(positional[0] ?? "");
-	if (codingAgent !== undefined) {
-		if (positional.length > 1) {
-			throw new Error("Coding-agent CLI arguments must come after --");
-		}
-		return parsedCodingAgent(codingAgent);
-	}
-	if (positional[0] === "list" && positional.length === 1) {
-		return parsed("list");
-	}
-	if (positional[0] === "status" && positional.length === 1) {
-		return parsed("status");
-	}
-	if (positional[0] === "stop" && positional.length === 1) {
-		return parsed("stop");
-	}
-	if (positional[0] === "down" && positional.length === 1) {
-		return parsed("down");
-	}
-	if (positional[0] === "doctor" && positional.length === 1) {
-		return parsed("doctor");
-	}
-	if (positional[0] === "ssh-config") {
-		if (positional.length === 1 || positional[1] === "install" && positional.length === 2) {
-			return parsed("ssh-config-install");
-		}
-		throw new Error(`Unknown ssh-config command: ${positional.slice(1).join(" ")}. Usage: boxdown ssh-config [install] [--workspace <path>] [--alias <name>]`);
-	}
-	if (positional[0] === "ssh-proxy" && positional.length === 1) {
-		return parsed("ssh-proxy");
-	}
-	if (positional[0] === "refresh-gh-token" && positional.length === 1) {
-		return parsed("refresh-gh-token");
-	}
-	if (positional[0] === "refresh-gh-token-running" && positional.length === 1) {
-		return parsed("refresh-gh-token-running");
-	}
-	throw new Error(`Unknown command: ${positional.join(" ")}`);
-}
-async function runCli(argv = process.argv.slice(2)) {
-	try {
-		const parsed = parseCliArgs(argv);
-		if (parsed.command === "help") {
-			process.stdout.write(USAGE);
-			return 0;
-		}
-		if (parsed.command === "list") {
-			const metadata = listWorkspaceMetadata(defaultDataRoot());
-			const containers = await listWorkspaceContainers();
-			const entries = createWorkspaceListEntries(metadata, containers, node_fs.existsSync);
-			if (parsed.json) {
-				process.stdout.write(`${JSON.stringify(entries, null, 2)}\n`);
-			} else {
-				process.stdout.write(formatWorkspaceListText(entries));
-			}
-			return 0;
-		}
-		const context = createWorkspaceContext({ workspace: parsed.workspace });
-		const alias = parsed.alias ?? defaultSshAlias(context.workspaceBasename);
-		const aliasSource = parsed.alias === undefined ? "default" : "provided";
-		if (commandWritesWorkspaceMetadata(parsed.command)) {
-			writeWorkspaceMetadata(context, alias);
-		}
-		if (parsed.command === "ssh-config-install") {
-			await installSshConfig(context, alias);
-			return 0;
-		}
-		if (parsed.command === "status") {
-			const container = await findWorkspaceContainer(context);
-			const status = createStatusInfo(context, alias, container, node_fs.existsSync, { aliasSource });
-			if (parsed.json) {
-				process.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
-			} else {
-				process.stdout.write(formatStatusText(status, { color: true }));
-			}
-			return statusIsHealthy(status) ? 0 : 1;
-		}
-		if (parsed.command === "stop") {
-			await stopWorkspaceContainer(context);
-			return 0;
-		}
-		if (parsed.command === "down") {
-			await removeWorkspaceContainer(context);
-			return 0;
-		}
-		if (parsed.command === "doctor") {
-			const checks = await runDoctorChecks(context);
-			process.stdout.write(formatDoctorText(checks));
-			return doctorHasFailures(checks) ? 1 : 0;
-		}
-		if (!(0, node_fs.existsSync)(context.assetsDevcontainerDir)) {
-			throw new Error(`Missing Boxdown devcontainer assets: ${context.assetsDevcontainerDir}`);
-		}
-		if (parsed.command === "ssh-proxy") {
-			await installSshConfig(context, alias, { quiet: true });
-			const containerId = await startDevcontainer(context, {
-				recreate: parsed.recreate,
-				proxyMode: true,
-				reuseRunning: true
-			});
-			await refreshContainerCodingAgentClis(context, true);
-			await ensureContainerSshRuntime(context);
-			return runSshdProxy(containerId);
-		}
-		if (parsed.command === "refresh-gh-token-running") {
-			const containerId = await findRunningContainerId(context);
-			if (containerId === undefined) {
-				throw new Error(`No running devcontainer found for: ${context.workspaceFolder}`);
-			}
-			await refreshContainerGhAuth(context);
-			return 0;
-		}
-		if (parsed.command === "refresh-gh-token") {
-			await startDevcontainer(context);
-			await refreshContainerGhAuth(context);
-			return 0;
-		}
-		if (parsed.command === "coding-agent") {
-			const agent = parsed.agent;
-			if (agent === undefined) {
-				throw new Error("Missing coding-agent command");
-			}
-			await startDevcontainer(context, { recreate: parsed.recreate });
-			await refreshContainerCodingAgentClis(context, false, [agent]);
-			return openCodingAgentCli(context, agent, parsed.agentArgs ?? []);
-		}
-		const containerId = await startDevcontainer(context, { recreate: parsed.recreate });
-		await printPortHint(context, containerId);
-		return openShell(context);
-	} catch (error) {
-		process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-		return 1;
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'USAGE', {
-  enumerable: true,
-  get: function () {
-    return USAGE;
-  }
-});
-Object.defineProperty(exports, 'commandWritesWorkspaceMetadata', {
-  enumerable: true,
-  get: function () {
-    return commandWritesWorkspaceMetadata;
-  }
-});
-Object.defineProperty(exports, 'parseCliArgs', {
-  enumerable: true,
-  get: function () {
-    return parseCliArgs;
-  }
-});
-Object.defineProperty(exports, 'runCli', {
-  enumerable: true,
-  get: function () {
-    return runCli;
-  }
-});