@tagma/sdk 0.4.14 → 0.4.16

package/src/approval.ts

@@ -1,131 +1,131 @@
-import { randomUUID } from 'crypto';
-import { nowISO } from './utils';
-
-// Approval types (ApprovalRequest, ApprovalDecision, ApprovalOutcome,
-// ApprovalEvent, ApprovalListener, ApprovalGateway) live in the shared
-// @tagma/types package so trigger plugins can import them without
-// depending on the engine's runtime implementation. This module keeps
-// only the in-memory implementation. Internal SDK imports go through
-// ./types (the engine-side re-export) for consistency with the rest of
-// the SDK source.
-import type {
-  ApprovalRequest,
-  ApprovalDecision,
-  ApprovalEvent,
-  ApprovalListener,
-  ApprovalGateway,
-} from './types';
-
-// Re-export for existing engine-side consumers that import from this file.
-export type {
-  ApprovalRequest,
-  ApprovalDecision,
-  ApprovalOutcome,
-  ApprovalEvent,
-  ApprovalListener,
-  ApprovalGateway,
-} from './types';
-
-// ═══ Default In-Memory Implementation ═══
-
-interface PendingEntry {
-  readonly request: ApprovalRequest;
-  readonly settle: (decision: ApprovalDecision) => void;
-  readonly timer: ReturnType<typeof setTimeout> | null;
-}
-
-export class InMemoryApprovalGateway implements ApprovalGateway {
-  private readonly pendingMap = new Map<string, PendingEntry>();
-  private readonly listeners = new Set<ApprovalListener>();
-
-  request(req: Omit<ApprovalRequest, 'id' | 'createdAt'>): Promise<ApprovalDecision> {
-    const full: ApprovalRequest = {
-      id: randomUUID(),
-      createdAt: nowISO(),
-      taskId: req.taskId,
-      trackId: req.trackId,
-      message: req.message,
-      timeoutMs: req.timeoutMs,
-      metadata: req.metadata,
-    };
-
-    return new Promise<ApprovalDecision>((resolvePromise) => {
-      let timer: ReturnType<typeof setTimeout> | null = null;
-      if (full.timeoutMs > 0) {
-        timer = setTimeout(() => {
-          const entry = this.pendingMap.get(full.id);
-          if (!entry) return;
-          this.pendingMap.delete(full.id);
-          const decision: ApprovalDecision = {
-            approvalId: full.id,
-            outcome: 'timeout',
-            reason: `Approval timed out after ${full.timeoutMs}ms`,
-            decidedAt: nowISO(),
-          };
-          this.emit({ type: 'expired', request: full });
-          resolvePromise(decision);
-        }, full.timeoutMs);
-      }
-
-      this.pendingMap.set(full.id, { request: full, settle: resolvePromise, timer });
-      this.emit({ type: 'requested', request: full });
-    });
-  }
-
-  resolve(
-    approvalId: string,
-    decision: Omit<ApprovalDecision, 'approvalId' | 'decidedAt'>,
-  ): boolean {
-    const entry = this.pendingMap.get(approvalId);
-    if (!entry) return false;
-    this.pendingMap.delete(approvalId);
-    if (entry.timer) clearTimeout(entry.timer);
-
-    const full: ApprovalDecision = {
-      approvalId,
-      outcome: decision.outcome,
-      actor: decision.actor,
-      reason: decision.reason,
-      decidedAt: nowISO(),
-    };
-    this.emit({ type: 'resolved', request: entry.request, decision: full });
-    entry.settle(full);
-    return true;
-  }
-
-  pending(): readonly ApprovalRequest[] {
-    return Array.from(this.pendingMap.values()).map((e) => e.request);
-  }
-
-  subscribe(listener: ApprovalListener): () => void {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  abortAll(reason: string): void {
-    const entries = Array.from(this.pendingMap.entries());
-    this.pendingMap.clear();
-    for (const [id, entry] of entries) {
-      if (entry.timer) clearTimeout(entry.timer);
-      this.emit({ type: 'aborted', request: entry.request, reason });
-      entry.settle({
-        approvalId: id,
-        outcome: 'aborted',
-        reason,
-        decidedAt: nowISO(),
-      });
-    }
-  }
-
-  private emit(event: ApprovalEvent): void {
-    for (const listener of this.listeners) {
-      try {
-        listener(event);
-      } catch (err) {
-        console.error('[approval gateway] listener error:', err);
-      }
-    }
-  }
-}
+import { randomUUID } from 'crypto';
+import { nowISO } from './utils';
+
+// Approval types (ApprovalRequest, ApprovalDecision, ApprovalOutcome,
+// ApprovalEvent, ApprovalListener, ApprovalGateway) live in the shared
+// @tagma/types package so trigger plugins can import them without
+// depending on the engine's runtime implementation. This module keeps
+// only the in-memory implementation. Internal SDK imports go through
+// ./types (the engine-side re-export) for consistency with the rest of
+// the SDK source.
+import type {
+  ApprovalRequest,
+  ApprovalDecision,
+  ApprovalEvent,
+  ApprovalListener,
+  ApprovalGateway,
+} from './types';
+
+// Re-export for existing engine-side consumers that import from this file.
+export type {
+  ApprovalRequest,
+  ApprovalDecision,
+  ApprovalOutcome,
+  ApprovalEvent,
+  ApprovalListener,
+  ApprovalGateway,
+} from './types';
+
+// ═══ Default In-Memory Implementation ═══
+
+interface PendingEntry {
+  readonly request: ApprovalRequest;
+  readonly settle: (decision: ApprovalDecision) => void;
+  readonly timer: ReturnType<typeof setTimeout> | null;
+}
+
+export class InMemoryApprovalGateway implements ApprovalGateway {
+  private readonly pendingMap = new Map<string, PendingEntry>();
+  private readonly listeners = new Set<ApprovalListener>();
+
+  request(req: Omit<ApprovalRequest, 'id' | 'createdAt'>): Promise<ApprovalDecision> {
+    const full: ApprovalRequest = {
+      id: randomUUID(),
+      createdAt: nowISO(),
+      taskId: req.taskId,
+      trackId: req.trackId,
+      message: req.message,
+      timeoutMs: req.timeoutMs,
+      metadata: req.metadata,
+    };
+
+    return new Promise<ApprovalDecision>((resolvePromise) => {
+      let timer: ReturnType<typeof setTimeout> | null = null;
+      if (full.timeoutMs > 0) {
+        timer = setTimeout(() => {
+          const entry = this.pendingMap.get(full.id);
+          if (!entry) return;
+          this.pendingMap.delete(full.id);
+          const decision: ApprovalDecision = {
+            approvalId: full.id,
+            outcome: 'timeout',
+            reason: `Approval timed out after ${full.timeoutMs}ms`,
+            decidedAt: nowISO(),
+          };
+          this.emit({ type: 'expired', request: full });
+          resolvePromise(decision);
+        }, full.timeoutMs);
+      }
+
+      this.pendingMap.set(full.id, { request: full, settle: resolvePromise, timer });
+      this.emit({ type: 'requested', request: full });
+    });
+  }
+
+  resolve(
+    approvalId: string,
+    decision: Omit<ApprovalDecision, 'approvalId' | 'decidedAt'>,
+  ): boolean {
+    const entry = this.pendingMap.get(approvalId);
+    if (!entry) return false;
+    this.pendingMap.delete(approvalId);
+    if (entry.timer) clearTimeout(entry.timer);
+
+    const full: ApprovalDecision = {
+      approvalId,
+      outcome: decision.outcome,
+      actor: decision.actor,
+      reason: decision.reason,
+      decidedAt: nowISO(),
+    };
+    this.emit({ type: 'resolved', request: entry.request, decision: full });
+    entry.settle(full);
+    return true;
+  }
+
+  pending(): readonly ApprovalRequest[] {
+    return Array.from(this.pendingMap.values()).map((e) => e.request);
+  }
+
+  subscribe(listener: ApprovalListener): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  abortAll(reason: string): void {
+    const entries = Array.from(this.pendingMap.entries());
+    this.pendingMap.clear();
+    for (const [id, entry] of entries) {
+      if (entry.timer) clearTimeout(entry.timer);
+      this.emit({ type: 'aborted', request: entry.request, reason });
+      entry.settle({
+        approvalId: id,
+        outcome: 'aborted',
+        reason,
+        decidedAt: nowISO(),
+      });
+    }
+  }
+
+  private emit(event: ApprovalEvent): void {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.error('[approval gateway] listener error:', err);
+      }
+    }
+  }
+}

