@tagma/sdk 0.4.12 → 0.4.13

package/src/sdk.ts

@@ -1,82 +1,92 @@
-// ═══ tagma-sdk public API ═══
-//
-// This is the SDK entry point. Import from here, not from internal modules.
-// The CLI (src/index.ts in the CLI project) also imports from here.
-
-// ── Core engine ──
-export { runPipeline, TriggerBlockedError, TriggerTimeoutError } from './engine';
-export type { EngineResult, RunPipelineOptions, PipelineEvent } from './engine';
-
-// ── Pipeline runner (multi-pipeline lifecycle management) ──
-export { PipelineRunner } from './pipeline-runner';
-export type { PipelineRunnerStatus } from './pipeline-runner';
-
-// ── Raw config CRUD (visual editor / YAML sync) ──
-export {
-  createEmptyPipeline,
-  setPipelineField,
-  upsertTrack,
-  removeTrack,
-  moveTrack,
-  updateTrack,
-  upsertTask,
-  removeTask,
-  moveTask,
-  transferTask,
-} from './config-ops';
-
-// ── Raw config validation (real-time feedback) ──
-export { validateRaw } from './validate-raw';
-export type { ValidationError } from './validate-raw';
-
+// ═══ tagma-sdk public API ═══
+//
+// This is the SDK entry point. Import from here, not from internal modules.
+// The CLI (src/index.ts in the CLI project) also imports from here.
+
+// ── Core engine ──
+export { runPipeline, TriggerBlockedError, TriggerTimeoutError } from './engine';
+export type { EngineResult, RunPipelineOptions, PipelineEvent } from './engine';
+
+// ── Pipeline runner (multi-pipeline lifecycle management) ──
+export { PipelineRunner } from './pipeline-runner';
+export type { PipelineRunnerStatus } from './pipeline-runner';
+
+// ── Raw config CRUD (visual editor / YAML sync) ──
+export {
+  createEmptyPipeline,
+  setPipelineField,
+  upsertTrack,
+  removeTrack,
+  moveTrack,
+  updateTrack,
+  upsertTask,
+  removeTask,
+  moveTask,
+  transferTask,
+} from './config-ops';
+
+// ── Raw config validation (real-time feedback) ──
+export { validateRaw } from './validate-raw';
+export type { ValidationError } from './validate-raw';
+
 // ── Schema: parse / resolve / load / serialize / validate ──
