@cueloop/daemon 0.1.0-alpha.80 → 0.1.0-alpha.82

package/src/ghostty-thread-surface.test.ts

@@ -0,0 +1,398 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Thread } from "@cueloop/schema";
+import {
+  insideGhostty,
+  openGhosttyThreadSurface as openActualGhosttyThreadSurface,
+  resolveCueloopLaunchCommand,
+  supportsGhosttyAppleScript,
+  GHOSTTY_OPEN_APPLESCRIPT,
+  type GhosttyThreadSurfacePersistence,
+} from "./ghostty-thread-surface";
+import type { GhosttyThreadSurfaceHandle } from "./ghostty-thread-surface-store";
+
+const dir = mkdtempSync(join(tmpdir(), "cueloop-ghostty-thread-surface-"));
+const openGhosttyThreadSurface: typeof openActualGhosttyThreadSurface = (
+  reviewed,
+  persistence,
+  env,
+  mode,
+  binPath,
+  platform,
+) =>
+  openActualGhosttyThreadSurface(
+    reviewed,
+    persistence,
+    env,
+    mode,
+    binPath,
+    platform,
+    "/usr/local/bin/cueloop",
+  );
+
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+
+function thread(): Thread {
+  return {
+    schemaVersion: "1",
+    id: "ses_ghostty1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan", meta: { cwd: "/repo/work" } },
+    revisions: [{ revision: 1, content: "# Plan", submittedAt: "now" }],
+    annotations: [],
+    message: null,
+    status: "pending",
+    createdAt: "now",
+  };
+}
+
+function persistence(initial: GhosttyThreadSurfaceHandle | null = null) {
+  let saved = initial;
+  let claimed = false;
+  const port: GhosttyThreadSurfacePersistence = {
+    ghosttyClaimThreadSurface: async () => {
+      if (claimed) return false;
+      claimed = true;
+
+      return true;
+    },
+    ghosttyReleaseThreadSurface: async () => {
+      claimed = false;
+    },
+    ghosttyGetThreadSurface: async () => saved,
+    ghosttySetThreadSurface: async (_id, handle) => {
+      saved = handle;
+    },
+  };
+
+  return { port, saved: () => saved };
+}
+
+function stub(
+  name: string,
+  focusResult = "focused",
+  version = "1.3.1",
+  openFails = false,
+  closeFails = false,
+) {
+  const binPath = join(dir, `${name}.sh`);
+  const logPath = join(dir, `${name}.log`);
+  const scriptPath = join(dir, `${name}.applescript`);
+  const shellPath = join(dir, `${name}.shell-command`);
+
+  writeFileSync(
+    binPath,
+    `#!/bin/sh
+if [ "$2" = 'tell application "Ghostty" to get version' ]; then
+  printf 'version\\n' >> "${logPath}"
+  printf '${version}\\n'
+  exit 0
+fi
+printf '%s\\n' "$2" > "${scriptPath}"
+case "$2" in
+  *"close candidate"*)
+    printf 'close:%s\\n' "$3" >> "${logPath}"
+    ${closeFails ? "exit 1" : ""}
+    printf 'closed\\n'
+    exit 0
+    ;;
+esac
+if [ "$3" = "ses_previous" ] || [ "$3" = "term-1" ]; then
+  printf 'focus:%s\\n' "$3" >> "${logPath}"
+  printf '${focusResult}\\n'
+  exit 0
+fi
+printf 'open:%s:%s\\n' "$3" "$4" >> "${logPath}"
+printf '%s\\n' "$5" > "${shellPath}"
+${openFails ? "exit 1" : "printf 'term-1\\n'"}
+`,
+  );
+  chmodSync(binPath, 0o755);
+
+  return { binPath, logPath, scriptPath, shellPath };
+}
+
+function log(path: string): string[] {
+  return readFileSync(path, "utf8").trim().split("\n");
+}
+
+describe("Ghostty AppleScript capability", () => {
+  test.skipIf(process.platform !== "darwin" || !existsSync("/Applications/Ghostty.app"))(
+    "open script compiles against the installed Ghostty dictionary",
+    () => {
+      const compiled = Bun.spawnSync(
+        ["osacompile", "-e", GHOSTTY_OPEN_APPLESCRIPT, "-o", join(dir, "ghostty-open.scpt")],
+        { stdout: "pipe", stderr: "pipe" },
+      );
+
+      expect(compiled.stderr.toString()).toBe("");
+      expect(compiled.exitCode).toBe(0);
+    },
+  );
+
+  test("requires the documented 1.3 API", () => {
+    expect(supportsGhosttyAppleScript("1.2.3")).toBe(false);
+    expect(supportsGhosttyAppleScript("1.3.0")).toBe(true);
+    expect(supportsGhosttyAppleScript("1.3.1")).toBe(true);
+    expect(supportsGhosttyAppleScript(null)).toBe(false);
+  });
+
+  test("detects Ghostty's own environment, not TERM alone", () => {
+    expect(insideGhostty({ TERM_PROGRAM: "ghostty" })).toBe(true);
+    expect(insideGhostty({ GHOSTTY_RESOURCES_DIR: "/Applications/Ghostty.app" })).toBe(true);
+    expect(insideGhostty({ TERM_PROGRAM: "other" })).toBe(false);
+  });
+
+  test("source CLI invocation uses its absolute entry when no cueloop binary is installed", () => {
+    const entry = join(import.meta.dir, "../../cli/src/main.ts");
+
+    expect(resolveCueloopLaunchCommand(process.execPath, entry, "")).toBe(
+      `'${process.execPath}' run '${entry}'`,
+    );
+    expect(resolveCueloopLaunchCommand(process.execPath, "/other", "")).toBeNull();
+  });
+});
+
+describe("openGhosttyThreadSurface", () => {
+  test.each(["tab", "pane", "window"] as const)("opens a focused %s", async (mode) => {
+    const native = stub(`open-${mode}`);
+    const store = persistence();
+
+    expect(
+      await openGhosttyThreadSurface(
+        thread(),
+        store.port,
+        { TERM_PROGRAM: "ghostty" },
+        mode,
+        native.binPath,
+        "darwin",
+      ),
+    ).toBe("opened");
+    expect(store.saved()).toEqual({ terminalId: "term-1" });
+    expect(log(native.logPath)).toEqual(["version", `open:${mode}:/repo/work`]);
+    const script = readFileSync(native.scriptPath, "utf8");
+
+    expect(script).toContain(
+      "set initial working directory of surfaceConfiguration to threadDirectory",
+    );
+    expect(script).toContain("input text shellCommand to createdTerminal");
+    expect(script).toContain("set targetWindow to front window");
+    expect(script).toContain(
+      "split sourceTerminal direction right with configuration surfaceConfiguration",
+    );
+    expect(script).toContain('perform action "new_tab" on sourceTerminal');
+    expect(script).toContain("focus createdTerminal");
+    expect(readFileSync(native.shellPath, "utf8").trim()).toBe(
+      "cd -- '/repo/work' && '/usr/local/bin/cueloop' 'ses_ghostty1'",
+    );
+  });
+
+  test("focuses a live terminal without creating another", async () => {
+    const native = stub("focus");
+    const store = persistence({ terminalId: "ses_previous" });
+
+    expect(
+      await openGhosttyThreadSurface(
+        thread(),
+        store.port,
+        { TERM_PROGRAM: "ghostty" },
+        "tab",
+        native.binPath,
+        "darwin",
+      ),
+    ).toBe("focused");
+    expect(log(native.logPath)).toEqual(["version", "focus:ses_previous"]);
+  });
+
+  test("focuses a live terminal even if cueloop is no longer on PATH", async () => {
+    const native = stub("focus-no-binary");
+    const store = persistence({ terminalId: "ses_previous" });
+
+    expect(
+      await openActualGhosttyThreadSurface(
+        thread(),
+        store.port,
+        { TERM_PROGRAM: "ghostty" },
+        "tab",
+        native.binPath,
+        "darwin",
+        null,
+      ),
+    ).toBe("focused");
+    expect(log(native.logPath)).toEqual(["version", "focus:ses_previous"]);
+  });
+
+  test("quotes a workspace path before entering it in a Ghostty shell", async () => {
+    const native = stub("quoted-cwd");
+    const reviewed = thread();
+
+    reviewed.artifact.meta.cwd = "/repo/it's $(unsafe)";
+    expect(
+      await openGhosttyThreadSurface(
+        reviewed,
+        persistence().port,
+        { TERM_PROGRAM: "ghostty" },
+        "tab",
+        native.binPath,
+        "darwin",
+      ),
+    ).toBe("opened");
+    expect(readFileSync(native.shellPath, "utf8").trim()).toBe(
+      "cd -- '/repo/it'\\''s $(unsafe)' && '/usr/local/bin/cueloop' 'ses_ghostty1'",
+    );
+  });
+
+  test("reopens a closed terminal and replaces its handle", async () => {
+    const native = stub("closed", "closed");
+    const store = persistence({ terminalId: "ses_previous" });
+
+    expect(
+      await openGhosttyThreadSurface(
+        thread(),
+        store.port,
+        { TERM_PROGRAM: "ghostty" },
+        "pane",
+        native.binPath,
+        "darwin",
+      ),
+    ).toBe("opened");
+    expect(store.saved()).toEqual({ terminalId: "term-1" });
+    expect(log(native.logPath)).toEqual(["version", "focus:ses_previous", "open:pane:/repo/work"]);
+  });
+
+  test("closes an untracked terminal when daemon persistence fails", async () => {
+    const native = stub("persist-failed");
+    const store: GhosttyThreadSurfacePersistence = {
+      ghosttyClaimThreadSurface: async () => true,
+      ghosttyReleaseThreadSurface: async () => {},
+      ghosttyGetThreadSurface: async () => null,
+      ghosttySetThreadSurface: async () => {
+        throw new Error("daemon unavailable");
+      },
+    };
+
+    expect(
+      await openGhosttyThreadSurface(
+        thread(),
+        store,
+        { TERM_PROGRAM: "ghostty" },
+        "tab",
+        native.binPath,
+        "darwin",
+      ),
+    ).toBe("failed");
+    expect(log(native.logPath)).toEqual(["version", "open:tab:/repo/work", "close:term-1"]);
+  });
+
+  test("does not open another tab when native identity lookup fails", async () => {
+    const native = stub("lookup-failed");
+    const store: GhosttyThreadSurfacePersistence = {
+      ghosttyClaimThreadSurface: async () => true,
+      ghosttyReleaseThreadSurface: async () => {},
+      ghosttyGetThreadSurface: async () => {
+        throw new Error("daemon unavailable");
+      },
+      ghosttySetThreadSurface: async () => {},
+    };
+
+    expect(
+      await openGhosttyThreadSurface(
+        thread(),
+        store,
+        { TERM_PROGRAM: "ghostty" },
+        "tab",
+        native.binPath,
+        "darwin",
+      ),
+    ).toBe("failed");
+    expect(log(native.logPath)).toEqual(["version"]);
+  });
+
+  test("retains the claim if an untracked native terminal cannot be closed", async () => {
+    const native = stub("close-failed", "focused", "1.3.1", false, true);
+    let claimed = false;
+    const store: GhosttyThreadSurfacePersistence = {
+      ghosttyClaimThreadSurface: async () => {
+        if (claimed) return false;
+        claimed = true;
+
+        return true;
+      },
+      ghosttyReleaseThreadSurface: async () => {
+        claimed = false;
+      },
+      ghosttyGetThreadSurface: async () => null,
+      ghosttySetThreadSurface: async () => {
+        throw new Error("daemon write failed");
+      },
+    };
+    const launch = () =>
+      openGhosttyThreadSurface(
+        thread(),
+        store,
+        { TERM_PROGRAM: "ghostty" },
+        "tab",
+        native.binPath,
+        "darwin",
+      );
+
+    expect(await launch()).toBe("failed");
+    expect(await launch()).toBe("failed");
+    expect(log(native.logPath).filter((line) => line.startsWith("open:"))).toEqual([
+      "open:tab:/repo/work",
+    ]);
+  });
+
+  test("concurrent callers cannot open duplicate live surfaces", async () => {
+    const native = stub("concurrent");
+    const store = persistence();
+    const launch = () =>
+      openGhosttyThreadSurface(
+        thread(),
+        store.port,
+        { TERM_PROGRAM: "ghostty" },
+        "tab",
+        native.binPath,
+        "darwin",
+      );
+
+    expect((await Promise.all([launch(), launch()])).toSorted()).toEqual(["failed", "opened"]);
+    expect(log(native.logPath).filter((line) => line.startsWith("open:"))).toEqual([
+      "open:tab:/repo/work",
+    ]);
+  });
+
+  test("missing capability, denied automation, and disabled placement never resolve a Thread", async () => {
+    const old = stub("old", "focused", "1.2.3");
+    const denied = stub("denied", "focused", "1.3.1", true);
+    const store = persistence();
+    const env = { TERM_PROGRAM: "ghostty" };
+
+    expect(
+      await openGhosttyThreadSurface(thread(), store.port, env, "tab", old.binPath, "darwin"),
+    ).toBe("failed");
+    expect(
+      await openGhosttyThreadSurface(thread(), store.port, env, "tab", denied.binPath, "darwin"),
+    ).toBe("failed");
+    expect(
+      await openGhosttyThreadSurface(thread(), store.port, env, "none", denied.binPath, "darwin"),
+    ).toBe("disabled");
+    expect(
+      await openGhosttyThreadSurface(thread(), store.port, {}, "tab", denied.binPath, "darwin"),
+    ).toBe("unavailable");
+    expect(
+      await openActualGhosttyThreadSurface(
+        thread(),
+        store.port,
+        env,
+        "tab",
+        denied.binPath,
+        "darwin",
+        null,
+      ),
+    ).toBe("failed");
+    expect(store.saved()).toBeNull();
+  });
+});