package/src/bootstrap.ts

@@ -1,37 +1,37 @@
-import { registerPlugin } from './registry';
-
-// Built-in Drivers
-// Only claude-code is built in. Other drivers (codex, opencode) ship as
-// workspace plugins under plugins/ and must be declared in pipeline.yaml
-// via the `plugins` field, e.g.:
-//   plugins: ["@tagma/driver-codex", "@tagma/driver-opencode"]
-import { ClaudeCodeDriver } from './drivers/claude-code';
-
-// Built-in Triggers
-import { FileTrigger } from './triggers/file';
-import { ManualTrigger } from './triggers/manual';
-
-// Built-in Completions
-import { ExitCodeCompletion } from './completions/exit-code';
-import { FileExistsCompletion } from './completions/file-exists';
-import { OutputCheckCompletion } from './completions/output-check';
-
-// Built-in Middleware
-import { StaticContextMiddleware } from './middlewares/static-context';
-
-export function bootstrapBuiltins(): void {
-  // Drivers
-  registerPlugin('drivers', 'claude-code', ClaudeCodeDriver);
-
-  // Triggers
-  registerPlugin('triggers', 'file', FileTrigger);
-  registerPlugin('triggers', 'manual', ManualTrigger);
-
-  // Completions
-  registerPlugin('completions', 'exit_code', ExitCodeCompletion);
-  registerPlugin('completions', 'file_exists', FileExistsCompletion);
-  registerPlugin('completions', 'output_check', OutputCheckCompletion);
-
-  // Middlewares
-  registerPlugin('middlewares', 'static_context', StaticContextMiddleware);
-}
+import { registerPlugin } from './registry';
+
+// Built-in Drivers
+// Only claude-code is built in. Other drivers (codex, opencode) ship as
+// workspace plugins under plugins/ and must be declared in pipeline.yaml
+// via the `plugins` field, e.g.:
+//   plugins: ["@tagma/driver-codex", "@tagma/driver-opencode"]
+import { ClaudeCodeDriver } from './drivers/claude-code';
+
+// Built-in Triggers
+import { FileTrigger } from './triggers/file';
+import { ManualTrigger } from './triggers/manual';
+
+// Built-in Completions
+import { ExitCodeCompletion } from './completions/exit-code';
+import { FileExistsCompletion } from './completions/file-exists';
+import { OutputCheckCompletion } from './completions/output-check';
+
+// Built-in Middleware
+import { StaticContextMiddleware } from './middlewares/static-context';
+
+export function bootstrapBuiltins(): void {
+  // Drivers
+  registerPlugin('drivers', 'claude-code', ClaudeCodeDriver);
+
+  // Triggers
+  registerPlugin('triggers', 'file', FileTrigger);
+  registerPlugin('triggers', 'manual', ManualTrigger);
+
+  // Completions
+  registerPlugin('completions', 'exit_code', ExitCodeCompletion);
+  registerPlugin('completions', 'file_exists', FileExistsCompletion);
+  registerPlugin('completions', 'output_check', OutputCheckCompletion);
+
+  // Middlewares
+  registerPlugin('middlewares', 'static_context', StaticContextMiddleware);
+}

