devglide 0.1.1

package/src/apps/voice/src/services/stats.ts

@@ -0,0 +1,108 @@
+import { getProvider } from "../providers/index.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { VOICE_DIR } from "../../../../packages/paths.js";
+
+const DATA_DIR = VOICE_DIR;
+const STATS_FILE = join(DATA_DIR, "stats.json");
+
+export interface VoiceStats {
+  provider: string;
+  totalTranscriptions: number;
+  totalDurationSec: number;
+  totalErrors: number;
+  lastTranscriptionAt: string | null;
+  providerStatus: "configured" | "not_configured";
+}
+
+interface PersistedStats {
+  totalTranscriptions: number;
+  totalDurationSec: number;
+  totalErrors: number;
+  lastTranscriptionAt: string | null;
+}
+
+function loadStats(): PersistedStats {
+  try {
+    if (existsSync(STATS_FILE)) {
+      return JSON.parse(readFileSync(STATS_FILE, "utf-8"));
+    }
+  } catch {}
+  return { totalTranscriptions: 0, totalDurationSec: 0, totalErrors: 0, lastTranscriptionAt: null };
+}
+
+function saveStats(data: PersistedStats): void {
+  mkdirSync(DATA_DIR, { recursive: true });
+  writeFileSync(STATS_FILE, JSON.stringify(data, null, 2));
+}
+
+class StatsTracker {
+  private static instance: StatsTracker;
+
+  private totalTranscriptions: number;
+  private totalDurationSec: number;
+  private totalErrors: number;
+  private lastTranscriptionAt: Date | null;
+
+  private constructor() {
+    const persisted = loadStats();
+    this.totalTranscriptions = persisted.totalTranscriptions;
+    this.totalDurationSec = persisted.totalDurationSec;
+    this.totalErrors = persisted.totalErrors;
+    this.lastTranscriptionAt = persisted.lastTranscriptionAt ? new Date(persisted.lastTranscriptionAt) : null;
+  }
+
+  static getInstance(): StatsTracker {
+    if (!StatsTracker.instance) {
+      StatsTracker.instance = new StatsTracker();
+    }
+    return StatsTracker.instance;
+  }
+
+  private flush(): void {
+    saveStats({
+      totalTranscriptions: this.totalTranscriptions,
+      totalDurationSec: this.totalDurationSec,
+      totalErrors: this.totalErrors,
+      lastTranscriptionAt: this.lastTranscriptionAt?.toISOString() ?? null,
+    });
+  }
+
+  recordSuccess(durationSec?: number) {
+    this.totalTranscriptions++;
+    if (durationSec) {
+      this.totalDurationSec += durationSec;
+    }
+    this.lastTranscriptionAt = new Date();
+    this.flush();
+  }
+
+  recordError() {
+    this.totalErrors++;
+    this.flush();
+  }
+
+  reset() {
+    this.totalTranscriptions = 0;
+    this.totalDurationSec = 0;
+    this.totalErrors = 0;
+    this.lastTranscriptionAt = null;
+    this.flush();
+  }
+
+  getStats(): VoiceStats {
+    const provider = getProvider();
+    return {
+      provider: provider.name,
+      totalTranscriptions: this.totalTranscriptions,
+      totalDurationSec: Math.round(this.totalDurationSec * 100) / 100,
+      totalErrors: this.totalErrors,
+      lastTranscriptionAt: this.lastTranscriptionAt?.toISOString() ?? null,
+      providerStatus: provider.isConfigured()
+        ? "configured"
+        : "not_configured",
+    };
+  }
+}
+
+export const stats = StatsTracker.getInstance();

package/src/apps/voice/src/transcribe.ts

@@ -0,0 +1,11 @@
+import { getProvider } from "./providers/index.js";
+import type { TranscribeOptions, TranscriptionResult } from "./providers/types.js";
+
+export type { TranscribeOptions, TranscriptionResult };
+
+export async function transcribe(
+  audio: File,
+  options?: TranscribeOptions
+): Promise<TranscriptionResult> {
+  return getProvider().transcribe(audio, options);
+}

package/src/apps/voice/src/utils/mime.ts

