opalserve 0.1.0

package/src/utils/config.ts

@@ -0,0 +1,78 @@
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import YAML from 'yaml';
+
+export interface Config {
+  registry: {
+    port: number;
+    host: string;
+    contextTokenBudget: number;
+    maxToolsPerResponse: number;
+  };
+  auth: {
+    enabled: boolean;
+    jwtSecret: string;
+    apiKey?: string;
+  };
+  servers: ServerConfig[];
+}
+
+export interface ServerConfig {
+  id: string;
+  name: string;
+  type: string;
+  enabled: boolean;
+  description: string;
+  endpoint?: string;
+  auth: {
+    type: 'none' | 'api-key' | 'oauth' | 'jwt' | 'basic';
+    envVar?: string;
+  };
+  tags: string[];
+}
+
+export function loadConfig(path?: string): Config {
+  const configPath = path || resolve(process.cwd(), 'config/servers.yaml');
+  
+  if (!existsSync(configPath)) {
+    return getDefaultConfig();
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    const parsed = YAML.parse(content);
+    return {
+      registry: {
+        port: parseInt(process.env.PORT || '3000', 10),
+        host: process.env.HOST || 'localhost',
+        contextTokenBudget: parseInt(process.env.CONTEXT_TOKEN_BUDGET || '128000', 10),
+        maxToolsPerResponse: parseInt(process.env.MAX_TOOLS_PER_RESPONSE || '50', 10),
+      },
+      auth: {
+        enabled: process.env.ENABLE_AUTH === 'true',
+        jwtSecret: process.env.JWT_SECRET || 'dev-secret',
+        apiKey: process.env.API_KEY,
+      },
+      servers: parsed.servers || [],
+    };
+  } catch (error) {
+    console.error('Failed to load config:', error);
+    return getDefaultConfig();
+  }
+}
+
+function getDefaultConfig(): Config {
+  return {
+    registry: {
+      port: 3000,
+      host: 'localhost',
+      contextTokenBudget: 128000,
+      maxToolsPerResponse: 50,
+    },
+    auth: {
+      enabled: false,
+      jwtSecret: 'dev-secret',
+    },
+    servers: [],
+  };
+}

package/src/utils/index.ts

@@ -0,0 +1,47 @@
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+
+export function truncate(str: string, length: number): string {
+  if (str.length <= length) return str;
+  return str.slice(0, length - 3) + '...';
+}
+
+export function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)/g, '');
+}
+
+export function debounce<T extends (...args: unknown[]) => void>(
+  fn: T,
+  delay: number
+): (...args: Parameters<T>) => void {
+  let timeoutId: ReturnType<typeof setTimeout>;
+  return (...args: Parameters<T>) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn(...args), delay);
+  };
+}
+
+export function groupBy<T>(array: T[], key: keyof T): Record<string, T[]> {
+  return array.reduce((result, item) => {
+    const groupKey = String(item[key]);
+    if (!result[groupKey]) {
+      result[groupKey] = [];
+    }
+    result[groupKey].push(item);
+    return result;
+  }, {} as Record<string, T[]>);
+}

package/src/workflow/engine.ts

