@libtmux/workspace-cli 0.1.0-alpha.11

package/dist/tmux-wa2zn8z1.js

@@ -0,0 +1,893 @@
+import {
+  normalize,
+  openTerminal,
+  processRun
+} from "./main-c8atq2pj.js";
+import {
+  CliError,
+  OperationOutput,
+  colorEnabled,
+  emitJson,
+  expandPath,
+  mapping,
+  privatePath,
+  readDocument,
+  resolveWorkspace,
+  saveDocument,
+  scalarText,
+  styled,
+  write
+} from "./main-gh3pafqb.js";
+import {
+  __require
+} from "./main-1de529jm.js";
+
+// src/tmux.ts
+import {
+  isTmuxName,
+  LibTmuxError,
+  Server
+} from "libtmux";
+import { stat } from "node:fs/promises";
+import { setTimeout as sleep } from "node:timers/promises";
+import { basename, extname, resolve } from "node:path";
+function option(value) {
+  return typeof value === "boolean" ? value ? "on" : "off" : scalarText(value);
+}
+function isColdEndpoint(error) {
+  if (!(error instanceof LibTmuxError))
+    return false;
+  const reason = error.message.replace(/^cannot reach tmux: /u, "");
+  return reason.startsWith("no server running on ") || reason.startsWith("error connecting to ") && reason.endsWith(" (No such file or directory)");
+}
+function isTmuxUnavailable(error) {
+  return error instanceof LibTmuxError && error.message.startsWith("cannot reach tmux");
+}
+function unreachableMessage(server, error) {
+  const endpoint = server.socketPath ?? server.socketName ?? "the default tmux socket";
+  return isColdEndpoint(error) ? `No tmux server is running on ${endpoint}` : "The tmux executable could not be run for this command";
+}
+function currentEndpoint(context) {
+  if (!context.env.TMUX)
+    return;
+  const match = /^(.*),([0-9]+),[0-9]+$/s.exec(context.env.TMUX);
+  if (!match?.[1])
+    throw new CliError("usage", "TMUX must name the current server as socket,pid,session", 2);
+  return { socketPath: match[1], pid: match[2] };
+}
+function connection(values, context) {
+  let path = values.socket_path ? expandPath(scalarText(values.socket_path), context) : undefined;
+  if (!path && !values.socket_name)
+    path = currentEndpoint(context)?.socketPath;
+  const options = {
+    environment: { ...context.env, TMUX: undefined, TMUX_PANE: undefined },
+    ...path ? { socketPath: path } : {},
+    ...values.socket_name && !values.socket_path ? { socketName: scalarText(values.socket_name) } : {},
+    ...values.tmux_config_file ? { configFile: scalarText(values.tmux_config_file) } : {},
+    ...values.colors ? { colors: values.colors } : {},
+    ...context.env.TMUX_BIN ? { tmuxBin: context.env.TMUX_BIN } : {}
+  };
+  return new Server(options);
+}
+function terminalArguments(server) {
+  return [
+    server.tmuxBin,
+    ...server.socketPath ? ["-S", server.socketPath] : server.socketName ? ["-L", server.socketName] : []
+  ];
+}
+function targetMismatch() {
+  return new CliError("usage", "This operation must target the current pane's tmux server", 2);
+}
+async function verifyCurrentServer(server, context, endpoint) {
+  const acquisition = context.signal ? { signal: context.signal } : {};
+  const [currentResult, selectedResult] = await Promise.allSettled([
+    connection({}, context).daemonIdentity(acquisition),
+    server.snapshot(acquisition)
+  ]);
+  if (currentResult.status === "rejected") {
+    if (isTmuxUnavailable(currentResult.reason))
+      throw targetMismatch();
+    throw currentResult.reason;
+  }
+  if (selectedResult.status === "rejected") {
+    if (isTmuxUnavailable(selectedResult.reason))
+      throw targetMismatch();
+    throw selectedResult.reason;
+  }
+  const current = currentResult.value;
+  const selected = selectedResult.value;
+  if (current.pid !== endpoint.pid || current.pid !== selected.daemonIdentity.pid || current.startTime !== selected.daemonIdentity.startTime)
+    throw targetMismatch();
+  return selected;
+}
+async function currentSession(server, context) {
+  const endpoint = currentEndpoint(context);
+  if (!endpoint || !context.env.TMUX_PANE)
+    throw new CliError("usage", "This operation requires TMUX and TMUX_PANE from a current pane", 2);
+  const selected = await verifyCurrentServer(server, context, endpoint);
+  let pane;
+  try {
+    pane = selected.panes.oneOrUndefined({ id: context.env.TMUX_PANE });
+  } catch {
+    pane = undefined;
+  }
+  if (!pane?.session || !pane.format.pane_tty)
+    throw new CliError("usage", `TMUX_PANE does not name a pane with a terminal on this server: ${context.env.TMUX_PANE}`, 2);
+  return { session: pane.session, daemon: selected.daemonIdentity };
+}
+async function attachmentClient(server, context) {
+  const endpoint = currentEndpoint(context);
+  if (!endpoint) {
+    try {
+      const terminal = await openTerminal(context);
+      await terminal.close();
+    } catch (error) {
+      if (context.signal?.aborted)
+        throw error;
+      throw new CliError("usage", "Attached load needs a controlling terminal; pass -d", 2);
+    }
+    return { mode: "attach" };
+  }
+  if (!context.env.TMUX_PANE) {
+    await verifyCurrentServer(server, context, endpoint);
+    return { mode: "switch" };
+  }
+  const { session } = await currentSession(server, context);
+  const query = await processRun([...terminalArguments(server), "display-message", "-p", "#{client_name}"], {
+    cwd: context.cwd,
+    env: context.env,
+    terminal: "input",
+    ...context.signal ? { signal: context.signal } : {}
+  });
+  const name = query.stdout.trim();
+  const clients = (await server.snapshot(context.signal ? { signal: context.signal } : {})).clients;
+  if (query.code !== 0 || !clients.toArray().some((client) => client.name === name && client.session?.id === session.id))
+    throw new CliError("usage", "The current pane has no attached client; pass -d", 2);
+  return { mode: "switch", client: name };
+}
+async function options(target, value, signal) {
+  if (value === undefined)
+    return;
+  for (const [name, data] of Object.entries(mapping(value, "options")))
+    await target.setOption(name, option(data), signal ? { signal } : undefined);
+}
+function envInteger(context, name) {
+  const raw = context.env[name];
+  if (raw === undefined || raw.trim() === "")
+    return;
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || value < 1 || value > 65535)
+    throw new CliError("usage", `${name} must be an integer from 1 to 65535`, 2);
+  return value;
+}
+function sessionDimensions(context) {
+  let width = envInteger(context, "TMUXP_DEFAULT_COLUMNS") ?? envInteger(context, "COLUMNS") ?? 80;
+  let height = envInteger(context, "TMUXP_DEFAULT_ROWS") ?? envInteger(context, "ROWS") ?? 24;
+  const detect = context.env.TMUXP_DETECT_TERMINAL_SIZE;
+  if (detect !== undefined && detect !== "1")
+    return {};
+  const stream = context.stdout;
+  if (stream.isTTY && stream.columns && stream.rows) {
+    width = stream.columns;
+    height = stream.rows;
+  }
+  width = envInteger(context, "COLUMNS") ?? width;
+  height = envInteger(context, "LINES") ?? height;
+  return { width, height };
+}
+async function send(pane, spec, context) {
+  let enter = spec.data.enter ?? true;
+  let before = spec.data.sleep_before ?? null;
+  let after = spec.data.sleep_after ?? null;
+  for (const command of spec.commands) {
+    context.signal?.throwIfAborted();
+    if (command.enter !== undefined)
+      enter = command.enter;
+    if (command.sleep_before !== undefined)
+      before = command.sleep_before;
+    if (command.sleep_after !== undefined)
+      after = command.sleep_after;
+    if (before)
+      await sleep(Number(before) * 1000, undefined, { signal: context.signal });
+    await pane.sendKeys((spec.suppress ? " " : "") + command.cmd, {
+      enter: Boolean(enter),
+      literal: true,
+      ...context.signal ? { signal: context.signal } : {}
+    });
+    if (after)
+      await sleep(Number(after) * 1000, undefined, { signal: context.signal });
+  }
+}
+async function ready(pane, context) {
+  const deadline = performance.now() + 2000;
+  while (performance.now() < deadline) {
+    const [x = "0", y = "0"] = (await pane.displayMessage("#{cursor_x};#{cursor_y}"))[0]?.split(";") ?? [];
+    if (Number(x) !== 0 || Number(y) !== 0)
+      return true;
+    await sleep(50, undefined, { signal: context.signal });
+  }
+  return false;
+}
+function freeIndex(occupied, first) {
+  let index = first;
+  while (occupied.has(index)) {
+    if (index === 2147483647)
+      throw new CliError("invalid_workspace", `No free window index at or above ${first}`);
+    index++;
+  }
+  return index;
+}
+async function removePlaceholder(session, placeholder, result) {
+  const renumber = (await session.showResolvedOptions()).get("renumber-windows") === "on";
+  const previous = renumber ? (await session.showOptions()).get("renumber-windows") : undefined;
+  let failure;
+  try {
+    if (renumber)
+      await session.setOption("renumber-windows", "off");
+    await placeholder.kill();
+    const dropped = result.created_windows.indexOf(placeholder.id);
+    if (dropped >= 0)
+      result.created_window_names?.splice(dropped, 1);
+    result.created_windows = result.created_windows.filter((id) => id !== placeholder.id);
+    const removed = new Set(placeholder.panes.toArray().map((pane) => pane.id));
+    result.created_panes = result.created_panes.filter((id) => !removed.has(id));
+  } catch (error) {
+    failure = error;
+  } finally {
+    if (renumber) {
+      try {
+        if (previous === undefined)
+          await session.unsetOption("renumber-windows");
+        else
+          await session.setOption("renumber-windows", previous);
+      } catch (error) {
+        result.renumber_restore_error = error instanceof Error ? error.message : String(error);
+        failure ??= error;
+      }
+    }
+  }
+  if (failure)
+    throw failure;
+}
+async function unusableDirectories(spec) {
+  const declared = new Set;
+  if (spec.directory !== undefined)
+    declared.add(spec.directory);
+  for (const window of spec.windows)
+    for (const pane of window.panes)
+      if (pane.directory !== undefined)
+        declared.add(pane.directory);
+  const unusable = [];
+  for (const path of declared) {
+    const details = await stat(path).catch(() => {
+      return;
+    });
+    if (!details?.isDirectory())
+      unusable.push(path);
+  }
+  return unusable;
+}
+function missingWindows(spec, session) {
+  const available = new Map;
+  let spare = 0;
+  for (const window of session.windows.toArray()) {
+    if (window.name === null)
+      spare++;
+    else
+      available.set(window.name, (available.get(window.name) ?? 0) + 1);
+  }
+  const missing = [];
+  const unnamed = [];
+  for (const [ordinal, window] of spec.windows.entries()) {
+    if (window.name === undefined) {
+      unnamed.push(`#${String(ordinal + 1)}`);
+      continue;
+    }
+    const held = available.get(window.name) ?? 0;
+    if (held > 0)
+      available.set(window.name, held - 1);
+    else
+      missing.push(window.name);
+  }
+  spare += [...available.values()].reduce((total, count) => total + count, 0);
+  return [...missing, ...unnamed.slice(spare)];
+}
+function markRemoved(result) {
+  result.session_removed = true;
+  result.completed_stages.push("session-removed");
+  result.created_windows = [];
+  result.created_panes = [];
+  delete result.created_window_names;
+}
+async function discardSession(server, result) {
+  if (!result.session_id || result.session_removed)
+    return;
+  const id = result.session_id;
+  try {
+    const session = (await server.snapshot({ signal: AbortSignal.timeout(5000) })).sessions.oneOrUndefined({ id });
+    if (session)
+      await session.kill();
+    markRemoved(result);
+  } catch (error) {
+    result.session_removal_error = error instanceof Error ? error.message : String(error);
+  }
+}
+async function create(server, spec, context, output, result, existing, futureIndexes = new Set) {
+  const inputIndex = result.input_index;
+  const acquisition = context.signal ? { signal: context.signal } : {};
+  context.signal?.throwIfAborted();
+  result.stage = existing ? "append" : "creating-session";
+  const { width, height } = sessionDimensions(context);
+  const session = existing ?? await server.newSession({
+    name: spec.name,
+    ...spec.directory ? { startDirectory: spec.directory } : {},
+    ...width !== undefined ? { width } : {},
+    ...height !== undefined ? { height } : {},
+    ...context.signal ? { signal: context.signal } : {}
+  });
+  result.session_id = session.id;
+  result.session_name = session.name ?? spec.name;
+  if (!existing) {
+    const bootstrap = session.windows.at(0);
+    result.created_windows.push(bootstrap.id);
+    (result.created_window_names ??= []).push(bootstrap.name ?? String(bootstrap.index));
+    result.created_panes.push(...bootstrap.panes.toArray().map((pane) => pane.id));
+  }
+  result.completed_stages.push(existing ? "session-resolved" : "session-created");
+  if (!existing)
+    await output.event("session-created", {
+      input_index: inputIndex,
+      session_id: session.id,
+      session_name: session.name
+    });
+  if (spec.bootstrap) {
+    result.stage = "before-script";
+    try {
+      await output.event("script-started", { input_index: inputIndex });
+      let child;
+      try {
+        child = await processRun(spec.bootstrap, {
+          cwd: spec.directory ?? context.cwd,
+          env: context.env,
+          ...context.signal ? { signal: context.signal } : {},
+          output: async (stream, text) => {
+            const handled = await output.event("script-output", {
+              input_index: inputIndex,
+              stream,
+              text
+            });
+            if (output.mode === "human" && !handled)
+              await write(stream === "stdout" ? context.stdout : context.stderr, text, context.signal);
+          }
+        });
+      } catch (error) {
+        if (error instanceof CliError)
+          throw error;
+        throw new CliError("script_failed", `before_script could not run: ${spec.bootstrap[0]}`);
+      }
+      await output.event("script-completed", {
+        input_index: inputIndex,
+        child_status: child.code,
+        truncated: child.truncated.stdout || child.truncated.stderr
+      });
+      result.script_output = child;
+      if (child.code !== 0) {
+        const detail = child.stderr.trim();
+        throw new CliError("script_failed", `before_script exited with status ${child.code}${detail ? ": " + detail : ""}`);
+      }
+      result.completed_stages.push("before-script");
+    } catch (error) {
+      if (!existing && !context.signal?.aborted) {
+        await session.kill();
+        markRemoved(result);
+      }
+      throw error;
+    }
+  }
+  result.stage = "session-options";
+  const declared = spec.data.options === undefined ? {} : mapping(spec.data.options, "options");
+  const sessionScoped = {};
+  const windowScoped = {};
+  if (Object.keys(declared).length > 0) {
+    const windowOptions = await server.showGlobalOptions("window", acquisition);
+    for (const [name, value] of Object.entries(declared))
+      if (windowOptions.has(name))
+        windowScoped[name] = value;
+      else
+        sessionScoped[name] = value;
+  }
+  await options(session, sessionScoped, context.signal);
+  for (const [name, value] of Object.entries(spec.data.global_options ? mapping(spec.data.global_options) : {}))
+    await server.setGlobalOption("session", name, option(value), context.signal ? { signal: context.signal } : undefined);
+  for (const [name, value] of Object.entries(spec.environment))
+    await session.setEnvironment(name, value, context.signal ? { signal: context.signal } : undefined);
+  const wait = spec.readiness !== "never" && spec.windows.some((window) => window.panes.some((pane) => !pane.shell && pane.commands.length > 0));
+  result.completed_stages.push("session-options");
+  result.stage = "window-allocation";
+  const current = (await server.snapshot(acquisition)).sessions.one({ id: session.id });
+  const placeholder = existing ? undefined : current.windows.toArray().find((window) => window.id === session.windows.at(0)?.id);
+  const occupied = new Set(current.windows.toArray().filter((window) => window.id !== placeholder?.id).map((window) => Number(window.index)));
+  const reserved = new Set([...occupied, ...futureIndexes]);
+  for (const window of spec.windows) {
+    if (window.index === undefined)
+      continue;
+    if (occupied.has(window.index))
+      throw new CliError("invalid_workspace", `Window index ${window.index} already exists`);
+    reserved.add(window.index);
+  }
+  let next = spec.windows.some((window) => window.index === undefined) ? Number((await session.showResolvedOptions(acquisition)).get("base-index") ?? "0") : 0;
+  const indexes = spec.windows.map((window) => {
+    if (window.index !== undefined)
+      return window.index;
+    next = freeIndex(reserved, next);
+    reserved.add(next);
+    return next;
+  });
+  if (placeholder) {
+    const spare = freeIndex(reserved, 0);
+    if (Number(placeholder.index) !== spare)
+      await placeholder.move({ index: spare });
+  }
+  let focusWindow;
+  for (const [windowIndex, desired] of spec.windows.entries()) {
+    context.signal?.throwIfAborted();
+    const first = desired.panes[0];
+    result.stage = "creating-window";
+    const window = await session.newWindow({
+      index: indexes[windowIndex],
+      ...desired.name ? { name: desired.name } : {},
+      ...first.directory ? { startDirectory: first.directory } : {},
+      ...first.shell ? { shellCommand: first.shell } : {},
+      environment: first.environment,
+      ...context.signal ? { signal: context.signal } : {}
+    });
+    result.created_windows.push(window.id);
+    (result.created_window_names ??= []).push(window.name ?? String(indexes[windowIndex]));
+    result.created_panes.push(window.panes.at(0).id);
+    if (windowIndex === 0 && placeholder) {
+      result.stage = "bootstrap-removal";
+      await removePlaceholder(session, placeholder, result);
+    }
+    result.stage = "window-options";
+    await options(window, windowScoped, context.signal);
+    await options(window, desired.data.options, context.signal);
+    await output.event("window-created", {
+      input_index: inputIndex,
+      session_id: session.id,
+      window_id: window.id,
+      window_name: window.name,
+      window_index: windowIndex + 1,
+      pane_total: desired.panes.length
+    });
+    let previous = window.panes.at(0);
+    let focusPane;
+    const panes = [previous];
+    for (const [paneIndex, paneSpec] of desired.panes.entries()) {
+      if (paneIndex === 0)
+        continue;
+      context.signal?.throwIfAborted();
+      result.stage = "creating-pane";
+      const pane = await previous.split({
+        ...paneSpec.directory ? { startDirectory: paneSpec.directory } : {},
+        ...paneSpec.shell ? { shellCommand: paneSpec.shell } : {},
+        environment: paneSpec.environment,
+        ...context.signal ? { signal: context.signal } : {}
+      });
+      result.created_panes.push(pane.id);
+      previous = pane;
+      panes.push(pane);
+      await window.selectLayout("tiled");
+    }
+    if (desired.data.layout)
+      await window.selectLayout(scalarText(desired.data.layout));
+    for (const [paneIndex, paneSpec] of desired.panes.entries()) {
+      context.signal?.throwIfAborted();
+      const pane = panes[paneIndex];
+      await output.event("pane-created", {
+        input_index: inputIndex,
+        session_id: session.id,
+        pane_id: pane.id,
+        window_id: window.id,
+        pane_index: paneIndex + 1
+      });
+      if (paneSpec.commands.length > 0 && !paneSpec.shell && wait && !await ready(pane, context))
+        await output.event("warning", {
+          input_index: inputIndex,
+          pane_id: pane.id,
+          message: "Pane readiness timed out; sending commands"
+        });
+      result.stage = "pane-commands";
+      await send(pane, paneSpec, context);
+      await output.event("pane-completed", {
+        input_index: inputIndex,
+        session_id: session.id,
+        pane_id: pane.id,
+        window_id: window.id,
+        pane_index: paneIndex + 1
+      });
+      if (paneSpec.data.focus)
+        focusPane = pane;
+    }
+    await (focusPane ?? panes.at(-1)).select();
+    result.stage = "window-options-after";
+    await options(window, desired.data.options_after, context.signal);
+    await output.event("window-completed", {
+      input_index: inputIndex,
+      session_id: session.id,
+      window_id: window.id,
+      window_index: windowIndex + 1
+    });
+    if (desired.data.focus || !existing && !focusWindow)
+      focusWindow = window;
+  }
+  if (focusWindow)
+    await focusWindow.select();
+  result.completed_stages.push("windows-created");
+  return (await server.snapshot(acquisition)).sessions.one({ id: session.id });
+}
+async function promptChoice(context, message, choices) {
+  await write(context.stdout, message, context.signal);
+  const { createInterface } = await import("node:readline");
+  const rl = createInterface({ input: context.stdin, terminal: false });
+  try {
+    for await (const line of rl) {
+      const answer = line.trim().toLowerCase().slice(0, 1);
+      return choices.includes(answer) ? answer : choices[0];
+    }
+    return choices[0];
+  } finally {
+    rl.close();
+  }
+}
+async function load(request, context) {
+  if (request.values.colors === 88)
+    throw new CliError("usage", "tmux 3.2a+ rejects the legacy 88-color flag (-8); remove it or use -2 for 256 colors", 2);
+  if (request.mode !== "human" && !request.values.detached && !request.values.append)
+    throw new CliError("usage", "Machine load requires -d or an explicit append operation", 2);
+  let appendRequested = Boolean(request.values.append) && !request.values.detached;
+  sessionDimensions(context);
+  const progress = request.mode === "human" && context.stderr.isTTY ? (await import("./progress-n08zapg2.js")).LoadProgress.create(request, context) : undefined;
+  const inputs = [];
+  let bridge;
+  const files = request.values.workspace_files;
+  for (const [index, input] of files.entries()) {
+    try {
+      const path = await resolveWorkspace(input, context);
+      const document = await readDocument(path);
+      const override = index === files.length - 1 && request.values.new_session_name ? scalarText(request.values.new_session_name) : undefined;
+      if (["plugins", "workspace_builder", "workspace_builder_paths"].some((key) => Object.hasOwn(document, key)))
+        bridge ??= await import("./extensions-8v6mfszj.js");
+      const extension = await bridge?.extensionPlan(document, path, context, appendRequested, override);
+      inputs.push(extension ? { path, kind: "extension", spec: extension } : { path, kind: "native", spec: normalize(document, path, context, override) });
+    } catch (error) {
+      if (error instanceof CliError)
+        throw error;
+      throw new CliError("invalid_workspace", error instanceof Error ? error.message : String(error));
+    }
+  }
+  const python = inputs.some((input) => input.kind === "extension") ? await bridge.extensionRuntime(context) : undefined;
+  const server = connection(request.values, context);
+  try {
+    await server.validateLayouts(inputs.flatMap((input) => input.kind === "native" ? input.spec.windows.flatMap((window) => window.data.layout ? [{ layout: scalarText(window.data.layout), panes: window.panes.length }] : []) : []), context.signal ? { signal: context.signal } : {});
+  } catch (error) {
+    if (!(error instanceof TypeError))
+      throw error;
+    throw new CliError("invalid_workspace", error.message);
+  }
+  let attached = request.mode === "human" && !request.values.detached && !appendRequested;
+  let client = attached ? await attachmentClient(server, context) : undefined;
+  const interactive = attached && !request.values.answer_yes && Boolean(context.stdin.isTTY);
+  let declinedReuse = false;
+  if (attached) {
+    const lastName = inputs.at(-1).spec.name;
+    let existingLast = false;
+    try {
+      existingLast = (await server.snapshot(context.signal ? { signal: context.signal } : {})).sessions.oneOrUndefined({ name: lastName }) !== undefined;
+    } catch (error) {
+      if (!isColdEndpoint(error))
+        throw error;
+    }
+    if (existingLast) {
+      const answer = interactive ? await promptChoice(context, `${lastName} is already running. Attach? [Y/n] `, ["y", "n"]) : "y";
+      if (answer === "n") {
+        attached = false;
+        client = undefined;
+        declinedReuse = true;
+      }
+    } else if (client?.mode === "switch") {
+      const answer = interactive ? await promptChoice(context, "Already inside tmux: switch (y), load detached (n), or append (a)? [y/n/a] ", ["y", "n", "a"]) : "y";
+      if (answer === "n") {
+        attached = false;
+        client = undefined;
+      } else if (answer === "a") {
+        attached = false;
+        client = undefined;
+        appendRequested = true;
+      }
+    }
+  }
+  let append;
+  let borrowed;
+  const futureIndexes = new Set;
+  if (appendRequested) {
+    borrowed = await currentSession(server, context);
+    append = borrowed.session;
+    const reserved = new Set(append.windows.toArray().map((window) => Number(window.index)));
+    for (const input of inputs) {
+      if (input.kind !== "native")
+        continue;
+      for (const window of input.spec.windows)
+        if (window.index !== undefined) {
+          if (reserved.has(window.index))
+            throw new CliError("invalid_workspace", `Append cannot replace existing window index ${window.index}`);
+          reserved.add(window.index);
+          futureIndexes.add(window.index);
+        }
+    }
+  }
+  const output = new OperationOutput("load", request.mode, context.stdout, context.signal, async (event, data) => {
+    const level = event === "failed" ? "error" : event === "warning" ? "warning" : ["started", "completed", "script-output", "workspace-completed"].includes(event) ? "info" : "debug";
+    const echo = event === "failed" ? false : request.mode !== "human" || event !== "script-output";
+    if (echo && context.diagnostics?.accepts(level))
+      await progress?.clear();
+    await context.diagnostics?.record(level, event, data, echo);
+    return progress?.event(event, data);
+  });
+  const results = [];
+  await output.event("started", { inputs: inputs.length });
+  try {
+    for (const [index, input] of inputs.entries()) {
+      await output.event("workspace-started", {
+        input_index: index,
+        input: privatePath(input.path, context),
+        session_name: input.spec.name,
+        ...input.kind === "native" ? {
+          window_total: input.spec.windows.length,
+          session_pane_total: input.spec.windows.reduce((total, window) => total + window.panes.length, 0)
+        } : {}
+      });
+      if (input.kind === "native") {
+        for (const message of input.spec.warnings)
+          await output.event("warning", { input_index: index, message });
+        for (const path of await unusableDirectories(input.spec))
+          await output.event("warning", {
+            input_index: index,
+            message: `start_directory is not a directory, tmux will fall back to $HOME: ${path}`
+          });
+      }
+      const result = {
+        input_index: index,
+        input: privatePath(input.path, context),
+        session_name: input.spec.name,
+        reused: false,
+        appended: Boolean(append),
+        stage: "session-lookup",
+        completed_stages: [],
+        created_windows: [],
+        created_panes: []
+      };
+      results.push(result);
+      if (input.kind === "native") {
+        for (const window of input.spec.windows)
+          if (window.index !== undefined)
+            futureIndexes.delete(window.index);
+      }
+      let session;
+      if (input.kind === "extension") {
+        session = await bridge.buildExtension(python, input.spec, input.path, server, context, output, result, borrowed);
+      } else {
+        let existing;
+        if (!append) {
+          try {
+            existing = (await server.snapshot(context.signal ? { signal: context.signal } : {})).sessions.oneOrUndefined({ name: input.spec.name });
+          } catch (error) {
+            if (!isColdEndpoint(error))
+              throw error;
+          }
+        }
+        result.reused = existing !== undefined;
+        if (existing) {
+          session = existing;
+          const skipCompare = declinedReuse && index === inputs.length - 1;
+          const missing = skipCompare ? [] : missingWindows(input.spec, existing);
+          if (missing.length > 0) {
+            result.session_id = existing.id;
+            result.session_name = existing.name ?? input.spec.name;
+            result.missing_windows = missing;
+            throw new CliError("session_mismatch", `Session ${input.spec.name} is already running and does not hold ${missing.join(", ")}; it was left as it is`);
+          }
+        } else {
+          try {
+            session = await create(server, input.spec, context, output, result, append, futureIndexes);
+          } catch (error) {
+            if (!append && !context.signal?.aborted)
+              await discardSession(server, result);
+            throw error;
+          }
+        }
+      }
+      result.session_id = session.id;
+      result.session_name = session.name ?? input.spec.name;
+      result.stage = "completed";
+      await output.event("workspace-completed", result);
+      if (request.mode === "human") {
+        const color = colorEnabled(request.mode, request.values.color, context.env, Boolean(context.stdout.isTTY));
+        await write(context.stdout, `${styled("success", result.reused ? "Reused" : append ? "Appended" : "Loaded", color)} ${styled("subject", session.name, color)}
+`, context.signal);
+      }
+    }
+    const last = results.at(-1);
+    if (attached && last?.session_id) {
+      last.stage = client?.mode === "switch" ? "switching-client" : "attaching";
+      const args = terminalArguments(server);
+      if (request.values.colors === 256)
+        args.push("-2");
+      args.push(...client?.mode === "switch" ? client.client ? ["switch-client", "-c", client.client] : ["switch-client"] : ["attach-session"], "-t", last.session_id);
+      const child = await processRun(args, {
+        cwd: context.cwd,
+        env: context.env,
+        terminal: client?.mode === "switch" ? client.client ? "input" : false : true,
+        ...context.signal ? { signal: context.signal } : {}
+      });
+      if (child.code !== 0)
+        throw new CliError("tmux_failed", `tmux attachment failed${child.stderr.trim() ? ": " + child.stderr.trim() : ""}`, child.code);
+      last.stage = "completed";
+    }
+    await output.result({ status: "ok", results, errors: [] });
+    return 0;
+  } catch (error) {
+    if (output.isFinished)
+      throw error;
+    const interrupted = context.signal?.aborted;
+    const changed = results.some((result) => result.effects_unknown || result.stage === "completed" || result.session_id && !result.session_removed && !result.missing_windows);
+    const unreachable = !(error instanceof CliError) && isTmuxUnavailable(error);
+    const code = interrupted ? "interrupted" : error instanceof CliError ? error.code : unreachable ? "tmux_unavailable" : "tmux_failed";
+    const kept = results.flatMap((result) => result.session_id && !result.session_removed ? result.created_window_names ?? [] : []);
+    const message = (unreachable ? unreachableMessage(server, error) : error instanceof Error ? error.message : String(error)) + (kept.length > 0 ? `. Windows kept: ${kept.join(", ")}` : "");
+    await output.result({
+      status: changed ? "partial" : "error",
+      results,
+      errors: [
+        {
+          code,
+          message,
+          input_index: results.at(-1)?.input_index ?? 0,
+          failed_stage: results.at(-1)?.stage ?? "started"
+        }
+      ]
+    });
+    if (request.mode === "human") {
+      for (const result of results)
+        if (result.session_id && !result.session_removed)
+          await write(context.stderr, `Session ${styled("subject", result.session_name, false)} remains available (${result.stage})${result.created_window_names?.length ? `; windows kept: ${result.created_window_names.join(", ")}` : ""}.
+`, context.signal);
+      throw error;
+    }
+    await write(context.stderr, JSON.stringify({ schema_version: 1, code, message }) + `
+`, context.signal).catch(() => {});
+    return interrupted ? 130 : 1;
+  } finally {
+    await progress?.clear(AbortSignal.timeout(100)).catch(() => {});
+  }
+}
+function addressable(name) {
+  return isTmuxName(name);
+}
+var requireAddressableName = (kind, name) => {
+  if (name !== null && !addressable(name))
+    throw new CliError("invalid_workspace", `The ${kind} named ${name} cannot be captured: tmux reads "." and ":" as target separators, so a workspace could not name it again`);
+};
+async function freezeSession(server, request, context) {
+  const name = request.values.session_name;
+  const explicit = name !== null && name !== undefined;
+  if (!explicit && context.env.TMUX)
+    return (await currentSession(server, context)).session;
+  if (explicit)
+    requireAddressableName("session", scalarText(name));
+  const acquisition = context.signal ? { signal: context.signal } : {};
+  let sessions = [];
+  try {
+    sessions = (await server.snapshot(acquisition)).sessions.toArray();
+  } catch (error) {
+    if (!isColdEndpoint(error))
+      throw error;
+  }
+  if (explicit) {
+    const target = scalarText(name);
+    const session = sessions.find((item) => item.name === target || item.id === target);
+    if (!session)
+      throw new CliError("session_not_found", `Session not found: ${target}`);
+    return session;
+  }
+  if (sessions.length === 1)
+    return sessions[0];
+  if (!sessions.length)
+    throw new CliError("session_not_found", "No live sessions to capture");
+  throw new CliError("usage", "Several sessions are available; specify a session name or ID to freeze", 2);
+}
+async function freeze(request, context) {
+  const server = connection(request.values, context);
+  try {
+    return await capture(server, request, context);
+  } catch (error) {
+    if (error instanceof CliError || context.signal?.aborted)
+      throw error;
+    if (isTmuxUnavailable(error))
+      throw new CliError("tmux_unavailable", unreachableMessage(server, error));
+    throw new CliError("tmux_failed", error instanceof Error ? error.message : String(error));
+  }
+}
+async function capture(server, request, context) {
+  const session = await freezeSession(server, request, context);
+  const acquisition = context.signal ? { signal: context.signal } : {};
+  requireAddressableName("session", session.name);
+  const ordinaryShells = new Set([
+    "sh",
+    "bash",
+    "zsh",
+    "dash",
+    "ash",
+    "ksh",
+    "mksh",
+    "fish",
+    "csh",
+    "tcsh"
+  ]);
+  const defaultShell = basename((await session.showResolvedOptions(acquisition)).get("default-shell") ?? "");
+  const isDefaultShell = (command) => command === defaultShell || ordinaryShells.has(command);
+  const windows = [];
+  for (const window of session.windows.toArray()) {
+    requireAddressableName("window", window.name);
+    const panes = window.panes.toArray().map((pane) => ({
+      ...pane.currentCommand !== null && !isDefaultShell(pane.currentCommand) ? { shell_command: [pane.currentCommand] } : {},
+      start_directory: pane.currentPath ?? context.cwd,
+      ...pane.active === true ? { focus: true } : {}
+    }));
+    const optionsAfter = Object.fromEntries(await window.showOptions(acquisition));
+    windows.push({
+      window_name: window.name,
+      window_index: Number(window.index),
+      layout: window.layout,
+      options_after: optionsAfter,
+      panes,
+      ...window.active === true ? { focus: true } : {}
+    });
+  }
+  const sessionOptions = Object.fromEntries(await session.showOptions(acquisition));
+  delete sessionOptions["default-size"];
+  const document = {
+    session_name: session.name,
+    windows,
+    options: sessionOptions
+  };
+  const destination = request.values.save_to ? resolve(context.cwd, expandPath(scalarText(request.values.save_to), context)) : undefined;
+  const format = scalarText(request.values.workspace_format ?? (destination && extname(destination).toLowerCase() === ".json" ? "json" : "yaml"));
+  if (!destination && request.mode === "human")
+    throw new CliError("usage", "Specify --save-to or choose --json/--ndjson capture output", 2);
+  if (destination)
+    await saveDocument(document, destination, format, Boolean(request.values.force), context.signal);
+  if (request.mode === "json")
+    await emitJson(context.stdout, destination ? {
+      schema_version: 1,
+      command: "freeze",
+      status: "ok",
+      destination: privatePath(destination, context),
+      format
+    } : document, true, context.signal);
+  else if (request.mode === "ndjson")
+    await emitJson(context.stdout, {
+      schema_version: 1,
+      command: "freeze",
+      status: "ok",
+      ...destination ? { destination: privatePath(destination, context), format } : { workspace: document }
+    }, false, context.signal);
+  else if (!request.values.quiet)
+    await write(context.stdout, `Saved ${destination}
+`, context.signal);
+  return 0;
+}
+export {
+  connection,
+  freeze,
+  load
+};