@@ -0,0 +1,16 @@
+/** Canonical extension-to-MIME mapping for audio files. */
+const mimeMap: Record<string, string> = {
+  ogg: "audio/ogg",
+  mp4: "audio/mp4",
+  m4a: "audio/mp4",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  flac: "audio/flac",
+  webm: "audio/webm",
+};
+
+/** Return the audio MIME type for a filename, defaulting to `audio/webm`. */
+export function mimeFromFilename(filename: string): string {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  return mimeMap[ext || ""] || "audio/webm";
+}

package/src/apps/voice/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../packages/tsconfig/node.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/src/apps/workflow/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+ WARN  Issue while reading "/home/runner/_work/devglide/devglide/.npmrc". Failed to replace env in config: ${NODE_AUTH_TOKEN}
+
+> @devglide/workflow@0.1.0 build /home/runner/_work/devglide/devglide/src/apps/workflow
+> tsc
+

package/src/apps/workflow/.turbo/turbo-lint.log

@@ -0,0 +1,96 @@
+ WARN  Issue while reading "/home/runner/_work/devglide/devglide/.npmrc". Failed to replace env in config: ${NODE_AUTH_TOKEN}
+
+> @devglide/workflow@0.1.0 lint /home/runner/_work/devglide/devglide/src/apps/workflow
+> eslint .
+
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/engine/executors/file-executor.ts
+  2:1  warning  There should be at least one empty line between import groups  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/engine/executors/git-executor.ts
+  1:1  warning  There should be at least one empty line between import groups  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/engine/executors/index.ts
+   1:1  warning  There should be at least one empty line between import groups                             import/order
+   2:1  warning  `./trigger-executor.js` import should occur after import of `./sub-workflow-executor.js`  import/order
+   3:1  warning  `./shell-executor.js` import should occur after import of `./loop-executor.js`            import/order
+   4:1  warning  `./kanban-executor.js` import should occur after import of `./decision-executor.js`       import/order
+   5:1  warning  `./git-executor.js` import should occur after import of `./decision-executor.js`          import/order
+   6:1  warning  `./test-executor.js` import should occur after import of `./sub-workflow-executor.js`     import/order
+   7:1  warning  `./log-executor.js` import should occur after import of `./decision-executor.js`          import/order
+   8:1  warning  `./file-executor.js` import should occur after import of `./decision-executor.js`         import/order
+   9:1  warning  `./llm-executor.js` import should occur after import of `./decision-executor.js`          import/order
+  10:1  warning  `./http-executor.js` import should occur after import of `./decision-executor.js`         import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/engine/executors/kanban-executor.ts
+  1:1  warning  There should be at least one empty line between import groups                                  import/order
+  1:1  warning  `../../types.js` type import should occur after import of `../../../../apps/kanban/src/db.js`  import/order
+  2:1  warning  There should be at least one empty line between import groups                                  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/engine/executors/llm-executor.ts
+  2:1  warning  There should be at least one empty line between import groups  import/order
+  3:1  warning  There should be at least one empty line between import groups  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/engine/executors/log-executor.ts
+  2:1  warning  There should be at least one empty line between import groups                                                 import/order
+  4:1  warning  `../../../../apps/log/src/services/log-writer.js` import should occur before type import of `../../types.js`  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/engine/executors/shell-executor.ts
+  2:1  warning  There should be at least one empty line between import groups  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/engine/expression-evaluator.ts
+  1:1  warning  There should be at least one empty line between import groups  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/engine/graph-runner.ts
+   1:1  warning  There should be at least one empty line between import groups                          import/order
+   8:3  warning  'RunStatus' is defined but never used. Allowed unused vars must match /^_/u            @typescript-eslint/no-unused-vars
+  12:1  warning  There should be at least one empty line between import groups                          import/order
+  12:1  warning  `./expression-evaluator.js` import should occur before import of `./node-executor.js`  import/order
+  13:1  warning  `../../../project-context.js` import should occur before type import of `../types.js`  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/engine/node-executor.ts
+  1:1  warning  There should be at least one empty line between import groups  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/mcp.ts
+  2:1   warning  There should be at least one empty line between import groups                                                import/order
+  3:1   warning  There should be at least one empty line between import groups                                                import/order
+  4:1   warning  There should be at least one empty line between import groups                                                import/order
+  4:1   warning  `../../project-context.js` import should occur before import of `./services/workflow-store.js`               import/order
+  5:1   warning  There should be at least one empty line between import groups                                                import/order
+  5:15  warning  'Workflow' is defined but never used. Allowed unused vars must match /^_/u                                   @typescript-eslint/no-unused-vars
+  6:1   warning  `../../packages/mcp-utils/src/index.js` import should occur before import of `./services/workflow-store.js`  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/services/custom-node-loader.ts
+  2:1  warning  There should be at least one empty line between import groups  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/services/legacy-converter.ts
+  1:1  warning  There should be at least one empty line between import groups  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/services/run-manager.ts
+  1:1  warning  There should be at least one empty line between import groups                        import/order
+  2:1  warning  There should be at least one empty line between import groups                        import/order
+  4:1  warning  `../engine/graph-runner.js` import should occur before type import of `../types.js`  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/services/workflow-store.ts
+    2:1   warning  There should be at least one empty line between import groups                                   import/order
+    3:1   warning  There should be at least one empty line between import groups                                   import/order
+    5:1   warning  `../../../project-context.js` import should occur before type import of `../types.js`           import/order
+    6:1   warning  `../../../packages/paths.js` import should occur before type import of `../types.js`            import/order
+    7:1   warning  `../../../packages/json-file-store.js` import should occur before type import of `../types.js`  import/order
+  279:37  warning  Unexpected any. Specify a different type                                                        @typescript-eslint/no-explicit-any
+  389:37  warning  Unexpected any. Specify a different type                                                        @typescript-eslint/no-explicit-any
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/services/workflow-validator.test.ts
+  1:1  warning  There should be at least one empty line between import groups  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/services/workflow-validator.ts
+   2:1   warning  `../engine/node-registry.js` import should occur before type import of `../types.js`  import/order
+  49:37  warning  Unexpected any. Specify a different type                                              @typescript-eslint/no-explicit-any
+
+/home/runner/_work/devglide/devglide/src/apps/workflow/src/index.ts
+  2:1  warning  There should be at least one empty line between import groups           import/order
+  3:1  warning  `@devglide/mcp-utils` import should occur before import of `../mcp.js`  import/order
+
+✖ 51 problems (0 errors, 51 warnings)
+  0 errors and 46 warnings potentially fixable with the `--fix` option.
+

