assistant-ui 0.0.111 → 0.0.113

package/src/lib/run-spawn.test.ts

@@ -0,0 +1,148 @@
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  spawn: vi.fn(),
+}));
+
+vi.mock("cross-spawn", async (importOriginal) => ({
+  ...(await importOriginal()),
+  spawn: mocks.spawn,
+}));
+
+import {
+  hasActiveSpawn,
+  runSpawn,
+  runSpawnCapture,
+  SpawnExitError,
+  SpawnSignalError,
+} from "./run-spawn";
+
+const createChild = () =>
+  Object.assign(new EventEmitter(), {
+    kill: vi.fn(() => true),
+  });
+
+const trackSignal = (signal: NodeJS.Signals) => {
+  const before = new Set(process.listeners(signal));
+  return {
+    count: before.size,
+    added: () =>
+      process.listeners(signal).find((listener) => !before.has(listener)),
+  };
+};
+
+describe("runSpawn", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  });
+
+  it("forwards the first termination signal and cleans up listeners", async () => {
+    const child = createChild();
+    mocks.spawn.mockReturnValue(child);
+    const sigterm = trackSignal("SIGTERM");
+    const result = runSpawn("assistant-ui", ["create"]);
+    const signalHandler = sigterm.added();
+
+    expect(signalHandler).toBeDefined();
+    signalHandler?.("SIGTERM");
+    expect(child.kill).toHaveBeenCalledWith("SIGTERM");
+
+    child.emit("close", null, "SIGTERM");
+    await expect(result).rejects.toMatchObject({
+      signal: "SIGTERM",
+      forwarded: true,
+    });
+    expect(process.listenerCount("SIGTERM")).toBe(sigterm.count);
+  });
+
+  it("escalates a repeated termination signal", async () => {
+    const child = createChild();
+    mocks.spawn.mockReturnValue(child);
+    const sigterm = trackSignal("SIGTERM");
+    const result = runSpawn("assistant-ui", ["create"]);
+    const signalHandler = sigterm.added();
+
+    expect(signalHandler).toBeDefined();
+    signalHandler?.("SIGTERM");
+    signalHandler?.("SIGTERM");
+
+    expect(child.kill).toHaveBeenNthCalledWith(1, "SIGTERM");
+    expect(child.kill).toHaveBeenNthCalledWith(2, "SIGKILL");
+    await expect(result).rejects.toBeInstanceOf(SpawnSignalError);
+    expect(process.listenerCount("SIGTERM")).toBe(sigterm.count);
+  });
+
+  it("reports an active spawn only while the child is running", async () => {
+    const child = createChild();
+    mocks.spawn.mockReturnValue(child);
+
+    expect(hasActiveSpawn()).toBe(false);
+    const result = runSpawn("assistant-ui", ["create"]);
+    expect(hasActiveSpawn()).toBe(true);
+
+    child.emit("close", 0, null);
+    await result;
+
+    expect(hasActiveSpawn()).toBe(false);
+  });
+
+  it("preserves normal child exit handling", async () => {
+    const child = createChild();
+    mocks.spawn.mockReturnValue(child);
+    const result = runSpawn("assistant-ui", ["create"]);
+
+    child.emit("close", 0, null);
+
+    await expect(result).resolves.toBeUndefined();
+  });
+
+  it("reports nonzero child exits", async () => {
+    const child = createChild();
+    mocks.spawn.mockReturnValue(child);
+    const result = runSpawn("assistant-ui", ["create"]);
+
+    child.emit("close", 7, null);
+
+    await expect(result).rejects.toEqual(expect.any(SpawnExitError));
+    await expect(result).rejects.toMatchObject({ code: 7 });
+  });
+
+  it("distinguishes child signals from forwarded signals", async () => {
+    const child = createChild();
+    mocks.spawn.mockReturnValue(child);
+    const result = runSpawn("assistant-ui", ["create"]);
+
+    child.emit("close", null, "SIGSEGV");
+
+    await expect(result).rejects.toMatchObject({
+      signal: "SIGSEGV",
+      forwarded: false,
+    });
+  });
+
+  it("captures output without blocking the event loop", async () => {
+    const child = Object.assign(new EventEmitter(), {
+      kill: vi.fn(() => true),
+      stdout: new PassThrough(),
+      stderr: new PassThrough(),
+    });
+    mocks.spawn.mockReturnValue(child);
+    const result = runSpawnCapture("jscodeshift", ["--version"]);
+
+    child.stdout.write("Processing file one\n");
+    child.stderr.write("warning\n");
+    child.stdout.end();
+    child.stderr.end();
+    child.emit("close", 0, null);
+
+    await expect(result).resolves.toMatchObject({
+      code: 0,
+      signal: null,
+      stdout: "Processing file one\n",
+      stderr: "warning\n",
+    });
+  });
+});

