wave-agent-sdk 1.0.4 → 1.0.6

package/src/managers/cronManager.ts

@@ -1,401 +0,0 @@
-import { Container } from "../utils/container.js";
-import { CronJob } from "../types/cron.js";
-import { AIManager } from "./aiManager.js";
-import { MessageManager } from "./messageManager.js";
-import { CronExpressionParser } from "cron-parser";
-import { logger } from "../utils/globalLogger.js";
-import {
-  readCronTasks,
-  addCronTask,
-  removeCronTasks,
-  markCronTasksFired,
-} from "../utils/cronTasks.js";
-import {
-  tryAcquireSchedulerLock,
-  releaseSchedulerLock,
-  registerSchedulerLockCleanup,
-} from "../utils/cronTasksLock.js";
-import { ensureWaveRuntimeFilesExcluded } from "../utils/gitUtils.js";
-
-export class CronManager {
-  private jobs = new Map<string, CronJob>();
-  private interval: NodeJS.Timeout | null = null;
-  private isOwner = false;
-  private lockProbeTimer: NodeJS.Timeout | null = null;
-  private cleanupSchedulerLock: (() => void) | null = null;
-  private sessionId: string;
-
-  constructor(
-    private container: Container,
-    sessionId?: string,
-  ) {
-    this.sessionId = sessionId ?? "unknown";
-  }
-
-  private get aiManager(): AIManager {
-    return this.container.get<AIManager>("AIManager")!;
-  }
-
-  private get messageManager(): MessageManager {
-    return this.container.get<MessageManager>("MessageManager")!;
-  }
-
-  public start(): void {
-    if (this.interval) return;
-
-    // Load durable tasks from file (best-effort, resilient to mocked fs in tests)
-    const workdir = this.container.get<string>("Workdir") ?? process.cwd();
-    let durableTasks: Awaited<ReturnType<typeof readCronTasks>> = [];
-    try {
-      durableTasks = readCronTasks(workdir) ?? [];
-      for (const task of durableTasks) {
-        // Recalculate runtime fields for loaded tasks
-        try {
-          const interval = CronExpressionParser.parse(task.cron);
-          const nextRunDate = interval.next().toDate();
-          const nextRun = nextRunDate.getTime();
-          const secondRunDate = interval.next().toDate();
-          const periodMs = secondRunDate.getTime() - nextRunDate.getTime();
-          const jitteredNextRun = this.applyJitter(
-            nextRun,
-            periodMs,
-            task.recurring,
-            nextRunDate,
-            task.id,
-          );
-          this.jobs.set(task.id, {
-            ...task,
-            nextRun: jitteredNextRun,
-            periodMs,
-          });
-        } catch (e) {
-          logger?.warn(
-            `CronManager: Failed to restore durable task ${task.id}:`,
-            e,
-          );
-        }
-      }
-    } catch (e) {
-      logger?.warn("CronManager: failed to load durable tasks from disk:", e);
-    }
-
-    this.interval = setInterval(() => this.checkJobs(), 60000);
-    this.interval.unref();
-
-    // Only acquire scheduler lock and register cleanup when durable tasks exist
-    if (durableTasks.length > 0) {
-      try {
-        this.tryLock(workdir);
-      } catch (e) {
-        logger?.warn("CronManager: failed to acquire scheduler lock:", e);
-      }
-      try {
-        this.cleanupSchedulerLock = registerSchedulerLockCleanup({
-          dir: workdir,
-          sessionId: this.sessionId,
-        });
-      } catch (e) {
-        logger?.warn("CronManager: failed to register lock cleanup:", e);
-      }
-    }
-  }
-
-  private tryLock(workdir: string): void {
-    ensureWaveRuntimeFilesExcluded(workdir);
-    tryAcquireSchedulerLock({ dir: workdir, sessionId: this.sessionId })
-      .then((acquired) => {
-        if (acquired) {
-          this.isOwner = true;
-          logger?.info("CronManager: acquired scheduler lock");
-        } else {
-          this.isOwner = false;
-          logger?.info(
-            "CronManager: another session owns the scheduler lock, will probe periodically",
-          );
-          // Set up periodic lock probe to take over if owner dies
-          this.startLockProbe(workdir);
-        }
-      })
-      .catch((err) => {
-        logger?.error("CronManager: failed to acquire scheduler lock:", err);
-      });
-  }
-
-  private ensureLock(workdir: string): void {
-    if (this.isOwner) return;
-    this.tryLock(workdir);
-    try {
-      this.cleanupSchedulerLock = registerSchedulerLockCleanup({
-        dir: workdir,
-        sessionId: this.sessionId,
-      });
-    } catch (e) {
-      logger?.warn("CronManager: failed to register lock cleanup:", e);
-    }
-  }
-
-  private startLockProbe(workdir: string): void {
-    if (this.lockProbeTimer) return;
-    this.lockProbeTimer = setInterval(() => {
-      if (this.isOwner) {
-        // Already acquired, stop probing
-        if (this.lockProbeTimer) {
-          clearInterval(this.lockProbeTimer);
-          this.lockProbeTimer = null;
-        }
-        return;
-      }
-      tryAcquireSchedulerLock({ dir: workdir, sessionId: this.sessionId })
-        .then((acquired) => {
-          if (acquired) {
-            this.isOwner = true;
-            logger?.info("CronManager: acquired scheduler lock (takeover)");
-            if (this.lockProbeTimer) {
-              clearInterval(this.lockProbeTimer);
-              this.lockProbeTimer = null;
-            }
-          }
-        })
-        .catch(() => {
-          // Ignore probe errors
-        });
-    }, 5000);
-    this.lockProbeTimer.unref();
-  }
-
-  public stop(): void {
-    if (this.interval) {
-      clearInterval(this.interval);
-      this.interval = null;
-    }
-    if (this.lockProbeTimer) {
-      clearInterval(this.lockProbeTimer);
-      this.lockProbeTimer = null;
-    }
-    if (this.cleanupSchedulerLock) {
-      this.cleanupSchedulerLock();
-      this.cleanupSchedulerLock = null;
-    }
-    const workdir = this.container.get<string>("Workdir") ?? process.cwd();
-    if (this.isOwner) {
-      releaseSchedulerLock({ dir: workdir, sessionId: this.sessionId }).catch(
-        () => {
-          // Best-effort cleanup
-        },
-      );
-    }
-  }
-
-  public createJob(
-    job: Omit<CronJob, "id" | "createdAt" | "nextRun" | "periodMs">,
-  ): CronJob {
-    const id = Math.random().toString(36).substring(2, 11);
-    const createdAt = Date.now();
-
-    const interval = CronExpressionParser.parse(job.cron);
-    const nextRunDate = interval.next().toDate();
-    const nextRun = nextRunDate.getTime();
-
-    // Calculate periodMs
-    const secondRunDate = interval.next().toDate();
-    const periodMs = secondRunDate.getTime() - nextRunDate.getTime();
-
-    // Apply Jitter
-    const jitteredNextRun = this.applyJitter(
-      nextRun,
-      periodMs,
-      job.recurring,
-      nextRunDate,
-      id,
-    );
-
-    const newJob: CronJob = {
-      ...job,
-      id,
-      createdAt,
-      nextRun: jitteredNextRun,
-      periodMs,
-    };
-
-    this.jobs.set(id, newJob);
-
-    // Persist durable jobs to file
-    if (job.durable) {
-      try {
-        const workdir = this.container.get<string>("Workdir") ?? process.cwd();
-        addCronTask(newJob, workdir);
-        this.ensureLock(workdir);
-      } catch (e) {
-        logger?.warn(
-          `CronManager: failed to persist durable job ${id} to disk:`,
-          e,
-        );
-      }
-    }
-
-    return newJob;
-  }
-
-  public deleteJob(id: string): boolean {
-    const job = this.jobs.get(id);
-    const deleted = this.jobs.delete(id);
-
-    // Remove durable jobs from file
-    if (deleted && job?.durable) {
-      try {
-        const workdir = this.container.get<string>("Workdir") ?? process.cwd();
-        removeCronTasks([id], workdir);
-      } catch (e) {
-        logger?.warn(
-          `CronManager: failed to remove durable job ${id} from disk:`,
-          e,
-        );
-      }
-    }
-
-    return deleted;
-  }
-
-  public listJobs(): CronJob[] {
-    return Array.from(this.jobs.values());
-  }
-
-  private applyJitter(
-    nextRun: number,
-    periodMs: number,
-    recurring: boolean,
-    nextRunDate: Date,
-    id: string,
-  ): number {
-    const deterministicRandom = this.getDeterministicRandom(id);
-    if (recurring) {
-      // Recurring: Random delay up to 10% of period (max 15 min)
-      const maxJitter = Math.min(periodMs * 0.1, 15 * 60 * 1000);
-      return nextRun + deterministicRandom * maxJitter;
-    } else {
-      // One-shot: Random early fire up to 90s if scheduled on :00 or :30
-      const minutes = nextRunDate.getMinutes();
-      const seconds = nextRunDate.getSeconds();
-      if ((minutes === 0 || minutes === 30) && seconds === 0) {
-        return nextRun - deterministicRandom * 90 * 1000;
-      }
-    }
-    return nextRun;
-  }
-
-  private getDeterministicRandom(id: string): number {
-    let hash = 0;
-    for (let i = 0; i < id.length; i++) {
-      const char = id.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash |= 0; // Convert to 32bit integer
-    }
-    // Use a simple LCG-like approach to get a value between 0 and 1
-    const x = Math.sin(hash) * 10000;
-    return x - Math.floor(x);
-  }
-
-  private async checkJobs(): Promise<void> {
-    const now = Date.now();
-    const aiManager = this.aiManager;
-    const messageManager = this.messageManager;
-    const workdir = this.container.get<string>("Workdir") ?? process.cwd();
-
-    for (const [id, job] of this.jobs.entries()) {
-      // Expiration: Recurring jobs MUST auto-expire after 7 days
-      if (job.recurring && now - job.createdAt > 7 * 24 * 60 * 60 * 1000) {
-        this.jobs.delete(id);
-        if (job.durable) {
-          try {
-            removeCronTasks([id], workdir);
-          } catch (e) {
-            logger?.warn(
-              `CronManager: failed to remove expired durable job ${id} from disk:`,
-              e,
-            );
-          }
-        }
-        continue;
-      }
-
-      if (now >= job.nextRun) {
-        // Durable tasks only fire if we hold the scheduler lock
-        if (job.durable && !this.isOwner) {
-          continue;
-        }
-
-        // Idle-Check: Only fire jobs if AIManager.isLoading is false
-        if (aiManager.isLoading) {
-          logger?.debug(`CronManager: Skipping job ${id} because AI is busy`);
-          continue;
-        }
-
-        logger?.info(`CronManager: Firing job ${id}: ${job.prompt}`);
-
-        // Execution
-        messageManager.addUserMessage({ content: job.prompt });
-        aiManager.sendAIMessage().catch((err) => {
-          logger?.error(`CronManager: Failed to execute job ${id}`, err);
-        });
-
-        if (job.recurring) {
-          // Schedule next run
-          try {
-            const interval = CronExpressionParser.parse(job.cron, {
-              currentDate: new Date(job.nextRun + 1000),
-            });
-            const nextRunDate = interval.next().toDate();
-            const nextRun = nextRunDate.getTime();
-            job.nextRun = this.applyJitter(
-              nextRun,
-              job.periodMs,
-              true,
-              nextRunDate,
-              id,
-            );
-
-            // For durable recurring tasks, batch-write lastFiredAt
-            if (job.durable) {
-              try {
-                markCronTasksFired([id], now, workdir);
-              } catch (e) {
-                logger?.warn(
-                  `CronManager: failed to update lastFiredAt for durable job ${id}:`,
-                  e,
-                );
-              }
-            }
-          } catch (e) {
-            logger?.error(
-              `CronManager: Failed to parse cron for recurring job ${id}`,
-              e,
-            );
-            this.jobs.delete(id);
-            if (job.durable) {
-              try {
-                removeCronTasks([id], workdir);
-              } catch (fileErr) {
-                logger?.warn(
-                  `CronManager: failed to remove durable job ${id} from disk:`,
-                  fileErr,
-                );
-              }
-            }
-          }
-        } else {
-          this.jobs.delete(id);
-          if (job.durable) {
-            try {
-              removeCronTasks([id], workdir);
-            } catch (e) {
-              logger?.warn(
-                `CronManager: failed to remove durable job ${id} from disk:`,
-                e,
-              );
-            }
-          }
-        }
-      }
-    }
-  }
-}