-export { parseYaml, resolveConfig, loadPipeline, serializePipeline, deresolvePipeline, validateConfig } from './schema';
-
-// ── DAG ──
-export { buildDag, buildRawDag } from './dag';
-export type { DagNode, Dag, RawDagNode, RawDag } from './dag';
-
-// ── Plugin registry ──
-export { bootstrapBuiltins } from './bootstrap';
-export {
-  loadPlugins,
-  registerPlugin,
-  unregisterPlugin,
-  getHandler,
-  hasHandler,
-  listRegistered,
-  isValidPluginName,
-  PLUGIN_NAME_RE,
-  readPluginManifest,
-} from './registry';
-export type { RegisterResult } from './registry';
-
-// ── Approval gateway ──
-export { InMemoryApprovalGateway } from './approval';
-export type {
-  ApprovalGateway,
-  ApprovalRequest,
-  ApprovalDecision,
-  ApprovalOutcome,
-  ApprovalEvent,
-  ApprovalListener,
-} from './approval';
-
-// ── Approval adapters ──
-export { attachStdinApprovalAdapter } from './adapters/stdin-approval';
-export type { StdinApprovalAdapter } from './adapters/stdin-approval';
-export { attachWebSocketApprovalAdapter } from './adapters/websocket-approval';
-export type { WebSocketApprovalAdapter, WebSocketApprovalAdapterOptions } from './adapters/websocket-approval';
-
-// ── Logger ──
-export { Logger, tailLines, clip } from './logger';
-export type { LogRecord, LogLevel, LogListener } from './logger';
-
-// ── Hook context types (useful for frontend display) ──
-export type { HookResult, PipelineInfo, TrackInfo, TaskInfo } from './hooks';
-
-// ── Utils (public subset) ──
-export { parseDuration, validatePath, generateRunId, nowISO, truncateForName } from './utils';
-
-// ── All types from @tagma/types + runtime constants ──
-export * from './types';
+export {
+  parseYaml,
+  resolveConfig,
+  loadPipeline,
+  serializePipeline,
+  deresolvePipeline,
+  validateConfig,
+} from './schema';
+
+// ── DAG ──
+export { buildDag, buildRawDag } from './dag';
+export type { DagNode, Dag, RawDagNode, RawDag } from './dag';
+
+// ── Plugin registry ──
+export { bootstrapBuiltins } from './bootstrap';
+export {
+  loadPlugins,
+  registerPlugin,
+  unregisterPlugin,
+  getHandler,
+  hasHandler,
+  listRegistered,
+  isValidPluginName,
+  PLUGIN_NAME_RE,
+  readPluginManifest,
+} from './registry';
+export type { RegisterResult } from './registry';
+
+// ── Approval gateway ──
+export { InMemoryApprovalGateway } from './approval';
+export type {
+  ApprovalGateway,
+  ApprovalRequest,
+  ApprovalDecision,
+  ApprovalOutcome,
+  ApprovalEvent,
+  ApprovalListener,
+} from './approval';
+
+// ── Approval adapters ──
+export { attachStdinApprovalAdapter } from './adapters/stdin-approval';
+export type { StdinApprovalAdapter } from './adapters/stdin-approval';
+export { attachWebSocketApprovalAdapter } from './adapters/websocket-approval';
+export type {
+  WebSocketApprovalAdapter,
+  WebSocketApprovalAdapterOptions,
+} from './adapters/websocket-approval';
+
+// ── Logger ──
+export { Logger, tailLines, clip } from './logger';
+export type { LogRecord, LogLevel, LogListener } from './logger';
+
+// ── Hook context types (useful for frontend display) ──
+export type { HookResult, PipelineInfo, TrackInfo, TaskInfo } from './hooks';
+
+// ── Utils (public subset) ──
+export { parseDuration, validatePath, generateRunId, nowISO, truncateForName } from './utils';
+
+// ── All types from @tagma/types + runtime constants ──
+export * from './types';

package/src/triggers/file.ts

@@ -57,7 +57,9 @@ export const FileTrigger: TriggerPlugin = {
       const dir = dirname(safePath);
       try {
         await mkdir(dir, { recursive: true });
-      } catch { /* best effort — dir may already exist */ }
+      } catch {
+        /* best effort — dir may already exist */
+      }
 
       // Pass `cwd: dir` so chokidar resolves paths relative to the watched
       // directory. The 'add'/'change' events will then carry paths relative
