tmux-agent 0.1.0

package/tests/e2e/codexForkHome.test.ts

@@ -0,0 +1,146 @@
+import { promises as fs } from "node:fs";
+import { spawnSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { codexForkHomeCleanupCommand, codexForkHomePrepareCommand } from "../../src/cli/commands/codex/forkHome";
+
+function codexAvailable(): boolean {
+  const result = spawnSync("codex", ["--version"], { encoding: "utf8" });
+  return result.status === 0;
+}
+
+const describeIf = process.env.AGENT_TMUX_E2E_CODEX === "1" && codexAvailable() ? describe : describe.skip;
+
+function resolveDefaultCodexHome(previousCodexHome: string | undefined): string {
+  if (previousCodexHome && previousCodexHome.trim()) {
+    return path.resolve(previousCodexHome.trim());
+  }
+  return path.resolve(path.join(process.env.HOME || "", ".codex"));
+}
+
+async function copyIfExists(src: string, dst: string): Promise<void> {
+  try {
+    await fs.stat(src);
+  } catch {
+    return;
+  }
+  await fs.copyFile(src, dst);
+}
+
+async function seedCodexHome(dstHome: string, srcHome: string): Promise<void> {
+  await fs.mkdir(dstHome, { recursive: true });
+  await copyIfExists(path.join(srcHome, "config.toml"), path.join(dstHome, "config.toml"));
+  await copyIfExists(path.join(srcHome, "config.json"), path.join(dstHome, "config.json"));
+  await copyIfExists(path.join(srcHome, "auth.json"), path.join(dstHome, "auth.json"));
+  await copyIfExists(path.join(srcHome, ".credentials.json"), path.join(dstHome, ".credentials.json"));
+}
+
+async function findSingleRollout(codexHome: string): Promise<string> {
+  const sessionsDir = path.join(codexHome, "sessions");
+  const stack: string[] = [sessionsDir];
+  const rollouts: { path: string; mtimeMs: number }[] = [];
+
+  while (stack.length) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    let entries: fs.Dirent[];
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      if (!entry.name.startsWith("rollout-") || !entry.name.endsWith(".jsonl")) {
+        continue;
+      }
+      const stat = await fs.stat(full);
+      rollouts.push({ path: full, mtimeMs: stat.mtimeMs });
+    }
+  }
+
+  if (rollouts.length === 0) {
+    throw new Error("no rollout file created");
+  }
+  rollouts.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return rollouts[0].path;
+}
+
+describeIf("codex fork-home e2e", () => {
+  it(
+    "prepare/cleanup works with guard rails (requires local codex + credentials)",
+    async () => {
+      const parentHome = await fs.mkdtemp(path.join(os.tmpdir(), "agent-tmux-codex-parent-"));
+      const allowedRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agent-tmux-codex-allowed-"));
+      const forkHome = path.join(allowedRoot, "fork");
+
+      const previousHome = process.env.CODEX_HOME;
+      process.env.CODEX_HOME = parentHome;
+
+      try {
+        await seedCodexHome(parentHome, resolveDefaultCodexHome(previousHome));
+
+        const result = spawnSync(
+          "codex",
+          ["exec", "hello", "-m", "gpt-5.1-codex-mini", "-c", "model_reasoning_effort=low"],
+          { encoding: "utf8", env: { ...process.env, CODEX_HOME: parentHome } }
+        );
+        let parentRollout: string;
+        try {
+          parentRollout = await findSingleRollout(parentHome);
+        } catch {
+          const status = result.status ?? -1;
+          const stderr = (result.stderr || "").toString().slice(-2000);
+          const stdout = (result.stdout || "").toString().slice(-2000);
+          throw new Error(
+            `codex exec did not create rollout (status=${status}).\nstdout:\n${stdout}\nstderr:\n${stderr}`
+          );
+        }
+
+        const preparedJson = await codexForkHomePrepareCommand({
+          json: true,
+          parentRollout,
+          forkHome
+        });
+        const prepared = JSON.parse(preparedJson);
+        expect(prepared.fork_home).toBe(path.resolve(forkHome));
+        await fs.stat(prepared.fork_rollout_path);
+
+        await expect(
+          codexForkHomeCleanupCommand({
+            path: forkHome,
+            allowedRoot: path.join(os.tmpdir(), "not-allowed")
+          })
+        ).rejects.toBeTruthy();
+
+        const cleanupJson = await codexForkHomeCleanupCommand({
+          json: true,
+          path: forkHome,
+          allowedRoot
+        });
+        const cleaned = JSON.parse(cleanupJson);
+        expect(cleaned.removed).toBe(true);
+      } finally {
+        await fs.rm(parentHome, { recursive: true, force: true });
+        await fs.rm(allowedRoot, { recursive: true, force: true });
+        if (previousHome === undefined) {
+          delete process.env.CODEX_HOME;
+        } else {
+          process.env.CODEX_HOME = previousHome;
+        }
+      }
+    },
+    300_000
+  );
+});

