@usejarvis/brain 0.1.0

package/src/workflows/nodes/actions/discord.ts

@@ -0,0 +1,77 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const discordAction: NodeDefinition = {
+  type: 'action.discord',
+  label: 'Send Discord Message',
+  description: 'Send a message to a Discord channel via a webhook or bot token.',
+  category: 'action',
+  icon: '🎮',
+  color: '#3b82f6',
+  configSchema: {
+    channel_id: {
+      type: 'string',
+      label: 'Channel ID or Webhook URL',
+      description: 'Discord channel ID (requires bot token) or full webhook URL.',
+      required: true,
+      placeholder: '1234567890123456789',
+    },
+    message: {
+      type: 'template',
+      label: 'Message',
+      description: 'Message content. Supports template expressions and Discord markdown.',
+      required: true,
+      placeholder: '**Alert**: {{data.message}}',
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const channelId = String(config.channel_id ?? '');
+    const message = String(config.message ?? '');
+
+    ctx.logger.info(`Sending Discord message to channel ${channelId}`);
+
+    let success = false;
+    let note = '';
+
+    // If channelId looks like a webhook URL, use it directly
+    if (channelId.startsWith('https://discord.com/api/webhooks/') || channelId.startsWith('https://discordapp.com/api/webhooks/')) {
+      try {
+        const resp = await fetch(channelId, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ content: message }),
+          signal: ctx.abortSignal,
+        });
+        success = resp.ok;
+        if (!resp.ok) {
+          note = `Discord webhook returned ${resp.status}`;
+          ctx.logger.warn(note);
+        }
+      } catch (err) {
+        throw new Error(`Discord webhook send failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else if (ctx.toolRegistry.has('send_discord')) {
+      try {
+        await ctx.toolRegistry.execute('send_discord', { channel_id: channelId, content: message });
+        success = true;
+      } catch (err) {
+        throw new Error(`Discord send failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else {
+      note = 'Discord integration not configured — message not sent';
+      ctx.logger.warn(note);
+    }
+
+    return {
+      data: {
+        ...input.data,
+        discord_sent: success,
+        channel_id: channelId,
+        message,
+        note: note || undefined,
+        sentAt: Date.now(),
+      },
+    };
+  },
+};

package/src/workflows/nodes/actions/file-write.ts

@@ -0,0 +1,73 @@
+import { writeFileSync, appendFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import type { NodeDefinition } from '../registry.ts';
+
+export const fileWriteAction: NodeDefinition = {
+  type: 'action.file_write',
+  label: 'File Write',
+  description: 'Write or append content to a file on disk.',
+  category: 'action',
+  icon: '💾',
+  color: '#3b82f6',
+  configSchema: {
+    path: {
+      type: 'template',
+      label: 'File Path',
+      description: 'Absolute or relative path to the file. Supports template expressions.',
+      required: true,
+      placeholder: '/tmp/output.txt',
+    },
+    content: {
+      type: 'template',
+      label: 'Content',
+      description: 'Content to write. Supports template expressions.',
+      required: true,
+      placeholder: '{{data.result}}',
+    },
+    mode: {
+      type: 'select',
+      label: 'Mode',
+      description: 'Whether to overwrite the file or append to it.',
+      required: true,
+      default: 'write',
+      options: [
+        { label: 'Write (overwrite)', value: 'write' },
+        { label: 'Append', value: 'append' },
+      ],
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const filePath = String(config.path ?? '');
+    if (!filePath) throw new Error('path is required');
+
+    const content = String(config.content ?? '');
+    const mode = String(config.mode ?? 'write');
+
+    ctx.logger.info(`File ${mode}: ${filePath}`);
+
+    // Ensure parent directory exists
+    try {
+      mkdirSync(dirname(filePath), { recursive: true });
+    } catch {
+      // ignore — may already exist
+    }
+
+    if (mode === 'append') {
+      appendFileSync(filePath, content, 'utf8');
+    } else {
+      writeFileSync(filePath, content, 'utf8');
+    }
+
+    return {
+      data: {
+        ...input.data,
+        path: filePath,
+        mode,
+        bytesWritten: Buffer.byteLength(content, 'utf8'),
+        writtenAt: Date.now(),
+      },
+    };
+  },
+};

package/src/workflows/nodes/actions/gmail.ts

@@ -0,0 +1,69 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const gmailAction: NodeDefinition = {
+  type: 'action.gmail',
+  label: 'Send Gmail',
+  description: 'Send an email via Gmail using the Google API integration.',
+  category: 'action',
+  icon: '📨',
+  color: '#3b82f6',
+  configSchema: {
+    to: {
+      type: 'template',
+      label: 'To',
+      description: 'Recipient email address. Supports template expressions.',
+      required: true,
+      placeholder: 'user@example.com',
+    },
+    subject: {
+      type: 'template',
+      label: 'Subject',
+      description: 'Email subject. Supports template expressions.',
+      required: true,
+      placeholder: 'Report from JARVIS',
+    },
+    body: {
+      type: 'template',
+      label: 'Body',
+      description: 'Email body (plain text or HTML). Supports template expressions.',
+      required: true,
+      placeholder: 'Here is your report:\n\n{{data.content}}',
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const to = String(config.to ?? '');
+    const subject = String(config.subject ?? '');
+    const body = String(config.body ?? '');
+
+    ctx.logger.info(`Sending Gmail to ${to}: ${subject}`);
+
+    // Delegate to the send_email tool if registered, otherwise placeholder
+    let success = false;
+    let note = '';
+    if (ctx.toolRegistry.has('send_email')) {
+      try {
+        await ctx.toolRegistry.execute('send_email', { to, subject, body });
+        success = true;
+      } catch (err) {
+        throw new Error(`Gmail send failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else {
+      note = 'Google API integration not configured — email not sent';
+      ctx.logger.warn(note);
+      success = false;
+    }
+
+    return {
+      data: {
+        ...input.data,
+        gmail_sent: success,
+        to,
+        subject,
+        note: note || undefined,
+        sentAt: Date.now(),
+      },
+    };
+  },
+};

package/src/workflows/nodes/actions/http-request.ts

@@ -0,0 +1,117 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const httpRequestAction: NodeDefinition = {
+  type: 'action.http_request',
+  label: 'HTTP Request',
+  description: 'Make an outbound HTTP request and return the response.',
+  category: 'action',
+  icon: '🌐',
+  color: '#3b82f6',
+  configSchema: {
+    url: {
+      type: 'template',
+      label: 'URL',
+      description: 'Target URL. Supports template expressions.',
+      required: true,
+      placeholder: 'https://api.example.com/endpoint',
+    },
+    method: {
+      type: 'select',
+      label: 'Method',
+      description: 'HTTP method.',
+      required: true,
+      default: 'GET',
+      options: [
+        { label: 'GET', value: 'GET' },
+        { label: 'POST', value: 'POST' },
+        { label: 'PUT', value: 'PUT' },
+        { label: 'PATCH', value: 'PATCH' },
+        { label: 'DELETE', value: 'DELETE' },
+      ],
+    },
+    headers: {
+      type: 'json',
+      label: 'Headers',
+      description: 'JSON object of request headers.',
+      required: false,
+      default: {},
+    },
+    body: {
+      type: 'template',
+      label: 'Body',
+      description: 'Request body. Supports template expressions. Leave empty for GET/DELETE.',
+      required: false,
+      placeholder: '{"key": "{{data.value}}"}',
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const url = String(config.url ?? '');
+    if (!url) throw new Error('url is required');
+
+    const method = String(config.method ?? 'GET');
+    const body = config.body ? String(config.body) : undefined;
+
+    // Build headers
+    let headers: Record<string, string> = {};
+    if (config.headers && typeof config.headers === 'object' && !Array.isArray(config.headers)) {
+      headers = Object.fromEntries(
+        Object.entries(config.headers as Record<string, unknown>).map(([k, v]) => [k, String(v)])
+      );
+    } else if (typeof config.headers === 'string' && config.headers) {
+      try {
+        const parsed = JSON.parse(config.headers);
+        headers = Object.fromEntries(
+          Object.entries(parsed as Record<string, unknown>).map(([k, v]) => [k, String(v)])
+        );
+      } catch {
+        ctx.logger.warn('Could not parse headers JSON — using empty headers');
+      }
+    }
+
+    ctx.logger.info(`HTTP ${method} ${url}`);
+
+    const fetchOptions: RequestInit = {
+      method,
+      headers,
+      signal: ctx.abortSignal,
+    };
+
+    if (body && !['GET', 'HEAD', 'DELETE'].includes(method)) {
+      fetchOptions.body = body;
+      if (!headers['Content-Type'] && !headers['content-type']) {
+        (fetchOptions.headers as Record<string, string>)['Content-Type'] = 'application/json';
+      }
+    }
+
+    const response = await fetch(url, fetchOptions);
+    const statusCode = response.status;
+    const responseHeaders: Record<string, string> = {};
+    response.headers.forEach((value, key) => { responseHeaders[key] = value; });
+
+    const responseText = await response.text();
+    let responseBody: unknown = responseText;
+    try {
+      responseBody = JSON.parse(responseText);
+    } catch {
+      // keep as text
+    }
+
+    if (!response.ok) {
+      ctx.logger.warn(`HTTP ${method} ${url} returned ${statusCode}`);
+    }
+
+    return {
+      data: {
+        ...input.data,
+        status: statusCode,
+        ok: response.ok,
+        headers: responseHeaders,
+        body: responseBody,
+        url,
+        method,
+      },
+    };
+  },
+};

package/src/workflows/nodes/actions/notification.ts

@@ -0,0 +1,85 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const notificationAction: NodeDefinition = {
+  type: 'action.notification',
+  label: 'Desktop Notification',
+  description: 'Send a desktop notification via the OS notification system.',
+  category: 'action',
+  icon: '🔔',
+  color: '#3b82f6',
+  configSchema: {
+    title: {
+      type: 'template',
+      label: 'Title',
+      description: 'Notification title. Supports template expressions.',
+      required: true,
+      placeholder: 'JARVIS Alert',
+    },
+    body: {
+      type: 'template',
+      label: 'Body',
+      description: 'Notification body text. Supports template expressions.',
+      required: true,
+      placeholder: 'Something happened: {{data.message}}',
+    },
+    urgency: {
+      type: 'select',
+      label: 'Urgency',
+      description: 'Notification urgency level.',
+      required: true,
+      default: 'normal',
+      options: [
+        { label: 'Low', value: 'low' },
+        { label: 'Normal', value: 'normal' },
+        { label: 'High', value: 'high' },
+      ],
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const title = String(config.title ?? 'JARVIS');
+    const body = String(config.body ?? '');
+    const urgency = String(config.urgency ?? 'normal');
+
+    ctx.logger.info(`Sending notification: [${urgency}] ${title}`);
+
+    // Broadcast to dashboard via WebSocket
+    if (ctx.broadcast) {
+      ctx.broadcast('workflow_message', {
+        channel: 'notification',
+        message: body ? `**${title}**: ${body}` : title,
+        title,
+        body,
+        urgency,
+        executionId: ctx.executionId,
+        workflowId: ctx.workflowId,
+      });
+    }
+
+    // Also try notify-send on Linux/WSLg for desktop notification
+    let sent = false;
+    try {
+      const urgencyFlag = urgency === 'high' ? 'critical' : urgency === 'low' ? 'low' : 'normal';
+      const proc = Bun.spawn(
+        ['notify-send', '-u', urgencyFlag, '--', title, body],
+        { stdout: 'pipe', stderr: 'pipe' }
+      );
+      await proc.exited;
+      sent = proc.exitCode === 0;
+    } catch {
+      // notify-send not available — dashboard broadcast is the primary channel
+    }
+
+    return {
+      data: {
+        ...input.data,
+        notification_sent: sent,
+        title,
+        body,
+        urgency,
+        sentAt: Date.now(),
+      },
+    };
+  },
+};

package/src/workflows/nodes/actions/run-tool.ts

@@ -0,0 +1,55 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const runToolAction: NodeDefinition = {
+  type: 'action.run_tool',
+  label: 'Run Tool',
+  description: 'Execute any registered JARVIS tool by name.',
+  category: 'action',
+  icon: '🔧',
+  color: '#3b82f6',
+  configSchema: {
+    tool_name: {
+      type: 'string',
+      label: 'Tool Name',
+      description: 'Name of the registered tool to execute.',
+      required: true,
+      placeholder: 'web_search',
+    },
+    arguments: {
+      type: 'json',
+      label: 'Arguments',
+      description: 'JSON object of arguments to pass to the tool.',
+      required: false,
+      default: {},
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const toolName = String(config.tool_name ?? '');
+    if (!toolName) throw new Error('tool_name is required');
+
+    // Resolve arguments — they may contain template values already resolved upstream
+    let resolvedArgs: Record<string, unknown> = {};
+    if (config.arguments && typeof config.arguments === 'object' && !Array.isArray(config.arguments)) {
+      resolvedArgs = config.arguments as Record<string, unknown>;
+    } else if (typeof config.arguments === 'string') {
+      try {
+        resolvedArgs = JSON.parse(config.arguments);
+      } catch {
+        throw new Error(`arguments must be a valid JSON object, got: ${config.arguments}`);
+      }
+    }
+
+    ctx.logger.info(`Running tool: ${toolName}`);
+    const result = await ctx.toolRegistry.execute(toolName, resolvedArgs);
+
+    return {
+      data: {
+        ...input.data,
+        tool_name: toolName,
+        tool_result: result,
+      },
+    };
+  },
+};

package/src/workflows/nodes/actions/send-message.ts

@@ -0,0 +1,82 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const sendMessageAction: NodeDefinition = {
+  type: 'action.send_message',
+  label: 'Send Message',
+  description: 'Send a message to a channel: dashboard, Telegram, or Discord.',
+  category: 'action',
+  icon: '💬',
+  color: '#3b82f6',
+  configSchema: {
+    channel: {
+      type: 'select',
+      label: 'Channel',
+      description: 'Destination channel for the message.',
+      required: true,
+      default: 'dashboard',
+      options: [
+        { label: 'Dashboard', value: 'dashboard' },
+        { label: 'Telegram', value: 'telegram' },
+        { label: 'Discord', value: 'discord' },
+      ],
+    },
+    message: {
+      type: 'template',
+      label: 'Message',
+      description: 'Message content. Supports template expressions.',
+      required: true,
+      placeholder: 'Hello from JARVIS! Result: {{data.result}}',
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const channel = String(config.channel ?? 'dashboard');
+    const message = String(config.message ?? '');
+    ctx.logger.info(`Sending message to ${channel}: ${message.slice(0, 100)}`);
+
+    let success = false;
+
+    if (channel === 'dashboard') {
+      // Broadcast directly to connected dashboard clients via WebSocket
+      if (ctx.broadcast) {
+        ctx.broadcast('workflow_message', {
+          channel: 'dashboard',
+          message,
+          executionId: ctx.executionId,
+          workflowId: ctx.workflowId,
+        });
+        success = true;
+      } else {
+        ctx.logger.warn('No broadcast function available — message logged only');
+      }
+    } else {
+      // Route to Telegram/Discord via tool registry
+      const toolName = channel === 'telegram'
+        ? 'send_telegram'
+        : 'send_discord';
+
+      try {
+        if (ctx.toolRegistry.has(toolName)) {
+          await ctx.toolRegistry.execute(toolName, { message });
+          success = true;
+        } else {
+          ctx.logger.warn(`Tool '${toolName}' not available — message logged only`);
+        }
+      } catch (err) {
+        ctx.logger.error(`Failed to send message: ${err instanceof Error ? err.message : String(err)}`);
+        throw err;
+      }
+    }
+
+    return {
+      data: {
+        ...input.data,
+        sent: success,
+        channel,
+        message,
+        sentAt: Date.now(),
+      },
+    };
+  },
+};

package/src/workflows/nodes/actions/shell-command.ts

@@ -0,0 +1,76 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const shellCommandAction: NodeDefinition = {
+  type: 'action.shell_command',
+  label: 'Shell Command',
+  description: 'Execute a shell command and capture its output.',
+  category: 'action',
+  icon: '💻',
+  color: '#3b82f6',
+  configSchema: {
+    command: {
+      type: 'template',
+      label: 'Command',
+      description: 'Shell command to run. Supports template expressions.',
+      required: true,
+      placeholder: 'echo "Hello {{data.name}}"',
+    },
+    timeout_ms: {
+      type: 'number',
+      label: 'Timeout (ms)',
+      description: 'Maximum execution time before the process is killed.',
+      required: false,
+      default: 30000,
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const command = String(config.command ?? '');
+    if (!command) throw new Error('command is required');
+    const timeoutMs = typeof config.timeout_ms === 'number' ? config.timeout_ms : 30000;
+
+    ctx.logger.info(`Shell command: ${command.slice(0, 120)}`);
+
+    // Use Bun.spawn with /bin/sh -c to support full shell syntax
+    const proc = Bun.spawn(['/bin/sh', '-c', command], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+
+    // Race between process exit and timeout (with proper cleanup)
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`Shell command timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+
+    let exitCode: number | null = null;
+    try {
+      exitCode = await Promise.race([proc.exited, timeoutPromise]);
+    } catch (err) {
+      proc.kill();
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+
+    const success = exitCode === 0;
+    if (!success) {
+      ctx.logger.warn(`Shell command exited with code ${exitCode}: ${stderr.slice(0, 200)}`);
+    }
+
+    return {
+      data: {
+        ...input.data,
+        exit_code: exitCode,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        success,
+        command,
+      },
+    };
+  },
+};

package/src/workflows/nodes/actions/telegram.ts

@@ -0,0 +1,60 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const telegramAction: NodeDefinition = {
+  type: 'action.telegram',
+  label: 'Send Telegram Message',
+  description: 'Send a message to a Telegram chat via the Bot API.',
+  category: 'action',
+  icon: '✈️',
+  color: '#3b82f6',
+  configSchema: {
+    chat_id: {
+      type: 'string',
+      label: 'Chat ID',
+      description: 'Telegram chat ID or username to send the message to.',
+      required: true,
+      placeholder: '-1001234567890',
+    },
+    message: {
+      type: 'template',
+      label: 'Message',
+      description: 'Message text. Supports template expressions and Markdown.',
+      required: true,
+      placeholder: 'Alert: {{data.message}}',
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const chatId = String(config.chat_id ?? '');
+    const message = String(config.message ?? '');
+
+    ctx.logger.info(`Sending Telegram message to ${chatId}`);
+
+    // Delegate to telegram tool if registered
+    let success = false;
+    let note = '';
+    if (ctx.toolRegistry.has('send_telegram')) {
+      try {
+        await ctx.toolRegistry.execute('send_telegram', { chat_id: chatId, text: message });
+        success = true;
+      } catch (err) {
+        throw new Error(`Telegram send failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else {
+      note = 'Telegram tool not registered — message not sent';
+      ctx.logger.warn(note);
+    }
+
+    return {
+      data: {
+        ...input.data,
+        telegram_sent: success,
+        chat_id: chatId,
+        message,
+        note: note || undefined,
+        sentAt: Date.now(),
+      },
+    };
+  },
+};