@pellux/goodvibes-tui 0.18.4

package/src/runtime/tasks/adapters/process-adapter.ts

@@ -0,0 +1,214 @@
+/**
+ * ProcessTaskAdapter — bridges ProcessManager background processes into the
+ * unified RuntimeTask registry.
+ *
+ * Each spawned background process gets a corresponding RuntimeTask of kind
+ * 'exec'. The adapter tracks the pid→taskId mapping and reconciles state
+ * on demand via sync().
+ *
+ * NOTE: This adapter writes directly to the Zustand store for performance,
+ * bypassing TaskManager. Lifecycle validation is the caller's responsibility.
+ * This is intentional — adapters are authoritative sources for their subsystem.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { createDomainDispatch } from '../../store/index.ts';
+import type { RuntimeStore, DomainDispatch } from '../../store/index.ts';
+import type { RuntimeTask } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
+import { ProcessManager } from '@pellux/goodvibes-sdk/platform/tools/shared/process-manager';
+
+/** Owner context supplied when wrapping a process. */
+export interface ProcessOwner {
+  /** Session ID that spawned this process. */
+  sessionId: string;
+  /** Optional agent ID that owns this process. */
+  agentId?: string;
+}
+
+/**
+ * Bridges ProcessManager background processes into the RuntimeTask registry.
+ *
+ * @example
+ * ```ts
+ * const adapter = new ProcessTaskAdapter(store);
+ * const taskId = adapter.wrapProcess(proc.pid, 'npm run build', { sessionId: 'sess_1' });
+ * // later...
+ * adapter.handleProcessExit(proc.pid, 0);
+ * ```
+ */
+export class ProcessTaskAdapter {
+  /** Maps process internal ID (bg_N_ts) → task ID. */
+  private readonly _idToTask = new Map<string, string>();
+  /** Maps task ID → process internal ID. */
+  private readonly _taskToId = new Map<string, string>();
+  /** Maps pid → process internal ID (for exit handling). */
+  private readonly _pidToId = new Map<number, string>();
+
+  private readonly _manager: ProcessManager;
+  private readonly _dispatch: DomainDispatch;
+
+  constructor(
+    private readonly _store: RuntimeStore,
+    manager: ProcessManager,
+  ) {
+    this._manager = manager;
+    this._dispatch = createDomainDispatch(_store);
+  }
+
+  // ── Core API ────────────────────────────────────────────────────────────────
+
+  /**
+   * Wrap a spawned process as a RuntimeTask.
+   *
+   * @param processId - The ProcessManager internal ID (process_id from spawn result).
+   * @param pid - OS process ID.
+   * @param command - The shell command string for display.
+   * @param owner - Session/agent that owns this process.
+   * @returns The new task ID.
+   */
+  wrapProcess(
+    processId: string,
+    pid: number,
+    command: string,
+    owner: ProcessOwner,
+  ): string {
+    // Idempotent: if already wrapped, return existing task ID
+    const existing = this._idToTask.get(processId);
+    if (existing !== undefined) return existing;
+
+    const taskId = randomUUID();
+    const now = Date.now();
+
+    const task: RuntimeTask = {
+      id: taskId,
+      kind: 'exec',
+      title: command.length > 80 ? `${command.slice(0, 77)}...` : command,
+      description: command,
+      status: 'running',
+      owner: owner.agentId ?? owner.sessionId,
+      cancellable: true,
+      childTaskIds: [],
+      queuedAt: now,
+      startedAt: now,
+      correlationId: owner.sessionId,
+      turnId: owner.agentId,
+    };
+
+    this._idToTask.set(processId, taskId);
+    this._taskToId.set(taskId, processId);
+    this._pidToId.set(pid, processId);
+
+    this._upsertTask(task);
+    return taskId;
+  }
+
+  /**
+   * Update task status when a process exits.
+   *
+   * @param pid - OS process ID that exited.
+   * @param exitCode - Process exit code (0 = success).
+   */
+  handleProcessExit(pid: number, exitCode: number): void {
+    const processId = this._pidToId.get(pid);
+    if (processId === undefined) return;
+
+    const taskId = this._idToTask.get(processId);
+    if (taskId === undefined) return;
+
+    this._pidToId.delete(pid);
+
+    this._transitionTask(taskId, exitCode === 0 ? 'completed' : 'failed', {
+      exitCode,
+      error: exitCode !== 0 ? `Process exited with code ${exitCode}` : undefined,
+    });
+  }
+
+  /**
+   * Cancel a process task by task ID.
+   * Stops the underlying process via ProcessManager and marks the task cancelled.
+   *
+   * @param taskId - The RuntimeTask ID to cancel.
+   */
+  cancelProcess(taskId: string): void {
+    const processId = this._taskToId.get(taskId);
+    if (processId === undefined) return;
+
+    // Look up the pid before stopping so we can clean up _pidToId
+    const entry = this._manager.getStatus(processId);
+    this._manager.stop(processId);
+    if (entry !== undefined) {
+      this._pidToId.delete(entry.pid);
+    }
+    this._transitionTask(taskId, 'cancelled', {});
+  }
+
+  /**
+   * Reconcile adapter state with the RuntimeTask registry.
+   *
+   * Scans all ProcessManager processes:
+   * - Wraps any un-tracked processes as new tasks (with a fallback owner).
+   * - Marks completed (done) processes as completed or failed in the task store.
+   * - Removes task mappings for processes that have been cleaned up.
+   *
+   * @param defaultOwner - Owner context used when auto-wrapping unknown processes.
+   */
+  sync(defaultOwner: ProcessOwner = { sessionId: 'system' }): void {
+    const liveProcesses = this._manager.list();
+    const liveIds = new Set(liveProcesses.map((p) => p.id));
+
+    // Handle processes not yet tracked
+    for (const proc of liveProcesses) {
+      if (!this._idToTask.has(proc.id)) {
+        // Use the real pid from list() for accurate _pidToId tracking
+        this.wrapProcess(proc.id, proc.pid, proc.cmd, defaultOwner);
+      }
+
+      // Check if the process has finished
+      const entry = this._manager.getStatus(proc.id);
+      if (entry?.done) {
+        const taskId = this._idToTask.get(proc.id);
+        if (taskId !== undefined) {
+          const exitCode = entry.exitCode ?? 1;
+          this._transitionTask(taskId, exitCode === 0 ? 'completed' : 'failed', {
+            exitCode,
+            error: exitCode !== 0 ? `Process exited with code ${exitCode}` : undefined,
+          });
+        }
+      }
+    }
+
+    // Clean up stale mappings for processes no longer tracked by the manager
+    const staleProcessIds: string[] = [];
+    for (const [processId] of this._idToTask.entries()) {
+      if (!liveIds.has(processId)) staleProcessIds.push(processId);
+    }
+    for (const processId of staleProcessIds) {
+      const taskId = this._idToTask.get(processId)!;
+      this._idToTask.delete(processId);
+      this._taskToId.delete(taskId);
+    }
+  }
+
+  // ── Private helpers ─────────────────────────────────────────────────────────
+
+  private _upsertTask(task: RuntimeTask): void {
+    this._dispatch.syncRuntimeTask(task, 'process-adapter');
+  }
+
+  private _transitionTask(
+    taskId: string,
+    status: 'completed' | 'failed' | 'cancelled',
+    extras: { exitCode?: number; error?: string },
+  ): void {
+    this._dispatch.transitionRuntimeTask(
+      taskId,
+      status,
+      {
+        endedAt: Date.now(),
+        exitCode: extras.exitCode,
+        error: extras.error,
+      },
+      'process-adapter',
+    );
+  }
+}