package/src/apps/workflow/.turbo/turbo-typecheck.log

@@ -0,0 +1,5 @@
+ WARN  Issue while reading "/home/runner/_work/devglide/devglide/.npmrc". Failed to replace env in config: ${NODE_AUTH_TOKEN}
+
+> @devglide/workflow@0.1.0 typecheck /home/runner/_work/devglide/devglide/src/apps/workflow
+> tsc --noEmit
+

package/src/apps/workflow/engine/executors/decision-executor.ts

@@ -0,0 +1,87 @@
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, DecisionConfig } from '../../types.js';
+import { evaluate } from '../expression-evaluator.js';
+
+/**
+ * Decision executor evaluates conditions and sets __decision_port.
+ * The graph-runner's handleDecision() reads __decision_port to route edges —
+ * this is the single source of truth for decision routing.
+ */
+export const decisionExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  context: ExecutionContext,
+  _emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as DecisionConfig;
+
+  try {
+    let selectedPort: string | undefined;
+
+    switch (cfg.conditionType) {
+      case 'exit-code': {
+        // Use actual predecessors (set by graph-runner before execution)
+        // rather than sorting all node states globally
+        const predecessorIds = context.variables.get('__predecessor_ids') as string[] | undefined;
+        let exitCode: number | undefined;
+
+        if (predecessorIds && predecessorIds.length > 0) {
+          // Use the most recently completed predecessor
+          const predecessorStates = predecessorIds
+            .map((id) => context.nodeStates.get(id))
+            .filter((s) => s?.completedAt)
+            .sort((a, b) => (b!.completedAt ?? '').localeCompare(a!.completedAt ?? ''));
+          exitCode = predecessorStates[0]?.exitCode;
+        }
+
+        const code = exitCode ?? -1;
+        for (const port of cfg.ports) {
+          if (port.condition && String(code) === port.condition) {
+            selectedPort = port.id;
+            break;
+          }
+        }
+        break;
+      }
+
+      case 'variable': {
+        if (!cfg.variable) {
+          return { status: 'failed', error: 'variable is required for variable condition type' };
+        }
+        const value = String(context.variables.get(cfg.variable) ?? '');
+
+        for (const port of cfg.ports) {
+          if (port.condition && value === port.condition) {
+            selectedPort = port.id;
+            break;
+          }
+        }
+        break;
+      }
+
+      case 'expression': {
+        for (const port of cfg.ports) {
+          if (port.condition) {
+            const match = evaluate(port.condition, context);
+            if (match) {
+              selectedPort = port.id;
+              break;
+            }
+          }
+        }
+        break;
+      }
+    }
+
+    if (!selectedPort && cfg.ports.length > 0) {
+      const defaultPort = cfg.ports.find((p) => !p.condition) ?? cfg.ports[cfg.ports.length - 1];
+      selectedPort = defaultPort.id;
+    }
+
+    return {
+      status: 'passed',
+      output: selectedPort,
+      variables: { __decision_port: selectedPort },
+    };
+  } catch (err) {
+    return { status: 'failed', error: (err as Error).message };
+  }
+};