package/src/ghostty-thread-surface.ts

@@ -0,0 +1,267 @@
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, existsSync, statSync } from "node:fs";
+import { basename, delimiter, isAbsolute, join } from "node:path";
+import type { Thread, ThreadSurfaceOpenStatus } from "@cueloop/schema";
+import type { GhosttyThreadSurfaceHandle } from "./ghostty-thread-surface-store";
+import { loadGhosttyThreadSurface, type GhosttyThreadSurface } from "./thread-surface-config";
+
+const APPLESCRIPT_TIMEOUT_MS = 10000;
+const VERSION_SCRIPT = 'tell application "Ghostty" to get version';
+export const GHOSTTY_OPEN_APPLESCRIPT = `on run argv
+  set placement to item 1 of argv
+  set threadDirectory to item 2 of argv
+  set shellCommand to item 3 of argv
+  tell application "Ghostty"
+    if placement is "tab" then
+      set targetWindow to front window
+      set beforeCount to count of tabs of targetWindow
+      set beforeIds to id of every tab of targetWindow
+      set sourceTerminal to focused terminal of selected tab of targetWindow
+      if not (perform action "new_tab" on sourceTerminal) then error "Ghostty rejected new_tab"
+      repeat 50 times
+        if (count of tabs of targetWindow) > beforeCount then exit repeat
+        delay 0.1
+      end repeat
+      if (count of tabs of targetWindow) <= beforeCount then error "Ghostty did not create a tab"
+      set newTabs to {}
+      repeat with candidateTab in tabs of targetWindow
+        if (id of candidateTab) is not in beforeIds then set end of newTabs to candidateTab
+      end repeat
+      if (count of newTabs) is not 1 then error "Ghostty tab identity is ambiguous"
+      set createdTab to item 1 of newTabs
+      set createdTerminal to focused terminal of createdTab
+    else
+      set surfaceConfiguration to new surface configuration
+      set initial working directory of surfaceConfiguration to threadDirectory
+      if placement is "window" then
+        set createdWindow to new window with configuration surfaceConfiguration
+        set createdTerminal to focused terminal of selected tab of createdWindow
+      else
+        set targetWindow to front window
+        set sourceTerminal to focused terminal of selected tab of targetWindow
+        set createdTerminal to split sourceTerminal direction right with configuration surfaceConfiguration
+      end if
+    end if
+    try
+      repeat 50 times
+        if (name of createdTerminal) is not "👻" and (name of createdTerminal) is not "" then exit repeat
+        delay 0.1
+      end repeat
+      if (name of createdTerminal) is "👻" or (name of createdTerminal) is "" then error "Ghostty surface has no shell"
+      input text shellCommand to createdTerminal
+      send key "enter" to createdTerminal
+      focus createdTerminal
+      return id of createdTerminal
+    on error
+      if placement is "tab" then
+        close tab createdTab
+      else if placement is "window" then
+        close window createdWindow
+      else
+        close createdTerminal
+      end if
+      error "Ghostty surface did not launch the Thread"
+    end try
+  end tell
+end run`;
+const FOCUS_SCRIPT = `on run argv
+  set targetId to item 1 of argv
+  tell application "Ghostty"
+    repeat with candidate in terminals
+      if (id of candidate) is targetId then
+        focus candidate
+        return "focused"
+      end if
+    end repeat
+  end tell
+  return "closed"
+end run`;
+const CLOSE_SCRIPT = `on run argv
+  set targetId to item 1 of argv
+  tell application "Ghostty"
+    repeat with candidate in terminals
+      if (id of candidate) is targetId then
+        close candidate
+        return "closed"
+      end if
+    end repeat
+  end tell
+  return "absent"
+end run`;
+
+export interface GhosttyThreadSurfacePersistence {
+  ghosttyClaimThreadSurface(threadId: string): Promise<boolean>;
+  ghosttyReleaseThreadSurface(threadId: string): Promise<void>;
+  ghosttyGetThreadSurface(threadId: string): Promise<GhosttyThreadSurfaceHandle | null>;
+  ghosttySetThreadSurface(threadId: string, handle: GhosttyThreadSurfaceHandle): Promise<void>;
+}
+
+export interface GhosttyEnv {
+  [name: string]: string | undefined;
+  TERM_PROGRAM?: string;
+  GHOSTTY_RESOURCES_DIR?: string;
+}
+
+interface GhosttyLaunchResult {
+  status: ThreadSurfaceOpenStatus;
+  retainClaim: boolean;
+}
+
+function runAppleScript(binPath: string, script: string, args: string[] = []): string | null {
+  try {
+    const result = spawnSync(binPath, ["-e", script, ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: APPLESCRIPT_TIMEOUT_MS,
+    });
+
+    return result.status === 0 ? result.stdout.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+export function resolveCueloopLaunchCommand(
+  executable = process.execPath,
+  entry = process.argv[1],
+  path = process.env.PATH,
+): string | null {
+  if (basename(executable) === "cueloop") return shellQuote(executable);
+
+  if (
+    entry &&
+    isAbsolute(entry) &&
+    entry.endsWith(join("packages", "cli", "src", "main.ts")) &&
+    existsSync(entry)
+  ) {
+    return `${shellQuote(executable)} run ${shellQuote(entry)}`;
+  }
+
+  for (const directory of path?.split(delimiter) ?? []) {
+    if (!isAbsolute(directory)) continue;
+    const candidate = join(directory, "cueloop");
+
+    try {
+      accessSync(candidate, constants.X_OK);
+      if (statSync(candidate).isFile()) return shellQuote(candidate);
+    } catch {
+      // A PATH entry without an executable cannot launch the Thread.
+    }
+  }
+
+  return null;
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+/** Ghostty 1.3.0 introduced the native AppleScript commands used here. */
+export function supportsGhosttyAppleScript(version: string | null): boolean {
+  const parsed = version?.match(/^(\d+)\.(\d+)\.(\d+)/);
+
+  if (!parsed) return false;
+  const major = Number(parsed[1]);
+  const minor = Number(parsed[2]);
+
+  return major > 1 || (major === 1 && minor >= 3);
+}
+
+/** Herdr selection happens before this adapter, even when it runs inside Ghostty. */
+export function insideGhostty(env: GhosttyEnv = process.env): boolean {
+  return env.TERM_PROGRAM?.toLowerCase() === "ghostty" || Boolean(env.GHOSTTY_RESOURCES_DIR);
+}
+
+/** Reuse a live Ghostty terminal, reopen a closed one, or leave the Thread pending. */
+export async function openGhosttyThreadSurface(
+  thread: Thread,
+  persistence: GhosttyThreadSurfacePersistence,
+  env: GhosttyEnv = process.env,
+  mode: GhosttyThreadSurface = loadGhosttyThreadSurface(),
+  binPath = "osascript",
+  platform: NodeJS.Platform = process.platform,
+  cueloopBinPath?: string | null,
+): Promise<ThreadSurfaceOpenStatus> {
+  if (platform !== "darwin" || !insideGhostty(env)) return "unavailable";
+  if (mode === "none") return "disabled";
+  if (!supportsGhosttyAppleScript(runAppleScript(binPath, VERSION_SCRIPT))) return "failed";
+
+  try {
+    if (!(await persistence.ghosttyClaimThreadSurface(thread.id))) return "failed";
+  } catch {
+    return "failed";
+  }
+
+  let result: GhosttyLaunchResult;
+
+  try {
+    result = await openClaimedGhosttyThreadSurface(
+      thread,
+      persistence,
+      mode,
+      binPath,
+      cueloopBinPath,
+    );
+  } catch {
+    result = { status: "failed", retainClaim: true };
+  }
+
+  if (result.retainClaim) return "failed";
+
+  try {
+    await persistence.ghosttyReleaseThreadSurface(thread.id);
+  } catch {
+    return "failed";
+  }
+
+  return result.status;
+}
+
+async function openClaimedGhosttyThreadSurface(
+  thread: Thread,
+  persistence: GhosttyThreadSurfacePersistence,
+  mode: Exclude<GhosttyThreadSurface, "none">,
+  binPath: string,
+  cueloopBinPath?: string | null,
+): Promise<GhosttyLaunchResult> {
+  let recorded: GhosttyThreadSurfaceHandle | null;
+
+  try {
+    recorded = await persistence.ghosttyGetThreadSurface(thread.id);
+  } catch {
+    return { status: "failed", retainClaim: false };
+  }
+
+  if (recorded) {
+    const result = runAppleScript(binPath, FOCUS_SCRIPT, [recorded.terminalId]);
+
+    if (result === "focused") return { status: "focused", retainClaim: false };
+    if (result !== "closed") return { status: "failed", retainClaim: false };
+  }
+
+  const launchCommand =
+    cueloopBinPath === undefined
+      ? resolveCueloopLaunchCommand()
+      : cueloopBinPath && shellQuote(cueloopBinPath);
+
+  if (!launchCommand) return { status: "failed", retainClaim: false };
+
+  const cwd = thread.artifact.meta.cwd ?? thread.workspace.repoRoot;
+  const terminalId = runAppleScript(binPath, GHOSTTY_OPEN_APPLESCRIPT, [
+    mode,
+    cwd,
+    `cd -- ${shellQuote(cwd)} && ${launchCommand} ${shellQuote(thread.id)}`,
+  ]);
+
+  if (!terminalId) return { status: "failed", retainClaim: false };
+
+  try {
+    await persistence.ghosttySetThreadSurface(thread.id, { terminalId });
+  } catch {
+    const closed = runAppleScript(binPath, CLOSE_SCRIPT, [terminalId]);
+
+    return { status: "failed", retainClaim: closed !== "closed" && closed !== "absent" };
+  }
+
+  return { status: "opened", retainClaim: false };
+}

package/src/harness-delivery.test.ts

@@ -34,6 +34,21 @@ function createPlan(instance: DaemonCore) {
 }
 
 describe("durable harness delivery", () => {
+  test("reload finds only bindings for the active harness conversation", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const current = first.harnessBind({
+      threadId: thread.id,
+      harness: "pi",
+      harnessSessionId: "pi-current",
+    });
+
+    first.harnessBind({ threadId: thread.id, harness: "pi", harnessSessionId: "pi-other" });
+    first.harnessBind({ threadId: thread.id, harness: "codex", harnessSessionId: "pi-current" });
+
+    expect(core().harnessBindingsForSession("pi", "pi-current")).toEqual([current]);
+  });
+
   test("redelivers after reload until the harness acknowledges the Message", () => {
     const first = core();
     const thread = createPlan(first);