claude-yes 1.32.3 → 1.34.0

package/ts/index.ts

@@ -18,15 +18,17 @@ import { removeControlCharacters } from "./removeControlCharacters.ts";
 import { acquireLock, releaseLock, shouldUseLock } from "./runningLock.ts";
 import { logger } from "./logger.ts";
 import { createFifoStream } from "./beta/fifo.ts";
+import { PidStore } from "./pidStore.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import winston from "winston";
-import { mapObject, pipe } from "rambda";
 
 export { removeControlCharacters };
 
 export type AgentCliConfig = {
   // cli
-  install?: string; // hint user for install command if not installed
+  install?:
+    | string
+    | { powershell?: string; bash?: string; npm?: string; unix?: string; windows?: string }; // hint user for install command if not installed
   version?: string; // hint user for version command to check if installed
   binary?: string; // actual binary name if different from cli, e.g. cursor -> cursor-agent
   defaultArgs?: string[]; // function to ensure certain args are present
@@ -167,6 +169,10 @@ export default async function agentYes({
     });
   }
 
+  // Initialize process registry
+  const pidStore = new PidStore(workingDir);
+  await pidStore.init();
+
   process.stdin.setRawMode?.(true); // must be called any stdout/stdin usage
 
   let isFatal = false; // when true, do not restart on crash, and exit agent
