tmux-agent 0.1.0

package/src/cli/commands/send.ts

@@ -0,0 +1,71 @@
+import { formatJson } from "../../lib/output/format";
+import { readStdin } from "../../lib/io/readStdin";
+import { resolveSessionScope, resolveWindowScope } from "../../lib/targeting/scope";
+import { resolvePaneTarget } from "../../lib/targeting/resolvePaneTarget";
+import { snapshotPanes } from "../../lib/tmux/snapshotPanes";
+import { sendKeys } from "../../lib/tmux/sendKeys";
+import { isCodexPane } from "../../lib/codex/isCodexPane";
+
+function isPaneIdTarget(target: string): boolean {
+  return target.startsWith("%") || /^@[^%]+%[^%]+$/.test(target);
+}
+
+export type SendOptions = {
+  json?: boolean;
+  session?: string;
+  window?: string;
+  noEnter?: boolean;
+  enterDelayMs?: number;
+};
+
+export async function send(
+  target: string,
+  textArg: string,
+  options: SendOptions = {}
+): Promise<string> {
+  if (!target || !textArg) {
+    throw new Error("send requires <paneTarget> <text>");
+  }
+
+  const scope = await resolveSessionScope(options.session?.trim() || undefined);
+
+  let windowId: string | undefined;
+  if (!isPaneIdTarget(target)) {
+    const window = await resolveWindowScope(
+      scope.session,
+      options.window?.trim() || undefined
+    );
+    windowId = window.wid;
+  }
+
+  const panes = await snapshotPanes({ session: scope.session });
+  const resolved = resolvePaneTarget(panes, target, { windowId });
+
+  const text = textArg === "-" ? await readStdin() : textArg;
+  const noEnter = Boolean(options.noEnter);
+  const explicitEnterDelayMs =
+    options.enterDelayMs !== undefined ? Math.max(0, Math.floor(options.enterDelayMs)) : undefined;
+  const resolvedPane = panes.find((pane) => pane.id === resolved.id);
+  let enterDelayMs = 0;
+  if (!noEnter) {
+    if (explicitEnterDelayMs !== undefined) {
+      enterDelayMs = explicitEnterDelayMs;
+    } else if (resolvedPane) {
+      enterDelayMs = (await isCodexPane(resolvedPane)) ? 250 : 0;
+    }
+  }
+  const sent = await sendKeys(resolved.id, text, {
+    noEnter,
+    enterDelayMs
+  });
+
+  if (options.json) {
+    return formatJson({
+      requested: { target },
+      resolved: { id: resolved.id, ...(resolved.idx !== undefined ? { idx: resolved.idx } : {}) },
+      sent
+    });
+  }
+
+  return resolved.id;
+}

package/src/cli/commands/snapshot.ts

@@ -0,0 +1,28 @@
+import { formatJson, formatPaneTable } from "../../lib/output/format";
+import { resolveSessionScope, resolveWindowScope } from "../../lib/targeting/scope";
+import { snapshotPanes } from "../../lib/tmux/snapshotPanes";
+
+export type SnapshotOptions = {
+  json?: boolean;
+  session?: string;
+  window?: string;
+};
+
+export async function snapshot(options: SnapshotOptions = {}): Promise<string> {
+  const scope = await resolveSessionScope(options.session?.trim() || undefined);
+  const window = await resolveWindowScope(
+    scope.session,
+    options.window?.trim() || undefined
+  );
+  const panes = await snapshotPanes({ windowId: window.wid });
+
+  if (options.json) {
+    return formatJson({
+      session: { name: scope.session },
+      window: { widx: window.widx, wid: window.wid, name: window.name },
+      panes
+    });
+  }
+
+  return formatPaneTable(panes);
+}

package/src/cli/commands/ui/select.ts

@@ -0,0 +1,49 @@
+import { formatJson } from "../../../lib/output/format";
+import { readStdin } from "../../../lib/io/readStdin";
+import { popupSelect, type PopupSelectSpec } from "../../../lib/ui/popupSelect";
+
+function parseJsonObject(raw: string): PopupSelectSpec {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("spec must be valid JSON");
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("spec must be a JSON object");
+  }
+  return parsed as PopupSelectSpec;
+}
+
+export type UiSelectOptions = {
+  json?: boolean;
+  spec: string;
+};
+
+export async function uiSelectCommand(options: UiSelectOptions): Promise<string> {
+  const specArg = String(options.spec || "").trim();
+  if (!specArg) {
+    throw new Error("ui select requires --spec -");
+  }
+  if (specArg !== "-") {
+    throw new Error("spec must be '-' to read from stdin");
+  }
+
+  const spec = parseJsonObject(await readStdin());
+  const result = await popupSelect(spec);
+
+  const selectedValues =
+    result.customInput && result.customInput.trim()
+      ? [result.customInput.trim()]
+      : result.selectedValues;
+
+  if (options.json) {
+    return formatJson({
+      mode: result.mode,
+      selected: { values: selectedValues },
+      ...(result.customInput ? { custom_input: result.customInput, custom_input_via: result.customInputVia } : {})
+    });
+  }
+
+  return selectedValues.join("\n");
+}