@@ -74,7 +76,9 @@ export const FileTrigger: TriggerPlugin = {
       const cleanup = () => {
         if (settled) return;
         settled = true;
-        watcher.close().catch(() => { /* ignore */ });
+        watcher.close().catch(() => {
+          /* ignore */
+        });
         if (timer) clearTimeout(timer);
         ctx.signal.removeEventListener('abort', onAbort);
       };
@@ -106,7 +110,11 @@ export const FileTrigger: TriggerPlugin = {
       watcher.on('error', (err: unknown) => {
         if (settled) return;
         cleanup();
-        reject(new Error(`file trigger watch error: ${err instanceof Error ? err.message : String(err)}`));
+        reject(
+          new Error(
+            `file trigger watch error: ${err instanceof Error ? err.message : String(err)}`,
+          ),
+        );
       });
 
       // After the watcher finishes its initial scan, check if the file already exists.
@@ -114,24 +122,35 @@ export const FileTrigger: TriggerPlugin = {
       // and watcher startup, so we neither miss events nor double-resolve.
       watcher.on('ready', () => {
         if (settled) return;
-        Bun.file(safePath).exists().then((exists) => {
-          if (settled) return;
-          if (exists) {
+        Bun.file(safePath)
+          .exists()
+          .then((exists) => {
+            if (settled) return;
+            if (exists) {
+              cleanup();
+              resolve_p({ path: safePath });
+            }
+          })
+          .catch((err: unknown) => {
+            if (settled) return;
             cleanup();
-            resolve_p({ path: safePath });
-          }
-        }).catch((err: unknown) => {
-          if (settled) return;
-          cleanup();
-          reject(new Error(`file trigger existence check failed: ${err instanceof Error ? err.message : String(err)}`));
-        });
+            reject(
+              new Error(
+                `file trigger existence check failed: ${err instanceof Error ? err.message : String(err)}`,
+              ),
+            );
+          });
       });
 
       if (timeoutMs > 0) {
         timer = setTimeout(() => {
           if (settled) return;
           cleanup();
-          reject(new TriggerTimeoutError(`file trigger timeout: ${filePath} did not appear within ${config.timeout}`));
+          reject(
+            new TriggerTimeoutError(
+              `file trigger timeout: ${filePath} did not appear within ${config.timeout}`,
+            ),
+          );
         }, timeoutMs);
       }
 

package/src/triggers/manual.ts

@@ -1,81 +1,86 @@
-import type { TriggerPlugin, TriggerContext } from '../types';
-import { parseDuration } from '../utils';
-import { TriggerBlockedError, TriggerTimeoutError } from '../engine';
-
-export const ManualTrigger: TriggerPlugin = {
-  name: 'manual',
-  schema: {
-    description: 'Pause the task until a user approves via the approval gateway.',
-    fields: {
-      message: {
-        type: 'string',
-        description: 'Prompt shown to the approver. Defaults to a generic message if empty.',
-        placeholder: 'Confirm deployment to production?',
-      },
-      timeout: {
-        type: 'duration',
-        description: 'Maximum wait time (e.g. 10m). Omit or 0 to wait indefinitely.',
-        placeholder: '10m',
-      },
-    },
-  },
-
-  async watch(config: Record<string, unknown>, ctx: TriggerContext): Promise<unknown> {
-    const message =
-      (config.message as string | undefined) ?? `Manual confirmation required for task "${ctx.taskId}"`;
-    const timeoutMs = config.timeout ? parseDuration(config.timeout as string) : 0;
-    const metadata =
-      config.metadata && typeof config.metadata === 'object'
-        ? (config.metadata as Record<string, unknown>)
-        : undefined;
-
-    const decisionPromise = ctx.approvalGateway.request({
-      taskId: ctx.taskId,
-      trackId: ctx.trackId,
-      message,
-      timeoutMs,
-      metadata,
-    });
-
-    // Wire AbortSignal → try to resolve this specific request as aborted.
-    // We can't directly cancel via the gateway (no id yet at .request() call site),
-    // so instead we race against an abort promise and let engine status logic
-    // fall back to pipelineAborted → skipped. abortAll() on gateway still runs
-    // from engine shutdown path to clean up any truly-pending entries.
-    const onAbort = () => {};
-    const abortPromise = new Promise<never>((_, reject) => {
-      if (ctx.signal.aborted) {
-        reject(new Error('Pipeline aborted'));
-        return;
-      }
-      const handler = () => reject(new Error('Pipeline aborted'));
-      // Store reference so we can remove it after the race settles.
-      (onAbort as { handler?: () => void }).handler = handler;
-      ctx.signal.addEventListener('abort', handler, { once: true });
-    });
-
-    let decision: Awaited<typeof decisionPromise>;
-    try {
-      decision = await Promise.race([decisionPromise, abortPromise]);
-    } finally {
-      // Clean up the abort listener to prevent leaking on normal completion.
-      const handler = (onAbort as { handler?: () => void }).handler;
-      if (handler) ctx.signal.removeEventListener('abort', handler);
-    }
-
-    switch (decision.outcome) {
-      case 'approved':
-        return { confirmed: true, approvalId: decision.approvalId, actor: decision.actor };
-      case 'rejected':
-        // A7: Use typed error for proper classification in the engine.
-        throw new TriggerBlockedError(
-          `Manual trigger rejected by ${decision.actor ?? 'user'}` +
-            (decision.reason ? `: ${decision.reason}` : ''),
-        );
-      case 'timeout':
-        throw new TriggerTimeoutError(`Manual trigger timeout: ${decision.reason ?? 'no decision made'}`);
-      case 'aborted':
-        throw new TriggerBlockedError(`Manual trigger aborted: ${decision.reason ?? 'pipeline aborted'}`);
-    }
-  },
-};
+import type { TriggerPlugin, TriggerContext } from '../types';
+import { parseDuration } from '../utils';
+import { TriggerBlockedError, TriggerTimeoutError } from '../engine';
+
+export const ManualTrigger: TriggerPlugin = {
+  name: 'manual',
+  schema: {
+    description: 'Pause the task until a user approves via the approval gateway.',
+    fields: {
+      message: {
+        type: 'string',
+        description: 'Prompt shown to the approver. Defaults to a generic message if empty.',
+        placeholder: 'Confirm deployment to production?',
+      },
+      timeout: {
+        type: 'duration',
+        description: 'Maximum wait time (e.g. 10m). Omit or 0 to wait indefinitely.',
+        placeholder: '10m',
+      },
+    },
+  },
+
+  async watch(config: Record<string, unknown>, ctx: TriggerContext): Promise<unknown> {
+    const message =
+      (config.message as string | undefined) ??
+      `Manual confirmation required for task "${ctx.taskId}"`;
+    const timeoutMs = config.timeout ? parseDuration(config.timeout as string) : 0;
+    const metadata =
+      config.metadata && typeof config.metadata === 'object'
+        ? (config.metadata as Record<string, unknown>)
+        : undefined;
+
+    const decisionPromise = ctx.approvalGateway.request({
+      taskId: ctx.taskId,
+      trackId: ctx.trackId,
+      message,
+      timeoutMs,
+      metadata,
+    });
+
+    // Wire AbortSignal → try to resolve this specific request as aborted.
+    // We can't directly cancel via the gateway (no id yet at .request() call site),
+    // so instead we race against an abort promise and let engine status logic
+    // fall back to pipelineAborted → skipped. abortAll() on gateway still runs
+    // from engine shutdown path to clean up any truly-pending entries.
+    const onAbort = () => {};
+    const abortPromise = new Promise<never>((_, reject) => {
+      if (ctx.signal.aborted) {
+        reject(new Error('Pipeline aborted'));
+        return;
+      }
+      const handler = () => reject(new Error('Pipeline aborted'));
+      // Store reference so we can remove it after the race settles.
+      (onAbort as { handler?: () => void }).handler = handler;
+      ctx.signal.addEventListener('abort', handler, { once: true });
+    });
+
+    let decision: Awaited<typeof decisionPromise>;
+    try {
+      decision = await Promise.race([decisionPromise, abortPromise]);
+    } finally {
+      // Clean up the abort listener to prevent leaking on normal completion.
+      const handler = (onAbort as { handler?: () => void }).handler;
+      if (handler) ctx.signal.removeEventListener('abort', handler);
+    }
+
+    switch (decision.outcome) {
+      case 'approved':
+        return { confirmed: true, approvalId: decision.approvalId, actor: decision.actor };
+      case 'rejected':
+        // A7: Use typed error for proper classification in the engine.
+        throw new TriggerBlockedError(
+          `Manual trigger rejected by ${decision.actor ?? 'user'}` +
+            (decision.reason ? `: ${decision.reason}` : ''),
+        );
+      case 'timeout':
+        throw new TriggerTimeoutError(
+          `Manual trigger timeout: ${decision.reason ?? 'no decision made'}`,
+        );
+      case 'aborted':
+        throw new TriggerBlockedError(
+          `Manual trigger aborted: ${decision.reason ?? 'pipeline aborted'}`,
+        );
+    }
+  },
+};

package/src/types.ts

@@ -1,18 +1,18 @@
-// ═══ Engine-facing type surface ═══
-//
-// All type definitions live in the shared `@tagma/types` workspace package
-// so that plugins under plugins/* can depend on the same types without
-// reaching into the engine's internals. This file re-exports everything
-// and adds runtime-only values (constants) that plugins don't need.
-
-export * from '@tagma/types';
-
-import type { Permissions } from '@tagma/types';
-
-// ═══ Runtime Constants ═══
-
-export const DEFAULT_PERMISSIONS: Permissions = {
-  read: true,
-  write: false,
-  execute: false,
-};
+// ═══ Engine-facing type surface ═══
+//
+// All type definitions live in the shared `@tagma/types` workspace package
+// so that plugins under plugins/* can depend on the same types without
+// reaching into the engine's internals. This file re-exports everything
+// and adds runtime-only values (constants) that plugins don't need.
+
+export * from '@tagma/types';
+
+import type { Permissions } from '@tagma/types';
+
+// ═══ Runtime Constants ═══
+
+export const DEFAULT_PERMISSIONS: Permissions = {
+  read: true,
+  write: false,
+  execute: false,
+};