package/src/runtime/tasks/adapters/scheduler-adapter.ts

@@ -0,0 +1,193 @@
+/**
+ * SchedulerTaskAdapter — bridges TaskScheduler scheduled job executions into
+ * the unified RuntimeTask registry.
+ *
+ * Each time a scheduled task fires (i.e. TaskRunRecord is created), a
+ * corresponding RuntimeTask of kind 'scheduler' is registered. The adapter
+ * tracks runRecord agentId → task ID and handles completion via state sync.
+ *
+ * NOTE: This adapter writes directly to the Zustand store for performance,
+ * bypassing TaskManager. Lifecycle validation is the caller's responsibility.
+ * This is intentional — adapters are authoritative sources for their subsystem.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { createDomainDispatch } from '../../store/index.ts';
+import type { RuntimeStore, DomainDispatch } from '../../store/index.ts';
+import type { RuntimeTask } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
+import type { TaskScheduler, ScheduledTask, TaskRunRecord } from '@pellux/goodvibes-sdk/platform/scheduler/scheduler';
+
+/**
+ * Bridges TaskScheduler job executions into the RuntimeTask registry.
+ *
+ * The scheduler runs jobs that spawn agent sessions. Each run is tracked as a
+ * RuntimeTask of kind 'scheduler'. The run's agentId is used as the correlation
+ * key between the scheduler's TaskRunRecord and the RuntimeTask.
+ *
+ * @example
+ * ```ts
+ * const adapter = new SchedulerTaskAdapter(store);
+ * // When a scheduled task fires:
+ * const taskId = adapter.wrapScheduledRun(record, scheduledTask);
+ * // When the run completes:
+ * adapter.handleRunComplete(record.agentId, 'completed');
+ * ```
+ */
+export class SchedulerTaskAdapter {
+  /** Maps run agentId → task ID. */
+  private readonly _runToTask = new Map<string, string>();
+  /** Maps task ID → run agentId. */
+  private readonly _taskToRun = new Map<string, string>();
+
+  private readonly _dispatch: DomainDispatch;
+
+  constructor(private readonly _store: RuntimeStore) {
+    this._dispatch = createDomainDispatch(_store);
+  }
+
+  // ── Core API ────────────────────────────────────────────────────────────────
+
+  /**
+   * Wrap a scheduled task run as a RuntimeTask.
+   *
+   * @param record - The TaskRunRecord from the scheduler.
+   * @param scheduledTask - The parent ScheduledTask definition.
+   * @returns The new task ID.
+   */
+  wrapScheduledRun(record: TaskRunRecord, scheduledTask: ScheduledTask): string {
+    // Idempotent: return existing if already wrapped
+    const existing = this._runToTask.get(record.agentId);
+    if (existing !== undefined) return existing;
+
+    const taskId = randomUUID();
+    const now = record.startedAt;
+
+    const task: RuntimeTask = {
+      id: taskId,
+      kind: 'scheduler',
+      title: `Scheduled: ${scheduledTask.name}`,
+      description: scheduledTask.prompt.length > 200
+        ? `${scheduledTask.prompt.slice(0, 197)}...`
+        : scheduledTask.prompt,
+      status: record.status === 'running' ? 'running' : 'completed',
+      owner: `scheduler:${scheduledTask.id}`,
+      cancellable: record.status === 'running',
+      childTaskIds: [],
+      queuedAt: now,
+      startedAt: now,
+      endedAt: record.status !== 'running' ? Date.now() : undefined,
+      correlationId: record.agentId,
+      turnId: record.taskId,
+      error: record.error,
+    };
+
+    this._runToTask.set(record.agentId, taskId);
+    this._taskToRun.set(taskId, record.agentId);
+
+    this._upsertTask(task);
+    return taskId;
+  }
+
+  /**
+   * Handle a scheduled run completion or failure.
+   *
+   * @param runAgentId - The agentId from the TaskRunRecord.
+   * @param status - Terminal status: 'completed' or 'failed'.
+   * @param error - Optional error message if status is 'failed'.
+   */
+  handleRunComplete(
+    runAgentId: string,
+    status: 'completed' | 'failed',
+    error?: string,
+  ): void {
+    const taskId = this._runToTask.get(runAgentId);
+    if (taskId === undefined) return;
+
+    this._transitionTask(taskId, status, { error });
+    this._runToTask.delete(runAgentId);
+    this._taskToRun.delete(taskId);
+  }
+
+  /**
+   * Cancel a scheduled run task by task ID.
+   * Marks the task as cancelled. The caller is responsible for disabling the
+   * scheduled task via TaskScheduler.setEnabled().
+   *
+   * @param taskId - The RuntimeTask ID to cancel.
+   */
+  cancelScheduled(taskId: string): void {
+    const runAgentId = this._taskToRun.get(taskId);
+    if (runAgentId === undefined) return;
+
+    this._transitionTask(taskId, 'cancelled', {});
+    this._runToTask.delete(runAgentId);
+    this._taskToRun.delete(taskId);
+  }
+
+  /**
+   * Reconcile adapter state with the current TaskScheduler snapshot.
+   *
+   * Scans all run history records from the scheduler:
+   * - Wraps any un-tracked running jobs as new tasks.
+   * - Marks completed/failed jobs that are still showing as running.
+   *
+   * @param scheduler - The TaskScheduler instance to sync from.
+   */
+  sync(scheduler: TaskScheduler): void {
+    const scheduledTasks = scheduler.list();
+    const scheduledTaskMap = new Map<string, ScheduledTask>(
+      scheduledTasks.map((t) => [t.id, t]),
+    );
+
+    const allHistory = scheduler.getAllHistory();
+    const runningRuns = allHistory.filter((r) => r.status === 'running');
+
+    for (const record of runningRuns) {
+      const scheduledTask = scheduledTaskMap.get(record.taskId);
+      if (!scheduledTask) continue;
+
+      if (!this._runToTask.has(record.agentId)) {
+        this.wrapScheduledRun(record, scheduledTask);
+      }
+    }
+
+    // Reconcile tracked runs that are no longer running.
+    // Build a Map for O(1) history lookups — acceptable O(n) build at current scheduler scale.
+    const historyByAgentId = new Map<string, TaskRunRecord>(allHistory.map((r) => [r.agentId, r]));
+    const runningAgentIds = new Set(runningRuns.map((r) => r.agentId));
+    const staleRunIds: string[] = [];
+    for (const [runAgentId] of this._runToTask.entries()) {
+      if (!runningAgentIds.has(runAgentId)) staleRunIds.push(runAgentId);
+    }
+    for (const runAgentId of staleRunIds) {
+      const taskId = this._runToTask.get(runAgentId)!;
+      const record = historyByAgentId.get(runAgentId);
+      const terminalStatus = record?.status === 'failed' ? 'failed' : 'completed';
+      this._transitionTask(taskId, terminalStatus, { error: record?.error });
+      this._runToTask.delete(runAgentId);
+      this._taskToRun.delete(taskId);
+    }
+  }
+
+  // ── Private helpers ─────────────────────────────────────────────────────────
+
+  private _upsertTask(task: RuntimeTask): void {
+    this._dispatch.syncRuntimeTask(task, 'scheduler-adapter');
+  }
+
+  private _transitionTask(
+    taskId: string,
+    status: 'completed' | 'failed' | 'cancelled',
+    opts: { error?: string },
+  ): void {
+    this._dispatch.transitionRuntimeTask(
+      taskId,
+      status,
+      {
+        endedAt: Date.now(),
+        error: opts.error,
+      },
+      'scheduler-adapter',
+    );
+  }
+}

