@usejarvis/brain 0.1.0

package/src/workflows/nodes/triggers/cron.ts

@@ -0,0 +1,40 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const cronTrigger: NodeDefinition = {
+  type: 'trigger.cron',
+  label: 'Cron Trigger',
+  description: 'Fire a workflow on a cron schedule.',
+  category: 'trigger',
+  icon: '⏰',
+  color: '#8b5cf6',
+  configSchema: {
+    expression: {
+      type: 'string',
+      label: 'Cron Expression',
+      description: 'Standard cron expression, e.g. "0 9 * * 1-5"',
+      required: true,
+      placeholder: '0 9 * * *',
+    },
+    timezone: {
+      type: 'string',
+      label: 'Timezone',
+      description: 'IANA timezone name, e.g. "America/New_York". Defaults to UTC.',
+      required: false,
+      placeholder: 'UTC',
+    },
+  },
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    ctx.logger.info(`Cron trigger fired — expression: ${config.expression}`);
+    return {
+      data: {
+        triggerType: 'cron',
+        expression: config.expression,
+        timezone: config.timezone ?? 'UTC',
+        firedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};

package/src/workflows/nodes/triggers/email.ts

@@ -0,0 +1,40 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const emailTrigger: NodeDefinition = {
+  type: 'trigger.email',
+  label: 'Email Trigger',
+  description: 'Fire when a new email is received matching optional from/subject filters.',
+  category: 'trigger',
+  icon: '📧',
+  color: '#8b5cf6',
+  configSchema: {
+    from_filter: {
+      type: 'string',
+      label: 'From Filter',
+      description: 'Regex or plain-text pattern to match the sender address.',
+      required: false,
+      placeholder: 'alerts@example.com',
+    },
+    subject_filter: {
+      type: 'string',
+      label: 'Subject Filter',
+      description: 'Regex or plain-text pattern to match the email subject.',
+      required: false,
+      placeholder: 'URGENT:',
+    },
+  },
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    ctx.logger.info('Email trigger fired');
+    return {
+      data: {
+        triggerType: 'email',
+        from_filter: config.from_filter ?? null,
+        subject_filter: config.subject_filter ?? null,
+        receivedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};

package/src/workflows/nodes/triggers/file-change.ts

@@ -0,0 +1,45 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const fileChangeTrigger: NodeDefinition = {
+  type: 'trigger.file_change',
+  label: 'File Change Trigger',
+  description: 'Fire when a file or directory changes on disk.',
+  category: 'trigger',
+  icon: '📁',
+  color: '#8b5cf6',
+  configSchema: {
+    watch_path: {
+      type: 'string',
+      label: 'Watch Path',
+      description: 'Absolute or relative path to watch. Supports glob patterns.',
+      required: true,
+      placeholder: '/home/user/documents/**',
+    },
+    events: {
+      type: 'select',
+      label: 'Events',
+      description: 'Which file system events to listen for.',
+      required: true,
+      default: 'modified',
+      options: [
+        { label: 'Created', value: 'created' },
+        { label: 'Modified', value: 'modified' },
+        { label: 'Deleted', value: 'deleted' },
+      ],
+    },
+  },
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    ctx.logger.info(`File change trigger fired — path: ${config.watch_path}, event: ${config.events}`);
+    return {
+      data: {
+        triggerType: 'file_change',
+        watch_path: config.watch_path,
+        event: config.events,
+        firedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};

package/src/workflows/nodes/triggers/git.ts

@@ -0,0 +1,46 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const gitTrigger: NodeDefinition = {
+  type: 'trigger.git',
+  label: 'Git Trigger',
+  description: 'Fire when a git event occurs in a local repository.',
+  category: 'trigger',
+  icon: '🌿',
+  color: '#8b5cf6',
+  configSchema: {
+    repo_path: {
+      type: 'string',
+      label: 'Repository Path',
+      description: 'Absolute path to the local git repository.',
+      required: true,
+      placeholder: '/home/user/my-project',
+    },
+    events: {
+      type: 'select',
+      label: 'Git Event',
+      description: 'Which git event to listen for.',
+      required: true,
+      default: 'commit',
+      options: [
+        { label: 'Push', value: 'push' },
+        { label: 'Pull', value: 'pull' },
+        { label: 'Commit', value: 'commit' },
+        { label: 'Branch', value: 'branch' },
+      ],
+    },
+  },
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    ctx.logger.info(`Git trigger fired — repo: ${config.repo_path}, event: ${config.events}`);
+    return {
+      data: {
+        triggerType: 'git',
+        repo_path: config.repo_path,
+        event: config.events,
+        firedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};

package/src/workflows/nodes/triggers/manual.ts

@@ -0,0 +1,23 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const manualTrigger: NodeDefinition = {
+  type: 'trigger.manual',
+  label: 'Manual Trigger',
+  description: 'Trigger the workflow manually via the dashboard or API.',
+  category: 'trigger',
+  icon: '▶️',
+  color: '#8b5cf6',
+  configSchema: {},
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, _config, ctx) => {
+    ctx.logger.info('Manual trigger fired');
+    return {
+      data: {
+        triggerType: 'manual',
+        firedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};

package/src/workflows/nodes/triggers/poll.ts

@@ -0,0 +1,81 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const pollTrigger: NodeDefinition = {
+  type: 'trigger.poll',
+  label: 'Poll Trigger',
+  description: 'Periodically poll a URL and fire when the response changes.',
+  category: 'trigger',
+  icon: '🔄',
+  color: '#8b5cf6',
+  configSchema: {
+    url: {
+      type: 'template',
+      label: 'URL',
+      description: 'URL to poll. Supports template expressions.',
+      required: true,
+      placeholder: 'https://api.example.com/status',
+    },
+    interval_ms: {
+      type: 'number',
+      label: 'Interval (ms)',
+      description: 'Polling interval in milliseconds.',
+      required: true,
+      default: 60000,
+    },
+    method: {
+      type: 'select',
+      label: 'HTTP Method',
+      description: 'HTTP method to use when polling.',
+      required: true,
+      default: 'GET',
+      options: [
+        { label: 'GET', value: 'GET' },
+        { label: 'POST', value: 'POST' },
+      ],
+    },
+    dedup_field: {
+      type: 'string',
+      label: 'Dedup Field',
+      description: 'Optional dot-path into the response body to use for deduplication.',
+      required: false,
+      placeholder: 'data.id',
+    },
+  },
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const url = String(config.url ?? '');
+    const method = String(config.method ?? 'GET');
+    ctx.logger.info(`Poll trigger fired — url: ${url}, method: ${method}`);
+
+    let responseData: unknown = null;
+    let responseStatus = 0;
+
+    try {
+      const response = await fetch(url, { method, signal: ctx.abortSignal });
+      responseStatus = response.status;
+      const text = await response.text();
+      try {
+        responseData = JSON.parse(text);
+      } catch {
+        responseData = text;
+      }
+    } catch (err) {
+      ctx.logger.warn(`Poll fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    return {
+      data: {
+        triggerType: 'poll',
+        url,
+        method,
+        interval_ms: config.interval_ms,
+        dedup_field: config.dedup_field ?? null,
+        status: responseStatus,
+        response: responseData,
+        firedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};

package/src/workflows/nodes/triggers/process.ts

@@ -0,0 +1,44 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const processTrigger: NodeDefinition = {
+  type: 'trigger.process',
+  label: 'Process Trigger',
+  description: 'Fire when a system process starts or stops.',
+  category: 'trigger',
+  icon: '⚙️',
+  color: '#8b5cf6',
+  configSchema: {
+    process_name: {
+      type: 'string',
+      label: 'Process Name',
+      description: 'Name or partial name of the process to watch.',
+      required: true,
+      placeholder: 'chrome',
+    },
+    event: {
+      type: 'select',
+      label: 'Event',
+      description: 'Whether to fire when the process starts or stops.',
+      required: true,
+      default: 'started',
+      options: [
+        { label: 'Started', value: 'started' },
+        { label: 'Stopped', value: 'stopped' },
+      ],
+    },
+  },
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    ctx.logger.info(`Process trigger fired — process: ${config.process_name}, event: ${config.event}`);
+    return {
+      data: {
+        triggerType: 'process',
+        process_name: config.process_name,
+        event: config.event,
+        firedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};

package/src/workflows/nodes/triggers/screen-event.ts

@@ -0,0 +1,37 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const screenEventTrigger: NodeDefinition = {
+  type: 'trigger.screen_event',
+  label: 'Screen Event Trigger',
+  description: 'Fire when the Continuous Awareness Engine detects a screen event.',
+  category: 'trigger',
+  icon: '🖥️',
+  color: '#8b5cf6',
+  configSchema: {
+    event_type: {
+      type: 'select',
+      label: 'Event Type',
+      description: 'The type of screen event to listen for.',
+      required: true,
+      default: 'error_detected',
+      options: [
+        { label: 'Error Detected', value: 'error_detected' },
+        { label: 'Struggle Detected', value: 'struggle_detected' },
+        { label: 'Context Changed', value: 'context_changed' },
+      ],
+    },
+  },
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    ctx.logger.info(`Screen event trigger fired — type: ${config.event_type}`);
+    return {
+      data: {
+        triggerType: 'screen_event',
+        event_type: config.event_type,
+        firedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};

package/src/workflows/nodes/triggers/webhook.ts

@@ -0,0 +1,39 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const webhookTrigger: NodeDefinition = {
+  type: 'trigger.webhook',
+  label: 'Webhook Trigger',
+  description: 'Receive an inbound HTTP request and fire the workflow.',
+  category: 'trigger',
+  icon: '🔗',
+  color: '#8b5cf6',
+  configSchema: {
+    path: {
+      type: 'string',
+      label: 'Path',
+      description: 'URL path this webhook listens on, e.g. "/webhooks/my-event"',
+      required: true,
+      placeholder: '/webhooks/my-event',
+    },
+    secret: {
+      type: 'string',
+      label: 'Secret',
+      description: 'Optional HMAC-SHA256 secret used to verify incoming payloads.',
+      required: false,
+      placeholder: 'my-secret-token',
+    },
+  },
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    ctx.logger.info(`Webhook trigger fired — path: ${config.path}`);
+    return {
+      data: {
+        triggerType: 'webhook',
+        path: config.path,
+        receivedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};

package/src/workflows/safe-eval.ts

@@ -0,0 +1,139 @@
+/**
+ * Safe Expression Evaluator — sandboxed execution for workflow nodes.
+ *
+ * Validates expressions against a blocklist of dangerous patterns,
+ * freezes scope objects, and enforces timeouts for code execution.
+ */
+
+/** Patterns that indicate dangerous code — block these in expressions */
+const BLOCKED_PATTERNS = [
+  /\brequire\s*\(/,
+  /\bimport\s*[\(\{]/,
+  /\bimport\b/,
+  /\bprocess\b/,
+  /\bBun\b/,
+  /\bDeno\b/,
+  /\bglobalThis\b/,
+  /\bglobal\b/,
+  /\beval\s*\(/,
+  /\bFunction\s*\(/,
+  /\bchild_process\b/,
+  /\b__dirname\b/,
+  /\b__filename\b/,
+  /\bsetTimeout\b/,
+  /\bsetInterval\b/,
+  /\bsetImmediate\b/,
+  /\bclearTimeout\b/,
+  /\bclearInterval\b/,
+  /\bfetch\s*\(/,
+  /\bXMLHttpRequest\b/,
+  /\bWebSocket\b/,
+  /\bnew\s+Worker\b/,
+  /\bfs\b\.\b/,
+  /\bexecSync\b/,
+  /\bspawnSync\b/,
+  /\bexec\s*\(/,
+  /\bspawn\s*\(/,
+];
+
+/**
+ * Validate an expression or code string against the blocklist.
+ * Throws if a dangerous pattern is detected.
+ */
+export function validateExpression(expr: string): void {
+  for (const pattern of BLOCKED_PATTERNS) {
+    if (pattern.test(expr)) {
+      throw new Error(
+        `Blocked: expression contains forbidden pattern "${pattern.source}". ` +
+        `Workflow expressions cannot access system APIs, imports, or process globals.`
+      );
+    }
+  }
+}
+
+/**
+ * Safely evaluate a simple JavaScript expression.
+ * Used by if-else, switch, and map-filter nodes.
+ *
+ * The expression is validated against the blocklist, then executed
+ * in a Function with frozen scope objects.
+ */
+export function safeEvaluateExpression(
+  expression: string,
+  scope: Record<string, unknown>,
+): unknown {
+  validateExpression(expression);
+
+  // Freeze scope to prevent mutation
+  const frozenScope: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(scope)) {
+    frozenScope[key] = value && typeof value === 'object' ? Object.freeze({ ...value as object }) : value;
+  }
+
+  const scopeKeys = Object.keys(frozenScope);
+  const scopeValues = Object.values(frozenScope);
+
+  // eslint-disable-next-line no-new-func
+  const fn = new Function(
+    ...scopeKeys,
+    `"use strict"; return (${expression});`,
+  );
+
+  return fn(...scopeValues);
+}
+
+/**
+ * Safely execute a code block with timeout.
+ * Used by the code-execution node.
+ *
+ * Validates against blocklist, shadows dangerous globals,
+ * freezes context, and enforces a timeout.
+ */
+export async function safeExecuteCode(
+  code: string,
+  input: { data: Record<string, unknown>; variables: Record<string, unknown>; executionId: string },
+  safeCtx: Record<string, unknown>,
+  timeoutMs: number = 10_000,
+): Promise<unknown> {
+  validateExpression(code);
+
+  // Freeze context objects
+  const frozenInput = Object.freeze({
+    data: Object.freeze({ ...input.data }),
+    variables: Object.freeze({ ...input.variables }),
+    executionId: input.executionId,
+  });
+  const frozenCtx = Object.freeze({ ...safeCtx });
+
+  // Shadow dangerous globals by declaring them as undefined in the function scope
+  const wrappedCode = `
+    "use strict";
+    var process = undefined, Bun = undefined, Deno = undefined;
+    var require = undefined, globalThis = undefined, global = undefined;
+    var fetch = undefined, XMLHttpRequest = undefined, WebSocket = undefined;
+    var __dirname = undefined, __filename = undefined;
+    return (async function(input, ctx) {
+      ${code}
+    })(input, ctx);
+  `;
+
+  // eslint-disable-next-line no-new-func
+  const fn = new Function('input', 'ctx', wrappedCode);
+
+  // Execute with timeout
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const result = await Promise.race([
+      fn(frozenInput, frozenCtx),
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`Code execution timed out after ${timeoutMs}ms`)),
+          timeoutMs,
+        );
+      }),
+    ]);
+    return result;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/workflows/template.ts

@@ -0,0 +1,118 @@
+/**
+ * Template Expression Engine
+ *
+ * Resolves {{...}} expressions in workflow node configs.
+ * Supported patterns:
+ *   {{variable.path}}                   — access execution/persistent variables
+ *   {{$trigger.field}}                  — trigger data
+ *   {{$node["nodeName"].data.field}}    — output from a previous node
+ *   {{$env.VAR_NAME}}                   — environment variable
+ */
+
+export type TemplateContext = {
+  variables: Record<string, unknown>;
+  nodeOutputs: Map<string, Record<string, unknown>>;
+  triggerData: Record<string, unknown>;
+  env: Record<string, string>;
+};
+
+const EXPR_RE = /\{\{(.+?)\}\}/g;
+
+/**
+ * Resolve a single expression (the content between {{ and }})
+ */
+export function resolveExpression(expr: string, ctx: TemplateContext): unknown {
+  const trimmed = expr.trim();
+
+  // $node["nodeName"].data.field
+  const nodeMatch = trimmed.match(/^\$node\["([^"]+)"\]\.(.+)$/);
+  if (nodeMatch) {
+    const [, nodeName, path] = nodeMatch;
+    const nodeData = ctx.nodeOutputs.get(nodeName!);
+    if (!nodeData) return undefined;
+    return resolvePath(nodeData, path!);
+  }
+
+  // $trigger.field
+  if (trimmed.startsWith('$trigger.')) {
+    const path = trimmed.slice('$trigger.'.length);
+    return resolvePath(ctx.triggerData, path);
+  }
+
+  // $env.VAR
+  if (trimmed.startsWith('$env.')) {
+    const key = trimmed.slice('$env.'.length);
+    return ctx.env[key] ?? '';
+  }
+
+  // variable.path (default)
+  return resolvePath(ctx.variables, trimmed);
+}
+
+/**
+ * Resolve all {{...}} expressions in a string. If the entire string
+ * is a single expression, return the raw value (not stringified).
+ */
+export function resolveTemplateString(template: string, ctx: TemplateContext): unknown {
+  // If entire string is a single expression, return raw value
+  const singleMatch = template.match(/^\{\{(.+?)\}\}$/);
+  if (singleMatch) {
+    return resolveExpression(singleMatch[1]!, ctx);
+  }
+
+  // Otherwise interpolate all expressions as strings
+  return template.replace(EXPR_RE, (_match, expr) => {
+    const val = resolveExpression(expr, ctx);
+    if (val === undefined || val === null) return '';
+    return typeof val === 'object' ? JSON.stringify(val) : String(val);
+  });
+}
+
+/**
+ * Recursively resolve all template strings in a config object.
+ */
+export function resolveAllTemplates(
+  config: Record<string, unknown>,
+  ctx: TemplateContext,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(config)) {
+    if (typeof value === 'string' && value.includes('{{')) {
+      result[key] = resolveTemplateString(value, ctx);
+    } else if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+      result[key] = resolveAllTemplates(value as Record<string, unknown>, ctx);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map(item => {
+        if (typeof item === 'string' && item.includes('{{')) {
+          return resolveTemplateString(item, ctx);
+        }
+        if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
+          return resolveAllTemplates(item as Record<string, unknown>, ctx);
+        }
+        return item;
+      });
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Resolve a dot-separated path on an object.
+ * Supports nested access: "foo.bar.baz" → obj.foo.bar.baz
+ */
+function resolvePath(obj: unknown, path: string): unknown {
+  const parts = path.split('.');
+  let current: unknown = obj;
+
+  for (const part of parts) {
+    if (current === null || current === undefined) return undefined;
+    if (typeof current !== 'object') return undefined;
+    current = (current as Record<string, unknown>)[part];
+  }
+
+  return current;
+}