@tagma/sdk 0.6.11 → 0.7.0

package/src/core/trigger-errors.ts

@@ -0,0 +1,15 @@
+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';
+  }
+}

package/src/engine-ports.test.ts

@@ -112,6 +112,72 @@ function finalStatusFrom(events: RunEventPayload[], qid: string): TaskStatus | u
 // ─── Tests ────────────────────────────────────────────────────────────
 
 describe('engine — ports: output extraction + input resolution', () => {
+  test('lightweight task inputs substitute command placeholders without ports', async () => {
+    const dir = makeDir();
+    try {
+      const echo = writeEchoArgsScript(dir, 'echo');
+      const config = pipeline([
+        task({
+          id: 'down',
+          command: `node "${echo}" "{{inputs.city}}" "{{inputs.mode}}"`,
+          inputs: {
+            city: { value: 'Shanghai' },
+            mode: { default: 'quick' },
+          },
+        }),
+      ]);
+
+      const { events, success } = await run(config, dir);
+      expect(success).toBe(true);
+      const downFinal = finalUpdateFor(events, 't.down');
+      if (downFinal?.type === 'task_update') {
+        expect((downFinal.stdout ?? '').trim()).toBe('Shanghai|quick');
+        expect(downFinal.inputs).toEqual({ city: 'Shanghai', mode: 'quick' });
+      }
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('lightweight task outputs publish named values for downstream bindings', async () => {
+    const dir = makeDir();
+    try {
+      const emit = writeEmitScript(dir, 'emit', { bundlePath: 'dist/app.js' });
+      const echo = writeEchoArgsScript(dir, 'echo');
+      const config = pipeline([
+        task({
+          id: 'build',
+          command: `node "${emit}"`,
+          outputs: {
+            bundlePath: {},
+          },
+        }),
+        task({
+          id: 'test',
+          depends_on: ['build'],
+          command: `node "${echo}" "{{inputs.bundlePath}}"`,
+          inputs: {
+            bundlePath: { from: 't.build.outputs.bundlePath', required: true },
+          },
+        }),
+      ]);
+
+      const { events, success } = await run(config, dir);
+      expect(success).toBe(true);
+      const buildFinal = finalUpdateFor(events, 't.build');
+      if (buildFinal?.type === 'task_update') {
+        expect(buildFinal.outputs).toEqual({ bundlePath: 'dist/app.js' });
+      }
+      const testFinal = finalUpdateFor(events, 't.test');
+      if (testFinal?.type === 'task_update') {
+        expect((testFinal.stdout ?? '').trim()).toBe('dist/app.js');
+        expect(testFinal.inputs).toEqual({ bundlePath: 'dist/app.js' });
+      }
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   test('upstream outputs feed downstream inputs via name match', async () => {
     const dir = makeDir();
     try {

package/src/engine-task-type.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runPipeline, type RunEventPayload } from './engine';
+import { PluginRegistry } from './registry';
+import type { PipelineConfig } from './types';
+
+function makeDir(): string {
+  return mkdtempSync(join(tmpdir(), 'tagma-task-type-'));
+}
+
+describe('engine task type detection', () => {
+  test('empty command is still a command task and does not require a driver', async () => {
+    const dir = makeDir();
+    const previousShell = process.env.PIPELINE_SHELL;
+    process.env.PIPELINE_SHELL = 'cmd';
+    try {
+      const events: RunEventPayload[] = [];
+      const config: PipelineConfig = {
+        name: 'empty-command',
+        tracks: [
+          {
+            id: 't',
+            name: 'T',
+            tasks: [{ id: 'cmd', name: 'cmd', command: '' }],
+          },
+        ],
+      };
+
+      const result = await runPipeline(config, dir, {
+        registry: new PluginRegistry(),
+        skipPluginLoading: true,
+        onEvent: (event) => events.push(event),
+      });
+
+      expect(result.success).toBe(true);
+      expect(events.some((event) => event.type === 'run_start')).toBe(true);
+      const final = events.findLast(
+        (event) => event.type === 'task_update' && event.taskId === 't.cmd',
+      );
+      expect(final?.type).toBe('task_update');
+      if (final?.type === 'task_update') {
+        expect(final.status).toBe('success');
+        expect(final.resolvedDriver).toBeNull();
+      }
+    } finally {
+      if (previousShell === undefined) {
+        delete process.env.PIPELINE_SHELL;
+      } else {
+        process.env.PIPELINE_SHELL = previousShell;
+      }
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});