package/src/managers/foregroundTaskManager.ts

@@ -1,30 +0,0 @@
-import { ForegroundTask, IForegroundTaskManager } from "../types/processes.js";
-import { Container } from "../utils/container.js";
-
-export class ForegroundTaskManager implements IForegroundTaskManager {
-  private activeForegroundTasks: ForegroundTask[] = [];
-
-  constructor(private container: Container) {}
-
-  public registerForegroundTask(task: ForegroundTask): void {
-    this.activeForegroundTasks.push(task);
-  }
-
-  public unregisterForegroundTask(id: string): void {
-    this.activeForegroundTasks = this.activeForegroundTasks.filter(
-      (t) => t.id !== id,
-    );
-  }
-
-  public async backgroundCurrentTask(): Promise<void> {
-    const tasks = [...this.activeForegroundTasks].reverse();
-    this.activeForegroundTasks = [];
-    for (const task of tasks) {
-      await task.backgroundHandler();
-    }
-  }
-
-  public hasActiveTasks(): boolean {
-    return this.activeForegroundTasks.length > 0;
-  }
-}

package/src/managers/forkedAgentManager.ts

@@ -1,216 +0,0 @@
-import { randomUUID } from "crypto";
-import * as os from "os";
-import * as fs from "fs";
-import * as path from "path";
-import type { Message } from "../types/index.js";
-import { logger } from "../utils/globalLogger.js";
-import { Container } from "../utils/container.js";
-import { SubagentManager, type SubagentInstance } from "./subagentManager.js";
-import type { PermissionMode } from "../types/permissions.js";
-
-export interface ForkedAgentEntry {
-  id: string;
-  instance: SubagentInstance;
-  logPath: string;
-  logStream?: fs.WriteStream;
-  status: "running" | "completed" | "failed";
-}
-
-export interface ForkedAgentManagerCallbacks {
-  onForkedAgentStatusChange?: (entries: ForkedAgentEntry[]) => void;
-}
-
-export class ForkedAgentManager {
-  private activeForks = new Map<string, ForkedAgentEntry>();
-  private inFlightPromises = new Set<Promise<void>>();
-  private callbacks: ForkedAgentManagerCallbacks;
-
-  constructor(
-    private container: Container,
-    options: { callbacks?: ForkedAgentManagerCallbacks } = {},
-  ) {
-    this.callbacks = options.callbacks || {};
-  }
-
-  private get subagentManager(): SubagentManager {
-    return this.container.get<SubagentManager>("SubagentManager")!;
-  }
-
-  /**
-   * Creates a forked subagent with conversation history and executes it asynchronously (fire-and-forget).
-   * Does NOT interact with BackgroundTaskManager.
-   */
-  async forkAndExecute(
-    subagentType: string,
-    messages: Message[],
-    parameters: {
-      description: string;
-      allowedTools?: string[];
-      model?: string;
-      permissionModeOverride?: PermissionMode;
-      maxTurns?: number;
-    },
-    prompt: string,
-  ): Promise<string> {
-    const id = randomUUID();
-
-    // Create log file for debugging
-    const logPath = path.join(os.tmpdir(), `wave-forked-agent-${id}.log`);
-    const logStream = fs.createWriteStream(logPath, { flags: "a" });
-
-    const entry: ForkedAgentEntry = {
-      id,
-      instance: {} as SubagentInstance, // Temporary placeholder
-      logPath,
-      logStream,
-      status: "running",
-    };
-    this.activeForks.set(id, entry);
-
-    // Fire-and-forget execution
-    const forkPromise = this.executeFork(
-      entry,
-      subagentType,
-      messages,
-      parameters,
-      prompt,
-    ).catch((error) => {
-      logger.error("Forked agent execution failed:", error);
-    });
-    this.inFlightPromises.add(forkPromise);
-    forkPromise.finally(() => this.inFlightPromises.delete(forkPromise));
-
-    return id;
-  }
-
-  private async executeFork(
-    entry: ForkedAgentEntry,
-    subagentType: string,
-    messages: Message[],
-    parameters: {
-      description: string;
-      allowedTools?: string[];
-      model?: string;
-      permissionModeOverride?: PermissionMode;
-      maxTurns?: number;
-    },
-    prompt: string,
-  ): Promise<void> {
-    try {
-      const configuration =
-        await this.subagentManager.findSubagent(subagentType);
-      if (!configuration) {
-        throw new Error(`Subagent type ${subagentType} not found`);
-      }
-
-      const instance = await this.subagentManager.createInstance(
-        configuration,
-        {
-          description: parameters.description,
-          subagent_type: subagentType,
-          prompt: "",
-          allowedTools: parameters.allowedTools,
-          model: parameters.model,
-          permissionModeOverride: parameters.permissionModeOverride,
-          maxTurns: parameters.maxTurns,
-        },
-        false,
-      );
-
-      // Pre-load the message manager with conversation history
-      instance.messageManager.setMessages(messages);
-      instance.logStream = entry.logStream;
-
-      entry.instance = instance;
-
-      // Execute the agent asynchronously
-      const result = await this.subagentManager.executeAgent(
-        instance,
-        prompt,
-        undefined,
-        false, // NOT runInBackground — we handle logging ourselves
-      );
-
-      // Write final response and completion to log
-      try {
-        if (entry.logStream && !entry.logStream.destroyed) {
-          entry.logStream.write(
-            `[${new Date().toISOString()}] Final response:\n${result}\n`,
-          );
-          entry.logStream.write(
-            `[${new Date().toISOString()}] Agent completed\n`,
-          );
-          entry.logStream.end();
-        }
-      } catch {
-        // Stream may have been destroyed during cleanup
-      }
-
-      entry.status = "completed";
-      this.notifyChange();
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-
-      try {
-        if (entry.logStream && !entry.logStream.destroyed) {
-          entry.logStream.write(
-            `[${new Date().toISOString()}] Agent failed: ${errorMessage}\n`,
-          );
-          entry.logStream.end();
-        }
-      } catch {
-        // Stream may have been destroyed during cleanup
-      }
-
-      entry.status = "failed";
-      this.notifyChange();
-    }
-  }
-
-  /**
-   * Abort a running forked agent.
-   */
-  stop(id: string): boolean {
-    const entry = this.activeForks.get(id);
-    if (!entry) {
-      return false;
-    }
-
-    entry.instance?.aiManager?.abortAIMessage();
-    entry.logStream?.destroy();
-    this.activeForks.delete(id);
-    this.notifyChange();
-    return true;
-  }
-
-  /**
-   * Stop all running forked agents, wait for in-flight executions to settle, and clear the map.
-   */
-  async cleanup(): Promise<void> {
-    for (const [, entry] of this.activeForks) {
-      entry.instance?.aiManager?.abortAIMessage();
-      // Suppress async write errors from in-flight writes
-      entry.logStream?.on("error", () => {});
-      entry.logStream?.destroy();
-    }
-    this.activeForks.clear();
-    this.notifyChange();
-    // Wait for all in-flight fork executions to settle before returning
-    await Promise.allSettled(this.inFlightPromises);
-    this.inFlightPromises.clear();
-  }
-
-  /**
-   * Returns list of active forked agents.
-   */
-  getActiveForks(): ForkedAgentEntry[] {
-    return Array.from(this.activeForks.values());
-  }
-
-  private notifyChange(): void {
-    this.callbacks.onForkedAgentStatusChange?.(
-      Array.from(this.activeForks.values()),
-    );
-  }
-}