package/src/lib/run-spawn.ts

@@ -2,31 +2,141 @@ import { spawn } from "cross-spawn";
 
 export class SpawnExitError extends Error {
   code: number;
+  stderr: string;
 
-  constructor(code: number) {
-    super(`Process exited with code ${code}`);
+  constructor(code: number, stderr = "") {
+    super(
+      stderr
+        ? `Process exited with code ${code}\n${stderr}`
+        : `Process exited with code ${code}`,
+    );
     this.code = code;
+    this.stderr = stderr;
   }
 }
 
-export function runSpawn(
+export class SpawnSignalError extends Error {
+  signal: NodeJS.Signals;
+  forwarded: boolean;
+
+  constructor(signal: NodeJS.Signals, forwarded: boolean) {
+    super(`Process terminated by ${signal}`);
+    this.signal = signal;
+    this.forwarded = forwarded;
+  }
+}
+
+export interface SpawnResult {
+  code: number | null;
+  signal: NodeJS.Signals | null;
+  stdout: string;
+  stderr: string;
+}
+
+let activeSpawns = 0;
+
+// A spawn that is forwarding a signal owns termination for that window, so
+// callers with their own cleanup listeners defer to it instead of racing it.
+export const hasActiveSpawn = (): boolean => activeSpawns > 0;
+
+function spawnProcess(
   command: string,
   args: string[],
-  cwd?: string,
-): Promise<void> {
+  cwd: string | undefined,
+  captureOutput: boolean,
+): Promise<SpawnResult> {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
-      stdio: "inherit",
+      stdio: captureOutput ? ["ignore", "pipe", "pipe"] : "inherit",
       cwd,
     });
+    let forwardedSignal: NodeJS.Signals | null = null;
+    let settled = false;
+    let stdout = "";
+    let stderr = "";
+
+    if (captureOutput) {
+      child.stdout?.setEncoding("utf8");
+      child.stdout?.on("data", (chunk: string) => {
+        stdout += chunk;
+      });
+      child.stderr?.setEncoding("utf8");
+      child.stderr?.on("data", (chunk: string) => {
+        stderr += chunk;
+      });
+    }
+
+    const cleanup = () => {
+      activeSpawns -= 1;
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+    };
+
+    const rejectWithSignal = (signal: NodeJS.Signals) => {
+      settled = true;
+      cleanup();
+      reject(new SpawnSignalError(signal, forwardedSignal !== null));
+    };
+
+    const forwardSignal = (signal: NodeJS.Signals) => {
+      if (forwardedSignal !== null) {
+        child.kill("SIGKILL");
+        rejectWithSignal(forwardedSignal);
+        return;
+      }
+
+      forwardedSignal = signal;
+      child.kill(signal);
+    };
+    const onSigint = () => forwardSignal("SIGINT");
+    const onSigterm = () => forwardSignal("SIGTERM");
 
-    child.on("error", (error) => reject(error));
-    child.on("close", (code) => {
-      if (code !== 0) {
-        reject(new SpawnExitError(code || 1));
+    activeSpawns += 1;
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (forwardedSignal !== null) {
+        reject(new SpawnSignalError(forwardedSignal, true));
       } else {
-        resolve();
+        reject(error);
+      }
+    });
+    child.on("close", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (forwardedSignal !== null) {
+        reject(new SpawnSignalError(forwardedSignal, true));
+      } else {
+        resolve({ code, signal: signal ?? null, stdout, stderr });
       }
     });
   });
 }