@@ -0,0 +1,187 @@
+import type { Workflow, Node, Edge, WorkflowExecution, ExecutionLog } from './types.js';
+
+export class WorkflowEngine {
+  private workflows: Map<string, Workflow> = new Map();
+  private executions: Map<string, WorkflowExecution> = new Map();
+
+  registerWorkflow(workflow: Workflow): void {
+    this.validateWorkflow(workflow);
+    this.workflows.set(workflow.id, workflow);
+  }
+
+  getWorkflow(id: string): Workflow | undefined {
+    return this.workflows.get(id);
+  }
+
+  getAllWorkflows(): Workflow[] {
+    return Array.from(this.workflows.values());
+  }
+
+  deleteWorkflow(id: string): boolean {
+    return this.workflows.delete(id);
+  }
+
+  async execute(workflowId: string, input: Record<string, unknown>): Promise<WorkflowExecution> {
+    const workflow = this.workflows.get(workflowId);
+    if (!workflow) {
+      throw new Error(`Workflow ${workflowId} not found`);
+    }
+
+    const executionId = `${workflowId}-${Date.now()}`;
+    const execution: WorkflowExecution = {
+      id: executionId,
+      workflowId,
+      status: 'running',
+      startedAt: new Date().toISOString(),
+      completedAt: null,
+      context: { ...workflow.variables, ...input },
+      logs: [],
+      error: null,
+    };
+
+    this.executions.set(executionId, execution);
+
+    try {
+      const result = await this.executeNodes(workflow, execution);
+      execution.status = 'completed';
+      execution.completedAt = new Date().toISOString();
+      execution.context = { ...execution.context, ...result };
+    } catch (error) {
+      execution.status = 'failed';
+      execution.error = error instanceof Error ? error.message : String(error);
+      execution.completedAt = new Date().toISOString();
+    }
+
+    this.updateWorkflowLastRun(workflowId);
+    return execution;
+  }
+
+  private async executeNodes(workflow: Workflow, execution: WorkflowExecution): Promise<Record<string, unknown>> {
+    const { nodes, edges } = workflow;
+    const startNodes = nodes.filter(n => n.type === 'trigger');
+    const context: Record<string, unknown> = { ...execution.context };
+
+    const visited = new Set<string>();
+    const queue = [...startNodes];
+
+    while (queue.length > 0) {
+      const node = queue.shift()!;
+      if (visited.has(node.id)) continue;
+      visited.add(node.id);
+
+      this.log(execution, node, 'start', 'Executing node');
+
+      try {
+        const result = await this.executeNode(node, context, edges);
+        Object.assign(context, result);
+        this.log(execution, node, 'end', 'Node completed', result);
+
+        const outgoingEdges = edges.filter(e => e.source === node.id);
+        for (const edge of outgoingEdges) {
+          const nextNode = nodes.find(n => n.id === edge.target);
+          if (nextNode && !visited.has(nextNode.id)) {
+            queue.push(nextNode);
+          }
+        }
+      } catch (error) {
+        this.log(execution, node, 'error', String(error));
+        throw error;
+      }
+    }
+
+    return context;
+  }
+
+  private async executeNode(
+    node: Node,
+    context: Record<string, unknown>,
+    _edges: Edge[]
+  ): Promise<Record<string, unknown>> {
+    switch (node.type) {
+      case 'trigger':
+        return { trigger: node.name, timestamp: new Date().toISOString() };
+
+      case 'tool':
+        return { [`tool_${node.id}_result`]: { executed: true, nodeId: node.id } };
+
+      case 'condition':
+        const conditionValue = context[node.config.field as string];
+        const expectedValue = node.config.value;
+        const result = node.config.operator === 'equals' 
+          ? conditionValue === expectedValue
+          : conditionValue !== expectedValue;
+        return { [`condition_${node.id}_result`]: result };
+
+      case 'transform':
+        const input = context[node.config.input as string] as unknown[];
+        if (Array.isArray(input)) {
+          const transformed = input.map((item, index) => ({
+            ...(item as Record<string, unknown>),
+            _index: index,
+            _transformed: true,
+          }));
+          return { [node.config.output as string]: transformed };
+        }
+        return { [node.config.output as string]: input };
+
+      case 'loop':
+        return { loop_count: 0 };
+
+      case 'output':
+        return { output: context };
+
+      default:
+        return {};
+    }
+  }
+
+  private log(execution: WorkflowExecution, node: Node, status: ExecutionLog['status'], message: string, data?: Record<string, unknown>): void {
+    execution.logs.push({
+      timestamp: new Date().toISOString(),
+      nodeId: node.id,
+      nodeName: node.name,
+      status,
+      message,
+      data: data || null,
+    });
+  }
+
+  private validateWorkflow(workflow: Workflow): void {
+    if (workflow.nodes.length === 0) {
+      throw new Error('Workflow must have at least one node');
+    }
+
+    const hasTrigger = workflow.nodes.some(n => n.type === 'trigger');
+    if (!hasTrigger) {
+      throw new Error('Workflow must have at least one trigger node');
+    }
+
+    const nodeIds = new Set(workflow.nodes.map(n => n.id));
+    for (const edge of workflow.edges) {
+      if (!nodeIds.has(edge.source)) {
+        throw new Error(`Edge references non-existent source node: ${edge.source}`);
+      }
+      if (!nodeIds.has(edge.target)) {
+        throw new Error(`Edge references non-existent target node: ${edge.target}`);
+      }
+    }
+  }
+
+  private updateWorkflowLastRun(workflowId: string): void {
+    const workflow = this.workflows.get(workflowId);
+    if (workflow) {
+      workflow.lastRunAt = new Date().toISOString();
+      this.workflows.set(workflowId, workflow);
+    }
+  }
+
+  getExecution(id: string): WorkflowExecution | undefined {
+    return this.executions.get(id);
+  }
+
+  getWorkflowExecutions(workflowId: string): WorkflowExecution[] {
+    return Array.from(this.executions.values())
+      .filter(e => e.workflowId === workflowId)
+      .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+  }
+}