package/src/cli/commands/windowKill.ts

@@ -0,0 +1,35 @@
+import { formatJson } from "../../lib/output/format";
+import { resolveSessionScope } from "../../lib/targeting/scope";
+import { resolveWindowTarget } from "../../lib/targeting/resolveWindowTarget";
+import { snapshotWindows } from "../../lib/tmux/snapshotWindows";
+import { windowKill } from "../../lib/tmux/windowOps";
+
+export type WindowKillOptions = {
+  json?: boolean;
+  session?: string;
+};
+
+export async function windowKillCommand(
+  target: string,
+  options: WindowKillOptions = {}
+): Promise<string> {
+  if (!target) {
+    throw new Error("window kill requires <windowTarget>");
+  }
+
+  const scope = await resolveSessionScope(options.session?.trim() || undefined);
+
+  const windows = await snapshotWindows(scope.session);
+  const resolved = resolveWindowTarget(windows, target);
+  await windowKill(resolved.wid);
+
+  if (options.json) {
+    return formatJson({
+      requested: { target },
+      resolved: { wid: resolved.wid, widx: resolved.widx },
+      killed: true
+    });
+  }
+
+  return resolved.wid;
+}

package/src/cli/commands/windowLs.ts

@@ -0,0 +1,20 @@
+import { formatJson, formatWindowTable } from "../../lib/output/format";
+import { resolveSessionScope } from "../../lib/targeting/scope";
+import { snapshotWindows } from "../../lib/tmux/snapshotWindows";
+
+export type WindowLsOptions = {
+  json?: boolean;
+  session?: string;
+};
+
+export async function windowLs(options: WindowLsOptions = {}): Promise<string> {
+  const session = String(options.session ?? "");
+  const scope = await resolveSessionScope(session.trim() || undefined);
+  const windows = await snapshotWindows(scope.session);
+
+  if (options.json) {
+    return formatJson({ session: { name: scope.session }, windows });
+  }
+
+  return formatWindowTable(windows);
+}

package/src/cli/commands/windowNew.ts

@@ -0,0 +1,40 @@
+import { formatJson } from "../../lib/output/format";
+import { readStdin } from "../../lib/io/readStdin";
+import { resolveSessionScope } from "../../lib/targeting/scope";
+import { tmuxExec } from "../../lib/tmux/exec";
+import { pasteText } from "../../lib/tmux/paste";
+import { windowNew } from "../../lib/tmux/windowOps";
+
+export type WindowNewOptions = {
+  json?: boolean;
+  session?: string;
+  command?: string;
+};
+
+export async function windowNewCommand(
+  name: string,
+  options: WindowNewOptions = {}
+): Promise<string> {
+  if (!name) {
+    throw new Error("window new requires <name>");
+  }
+
+  const scope = await resolveSessionScope(options.session?.trim() || undefined);
+
+  let command = options.command?.trim() || undefined;
+  if (command === "-") {
+    command = await readStdin();
+  }
+
+  const created = await windowNew(scope.session, name);
+  if (command) {
+    await pasteText(created.paneId, command);
+    await tmuxExec(["send-keys", "-t", created.paneId, "Enter"]);
+  }
+
+  if (options.json) {
+    return formatJson({ created: { wid: created.wid, widx: created.widx, name: created.name } });
+  }
+
+  return created.wid;
+}

package/src/cli/commands/windowRename.ts

@@ -0,0 +1,36 @@
+import { formatJson } from "../../lib/output/format";
+import { resolveSessionScope } from "../../lib/targeting/scope";
+import { resolveWindowTarget } from "../../lib/targeting/resolveWindowTarget";
+import { snapshotWindows } from "../../lib/tmux/snapshotWindows";
+import { windowRename } from "../../lib/tmux/windowOps";
+
+export type WindowRenameOptions = {
+  json?: boolean;
+  session?: string;
+};
+
+export async function windowRenameCommand(
+  target: string,
+  name: string,
+  options: WindowRenameOptions = {}
+): Promise<string> {
+  if (!target || !name) {
+    throw new Error("window rename requires <windowTarget> <name>");
+  }
+
+  const scope = await resolveSessionScope(options.session?.trim() || undefined);
+
+  const windows = await snapshotWindows(scope.session);
+  const resolved = resolveWindowTarget(windows, target);
+  await windowRename(resolved.wid, name);
+
+  if (options.json) {
+    return formatJson({
+      requested: { target, name },
+      resolved: { wid: resolved.wid, widx: resolved.widx },
+      renamed: { name }
+    });
+  }
+
+  return resolved.wid;
+}