+
+export function runSpawn(
+  command: string,
+  args: string[],
+  cwd?: string,
+): Promise<void> {
+  return spawnProcess(command, args, cwd, false).then(({ code, signal }) => {
+    if (signal != null) {
+      throw new SpawnSignalError(signal, false);
+    }
+    if (code !== 0) {
+      throw new SpawnExitError(code || 1);
+    }
+  });
+}
+
+export function runSpawnCapture(
+  command: string,
+  args: string[],
+  cwd?: string,
+): Promise<SpawnResult> {
+  return spawnProcess(command, args, cwd, true);
+}

package/src/lib/transform.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  runSpawnCapture: vi.fn(),
+}));
+
+vi.mock("./run-spawn", async (importOriginal) => ({
+  ...(await importOriginal()),
+  runSpawnCapture: mocks.runSpawnCapture,
+}));
+
+import { transform } from "./transform";
+import { SpawnExitError } from "./run-spawn";
+
+describe("transform", () => {
+  it("runs codemods asynchronously and reports progress", async () => {
+    mocks.runSpawnCapture.mockResolvedValue({
+      code: 0,
+      signal: null,
+      stdout: "Processing file one\nProcessing file two\n",
+      stderr: "",
+    });
+    const onProgress = vi.fn();
+
+    const errors = await transform(
+      "v0-8/ui-package-split",
+      "/tmp/project",
+      { dry: true },
+      {
+        logStatus: false,
+        onProgress,
+        relevantFiles: ["/tmp/project/app.tsx"],
+      },
+    );
+
+    expect(errors).toEqual([]);
+    expect(onProgress).toHaveBeenCalledWith(2);
+    expect(mocks.runSpawnCapture).toHaveBeenCalledWith(
+      "npx",
+      expect.arrayContaining(["jscodeshift", "--dry"]),
+    );
+  });
+
+  it("surfaces the codemod's stderr when it exits nonzero", async () => {
+    mocks.runSpawnCapture.mockResolvedValue({
+      code: 1,
+      signal: null,
+      stdout: "",
+      stderr: "SyntaxError: Unexpected token\n",
+    });
+
+    const failure = transform(
+      "v0-8/ui-package-split",
+      "/tmp/project",
+      { dry: true },
+      { logStatus: false, relevantFiles: ["/tmp/project/app.tsx"] },
+    );
+
+    await expect(failure).rejects.toBeInstanceOf(SpawnExitError);
+    await expect(failure).rejects.toThrow("SyntaxError: Unexpected token");
+  });
+});

package/src/lib/transform.ts

@@ -1,10 +1,10 @@
-import { execFileSync, spawnSync } from "node:child_process";
 import debug from "debug";
 import path from "node:path";
 import type { TransformOptions } from "./transform-options";
 import { fileURLToPath } from "node:url";
 import * as fs from "node:fs";
 import { sync as globSync } from "glob";
+import { runSpawnCapture, SpawnExitError, SpawnSignalError } from "./run-spawn";
 
 const log = debug("codemod:transform");
 const error = debug("codemod:transform:error");
@@ -106,7 +106,7 @@ function parseErrors(transform: string, output: string): TransformErrors {
   return errors;
 }
 
