@tagma/sdk 0.1.3 → 0.1.5

package/src/adapters/websocket-approval.ts

@@ -1,144 +1,144 @@
-import type { ApprovalGateway, ApprovalEvent } from '../approval';
-
-// ═══ WebSocket Approval Adapter ═══
-//
-// Bridges the ApprovalGateway to WebSocket clients (e.g. a frontend UI).
-// Mirrors the stdin-approval adapter pattern: subscribe to gateway events,
-// forward them as JSON to all connected clients, and call gateway.resolve()
-// when a client sends a resolution message.
-//
-// Protocol — server → client:
-//   { type: 'pending',             requests: ApprovalRequest[] }   ← sent on connect
-//   { type: 'approval_requested',  request:  ApprovalRequest }
-//   { type: 'approval_resolved',   request:  ApprovalRequest, decision: ApprovalDecision }
-//   { type: 'approval_expired',    request:  ApprovalRequest }
-//   { type: 'approval_aborted',    request:  ApprovalRequest, reason: string }
-//
-// Protocol — client → server:
-//   { type: 'resolve', approvalId: string, outcome: 'approved'|'rejected',
-//     choice?: string, actor?: string, reason?: string }
-
-export interface WebSocketApprovalAdapterOptions {
-  port?: number;      // default: 3000
-  hostname?: string;  // default: 'localhost'
-}
-
-export interface WebSocketApprovalAdapter {
-  readonly port: number;
-  readonly detach: () => void;
-}
-
-export function attachWebSocketApprovalAdapter(
-  gateway: ApprovalGateway,
-  options: WebSocketApprovalAdapterOptions = {},
-): WebSocketApprovalAdapter {
-  const port = options.port ?? 3000;
-  const hostname = options.hostname ?? 'localhost';
-
-  const clients = new Set<import('bun').ServerWebSocket<unknown>>();
-
-  function broadcast(msg: unknown): void {
-    const text = JSON.stringify(msg);
-    for (const ws of clients) {
-      ws.send(text);
-    }
-  }
-
-  const unsubscribe = gateway.subscribe((event: ApprovalEvent) => {
-    switch (event.type) {
-      case 'requested':
-        broadcast({ type: 'approval_requested', request: event.request });
-        break;
-      case 'resolved':
-        broadcast({ type: 'approval_resolved', request: event.request, decision: event.decision });
-        break;
-      case 'expired':
-        broadcast({ type: 'approval_expired', request: event.request });
-        break;
-      case 'aborted':
-        broadcast({ type: 'approval_aborted', request: event.request, reason: event.reason });
-        break;
-    }
-  });
-
-  const server = Bun.serve({
-    port,
-    hostname,
-
-    fetch(req, server) {
-      if (server.upgrade(req)) return undefined;
-      return new Response('tagma-sdk WebSocket approval endpoint', { status: 426 });
-    },
-
-    websocket: {
-      open(ws) {
-        clients.add(ws);
-        // Sync current pending approvals to newly connected client.
-        ws.send(JSON.stringify({ type: 'pending', requests: gateway.pending() }));
-      },
-
-      message(ws, raw) {
-        let msg: unknown;
-        try {
-          msg = JSON.parse(typeof raw === 'string' ? raw : raw.toString());
-        } catch {
-          ws.send(JSON.stringify({ type: 'error', message: 'invalid JSON' }));
-          return;
-        }
-
-        if (!isResolveMessage(msg)) {
-          ws.send(JSON.stringify({ type: 'error', message: 'unknown message type' }));
-          return;
-        }
-
-        const ok = gateway.resolve(msg.approvalId, {
-          outcome: msg.outcome,
-          choice: msg.choice,
-          actor: msg.actor ?? 'websocket',
-          reason: msg.reason,
-        });
-
-        if (!ok) {
-          ws.send(JSON.stringify({
-            type: 'error',
-            message: `approval ${msg.approvalId} not found or already resolved`,
-          }));
-        }
-      },
-
-      close(ws) {
-        clients.delete(ws);
-      },
-    },
-  });
-
-  return {
-    port: server.port,
-    detach() {
-      unsubscribe();
-      clients.clear();
-      server.stop(true);
-    },
-  };
-}
-
-// ── Type guard ──
-
-interface ResolveMessage {
-  type: 'resolve';
-  approvalId: string;
-  outcome: 'approved' | 'rejected';
-  choice?: string;
-  actor?: string;
-  reason?: string;
-}
-
-function isResolveMessage(v: unknown): v is ResolveMessage {
-  if (typeof v !== 'object' || v === null) return false;
-  const m = v as Record<string, unknown>;
-  return (
-    m['type'] === 'resolve' &&
-    typeof m['approvalId'] === 'string' &&
-    (m['outcome'] === 'approved' || m['outcome'] === 'rejected')
-  );
-}
+import type { ApprovalGateway, ApprovalEvent } from '../approval';
+
+// ═══ WebSocket Approval Adapter ═══
+//
+// Bridges the ApprovalGateway to WebSocket clients (e.g. a frontend UI).
+// Mirrors the stdin-approval adapter pattern: subscribe to gateway events,
+// forward them as JSON to all connected clients, and call gateway.resolve()
+// when a client sends a resolution message.
+//
+// Protocol — server → client:
+//   { type: 'pending',             requests: ApprovalRequest[] }   ← sent on connect
+//   { type: 'approval_requested',  request:  ApprovalRequest }
+//   { type: 'approval_resolved',   request:  ApprovalRequest, decision: ApprovalDecision }
+//   { type: 'approval_expired',    request:  ApprovalRequest }
+//   { type: 'approval_aborted',    request:  ApprovalRequest, reason: string }
+//
+// Protocol — client → server:
+//   { type: 'resolve', approvalId: string, outcome: 'approved'|'rejected',
+//     choice?: string, actor?: string, reason?: string }
+
+export interface WebSocketApprovalAdapterOptions {
+  port?: number;      // default: 3000
+  hostname?: string;  // default: 'localhost'
+}
+
+export interface WebSocketApprovalAdapter {
+  readonly port: number;
+  readonly detach: () => void;
+}
+
+export function attachWebSocketApprovalAdapter(
+  gateway: ApprovalGateway,
+  options: WebSocketApprovalAdapterOptions = {},
+): WebSocketApprovalAdapter {
+  const port = options.port ?? 3000;
+  const hostname = options.hostname ?? 'localhost';
+
+  const clients = new Set<import('bun').ServerWebSocket<unknown>>();
+
+  function broadcast(msg: unknown): void {
+    const text = JSON.stringify(msg);
+    for (const ws of clients) {
+      ws.send(text);
+    }
+  }
+
+  const unsubscribe = gateway.subscribe((event: ApprovalEvent) => {
+    switch (event.type) {
+      case 'requested':
+        broadcast({ type: 'approval_requested', request: event.request });
+        break;
+      case 'resolved':
+        broadcast({ type: 'approval_resolved', request: event.request, decision: event.decision });
+        break;
+      case 'expired':
+        broadcast({ type: 'approval_expired', request: event.request });
+        break;
+      case 'aborted':
+        broadcast({ type: 'approval_aborted', request: event.request, reason: event.reason });
+        break;
+    }
+  });
+
+  const server = Bun.serve({
+    port,
+    hostname,
+
+    fetch(req, server) {
+      if (server.upgrade(req)) return undefined;
+      return new Response('tagma-sdk WebSocket approval endpoint', { status: 426 });
+    },
+
+    websocket: {
+      open(ws) {
+        clients.add(ws);
+        // Sync current pending approvals to newly connected client.
+        ws.send(JSON.stringify({ type: 'pending', requests: gateway.pending() }));
+      },
+
+      message(ws, raw) {
+        let msg: unknown;
+        try {
+          msg = JSON.parse(typeof raw === 'string' ? raw : raw.toString());
+        } catch {
+          ws.send(JSON.stringify({ type: 'error', message: 'invalid JSON' }));
+          return;
+        }
+
+        if (!isResolveMessage(msg)) {
+          ws.send(JSON.stringify({ type: 'error', message: 'unknown message type' }));
+          return;
+        }
+
+        const ok = gateway.resolve(msg.approvalId, {
+          outcome: msg.outcome,
+          choice: msg.choice,
+          actor: msg.actor ?? 'websocket',
+          reason: msg.reason,
+        });
+
+        if (!ok) {
+          ws.send(JSON.stringify({
+            type: 'error',
+            message: `approval ${msg.approvalId} not found or already resolved`,
+          }));
+        }
+      },
+
+      close(ws) {
+        clients.delete(ws);
+      },
+    },
+  });
+
+  return {
+    port: server.port!,
+    detach() {
+      unsubscribe();
+      clients.clear();
+      server.stop(true);
+    },
+  };
+}
+
+// ── Type guard ──
+
+interface ResolveMessage {
+  type: 'resolve';
+  approvalId: string;
+  outcome: 'approved' | 'rejected';
+  choice?: string;
+  actor?: string;
+  reason?: string;
+}
+
+function isResolveMessage(v: unknown): v is ResolveMessage {
+  if (typeof v !== 'object' || v === null) return false;
+  const m = v as Record<string, unknown>;
+  return (
+    m['type'] === 'resolve' &&
+    typeof m['approvalId'] === 'string' &&
+    (m['outcome'] === 'approved' || m['outcome'] === 'rejected')
+  );
+}

