claude-yes 1.31.1 → 1.32.1

package/ts/postbuild.ts

@@ -1,18 +1,32 @@
 #! /usr/bin/env bun
-import { execaCommand } from 'execa';
-import { copyFile } from 'fs/promises';
-import * as pkg from '../package.json';
-import { CLIS_CONFIG } from '.';
+/**
+ * Postbuild script: Create Node.js wrapper files in dist/
+ * These wrappers execute dist/cli.js with the appropriate CLI name
+ */
+import { writeFile, chmod } from "fs/promises";
+import { CLIS_CONFIG } from "./index.ts";
+import sflow from "sflow";
+import pkg from "../package.json";
 
-const src = 'dist/cli.js';
-await Promise.all(
-  Object.keys(CLIS_CONFIG).map(async (cli) => {
-    const dst = `dist/${cli}-yes.js`;
-    if (!(pkg.bin as Record<string, string>)?.[`${cli}-yes`]) {
-      console.log(`package.json Updated bin.${cli}-yes = ${dst}`);
-      await execaCommand(`npm pkg set bin.${cli}-yes=${dst}`);
+// Create copies for each CLI variant (all use the same wrapper logic)
+await sflow([...Object.keys(CLIS_CONFIG), "agent"])
+  .map(async (cli) => {
+    const cliName = `${cli}-yes`;
+
+    const wrapperPath = `./dist/${cliName}.js`;
+    await writeFile(
+      wrapperPath,
+      `
+#!/usr/bin/env bun
+await import('./cli.js')
+`.trim(),
+    );
+    await chmod(wrapperPath, 0o755);
+
+    if (!(pkg.bin as Record<string, string>)?.[cliName]) {
+      await Bun.$`npm pkg set ${"bin." + cliName}=${wrapperPath}`;
+      console.log(`${wrapperPath} created`);
     }
-    await copyFile(src, dst);
-    console.log(`${dst} Updated`);
-  }),
-);
+  })
+
+  .run();

package/ts/pty-fix.ts

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { arch, platform } from "process";
+import { fileURLToPath } from "url";
+
+// Determine the platform-specific library name
+function getLibraryName() {
+  switch (platform) {
+    case "win32":
+      return "rust_pty.dll";
+    case "darwin":
+      return arch === "arm64" ? "librust_pty_arm64.dylib" : "librust_pty.dylib";
+    case "linux":
+      return arch === "arm64" ? "librust_pty_arm64.so" : "librust_pty.so";
+    default:
+      return "librust_pty.so";
+  }
+}
+
+// Check if we need to rebuild bun-pty
+const bunPtyPath = dirname(fileURLToPath(import.meta.resolve("@snomiao/bun-pty"))) + "/..";
+const libName = getLibraryName();
+const libPath = join(bunPtyPath, "rust-pty", "target", "release", libName);
+
+if (!existsSync(bunPtyPath)) {
+  console.log({ bunPtyPath });
+  console.log("bun-pty not found, skipping pty-fix in ");
+  process.exit(0);
+}
+
+// Platform-specific compatibility check
+if (platform === "linux") {
+  // Check if the binary exists and if it has GLIBC compatibility issues
+  try {
+    const lddOutput = execSync(`ldd "${libPath}" 2>&1`, { encoding: "utf8" });
+    if (lddOutput.includes("GLIBC") && lddOutput.includes("not found")) {
+      console.log("GLIBC compatibility issue detected, rebuilding bun-pty...");
+      rebuildBunPty();
+    } else {
+      console.log("bun-pty binary is compatible");
+    }
+  } catch {
+    // If ldd fails or file doesn't exist, try to rebuild
+    console.log("Checking bun-pty compatibility...");
+    rebuildBunPty();
+  }
+} else if (platform === "win32") {
+  // Windows: Check if DLL exists
+  if (!existsSync(libPath)) {
+    console.log("Windows DLL not found, attempting to rebuild...");
+    rebuildBunPty();
+  } else {
+    console.log("bun-pty Windows DLL found");
+  }
+} else if (platform === "darwin") {
+  // macOS: Check if dylib exists
+  if (!existsSync(libPath)) {
+    console.log("macOS dylib not found, attempting to rebuild...");
+    rebuildBunPty();
+  } else {
+    console.log("bun-pty macOS dylib found");
+  }
+} else {
+  console.log(`Platform ${platform} may require manual configuration`);
+}
+
+function rebuildBunPty() {
+  try {
+    // Check if cargo is available
+    const cargoCmd = platform === "win32" ? "cargo.exe" : "cargo";
+    try {
+      execSync(`${cargoCmd} --version`, { stdio: "ignore" });
+    } catch {
+      console.warn("Warning: Rust/Cargo not found. bun-pty native module may not work.");
+      console.warn("To fix this, install Rust: https://rustup.rs/");
+      return;
+    }
+
+    const rustPtyDir = join(bunPtyPath, "rust-pty");
+    const isWindows = platform === "win32";
+    const tempBase = isWindows ? process.env.TEMP || "C:\\Temp" : "/tmp";
+
+    // Check if source code exists
+    if (!existsSync(join(rustPtyDir, "Cargo.toml"))) {
+      // Try to clone and build from source
+      console.log("Source code not found in npm package, cloning from repository...");
+      const tmpDir = join(tempBase, `bun-pty-build-${Date.now()}`);
+
+      try {
+        execSync(`git clone https://github.com/snomiao/bun-pty.git "${tmpDir}"`, {
+          stdio: "inherit",
+        });
+
+        // Build command varies by platform
+        if (isWindows) {
+          execSync(
+            `cd /d "${tmpDir}" && cargo build --release --manifest-path rust-pty\\Cargo.toml`,
+            { stdio: "inherit" },
+          );
+        } else {
+          execSync(`cd "${tmpDir}" && cargo build --release --manifest-path rust-pty/Cargo.toml`, {
+            stdio: "inherit",
+          });
+        }
+
+        // Copy the built library
+        const builtLib = join(tmpDir, "rust-pty", "target", "release", libName);
+        if (existsSync(builtLib)) {
+          // Ensure target directory exists
+          const targetDir = join(rustPtyDir, "target", "release");
+          if (isWindows) {
+            execSync(`if not exist "${targetDir}" mkdir "${targetDir}"`, {});
+            execSync(`copy /Y "${builtLib}" "${libPath}"`, {});
+          } else {
+            execSync(`mkdir -p "${targetDir}"`, { stdio: "inherit" });
+            execSync(`cp "${builtLib}" "${libPath}"`, { stdio: "inherit" });
+          }
+          console.log("Successfully rebuilt bun-pty native module");
+        }
+
+        // Cleanup
+        if (isWindows) {
+          execSync(`rmdir /s /q "${tmpDir}"`, { stdio: "ignore" });
+        } else {
+          execSync(`rm -rf "${tmpDir}"`, { stdio: "ignore" });
+        }
+      } catch (buildError) {
+        console.error(
+          "Failed to build bun-pty:",
+          buildError instanceof Error ? buildError.message : buildError,
+        );
+        console.warn("The application may not work correctly without bun-pty");
+      }
+    } else {
+      // Build from included source
+      console.log("Building bun-pty from source...");
+      if (isWindows) {
+        execSync(`cd /d "${rustPtyDir}" && cargo build --release`, {
+          stdio: "inherit",
+        });
+      } else {
+        execSync(`cd "${rustPtyDir}" && cargo build --release`, {
+          stdio: "inherit",
+        });
+      }
+      console.log("Successfully rebuilt bun-pty native module");
+    }
+  } catch (error) {
+    console.error("Failed to rebuild bun-pty:", error instanceof Error ? error.message : error);
+    console.warn("The application may not work correctly without bun-pty");
+  }
+}

package/ts/pty.ts

@@ -0,0 +1,19 @@
+import { logger } from "./logger.ts";
+
+// its recommened to use bun-pty in windows, since node-pty is super complex to install there, requires a 10G M$ build tools
+
+async function getPty() {
+  return globalThis.Bun
+    ? await import("bun-pty").catch((error) => {
+        logger.error("Failed to load bun-pty:", error);
+        throw error;
+      })
+    : await import("node-pty").catch((error) => {
+        logger.error("Failed to load node-pty:", error);
+        throw error;
+      });
+}
+
+const pty = await getPty();
+export const ptyPackage = globalThis.Bun ? "bun-pty" : "node-pty";
+export default pty;

package/ts/removeControlCharacters.spec.ts

@@ -1,74 +1,73 @@
-import { describe, expect, it } from 'vitest';
-import { removeControlCharacters } from './removeControlCharacters';
+import { describe, expect, it } from "vitest";
+import { removeControlCharacters } from "./removeControlCharacters";
 
-describe('removeControlCharacters', () => {
-  it('should remove ANSI escape sequences', () => {
-    const input = '\u001b[31mRed text\u001b[0m';
-    const expected = 'Red text';
+describe("removeControlCharacters", () => {
+  it("should remove ANSI escape sequences", () => {
+    const input = "\u001b[31mRed text\u001b[0m";
+    const expected = "Red text";
     expect(removeControlCharacters(input)).toBe(expected);
   });
 
-  it('should remove cursor positioning codes', () => {
-    const input = '\u001b[1;1HHello\u001b[2;1HWorld';
-    const expected = 'HelloWorld';
+  it("should remove cursor positioning codes", () => {
+    const input = "\u001b[1;1HHello\u001b[2;1HWorld";
+    const expected = "HelloWorld";
     expect(removeControlCharacters(input)).toBe(expected);
   });
 
-  it('should remove color codes', () => {
-    const input = '\u001b[32mGreen\u001b[0m \u001b[31mRed\u001b[0m';
-    const expected = 'Green Red';
+  it("should remove color codes", () => {
+    const input = "\u001b[32mGreen\u001b[0m \u001b[31mRed\u001b[0m";
+    const expected = "Green Red";
     expect(removeControlCharacters(input)).toBe(expected);
   });
 
-  it('should remove complex ANSI sequences', () => {
-    const input = '\u001b[1;33;40mYellow on black\u001b[0m';
-    const expected = 'Yellow on black';
+  it("should remove complex ANSI sequences", () => {
+    const input = "\u001b[1;33;40mYellow on black\u001b[0m";
+    const expected = "Yellow on black";
     expect(removeControlCharacters(input)).toBe(expected);
   });
 
-  it('should handle empty string', () => {
-    expect(removeControlCharacters('')).toBe('');
+  it("should handle empty string", () => {
+    expect(removeControlCharacters("")).toBe("");
   });
 
-  it('should handle string with no control characters', () => {
-    const input = 'Plain text with no escape sequences';
+  it("should handle string with no control characters", () => {
+    const input = "Plain text with no escape sequences";
     expect(removeControlCharacters(input)).toBe(input);
   });
 
-  it('should remove CSI sequences with multiple parameters', () => {
-    const input = '\u001b[38;5;196mBright red\u001b[0m';
-    const expected = 'Bright red';
+  it("should remove CSI sequences with multiple parameters", () => {
+    const input = "\u001b[38;5;196mBright red\u001b[0m";
+    const expected = "Bright red";
     expect(removeControlCharacters(input)).toBe(expected);
   });
 
-  it('should remove C1 control characters', () => {
-    const input = '\u009b[32mGreen text\u009b[0m';
-    const expected = 'Green text';
+  it("should remove C1 control characters", () => {
+    const input = "\u009b[32mGreen text\u009b[0m";
+    const expected = "Green text";
     expect(removeControlCharacters(input)).toBe(expected);
   });
 
-  it('should handle mixed control and regular characters', () => {
-    const input =
-      'Start\u001b[1mBold\u001b[0mMiddle\u001b[4mUnderline\u001b[0mEnd';
-    const expected = 'StartBoldMiddleUnderlineEnd';
+  it("should handle mixed control and regular characters", () => {
+    const input = "Start\u001b[1mBold\u001b[0mMiddle\u001b[4mUnderline\u001b[0mEnd";
+    const expected = "StartBoldMiddleUnderlineEnd";
     expect(removeControlCharacters(input)).toBe(expected);
   });
 
-  it('should preserve spaces and newlines', () => {
-    const input = 'Line 1\u001b[31m\nRed Line 2\u001b[0m\n\nLine 4';
-    const expected = 'Line 1\nRed Line 2\n\nLine 4';
+  it("should preserve spaces and newlines", () => {
+    const input = "Line 1\u001b[31m\nRed Line 2\u001b[0m\n\nLine 4";
+    const expected = "Line 1\nRed Line 2\n\nLine 4";
     expect(removeControlCharacters(input)).toBe(expected);
   });
 
-  it('should handle cursor movement sequences', () => {
-    const input = '\u001b[2AUp\u001b[3BDown\u001b[4CRight\u001b[5DLeft';
-    const expected = 'UpDownRightLeft';
+  it("should handle cursor movement sequences", () => {
+    const input = "\u001b[2AUp\u001b[3BDown\u001b[4CRight\u001b[5DLeft";
+    const expected = "UpDownRightLeft";
     expect(removeControlCharacters(input)).toBe(expected);
   });
 
-  it('should handle erase sequences', () => {
-    const input = 'Text\u001b[2JClear\u001b[KLine';
-    const expected = 'TextClearLine';
+  it("should handle erase sequences", () => {
+    const input = "Text\u001b[2JClear\u001b[KLine";
+    const expected = "TextClearLine";
     expect(removeControlCharacters(input)).toBe(expected);
   });
 });

package/ts/removeControlCharacters.ts

@@ -1,7 +1,8 @@
 export function removeControlCharacters(str: string): string {
   // Matches control characters in the C0 and C1 ranges, including Delete (U+007F)
   return str.replace(
+    // eslint-disable-next-line no-control-regex This is a control regex
     /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
-    '',
+    "",
   );
 }