package/tests/e2e/codexSessionInfo.test.ts

@@ -0,0 +1,112 @@
+import { promises as fs } from "node:fs";
+import { spawnSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { codexSendCommand } from "../../src/cli/commands/codex/send";
+import { codexSessionInfoCommand } from "../../src/cli/commands/codex/sessionInfo";
+import { createTmuxHarness, tmuxAvailable } from "../integration/tmuxHarness";
+
+function codexAvailable(): boolean {
+  const result = spawnSync("codex", ["--version"], { encoding: "utf8" });
+  return result.status === 0;
+}
+
+const describeIf =
+  tmuxAvailable() && process.env.AGENT_TMUX_E2E_CODEX === "1" && codexAvailable()
+    ? describe
+    : describe.skip;
+
+function resolveDefaultCodexHome(previousCodexHome: string | undefined): string {
+  if (previousCodexHome && previousCodexHome.trim()) {
+    return path.resolve(previousCodexHome.trim());
+  }
+  return path.resolve(path.join(process.env.HOME || "", ".codex"));
+}
+
+async function copyIfExists(src: string, dst: string): Promise<void> {
+  try {
+    await fs.stat(src);
+  } catch {
+    return;
+  }
+  await fs.copyFile(src, dst);
+}
+
+async function seedCodexHome(dstHome: string, srcHome: string): Promise<void> {
+  await fs.mkdir(dstHome, { recursive: true });
+  await copyIfExists(path.join(srcHome, "config.toml"), path.join(dstHome, "config.toml"));
+  await copyIfExists(path.join(srcHome, "config.json"), path.join(dstHome, "config.json"));
+  await copyIfExists(path.join(srcHome, "auth.json"), path.join(dstHome, "auth.json"));
+  await copyIfExists(path.join(srcHome, ".credentials.json"), path.join(dstHome, ".credentials.json"));
+}
+
+describeIf("codex session-info e2e", () => {
+  it(
+    "returns session_id and rollout_path for a codex TUI pane",
+    async () => {
+      const harness = createTmuxHarness();
+      const previousServer = process.env.AGENT_TMUX_SERVER;
+      const previousHome = process.env.CODEX_HOME;
+      process.env.AGENT_TMUX_SERVER = harness.server;
+
+      const codexHome = await fs.mkdtemp(path.join(os.tmpdir(), "agent-tmux-codex-home-"));
+      process.env.CODEX_HOME = codexHome;
+
+      try {
+        await seedCodexHome(codexHome, resolveDefaultCodexHome(previousHome));
+
+        const originPaneId = harness
+          .run(["list-panes", "-t", `${harness.session}:0`, "-F", "#{pane_id}"])
+          .trim()
+          .split(/\r?\n/)[0]
+          .trim();
+
+        const paneId = harness
+          .run([
+            "split-window",
+            "-d",
+            "-P",
+            "-F",
+            "#{pane_id}",
+            "-t",
+            originPaneId,
+            "-e",
+            `CODEX_HOME=${codexHome}`,
+            "bash",
+            "-lc",
+            "codex -m gpt-5.1-codex-mini -c model_reasoning_effort=low"
+          ])
+          .trim();
+
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+
+        await codexSendCommand(paneId, "hello", { session: harness.session, json: true });
+
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+
+        const json = await codexSessionInfoCommand(paneId, { session: harness.session, json: true });
+        const parsed = JSON.parse(json);
+        expect(parsed.session_id).toMatch(
+          /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/
+        );
+        expect(parsed.rollout_path).toContain(path.join(codexHome, "sessions"));
+        await fs.stat(parsed.rollout_path);
+      } finally {
+        harness.cleanup();
+        await fs.rm(codexHome, { recursive: true, force: true });
+        if (previousServer === undefined) {
+          delete process.env.AGENT_TMUX_SERVER;
+        } else {
+          process.env.AGENT_TMUX_SERVER = previousServer;
+        }
+        if (previousHome === undefined) {
+          delete process.env.CODEX_HOME;
+        } else {
+          process.env.CODEX_HOME = previousHome;
+        }
+      }
+    },
+    300_000
+  );
+});

package/tests/e2e/codexTuiSend.test.ts

@@ -0,0 +1,68 @@
+import { spawnSync } from "node:child_process";
+import { describe, expect, it } from "vitest";
+import { codexSendCommand } from "../../src/cli/commands/codex/send";
+import { createTmuxHarness, tmuxAvailable } from "../integration/tmuxHarness";
+
+function codexAvailable(): boolean {
+  const result = spawnSync("codex", ["--version"], { encoding: "utf8" });
+  return result.status === 0;
+}
+
+const describeIf =
+  tmuxAvailable() && process.env.AGENT_TMUX_E2E_CODEX === "1" && codexAvailable()
+    ? describe
+    : describe.skip;
+
+describeIf("codex tui send e2e", () => {
+  it(
+    "can inject text and submit (requires local codex + credentials)",
+    async () => {
+      const harness = createTmuxHarness();
+      const previousServer = process.env.AGENT_TMUX_SERVER;
+      process.env.AGENT_TMUX_SERVER = harness.server;
+
+      try {
+        const originPaneId = harness
+          .run(["list-panes", "-t", `${harness.session}:0`, "-F", "#{pane_id}"])
+          .trim()
+          .split(/\r?\n/)[0]
+          .trim();
+
+        const paneId = harness
+          .run([
+            "split-window",
+            "-d",
+            "-P",
+            "-F",
+            "#{pane_id}",
+            "-t",
+            originPaneId,
+            "bash",
+            "-lc",
+            "codex -m gpt-5.1-codex-mini -c model_reasoning_effort=low"
+          ])
+          .trim();
+
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+
+        const json = await codexSendCommand(paneId, "继续", {
+          session: harness.session,
+          json: true,
+          captureTail: 20
+        });
+        const parsed = JSON.parse(json);
+        expect(parsed.resolved.id).toBe(paneId);
+        expect(parsed.sent.submit_delay_ms).toBe(250);
+        expect(typeof parsed.capture_tail).toBe("string");
+      } finally {
+        harness.cleanup();
+        if (previousServer === undefined) {
+          delete process.env.AGENT_TMUX_SERVER;
+        } else {
+          process.env.AGENT_TMUX_SERVER = previousServer;
+        }
+      }
+    },
+    300_000
+  );
+});

package/tests/integration/codexSpawn.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import { codexSpawnCommand } from "../../src/cli/commands/codex/spawn";
+import { createTmuxHarness, tmuxAvailable } from "./tmuxHarness";
+
+const describeIf = tmuxAvailable() ? describe : describe.skip;
+
+function listPanes(harness: ReturnType<typeof createTmuxHarness>): Array<{ id: string; active: boolean }> {
+  const out = harness.run([
+    "list-panes",
+    "-t",
+    `${harness.session}:0`,
+    "-F",
+    "#{pane_id}\t#{pane_active}"
+  ]);
+  return out
+    .trim()
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const [id, activeRaw] = line.split("\t");
+      return { id, active: activeRaw === "1" };
+    });
+}
+
+describeIf("codex spawn integration", () => {
+  it("creates a pane without stealing focus", async () => {
+    const harness = createTmuxHarness();
+    const previousServer = process.env.AGENT_TMUX_SERVER;
+    process.env.AGENT_TMUX_SERVER = harness.server;
+
+    try {
+      const before = listPanes(harness);
+      const origin = before.find((pane) => pane.active)?.id;
+      expect(origin).toBeTruthy();
+
+      const json = await codexSpawnCommand({ json: true, origin: String(origin) });
+      const parsed = JSON.parse(json);
+      expect(parsed.created.id).toMatch(/^%/);
+
+      const after = listPanes(harness);
+      const originAfter = after.find((pane) => pane.id === origin);
+      expect(originAfter?.active).toBe(true);
+      expect(after.some((pane) => pane.id === parsed.created.id)).toBe(true);
+    } finally {
+      harness.cleanup();
+      if (previousServer === undefined) {
+        delete process.env.AGENT_TMUX_SERVER;
+      } else {
+        process.env.AGENT_TMUX_SERVER = previousServer;
+      }
+    }
+  });
+
+  it("refuses when window layout is unsafe", async () => {
+    const harness = createTmuxHarness();
+    const previousServer = process.env.AGENT_TMUX_SERVER;
+    process.env.AGENT_TMUX_SERVER = harness.server;
+
+    try {
+      const before = listPanes(harness);
+      const origin = before.find((pane) => pane.active)?.id;
+      expect(origin).toBeTruthy();
+
+      harness.run(["split-window", "-v", "-d", "-t", String(origin), "sleep", "300"]);
+
+      await expect(codexSpawnCommand({ origin: String(origin) })).rejects.toThrow(
+        "leftmost column"
+      );
+
+      const after = listPanes(harness);
+      expect(after.length).toBe(before.length + 1);
+    } finally {
+      harness.cleanup();
+      if (previousServer === undefined) {
+        delete process.env.AGENT_TMUX_SERVER;
+      } else {
+        process.env.AGENT_TMUX_SERVER = previousServer;
+      }
+    }
+  });
+
+  it("allows explicit force-simple-split fallback", async () => {
+    const harness = createTmuxHarness();
+    const previousServer = process.env.AGENT_TMUX_SERVER;
+    process.env.AGENT_TMUX_SERVER = harness.server;
+
+    try {
+      const before = listPanes(harness);
+      const origin = before.find((pane) => pane.active)?.id;
+      expect(origin).toBeTruthy();
+
+      harness.run(["split-window", "-v", "-d", "-t", String(origin), "sleep", "300"]);
+
+      const json = await codexSpawnCommand({
+        json: true,
+        origin: String(origin),
+        forceSimpleSplit: true
+      });
+      const parsed = JSON.parse(json);
+      expect(parsed.created.id).toMatch(/^%/);
+      expect(parsed.meta.action).toBe("simple_split");
+      expect(parsed.meta.source).toBe("force-simple-split");
+    } finally {
+      harness.cleanup();
+      if (previousServer === undefined) {
+        delete process.env.AGENT_TMUX_SERVER;
+      } else {
+        process.env.AGENT_TMUX_SERVER = previousServer;
+      }
+    }
+  });
+});