package/src/completions/exit-code.ts

@@ -1,34 +1,34 @@
-import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
-
-export const ExitCodeCompletion: CompletionPlugin = {
-  name: 'exit_code',
-  schema: {
-    description: 'Mark the task successful when the exit code matches.',
-    fields: {
-      expect: {
-        type: 'number-or-list',
-        default: 0,
-        description: 'Expected exit code, or list of acceptable codes (e.g. 0 or [0, 2]).',
-        placeholder: '0',
-      },
-    },
-  },
-
-  async check(
-    config: Record<string, unknown>,
-    result: TaskResult,
-    _ctx: CompletionContext,
-  ): Promise<boolean> {
-    const expected = config.expect ?? 0;
-
-    if (typeof expected === 'number') {
-      return result.exitCode === expected;
-    }
-    if (Array.isArray(expected) && expected.every((v) => typeof v === 'number')) {
-      return expected.includes(result.exitCode);
-    }
-    throw new Error(
-      `exit_code completion: "expect" must be a number or number[], got ${typeof expected}`,
-    );
-  },
-};
+import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
+
+export const ExitCodeCompletion: CompletionPlugin = {
+  name: 'exit_code',
+  schema: {
+    description: 'Mark the task successful when the exit code matches.',
+    fields: {
+      expect: {
+        type: 'number-or-list',
+        default: 0,
+        description: 'Expected exit code, or list of acceptable codes (e.g. 0 or [0, 2]).',
+        placeholder: '0',
+      },
+    },
+  },
+
+  async check(
+    config: Record<string, unknown>,
+    result: TaskResult,
+    _ctx: CompletionContext,
+  ): Promise<boolean> {
+    const expected = config.expect ?? 0;
+
+    if (typeof expected === 'number') {
+      return result.exitCode === expected;
+    }
+    if (Array.isArray(expected) && expected.every((v) => typeof v === 'number')) {
+      return expected.includes(result.exitCode);
+    }
+    throw new Error(
+      `exit_code completion: "expect" must be a number or number[], got ${typeof expected}`,
+    );
+  },
+};