package/src/workflow/index.ts

@@ -0,0 +1,3 @@
+export { WorkflowEngine } from './engine.js';
+export { WORKFLOW_TEMPLATES, createWorkflowFromTemplate } from './templates.js';
+export * from './types.js';

package/src/workflow/templates.ts

@@ -0,0 +1,220 @@
+import type { WorkflowTemplate, Workflow } from './types.js';
+
+export const WORKFLOW_TEMPLATES: WorkflowTemplate[] = [
+  {
+    id: 'github-issue-to-slack',
+    name: 'GitHub Issue → Slack Notification',
+    description: 'When a new GitHub issue is created, notify a Slack channel',
+    category: 'notifications',
+    tags: ['github', 'slack', 'automation'],
+    nodes: [
+      {
+        id: 'trigger-1',
+        type: 'trigger',
+        name: 'GitHub Issue Created',
+        description: 'Triggered when a new issue is created',
+        position: { x: 100, y: 100 },
+        config: { event: 'issues.opened' },
+        inputs: [],
+        outputs: ['issue-data'],
+      },
+      {
+        id: 'tool-1',
+        type: 'tool',
+        name: 'Format Message',
+        description: 'Format the issue as a Slack message',
+        position: { x: 300, y: 100 },
+        toolId: 'custom:custom_transform_data',
+        config: { operation: 'map', expression: 'issue => `New Issue: ${issue.title}\\n${issue.body}`' },
+        inputs: ['issue-data'],
+        outputs: ['formatted-message'],
+      },
+      {
+        id: 'tool-2',
+        type: 'tool',
+        name: 'Post to Slack',
+        description: 'Post the formatted message to Slack',
+        position: { x: 500, y: 100 },
+        toolId: 'slack:slack_post_message',
+        config: { channel: '#engineering', text: '{{formatted-message}}' },
+        inputs: ['formatted-message'],
+        outputs: ['notification-result'],
+      },
+      {
+        id: 'output-1',
+        type: 'output',
+        name: 'Complete',
+        position: { x: 700, y: 100 },
+        config: {},
+        inputs: ['notification-result'],
+        outputs: [],
+      },
+    ],
+    edges: [
+      { id: 'e1', source: 'trigger-1', target: 'tool-1' },
+      { id: 'e2', source: 'tool-1', target: 'tool-2' },
+      { id: 'e3', source: 'tool-2', target: 'output-1' },
+    ],
+    variables: {
+      slack_channel: '#engineering',
+      github_repo: 'owner/repo',
+    },
+  },
+  {
+    id: 'database-report',
+    name: 'Daily Database Report',
+    description: 'Query database and send daily metrics report',
+    category: 'reporting',
+    tags: ['postgres', 'email', 'scheduled'],
+    nodes: [
+      {
+        id: 'trigger-1',
+        type: 'trigger',
+        name: 'Daily Schedule',
+        description: 'Runs daily at 9 AM',
+        position: { x: 100, y: 100 },
+        config: { schedule: '0 9 * * *' },
+        inputs: [],
+        outputs: ['schedule-trigger'],
+      },
+      {
+        id: 'tool-1',
+        type: 'tool',
+        name: 'Query Metrics',
+        description: 'Run database query for metrics',
+        position: { x: 300, y: 100 },
+        toolId: 'postgres:postgres_query',
+        config: { sql: 'SELECT COUNT(*) FROM users' },
+        inputs: [],
+        outputs: ['metrics-data'],
+      },
+      {
+        id: 'tool-2',
+        type: 'tool',
+        name: 'Aggregate Metrics',
+        description: 'Calculate totals and averages',
+        position: { x: 500, y: 100 },
+        toolId: 'custom:custom_aggregate_metrics',
+        config: { metrics: ['count', 'sum', 'avg'] },
+        inputs: ['metrics-data'],
+        outputs: ['aggregated'],
+      },
+      {
+        id: 'tool-3',
+        type: 'tool',
+        name: 'Send Email Report',
+        description: 'Email the report to stakeholders',
+        position: { x: 700, y: 100 },
+        toolId: 'custom:custom_send_email',
+        config: { subject: 'Daily Report' },
+        inputs: ['aggregated'],
+        outputs: ['email-result'],
+      },
+      {
+        id: 'output-1',
+        type: 'output',
+        name: 'Complete',
+        position: { x: 900, y: 100 },
+        config: {},
+        inputs: ['email-result'],
+        outputs: [],
+      },
+    ],
+    edges: [
+      { id: 'e1', source: 'trigger-1', target: 'tool-1' },
+      { id: 'e2', source: 'tool-1', target: 'tool-2' },
+      { id: 'e3', source: 'tool-2', target: 'tool-3' },
+      { id: 'e4', source: 'tool-3', target: 'output-1' },
+    ],
+    variables: {
+      recipients: ['team@example.com'],
+    },
+  },
+  {
+    id: 'file-sync',
+    name: 'Google Drive File Sync',
+    description: 'Monitor a Drive folder and notify on new files',
+    category: 'file-management',
+    tags: ['google-drive', 'slack', 'monitoring'],
+    nodes: [
+      {
+        id: 'trigger-1',
+        type: 'trigger',
+        name: 'Folder Monitor',
+        description: 'Check for new files every hour',
+        position: { x: 100, y: 100 },
+        config: { interval: '1h', folderId: 'root' },
+        inputs: [],
+        outputs: ['folder-state'],
+      },
+      {
+        id: 'tool-1',
+        type: 'tool',
+        name: 'List Files',
+        description: 'List files in monitored folder',
+        position: { x: 300, y: 100 },
+        toolId: 'google-drive:drive_list_files',
+        config: { folderId: '{{folderId}}' },
+        inputs: ['folder-state'],
+        outputs: ['files'],
+      },
+      {
+        id: 'condition-1',
+        type: 'condition',
+        name: 'New Files?',
+        description: 'Check if there are new files',
+        position: { x: 500, y: 100 },
+        config: { field: 'files.length', operator: 'greater_than', value: 0 },
+        inputs: ['files'],
+        outputs: ['has-files'],
+      },
+      {
+        id: 'tool-2',
+        type: 'tool',
+        name: 'Notify New Files',
+        description: 'Post file list to Slack',
+        position: { x: 700, y: 50 },
+        toolId: 'slack:slack_post_message',
+        config: { channel: '#files' },
+        inputs: ['has-files'],
+        outputs: ['notification'],
+      },
+      {
+        id: 'output-1',
+        type: 'output',
+        name: 'End (No Files)',
+        position: { x: 700, y: 150 },
+        config: {},
+        inputs: ['has-files'],
+        outputs: [],
+      },
+    ],
+    edges: [
+      { id: 'e1', source: 'trigger-1', target: 'tool-1' },
+      { id: 'e2', source: 'tool-1', target: 'condition-1' },
+      { id: 'e3', source: 'condition-1', target: 'tool-2', label: 'Yes' },
+      { id: 'e4', source: 'condition-1', target: 'output-1', label: 'No' },
+    ],
+    variables: {
+      folderId: '',
+    },
+  },
+];
+
+export function createWorkflowFromTemplate(template: WorkflowTemplate, overrides?: Partial<Workflow>): Workflow {
+  const now = new Date().toISOString();
+  return {
+    id: `workflow-${Date.now()}`,
+    name: overrides?.name || template.name,
+    description: overrides?.description || template.description,
+    version: '1.0.0',
+    nodes: template.nodes.map(n => ({ ...n })),
+    edges: template.edges.map(e => ({ ...e })),
+    variables: { ...template.variables, ...overrides?.variables },
+    tags: [...template.tags, ...(overrides?.tags || [])],
+    status: 'draft',
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+}

package/src/workflow/types.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+
+export const NodeTypeSchema = z.enum([
+  'trigger',
+  'tool',
+  'condition',
+  'transform',
+  'loop',
+  'output',
+]);
+
+export const NodeSchema = z.object({
+  id: z.string(),
+  type: NodeTypeSchema,
+  name: z.string(),
+  description: z.string().optional(),
+  position: z.object({
+    x: z.number(),
+    y: z.number(),
+  }),
+  config: z.record(z.any()).default({}),
+  toolId: z.string().optional(),
+  inputs: z.array(z.string()).default([]),
+  outputs: z.array(z.string()).default([]),
+});
+
+export type NodeType = z.infer<typeof NodeTypeSchema>;
+export type Node = z.infer<typeof NodeSchema>;
+
+export const EdgeSchema = z.object({
+  id: z.string(),
+  source: z.string(),
+  sourceHandle: z.string().optional(),
+  target: z.string(),
+  targetHandle: z.string().optional(),
+  label: z.string().optional(),
+});
+
+export type Edge = z.infer<typeof EdgeSchema>;
+
+export const WorkflowSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  version: z.string().default('1.0.0'),
+  nodes: z.array(NodeSchema).default([]),
+  edges: z.array(EdgeSchema).default([]),
+  variables: z.record(z.any()).default({}),
+  owner: z.string().optional(),
+  team: z.string().optional(),
+  tags: z.array(z.string()).default([]),
+  status: z.enum(['draft', 'active', 'paused', 'archived']).default('draft'),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  lastRunAt: z.string().optional(),
+});
+
+export type Workflow = z.infer<typeof WorkflowSchema>;
+
+export interface WorkflowExecution {
+  id: string;
+  workflowId: string;
+  status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+  startedAt: string;
+  completedAt: string | null;
+  context: Record<string, unknown>;
+  logs: ExecutionLog[];
+  error: string | null;
+}
+
+export interface ExecutionLog {
+  timestamp: string;
+  nodeId: string;
+  nodeName: string;
+  status: 'start' | 'end' | 'error' | 'info';
+  message: string;
+  data: Record<string, unknown> | null;
+}
+
+export interface WorkflowTemplate {
+  id: string;
+  name: string;
+  description: string;
+  category: string;
+  nodes: Node[];
+  edges: Edge[];
+  variables: Record<string, unknown>;
+  tags: string[];
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}