package/tests/integration/paneOps.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it, vi } from "vitest";
+import { paneSpawnCommand } from "../../src/cli/commands/paneSpawn";
+import { paneTitleCommand } from "../../src/cli/commands/paneTitle";
+import { paneKillCommand } from "../../src/cli/commands/paneKill";
+import { createTmuxHarness, tmuxAvailable } from "./tmuxHarness";
+import { readStdin } from "../../src/lib/io/readStdin";
+import { tmuxExec } from "../../src/lib/tmux/exec";
+
+vi.mock("../../src/lib/io/readStdin", () => ({
+  readStdin: vi.fn()
+}));
+
+const describeIf = tmuxAvailable() ? describe : describe.skip;
+
+describeIf("pane ops integration", () => {
+  it("spawns, titles, and kills panes", async () => {
+    const harness = createTmuxHarness();
+    const previousServer = process.env.AGENT_TMUX_SERVER;
+    process.env.AGENT_TMUX_SERVER = harness.server;
+
+    try {
+      vi.mocked(readStdin).mockResolvedValue("sleep 300");
+      const sessionList = await tmuxExec([
+        "list-sessions",
+        "-F",
+        "#{session_name}"
+      ]);
+      expect(sessionList.stdout).toContain(harness.session);
+
+      const spawnJson = await paneSpawnCommand("-", {
+        session: harness.session,
+        json: true,
+        title: "logs"
+      });
+      const created = JSON.parse(spawnJson).created;
+      expect(created.id).toMatch(/^%/);
+
+      const titleJson = await paneTitleCommand(created.id, "updated", {
+        session: harness.session,
+        json: true
+      });
+      const updated = JSON.parse(titleJson);
+      expect(updated.updated.title).toBe("updated");
+
+      const killJson = await paneKillCommand(created.id, {
+        session: harness.session,
+        json: true
+      });
+      const killed = JSON.parse(killJson);
+      expect(killed.killed).toBe(true);
+    } finally {
+      harness.cleanup();
+      if (previousServer === undefined) {
+        delete process.env.AGENT_TMUX_SERVER;
+      } else {
+        process.env.AGENT_TMUX_SERVER = previousServer;
+      }
+    }
+  });
+});

