Make Cloud Bash prompts follow VM names

Sources/Surfaces/CmuxTuiSurfaceProvider+TerminalIO.swift

@@ -1,6 +1,40 @@
 import Foundation
 
 extension CmuxTuiSurfaceProvider {
+    /// Type text into a remote terminal without adding a newline.
+    func sendText(terminalID: String, text: String) async throws {
+        let connected = try await links.connected(machineID: machineID)
+        guard let link = await links.link(machineID: machineID) else { throw ProviderError.machineAsleep(machineID) }
+        _ = try await link.run(arguments: CloudTuiCommandLine.writeArguments(socketPath: connected.socketPath, terminalID: terminalID, text: text))
+    }
+
+    /// Press named keys in the remote terminal, in order.
+    func sendKeys(terminalID: String, keys: [String]) async throws {
+        let connected = try await links.connected(machineID: machineID)
+        guard let link = await links.link(machineID: machineID) else { throw ProviderError.machineAsleep(machineID) }
+        _ = try await link.run(arguments: CloudTuiCommandLine.keysArguments(socketPath: connected.socketPath, terminalID: terminalID, keys: keys))
+    }
+
+    /// Read the visible terminal grid reported by the daemon.
+    func readScreen(terminalID: String) async throws -> [String: Any] {
+        let connected = try await links.connected(machineID: machineID)
+        guard let link = await links.link(machineID: machineID) else { throw ProviderError.machineAsleep(machineID) }
+        let data = try await link.run(arguments: CloudTuiCommandLine.screenReadArguments(socketPath: connected.socketPath, terminalID: terminalID))
+        return (try JSONSerialization.jsonObject(with: data) as? [String: Any]) ?? [:]
+    }
+
+    /// Wait for the screen pattern, with time for the link to return its result.
+    func waitForScreen(terminalID: String, pattern: String, timeoutMs: Int?) async throws -> [String: Any] {
+        let connected = try await links.connected(machineID: machineID)
+        guard let link = await links.link(machineID: machineID) else { throw ProviderError.machineAsleep(machineID) }
+        let effectiveMs = Self.clampedWaitTimeoutMs(timeoutMs)
+        let data = try await link.run(
+            arguments: CloudTuiCommandLine.screenWaitArguments(socketPath: connected.socketPath, terminalID: terminalID, pattern: pattern, timeoutMs: effectiveMs),
+            timeout: .milliseconds(effectiveMs + 5_000)
+        )
+        return (try JSONSerialization.jsonObject(with: data) as? [String: Any]) ?? [:]
+    }
+
     nonisolated static let defaultWaitTimeoutMs = 30_000
     nonisolated static let maxWaitTimeoutMs = 3_600_000
 

Sources/Surfaces/CmuxTuiSurfaceProviders.swift

@@ -728,6 +728,35 @@ final class CmuxTuiSurfaceProvider: SurfaceProvider {
         )
     }
 