package/src/apps/workflow/engine/executors/file-executor.ts

@@ -0,0 +1,90 @@
+import fs from 'fs/promises';
+import path from 'path';
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, FileConfig } from '../../types.js';
+
+async function safePath(reqPath: string, root: string): Promise<string> {
+  const abs = path.resolve(root, reqPath.replace(/^\/+/, ''));
+  if (!abs.startsWith(root + path.sep) && abs !== root) throw new Error('Path traversal denied');
+
+  // Resolve symlinks to prevent symlink-based traversal.
+  // For non-existing targets (write/append), walk up to the nearest existing ancestor.
+  const realRoot = await fs.realpath(root);
+  let check = abs;
+  while (true) {
+    try {
+      const real = await fs.realpath(check);
+      if (!real.startsWith(realRoot + path.sep) && real !== realRoot) {
+        throw new Error('Symlink traversal denied');
+      }
+      break;
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
+      const parent = path.dirname(check);
+      if (parent === check) break; // hit filesystem root
+      check = parent;
+    }
+  }
+
+  return abs;
+}
+
+export const fileExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  _context: ExecutionContext,
+  _emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as FileConfig;
+  const root = _context.project?.path ?? process.cwd();
+
+  try {
+    const target = await safePath(cfg.path, root);
+
+    switch (cfg.operation) {
+      case 'read': {
+        const content = await fs.readFile(target, 'utf-8');
+        return { status: 'passed', output: content };
+      }
+
+      case 'write': {
+        if (cfg.content === undefined) {
+          return { status: 'failed', error: 'content is required for write' };
+        }
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.writeFile(target, cfg.content, 'utf-8');
+        return { status: 'passed', output: `Written to ${target}` };
+      }
+
+      case 'append': {
+        if (cfg.content === undefined) {
+          return { status: 'failed', error: 'content is required for append' };
+        }
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.appendFile(target, cfg.content, 'utf-8');
+        return { status: 'passed', output: `Appended to ${target}` };
+      }
+
+      case 'exists': {
+        try {
+          await fs.access(target);
+          return { status: 'passed', output: true };
+        } catch {
+          return { status: 'passed', output: false };
+        }
+      }
+
+      case 'tree': {
+        const entries = await fs.readdir(target, { withFileTypes: true });
+        const listing = entries.map((e) => ({
+          name: e.name,
+          type: e.isDirectory() ? 'directory' : 'file',
+        }));
+        return { status: 'passed', output: listing };
+      }
+
+      default:
+        return { status: 'failed', error: `Unknown file operation: ${(cfg as FileConfig).operation}` };
+    }
+  } catch (err) {
+    return { status: 'failed', error: (err as Error).message };
+  }
+};

package/src/apps/workflow/engine/executors/git-executor.ts