package/tests/integration/sendRead.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it, vi } from "vitest";
+import { send } from "../../src/cli/commands/send";
+import { read } from "../../src/cli/commands/read";
+import { createTmuxHarness, tmuxAvailable } from "./tmuxHarness";
+import { readStdin } from "../../src/lib/io/readStdin";
+import { tmuxExec } from "../../src/lib/tmux/exec";
+
+vi.mock("../../src/lib/io/readStdin", () => ({
+  readStdin: vi.fn()
+}));
+
+const describeIf = tmuxAvailable() ? describe : describe.skip;
+
+function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describeIf("send/read integration", () => {
+  it("sends text from stdin and reads output", async () => {
+    const harness = createTmuxHarness();
+    const previousServer = process.env.AGENT_TMUX_SERVER;
+    process.env.AGENT_TMUX_SERVER = harness.server;
+
+    try {
+      vi.mocked(readStdin).mockResolvedValue("echo stdin-test");
+      const sessionList = await tmuxExec([
+        "list-sessions",
+        "-F",
+        "#{session_name}"
+      ]);
+      expect(sessionList.stdout).toContain(harness.session);
+
+      const sendJson = await send("0", "-", { session: harness.session, json: true });
+      const sendData = JSON.parse(sendJson);
+      expect(sendData.resolved.id).toMatch(/^%/);
+
+      await send("0", "echo delay-test", { session: harness.session, enterDelayMs: 10 });
+
+      await wait(100);
+      const output = await read("0", { session: harness.session, lines: 20 });
+      expect(output).toContain("stdin-test");
+      expect(output).toContain("delay-test");
+    } finally {
+      harness.cleanup();
+      if (previousServer === undefined) {
+        delete process.env.AGENT_TMUX_SERVER;
+      } else {
+        process.env.AGENT_TMUX_SERVER = previousServer;
+      }
+    }
+  });
+});

