@tagma/sdk 0.2.9 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagma/sdk",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/engine.ts

@@ -19,6 +19,26 @@ import {
 import { Logger, tailLines, clip, type LogLevel } from './logger';
 import { InMemoryApprovalGateway, type ApprovalGateway } from './approval';
 
+// ═══ A7: Typed trigger errors ═══
+// Replace string-matching on error messages with structured error types so
+// coincidental substrings don't cause misclassification.
+
+export class TriggerBlockedError extends Error {
+  readonly code = 'TRIGGER_BLOCKED' as const;
+  constructor(message: string) {
+    super(message);
+    this.name = 'TriggerBlockedError';
+  }
+}
+
+export class TriggerTimeoutError extends Error {
+  readonly code = 'TRIGGER_TIMEOUT' as const;
+  constructor(message: string) {
+    super(message);
+    this.name = 'TriggerTimeoutError';
+  }
+}
+
 // ═══ Preflight Validation ═══
 
 function preflight(config: PipelineConfig, dag: Dag): void {
@@ -420,18 +440,26 @@ export async function runPipeline(
         });
         log.debug(`[task:${taskId}]`, `trigger fired`);
       } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err);
         // If pipeline was aborted while we were still waiting for the trigger,
         // this task never entered running state → skipped, not timeout.
         state.finishedAt = nowISO();
         if (pipelineAborted) {
           setTaskStatus(taskId, 'skipped');
-        } else if (msg.includes('rejected') || msg.includes('denied')) {
+        } else if (err instanceof TriggerBlockedError) {
           setTaskStatus(taskId, 'blocked');       // user/policy rejection
-        } else if (msg.includes('timeout')) {
+        } else if (err instanceof TriggerTimeoutError) {
           setTaskStatus(taskId, 'timeout');       // genuine trigger wait timeout
         } else {
-          setTaskStatus(taskId, 'failed');        // plugin error, watcher crash, etc.
+          // A7 fallback: also check message strings for backward-compat with
+          // third-party trigger plugins that don't throw typed errors yet.
+          const msg = err instanceof Error ? err.message : String(err);
+          if (msg.includes('rejected') || msg.includes('denied')) {
+            setTaskStatus(taskId, 'blocked');
+          } else if (msg.includes('timeout')) {
+            setTaskStatus(taskId, 'timeout');
+          } else {
+            setTaskStatus(taskId, 'failed');      // plugin error, watcher crash, etc.
+          }
         }
         try {
           await fireHook(taskId, 'task_failure');

package/src/sdk.ts

@@ -4,7 +4,7 @@
 // The CLI (src/index.ts in the CLI project) also imports from here.
 
 // ── Core engine ──
-export { runPipeline } from './engine';
+export { runPipeline, TriggerBlockedError, TriggerTimeoutError } from './engine';
 export type { EngineResult, RunPipelineOptions, PipelineEvent } from './engine';
 
 // ── Pipeline runner (multi-pipeline lifecycle management) ──

package/src/triggers/file.ts

@@ -3,6 +3,7 @@ import { resolve, dirname } from 'path';
 import { mkdir } from 'fs/promises';
 import type { TriggerPlugin, TriggerContext } from '../types';
 import { parseDuration, validatePath } from '../utils';
+import { TriggerTimeoutError } from '../engine';
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -118,7 +119,7 @@ export const FileTrigger: TriggerPlugin = {
         timer = setTimeout(() => {
           if (settled) return;
           cleanup();
-          reject(new Error(`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,5 +1,6 @@
 import type { TriggerPlugin, TriggerContext } from '../types';
 import { parseDuration } from '../utils';
+import { TriggerBlockedError, TriggerTimeoutError } from '../engine';
 
 export const ManualTrigger: TriggerPlugin = {
   name: 'manual',
@@ -66,14 +67,15 @@ export const ManualTrigger: TriggerPlugin = {
       case 'approved':
         return { confirmed: true, approvalId: decision.approvalId, actor: decision.actor };
       case 'rejected':
-        throw new Error(
+        // 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 Error(`Manual trigger timeout: ${decision.reason ?? 'no decision made'}`);
+        throw new TriggerTimeoutError(`Manual trigger timeout: ${decision.reason ?? 'no decision made'}`);
       case 'aborted':
-        throw new Error(`Manual trigger aborted: ${decision.reason ?? 'pipeline aborted'}`);
+        throw new TriggerBlockedError(`Manual trigger aborted: ${decision.reason ?? 'pipeline aborted'}`);
     }
   },
 };