agent-yes 1.31.41

package/ts/removeControlCharacters.spec.ts

@@ -0,0 +1,73 @@
+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";
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  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";
+    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";
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it("should handle empty string", () => {
+    expect(removeControlCharacters("")).toBe("");
+  });
+
+  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";
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  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";
+    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";
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  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";
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+});

package/ts/removeControlCharacters.ts

@@ -0,0 +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,
+    "",
+  );
+}

package/ts/runningLock.spec.ts

@@ -0,0 +1,485 @@
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  acquireLock,
+  cleanStaleLocks,
+  releaseLock,
+  shouldUseLock,
+  type Task,
+  updateCurrentTaskStatus,
+} from "./runningLock";
+
+// Keep lock files inside the repo to avoid $HOME permission issues in CI
+process.env.CLAUDE_YES_HOME = path.join(process.cwd(), ".cache");
+
+const LOCK_DIR = path.join(process.env.CLAUDE_YES_HOME, ".claude-yes");
+const LOCK_FILE = path.join(LOCK_DIR, "running.lock.json");
+const TEST_DIR = path.join(process.cwd(), ".cache", "test-lock");
+
+describe("runningLock", () => {
+  beforeEach(async () => {
+    // Clean up before each test
+    await cleanupLockFile();
+    await mkdir(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up after each test
+    await cleanupLockFile();
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("shouldUseLock", () => {
+    it("should return true for any directory", () => {
+      expect(shouldUseLock(process.cwd())).toBe(true);
+      expect(shouldUseLock("/tmp")).toBe(true);
+      expect(shouldUseLock(TEST_DIR)).toBe(true);
+    });
+  });
+
+  describe("acquireLock and releaseLock", () => {
+    it("should acquire and release lock successfully", async () => {
+      await acquireLock(TEST_DIR, "Test task");
+
+      // Check lock file exists and contains task
+      const lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].cwd).toBe(path.resolve(TEST_DIR));
+      expect(lockData.tasks[0].task).toBe("Test task");
+      expect(lockData.tasks[0].pid).toBe(process.pid);
+      expect(lockData.tasks[0].status).toBe("running");
+
+      // Release lock
+      await releaseLock();
+
+      // Check lock is released
+      const lockDataAfter = await readLockFile();
+      expect(lockDataAfter.tasks).toHaveLength(0);
+    });
+
+    it("should create lock directory if it does not exist", async () => {
+      // Remove lock directory
+      await rm(LOCK_DIR, { recursive: true, force: true });
+
+      await acquireLock(TEST_DIR, "Test task");
+
+      // Check directory and file exist
+      expect(existsSync(LOCK_DIR)).toBe(true);
+      expect(existsSync(LOCK_FILE)).toBe(true);
+
+      await releaseLock();
+    });
+
+    it("should handle prompt longer than 100 characters", async () => {
+      const longPrompt = "A".repeat(150);
+
+      await acquireLock(TEST_DIR, longPrompt);
+
+      const lockData = await readLockFile();
+      expect(lockData.tasks[0].task).toHaveLength(100);
+      expect(lockData.tasks[0].task).toBe("A".repeat(100));
+
+      await releaseLock();
+    });
+
+    it("should include timestamp fields", async () => {
+      const before = Date.now();
+      await acquireLock(TEST_DIR, "Test task");
+      const after = Date.now();
+
+      const lockData = await readLockFile();
+      const task = lockData.tasks[0];
+
+      expect(task.startedAt).toBeGreaterThanOrEqual(before);
+      expect(task.startedAt).toBeLessThanOrEqual(after);
+      expect(task.lockedAt).toBeGreaterThanOrEqual(before);
+      expect(task.lockedAt).toBeLessThanOrEqual(after);
+
+      await releaseLock();
+    });
+  });
+
+  describe("git repository detection", () => {
+    it("should detect git root for repository", async () => {
+      // Use current directory which is a git repo
+      const gitRoot = execSync("git rev-parse --show-toplevel", {
+        cwd: process.cwd(),
+        encoding: "utf8",
+      }).trim();
+
+      await acquireLock(process.cwd(), "Git repo task");
+
+      const lockData = await readLockFile();
+      expect(lockData.tasks[0].gitRoot).toBe(gitRoot);
+
+      await releaseLock();
+    });
+
+    it("should detect same git root for subdirectory", async () => {
+      const gitRoot = execSync("git rev-parse --show-toplevel", {
+        cwd: process.cwd(),
+        encoding: "utf8",
+      }).trim();
+      const subdir = path.join(process.cwd(), "docs");
+
+      await acquireLock(subdir, "Subdirectory task");
+
+      const lockData = await readLockFile();
+      expect(lockData.tasks[0].gitRoot).toBe(gitRoot);
+      expect(lockData.tasks[0].cwd).toBe(path.resolve(subdir));
+
+      await releaseLock();
+    });
+
+    it("should not have gitRoot for non-git directory", async () => {
+      // Create a temporary directory outside of any git repo
+      const tempDir = path.join("/tmp", "test-non-git-" + Date.now());
+      await mkdir(tempDir, { recursive: true });
+
+      try {
+        await acquireLock(tempDir, "Non-git task");
+
+        const lockData = await readLockFile();
+        expect(lockData.tasks[0].gitRoot).toBeUndefined();
+        expect(lockData.tasks[0].cwd).toBe(path.resolve(tempDir));
+
+        await releaseLock();
+      } finally {
+        await rm(tempDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe("updateCurrentTaskStatus", () => {
+    it("should update task status", async () => {
+      await acquireLock(TEST_DIR, "Test task");
+
+      // Update to completed
+      await updateCurrentTaskStatus("completed");
+
+      let lockData = await readLockFile();
+      expect(lockData.tasks[0].status).toBe("completed");
+
+      // Update to failed
+      await updateCurrentTaskStatus("failed");
+
+      lockData = await readLockFile();
+      expect(lockData.tasks[0].status).toBe("failed");
+
+      await releaseLock();
+    });
+
+    it("should not throw when updating non-existent task", async () => {
+      // Should complete without throwing
+      await updateCurrentTaskStatus("completed");
+      // If we got here, no error was thrown
+      expect(true).toBe(true);
+    });
+  });
+
+  describe("cleanStaleLocks", () => {
+    it("should remove stale locks with invalid PIDs", async () => {
+      // Use a PID that definitely doesn't exist
+      const invalidPid = 9999999;
+
+      // Create a lock with a non-existent PID
+      const staleLock = {
+        tasks: [
+          {
+            cwd: TEST_DIR,
+            task: "Stale task",
+            pid: invalidPid,
+            status: "running" as const,
+            startedAt: Date.now() - 60000,
+            lockedAt: Date.now() - 60000,
+          },
+        ],
+      };
+
+      await mkdir(LOCK_DIR, { recursive: true });
+      await writeFile(LOCK_FILE, JSON.stringify(staleLock, null, 2));
+
+      // Verify the stale lock was written
+      let rawContent = await readFile(LOCK_FILE, "utf8");
+      let rawData = JSON.parse(rawContent);
+      expect(rawData.tasks).toHaveLength(1);
+      expect(rawData.tasks[0].pid).toBe(invalidPid);
+
+      // Now acquire a lock - this will trigger cleanup of stale locks
+      await acquireLock(TEST_DIR, "New task");
+
+      // The stale lock should be cleaned, and only our new task should remain
+      const lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].pid).toBe(process.pid);
+      expect(lockData.tasks[0].task).toBe("New task");
+
+      await releaseLock();
+    });
+
+    it("should keep valid locks with running PIDs", async () => {
+      await acquireLock(TEST_DIR, "Valid task");
+
+      // Clean stale locks (should not remove our lock)
+      await cleanStaleLocks();
+
+      const lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].pid).toBe(process.pid);
+
+      await releaseLock();
+    });
+
+    it("should handle corrupted lock file", async () => {
+      // Write invalid JSON
+      await mkdir(LOCK_DIR, { recursive: true });
+      await writeFile(LOCK_FILE, "invalid json{{{");
+
+      // Reading the lock file should handle corruption gracefully
+      const lockData = await readLockFile();
+
+      // Should return empty task list for corrupted file
+      expect(lockData.tasks).toHaveLength(0);
+    });
+
+    it("should handle missing lock file", async () => {
+      await rm(LOCK_FILE, { force: true });
+
+      // Reading non-existent lock file should return empty
+      const lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(0);
+    });
+  });
+
+  describe("concurrent access", () => {
+    it("should handle multiple tasks from different processes", async () => {
+      // Acquire first task
+      await acquireLock(TEST_DIR, "Task 1");
+
+      // Verify the task exists
+      let lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe("Task 1");
+
+      // Acquire a second task with the same PID (should replace the first)
+      await acquireLock("/tmp", "Task 2");
+
+      // Should have only one task (the latest one)
+      lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe("Task 2");
+
+      await releaseLock();
+
+      // After release, no tasks should remain
+      const finalLockData = await readLockFile();
+      expect(finalLockData.tasks).toHaveLength(0);
+    });
+
+    it("should not duplicate tasks with same PID", async () => {
+      await acquireLock(TEST_DIR, "Task 1");
+
+      // Try to acquire again with same PID
+      await acquireLock(TEST_DIR, "Task 2");
+
+      // Should only have one task
+      const lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe("Task 2"); // Latest task
+
+      await releaseLock();
+    });
+  });
+
+  describe("lock file structure", () => {
+    it("should have all required fields", async () => {
+      await acquireLock(TEST_DIR, "Complete task");
+
+      const lockData = await readLockFile();
+      const task = lockData.tasks[0];
+
+      expect(task).toHaveProperty("cwd");
+      expect(task).toHaveProperty("task");
+      expect(task).toHaveProperty("pid");
+      expect(task).toHaveProperty("status");
+      expect(task).toHaveProperty("startedAt");
+      expect(task).toHaveProperty("lockedAt");
+
+      expect(typeof task.cwd).toBe("string");
+      expect(typeof task.task).toBe("string");
+      expect(typeof task.pid).toBe("number");
+      expect(typeof task.status).toBe("string");
+      expect(typeof task.startedAt).toBe("number");
+      expect(typeof task.lockedAt).toBe("number");
+
+      await releaseLock();
+    });
+
+    it("should have valid status values", async () => {
+      const validStatuses: Task["status"][] = ["running", "queued", "completed", "failed"];
+
+      for (const status of validStatuses) {
+        await acquireLock(TEST_DIR, `Task with ${status}`);
+        await updateCurrentTaskStatus(status);
+
+        const lockData = await readLockFile();
+        expect(lockData.tasks[0].status).toBe(status);
+
+        await releaseLock();
+      }
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle empty task description", async () => {
+      await acquireLock(TEST_DIR, "");
+
+      const lockData = await readLockFile();
+      expect(lockData.tasks[0].task).toBe("");
+
+      await releaseLock();
+    });
+
+    it("should handle special characters in task description", async () => {
+      const specialTask = "Task with \"quotes\" and 'apostrophes' and \n newlines";
+
+      await acquireLock(TEST_DIR, specialTask);
+
+      const lockData = await readLockFile();
+      expect(lockData.tasks[0].task).toContain("quotes");
+
+      await releaseLock();
+    });
+
+    it("should resolve symlinks to real paths", async () => {
+      await acquireLock(TEST_DIR, "Symlink test");
+
+      const lockData = await readLockFile();
+      // Should be an absolute path
+      expect(path.isAbsolute(lockData.tasks[0].cwd)).toBe(true);
+
+      await releaseLock();
+    });
+
+    it("should handle rapid acquire/release cycles", async () => {
+      for (let i = 0; i < 10; i++) {
+        await acquireLock(TEST_DIR, `Rapid task ${i}`);
+        await releaseLock();
+      }
+
+      // Final state should be clean
+      const lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(0);
+    });
+  });
+
+  describe("queueing behavior", () => {
+    it("should detect when lock is held by same git repo", async () => {
+      const gitRoot = execSync("git rev-parse --show-toplevel", {
+        cwd: process.cwd(),
+        encoding: "utf8",
+      }).trim();
+
+      // Acquire lock at root
+      await acquireLock(gitRoot, "Root task");
+
+      // Create a lock with different PID to simulate another process
+      const lockData = await readLockFile();
+      lockData.tasks.push({
+        cwd: path.join(gitRoot, "subdirectory"),
+        gitRoot: gitRoot,
+        task: "Subdirectory task",
+        pid: process.pid + 1,
+        status: "running",
+        startedAt: Date.now(),
+        lockedAt: Date.now(),
+      });
+      await writeFile(LOCK_FILE, JSON.stringify(lockData, null, 2));
+
+      // Both tasks should be in the same git repo
+      const updatedLockData = await readLockFile();
+      const gitRoots = updatedLockData.tasks.map((t) => t.gitRoot).filter((g) => g);
+      expect(new Set(gitRoots).size).toBe(1); // All same git root
+
+      await releaseLock();
+    });
+
+    it("should allow different directories without git repos", async () => {
+      // Test that when we already have a task, acquiring a new one replaces it
+      // (since both use the same PID)
+
+      // Create lock for /tmp manually
+      const lock = {
+        tasks: [
+          {
+            cwd: "/tmp",
+            task: "Tmp task",
+            pid: process.pid,
+            status: "running" as const,
+            startedAt: Date.now(),
+            lockedAt: Date.now(),
+          },
+        ],
+      };
+      await writeFile(LOCK_FILE, JSON.stringify(lock, null, 2));
+
+      // Verify initial state
+      let lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe("Tmp task");
+
+      // Acquire lock for different directory (should replace the existing task)
+      await acquireLock(TEST_DIR, "Test task");
+
+      // Should only have the new task
+      lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe("Test task");
+
+      await releaseLock();
+    });
+  });
+
+  describe("disableLock option", () => {
+    it("should respect lock file operations when disableLock is false", async () => {
+      // Clean up first
+      await rm(LOCK_FILE, { force: true });
+
+      // When disableLock is not used (default behavior), locks work normally
+      await acquireLock(TEST_DIR, "Test task");
+      expect(existsSync(LOCK_FILE)).toBe(true);
+
+      const lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+
+      await releaseLock();
+
+      const lockDataAfter = await readLockFile();
+      expect(lockDataAfter.tasks).toHaveLength(0);
+    });
+  });
+});
+
+// Helper functions
+
+async function cleanupLockFile() {
+  try {
+    await rm(LOCK_FILE, { force: true });
+  } catch {
+    // Ignore errors
+  }
+}
+
+async function readLockFile(): Promise<{ tasks: Task[] }> {
+  try {
+    const content = await readFile(LOCK_FILE, "utf8");
+    const lockFile = JSON.parse(content);
+    // Don't clean stale locks in tests - we want to see the raw data
+    return lockFile;
+  } catch {
+    return { tasks: [] };
+  }
+}