@@ -187,23 +193,10 @@ export default async function agentYes({
 
   logger.debug(`Using ${ptyPackage} for pseudo terminal management.`);
 
-  const datetime = new Date().toISOString().replace(/\D/g, "").slice(0, 17);
-  const logPath = config.logsDir && path.resolve(config.logsDir, `${cli}-yes-${datetime}.log`);
-  const rawLogPath =
-    config.logsDir && path.resolve(config.logsDir, `${cli}-yes-${datetime}.raw.log`);
-  const rawLinesLogPath =
-    config.logsDir && path.resolve(config.logsDir, `${cli}-yes-${datetime}.lines.log`);
-  const debuggingLogsPath =
-    config.logsDir && path.resolve(config.logsDir, `${cli}-yes-${datetime}.debug.log`);
-
-  // add
-  if (debuggingLogsPath)
-    logger.add(
-      new winston.transports.File({
-        filename: debuggingLogsPath,
-        level: "debug",
-      }),
-    );
+  let logPath: string | false = false;
+  let rawLogPath: string | false = false;
+  let rawLinesLogPath: string | false = false;
+  let debuggingLogsPath: string | false = false;
 
   // Detect if running as sub-agent
   const isSubAgent = !!process.env.CLAUDE_PPID;
@@ -336,6 +329,41 @@ export default async function agentYes({
   }
   // Determine the actual cli command to run
 
+  // Helper function to get install command based on platform/availability
+  const getInstallCommand = (
+    installConfig:
+      | string
+      | { powershell?: string; bash?: string; npm?: string; unix?: string; windows?: string },
+  ): string | null => {
+    if (typeof installConfig === "string") {
+      return installConfig;
+    }
+
+    const isWindows = process.platform === "win32";
+    const platform = isWindows ? "windows" : "unix";
+
+    // Try platform-specific commands first
+    if (installConfig[platform]) {
+      return installConfig[platform];
+    }
+
+    // Try shell-specific commands
+    if (isWindows && installConfig.powershell) {
+      return installConfig.powershell;
+    }
+
+    if (!isWindows && installConfig.bash) {
+      return installConfig.bash;
+    }
+
+    // Fallback to npm if available
+    if (installConfig.npm) {
+      return installConfig.npm;
+    }
+
+    return null;
+  };
+
   const spawn = () => {
     const cliCommand = cliConf?.binary || cli;
     let [bin, ...args] = [...parseCommandString(cliCommand), ...cliArgs];
@@ -356,17 +384,21 @@ export default async function agentYes({
 
       const isNotFound = isCommandNotFoundError(error);
       if (cliConf?.install && isNotFound) {
-        logger.info(`Please install the cli by run ${cliConf.install}`);
+        const installCmd = getInstallCommand(cliConf.install);
+        if (!installCmd) {
+          logger.error(`No suitable install command found for ${cli} on this platform`);
+          throw error;
+        }
+
+        logger.info(`Please install the cli by run ${installCmd}`);
 
         if (install) {
           logger.info(`Attempting to install ${cli}...`);
-          execaCommandSync(cliConf.install, { stdio: "inherit" });
+          execaCommandSync(installCmd, { stdio: "inherit" });
           logger.info(`${cli} installed successfully. Please rerun the command.`);
           return spawn();
         } else {
-          logger.error(
-            `If you did not installed it yet, Please install it first: ${cliConf.install}`,
-          );
+          logger.error(`If you did not installed it yet, Please install it first: ${installCmd}`);
           throw error;
         }
       }
@@ -392,6 +424,22 @@ export default async function agentYes({
     },
     spawn,
   )();
+
+  // Register process in pidStore and compute log paths
+  await pidStore.registerProcess({ pid: shell.pid, cli, args: cliArgs, prompt });
+  logPath = pidStore.getLogPath(shell.pid);
+  rawLogPath = path.resolve(path.dirname(logPath), `${shell.pid}.raw.log`);
+  rawLinesLogPath = path.resolve(path.dirname(logPath), `${shell.pid}.lines.log`);
+  debuggingLogsPath = path.resolve(path.dirname(logPath), `${shell.pid}.debug.log`);
+
+  if (debuggingLogsPath)
+    logger.add(
+      new winston.transports.File({
+        filename: debuggingLogsPath,
+        level: "debug",
+      }),
+    );
+
   const pendingExitCode = Promise.withResolvers<number | null>();
 
   async function onData(data: string) {
@@ -407,6 +455,10 @@ export default async function agentYes({
     // Handle restart without continue args (e.g., "No conversation found to continue")
     // logger.debug(``, { shouldRestartWithoutContinue, robust })
     if (shouldRestartWithoutContinue) {
+      await pidStore.updateStatus(shell.pid, "exited", {
+        exitReason: "restarted",
+        exitCode: exitCode ?? undefined,
+      });
       shouldRestartWithoutContinue = false; // reset flag
       isFatal = false; // reset fatal flag to allow restart
 
@@ -419,6 +471,7 @@ export default async function agentYes({
       logger.info(`Restarting ${cli} ${JSON.stringify([bin, ...args])}`);
 
       shell = pty.spawn(bin!, args, getPtyOptions());
+      await pidStore.registerProcess({ pid: shell.pid, cli, args, prompt });
       shell.onData(onData);
       shell.onExit(onExit);
       return;
@@ -434,8 +487,18 @@ export default async function agentYes({
         );
         return;
       }
-      if (isFatal) return pendingExitCode.resolve(exitCode);
+      if (isFatal) {
+        await pidStore.updateStatus(shell.pid, "exited", {
+          exitReason: "fatal",
+          exitCode: exitCode ?? undefined,
+        });
+        return pendingExitCode.resolve(exitCode);
+      }
 
+      await pidStore.updateStatus(shell.pid, "exited", {
+        exitReason: "restarted",
+        exitCode: exitCode ?? undefined,
+      });
       logger.info(`${cli} crashed, restarting...`);
 
       // For codex, try to use stored session ID for this directory
@@ -452,10 +515,16 @@ export default async function agentYes({
       }
 
       shell = pty.spawn(cli, restoreArgs, getPtyOptions());
+      await pidStore.registerProcess({ pid: shell.pid, cli, args: restoreArgs, prompt });
       shell.onData(onData);
       shell.onExit(onExit);
       return;
     }
+    const exitReason = agentCrashed ? "crash" : "normal";
+    await pidStore.updateStatus(shell.pid, "exited", {
+      exitReason,
+      exitCode: exitCode ?? undefined,
+    });
     return pendingExitCode.resolve(exitCode);
   });
 
@@ -475,6 +544,7 @@ export default async function agentYes({
   const idleWaiter = new IdleWaiter();
   if (exitOnIdle)
     idleWaiter.wait(exitOnIdle).then(async () => {
+      await pidStore.updateStatus(shell.pid, "idle").catch(() => null);
       if (isStillWorkingQ()) {
         logger.warn("[${cli}-yes] ${cli} is idle, but seems still working, not exiting yet");
         return;
@@ -513,9 +583,10 @@ export default async function agentYes({
     // read from FIFO if available, e.g. /tmp/agent-yes-*.stdin, which can be used to send additional input from other processes
     .by((s) => {
       if (!useFifo) return s;
-      const fifoResult = createFifoStream(cli);
+      const fifoResult = createFifoStream(cli, pidStore.getFifoPath(shell.pid));
       if (!fifoResult) return s;
       pendingExitCode.promise.finally(() => fifoResult.cleanup());
+      process.stderr.write(`\n  Append prompts: ${cli}-yes --append-prompt '...'\n\n`);
       return s.merge(fifoResult.stream);
     })
 
@@ -539,7 +610,10 @@ export default async function agentYes({
       readable: shellOutputStream.readable,
     })
 
-    .forEach(() => idleWaiter.ping())
+    .forEach(() => {
+      idleWaiter.ping();
+      pidStore.updateStatus(shell.pid, "active").catch(() => null);
+    })
     .forEach(() => nextStdout.ready())
 
     .forkTo(async function rawLogger(f) {
@@ -695,6 +769,9 @@ export default async function agentYes({
   const exitCode = await pendingExitCode.promise;
   logger.info(`[${cli}-yes] ${cli} exited with code ${exitCode}`);
 
+  // Final pidStore cleanup
+  await pidStore.close();
+
   // Update task status.writable release lock
   await outputWriter.close();
 

package/ts/logger.ts

@@ -19,4 +19,3 @@ export const logger = winston.createLogger({
   ],
   silent: false,
 });
-

package/ts/parseCliArgs.ts

@@ -88,6 +88,15 @@ export function parseCliArgs(argv: string[]) {
       default: false,
       alias: "c",
     })
+    .option("append-prompt", {
+      type: "string",
+      description: "Send a prompt to the active agent's FIFO stdin in current directory",
+    })
+    .option("fifo", {
+      type: "boolean",
+      description: "Enable FIFO input stream for additional stdin input (Linux only)",
+      default: false,
+    })
     .positional("cli", {
       describe: "The AI CLI to run, e.g., claude, codex, copilot, cursor, gemini",
       type: "string",
@@ -180,5 +189,7 @@ export function parseCliArgs(argv: string[]) {
     verbose: parsedArgv.verbose,
     resume: parsedArgv.continue, // Note: intentional use resume here to avoid preserved keyword (continue)
     useSkills: parsedArgv.useSkills,
+    appendPrompt: parsedArgv.appendPrompt,
+    useFifo: parsedArgv.fifo,
   };
 }

package/ts/pidStore.ts

@@ -0,0 +1,135 @@
+import Datastore from "@seald-io/nedb";
+import { mkdir } from "fs/promises";
+import path from "path";
+import { logger } from "./logger.ts";
+
+export interface PidRecord {
+  pid: number;
+  cli: string;
+  args: string[];
+  prompt?: string;
+  logFile: string;
+  fifoFile: string;
+  status: "idle" | "active" | "exited";
+  exitReason: string;
+  exitCode?: number;
+  startedAt: number;
+  updatedAt: number;
+}
+
+export class PidStore {
+  protected db!: Datastore<PidRecord>;
+  private baseDir: string;
+
+  constructor(workingDir: string) {
+    this.baseDir = path.resolve(workingDir, ".agent-yes");
+  }
+
+  async init(): Promise<void> {
+    await mkdir(path.join(this.baseDir, "logs"), { recursive: true });
+    await mkdir(path.join(this.baseDir, "fifo"), { recursive: true });
+
+    this.db = new Datastore<PidRecord>({
+      filename: path.join(this.baseDir, "pid.jsonl"),
+      autoload: true,
+    });
+    await this.db.loadDatabaseAsync();
+    await this.cleanStaleRecords();
+  }
+
+  async registerProcess({
+    pid,
+    cli,
+    args,
+    prompt,
+  }: {
+    pid: number;
+    cli: string;
+    args: string[];
+    prompt?: string;
+  }): Promise<PidRecord> {
+    const now = Date.now();
+    const record: PidRecord = {
+      pid,
+      cli,
+      args,
+      prompt,
+      logFile: this.getLogPath(pid),
+      fifoFile: this.getFifoPath(pid),
+      status: "active",
+      exitReason: "",
+      startedAt: now,
+      updatedAt: now,
+    };
+    await this.db.insertAsync(record);
+    logger.debug(`[pidStore] Registered process ${pid}`);
+    return record;
+  }
+
+  async updateStatus(
+    pid: number,
+    status: PidRecord["status"],
+    extra?: { exitReason?: string; exitCode?: number },
+  ): Promise<void> {
+    const update: Partial<PidRecord> = {
+      status,
+      updatedAt: Date.now(),
+      ...extra,
+    };
+    await this.db.updateAsync({ pid }, { $set: update }, {});
+    logger.debug(`[pidStore] Updated process ${pid} status=${status}`);
+  }
+
+  getLogPath(pid: number): string {
+    return path.resolve(this.baseDir, "logs", `${pid}.log`);
+  }
+
+  getFifoPath(pid: number): string {
+    return path.resolve(this.baseDir, "fifo", `${pid}.stdin`);
+  }
+
+  async cleanStaleRecords(): Promise<void> {
+    const activeRecords = await this.db.findAsync({
+      status: { $ne: "exited" } as any,
+    });
+    for (const record of activeRecords) {
+      if (!this.isProcessAlive(record.pid)) {
+        await this.db.updateAsync(
+          { pid: record.pid },
+          {
+            $set: {
+              status: "exited" as const,
+              exitReason: "stale-cleanup",
+              updatedAt: Date.now(),
+            },
+          },
+          {},
+        );
+        logger.debug(`[pidStore] Cleaned stale record for PID ${record.pid}`);
+      }
+    }
+  }
+
+  async close(): Promise<void> {
+    await this.db.compactDatafileAsync();
+    logger.debug("[pidStore] Database compacted and closed");
+  }
+
+  private isProcessAlive(pid: number): boolean {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static async findActiveFifo(workingDir: string): Promise<string | null> {
+    const store = new PidStore(workingDir);
+    await store.init();
+    const records = await store.db.findAsync({ status: { $ne: "exited" } as any });
+    await store.close();
+    const sorted = records.sort((a, b) => b.startedAt - a.startedAt);
+    return sorted[0]?.fifoFile ?? null;
+  }
+}