overmux 0.0.2 → 0.0.4

package/dist/bin.js

@@ -1,17 +1,17 @@
 #!/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";
 import { createJiti } from "jiti";
 import { ZodError, z } from "zod";
-import { homedir, tmpdir } from "node:os";
+import { homedir, hostname, tmpdir } from "node:os";
 import { createHash } from "node:crypto";
 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,
@@ -1842,6 +1842,7 @@ var durationToMilliseconds = (duration) => {
 	return Number.isSafeInteger(milliseconds) ? milliseconds : void 0;
 };
 var aiContextSnippets = ["package-source", "tech-stack-recommendations"];
+var instanceIdSchema$1 = z.string().max(253).regex(/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?(?![\s\S])/, "Expected a lowercase instance ID with only ASCII letters, digits, internal dots and hyphens");
 var zodTypeSchema = z.custom((value) => value instanceof z.ZodType, "Expected a Zod schema");
 var functionSchema = z.custom((value) => typeof value === "function", "Expected a function");
 var contractRuntimeSchema = z.object({
@@ -1909,6 +1910,7 @@ var configDefinitionRuntimeSchema = serverConfigRuntimeSchema.extend({
 	aiContextSnippets: z.array(z.enum(aiContextSnippets)).optional(),
 	auth: authConfigRuntimeSchema,
 	debug: z.boolean().optional(),
+	instanceId: z.union([instanceIdSchema$1, z.custom((value) => typeof value === "function", "Expected an instance ID or a function of the bound port")]).optional(),
 	server: serverDefinitionRuntimeSchema,
 	vite: z.string().min(1).optional()
 });
@@ -1989,6 +1991,11 @@ var notificationSchema = z.object({
 	open: z.object({ link: notificationLinkSchema }).strict().optional(),
 	title: z.string().min(1).max(4096)
 }).strict();
+var instanceIdSchema = z.string().max(253).regex(/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?(?![\s\S])/, "Expected a lowercase instance ID with only ASCII letters, digits, internal dots and hyphens");
+var createInstanceIdentity = (instanceId) => ({
+	instanceId: instanceIdSchema.parse(instanceId),
+	deepLinkPrefix: `overmux://${instanceId}`
+});
 var defaultAiContextSnippets = [...[packageSourceSnippet], techStackRecommendationsSnippet];
 var packageSourceSnippetContent = `Overmux ships with documentation and TypeScript source.
 
@@ -2047,6 +2054,7 @@ var readPrivateJson = async (path, schema) => {
 //#region src/internal/server/auth/instance-control.ts
 var maxControlMessageBytes = 16384;
 z.discriminatedUnion("type", [
+	z.object({ type: z.literal("get-instance") }).strict(),
 	z.object({ type: z.literal("ping") }).strict(),
 	z.object({ type: z.literal("create-login") }).strict(),
 	z.object({ type: z.literal("issue-bearer") }).strict(),
@@ -2072,6 +2080,10 @@ var sessionSchema = z.object({
 	revokedAt: z.string().optional()
 }).strict();
 var controlResponseSchemas = {
+	"get-instance": z.object({
+		instanceId: instanceIdSchema,
+		ok: z.literal(true)
+	}).strict(),
 	"create-login": z.object({
 		login: loginGrantSchema,
 		ok: z.literal(true)
@@ -2234,7 +2246,7 @@ var printLoginGrant = ({ login, output, port }) => {
 //#region src/internal/cli/parse-port.ts
 var parsePort = (value) => {
 	const port = Number(value);
-	return serverConfigRuntimeSchema.shape.port.safeParse(port).success ? port : /* @__PURE__ */ new Error(`Invalid port: ${value}`);
+	return port > 0 && serverConfigRuntimeSchema.shape.port.safeParse(port).success ? port : /* @__PURE__ */ new Error(`Invalid port: ${value}`);
 };
 //#endregion
 //#region src/internal/cli/commands/auth.ts
@@ -2415,7 +2427,7 @@ z.object({ endpoint: backgroundNotificationSubscriptionSchema.shape.endpoint }).
 z.object({
 	debug: z.boolean(),
 	operations: z.array(z.string().min(1)),
-	protocolVersion: z.literal(9),
+	protocolVersion: z.literal(10),
 	resources: z.array(z.string().min(1)),
 	streams: z.array(z.string().min(1))
 });
@@ -2521,7 +2533,12 @@ var protocolErrorMessageSchema = z.object({
 	subscriptionId: operationIdSchema.optional(),
 	type: z.literal("error")
 });
+var serverInfoMessageSchema = z.object({
+	type: z.literal("server-info"),
+	instanceId: instanceIdSchema
+}).strict();
 z.discriminatedUnion("type", [
+	serverInfoMessageSchema,
 	resourceResultMessageSchema,
 	resourceInvalidatedMessageSchema,
 	streamOpenedMessageSchema,
@@ -2533,6 +2550,30 @@ z.discriminatedUnion("type", [
 	notificationEventSchema
 ]);
 //#endregion
+//#region src/internal/server/runtime/runtime-instance.ts
+var createRuntimeInstance = (configured) => {
+	let identity;
+	const get = () => {
+		if (!identity) throw new Error("Overmux instance identity is not ready");
+		return identity;
+	};
+	return {
+		context: {
+			getInstanceId: () => get().instanceId,
+			getDeepLinkPrefix: () => get().deepLinkPrefix
+		},
+		establish: (port) => {
+			if (identity) throw new Error("Overmux instance identity is already established");
+			try {
+				identity = createInstanceIdentity(typeof configured === "function" ? configured({ port }) : configured ?? `${hostname()}-${port}`);
+			} catch (cause) {
+				throw new Error("Invalid Overmux instance ID; configure instanceId with a canonical lowercase ID", { cause });
+			}
+			return identity;
+		}
+	};
+};
+//#endregion
 //#region src/internal/server/runtime/runtime-lifecycle.ts
 var asError = (cause) => cause instanceof Error ? cause : new Error(String(cause));
 var disposeAll = async (disposers) => {
@@ -2699,7 +2740,7 @@ var getInvalidatedResourceIds = (graph, resourceId) => {
 };
 //#endregion
 //#region src/internal/server/runtime/runtime-resources.ts
-var createRuntimeResources = ({ definitions, lifecycle }) => {
+var createRuntimeResources = ({ definitions, instance, lifecycle }) => {
 	const graph = createResourceDependencyGraph(definitions);
 	const invalidationListeners = /* @__PURE__ */ new Set();
 	const contracts = /* @__PURE__ */ new Map();
@@ -2724,6 +2765,7 @@ var createRuntimeResources = ({ definitions, lifecycle }) => {
 		});
 	};
 	const context = (signal) => ({
+		instance,
 		invalidate,
 		signal: lifecycle.requestSignal(signal)
 	});
@@ -2858,9 +2900,11 @@ var createRuntimeStreams = ({ context, definitions, lifecycle }) => {
 //#region src/internal/server/runtime/create-runtime.ts
 var createRuntime = async ({ config, debug = false, notifications = { send: async () => void 0 }, signal }) => {
 	const lifecycle = createRuntimeLifecycle(signal);
+	const instance = createRuntimeInstance(config.instanceId);
 	try {
 		const resources = createRuntimeResources({
 			definitions: config.server.resources ?? {},
+			instance: instance.context,
 			lifecycle
 		});
 		const context = resources.context;
@@ -2876,14 +2920,17 @@ var createRuntime = async ({ config, debug = false, notifications = { send: asyn
 		});
 		lifecycle.signal.throwIfAborted();
 		lifecycle.completePreparation();
+		const manifest = {
+			debug,
+			operations: [...operations.names],
+			protocolVersion: 10,
+			resources: [...resources.names],
+			streams: [...streams.names]
+		};
 		return {
-			manifest: {
-				debug,
-				operations: [...operations.names],
-				protocolVersion: 9,
-				resources: [...resources.names],
-				streams: [...streams.names]
-			},
+			instance: instance.context,
+			establishInstance: instance.establish,
+			manifest,
 			dispose: lifecycle.dispose,
 			getOperation: operations.get,
 			getResource: resources.get,
@@ -3529,7 +3576,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 +3612,7 @@ var createDependencies = (process) => ({
 	findRelease: findDesktopRelease,
 	homeDirectory: homedir(),
 	platform: process.platform,
-	runCommand,
+	runCommand: runCommand$1,
 	sleep,
 	stderr: process.stderr,
 	stdout: process.stdout
@@ -3814,6 +3861,368 @@ 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/cli/commands/instance.ts
+var runInstance = async (flags, output) => {
+	const port = flags.port === void 0 ? void 0 : parsePort(flags.port);
+	if (port instanceof Error) throw port;
+	const identity = createInstanceIdentity((await sendControlRequest(await discoverInstance(port), { type: "get-instance" })).instanceId);
+	output.write(flags.json ? `${JSON.stringify(identity)}\n` : `Instance ID: ${identity.instanceId}\nDeep-link prefix: ${identity.deepLinkPrefix}\n`);
+};
+var createInstanceCommand = (output) => buildCommand({
+	func: (flags) => runInstance(flags, output),
+	parameters: {
+		aliases: { p: "port" },
+		flags: {
+			json: {
+				brief: "Print machine-readable JSON",
+				kind: "boolean",
+				optional: true
+			},
+			port: {
+				brief: "Running local server port",
+				kind: "parsed",
+				optional: true,
+				parse: String
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: []
+		}
+	},
+	docs: { brief: "Print the identity of a running Overmux server" }
+});
+//#endregion
 //#region src/internal/shared/routes.ts
 var viteHmrPath = "/_overmux/vite/hmr";
 //#endregion
@@ -4721,7 +5130,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 +5141,9 @@ var createCliApp = (process = globalThis.process) => buildApplication(buildRoute
 			docsRoot: resolveInstalledDocsRoot(import.meta.url),
 			output: process.stdout
 		}),
+		init: createInitCommand(process),
+		integration: integrationCommand,
+		instance: createInstanceCommand(process.stdout),
 		serve: serveCommand
 	}
 }), {