package/tests/integration/snapshot.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { windowLs } from "../../src/cli/commands/windowLs";
+import { snapshot } from "../../src/cli/commands/snapshot";
+import { createTmuxHarness, tmuxAvailable } from "./tmuxHarness";
+
+const describeIf = tmuxAvailable() ? describe : describe.skip;
+
+describeIf("snapshot integration", () => {
+  it("lists windows and snapshots panes", async () => {
+    const harness = createTmuxHarness();
+    const previousServer = process.env.AGENT_TMUX_SERVER;
+    process.env.AGENT_TMUX_SERVER = harness.server;
+
+    try {
+      harness.run(["split-window", "-t", `${harness.session}:0`]);
+      harness.run(["new-window", "-t", harness.session, "-n", "logs"]);
+      harness.run(["split-window", "-t", `${harness.session}:1`]);
+
+      const windowJson = await windowLs({ session: harness.session, json: true });
+      const windowData = JSON.parse(windowJson);
+      expect(windowData.windows.length).toBe(2);
+
+      const snapshotJson = await snapshot({
+        session: harness.session,
+        window: "0",
+        json: true
+      });
+      const snapshotData = JSON.parse(snapshotJson);
+      expect(snapshotData.panes.length).toBe(2);
+    } finally {
+      harness.cleanup();
+      if (previousServer === undefined) {
+        delete process.env.AGENT_TMUX_SERVER;
+      } else {
+        process.env.AGENT_TMUX_SERVER = previousServer;
+      }
+    }
+  });
+});