@@ -0,0 +1,137 @@
+import { spawn } from 'child_process';
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, GitConfig } from '../../types.js';
+
+const GIT_TIMEOUT_MS = 60_000; // 1 minute
+const BRANCH_RE = /^[a-zA-Z0-9._/\-]+$/;
+
+function runGit(args: string[], cwd: string): Promise<{ output: string; exitCode: number }> {
+  return new Promise((resolve, reject) => {
+    const ac = new AbortController();
+    const child = spawn('git', args, { cwd, signal: ac.signal });
+    const timer = setTimeout(() => ac.abort(), GIT_TIMEOUT_MS);
+    let output = '';
+
+    child.stdout?.on('data', (data: Buffer) => { output += data.toString(); });
+    child.stderr?.on('data', (data: Buffer) => { output += data.toString(); });
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      if (err.name === 'AbortError') {
+        resolve({ output: output.trim() + '\n[TIMEOUT]', exitCode: 124 });
+      } else {
+        reject(err);
+      }
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      resolve({ output: output.trim(), exitCode: code ?? 1 });
+    });
+  });
+}
+
+/** Validate branch name — reject flag-like values and invalid characters. */
+function safeBranch(name: string): string | null {
+  if (!name || name.startsWith('-') || !BRANCH_RE.test(name)) return null;
+  return name;
+}
+
+/** Sanitize file paths — reject flag-like values. */
+function safeFiles(files: string[]): string[] | null {
+  for (const f of files) {
+    if (f.startsWith('-')) return null;
+  }
+  return files;
+}
+
+export const gitExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  _context: ExecutionContext,
+  emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as GitConfig;
+  const cwd = _context.project?.path ?? process.cwd();
+
+  try {
+    let result: { output: string; exitCode: number };
+
+    switch (cfg.operation) {
+      case 'status':
+        result = await runGit(['status', '--porcelain'], cwd);
+        break;
+
+      case 'diff':
+        result = await runGit(['diff'], cwd);
+        break;
+
+      case 'commit': {
+        if (!cfg.message) {
+          return { status: 'failed', error: 'message is required for commit' };
+        }
+        let addArgs: string[];
+        if (cfg.files && cfg.files.length > 0) {
+          const safe = safeFiles(cfg.files);
+          if (!safe) return { status: 'failed', error: 'Invalid file path — must not start with -' };
+          addArgs = ['add', '--', ...safe];
+        } else {
+          addArgs = ['add', '-A'];
+        }
+        const addResult = await runGit(addArgs, cwd);
+        if (addResult.exitCode !== 0) {
+          return { status: 'failed', output: addResult.output, exitCode: addResult.exitCode, error: addResult.output };
+        }
+        result = await runGit(['commit', '-m', cfg.message], cwd);
+        break;
+      }
+
+      case 'push':
+        result = await runGit(['push'], cwd);
+        break;
+
+      case 'branch-create': {
+        if (!cfg.branch) {
+          return { status: 'failed', error: 'branch is required for branch-create' };
+        }
+        const newBranch = safeBranch(cfg.branch);
+        if (!newBranch) return { status: 'failed', error: 'Invalid branch name' };
+        result = await runGit(['checkout', '-b', '--', newBranch], cwd);
+        break;
+      }
+
+      case 'checkout': {
+        if (!cfg.branch) {
+          return { status: 'failed', error: 'branch is required for checkout' };
+        }
+        const target = safeBranch(cfg.branch);
+        if (!target) return { status: 'failed', error: 'Invalid branch name' };
+        result = await runGit(['checkout', '--', target], cwd);
+        break;
+      }
+
+      case 'add': {
+        let addArgs: string[];
+        if (cfg.files && cfg.files.length > 0) {
+          const safe = safeFiles(cfg.files);
+          if (!safe) return { status: 'failed', error: 'Invalid file path — must not start with -' };
+          addArgs = ['add', '--', ...safe];
+        } else {
+          addArgs = ['add', '-A'];
+        }
+        result = await runGit(addArgs, cwd);
+        break;
+      }
+
+      default:
+        return { status: 'failed', error: `Unknown git operation: ${(cfg as GitConfig).operation}` };
+    }
+
+    emit({ type: 'output', nodeId: _context.runId, data: result.output });
+
+    return {
+      status: result.exitCode === 0 ? 'passed' : 'failed',
+      output: result.output,
+      exitCode: result.exitCode,
+      error: result.exitCode !== 0 ? result.output : undefined,
+    };
+  } catch (err) {
+    return { status: 'failed', error: (err as Error).message };
+  }
+};

