assistant-ui 0.0.116 → 0.0.118

package/src/commands/create.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import * as p from "@clack/prompts";
 import { logger } from "../lib/utils/logger";
 import {
+  cleanupPendingProjectDownloads,
   dlxCommand,
   downloadProject,
   resolveLatestReleaseRef,
@@ -382,10 +383,30 @@ export function resolveCreateProjectDirectory(params: {
   const { projectDirectory, stdinIsTTY = process.stdin.isTTY } = params;
 
   if (projectDirectory) return projectDirectory;
-  if (!stdinIsTTY) return "my-aui-app";
+  if (!stdinIsTTY) return DEFAULT_PROJECT_DIRECTORY;
   return undefined;
 }
 
+export const DEFAULT_PROJECT_DIRECTORY = "my-aui-app";
+
+export const projectNamePromptOptions = {
+  message: "Project name:",
+  placeholder: DEFAULT_PROJECT_DIRECTORY,
+  defaultValue: DEFAULT_PROJECT_DIRECTORY,
+  validate: (value?: string) => {
+    // Enter on an untouched prompt is how clack accepts `defaultValue`, and it
+    // validates before finalize substitutes it, so an empty value has to pass
+    // here or the default is unreachable.
+    if (value === undefined || value === "") return undefined;
+    const name = value.trim();
+    if (!name) return "Project name cannot be empty";
+    if (name === "." || name === "..") return "Project name cannot be . or ..";
+    if (name.includes("/") || name.includes("\\"))
+      return "Project name cannot contain path separators";
+    return undefined;
+  },
+};
+
 export function resolveProjectDirectoryGuidance(params: {
   absoluteProjectDir: string;
   cwd?: string;
@@ -520,6 +541,12 @@ export const create = new Command()
   .option("--skip-install", "skip installing packages")
   .option("--skills", "add assistant-ui agent skills for AI coding assistants")
   .option("--no-skills", "skip adding assistant-ui agent skills")
+  .addOption(
+    new Option(
+      "--cwd <cwd>",
+      "the working directory. defaults to the current directory.",
+    ).hideHelp(),
+  )
   .addOption(
     new Option(
       "--debug-source-root <path>",
@@ -551,20 +578,7 @@ export const create = new Command()
     });
 
     if (!resolvedProjectDirectory) {
-      const result = await p.text({
-        message: "Project name:",
-        placeholder: "my-aui-app",
-        defaultValue: "my-aui-app",
-        validate: (value?: string) => {
-          const name = (value ?? "").trim();
-          if (!name) return "Project name cannot be empty";
-          if (name === "." || name === "..")
-            return "Project name cannot be . or ..";
-          if (name.includes("/") || name.includes("\\"))
-            return "Project name cannot contain path separators";
-          return undefined;
-        },
-      });
+      const result = await p.text(projectNamePromptOptions);
 
       if (p.isCancel(result)) {
         p.cancel("Project creation cancelled.");
@@ -575,9 +589,13 @@ export const create = new Command()
     }
 
     // Check directory
-    const absoluteProjectDir = path.resolve(resolvedProjectDirectory);
+    const absoluteProjectDir = path.resolve(
+      opts.cwd ?? process.cwd(),
+      resolvedProjectDirectory,
+    );
     const { display: displayProjectDir, cdCommand } =
       resolveProjectDirectoryGuidance({ absoluteProjectDir });
+    let projectDirExisted = true;
     try {
       const files = fs.readdirSync(absoluteProjectDir);
       if (files.length > 0) {
@@ -591,6 +609,7 @@ export const create = new Command()
         err instanceof Error ? (err as NodeJS.ErrnoException).code : undefined;
       if (code === "ENOENT") {
         // Directory doesn't exist — good, proceed
+        projectDirExisted = false;
       } else if (code === "ENOTDIR") {
         logger.error(
           `${displayProjectDir} already exists and is not a directory`,
@@ -638,11 +657,24 @@ export const create = new Command()
     );
 
     // Clean up partial project directory on unexpected exit (e.g. Ctrl+C)
+    const resetProjectDir = () => {
+      if (!projectDirExisted) {
+        fs.rmSync(absoluteProjectDir, { recursive: true, force: true });
+        return;
+      }
+      if (!fs.existsSync(absoluteProjectDir)) return;
+      for (const entry of fs.readdirSync(absoluteProjectDir)) {
+        fs.rmSync(path.join(absoluteProjectDir, entry), {
+          recursive: true,
+          force: true,
+        });
+      }
+    };
     let cleanupArmed = true;
     const cleanupOnExit = () => {
       if (!cleanupArmed) return;
       cleanupArmed = false;
-      fs.rmSync(absoluteProjectDir, { recursive: true, force: true });
+      resetProjectDir();
     };
     const disarmCleanup = () => {
       cleanupArmed = false;
@@ -651,10 +683,11 @@ export const create = new Command()
       process.removeListener("SIGTERM", cleanupOnSignal);
     };
     // Node emits no "exit" when a signal kills the process. An in-flight
-    // runSpawn forwards the signal itself, so the directory is removed on the
-    // error path once the child is reaped rather than while it is still writing.
+    // runSpawn forwards the signal itself, so cleanup runs on the error path
+    // once the child is reaped rather than while it is still writing.
     const cleanupOnSignal = (signal: NodeJS.Signals) => {
       if (hasActiveSpawn()) return;
+      cleanupPendingProjectDownloads();
       cleanupOnExit();
       disarmCleanup();
       process.kill(process.pid, signal);
@@ -696,7 +729,7 @@ export const create = new Command()
           ref &&
           !fs.existsSync(path.join(absoluteProjectDir, "package.json"))
         ) {
-          fs.rmSync(absoluteProjectDir, { recursive: true, force: true });
+          resetProjectDir();
           logger.warn(
             "Template not found at release tag, downloading from HEAD",
           );

package/src/commands/init.ts

@@ -83,8 +83,7 @@ export const init = new Command()
         logger.break();
       }
 
-      const createArgs: string[] = [];
-      if (projectDirectory) createArgs.push(targetDir);
+      const createArgs = projectDirectory ? [targetDir] : ["--cwd", cwd];
       if (presetUrl) createArgs.push("--preset", presetUrl);
       if (opts.useNpm) createArgs.push("--use-npm");
       if (opts.usePnpm) createArgs.push("--use-pnpm");

package/src/lib/agent-skill.ts

@@ -1,7 +1,17 @@
-import { dlxCommand } from "./create-project";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { downloadTemplate } from "giget";
+import {
+  DOWNLOAD_TIMEOUT_MS,
+  dlxCommand,
+  resolveGitHubAuthToken,
+} from "./create-project";
 import { type PackageManagerName } from "./utils/package-manager";
 
 export const SKILLS_PACKAGE = "assistant-ui/skills";
+export const SKILLS_COMMIT = "66befc4468ce0691c9203442d70cbbdcb5562ea1";
+export const SKILLS_PLUGIN_SOURCE = `gh:${SKILLS_PACKAGE}/assistant-ui#${SKILLS_COMMIT}`;
 
 export function resolveSkillsInstall(params: {
   skills?: boolean;
@@ -27,3 +37,95 @@ export function buildSkillsAddCommand(
 
   return [command, args];
 }
+
+export function skillsPluginDir(): string {
+  const cacheHome =
+    process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+  return path.join(cacheHome, "assistant-ui", "skills", SKILLS_COMMIT);
+}
+
+export async function ensureSkillsPlugin(): Promise<string> {
+  const dir = skillsPluginDir();
+  const marker = path.join(dir, ".claude-plugin", "plugin.json");
+  if (fs.existsSync(marker)) return dir;
+
+  const parent = path.dirname(dir);
+  await fs.promises.mkdir(parent, { recursive: true });
+  const staging = await fs.promises.mkdtemp(path.join(parent, ".staging-"));
+  // Node emits no "exit" when a signal kills the process, so the staging
+  // directory is removed on the signal and the signal re-raised. The
+  // listeners stay armed until the removal runs, which a download that
+  // outlives the timeout defers past the caller's own exit.
+  const removeStaging = () => {
+    process.removeListener("exit", removeStaging);
+    process.removeListener("SIGINT", removeStagingOnSignal);
+    process.removeListener("SIGTERM", removeStagingOnSignal);
+    fs.rmSync(staging, { recursive: true, force: true });
+  };
+  const removeStagingOnSignal = (signal: NodeJS.Signals) => {
+    removeStaging();
+    process.kill(process.pid, signal);
+  };
+  process.once("exit", removeStaging);
+  process.once("SIGINT", removeStagingOnSignal);
+  process.once("SIGTERM", removeStagingOnSignal);
+
+  // giget logs to console.debug whenever DEBUG is set, which the `debug`
+  // package does at module load for an unrelated namespace.
+  const origDebug = process.env.DEBUG;
+  delete process.env.DEBUG;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let downloadSettled = false;
+  let download: Promise<unknown> | undefined;
+  try {
+    const authToken = resolveGitHubAuthToken();
+    download = downloadTemplate(SKILLS_PLUGIN_SOURCE, {
+      dir: staging,
+      preferOffline: true,
+      silent: true,
+      ...(authToken ? { auth: authToken } : {}),
+    }).finally(() => {
+      downloadSettled = true;
+    });
+    const timeout = new Promise<never>((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error("Download timed out.")),
+        DOWNLOAD_TIMEOUT_MS,
+      );
+    });
+    await Promise.race([download, timeout]).catch((error: unknown) => {
+      throw new Error(
+        "Could not fetch the assistant-ui skills from GitHub. Check your network, or set GITHUB_TOKEN if you are rate limited.",
+        { cause: error },
+      );
+    });
+    await publish(staging, dir, marker);
+  } finally {
+    clearTimeout(timer);
+    if (origDebug !== undefined) process.env.DEBUG = origDebug;
+    if (!download || downloadSettled) removeStaging();
+    else void download.then(removeStaging, removeStaging);
+  }
+
+  return dir;
+}
+
+// A rename fails when the target directory exists and is not empty. A
+// concurrent invocation that published the same commit meanwhile wins and
+// the staged copy is dropped; a directory without the marker is a stale
+// partial cache and is replaced.
+async function publish(
+  staging: string,
+  dir: string,
+  marker: string,
+  retry = true,
+): Promise<void> {
+  try {
+    await fs.promises.rename(staging, dir);
+  } catch (error) {
+    if (fs.existsSync(marker)) return;
+    if (!retry) throw error;
+    await fs.promises.rm(dir, { recursive: true, force: true });
+    await publish(staging, dir, marker, false);
+  }
+}

package/src/lib/create-project.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { downloadTemplate } from "giget";
 import {
@@ -68,7 +69,7 @@ export function resolvePackageManager(opts: {
   return undefined;
 }
 
-function resolveGitHubAuthToken(): string | undefined {
+export function resolveGitHubAuthToken(): string | undefined {
   const token =
     process.env.GIGET_AUTH ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
   const trimmed = token?.trim();
@@ -96,7 +97,16 @@ export async function resolveLatestReleaseRef(): Promise<string | undefined> {
   }
 }
 
-const DOWNLOAD_TIMEOUT_MS = 30_000;
+export const DOWNLOAD_TIMEOUT_MS = 30_000;
+const pendingDownloadCleanups = new Set<() => void>();
+
+export function cleanupPendingProjectDownloads(): void {
+  for (const cleanup of pendingDownloadCleanups) {
+    pendingDownloadCleanups.delete(cleanup);
+    process.removeListener("exit", cleanup);
+    cleanup();
+  }
+}
 
 export async function downloadProject(
   repoPath: string,
@@ -113,13 +123,74 @@ export async function downloadProject(
   // namespaces. Temporarily unsetting it targets the root cause.
   const origDebug = process.env.DEBUG;
   delete process.env.DEBUG;
+  let destinationCreated = false;
+  let stagingDir: string | undefined;
+  let downloadPromise: Promise<unknown> | undefined;
+  let downloadFinished = false;
+  let downloadCommitted = false;
+  let cleanupRequested = false;
+  const removeCleanupListeners = () => {
+    process.removeListener("exit", cleanupOnExit);
+    pendingDownloadCleanups.delete(cleanupOnExit);
+  };
+  const attemptSyncCleanup = (cleanup: () => void) => {
+    try {
+      cleanup();
+    } catch {
+      return;
+    }
+  };
+  const cleanupOnExit = () => {
+    cleanupRequested = true;
+    const currentStagingDir = stagingDir;
+    if (currentStagingDir) {
+      attemptSyncCleanup(() => {
+        fs.rmSync(currentStagingDir, { recursive: true, force: true });
+      });
+    }
+    if (destinationCreated && !downloadCommitted) {
+      attemptSyncCleanup(() => {
+        fs.rmdirSync(destDir);
+      });
+    }
+  };
+  const removeStagingDir = async () => {
+    if (stagingDir) {
+      await fs.promises
+        .rm(stagingDir, { recursive: true, force: true })
+        .catch(() => undefined);
+    }
+    removeCleanupListeners();
+    if (destinationCreated && !downloadCommitted) {
+      await fs.promises.rmdir(destDir).catch(() => undefined);
+    }
+  };
   try {
+    await fs.promises.mkdir(path.dirname(destDir), { recursive: true });
+    try {
+      stagingDir = await fs.promises.mkdtemp(
+        path.join(path.dirname(destDir), ".assistant-ui-download-"),
+      );
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== "EACCES" && code !== "EPERM" && code !== "EROFS") {
+        throw error;
+      }
+      stagingDir = await fs.promises.mkdtemp(
+        path.join(os.tmpdir(), ".assistant-ui-download-"),
+      );
+    }
+    process.once("exit", cleanupOnExit);
+    pendingDownloadCleanups.add(cleanupOnExit);
+
     const authToken = resolveGitHubAuthToken();
-    const downloadPromise = downloadTemplate(source, {
-      dir: destDir,
+    downloadPromise = downloadTemplate(source, {
+      dir: stagingDir,
       force: true,
       silent: true,
       ...(authToken ? { auth: authToken } : {}),
+    }).finally(() => {
+      downloadFinished = true;
     });
 
     let timer: ReturnType<typeof setTimeout>;
@@ -137,10 +208,34 @@ export async function downloadProject(
 
     try {
       await Promise.race([downloadPromise, timeoutPromise]);
+      if (cleanupRequested) throw new Error("Download was interrupted.");
+      destinationCreated = !fs.existsSync(destDir);
+      await fs.promises.mkdir(destDir, { recursive: true });
+      for (const entry of await fs.promises.readdir(stagingDir)) {
+        const target = path.join(destDir, entry);
+        const sourceEntry = path.join(stagingDir, entry);
+        await fs.promises.rm(target, { recursive: true, force: true });
+        try {
+          await fs.promises.rename(sourceEntry, target);
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code !== "EXDEV") throw error;
+          await fs.promises.cp(sourceEntry, target, {
+            recursive: true,
+            force: true,
+          });
+          await fs.promises.rm(sourceEntry, { recursive: true, force: true });
+        }
+      }
+      downloadCommitted = true;
     } finally {
       clearTimeout(timer!);
     }
   } finally {
+    if (!downloadPromise || downloadFinished) {
+      await removeStagingDir();
+    } else {
+      void downloadPromise.then(removeStagingDir, removeStagingDir);
+    }
     if (origDebug !== undefined) {
       process.env.DEBUG = origDebug;
     }

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

@@ -70,7 +70,54 @@ describe("runSpawn", () => {
 
     expect(child.kill).toHaveBeenNthCalledWith(1, "SIGTERM");
     expect(child.kill).toHaveBeenNthCalledWith(2, "SIGKILL");
+    expect(hasActiveSpawn()).toBe(true);
+
+    child.emit("close", null, "SIGKILL");
+    await expect(result).rejects.toBeInstanceOf(SpawnSignalError);
+    expect(hasActiveSpawn()).toBe(false);
+    expect(process.listenerCount("SIGTERM")).toBe(sigterm.count);
+  });
+
+  it("settles after a signaled child exits while captured pipes stay open", async () => {
+    const child = Object.assign(createChild(), {
+      stdout: new PassThrough(),
+      stderr: new PassThrough(),
+    });
+    mocks.spawn.mockReturnValue(child);
+    const sigterm = trackSignal("SIGTERM");
+    const result = runSpawnCapture("jscodeshift", ["--version"]);
+    const signalHandler = sigterm.added();
+
+    signalHandler?.("SIGTERM");
+    signalHandler?.("SIGTERM");
+    child.emit("exit", null, "SIGKILL");
+
     await expect(result).rejects.toBeInstanceOf(SpawnSignalError);
+    expect(child.stdout.destroyed).toBe(true);
+    expect(child.stderr.destroyed).toBe(true);
+    expect(hasActiveSpawn()).toBe(false);
+    expect(process.listenerCount("SIGTERM")).toBe(sigterm.count);
+  });
+
+  it("settles on a third signal when the child does not exit", async () => {
+    const child = createChild();
+    mocks.spawn.mockReturnValue(child);
+    const sigterm = trackSignal("SIGTERM");
+    const result = runSpawn("assistant-ui", ["create"]);
+    const signalHandler = sigterm.added();
+
+    signalHandler?.("SIGTERM");
+    signalHandler?.("SIGTERM");
+    signalHandler?.("SIGTERM");
+
+    await expect(result).rejects.toMatchObject({
+      signal: "SIGTERM",
+      forwarded: true,
+    });
+    expect(child.kill).toHaveBeenNthCalledWith(1, "SIGTERM");
+    expect(child.kill).toHaveBeenNthCalledWith(2, "SIGKILL");
+    expect(child.kill).toHaveBeenCalledTimes(2);
+    expect(hasActiveSpawn()).toBe(false);
     expect(process.listenerCount("SIGTERM")).toBe(sigterm.count);
   });
 

package/src/lib/run-spawn.ts

@@ -3,15 +3,18 @@ import { spawn } from "cross-spawn";
 export class SpawnExitError extends Error {
   code: number;
   stderr: string;
+  stdout: string;
 
-  constructor(code: number, stderr = "") {
+  constructor(code: number, stderr = "", stdout = "") {
+    const output = [stdout, stderr].filter(Boolean).join("\n");
     super(
-      stderr
-        ? `Process exited with code ${code}\n${stderr}`
+      output
+        ? `Process exited with code ${code}\n${output}`
         : `Process exited with code ${code}`,
     );
     this.code = code;
     this.stderr = stderr;
+    this.stdout = stdout;
   }
 }
 
@@ -51,6 +54,7 @@ function spawnProcess(
       cwd,
     });
     let forwardedSignal: NodeJS.Signals | null = null;
+    let escalated = false;
     let settled = false;
     let stdout = "";
     let stderr = "";
@@ -72,16 +76,25 @@ function spawnProcess(
       process.off("SIGTERM", onSigterm);
     };
 
-    const rejectWithSignal = (signal: NodeJS.Signals) => {
+    const rejectForwardedSignal = () => {
+      if (settled || forwardedSignal === null) return false;
       settled = true;
+      child.stdout?.destroy();
+      child.stderr?.destroy();
       cleanup();
-      reject(new SpawnSignalError(signal, forwardedSignal !== null));
+      reject(new SpawnSignalError(forwardedSignal, true));
+      return true;
     };
 
     const forwardSignal = (signal: NodeJS.Signals) => {
       if (forwardedSignal !== null) {
-        child.kill("SIGKILL");
-        rejectWithSignal(forwardedSignal);
+        if (!escalated) {
+          escalated = true;
+          child.kill("SIGKILL");
+          return;
+        }
+
+        rejectForwardedSignal();
         return;
       }
 
@@ -97,23 +110,22 @@ function spawnProcess(
 
     child.on("error", (error) => {
       if (settled) return;
+      if (rejectForwardedSignal()) return;
       settled = true;
       cleanup();
-      if (forwardedSignal !== null) {
-        reject(new SpawnSignalError(forwardedSignal, true));
-      } else {
-        reject(error);
-      }
+      reject(error);
+    });
+    // "close" waits for stdio pipes, which a grandchild can hold open after
+    // the child is reaped, so a forwarded signal settles on "exit".
+    child.on("exit", () => {
+      rejectForwardedSignal();
     });
     child.on("close", (code, signal) => {
       if (settled) return;
+      if (rejectForwardedSignal()) return;
       settled = true;
       cleanup();
-      if (forwardedSignal !== null) {
-        reject(new SpawnSignalError(forwardedSignal, true));
-      } else {
-        resolve({ code, signal: signal ?? null, stdout, stderr });
-      }
+      resolve({ code, signal: signal ?? null, stdout, stderr });
     });
   });
 }

package/src/lib/transform-files.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it, onTestFinished } from "vitest";
+import { mkdirSync, mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, relative } from "node:path";
+import { getRelevantFiles, countFilesToProcess } from "./transform";
+
+const fixture = () => {
+  const directory = mkdtempSync(join(tmpdir(), "aui-transform-files-"));
+  onTestFinished(() => rmSync(directory, { recursive: true, force: true }));
+  const write = (
+    name: string,
+    source = 'import { useAssistantApi } from "@assistant-ui/react";',
+  ) => {
+    const file = join(directory, name);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, source);
+    return file;
+  };
+  return { directory, write };
+};
+
+describe("codemod file discovery", () => {
+  it.each(["js", "jsx", "ts", "tsx"])(
+    "accepts an explicit .%s target",
+    (extension) => {
+      const { write } = fixture();
+      const file = write(`my app.${extension}`);
+      expect(getRelevantFiles(file)).toEqual([file]);
+      expect(countFilesToProcess(file)).toBe(1);
+      expect(getRelevantFiles(relative(process.cwd(), file))).toEqual([file]);
+    },
+  );
+
+  it("keeps directory discovery filters", () => {
+    const { directory, write } = fixture();
+    const wanted = write("src/app.tsx");
+    for (const file of [
+      "node_modules/dependency.ts",
+      "dist/index.js",
+      "build/app.js",
+      "app.min.js",
+      "app.bundle.js",
+      "README.md",
+    ])
+      write(file);
+    write("unrelated.ts", "export const value = 1;");
+    expect(getRelevantFiles(directory)).toEqual([wanted]);
+  });
+
+  it.each([
+    "export const value = 1;",
+    'import { useAui } from "@/lib/aui"; const aui = useAui(); aui.thread().getState();',
+  ])("accepts explicitly named files without package text: %s", (source) => {
+    const { write } = fixture();
+    const file = write("app.tsx", source);
+    expect(getRelevantFiles(file)).toEqual([file]);
+    expect(countFilesToProcess(file)).toBe(1);
+  });
+
+  it("skips unsupported explicit files", () => {
+    const { write } = fixture();
+    expect(getRelevantFiles(write("README.md"))).toEqual([]);
+  });
+
+  it("rejects a missing target rather than silently reporting no work", () => {
+    const { directory } = fixture();
+    expect(() => getRelevantFiles(join(directory, "missing.tsx"))).toThrow(
+      /ENOENT/,
+    );
+  });
+});