@ai-devkit/agent-manager 0.38.0 → 0.40.0

package/src/__tests__/harnesses/devin/DevinSessionParser.test.ts

@@ -0,0 +1,218 @@
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { DevinSessionParser } from "../../../harnesses/devin/DevinSessionParser.js";
+import { writeDatabase } from "./fixtures.js";
+
+describe("DevinSessionParser", () => {
+  let tmpDir: string;
+  let dbPath: string;
+  let parser: DevinSessionParser;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devin-parser-test-"));
+    dbPath = path.join(tmpDir, "sessions.db");
+    parser = new DevinSessionParser();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function openDb(): Database.Database {
+    return new Database(dbPath, { readonly: true });
+  }
+
+  it("returns user and assistant messages in node order, skipping system", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "system", content: "preamble" },
+        { sessionId: "s", nodeId: 2, role: "user", content: "hello", isUserInput: true },
+        { sessionId: "s", nodeId: 3, role: "assistant", content: "hi" },
+        // Later turn roots a fresh preamble chain:
+        { sessionId: "s", nodeId: 4, role: "system", content: "more preamble" },
+        { sessionId: "s", nodeId: 5, role: "user", content: "again", isUserInput: true },
+        { sessionId: "s", nodeId: 6, role: "assistant", content: "done" },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getConversation(db, "s")).toEqual([
+        { role: "user", content: "hello" },
+        { role: "assistant", content: "hi" },
+        { role: "user", content: "again" },
+        { role: "assistant", content: "done" },
+      ]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("dedupes sibling revisions by message_id keeping the highest node_id", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "assistant", content: "draft", messageId: "m1" },
+        { sessionId: "s", nodeId: 2, role: "assistant", content: "final", messageId: "m1" },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getConversation(db, "s")).toEqual([
+        { role: "assistant", content: "final" },
+      ]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("skips non-input user nodes and empty content", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "user", content: "wrapper", isUserInput: false },
+        { sessionId: "s", nodeId: 2, role: "user", content: "   ", isUserInput: true },
+        { sessionId: "s", nodeId: 3, role: "user", content: "real", isUserInput: true },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getConversation(db, "s")).toEqual([{ role: "user", content: "real" }]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("includes tools and thinking only in verbose mode", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        {
+          sessionId: "s",
+          nodeId: 1,
+          role: "assistant",
+          content: "working",
+          thinking: "hmm",
+          toolCalls: [{ function: { name: "exec" } }],
+        },
+        { sessionId: "s", nodeId: 2, role: "tool", content: "tool output", name: "exec" },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getConversation(db, "s")).toEqual([
+        { role: "assistant", content: "working" },
+      ]);
+      expect(parser.getConversation(db, "s", { verbose: true })).toEqual([
+        { role: "assistant", content: "[thinking] hmm" },
+        { role: "assistant", content: "working" },
+        { role: "assistant", content: "[tool: exec]" },
+        { role: "assistant", content: "[tool: exec] tool output" },
+      ]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("honors tail and bounds the query window", () => {
+    writeDatabase(dbPath, {
+      nodes: Array.from({ length: 30 }, (_, i) => ({
+        sessionId: "s",
+        nodeId: i + 1,
+        role: "user" as const,
+        content: `msg-${i + 1}`,
+        isUserInput: true,
+      })),
+    });
+    const db = openDb();
+    try {
+      const convo = parser.getConversation(db, "s", { tail: 3 });
+      expect(convo).toEqual([
+        { role: "user", content: "msg-28" },
+        { role: "user", content: "msg-29" },
+        { role: "user", content: "msg-30" },
+      ]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("skips malformed chat_message rows and missing sessions", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, raw: "{not json" },
+        { sessionId: "s", nodeId: 2, role: "assistant", content: "ok" },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getConversation(db, "s")).toEqual([
+        { role: "assistant", content: "ok" },
+      ]);
+      expect(parser.getConversation(db, "missing")).toEqual([]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("reports session stats from the frontier node and latest prompt", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "user", content: "go", createdAt: 100 },
+        { sessionId: "s", nodeId: 2, role: "assistant", content: "done", createdAt: 200 },
+      ],
+      prompts: [
+        { sessionId: "s", content: "first task", timestamp: 100 },
+        { sessionId: "s", content: "/mcp", timestamp: 300 },
+        { sessionId: "s", content: "latest task", timestamp: 200 },
+        { sessionId: "s", content: "!shell", timestamp: 400, isShell: 1 },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getSessionStats(db, "s")).toEqual({
+        lastRole: "assistant",
+        lastTimeUpdated: 200_000,
+        summary: "latest task",
+      });
+      expect(parser.getSessionStats(db, "missing")).toEqual({
+        lastRole: null,
+        lastTimeUpdated: 0,
+        summary: "",
+      });
+    } finally {
+      db.close();
+    }
+  });
+
+  it("falls back to the first is_user_input node for the summary", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "user", content: "wrapper", isUserInput: false },
+        { sessionId: "s", nodeId: 2, role: "user", content: "real first", isUserInput: true },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getFirstUserMessage(db, "s")).toBe("real first");
+    } finally {
+      db.close();
+    }
+  });
+
+  it("falls back to the last is_user_input node for the working-on summary", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "user", content: "first", isUserInput: true },
+        { sessionId: "s", nodeId: 2, role: "user", content: "wrapper", isUserInput: false },
+        { sessionId: "s", nodeId: 3, role: "user", content: "last real", isUserInput: true },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getLastUserPrompt(db, "s")).toBe("last real");
+      expect(parser.getLastUserPrompt(db, "missing")).toBe("");
+    } finally {
+      db.close();
+    }
+  });
+});