+    /// Close a terminal, using its tab when the process has already exited.
+    func closeTerminal(_ id: SurfaceResourceID) async throws {
+        try await closeTerminal(id, fallbackTabID: nil)
+    }
+
+    func closeTerminal(_ id: SurfaceResourceID, fallbackTabID: String?) async throws {
+        pendingRemoteCreations.removeValue(forKey: id)
+        do {
+            _ = try await runCloseCommand {
+                CloudTuiCommandLine.closeTerminalArguments(socketPath: $0, terminalID: id.key)
+            }
+        } catch {
+            guard let tabID = fallbackTabID ?? tabByTerminal[id.key], Self.isSelectorNotFound(error) else { throw error }
+            _ = try await runCloseCommand {
+                CloudTuiCommandLine.closeTabArguments(socketPath: $0, tabID: tabID)
+            }
+        }
+        closeLocalPanes(showing: [id])
+        catalog.remove(id, from: self)
+        scheduleRefresh()
+    }
+
+    private func closeLocalPanes(showing ids: [SurfaceResourceID]) {
+        let wanted = Set(ids)
+        for projection in catalog.snapshot.projections where wanted.contains(projection.resource) {
+            SurfacePaneFactory.close(panelID: projection.panelID, in: projection.workspaceID)
+        }
+    }
+
     /// cmux-tui's `selector.not_found` error body, surfaced by `link.run` as the
     /// command's output text.
     static func isSelectorNotFound(_ error: Error) -> Bool {

web/app/lib/request-origin.ts

@@ -1,4 +1,4 @@
-import { NextRequest } from "next/server";
+import { NextRequest, type NextResponse } from "next/server";
 import { directDevBackendOrigin } from "./direct-dev-backend-origin";
 
 /**
@@ -36,3 +36,22 @@ export function requestWithOrigin(
     method: request.method,
   });
 }
+
+/** Public URLs belong in redirects; local rewrites must stay inside Next.
+ * Rewriting through Tailscale Serve runs middleware again and loops when
+ * next-intl removes the default locale prefix from its own rewrite. */
+export function responseWithInternalRewrite(
+  response: NextResponse,
+  incomingRequest: NextRequest,
+  environment: Record<string, string | undefined> = process.env,
+): NextResponse {
+  const publicOrigin = directDevBackendOrigin(environment)?.origin;
+  const rewrite = response.headers.get("x-middleware-rewrite");
+  if (!publicOrigin || !rewrite) return response;
+  const target = new URL(rewrite);
+  if (target.origin !== publicOrigin) return response;
+  target.protocol = incomingRequest.nextUrl.protocol;
+  target.host = incomingRequest.nextUrl.host;
+  response.headers.set("x-middleware-rewrite", target.toString());
+  return response;
+}

web/proxy.ts

@@ -12,7 +12,7 @@ import {
   remoteTmuxDocsLocales,
 } from "./i18n/locale-availability";
 import { buildAlternateLinkHeader } from "./i18n/seo";
-import { requestOrigin, requestWithOrigin } from "./app/lib/request-origin";
+import { requestOrigin, requestWithOrigin, responseWithInternalRewrite } from "./app/lib/request-origin";
 import {
   DASHBOARD_RETURN_PATH_HEADER,
   dashboardReturnPathForRequest,
@@ -28,6 +28,10 @@ const intlMiddleware = createMiddleware(routing);
 const localeSet = new Set<string>(routing.locales);
 
 export default function middleware(incomingRequest: NextRequest) {
+  return responseWithInternalRewrite(routeRequest(incomingRequest), incomingRequest);
+}
+
+function routeRequest(incomingRequest: NextRequest) {
   const request = requestWithOrigin(incomingRequest);
   const dashboardReturnPath = dashboardReturnPathForRequest(
     request.nextUrl.pathname,

web/scripts/build-devbox-freestyle.ts

@@ -340,6 +340,8 @@ try {
   // Cache seeds cover root and the work user (uid 1000).
   await step("cmux-etc", "mkdir -p /etc/cmux /etc/skel");
   await put("cmux-bashrc", "/etc/cmux/bashrc");
+  await put("cmux-prompt.bash", "/etc/cmux/prompt.bash");
+  await step("prompt-default-name", "echo cmux > /etc/cmux/vm-name");
   await put("seed-history", "/etc/cmux/seed-history");
   await put("cmux-terminfo.sh", "/etc/profile.d/cmux-terminfo.sh");
   await put("cmux-terminfo.src", "/etc/cmux/terminfo.src");

web/scripts/devbox-image-common.ts

@@ -38,6 +38,7 @@ export const DEVBOX_TEMPLATE_FILES = [
   "cmux-bashrc",
   "cmux-devbox-boot",
   "cmux-motd",
+  "cmux-prompt.bash",
   "cmux-terminfo.sh",
   "cmux-terminfo.src",
   "codex-managed.toml",

web/services/vms/drivers/freestyle.ts

@@ -47,6 +47,7 @@ import {
 } from "../images/desktop";
 import { recordSpanError, setSpanAttributes, withVmSpan } from "../telemetry";
 import { GUEST_CMUX_SHIM, GUEST_CMUX_SHIM_PATH } from "../guestCli";
+import { guestPromptInstallCommand, type GuestPromptIdentity } from "../guestPrompt";
 import {
   approveCmuxTuiEnrollment,
   CMUX_TUI_ATTACH_BUNDLE_NOT_READY_EXIT,
@@ -965,7 +966,7 @@ export class FreestyleProvider implements VMProvider {
 
             // The in-VM shim is a separate convenience layer over the baked
             // daemon and is installed idempotently for agents and peer links.
-            await this.installGuestCli(vm, vmId);
+            await this.installGuestCli(vm, vmId, options.promptIdentity);
             await this.announcePrivateAddresses(vm, data);
           } catch (err) {
             // A VM that failed to size or configure must not survive as an
@@ -1384,16 +1385,17 @@ export class FreestyleProvider implements VMProvider {
           // an invitation unless the caller is enrolled. Exit 3 means the daemon
           // was not ready inside the settle budget; heal, then run it again.
           const fingerprint = options?.deviceFingerprint;
+          const promptSetup = options?.promptIdentity ? `${guestPromptInstallCommand(options.promptIdentity)} && ` : "";
           let bundleResult = await this.execResult(
             vm,
-            cmuxTuiAttachBundleCommand({ readyGate: freestyleDaemonSettledCommand(), deviceFingerprint: fingerprint }),
+            promptSetup + cmuxTuiAttachBundleCommand({ readyGate: freestyleDaemonSettledCommand(), deviceFingerprint: fingerprint }),
             DAEMON_SETTLE_TIMEOUT_MS + EXEC_OVERHEAD_TIMEOUT_MS + EXEC_DEFAULT_TIMEOUT_MS,
           );
           let healed = false;
           if (!bundleResult || bundleResult.exitCode === CMUX_TUI_ATTACH_BUNDLE_NOT_READY_EXIT) {
             healed = true;
             await this.ensureCmuxTuiRunning(vm, vmId);
-            bundleResult = await this.execResult(vm, cmuxTuiAttachBundleCommand({ deviceFingerprint: fingerprint }));
+            bundleResult = await this.execResult(vm, promptSetup + cmuxTuiAttachBundleCommand({ deviceFingerprint: fingerprint }));
           }
           if (!healed && bundleResult?.exitCode === 0) {
             // The healthy fast path skips the heal, so this is where a machine
@@ -1653,12 +1655,13 @@ export class FreestyleProvider implements VMProvider {
    * the adapter on older images; create/attach callers treat a failed install
    * as a failed heal.
    */
-  private async installGuestCli(vm: Vm, vmId: string): Promise<void> {
+  private async installGuestCli(vm: Vm, vmId: string, promptIdentity?: GuestPromptIdentity): Promise<void> {
     const temporaryPath = `${GUEST_CMUX_SHIM_PATH}.tmp-${randomBytes(12).toString("hex")}`;
     try {
       await vm.fs.writeTextFile(temporaryPath, GUEST_CMUX_SHIM, { mode: 0o755 });
       const result = await vm.exec({
-        command: `chmod 0755 '${temporaryPath}' && mv -f '${temporaryPath}' '${GUEST_CMUX_SHIM_PATH}'`,
+        command: `chmod 0755 '${temporaryPath}' && mv -f '${temporaryPath}' '${GUEST_CMUX_SHIM_PATH}'`
+          + (promptIdentity ? ` && ${guestPromptInstallCommand(promptIdentity)}` : ""),
         timeoutMs: 30_000,
         linuxUser: GUEST_LINUX_USER,
       });

web/services/vms/drivers/types.ts

@@ -2,6 +2,8 @@
 // per-provider implementations behind an interface. Callers hold a `VMProvider` and never reach
 // into specifics.
 
+import type { GuestPromptIdentity } from "../guestPrompt";
+
 export type ProviderId = "freestyle";
 
 const PROVIDER_IDS: readonly ProviderId[] = ["freestyle"];
@@ -70,6 +72,8 @@ export type CreateOptions = {
   image: string; // provider-specific template/snapshot identifier
   /** Human-facing machine label; providers may ignore this cosmetic field. */
   displayName?: string;
+  /** Current prompt name, written into the guest rather than a shell environment. */
+  promptIdentity?: GuestPromptIdentity;
   providerMetadata?: Record<string, unknown>;
   /**
    * Name of a persistent volume to mount as the machine's home directory. Providers that
@@ -232,6 +236,8 @@ export type CmuxRemoteEndpoint = {
 };
 
 export type CmuxRemoteAttachOptions = {
+  /** Authoritative display name and revision, refreshed before returning the terminal. */
+  promptIdentity?: GuestPromptIdentity;
   /**
    * The caller's cmux-tui device fingerprint, when it already enrolled with this
    * VM's daemon. Lets the provider skip minting an invitation.

web/services/vms/guestPrompt.ts

@@ -0,0 +1,76 @@
+import { readFileSync } from "node:fs";
+import { shellQuote } from "./drivers/cmuxTuiDaemon";
+
+export type GuestPromptIdentity = {
+  readonly machineId: string;
+  readonly name: string;
+  readonly revision: number;
+};
+
+/** A display label becomes a prompt slug; the machine's routing id stays stable. */
+export function vmPromptIdentity(row: {
+  readonly id: string;
+  readonly slug: string | null;
+  readonly displayName: string | null;
+  readonly updatedAt: Date;
+}): GuestPromptIdentity {
+  const slug = (value: string) => value.normalize("NFKD").toLowerCase()
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/[^a-z0-9]+/g, "-").slice(0, 63).replace(/^-+|-+$/g, "");
+  return {
+    machineId: row.id,
+    name: slug(row.displayName ?? "") || slug(row.slug ?? "") || "cmux",
+    revision: row.updatedAt.getTime(),
+  };
+}
+
+const bashrc = readFileSync(new URL("./images/devbox/cmux-bashrc", import.meta.url), "utf8");
+const prompt = readFileSync(new URL("./images/devbox/cmux-prompt.bash", import.meta.url), "utf8");
+
+// Runs on lifecycle operations, never during shell startup or prompt drawing.
+// A lock serializes competing attaches/renames. Atomic replacement gives every
+// shell either the old complete name or the new one. The machine id prevents a
+// fork from inheriting its source's revision. User rc files are never touched.
+const install = String.raw`
+import fcntl, json, os, pathlib, sys, tempfile
+directory = pathlib.Path(sys.argv[1])
+payload = json.loads(sys.argv[2])
+directory.mkdir(parents=True, exist_ok=True)
+def replace(name, content):
+    target = directory / name
+    if target.is_file() and not target.is_symlink() and target.read_text() == content:
+        return
+    fd, temporary = tempfile.mkstemp(prefix=".prompt-", dir=directory)
+    try:
+        with os.fdopen(fd, "w") as stream:
+            stream.write(content)
+            os.fchmod(stream.fileno(), 0o644)
+        os.replace(temporary, target)
+    finally:
+        if os.path.exists(temporary): os.unlink(temporary)
+with (directory / ".prompt-lock").open("a") as lock:
+    fcntl.flock(lock, fcntl.LOCK_EX)
+    try:
+        current = json.loads((directory / ".prompt-identity").read_text())
+    except (FileNotFoundError, ValueError):
+        current = {}
+    if not isinstance(current, dict) or not isinstance(current.get("revision", -1), int):
+        current = {}
+    incoming = payload["identity"]
+    if current.get("machineId") != incoming["machineId"] or current.get("revision", -1) <= incoming["revision"]:
+        replace("vm-name", incoming["name"] + "\n")
+        replace(".prompt-identity", json.dumps(incoming))
+    for name, content in payload["files"].items():
+        replace(name, content)
+`;
+
+export function guestPromptInstallCommand(identity: GuestPromptIdentity, directory = "/etc/cmux"): string {
+  if (!/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(identity.name) || !Number.isSafeInteger(identity.revision)) {
+    throw new Error("Invalid Cloud prompt identity");
+  }
+  const files = {
+    "prompt.bash": prompt.replaceAll("/etc/cmux", directory),
+    bashrc: bashrc.replaceAll("/etc/cmux", directory),
+  };
+  return `python3 -c ${shellQuote(install)} ${shellQuote(directory)} ${shellQuote(JSON.stringify({ identity, files }))}`;
+}

web/services/vms/images/devbox/Dockerfile

@@ -274,6 +274,8 @@ RUN curl -fsSL https://github.com/akinomyoga/ble.sh/releases/download/nightly/bl
   && rm -f /tmp/ble.tar.xz \
   && test -f /usr/local/share/blesh/ble.sh
 COPY cmux-bashrc /etc/cmux/bashrc
+COPY cmux-prompt.bash /etc/cmux/prompt.bash
+RUN echo cmux > /etc/cmux/vm-name
 COPY seed-history /etc/cmux/seed-history
 COPY cmux-terminfo.sh /etc/profile.d/cmux-terminfo.sh
 # The cmux app's terminfo overlay (Resources/terminfo-overlay as infocmp

web/services/vms/images/devbox/README.md

@@ -102,9 +102,27 @@ contract, not decoration:
   away, and the verifier proves both that the refusal is gone and that a pane
   the daemon opens really reports `cmux@cmux`.
 
-`vm-devbox-image.test.ts` pins the shared files (`cmux-bashrc`,
-`agent-config.sh`, `seed-history`, `chrome-managed-policy.json`) to their
-chatmux counterparts, so edit both copies together.
+The default Bash prompt shows `cmux@<vm-name>`. It reads `/etc/cmux/vm-name`
+with Bash's built-in `read` before each prompt. Create and attach install
+the current name. Rename updates it on a running machine. A paused or
+unreachable machine gets the saved name on its next attach. The prompt name
+uses the display label in lowercase with hyphens, or the generated slug when
+there is no usable label. Routing ids do not change.
+
+Set `PS1` after the `/etc/cmux/bashrc` source line in `~/.bashrc` to customize
+the prompt. For example, `PS1='\u@${__cmux_vm_name}:\w\$ '` keeps the live
+name with a different layout. A fixed prompt or a prompt tool also works.
+The line editor attaches at the first prompt, after these user settings load.
+Remove the source line to replace the full cmux shell setup. Lifecycle updates
+only write system defaults, never user rc files or prompt settings. The
+name reader never rewrites `PS1`, runs Git, calls the network, or starts a
+child process. The shell variable is local scratch state, not exported
+configuration. After the first upgrade, open a new shell to load this setup. That shell then reads
+later name changes at its next prompt without a restart.
+
+The Dockerfile and Freestyle recipe use these same shell files.
+`vm-devbox-image.test.ts` checks the image contract; `vm-guest-prompt.test.ts`
+checks live prompt updates and user overrides.
 
 ## Desktop layer (`desktop/`)
 

web/services/vms/images/devbox/cmux-bashrc

@@ -1,9 +1,14 @@
 # cmux Cloud devbox interactive shell setup (/etc/cmux/bashrc).
 # Sourced from /etc/bash.bashrc, /etc/skel/.bashrc, /root/.bashrc, and
 # /home/cmux/.bashrc.
-# (byte-identical body below the header; vm-devbox-image.test.ts pins it) and
-# chatmux infra/sandbox-images/devshell.bashrc.
 case $- in *i*) ;; *) return ;; esac
+# A login shell can reach this file through both system and user rc files.
+if [[ ${__cmux_bashrc_loaded:-} ]]; then
+  # Ubuntu's per-user rc can replace the system PS1 between the two sources.
+  [ -r /etc/cmux/prompt.bash ] && . /etc/cmux/prompt.bash
+  return
+fi
+__cmux_bashrc_loaded=1
 
 # PTYs from the sandbox API do not reliably inherit these.
 export LANG="${LANG:-C.UTF-8}"
@@ -45,7 +50,8 @@ if [ -d /etc/cmux/blesh-cache-seed/blesh ]; then
 fi
 
 if [ -f /usr/local/share/blesh/ble.sh ] && [ -z "${BLE_VERSION:-}" ]; then
-  source /usr/local/share/blesh/ble.sh --noattach
+  # Attach at the first prompt, after the user's .bashrc can customize PS1.
+  source /usr/local/share/blesh/ble.sh --attach=prompt
   bleopt prompt_eol_mark= exec_errexit_mark= exec_elapsed_mark= exec_exit_mark=
   # Minimal integration: token highlighting off entirely (the stock faces
   # paint colored backgrounds under mistyped commands and mid-word input,
@@ -65,18 +71,9 @@ if [ -f /usr/local/share/blesh/ble.sh ] && [ -z "${BLE_VERSION:-}" ]; then
   ble-bind -f 'M-C-h' kill-backward-cword
 fi
 
-# Palette colors, not 256-color cube indices: the pane renders in the Mac's
-# Ghostty theme, so magenta/green/yellow/cyan/red land on whatever that theme
-# says, exactly like the local zsh prompt (ESC[35m, ESC[32m, ESC[33m). A cube
-# index such as 135 is the same fixed purple under every theme. The machine
-# name stays in the prompt (\h): cloud machines are addressed by name.
-__cmux_git() {
-  local b d=""
-  b=$(git symbolic-ref --short HEAD 2>/dev/null) || b=$(git rev-parse --short HEAD 2>/dev/null) || return 0
-  git diff --quiet --ignore-submodules HEAD 2>/dev/null || d="*"
-  printf ' on \001\033[36m\002%s\001\033[31m\002%s\001\033[0m\002' "$b" "$d"
-}
-PS1='\[\e[35m\]\u@\h\[\e[0m\] in \[\e[32m\]\w\[\e[0m\]$(__cmux_git)\[\e[33m\] λ\[\e[0m\] '
+# Users can override PS1 later in ~/.bashrc. The default reads the current
+# machine name with Bash builtins and no Git scan.
+[ -r /etc/cmux/prompt.bash ] && . /etc/cmux/prompt.bash
 
 HISTSIZE=50000
 HISTFILESIZE=50000
@@ -85,5 +82,3 @@ shopt -s histappend
 alias ls='ls --color=auto'
 alias grep='grep --color=auto'
 alias g=git
-
-[ -n "${BLE_VERSION:-}" ] && ble-attach