package/src/completions/exit-code.ts

@@ -1,19 +1,19 @@
-import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
-
-export const ExitCodeCompletion: CompletionPlugin = {
-  name: 'exit_code',
-
-  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',
+
+  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,39 +1,39 @@
-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',
-
-  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',
+
+  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;
+    }
+  },
+};

package/src/completions/output-check.ts

@@ -1,57 +1,57 @@
-import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
-import { shellArgs, parseDuration } from '../utils';
-
-const DEFAULT_TIMEOUT_MS = 30_000;
-
-export const OutputCheckCompletion: CompletionPlugin = {
-  name: 'output_check',
-
-  async check(config: Record<string, unknown>, result: TaskResult, ctx: CompletionContext): Promise<boolean> {
-    const checkCmd = config.check as string;
-    if (!checkCmd) throw new Error('output_check completion: "check" is required');
-
-    const timeoutMs = config.timeout != null
-      ? parseDuration(String(config.timeout))
-      : DEFAULT_TIMEOUT_MS;
-
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-
-    const proc = Bun.spawn(shellArgs(checkCmd) as string[], {
-      cwd: ctx.workDir,
-      stdin: 'pipe',
-      stdout: 'pipe',
-      stderr: 'pipe',
-      signal: controller.signal,
-    });
-
-    try {
-      if (proc.stdin) {
-        try {
-          proc.stdin.write(result.stdout);
-          await proc.stdin.end();
-        } catch (err: unknown) {
-          // EPIPE is expected when the check process exits before reading all of stdin
-          // (e.g. `grep -q` exits on first match). Anything else is a real failure.
-          const code = (err as NodeJS.ErrnoException)?.code;
-          if (code !== 'EPIPE') throw err;
-        }
-      }
-
-      const exitCode = await proc.exited;
-
-      if (exitCode !== 0) {
-        try {
-          const stderr = await new Response(proc.stderr).text();
-          if (stderr.trim()) {
-            console.warn(`[output_check] "${checkCmd}" exit=${exitCode}: ${stderr.trim()}`);
-          }
-        } catch { /* ignore stderr read failures */ }
-      }
-
-      return exitCode === 0;
-    } finally {
-      clearTimeout(timer);
-    }
-  },
-};
+import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
+import { shellArgs, parseDuration } from '../utils';
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+export const OutputCheckCompletion: CompletionPlugin = {
+  name: 'output_check',
+
+  async check(config: Record<string, unknown>, result: TaskResult, ctx: CompletionContext): Promise<boolean> {
+    const checkCmd = config.check as string;
+    if (!checkCmd) throw new Error('output_check completion: "check" is required');
+
+    const timeoutMs = config.timeout != null
+      ? parseDuration(String(config.timeout))
+      : DEFAULT_TIMEOUT_MS;
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+    const proc = Bun.spawn(shellArgs(checkCmd) as string[], {
+      cwd: ctx.workDir,
+      stdin: 'pipe',
+      stdout: 'pipe',
+      stderr: 'pipe',
+      signal: controller.signal,
+    });
+
+    try {
+      if (proc.stdin) {
+        try {
+          proc.stdin.write(result.stdout);
+          await proc.stdin.end();
+        } catch (err: unknown) {
+          // EPIPE is expected when the check process exits before reading all of stdin
+          // (e.g. `grep -q` exits on first match). Anything else is a real failure.
+          const code = (err as NodeJS.ErrnoException)?.code;
+          if (code !== 'EPIPE') throw err;
+        }
+      }
+
+      const exitCode = await proc.exited;
+
+      if (exitCode !== 0) {
+        try {
+          const stderr = await new Response(proc.stderr).text();
+          if (stderr.trim()) {
+            console.warn(`[output_check] "${checkCmd}" exit=${exitCode}: ${stderr.trim()}`);
+          }
+        } catch { /* ignore stderr read failures */ }
+      }
+
+      return exitCode === 0;
+    } finally {
+      clearTimeout(timer);
+    }
+  },
+};