package/src/__tests__/harnesses/devin/fixtures.ts

@@ -0,0 +1,144 @@
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as path from "path";
+
+export interface DevinSessionInput {
+  id: string;
+  directory: string;
+  title?: string | null;
+  timeCreated: number;
+  lastActivityAt?: number;
+  mainChainId?: number | null;
+  hidden?: number;
+}
+
+export interface DevinNodeInput {
+  nodeId: number;
+  parentNodeId?: number | null;
+  role: string;
+  content?: string;
+  messageId?: string;
+  createdAt?: number;
+  isUserInput?: boolean;
+  toolCalls?: { name?: string; function?: { name?: string } }[];
+  thinking?: string;
+  name?: string;
+  /** Raw chat_message text; when set, other fields are ignored. */
+  raw?: string;
+}
+
+export interface DevinPromptInput {
+  sessionId: string;
+  content: string;
+  timestamp?: number;
+  isShell?: number;
+}
+
+export function writeDatabase(
+  dbPath: string,
+  data: {
+    sessions?: DevinSessionInput[];
+    nodes?: (DevinNodeInput & { sessionId: string })[];
+    prompts?: DevinPromptInput[];
+  },
+): void {
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+  try {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        working_directory TEXT NOT NULL,
+        backend_type TEXT NOT NULL DEFAULT 'local',
+        model TEXT NOT NULL DEFAULT 'test-model',
+        agent_mode TEXT NOT NULL DEFAULT 'normal',
+        created_at INTEGER NOT NULL,
+        last_activity_at INTEGER NOT NULL,
+        title TEXT,
+        main_chain_id INTEGER,
+        hidden INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS message_nodes (
+        row_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        node_id INTEGER NOT NULL,
+        parent_node_id INTEGER,
+        chat_message TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        UNIQUE(session_id, node_id)
+      );
+      CREATE TABLE IF NOT EXISTS prompt_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        session_id TEXT NOT NULL,
+        is_shell INTEGER NOT NULL DEFAULT 0
+      );
+    `);
+
+    const insertSession = db.prepare(`
+      INSERT INTO sessions (id, working_directory, created_at, last_activity_at, title, main_chain_id, hidden)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const session of data.sessions ?? []) {
+      insertSession.run(
+        session.id,
+        session.directory,
+        session.timeCreated,
+        session.lastActivityAt ?? session.timeCreated,
+        session.title ?? null,
+        session.mainChainId ?? null,
+        session.hidden ?? 0,
+      );
+    }
+
+    const insertNode = db.prepare(`
+      INSERT INTO message_nodes (session_id, node_id, parent_node_id, chat_message, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    for (const node of data.nodes ?? []) {
+      const chatMessage =
+        node.raw ??
+        JSON.stringify({
+          message_id: node.messageId ?? `msg-${node.nodeId}`,
+          role: node.role,
+          content: node.content ?? "",
+          ...(node.toolCalls ? { tool_calls: node.toolCalls } : {}),
+          ...(node.thinking ? { thinking: { thinking: node.thinking } } : {}),
+          ...(node.name ? { name: node.name } : {}),
+          ...(node.isUserInput !== undefined
+            ? { metadata: { is_user_input: node.isUserInput } }
+            : {}),
+        });
+      insertNode.run(
+        node.sessionId,
+        node.nodeId,
+        node.parentNodeId ?? null,
+        chatMessage,
+        node.createdAt ?? 1000 + node.nodeId,
+      );
+    }
+
+    const insertPrompt = db.prepare(`
+      INSERT INTO prompt_history (session_id, content, timestamp, is_shell)
+      VALUES (?, ?, ?, ?)
+    `);
+    for (const prompt of data.prompts ?? []) {
+      insertPrompt.run(
+        prompt.sessionId,
+        prompt.content,
+        prompt.timestamp ?? 1000,
+        prompt.isShell ?? 0,
+      );
+    }
+  } finally {
+    db.close();
+  }
+}
+
+export function writeLocks(locksDir: string, locks: Record<string, number | string>): void {
+  fs.mkdirSync(locksDir, { recursive: true });
+  for (const [sessionId, pid] of Object.entries(locks)) {
+    fs.writeFileSync(path.join(locksDir, `${sessionId}.lock`), String(pid));
+  }
+}

package/src/__tests__/harnesses/readiness/AgentReadiness.test.ts

@@ -67,6 +67,7 @@ function fixture(overrides: Partial<AgentReadinessOptions> = {}) {
     ".kiro",
     ".gemini/antigravity-cli",
     ".config/opencode",
+    ".config/devin",
     ".pi",
   ]) {
     files[path.join(homeDir, directory)] = "<dir>";
@@ -100,6 +101,8 @@ function fixture(overrides: Partial<AgentReadinessOptions> = {}) {
         return { stdout: "github.com\n  Logged in to github.com account test-user\n", stderr: "" };
       if (command === "opencode")
         return { stdout: "●  litellm api\n●  OpenAI oauth\n", stderr: "" };
+      if (command === "devin")
+        return { stdout: "Logged in (via Devin).\n\nUser:\n  Name: test-user\n", stderr: "" };
       throw new Error(`unexpected command ${command}`);
     }),
     codexAuth: async () => true,
@@ -124,6 +127,7 @@ describe("agent readiness", () => {
       "opencode",
       "copilot",
       "pi",
+      "devin",
     ]);
     for (const [agent, report] of Object.entries(reports) as Array<
       [ReadinessAgentType, (typeof reports)[ReadinessAgentType]]
@@ -282,4 +286,41 @@ describe("agent readiness", () => {
       status: "pass",
     });
   });
+
+  it("checks Devin auth from devin auth status output", async () => {
+    const { options } = fixture({
+      runCommand: vi.fn(async (command) => {
+        if (command === "devin")
+          return { stdout: "Logged in (via Devin).\n\nUser:\n  Name: test-user\n", stderr: "" };
+        if (command === "pi") return { stdout: "npm:@ai-devkit/pi-session-tracker\n", stderr: "" };
+        if (command === "claude") return { stdout: JSON.stringify({ loggedIn: true }), stderr: "" };
+        throw new Error(`unexpected command ${command}`);
+      }),
+    });
+
+    const report = await getAgentReadinessReport("devin", options);
+
+    expect(report.auth).toMatchObject({
+      state: "authenticated",
+      source: "devin auth status",
+      provider: null,
+      availableProviders: ["devin"],
+      status: "pass",
+    });
+  });
+
+  it("reports Devin as unauthenticated without a login line", async () => {
+    const { options } = fixture({
+      runCommand: vi.fn(async (command) => {
+        if (command === "devin") return { stdout: "Not logged in\n", stderr: "" };
+        if (command === "pi") return { stdout: "npm:@ai-devkit/pi-session-tracker\n", stderr: "" };
+        if (command === "claude") return { stdout: JSON.stringify({ loggedIn: true }), stderr: "" };
+        throw new Error(`unexpected command ${command}`);
+      }),
+    });
+
+    const report = await getAgentReadinessReport("devin", options);
+
+    expect(report.auth).toMatchObject({ state: "unauthenticated", status: "fail" });
+  });
 });

package/src/__tests__/terminal/GhosttyBackend.test.ts

@@ -0,0 +1,271 @@
+import { execFile } from "child_process";
+import { writeFile } from "fs/promises";
+import type { Mock } from "vitest";
+
+import { ghosttyBackend } from "../../terminal/backends/ghostty.js";
+import { TerminalType, type TerminalLocation } from "../../terminal/types.js";
+import { TtyWriter } from "../../terminal/TtyWriter.js";
+import { getProcessCwdsAsync } from "../../utils/process.js";
+
+vi.mock("child_process", async () => {
+  const actual = await vi.importActual<typeof import("child_process")>("child_process");
+  return { ...actual, execFile: vi.fn() };
+});
+
+vi.mock("fs/promises", async () => {
+  const actual = await vi.importActual<typeof import("fs/promises")>("fs/promises");
+  return { ...actual, writeFile: vi.fn() };
+});
+
+vi.mock("../../utils/process.js", async () => {
+  const actual =
+    await vi.importActual<typeof import("../../utils/process.js")>("../../utils/process.js");
+  return { ...actual, getProcessCwdsAsync: vi.fn() };
+});
+
+const mockedExecFile = execFile as unknown as Mock;
+const mockedGetProcessCwds = getProcessCwdsAsync as unknown as Mock;
+const mockedWriteFile = writeFile as unknown as Mock;
+const SEP = "\x1f";
+
+interface FakeTerminal {
+  id: string;
+  name: string;
+  dir: string;
+}
+
+/**
+ * Fake `ps`, process cwds and Ghostty AppleScript. `processes` rows are
+ * `pid ppid tty comm`; `cwds` maps pid to its working directory. Writing an
+ * OSC 2 title to a TTY renames the terminal listed in `ttyOwner`.
+ */
+function fakeSystem(opts: {
+  processes: string[];
+  cwds?: Record<number, string>;
+  terminals: FakeTerminal[];
+  ttyOwner?: Record<string, string>;
+  osascriptResult?: string;
+}) {
+  const terminals = opts.terminals.map((t) => ({ ...t }));
+  mockedGetProcessCwds.mockImplementation(async (pids: number[]) => {
+    const cwds = new Map<number, string>();
+    for (const pid of pids) if (opts.cwds?.[pid]) cwds.set(pid, opts.cwds[pid]);
+    return cwds;
+  });
+  mockedWriteFile.mockImplementation(async (tty: string, data: string) => {
+    // eslint-disable-next-line no-control-regex
+    const title = /^\x1b\]2;(.*)\x07$/.exec(data)?.[1];
+    const owner = terminals.find((t) => t.id === opts.ttyOwner?.[tty]);
+    if (owner && title !== undefined) owner.name = title;
+  });
+  mockedExecFile.mockImplementation((...args: unknown[]) => {
+    const [cmd, argv] = args as [string, string[]];
+    const cb = args[args.length - 1] as (err: Error | null, r?: { stdout: string }) => void;
+    let stdout = "";
+    if (cmd === "ps") stdout = opts.processes.join("\n") + "\n";
+    else if (cmd === "osascript" && argv[1].includes("repeat with t in terminals")) {
+      stdout = terminals.map((t) => [t.id, t.name, t.dir].join(SEP)).join("\n") + "\n";
+    } else if (cmd === "osascript") stdout = opts.osascriptResult ?? "ok\n";
+    cb(null, { stdout });
+    return {};
+  });
+  return terminals;
+}
+
+const GHOSTTY = "500 1 ?? /Applications/Ghostty.app/Contents/MacOS/ghostty";
+
+describe("Ghostty terminal backend", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("find", () => {
+    it("ignores TTYs when Ghostty is not running", async () => {
+      fakeSystem({ processes: ["600 1 ttys001 /usr/bin/login"], terminals: [] });
+
+      expect(await ghosttyBackend.find("/dev/ttys001")).toBeNull();
+      expect(mockedExecFile).not.toHaveBeenCalledWith(
+        "osascript",
+        expect.anything(),
+        expect.anything(),
+      );
+    });
+
+    it("ignores TTYs whose session was not started by Ghostty", async () => {
+      fakeSystem({
+        processes: [GHOSTTY, "600 500 ttys001 /usr/bin/login", "700 1 ttys002 /usr/bin/login"],
+        terminals: [{ id: "T1", name: "zsh", dir: "/repo" }],
+      });
+
+      expect(await ghosttyBackend.find("/dev/ttys002")).toBeNull();
+      expect(mockedWriteFile).not.toHaveBeenCalled();
+    });
+
+    it("matches by working directory when it pairs one terminal with one TTY", async () => {
+      fakeSystem({
+        processes: [
+          GHOSTTY,
+          "600 500 ttys001 /usr/bin/login",
+          "601 600 ttys001 -zsh",
+          "602 601 ttys001 claude",
+          "700 500 ttys002 /usr/bin/login",
+          "701 700 ttys002 -zsh",
+        ],
+        cwds: { 601: "/repo/a", 602: "/repo/a", 701: "/repo/b" },
+        terminals: [
+          { id: "T1", name: "claude", dir: "/repo/a" },
+          { id: "T2", name: "zsh", dir: "/repo/b" },
+        ],
+      });
+
+      expect(await ghosttyBackend.find("/dev/ttys001")).toEqual({
+        type: TerminalType.GHOSTTY,
+        identifier: "T1",
+        tty: "/dev/ttys001",
+      });
+      expect(mockedWriteFile).not.toHaveBeenCalled();
+    });
+
+    it("uses a title marker when two terminals share the directory, then restores the title", async () => {
+      const terminals = fakeSystem({
+        processes: [
+          GHOSTTY,
+          "600 500 ttys001 /usr/bin/login",
+          "601 600 ttys001 claude",
+          "700 500 ttys002 /usr/bin/login",
+          "701 700 ttys002 codex",
+        ],
+        cwds: { 601: "/repo", 701: "/repo" },
+        terminals: [
+          { id: "T1", name: "first agent", dir: "/repo" },
+          { id: "T2", name: "second agent", dir: "/repo" },
+        ],
+        ttyOwner: { "/dev/ttys001": "T1", "/dev/ttys002": "T2" },
+      });
+
+      const location = await ghosttyBackend.find("/dev/ttys002");
+
+      expect(location?.identifier).toBe("T2");
+      const titles = mockedWriteFile.mock.calls.map(([tty, data]) => [tty, data]);
+      expect(titles).toHaveLength(2);
+      expect(titles[0][0]).toBe("/dev/ttys002");
+      // eslint-disable-next-line no-control-regex
+      expect(titles[0][1]).toMatch(/^\x1b\]2;ai-devkit-\d+-\d+\x07$/);
+      expect(titles[1]).toEqual(["/dev/ttys002", "\x1b]2;second agent\x07"]);
+      expect(terminals.find((t) => t.id === "T2")?.name).toBe("second agent");
+    });
+
+    it("does not trust a unique directory match when another Ghostty TTY has a process there", async () => {
+      // T1's own working directory is unreported; T2 sits in the agent's directory.
+      fakeSystem({
+        processes: [
+          GHOSTTY,
+          "600 500 ttys001 /usr/bin/login",
+          "601 600 ttys001 claude",
+          "700 500 ttys002 /usr/bin/login",
+          "701 700 ttys002 -zsh",
+        ],
+        cwds: { 601: "/repo", 701: "/repo" },
+        terminals: [
+          { id: "T1", name: "claude", dir: "" },
+          { id: "T2", name: "zsh", dir: "/repo" },
+        ],
+        ttyOwner: { "/dev/ttys001": "T1", "/dev/ttys002": "T2" },
+      });
+
+      expect((await ghosttyBackend.find("/dev/ttys001"))?.identifier).toBe("T1");
+      expect(mockedWriteFile).toHaveBeenCalled();
+    });
+
+    it("returns null when no terminal shows the marker", async () => {
+      vi.useFakeTimers();
+      try {
+        fakeSystem({
+          processes: [GHOSTTY, "600 500 ttys001 /usr/bin/login"],
+          terminals: [
+            { id: "T1", name: "a", dir: "/x" },
+            { id: "T2", name: "b", dir: "/y" },
+          ],
+        });
+
+        const result = ghosttyBackend.find("/dev/ttys001");
+        await vi.runAllTimersAsync();
+
+        expect(await result).toBeNull();
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it("returns null instead of throwing when Ghostty is not scriptable", async () => {
+      mockedGetProcessCwds.mockResolvedValue(new Map());
+      mockedExecFile.mockImplementation((...args: unknown[]) => {
+        const [cmd] = args as [string];
+        const cb = args[args.length - 1] as (err: Error | null, r?: { stdout: string }) => void;
+        if (cmd === "osascript") cb(new Error("Not authorized to send Apple events"));
+        else cb(null, { stdout: `${GHOSTTY}\n600 500 ttys001 /usr/bin/login\n` });
+        return {};
+      });
+
+      expect(await ghosttyBackend.find("/dev/ttys001")).toBeNull();
+    });
+  });
+
+  describe("focus, send and sendKey", () => {
+    const location: TerminalLocation = {
+      type: TerminalType.GHOSTTY,
+      identifier: "T1",
+      tty: "/dev/ttys001",
+    };
+    const scripts = () =>
+      mockedExecFile.mock.calls.filter(([cmd]) => cmd === "osascript").map(([, argv]) => argv[1]);
+
+    it("focuses the terminal by id and activates Ghostty", async () => {
+      fakeSystem({ processes: [], terminals: [] });
+
+      expect(await ghosttyBackend.focus(location)).toBe(true);
+      expect(scripts()[0]).toContain('every terminal whose id is "T1"');
+      expect(scripts()[0]).toContain("focus t");
+      expect(scripts()[0]).toContain("activate");
+    });
+
+    it("reports a failed focus when the terminal is gone", async () => {
+      fakeSystem({ processes: [], terminals: [], osascriptResult: "not_found\n" });
+
+      expect(await ghosttyBackend.focus(location)).toBe(false);
+    });
+
+    it("pastes the message with input text, then types a carriage return", async () => {
+      fakeSystem({ processes: [], terminals: [] });
+
+      await TtyWriter.send(location, 'say "hi"\nnext');
+
+      expect(scripts()).toHaveLength(2);
+      expect(scripts()[0]).toContain('input text "say \\"hi\\"\\nnext" to t');
+      expect(scripts()[1]).toContain('perform action "text:\\\\x0d" on t');
+    });
+
+    it("throws when the terminal is gone", async () => {
+      fakeSystem({ processes: [], terminals: [], osascriptResult: "not_found\n" });
+
+      await expect(TtyWriter.send(location, "hello")).rejects.toThrow(
+        "Ghostty terminal not found for TTY /dev/ttys001",
+      );
+    });
+
+    // Ghostty parses `text:` with Zig escapes; AppleScript doubles each backslash.
+    it.each([
+      ["2", "text:2"],
+      ["\x1b", "text:\\\\x1b"],
+      ["\r", "text:\\\\x0d"],
+      ["\\", "text:\\\\\\\\"],
+    ])("types key %j with the Ghostty action %s", async (key, action) => {
+      fakeSystem({ processes: [], terminals: [] });
+
+      await TtyWriter.sendKey(location, key);
+
+      expect(scripts()[0]).toContain(`perform action "${action}" on t`);
+      expect(scripts()[0]).not.toContain("send key");
+    });
+  });
+});