@bastani/atomic 0.6.0-0 → 0.6.1-0

package/src/commands/cli/footer.tsx

@@ -4,25 +4,43 @@
  * tmux window. The executor splits each agent window after creation and
  * runs `atomic _footer --name <window-name>` in the bottom pane.
  *
- * Setting `exitOnCtrlC: false` suppresses OpenTUI's built-in signal
- * handling, so we install our own teardown path. In the tmux case the
- * closed pty raises SIGPIPE on the next render, which hits our handler.
- * The parent-liveness watchdog is a portable fallback for the orphan case
- * where no signal arrives (process gets reparented to init/unknown).
+ * The footer is rendered through OpenTUI's headless renderer and repainted
+ * into the footer pane. A normal CLI renderer must not be used here:
+ * terminal capability probes from a footer pane can be answered by the
+ * attached client and routed by tmux into the active agent pane as input.
  */
 
-import { useEffect } from "react";
-import { createCliRenderer } from "@opentui/core";
-import { createRoot, useRenderer } from "@opentui/react";
+import {
+  getBaseAttributes,
+  TextAttributes,
+  type CapturedFrame,
+  type CapturedSpan,
+} from "@opentui/core";
+import { testRender } from "@opentui/react/test-utils";
+import { act } from "react";
 import { resolveTheme } from "../../sdk/runtime/theme.ts";
 import {
   deriveGraphTheme,
-  type GraphTheme,
 } from "../../sdk/components/graph-theme.ts";
 import { AttachedStatusline } from "../../sdk/components/attached-statusline.tsx";
 import type { AgentType } from "../../sdk/types.ts";
 
 const PARENT_WATCHDOG_MS = 2000;