-export function transform(
+export async function transform(
   codemod: string,
   source: string,
   transformOptions: TransformOptions,
@@ -115,7 +115,7 @@ export function transform(
     onProgress?: (processedFiles: number) => void;
     relevantFiles?: string[];
   } = { logStatus: true },
-): TransformErrors {
+): Promise<TransformErrors> {
   if (options.logStatus) {
     log(`Applying codemod '${codemod}': ${source}`);
   }
@@ -133,44 +133,28 @@ export function transform(
 
   const command = buildCommand(codemodPath, targetFiles, transformOptions);
 
-  // Use spawn instead of execFileSync to capture output in real-time
-  if (options.onProgress) {
-    const result = spawnSync(command[0]!, command.slice(1), {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-    });
+  const result = await runSpawnCapture(command[0]!, command.slice(1));
+  if (result.signal !== null) {
+    throw new SpawnSignalError(result.signal, false);
+  }
+  if (!options.onProgress && result.code !== 0) {
+    throw new SpawnExitError(result.code || 1, result.stderr);
+  }
 
-    const stdout = result.stdout || "";
+  const { stdout } = result;
 
-    // Count the number of processed files from the output
+  if (options.onProgress) {
     const processedFiles = (stdout.match(/Processing file/g) || []).length;
-    if (options.onProgress) {
-      options.onProgress(processedFiles);
-    }
+    options.onProgress(processedFiles);
+  }
 
-    const errors = parseErrors(codemod, stdout);
-    if (options.logStatus && errors.length > 0) {
-      errors.forEach(({ transform, filename, summary }) => {
-        error(
-          `Error applying codemod [codemod=${transform}, path=${filename}, summary=${summary}]`,
-        );
-      });
-    }
-    return errors;
-  } else {
-    // Use the original synchronous approach if no progress callback
-    const stdout = execFileSync(command[0]!, command.slice(1), {
-      encoding: "utf8",
-      stdio: "pipe",
+  const errors = parseErrors(codemod, stdout);
+  if (options.logStatus && errors.length > 0) {
+    errors.forEach(({ transform, filename, summary }) => {
+      error(
+        `Error applying codemod [codemod=${transform}, path=${filename}, summary=${summary}]`,
+      );
     });
-    const errors = parseErrors(codemod, stdout);
-    if (options.logStatus && errors.length > 0) {
-      errors.forEach(({ transform, filename, summary }) => {
-        error(
-          `Error applying codemod [codemod=${transform}, path=${filename}, summary=${summary}]`,
-        );
-      });
-    }
-    return errors;
   }
+  return errors;
 }

package/src/lib/upgrade.ts

@@ -42,6 +42,7 @@ export async function upgrade(options: TransformOptions) {
     {
       format: "Progress |{bar}| {percentage}% | ETA: {eta}s || {status}",
       hideCursor: true,
+      gracefulExit: true,
     },
     Presets.shades_classic,
   );
@@ -49,28 +50,31 @@ export async function upgrade(options: TransformOptions) {
   bar.start(totalWork, 0, { status: "Starting..." });
   const allErrors: TransformErrors = [];
 
-  for (const codemod of bundle) {
-    bar.update(completedWork, { status: `Running ${codemod}...` });
+  try {
+    for (const codemod of bundle) {
+      bar.update(completedWork, { status: `Running ${codemod}...` });
 
-    // Use a custom progress callback to update the progress bar
-    const errors = transform(codemod, cwd, options, {
-      logStatus: false,
-      onProgress: (processedFiles: number) => {
-        completedWork = bundle.indexOf(codemod) * fileCount + processedFiles;
-        bar.update(Math.min(completedWork, totalWork), {
-          status: `Running ${codemod} (${processedFiles}/${fileCount} files)`,
-        });
-      },
-      relevantFiles, // Pass the pre-computed relevant files
-    });
+      // Use a custom progress callback to update the progress bar
+      const errors = await transform(codemod, cwd, options, {
+        logStatus: false,
+        onProgress: (processedFiles: number) => {
+          completedWork = bundle.indexOf(codemod) * fileCount + processedFiles;
+          bar.update(Math.min(completedWork, totalWork), {
+            status: `Running ${codemod} (${processedFiles}/${fileCount} files)`,
+          });
+        },
+        relevantFiles, // Pass the pre-computed relevant files
+      });
 
-    allErrors.push(...errors);
-    completedWork = (bundle.indexOf(codemod) + 1) * fileCount;
-    bar.update(completedWork, { status: `Completed ${codemod}` });
-  }
+      allErrors.push(...errors);
+      completedWork = (bundle.indexOf(codemod) + 1) * fileCount;
+      bar.update(completedWork, { status: `Completed ${codemod}` });
+    }
 
-  bar.update(totalWork, { status: "Checking dependencies..." });
-  bar.stop();
+    bar.update(totalWork, { status: "Checking dependencies..." });
+  } finally {
+    bar.stop();
+  }
 
   if (allErrors.length > 0) {
     log("Some codemods did not apply successfully to all files. Details:");

package/src/lib/utils/file-scanner.ts

@@ -8,6 +8,23 @@ export interface ScanOptions {
   ignore?: string[];
 }
 
+export function* readProjectFiles(
+  pattern: string,
+  options: { cwd: string; ignore?: string[] },
+): Generator<{ file: string; fullPath: string; content: string }> {
+  const files = globSync(pattern, options);
+
+  for (const file of files) {
+    const fullPath = path.join(options.cwd, file);
+    try {
+      const content = fs.readFileSync(fullPath, "utf8");
+      yield { file, fullPath, content };
+    } catch {
+      continue;
+    }
+  }
+}
+
 export function scanForImport(
   importPattern: string | string[],
   options: ScanOptions = {},
@@ -20,20 +37,13 @@ export function scanForImport(
     "**/build/**",
   ];
 
-  const files = globSync(pattern, { cwd, ignore });
   const patterns = Array.isArray(importPattern)
     ? importPattern
     : [importPattern];
 
-  for (const file of files) {
-    const fullPath = path.join(cwd, file);
-    try {
-      const content = fs.readFileSync(fullPath, "utf8");
-      if (patterns.some((p) => content.includes(p))) {
-        return true;
-      }
-    } catch {
-      // Ignore files that cannot be read
+  for (const { content } of readProjectFiles(pattern, { cwd, ignore })) {
+    if (patterns.some((p) => content.includes(p))) {
+      return true;
     }
   }
 
@@ -52,18 +62,14 @@ export function getFilesContaining(
     "**/build/**",
   ];
 
-  const files = globSync(pattern, { cwd, ignore });
   const result: string[] = [];
 
-  for (const file of files) {
-    const fullPath = path.join(cwd, file);
-    try {
-      const content = fs.readFileSync(fullPath, "utf8");
-      if (content.includes(searchString)) {
-        result.push(fullPath);
-      }
-    } catch {
-      // Ignore files that cannot be read
+  for (const { fullPath, content } of readProjectFiles(pattern, {
+    cwd,
+    ignore,
+  })) {
+    if (content.includes(searchString)) {
+      result.push(fullPath);
     }
   }
 

package/src/lib/utils/package-manager.ts

@@ -1,9 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { spawnSync } from "node:child_process";
 import { detect } from "detect-package-manager";
 import * as readline from "node:readline";
 import { logger } from "./logger";
+import { runSpawn, SpawnSignalError } from "../run-spawn";
+
+export type PackageManagerName = "npm" | "pnpm" | "yarn" | "bun";
 
 export function askQuestion(query: string): Promise<string> {
   return new Promise((resolve) => {
@@ -62,25 +64,40 @@ export async function getInstallCommand(
   }
 }
 
+function detectFromUserAgent(): PackageManagerName | undefined {
+  const ua = process.env.npm_config_user_agent;
+  if (!ua) return undefined;
+  if (ua.startsWith("bun/")) return "bun";
+  if (ua.startsWith("pnpm/")) return "pnpm";
+  if (ua.startsWith("yarn/")) return "yarn";
+  if (ua.startsWith("npm/")) return "npm";
+  return undefined;
+}
+
+export async function resolvePackageManagerForCwd(
+  cwd: string,
+  packageManager?: PackageManagerName,
+): Promise<PackageManagerName> {
+  if (packageManager) return packageManager;
+  const fromAgent = detectFromUserAgent();
+  if (fromAgent) return fromAgent;
+  try {
+    return await detect({ cwd });
+  } catch {
+    return "npm";
+  }
+}
+
 export async function installPackage(
   packageName: string,
   cwd?: string,
 ): Promise<boolean> {
   try {
     const { command, args } = await getInstallCommand(packageName, cwd);
-    const result = spawnSync(command, args, { stdio: "inherit", cwd });
-
-    if (result.error || result.status !== 0) {
-      logger.error(
-        `Installation failed${
-          result.error ? `: ${String(result.error)}` : "."
-        }`,
-      );
-      return false;
-    }
-
+    await runSpawn(command, args, cwd);
     return true;
   } catch (e) {
+    if (e instanceof SpawnSignalError) throw e;
     logger.error(`Installation failed: ${String(e)}`);
     return false;
   }