tmux-ide 2.8.0 → 2.9.0-beta.6

package/packages/daemon/src/tui/mirror/hosted.ts

@@ -6,23 +6,28 @@
  * running the app full-screen, then attaches the terminal to it. ^q under
  * hosting DETACHES the client (the app keeps running); re-invocation from any
  * terminal — including a phone over ssh — reattaches the SAME cockpit with
- * scroll positions, dialogs, and workspace context intact.
+ * scroll positions, dialogs, and workspace context intact. Ctrl-Q is bound at
+ * tmux's root input table so it puts away only the client which pressed it.
  *
  * These are the PURE pieces of that contract: the entry decision, the tmux
  * argv builders, and the shell quoting for the host pane's command line. The
  * io (spawning tmux, resolving bun vs the compiled binary) stays in the CLI;
- * the app side only reads {@link HOSTED_ENV} to flip ^q from quit to detach.
+ * the app side reads {@link HOSTED_ENV} to keep direct pane-injected Ctrl-Q
+ * from destroying the resident renderer.
  */
 
 /** The internal host session. `_`-prefixed so every fleet surface (team --json,
  *  sidebar, home) and the snapshot/restore path already filter it out. */
 export const APP_HOST_SESSION = "_tmux-ide-app";
 
-/** The env marker the launcher sets on the hosted app process. The app flips
- *  ^q from "quit" to "detach the client" when it sees `=1`; the CLI treats it
- *  as a recursion guard (a hosted app never re-hosts). */
+/** The env marker the launcher sets on the hosted app process. The app consumes
+ *  renderer-delivered Ctrl-Q when it sees `=1`; real client Ctrl-Q is handled
+ *  by tmux before reaching the pane. The CLI also uses it as a recursion guard. */
 export const HOSTED_ENV = "TMUX_IDE_HOSTED";
 
