@tagma/sdk 0.7.4 → 0.7.6

package/src/pipeline-runner.test.ts

@@ -1,144 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { bootstrapBuiltins } from './bootstrap';
-import { PipelineRunner } from './pipeline-runner';
-import { PluginRegistry } from './registry';
-import type { PipelineConfig, TagmaRuntime, TaskResult } from './types';
-
-function makeDir(): string {
-  return mkdtempSync(join(tmpdir(), 'tagma-pipeline-runner-'));
-}
-
-function bindingsPipeline(dir: string): PipelineConfig {
-  return {
-    name: 'runner-snapshot',
-    tracks: [
-      {
-        id: 't',
-        name: 'T',
-        tasks: [
-          {
-            id: 'up',
-            name: 'up',
-            command: 'emit-city',
-            outputs: { city: { type: 'string' } },
-          },
-          {
-            id: 'down',
-            name: 'down',
-            depends_on: ['up'],
-            command: 'echo-city "{{inputs.city}}"',
-            inputs: { city: { from: 't.up.outputs.city', type: 'string', required: true } },
-          },
-        ],
-      },
-    ],
-  };
-}
-
-function taskResult(stdout: string): TaskResult {
-  return {
-    exitCode: 0,
-    stdout,
-    stderr: '',
-    stdoutPath: null,
-    stderrPath: null,
-    stdoutBytes: stdout.length,
-    stderrBytes: 0,
-    durationMs: 1,
-    sessionId: null,
-    normalizedOutput: null,
-    failureKind: null,
-  };
-}
-
-function fakeRuntime(): TagmaRuntime {
-  return {
-    async runCommand(command) {
-      return command.startsWith('emit-city')
-        ? taskResult('{"city":"Shanghai"}\n')
-        : taskResult('Shanghai\n');
-    },
-    async runSpawn() {
-      throw new Error('runSpawn should not be called');
-    },
-    async ensureDir() {
-      /* no-op */
-    },
-    async fileExists() {
-      return false;
-    },
-    async *watch() {
-      /* no-op */
-    },
-    logStore: {
-      openRunLog({ runId }) {
-        return {
-          path: `mem://${runId}/pipeline.log`,
-          dir: `mem://${runId}`,
-          append() {
-            /* memory sink */
-          },
-          close() {
-            /* memory sink */
-          },
-        };
-      },
-      taskOutputPath({ runId, taskId, stream }) {
-        return `mem://${runId}/${taskId}.${stream}`;
-      },
-      logsDir() {
-        return 'mem://logs';
-      },
-    },
-    now: () => new Date('2026-04-26T00:00:00.000Z'),
-    sleep: () => Promise.resolve(),
-  };
-}
-
-async function run(config: PipelineConfig, dir: string): Promise<PipelineRunner> {
-  const registry = new PluginRegistry();
-  bootstrapBuiltins(registry);
-  const runner = new PipelineRunner(config, dir, {
-    registry,
-    runtime: fakeRuntime(),
-    skipPluginLoading: true,
-  });
-
-  const result = await runner.start();
-  expect(result.success).toBe(true);
-  return runner;
-}
-
-describe('PipelineRunner task snapshot', () => {
-  test('getTasks reflects task_update inputs and outputs', async () => {
-    const dir = makeDir();
-    try {
-      const runner = await run(bindingsPipeline(dir), dir);
-
-      const tasks = runner.getTasks();
-      const up = tasks.get('t.up');
-      const down = tasks.get('t.down');
-      expect(up?.outputs).toEqual({ city: 'Shanghai' });
-      expect(down?.inputs).toEqual({ city: 'Shanghai' });
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test('getTasks folds streamed task logs into the task snapshot', async () => {
-    const dir = makeDir();
-    try {
-      const runner = await run(bindingsPipeline(dir), dir);
-
-      const tasks = runner.getTasks();
-      const up = tasks.get('t.up');
-      expect(up?.logs.length).toBeGreaterThan(0);
-      expect(up?.totalLogCount).toBeGreaterThan(0);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

package/src/pipeline-runner.ts

@@ -1,194 +0,0 @@
-// ═══ PipelineRunner ═══
-//
-// Wraps runPipeline in a lifecycle object suited for multi-pipeline
-// management in sidecar / Tauri IPC scenarios. Each instance controls
-// one pipeline run.
-//
-// The runner forwards wire-shape `RunEventPayload` values to its
-// subscribers — identical to what the editor server broadcasts over SSE —
-// so sidecar hosts don't need to know anything about the engine's
-// internal TaskState.
-//
-// Typical sidecar usage:
-//
-//   const runners = new Map<string, PipelineRunner>();
-//
-//   const runner = new PipelineRunner(config, workDir, { registry });
-//   runner.subscribe(event => ipcEmit('run_event', event));
-//   runner.start();
-//   runners.set(runner.instanceId, runner);
-//
-//   // Later, from IPC:
-//   runners.get(id)?.abort();
-
-import { runPipeline } from './engine';
-import type { EngineResult, RunPipelineOptions } from './engine';
-import { TASK_LOG_CAP, type PipelineConfig, type RunEventPayload, type RunTaskState } from './types';
-import { generateRunId } from './utils';
-
-export type { EngineResult };
-
-export type PipelineRunnerStatus = 'idle' | 'running' | 'done' | 'aborted';
-export type PipelineRunnerOptions = Omit<RunPipelineOptions, 'signal' | 'onEvent'>;
-
-export class PipelineRunner {
-  /**
-   * Stable ID assigned before start() — safe to use as a Map key before
-   * the engine-assigned runId becomes available.
-   */
-  readonly instanceId: string;
-
-  /**
-   * The runId generated by the engine. Set when the first `run_start`
-   * event arrives on the forwarded event stream. null until then.
-   */
-  private _runId: string | null = null;
-  private _status: PipelineRunnerStatus = 'idle';
-  private _result: Promise<EngineResult> | null = null;
-  private _abortController = new AbortController();
-  private _handlers = new Set<(event: RunEventPayload) => void>();
-  /**
-   * Wire-shape task mirror, kept in sync with `run_start` / `task_update`
-   * events. Exposed through `getTasks()`. Hosts see the same wire
-   * projection the editor client sees, so there is exactly one task-state
-   * vocabulary across IPC boundaries.
-   */
-  private _tasks = new Map<string, RunTaskState>();
-
-  constructor(
-    private readonly config: PipelineConfig,
-    private readonly workDir: string,
-    private readonly opts: PipelineRunnerOptions,
-  ) {
-    this.instanceId = generateRunId();
-  }
-
-  get runId(): string | null {
-    return this._runId;
-  }
-  get status(): PipelineRunnerStatus {
-    return this._status;
-  }
-
-  /**
-   * Start the pipeline. Calling start() more than once returns the same Promise.
-   */
-  start(): Promise<EngineResult> {
-    if (this._result) return this._result;
-
-    // Guard: if abort() was called before start(), the signal is already
-    // aborted. Create a fresh controller so the pipeline doesn't terminate
-    // immediately. If users truly want pre-abort semantics, they call
-    // abort() after start().
-    if (this._abortController.signal.aborted) {
-      this._abortController = new AbortController();
-      this._status = 'idle';
-    }
-
-    this._status = 'running';
-    this._result = runPipeline(this.config, this.workDir, {
-      ...this.opts,
-      signal: this._abortController.signal,
-      onEvent: (event) => {
-        this._applyEvent(event);
-        for (const h of this._handlers) h(event);
-      },
-    })
-      .then((result) => {
-        if (this._status === 'running') this._status = 'done';
-        return result;
-      })
-      .catch((err) => {
-        this._status = 'aborted';
-        throw err;
-      });
-
-    return this._result;
-  }
-
-  private _applyEvent(event: RunEventPayload): void {
-    switch (event.type) {
-      case 'run_start':
-        this._runId = event.runId;
-        this._tasks.clear();
-        for (const t of event.tasks) this._tasks.set(t.taskId, { ...t });
-        return;
-      case 'task_update': {
-        const prev = this._tasks.get(event.taskId);
-        if (!prev) return;
-        const pick = <T>(incoming: T | undefined, previous: T): T =>
-          incoming !== undefined ? incoming : previous;
-        this._tasks.set(event.taskId, {
-          ...prev,
-          status: event.status,
-          startedAt: pick(event.startedAt, prev.startedAt),
-          finishedAt: pick(event.finishedAt, prev.finishedAt),
-          durationMs: pick(event.durationMs, prev.durationMs),
-          exitCode: pick(event.exitCode, prev.exitCode),
-          stdout: pick(event.stdout, prev.stdout),
-          stderr: pick(event.stderr, prev.stderr),
-          stdoutPath: pick(event.stdoutPath, prev.stdoutPath),
-          stderrPath: pick(event.stderrPath, prev.stderrPath),
-          stdoutBytes: pick(event.stdoutBytes, prev.stdoutBytes),
-          stderrBytes: pick(event.stderrBytes, prev.stderrBytes),
-          sessionId: pick(event.sessionId, prev.sessionId),
-          normalizedOutput: pick(event.normalizedOutput, prev.normalizedOutput),
-          outputs: pick(event.outputs, prev.outputs),
-          inputs: pick(event.inputs, prev.inputs),
-          resolvedDriver: pick(event.resolvedDriver, prev.resolvedDriver),
-          resolvedModel: pick(event.resolvedModel, prev.resolvedModel),
-          resolvedPermissions: pick(event.resolvedPermissions, prev.resolvedPermissions),
-        });
-        return;
-      }
-      case 'task_log': {
-        if (event.taskId === null) return;
-        const prev = this._tasks.get(event.taskId);
-        if (!prev) return;
-        const logs = [
-          ...prev.logs,
-          { level: event.level, timestamp: event.timestamp, text: event.text },
-        ];
-        this._tasks.set(event.taskId, {
-          ...prev,
-          logs: logs.slice(-TASK_LOG_CAP),
-          totalLogCount: prev.totalLogCount + 1,
-        });
-        return;
-      }
-      case 'run_end':
-        this._status = this._abortController.signal.aborted ? 'aborted' : 'done';
-        return;
-      default:
-        return;
-    }
-  }
-
-  /**
-   * Cancel the running pipeline. Safe to call multiple times or before start().
-   */
-  abort(reason?: string): void {
-    this._status = 'aborted';
-    this._abortController.abort(reason);
-  }
-
-  /**
-   * Live snapshot of wire-shape task states. Populated from the first
-   * `run_start` event onward. Returns an empty map before the run starts.
-   */
-  getTasks(): ReadonlyMap<string, RunTaskState> {
-    const copy = new Map<string, RunTaskState>();
-    for (const [id, t] of this._tasks) copy.set(id, { ...t });
-    return copy;
-  }
-
-  /**
-   * Subscribe to run events. Returns an unsubscribe function. Events are
-   * emitted synchronously in the engine's event loop, so keep handlers
-   * non-blocking (e.g. queue to IPC, do not await inside).
-   */
-  subscribe(handler: (event: RunEventPayload) => void): () => void {
-    this._handlers.add(handler);
-    return () => this._handlers.delete(handler);
-  }
-}