package/src/apps/workflow/engine/executors/http-executor.ts

@@ -0,0 +1,65 @@
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, HttpConfig } from '../../types.js';
+
+const BLOCKED_HOSTS = new Set([
+  'localhost', '127.0.0.1', '[::1]', '::1', '0.0.0.0',
+  'metadata.google.internal', '169.254.169.254',
+]);
+
+function isBlockedUrl(urlStr: string): string | null {
+  let parsed: URL;
+  try { parsed = new URL(urlStr); } catch { return 'Invalid URL'; }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return 'Only HTTP/HTTPS allowed';
+  const hostname = parsed.hostname.toLowerCase();
+  if (BLOCKED_HOSTS.has(hostname)) return `Blocked host: ${hostname}`;
+  const parts = hostname.split('.').map(Number);
+  if (parts.length === 4 && parts.every((n) => !isNaN(n))) {
+    const [a, b] = parts;
+    if (a === 10) return 'Private IP blocked';
+    if (a === 172 && b >= 16 && b <= 31) return 'Private IP blocked';
+    if (a === 192 && b === 168) return 'Private IP blocked';
+    if (a === 169 && b === 254) return 'Link-local IP blocked';
+    if (a === 127) return 'Loopback IP blocked';
+  }
+  return null;
+}
+
+export const httpExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  _context: ExecutionContext,
+  _emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as HttpConfig;
+
+  try {
+    if (!cfg.url) {
+      return { status: 'failed', error: 'url is required' };
+    }
+
+    const blocked = isBlockedUrl(cfg.url);
+    if (blocked) {
+      return { status: 'failed', error: `SSRF blocked: ${blocked}` };
+    }
+
+    const init: RequestInit = {
+      method: cfg.method,
+      headers: cfg.headers,
+    };
+
+    if (cfg.body && cfg.method !== 'GET') {
+      init.body = cfg.body;
+    }
+
+    const response = await fetch(cfg.url, init);
+    const body = await response.text();
+    const ok = response.status >= 200 && response.status < 300;
+
+    return {
+      status: ok ? 'passed' : 'failed',
+      output: body,
+      exitCode: response.status,
+      error: ok ? undefined : `HTTP ${response.status}: ${response.statusText}`,
+    };
+  } catch (err) {
+    return { status: 'failed', error: (err as Error).message };
+  }
+};

package/src/apps/workflow/engine/executors/index.ts

@@ -0,0 +1,28 @@
+import { registerExecutor } from '../node-registry.js';
+import { triggerExecutor } from './trigger-executor.js';
+import { shellExecutor } from './shell-executor.js';
+import { kanbanExecutor } from './kanban-executor.js';
+import { gitExecutor } from './git-executor.js';
+import { testExecutor } from './test-executor.js';
+import { logExecutor } from './log-executor.js';
+import { fileExecutor } from './file-executor.js';
+import { llmExecutor } from './llm-executor.js';
+import { httpExecutor } from './http-executor.js';
+import { decisionExecutor } from './decision-executor.js';
+import { loopExecutor } from './loop-executor.js';
+import { subWorkflowExecutor } from './sub-workflow-executor.js';
+
+export function registerAllExecutors(): void {
+  registerExecutor('trigger', triggerExecutor);
+  registerExecutor('action:shell', shellExecutor);
+  registerExecutor('action:kanban', kanbanExecutor);
+  registerExecutor('action:git', gitExecutor);
+  registerExecutor('action:test', testExecutor);
+  registerExecutor('action:log', logExecutor);
+  registerExecutor('action:file', fileExecutor);
+  registerExecutor('action:llm', llmExecutor);
+  registerExecutor('action:http', httpExecutor);
+  registerExecutor('decision', decisionExecutor);
+  registerExecutor('loop', loopExecutor);
+  registerExecutor('sub-workflow', subWorkflowExecutor);
+}