+const FOOTER_RENDER_INTERVAL_MS = 250;
+const FOOTER_RENDER_ROWS = 1;
+const CLEAR_LINE = "\r\x1b[2K";
+
+type FooterOutput = {
+  columns?: number;
+  write(chunk: string): unknown;
+};
+
+type FooterRendererOptions = {
+  name: string;
+  agentType?: AgentType;
+  stdout?: FooterOutput;
+  onReady?: () => void;
+};
 
 /**
  * Snapshot the parent PID at module load. `process.ppid` is cached in both
@@ -59,74 +77,172 @@ const EXIT_SIGNALS: NodeJS.Signals[] =
     ? ["SIGTERM", "SIGINT", "SIGBREAK", "SIGHUP"]
     : ["SIGHUP", "SIGTERM", "SIGINT", "SIGPIPE"];
 
-function FooterShell({
+const ANSI_RESET = "\x1b[0m";
+
+function ansiColor(kind: 38 | 48, spanColor: CapturedSpan["fg"]): string {
+  const [r, g, b] = spanColor.toInts();
+  return `${kind};2;${r};${g};${b}`;
+}
+
+function sanitizeText(text: string): string {
+  return text.replace(/[\x00-\x1f\x7f]/g, " ");
+}
+
+function spanToAnsi(span: CapturedSpan): string {
+  const attrs = getBaseAttributes(span.attributes);
+  const codes = [
+    ansiColor(38, span.fg),
+    ansiColor(48, span.bg),
+  ];
+
+  if ((attrs & TextAttributes.BOLD) !== 0) codes.unshift("1");
+  if ((attrs & TextAttributes.DIM) !== 0) codes.unshift("2");
+  if ((attrs & TextAttributes.ITALIC) !== 0) codes.unshift("3");
+  if ((attrs & TextAttributes.UNDERLINE) !== 0) codes.unshift("4");
+  if ((attrs & TextAttributes.INVERSE) !== 0) codes.unshift("7");
+
+  return `\x1b[${codes.join(";")}m${sanitizeText(span.text)}`;
+}
+
+function frameToAnsi(frame: CapturedFrame): string {
+  const lines = frame.lines.map((line) =>
+    line.spans.map(spanToAnsi).join("")
+  );
+  return `${lines.join("\n")}${ANSI_RESET}`;
+}
+
+async function createFooterTestRenderer({
   name,
-  theme,
   agentType,
+  width = process.stdout.columns ?? 80,
 }: {
   name: string;
-  theme: GraphTheme;
   agentType?: AgentType;
+  width?: number;
 }) {
-  const renderer = useRenderer();
+  const theme = deriveGraphTheme(resolveTheme(null));
+  return await testRender(
+    <AttachedStatusline name={name} theme={theme} agentType={agentType} />,
+    {
+      width: Math.max(width, 1),
+      height: FOOTER_RENDER_ROWS,
+      exitOnCtrlC: false,
+      exitSignals: [],
+      clearOnShutdown: false,
+      useMouse: false,
+      useKittyKeyboard: null,
+      openConsoleOnError: false,
+    },
+  );
+}
+
+async function renderFooterSetupFrame(
+  testSetup: Awaited<ReturnType<typeof createFooterTestRenderer>>,
+): Promise<string> {
+  await act(async () => {
+    await testSetup.renderOnce();
+  });
+  return frameToAnsi(testSetup.captureSpans());
+}
+
+export async function renderFooterFrame({
+  name,
+  agentType,
+  width = process.stdout.columns ?? 80,
+}: {
+  name: string;
+  agentType?: AgentType;
+  width?: number;
+}): Promise<string> {
+  const testSetup = await createFooterTestRenderer({ name, agentType, width });
+  try {
+    return await renderFooterSetupFrame(testSetup);
+  } finally {
+    act(() => {
+      testSetup.renderer.destroy();
+    });
+  }
+}
+
+export async function runFooterRenderer({
+  name,
+  agentType,
+  stdout = process.stdout,
+  onReady,
+}: FooterRendererOptions): Promise<void> {
+  const testSetup = await createFooterTestRenderer({
+    name,
+    agentType,
+    width: stdout.columns,
+  });
+  let currentWidth = Math.max(stdout.columns ?? 80, 1);
+  let lastFrame = "";
+  let renderInFlight = false;
+  let tornDown = false;
+  let teardown!: () => void;
+
+  const render = async () => {
+    if (tornDown || renderInFlight) return;
+    renderInFlight = true;
+    try {
+      const nextWidth = Math.max(stdout.columns ?? 80, 1);
+      if (nextWidth !== currentWidth) {
+        currentWidth = nextWidth;
+        testSetup.resize(currentWidth, FOOTER_RENDER_ROWS);
+      }
 
-  useEffect(() => {
-    let tornDown = false;
-    const teardown = () => {
+      const frame = await renderFooterSetupFrame(testSetup);
+      if (!tornDown && frame !== lastFrame) {
+        stdout.write(`${CLEAR_LINE}${frame}`);
+        lastFrame = frame;
+      }
+    } finally {
+      renderInFlight = false;
+    }
+  };
+
+  await render();
+
+  await new Promise<void>((resolve) => {
+    teardown = () => {
       if (tornDown) return;
       tornDown = true;
-      try {
-        renderer.destroy();
-      } catch {
-        // renderer may already be mid-destroy; the pty is likely gone
+      for (const sig of EXIT_SIGNALS) {
+        process.off(sig, teardown);
       }
-      // Pane pty is already closed by the time we reach here, so there is
-      // no terminal state left to preserve. Exit explicitly in case
-      // destroy() doesn't (e.g. when stdout writes fail silently).
-      process.exit(0);
+      process.off("SIGWINCH", requestRender);
+      clearInterval(renderTick);
+      clearInterval(watchdog);
+      act(() => {
+        testSetup.renderer.destroy();
+      });
+      resolve();
     };
+
+    const requestRender = () => {
+      void render();
+    };
+
     for (const sig of EXIT_SIGNALS) {
       process.on(sig, teardown);
     }
+    process.on("SIGWINCH", requestRender);
 
+    const renderTick = setInterval(() => {
+      void render();
+    }, FOOTER_RENDER_INTERVAL_MS);
     const watchdog = setInterval(() => {
       if (!originalParentAlive()) teardown();
     }, PARENT_WATCHDOG_MS);
-    watchdog.unref?.();
-
-    return () => {
-      for (const sig of EXIT_SIGNALS) {
-        process.off(sig, teardown);
-      }
-      clearInterval(watchdog);
-    };
-  }, [renderer]);
-
-  return (
-    <box
-      width="100%"
-      height="100%"
-      flexDirection="column"
-      justifyContent="flex-end"
-      backgroundColor={theme.background}
-    >
-      <AttachedStatusline name={name} theme={theme} agentType={agentType} />
-    </box>
-  );
+    onReady?.();
+  });
 }
 
 export async function footerCommand(
   name: string,
   agentType?: AgentType,
+  options: Omit<FooterRendererOptions, "name" | "agentType"> = {},
 ): Promise<number> {
-  const renderer = await createCliRenderer({
-    exitOnCtrlC: false,
-  });
-  const theme = deriveGraphTheme(resolveTheme(renderer.themeMode));
-  createRoot(renderer).render(
-    <FooterShell name={name} theme={theme} agentType={agentType} />,
-  );
-
-  await new Promise<void>(() => {});
+  await runFooterRenderer({ name, agentType, ...options });
   return 0;
 }

package/src/lib/spawn.test.ts

@@ -0,0 +1,109 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  hasRequiredMuxBinary,
+  isMuxBinaryRequiredForPlatform,
+  prependPath,
+  psmuxReleaseAssetSuffix,
+  requiredMuxBinaryCandidatesForPlatform,
+  resolveCommandFromCurrentPath,
+  runCommand,
+} from "./spawn.ts";
+
+describe("spawn PATH helpers", () => {
+  let originalPath: string | undefined;
+  let tempDir: string;
+
+  beforeEach(() => {
+    originalPath = process.env.PATH;
+    tempDir = mkdtempSync(join(tmpdir(), "atomic-spawn-"));
+  });
+
+  afterEach(() => {
+    process.env.PATH = originalPath;
+    rmSync(tempDir, { force: true, recursive: true });
+  });
+
+  test("resolves commands added to PATH during the current process", () => {
+    const commandName = process.platform === "win32"
+      ? "atomic-spawn-test.cmd"
+      : "atomic-spawn-test";
+    const commandPath = join(tempDir, commandName);
+    const body = process.platform === "win32" ? "@echo off\r\n" : "#!/bin/sh\n";
+
+    writeFileSync(commandPath, body);
+    chmodSync(commandPath, 0o755);
+
+    process.env.PATH = originalPath ?? "";
+    prependPath(tempDir);
+
+    expect(resolveCommandFromCurrentPath("atomic-spawn-test")).toBe(commandPath);
+  });
+
+  test("requires native psmux binaries on Windows", () => {
+    expect(requiredMuxBinaryCandidatesForPlatform("win32")).toEqual([
+      "psmux",
+      "pmux",
+    ]);
+    expect(isMuxBinaryRequiredForPlatform("psmux", "win32")).toBe(true);
+    expect(isMuxBinaryRequiredForPlatform("pmux", "win32")).toBe(true);
+    expect(isMuxBinaryRequiredForPlatform("tmux", "win32")).toBe(false);
+  });
+
+  test("requires tmux on Unix-like platforms", () => {
+    expect(requiredMuxBinaryCandidatesForPlatform("linux")).toEqual(["tmux"]);
+    expect(requiredMuxBinaryCandidatesForPlatform("darwin")).toEqual(["tmux"]);
+    expect(isMuxBinaryRequiredForPlatform("tmux", "linux")).toBe(true);
+    expect(isMuxBinaryRequiredForPlatform("psmux", "linux")).toBe(false);
+    expect(isMuxBinaryRequiredForPlatform("pmux", "darwin")).toBe(false);
+  });
+
+  test("maps supported Windows architectures to psmux release assets", () => {
+    expect(psmuxReleaseAssetSuffix("x64")).toBe("windows-x64.zip");
+    expect(psmuxReleaseAssetSuffix("ia32")).toBe("windows-x86.zip");
+    expect(psmuxReleaseAssetSuffix("arm64")).toBe("windows-arm64.zip");
+    expect(psmuxReleaseAssetSuffix("arm")).toBeNull();
+  });
+
+  test("uses platform requirement when checking PATH", () => {
+    const commandPath = join(tempDir, "tmux");
+
+    writeFileSync(commandPath, "#!/bin/sh\n");
+    chmodSync(commandPath, 0o755);
+
+    process.env.PATH = tempDir;
+
+    expect(hasRequiredMuxBinary()).toBe(process.platform !== "win32");
+  });
+
+  test("does not add duplicate PATH entries", () => {
+    process.env.PATH = originalPath ?? "";
+
+    prependPath(tempDir);
+    prependPath(tempDir);
+
+    const delimiter = process.platform === "win32" ? ";" : ":";
+    const entries = (process.env.PATH ?? "").split(delimiter);
+    expect(entries.filter((entry) => entry === tempDir)).toHaveLength(1);
+  });
+
+  test("runCommand keeps stdout and stderr separate", async () => {
+    const scriptPath = join(tempDir, "streams.ts");
+    writeFileSync(
+      scriptPath,
+      "await Bun.write(Bun.stderr, 'warning\\n'); await Bun.write(Bun.stdout, 'value\\n');\n",
+    );
+
+    const result = await runCommand([
+      process.execPath,
+      scriptPath,
+    ]);
+
+    expect(result.success).toBe(true);
+    expect(result.details).toBe("warning");
+    expect(result.stderr).toBe("warning");
+    expect(result.stdout).toBe("value");
+  });
+});