package/tests/integration/tmuxHarness.ts

@@ -0,0 +1,39 @@
+import { randomUUID } from "node:crypto";
+import { spawnSync } from "node:child_process";
+
+export type TmuxHarness = {
+  server: string;
+  session: string;
+  run: (args: string[], input?: string) => string;
+  cleanup: () => void;
+};
+
+export function tmuxAvailable(): boolean {
+  const result = spawnSync("tmux", ["-V"], { encoding: "utf8" });
+  return result.status === 0;
+}
+
+export function createTmuxHarness(): TmuxHarness {
+  const serverSuffix = randomUUID().replace(/-/g, "").slice(0, 12);
+  const server = `agent-tmux-test-${process.pid}-${serverSuffix}`;
+  const session = `session-${randomUUID()}`;
+
+  const run = (args: string[], input?: string): string => {
+    const result = spawnSync("tmux", ["-L", server, "-f", "/dev/null", ...args], {
+      encoding: "utf8",
+      input
+    });
+    if (result.status !== 0) {
+      throw new Error(result.stderr || result.stdout || "tmux command failed");
+    }
+    return result.stdout;
+  };
+
+  run(["new-session", "-d", "-s", session, "-n", "main", "sleep", "300"]);
+
+  const cleanup = (): void => {
+    spawnSync("tmux", ["-L", server, "-f", "/dev/null", "kill-server"], { encoding: "utf8" });
+  };
+
+  return { server, session, run, cleanup };
+}

package/tests/integration/windowOps.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it, vi } from "vitest";
+import { windowNewCommand } from "../../src/cli/commands/windowNew";
+import { windowRenameCommand } from "../../src/cli/commands/windowRename";
+import { windowKillCommand } from "../../src/cli/commands/windowKill";
+import { createTmuxHarness, tmuxAvailable } from "./tmuxHarness";
+import { readStdin } from "../../src/lib/io/readStdin";
+import { tmuxExec } from "../../src/lib/tmux/exec";
+
+vi.mock("../../src/lib/io/readStdin", () => ({
+  readStdin: vi.fn()
+}));
+
+const describeIf = tmuxAvailable() ? describe : describe.skip;
+
+describeIf("window ops integration", () => {
+  it("creates, renames, and kills windows", async () => {
+    const harness = createTmuxHarness();
+    const previousServer = process.env.AGENT_TMUX_SERVER;
+    process.env.AGENT_TMUX_SERVER = harness.server;
+
+    try {
+      vi.mocked(readStdin).mockResolvedValue("sleep 300");
+      const sessionList = await tmuxExec([
+        "list-sessions",
+        "-F",
+        "#{session_name}"
+      ]);
+      expect(sessionList.stdout).toContain(harness.session);
+
+      const newJson = await windowNewCommand("build", {
+        session: harness.session,
+        json: true,
+        command: "-"
+      });
+      const created = JSON.parse(newJson).created;
+      expect(created.wid).toMatch(/^@/);
+
+      const renameJson = await windowRenameCommand(String(created.widx), "renamed", {
+        session: harness.session,
+        json: true
+      });
+      const renamed = JSON.parse(renameJson);
+      expect(renamed.renamed.name).toBe("renamed");
+
+      const killJson = await windowKillCommand(String(created.widx), {
+        session: harness.session,
+        json: true
+      });
+      const killed = JSON.parse(killJson);
+      expect(killed.killed).toBe(true);
+    } finally {
+      harness.cleanup();
+      if (previousServer === undefined) {
+        delete process.env.AGENT_TMUX_SERVER;
+      } else {
+        process.env.AGENT_TMUX_SERVER = previousServer;
+      }
+    }
+  });
+});