overmux 0.0.2 → 0.0.3

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # overmux
 
+## 0.0.3
+
+### Patch Changes
+
+- [#118](https://github.com/richardgill/overmux/pull/118) [`78a3b8f`](https://github.com/richardgill/overmux/commit/78a3b8f9b143b8408989309bfaa399208daaa133) Thanks [@richardgill](https://github.com/richardgill)! - Catch up the initial patch release with init scaffolding, resilient terminal connections and tmux navigation, plus improved xterm links, clipboard support, and Unicode rendering. The Zellij integration remains an independent minor release and now requires the current Overmux peer version.
+
+- [#117](https://github.com/richardgill/overmux/pull/117) [`d000b17`](https://github.com/richardgill/overmux/commit/d000b170d085f087e364672b3139b01e8fea1902) Thanks [@richardgill](https://github.com/richardgill)! - Scaffold AI agent guidance files when initializing an Overmux project.
+
+- Updated dependencies [[`78a3b8f`](https://github.com/richardgill/overmux/commit/78a3b8f9b143b8408989309bfaa399208daaa133)]:
+  - @overmux/keybindings@0.0.3
+
 ## 0.0.2
 
 ### Patch Changes

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
+import { createRequire, findPackageJSON } from "node:module";
 import { access, chmod, readFile, readdir, realpath } from "node:fs/promises";
 import { createConnection, isIP } from "node:net";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
@@ -11,7 +11,7 @@ import ts from "typescript";
 import { isDeepStrictEqual } from "node:util";
 import { fork, spawnSync } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { createWriteStream, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readlinkSync, renameSync, rmSync, watch } from "node:fs";
+import { cpSync, createWriteStream, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -877,7 +877,7 @@ function listAllRouteNamesAndAliasesForScan(routeMap, scannerCaseStyle, config)
 		return [routeName];
 	});
 }
-async function runCommand$1({ loader, parameters }, { context, inputs, scannerConfig, errorFormatting, determineExitCode, ansiColorByStream }) {
+async function runCommand$2({ loader, parameters }, { context, inputs, scannerConfig, errorFormatting, determineExitCode, ansiColorByStream }) {
 	let parsedArguments;
 	try {
 		const scanner = buildArgumentScanner(parameters, scannerConfig);
@@ -1348,7 +1348,7 @@ async function scanInputsAndRunTarget(app, rawInputs, context, text, ansiColorBy
 		result
 	});
 	if (typeof hookStartExitCode === "number") return hookStartExitCode;
-	const exitCode = await runCommand$1(result.target, {
+	const exitCode = await runCommand$2(result.target, {
 		context: commandContext,
 		inputs: result.unprocessedInputs,
 		scannerConfig: app.config.scanner,
@@ -3529,7 +3529,7 @@ var downloadVerifiedAsset = async ({ asset, destination, expectedSha256, fetch =
 //#region src/internal/cli/commands/desktop-installer.ts
 var bundleIdentifier = "com.overmux.desktop";
 var bundleName = "Overmux.app";
-var runCommand = (command, args) => {
+var runCommand$1 = (command, args) => {
 	const result = spawnSync(command, args, { encoding: "utf8" });
 	if (result.error) throw new Error(`Could not run ${command}`, { cause: result.error });
 	return {
@@ -3565,7 +3565,7 @@ var createDependencies = (process) => ({
 	findRelease: findDesktopRelease,
 	homeDirectory: homedir(),
 	platform: process.platform,
-	runCommand,
+	runCommand: runCommand$1,
 	sleep,
 	stderr: process.stderr,
 	stdout: process.stdout
@@ -3814,6 +3814,336 @@ var createDocsCommand = ({ docsRoot, output }) => buildCommand({
 	docs: { brief: "Print the installed documentation directory" }
 });
 //#endregion
+//#region src/internal/cli/commands/init-template.ts
+var initScaffoldPaths = [
+	".gitignore",
+	"AGENTS.md",
+	"CLAUDE.md",
+	"mise.toml",
+	"package.json",
+	"pnpm-lock.yaml",
+	"overmux.config.ts",
+	"src/server/index.ts",
+	"src/ui/app.tsx",
+	"src/ui/index.html",
+	"src/ui/main.tsx",
+	"src/ui/styles.css",
+	"vite.config.ts"
+];
+var packageJson = (overmuxVersion) => `${JSON.stringify({
+	name: "my-overmux",
+	private: true,
+	type: "module",
+	scripts: {
+		build: "vite build",
+		check: "overmux check --config ./overmux.config.ts",
+		dev: "overmux serve --config ./overmux.config.ts"
+	},
+	dependencies: {
+		overmux: overmuxVersion,
+		react: "^19.0.0",
+		"react-dom": "^19.0.0"
+	},
+	devDependencies: {
+		"@types/react": "^19.0.0",
+		"@types/react-dom": "^19.0.0",
+		"@vitejs/plugin-react": "^6.0.0",
+		typescript: "^5.9.0",
+		vite: "^8.0.0"
+	}
+}, null, 2)}\n`;
+var createInitScaffold = ({ overmuxVersion, toolchain }) => ({
+	".gitignore": "node_modules\ndist\n",
+	"AGENTS.md": "Immediately run `overmux ai context` for documentation about Overmux.\n",
+	"CLAUDE.md": "@AGENTS.md\n",
+	...toolchain === "mise" ? { "mise.toml": `[tools]
+node = "22"
+pnpm = "10"
+"npm:overmux" = "${overmuxVersion}"
+` } : {},
+	"package.json": packageJson(overmuxVersion),
+	"overmux.config.ts": `import { defineOvermuxConfig } from "overmux";
+
+import server from "./src/server/index";
+
+export default defineOvermuxConfig({
+  auth: { mode: "cli-login" },
+  productionWebAssetsDir: "./dist",
+  server,
+  vite: "./vite.config.ts",
+});
+`,
+	"src/server/index.ts": `import { defineOvermuxServer } from "overmux";
+
+export default defineOvermuxServer({ resources: {} });
+`,
+	"src/ui/app.tsx": `import { defineOvermuxClient } from "overmux/client";
+
+const App = () => <main>Overmux is running.</main>;
+
+export default defineOvermuxClient({
+  commands: {},
+  component: App,
+});
+`,
+	"src/ui/index.html": `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Overmux</title>
+  </head>
+  <body>
+    <div id="root">
+      <p>Loading Overmux…</p>
+      <button type="button" onclick="location.reload()">Retry</button>
+    </div>
+    <script type="module" src="/main.tsx"><\/script>
+  </body>
+</html>
+`,
+	"src/ui/main.tsx": `import { OvermuxHost } from "overmux/client";
+import { createRoot } from "react-dom/client";
+
+import definition from "./app";
+import "./styles.css";
+
+const root = document.querySelector("#root");
+if (!root) {
+  throw new Error("Missing root element");
+}
+
+createRoot(root).render(<OvermuxHost definition={definition} />);
+`,
+	"src/ui/styles.css": `:root {
+  color: #f5f5f5;
+  background: #111;
+  font-family: system-ui, sans-serif;
+}
+
+body {
+  margin: 0;
+}
+
+main {
+  display: grid;
+  min-height: 100vh;
+  place-items: center;
+}
+`,
+	"vite.config.ts": `import viteReact from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  build: { emptyOutDir: true, outDir: "../../dist" },
+  plugins: [viteReact()],
+  root: "src/ui",
+});
+`
+});
+//#endregion
+//#region src/internal/cli/commands/init.ts
+var miseActivationDocs = "https://mise.jdx.dev/getting-started.html#activate-mise";
+var runCommand = (command, args, options) => {
+	const result = spawnSync(command, args, {
+		cwd: options?.cwd,
+		encoding: "utf8",
+		maxBuffer: 20971520
+	});
+	return {
+		error: result.error,
+		status: result.status,
+		stderr: result.stderr ?? "",
+		stdout: result.stdout ?? ""
+	};
+};
+var getLatestOvermuxVersion = async () => {
+	const response = await fetch("https://registry.npmjs.org/overmux/latest", { headers: { accept: "application/json" } });
+	if (!response.ok) throw new Error(`Could not resolve the latest Overmux version: npm returned ${response.status}`);
+	const body = await response.json();
+	const version = typeof body === "object" && body !== null && "version" in body ? body.version : void 0;
+	if (typeof version !== "string") throw new Error("Could not resolve the latest Overmux version from npm");
+	return version;
+};
+var commandExists = (result) => result.error?.code !== "ENOENT";
+var isMiseActivated = (dependencies) => {
+	const doctor = dependencies.runCommand("mise", ["doctor", "--json"]);
+	if (doctor.status !== 0) return false;
+	try {
+		const report = JSON.parse(doctor.stdout);
+		return typeof report === "object" && report !== null && "activated" in report && report.activated === true;
+	} catch {
+		return false;
+	}
+};
+var detectToolchain = (dependencies) => {
+	const mise = dependencies.runCommand("mise", ["--version"]);
+	if (commandExists(mise)) {
+		if (mise.status !== 0) throw new Error(`Mise could not be validated. Activate mise and try again. ${miseActivationDocs}`);
+		if (!isMiseActivated(dependencies)) throw new Error(`Mise must be activated in your shell before running overmux init. ${miseActivationDocs}`);
+		return "mise";
+	}
+	const pnpm = dependencies.runCommand("pnpm", ["--version"]);
+	const major = Number.parseInt(pnpm.stdout.trim().split(".")[0] ?? "", 10);
+	if (!commandExists(pnpm) || pnpm.status !== 0 || !Number.isFinite(major)) throw new Error("pnpm 10 or newer is required when mise is not installed");
+	if (major < 10) throw new Error(`pnpm 10 or newer is required when mise is not installed (found ${pnpm.stdout.trim()})`);
+	return "pnpm";
+};
+var findCollisions = (directory) => {
+	if (existsSync(directory) && !statSync(directory).isDirectory()) return [directory];
+	return initScaffoldPaths.filter((path) => existsSync(join(directory, path)));
+};
+var writeScaffold = (directory, files) => {
+	Object.entries(files).forEach(([path, content]) => {
+		const destination = join(directory, path);
+		mkdirSync(dirname(destination), { recursive: true });
+		writeFileSync(destination, content);
+	});
+};
+var runProjectCommand = ({ args, command, cwd, dependencies }) => {
+	const result = dependencies.runCommand(command, args, { cwd });
+	dependencies.stdout.write(result.stdout);
+	dependencies.stderr.write(result.stderr);
+	if (result.error || result.status !== 0) throw new Error(`Command failed: ${command} ${args.join(" ")}`);
+};
+var pnpmCommands = [["install", "--ignore-workspace"], [
+	"exec",
+	"overmux",
+	"check",
+	"--config",
+	"./overmux.config.ts"
+]];
+var installAndCheck = ({ directory, dependencies, toolchain }) => {
+	const context = {
+		cwd: directory,
+		dependencies
+	};
+	if (toolchain === "mise") runProjectCommand({
+		...context,
+		command: "mise",
+		args: [
+			"install",
+			"node@22",
+			"pnpm@10",
+			"--yes"
+		]
+	});
+	pnpmCommands.forEach((args) => runProjectCommand({
+		...context,
+		command: toolchain,
+		args: toolchain === "mise" ? [
+			"exec",
+			"node@22",
+			"pnpm@10",
+			"--",
+			"pnpm",
+			...args
+		] : args
+	}));
+};
+var mergeScaffold = (source, target) => {
+	if (!existsSync(target)) {
+		renameSync(source, target);
+		return;
+	}
+	cpSync(source, target, {
+		errorOnExist: true,
+		force: false,
+		recursive: true
+	});
+};
+var initializeOvermux = async (dependencies) => {
+	const directory = resolve(dependencies.directory);
+	const collisions = findCollisions(directory);
+	if (collisions.length > 0) throw new Error(`Refusing to overwrite existing files:\n${collisions.map((path) => `- ${path}`).join("\n")}`);
+	const toolchain = detectToolchain(dependencies);
+	const files = createInitScaffold({
+		overmuxVersion: await dependencies.getLatestOvermuxVersion(),
+		toolchain
+	});
+	const parent = dirname(directory);
+	mkdirSync(parent, { recursive: true });
+	const stagingDirectory = mkdtempSync(join(parent, ".overmux-init-"));
+	try {
+		writeScaffold(stagingDirectory, Object.fromEntries(Object.entries(files).filter(([path]) => path !== "mise.toml")));
+		installAndCheck({
+			directory: stagingDirectory,
+			dependencies,
+			toolchain
+		});
+		if (!existsSync(join(stagingDirectory, "pnpm-lock.yaml"))) throw new Error("pnpm install did not generate pnpm-lock.yaml");
+		if (files["mise.toml"]) writeFileSync(join(stagingDirectory, "mise.toml"), files["mise.toml"]);
+		mergeScaffold(stagingDirectory, directory);
+	} finally {
+		rmSync(stagingDirectory, {
+			force: true,
+			recursive: true
+		});
+	}
+	dependencies.stdout.write(`Initialized Overmux in ${directory}\nNext: overmux serve\n`);
+};
+var createInitCommand = (process) => buildCommand({
+	func: () => initializeOvermux({
+		directory: getOvermuxPaths({ environment: process.env }).configDir,
+		getLatestOvermuxVersion,
+		runCommand,
+		stderr: process.stderr,
+		stdout: process.stdout
+	}),
+	parameters: { flags: {} },
+	docs: { brief: "Create a minimal Overmux application" }
+});
+//#endregion
+//#region src/internal/cli/commands/zellij-install.ts
+var resolveZellijInstall = (cwd) => {
+	const projectUrl = pathToFileURL(resolve(cwd, "package.json"));
+	const packagePath = findPackageJSON("@overmux/zellij/install", projectUrl);
+	if (packagePath === void 0) throw new Error("package not found");
+	const installExport = JSON.parse(readFileSync(packagePath, "utf8")).exports?.["./install"]?.import;
+	if (typeof installExport !== "string") throw new Error("package has no importable ./install export");
+	return resolve(dirname(packagePath), installExport);
+};
+var defaultDependencies = () => {
+	const cwd = process.cwd();
+	return {
+		cwd,
+		importModule: (specifier) => import(specifier),
+		resolveInstall: () => resolveZellijInstall(cwd)
+	};
+};
+var executeZellijInstall = async ({ session }, dependencies = defaultDependencies()) => {
+	let modulePath;
+	try {
+		modulePath = dependencies.resolveInstall();
+	} catch {
+		throw new Error(`Could not resolve @overmux/zellij/install from ${dependencies.cwd}. Add @overmux/zellij to this project, then run the command again.`);
+	}
+	const integration = await dependencies.importModule(pathToFileURL(modulePath).href);
+	if (typeof integration.installZellij !== "function") throw new Error("@overmux/zellij/install does not export installZellij. Update @overmux/zellij and run the command again.");
+	return integration.installZellij({ session });
+};
+var runZellijInstall = async ({ session }) => {
+	const result = await executeZellijInstall({ session });
+	console.log(`Installed Zellij plugin ${result.pluginVersion} (protocol ${result.protocolVersion})\nSession: ${result.session}\nArtifact: ${result.artifactPath}\nSHA-256: ${result.sha256}`);
+};
+var integrationCommand = buildRouteMap({
+	docs: { brief: "Manage Overmux integrations" },
+	routes: { install: buildRouteMap({
+		docs: { brief: "Install an Overmux integration" },
+		routes: { zellij: buildCommand({
+			docs: { brief: "Install and approve the @overmux/zellij plugin" },
+			func: runZellijInstall,
+			parameters: { flags: { session: {
+				brief: "Target an active Zellij session",
+				kind: "parsed",
+				optional: true,
+				parse: String,
+				placeholder: "name"
+			} } }
+		}) }
+	}) }
+});
+//#endregion
 //#region src/internal/shared/routes.ts
 var viteHmrPath = "/_overmux/vite/hmr";
 //#endregion
@@ -4721,7 +5051,7 @@ var detectCliEnvironment = async (process = globalThis.process) => {
 //#endregion
 //#region src/internal/cli/app.ts
 var createCliApp = (process = globalThis.process) => buildApplication(buildRouteMap({
-	docs: { brief: "Serve, validate, or invoke Overmux operations" },
+	docs: { brief: "Initialize and manage Overmux applications" },
 	routes: {
 		ai: createAiRoute(process),
 		auth: authRoute,
@@ -4732,6 +5062,8 @@ var createCliApp = (process = globalThis.process) => buildApplication(buildRoute
 			docsRoot: resolveInstalledDocsRoot(import.meta.url),
 			output: process.stdout
 		}),
+		init: createInitCommand(process),
+		integration: integrationCommand,
 		serve: serveCommand
 	}
 }), {