+/** Hosted put-away is a tmux client action, never a renderer action. */
+export const HOSTED_PUT_AWAY_KEY = "C-q" as const;
+
 /** Everything the entry decision reads — flags, config, and the guard. */
 export interface HostedEntryInput {
   /** `--detachable` (the primary flag). */
@@ -79,6 +84,7 @@ export function hostedEnvVars(base: {
     [HOSTED_ENV]: "1",
     TMUX_IDE_CWD: base.cwd,
     TMUX_IDE_CLI: base.cli,
+    COLORTERM: "truecolor",
   };
   if (base.path) env.PATH = base.path;
   if (base.home) env.TMUX_IDE_HOME = base.home;
@@ -98,7 +104,15 @@ export function hostedCommandLine(
   env: Record<string, string>,
 ): string {
   const assigns = Object.entries(env).map(([k, v]) => `${k}=${shellQuote(v)}`);
-  return ["exec", "env", ...assigns, shellQuote(bin), ...argv.map(shellQuote)].join(" ");
+  return [
+    "exec",
+    "env",
+    "-u",
+    "NO_COLOR",
+    ...assigns,
+    shellQuote(bin),
+    ...argv.map(shellQuote),
+  ].join(" ");
 }
 
 /** PURE — exact-match existence probe (`=` prefix: `has-session -t` would
@@ -203,3 +217,70 @@ export function hostAttachArgv(insideTmux: boolean): string[] {
     ? ["switch-client", "-t", `=${APP_HOST_SESSION}`]
     : ["attach-session", "-t", `=${APP_HOST_SESSION}`];
 }
+
+/**
+ * tmux 3.0 (the supported floor) cannot query one binding or format
+ * `list-keys`, so inspect the bounded root-table listing in-process.
+ */
+export function hostRootBindingsArgv(): string[] {
+  return ["list-keys", "-T", "root"];
+}
+
+/**
+ * Install Ctrl-Q at tmux's input boundary. A bound `detach-client` and
+ * `switch-client` execute with the key's exact client as their current client;
+ * a command launched by the shared renderer pane does not have that identity.
+ *
+ * The outer session guard preserves ordinary Ctrl-Q input everywhere else.
+ * A client which switched into the host returns to its own prior session; a
+ * plain attachment, which has no prior session, detaches only itself.
+ */
+export function hostPutAwayBindingArgv(): string[] {
+  return [
+    "bind-key",
+    "-T",
+    "root",
+    HOSTED_PUT_AWAY_KEY,
+    "if-shell",
+    "-F",
+    `#{==:#{session_name},${APP_HOST_SESSION}}`,
+    "if-shell -F '#{client_last_session}' 'switch-client -l' 'detach-client'",
+    `send-keys ${HOSTED_PUT_AWAY_KEY}`,
+  ];
+}
+
+export type HostedPutAwayBindingState = "absent" | "owned" | "conflict";
+
+const HOSTED_PUT_AWAY_LISTING_COMMAND =
+  `if-shell -F "#{==:#{session_name},${APP_HOST_SESSION}}" ` +
+  `"if-shell -F '#{client_last_session}' 'switch-client -l' 'detach-client'" ` +
+  `"send-keys ${HOSTED_PUT_AWAY_KEY}"`;
+
+function rootCtrlQBindingCommands(rootBindings: string): readonly string[] {
+  if (
+    typeof rootBindings !== "string" ||
+    rootBindings.includes("\0") ||
+    Buffer.byteLength(rootBindings, "utf8") > 1024 * 1024
+  ) {
+    return ["invalid-root-binding-list"];
+  }
+  return rootBindings
+    .split(/\r?\n/u)
+    .map(
+      (line) =>
+        line.match(/^\s*bind-key\s+-T\s+root\s+C-q\s+(?<command>.+?)\s*$/u)?.groups?.command,
+    )
+    .filter((command): command is string => command !== undefined);
+}
+
+/**
+ * Classify the existing root Ctrl-Q binding without evaluating or embedding a
+ * user-authored tmux command. Anything other than our exact canonical shape is
+ * a conflict and must remain untouched.
+ */
+export function hostedPutAwayBindingState(rootBindings: string): HostedPutAwayBindingState {
+  const matches = rootCtrlQBindingCommands(rootBindings);
+  if (matches.length === 0) return "absent";
+  if (matches.length !== 1) return "conflict";
+  return matches[0] === HOSTED_PUT_AWAY_LISTING_COMMAND ? "owned" : "conflict";
+}

package/packages/daemon/src/tui/mirror/input-lifecycle.ts

@@ -0,0 +1,248 @@
+export const OPENTUI_KEYMAP_DECISION = {
+  package: "@opentui/keymap",
+  evaluatedVersion: "0.4.3",
+  adopted: false,
+  reason:
+    "The app already has one Solid useKeyboard owner and must forward arbitrary editor/query/pane text; adding keymap here would duplicate rather than replace that root listener.",
+} as const;
+
+export type TuiInputMode = "home" | "editor" | "diff" | "missions" | "mirror";
+export type TuiMissionMode = "board" | "history" | "detail";
+export type TuiEditorFocus = "list" | "editor";
+
+export interface TuiKeyEvent {
+  name: string;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  super?: boolean;
+}
+
+export interface TuiInputContext {
+  dialogOpen: boolean;
+  menuOpen: boolean;
+  paletteOpen: boolean;
+  searchOpen: boolean;
+  mode: TuiInputMode;
+  activePanelInert: boolean;
+  missionMode: TuiMissionMode;
+  editorFocus: TuiEditorFocus;
+  editorFilterOpen: boolean;
+  diffFilterOpen: boolean;
+  homePromptOpen: boolean;
+  configuredShortcutKeys: readonly string[];
+  compositeCycleAvailable: boolean;
+}
+
+export type TuiGlobalCommand =
+  | { kind: "cycle-composite-focus" }
+  | { kind: "open-palette" }
+  | { kind: "select-hosted-view"; key: string }
+  | { kind: "go-home" }
+  | { kind: "toggle-editor" }
+  | { kind: "toggle-performance-hud" };
+
+export type TuiInputLayer =
+  | { kind: "lifecycle"; command: TuiLifecycleCommand }
+  | { kind: "kitty-super-palette" }
+  | { kind: "kitty-super-suppressed" }
+  | { kind: "dialog" }
+  | { kind: "menu" }
+  | { kind: "palette" }
+  | { kind: "search" }
+  | { kind: "global"; command: TuiGlobalCommand }
+  | { kind: "missions-detail" }
+  | { kind: "missions-board-history" }
+  | { kind: "inert" }
+  | { kind: "editor-filter" }
+  | { kind: "editor-list" }
+  | { kind: "editor-input" }
+  | { kind: "diff-filter" }
+  | { kind: "diff" }
+  | { kind: "home-prompt" }
+  | { kind: "home" }
+  | { kind: "terminal" };
+
+export type TuiLifecycleCommand =
+  | { kind: "destroy-renderer"; source: "keyboard" | "palette" | "error" }
+  | { kind: "hosted-detach"; source: "keyboard" };
+
+export function resolveInputLayer(
+  context: TuiInputContext,
+  event: TuiKeyEvent,
+  options: { hosted: boolean },
+): TuiInputLayer {
+  if (event.ctrl && event.name === "q") {
+    return { kind: "lifecycle", command: resolveQuitLifecycleCommand(options, "keyboard") };
+  }
+  if (event.super) {
+    if (
+      event.name === "k" &&
+      !event.ctrl &&
+      !context.dialogOpen &&
+      !context.menuOpen &&
+      !context.paletteOpen &&
+      !context.searchOpen
+    ) {
+      return { kind: "kitty-super-palette" };
+    }
+    return { kind: "kitty-super-suppressed" };
+  }
+  if (!event.ctrl && !event.meta && !event.shift && event.name === "f12")
+    return { kind: "global", command: { kind: "toggle-performance-hud" } };
+  if (context.dialogOpen) return { kind: "dialog" };
+  if (context.menuOpen) return { kind: "menu" };
+  if (context.paletteOpen) return { kind: "palette" };
+  if (context.searchOpen) return { kind: "search" };
+  const global = resolveGlobalCommand(context, event);
+  if (global) return { kind: "global", command: global };
+  if (context.mode === "missions") {
+    return context.missionMode === "detail"
+      ? { kind: "missions-detail" }
+      : { kind: "missions-board-history" };
+  }
+  if (context.activePanelInert) return { kind: "inert" };
+  if (event.ctrl && event.name === "e")
+    return { kind: "global", command: { kind: "toggle-editor" } };
+  if (context.mode === "editor") {
+    if (context.editorFocus === "list") {
+      return context.editorFilterOpen ? { kind: "editor-filter" } : { kind: "editor-list" };
+    }
+    return { kind: "editor-input" };
+  }
+  if (context.mode === "diff") {
+    return context.diffFilterOpen ? { kind: "diff-filter" } : { kind: "diff" };
+  }
+  if (context.mode === "home") {
+    return context.homePromptOpen ? { kind: "home-prompt" } : { kind: "home" };
+  }
+  return { kind: "terminal" };
+}
+
+export function resolveGlobalCommand(
+  context: TuiInputContext,
+  event: TuiKeyEvent,
+): TuiGlobalCommand | null {
+  if (!event.ctrl && !event.meta && !event.shift && event.name === "f12")
+    return { kind: "toggle-performance-hud" };
+  if (
+    context.compositeCycleAvailable &&
+    (event.name === "f8" || (event.ctrl && event.name === "tab"))
+  ) {
+    return { kind: "cycle-composite-focus" };
+  }
+  if (event.name === "f5" || (event.ctrl && event.name === "p")) {
+    return { kind: "open-palette" };
+  }
+  if (
+    !event.ctrl &&
+    !event.meta &&
+    !event.shift &&
+    context.configuredShortcutKeys.includes(event.name)
+  ) {
+    return { kind: "select-hosted-view", key: event.name };
+  }
+  if (event.ctrl && (event.name === "g" || event.name === "h")) {
+    return { kind: "go-home" };
+  }
+  return null;
+}
+
+export function resolveQuitLifecycleCommand(
+  options: { hosted: boolean },
+  source: "keyboard" | "palette" | "error",
+): TuiLifecycleCommand {
+  if (source === "keyboard" && options.hosted) return { kind: "hosted-detach", source };
+  return { kind: "destroy-renderer", source };
+}
+
+export type CtrlCCommand =
+  | { kind: "copy-editor-selection" }
+  | { kind: "copy-terminal-selection" }
+  | { kind: "forward-terminal-ctrl-c" }
+  | { kind: "consume" };
+
+export function resolveCtrlCCommand(context: {
+  layer: "editor" | "terminal" | "inert" | "overlay";
+  hasEditorSelection?: boolean;
+  hasTerminalSelection?: boolean;
+  mirrorAvailable?: boolean;
+}): CtrlCCommand {
+  if (context.layer === "editor") {
+    return context.hasEditorSelection ? { kind: "copy-editor-selection" } : { kind: "consume" };
+  }
+  if (context.layer === "terminal") {
+    if (!context.mirrorAvailable) return { kind: "consume" };
+    return context.hasTerminalSelection
+      ? { kind: "copy-terminal-selection" }
+      : { kind: "forward-terminal-ctrl-c" };
+  }
+  return { kind: "consume" };
+}
+
+export interface CtrlCExecutor {
+  copyEditorSelection: () => void;
+  copyTerminalSelection: () => void;
+  forwardTerminalCtrlC: () => void;
+}
+
+export function executeCtrlCCommand(command: CtrlCCommand, executor: CtrlCExecutor): void {
+  if (command.kind === "copy-editor-selection") executor.copyEditorSelection();
+  else if (command.kind === "copy-terminal-selection") executor.copyTerminalSelection();
+  else if (command.kind === "forward-terminal-ctrl-c") executor.forwardTerminalCtrlC();
+}
+
+export interface TuiCleanupResult {
+  names: string[];
+  failures: { name: string; error: unknown }[];
+}
+
+export class TuiCleanupRegistry {
+  private callbacks = new Map<string, () => void>();
+  private cleaned = false;
+
+  set(name: string, callback: () => void): void {
+    if (this.cleaned) return;
+    this.callbacks.set(name, callback);
+  }
+
+  runAll(): TuiCleanupResult {
+    if (this.cleaned) return { names: [], failures: [] };
+    this.cleaned = true;
+    const names = [...this.callbacks.keys()];
+    const failures: TuiCleanupResult["failures"] = [];
+    for (const [name, callback] of this.callbacks) {
+      try {
+        callback();
+      } catch (error) {
+        failures.push({ name, error });
+      }
+    }
+    this.callbacks.clear();
+    return { names, failures };
+  }
+}
+
+export interface TuiLifecycleExecutor {
+  run(command: TuiLifecycleCommand): void;
+}
+
+export function createTuiLifecycleExecutor(deps: {
+  destroyRenderer: () => void;
+}): TuiLifecycleExecutor {
+  let destroyRequested = false;
+
+  return {
+    run(command) {
+      if (command.kind === "destroy-renderer") {
+        if (destroyRequested) return;
+        destroyRequested = true;
+        deps.destroyRenderer();
+        return;
+      }
+      // Hosted detach belongs to tmux's root key binding, where the invoking
+      // client is still known. A command injected directly into the shared
+      // renderer pane is deliberately consumed without client mutation.
+    },
+  };
+}

package/packages/daemon/src/tui/mirror/interaction-flow.ts

@@ -0,0 +1,83 @@
+import {
+  workspaceEscapeFocusTarget,
+  workspaceInteractionPresentation,
+  type WorkspaceInteractionLayer,
+} from "@tmux-ide/core";
+import type { TuiInputLayer, TuiInputMode, TuiMissionMode } from "./input-lifecycle.ts";
+import type {
+  WorkbenchDockMode,
+  WorkbenchDockTabId,
+  WorkbenchFocusZone,
+} from "./workspace/workbench-shell.ts";
+
+export interface TuiInteractionContext {
+  dialogOpen: boolean;
+  menuOpen: boolean;
+  paletteOpen: boolean;
+  searchOpen: boolean;
+  surface: TuiInputMode;
+  focusZone: WorkbenchFocusZone;
+  dockMode: WorkbenchDockMode;
+  activeDockTab: WorkbenchDockTabId;
+  missionMode: TuiMissionMode;
+  editorFocus: "list" | "editor";
+  editorFilterOpen: boolean;
+  diffFilterOpen: boolean;
+  homePromptOpen: boolean;
+  hosted: boolean;
+}
+
+export interface TuiInteractionPresentation {
+  mode: string;
+  focus: string;
+  help: string;
+}
+
+/** Thin OpenTUI adapter over the renderer-neutral core interaction policy. */
+export function tuiInteractionPresentation(
+  context: TuiInteractionContext,
+): TuiInteractionPresentation {
+  const overlay = context.dialogOpen
+    ? "dialog"
+    : context.menuOpen
+      ? "menu"
+      : context.paletteOpen
+        ? "commands"
+        : context.searchOpen
+          ? "search"
+          : null;
+  const surface =
+    context.surface === "editor"
+      ? "files"
+      : context.surface === "diff"
+        ? "changes"
+        : context.surface === "mirror"
+          ? "terminals"
+          : context.surface;
+  return workspaceInteractionPresentation({
+    overlay,
+    surface:
+      context.focusZone === "dock-body" && context.activeDockTab === "activity"
+        ? "activity"
+        : surface,
+    focusZone: context.focusZone,
+    dockMode: context.dockMode,
+    missionMode: context.missionMode,
+    editorFocus: context.editorFocus,
+    editorFilterOpen: context.editorFilterOpen,
+    diffFilterOpen: context.diffFilterOpen,
+    homePromptOpen: context.homePromptOpen,
+    hosted: context.hosted,
+  });
+}
+
+/** OpenTUI layer names deliberately mirror the core interaction vocabulary. */
+export function tuiEscapeFocusTarget(input: {
+  focusZone: WorkbenchFocusZone;
+  layer: TuiInputLayer["kind"];
+}): WorkbenchFocusZone | null {
+  return workspaceEscapeFocusTarget({
+    focusZone: input.focusZone,
+    layer: input.layer as WorkspaceInteractionLayer,
+  });
+}

package/packages/daemon/src/tui/mirror/legacy/missions-workspace-loader.ts

@@ -0,0 +1,117 @@
+import {
+  MissionProjectionError,
+  projectMissionBoard,
+  projectMissionDetail,
+  projectMissionHistory,
+} from "../../../lib/mission-projections.ts";
+import { MissionRepository, MissionRepositoryError } from "../../../lib/mission-repository.ts";
+import type { ProjectRuntimeRepository } from "../../../lib/project-runtime-repository.ts";
+import type { MissionWorkspaceLoadState, MissionWorkspaceSnapshot } from "../missions-workspace.ts";
+
+/**
+ * Compatibility loader for the legacy filesystem-backed Missions runtime.
+ *
+ * New presentation and controller code must consume daemon resource
+ * envelopes instead. Keeping this adapter behind an explicit legacy import
+ * prevents MissionRepository and filesystem state from entering the TUI's
+ * eager presentation graph.
+ */
+export class MissionWorkspaceLoader {
+  #generation = 0;
+  #activeProjectKey: string | null = null;
+
+  begin(
+    projectKey: string | null,
+    priorSnapshot?: MissionWorkspaceSnapshot | null,
+  ): MissionWorkspaceLoadState {
+    this.#generation += 1;
+    this.#activeProjectKey = projectKey;
+    if (projectKey && priorSnapshot?.project.identityKey === projectKey) {
+      return {
+        status: "refreshing",
+        generation: this.#generation,
+        projectKey,
+        snapshot: priorSnapshot,
+      };
+    }
+    return { status: "loading", generation: this.#generation, projectKey };
+  }
+
+  cancel(): void {
+    this.#generation += 1;
+    this.#activeProjectKey = null;
+  }
+
+  accept(
+    generation: number,
+    projectKey: string,
+    snapshot: MissionWorkspaceSnapshot,
+  ): MissionWorkspaceLoadState | null {
+    if (generation !== this.#generation || projectKey !== this.#activeProjectKey) return null;
+    const status =
+      snapshot.board.counts.total === 0 && snapshot.history.length === 0 ? "empty" : "ready";
+    return { status, generation, snapshot };
+  }
+
+  reject(
+    generation: number,
+    projectKey: string | null,
+    error: unknown,
+  ): MissionWorkspaceLoadState | null {
+    if (generation !== this.#generation || projectKey !== this.#activeProjectKey) return null;
+    return { status: "error", generation, projectKey, message: missionErrorMessage(error) };
+  }
+
+  isCurrent(generation: number, projectKey: string | null): boolean {
+    return generation === this.#generation && projectKey === this.#activeProjectKey;
+  }
+}
+
+export function readMissionWorkspace(
+  repository: ProjectRuntimeRepository,
+  selectedMissionId: string | null = null,
+  now: () => Date = () => new Date(),
+): MissionWorkspaceSnapshot {
+  const missions = new MissionRepository(repository);
+  const { history, state } = missions.snapshot();
+  const board = projectMissionBoard(state, history);
+  const completed = projectMissionHistory(state, history);
+  const detail = selectedMissionId ? projectDetailOrNull(state, history, selectedMissionId) : null;
+  return {
+    board,
+    history: completed.map((entry) => detached(entry)),
+    detail: detail ? detached(detail) : null,
+    project: {
+      identityKey: repository.metadata.identityKey,
+      projectRoot: repository.metadata.projectRoot,
+    },
+    loadedAt: now().toISOString(),
+  };
+}
+
+function missionErrorMessage(error: unknown): string {
+  if (error instanceof MissionRepositoryError || error instanceof MissionProjectionError) {
+    return error.message;
+  }
+  if (error instanceof Error) return error.message;
+  return "mission data could not be loaded";
+}
+
+function projectDetailOrNull(
+  state: Parameters<typeof projectMissionDetail>[0],
+  history: Parameters<typeof projectMissionDetail>[1],
+  missionId: string,
+) {
+  try {
+    return projectMissionDetail(state, history, missionId);
+  } catch (error) {
+    if (error instanceof MissionProjectionError && error.projectionCode === "MISSION_NOT_FOUND") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+function detached<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}

package/packages/daemon/src/tui/mirror/menu-model.ts

@@ -47,6 +47,7 @@ export const MENU_ITEMS: Record<MenuRegion, MenuItem[]> = {
   // close — where there is no dialog — uses the inline confirm rearm.
   agent: [
     { id: "jump", label: "Go to agent" },
+    { id: "rename", label: "Rename agent", input: "rename to" },
     { id: "restart", label: "Restart agent" },
     { id: "stop", label: "Stop agent" },
     { id: "close", label: "Close pane", danger: true },
@@ -66,20 +67,6 @@ export const MENU_ITEMS: Record<MenuRegion, MenuItem[]> = {
     { id: "split-v", label: "Split vertical" },
     { id: "zoom", label: "Zoom toggle" },
     { id: "swap-next", label: "Swap with next" },
-    { id: "break", label: "Break to window" },
-    { id: "rotate", label: "Rotate panes" },
-    {
-      id: "layouts",
-      label: "Layouts",
-      children: [
-        { id: "layout:even-horizontal", label: "even-horizontal" },
-        { id: "layout:even-vertical", label: "even-vertical" },
-        { id: "layout:main-horizontal", label: "main-horizontal" },
-        { id: "layout:main-vertical", label: "main-vertical" },
-        { id: "layout:tiled", label: "tiled" },
-      ],
-    },
-    { id: "sync-toggle", label: "Synchronize panes", checkbox: true },
     { id: "kill", label: "Kill pane", danger: true },
   ],
   window: [