package/src/runtime/tasks/index.ts

@@ -0,0 +1,68 @@
+/**
+ * Runtime Tasks — barrel exports and factory.
+ *
+ * Usage:
+ * ```ts
+ * import { createTaskManager } from './tasks/index.ts';
+ *
+ * const taskManager = createTaskManager(store, bus, sessionId);
+ * const task = taskManager.createTask({ kind: 'exec', title: 'Run lint', owner: 'exec-tool' });
+ * taskManager.startTask(task.id);
+ * taskManager.completeTask(task.id);
+ * ```
+ */
+
+// ── Types ────────────────────────────────────────────────────────────────────
+export type {
+  TaskManager,
+  TaskCreateParams,
+  TaskUpdateParams,
+  TaskCancelParams,
+  TaskFailParams,
+} from '@pellux/goodvibes-sdk/platform/runtime/tasks/types';
+
+// ── Lifecycle ─────────────────────────────────────────────────────────────────
+export {
+  canTransition,
+  getValidTransitions,
+  isTerminalStatus,
+} from '@pellux/goodvibes-sdk/platform/runtime/tasks/lifecycle';
+
+// ── Registry ──────────────────────────────────────────────────────────────────
+export { TaskRegistry } from '@pellux/goodvibes-sdk/platform/runtime/tasks/registry';
+
+// ── Manager ───────────────────────────────────────────────────────────────────
+export {
+  UnifiedTaskManager,
+  TaskTransitionError,
+  TaskNotFoundError,
+  TaskNotCancellableError,
+} from './manager.ts';
+
+// ── Factory ───────────────────────────────────────────────────────────────────
+import type { RuntimeStore } from '../store/index.ts';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { TaskManager } from '@pellux/goodvibes-sdk/platform/runtime/tasks/types';
+import { UnifiedTaskManager } from './manager.ts';
+
+/**
+ * Creates a fully initialized UnifiedTaskManager bound to the given
+ * Zustand store, RuntimeEventBus, and session identifier.
+ *
+ * @param store - The runtime Zustand store.
+ * @param bus - The RuntimeEventBus for event emission.
+ * @param sessionId - Current session identifier (used in emitter context).
+ * @returns A TaskManager instance ready for use.
+ *
+ * @example
+ * ```ts
+ * const taskManager = createTaskManager(store, bus, sessionId);
+ * ```
+ */
+export function createTaskManager(
+  store: RuntimeStore,
+  bus: RuntimeEventBus,
+  sessionId: string
+): TaskManager {
+  return new UnifiedTaskManager(store, bus, sessionId);
+}