package/src/completions/file-exists.ts

@@ -1,66 +1,66 @@
-import { stat } from 'node:fs/promises';
-import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
-import { validatePath } from '../utils';
-
-type Kind = 'file' | 'dir' | 'any';
-
-export const FileExistsCompletion: CompletionPlugin = {
-  name: 'file_exists',
-  schema: {
-    description: 'Mark the task successful when a target file or directory exists.',
-    fields: {
-      path: {
-        type: 'path',
-        required: true,
-        description: 'Path to check (relative to workDir or absolute).',
-      },
-      kind: {
-        type: 'enum',
-        enum: ['file', 'dir', 'any'],
-        default: 'any',
-        description: 'Restrict to a file, directory, or accept either.',
-      },
-      min_size: {
-        type: 'number',
-        min: 0,
-        description: 'Optional minimum size in bytes (files only).',
-      },
-    },
-  },
-
-  async check(
-    config: Record<string, unknown>,
-    _result: TaskResult,
-    ctx: CompletionContext,
-  ): Promise<boolean> {
-    const filePath = config.path as string;
-    if (!filePath) throw new Error('file_exists completion: "path" is required');
-
-    const safePath = validatePath(filePath, ctx.workDir);
-
-    const kind = (config.kind as Kind | undefined) ?? 'any';
-    if (kind !== 'file' && kind !== 'dir' && kind !== 'any') {
-      throw new Error(
-        `file_exists completion: "kind" must be "file" | "dir" | "any", got "${kind}"`,
-      );
-    }
-
-    const minSize = config.min_size;
-    if (minSize != null && (typeof minSize !== 'number' || minSize < 0)) {
-      throw new Error(`file_exists completion: "min_size" must be a non-negative number`);
-    }
-
-    try {
-      const st = await stat(safePath);
-      if (kind === 'file' && !st.isFile()) return false;
-      if (kind === 'dir' && !st.isDirectory()) return false;
-      if (typeof minSize === 'number' && st.isFile() && st.size < minSize) return false;
-      return true;
-    } catch (err: unknown) {
-      const code = (err as NodeJS.ErrnoException).code;
-      if (code === 'ENOENT' || code === 'ENOTDIR') return false;
-      // Permission / IO errors should surface, not silently mean "missing"
-      throw err;
-    }
-  },
-};
+import { stat } from 'node:fs/promises';
+import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
+import { validatePath } from '../utils';
+
+type Kind = 'file' | 'dir' | 'any';
+
+export const FileExistsCompletion: CompletionPlugin = {
+  name: 'file_exists',
+  schema: {
+    description: 'Mark the task successful when a target file or directory exists.',
+    fields: {
+      path: {
+        type: 'path',
+        required: true,
+        description: 'Path to check (relative to workDir or absolute).',
+      },
+      kind: {
+        type: 'enum',
+        enum: ['file', 'dir', 'any'],
+        default: 'any',
+        description: 'Restrict to a file, directory, or accept either.',
+      },
+      min_size: {
+        type: 'number',
+        min: 0,
+        description: 'Optional minimum size in bytes (files only).',
+      },
+    },
+  },
+
+  async check(
+    config: Record<string, unknown>,
+    _result: TaskResult,
+    ctx: CompletionContext,
+  ): Promise<boolean> {
+    const filePath = config.path as string;
+    if (!filePath) throw new Error('file_exists completion: "path" is required');
+
+    const safePath = validatePath(filePath, ctx.workDir);
+
+    const kind = (config.kind as Kind | undefined) ?? 'any';
+    if (kind !== 'file' && kind !== 'dir' && kind !== 'any') {
+      throw new Error(
+        `file_exists completion: "kind" must be "file" | "dir" | "any", got "${kind}"`,
+      );
+    }
+
+    const minSize = config.min_size;
+    if (minSize != null && (typeof minSize !== 'number' || minSize < 0)) {
+      throw new Error(`file_exists completion: "min_size" must be a non-negative number`);
+    }
+
+    try {
+      const st = await stat(safePath);
+      if (kind === 'file' && !st.isFile()) return false;
+      if (kind === 'dir' && !st.isDirectory()) return false;
+      if (typeof minSize === 'number' && st.isFile() && st.size < minSize) return false;
+      return true;
+    } catch (err: unknown) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code === 'ENOENT' || code === 'ENOTDIR') return false;
+      // Permission / IO errors should surface, not silently mean "missing"
+      throw err;
+    }
+  },
+};