@plures/runebook 0.4.0

package/src/lib/components/TransformNode.svelte

@@ -0,0 +1,327 @@
+<script lang="ts">
+  import type { TransformNode } from '../types/canvas';
+  import { canvasStore, nodeDataStore, getNodeInputData, updateNodeData } from '../stores/canvas';
+  import Box from '../design-dojo/Box.svelte';
+  import Select from '../design-dojo/Select.svelte';
+  import Text from '../design-dojo/Text.svelte';
+
+  interface Props {
+    node: TransformNode;
+    tui?: boolean;
+  }
+
+  let { node, tui = false }: Props = $props();
+
+  let output = $state<any>('');
+  let error = $state<string>('');
+  let isProcessing = $state(false);
+
+  // Subscribe to node data changes and apply transformation
+  $effect(() => {
+    const canvas = $canvasStore;
+    const nodeData = $nodeDataStore;
+    
+    // Get input data from connected nodes
+    if (node.inputs && node.inputs.length > 0) {
+      const inputData = getNodeInputData(node.id, node.inputs[0].id, canvas.connections, nodeData);
+      if (inputData !== undefined) {
+        applyTransform(inputData);
+      }
+    }
+  });
+
+  async function applyTransform(inputData: any) {
+    if (!node.code.trim()) {
+      output = inputData;
+      updateNodeData(node.id, 'output', inputData);
+      return;
+    }
+
+    isProcessing = true;
+    error = '';
+
+    try {
+      let result: any;
+
+      switch (node.transformType) {
+        case 'map':
+          // Execute JavaScript map function
+          if (Array.isArray(inputData)) {
+            // Note: Using Function constructor allows user-defined transformations
+            // This is intended for local use only. Do not use with untrusted input.
+            const mapFn = new Function('item', 'index', `"use strict"; return (${node.code})`);
+            result = inputData.map((item, index) => mapFn(item, index));
+          } else {
+            error = 'Map transform requires array input';
+            return;
+          }
+          break;
+
+        case 'filter':
+          // Execute JavaScript filter function
+          if (Array.isArray(inputData)) {
+            const filterFn = new Function('item', 'index', `"use strict"; return (${node.code})`);
+            result = inputData.filter((item, index) => filterFn(item, index));
+          } else {
+            error = 'Filter transform requires array input';
+            return;
+          }
+          break;
+
+        case 'reduce':
+          // Execute JavaScript reduce function
+          if (Array.isArray(inputData)) {
+            if (inputData.length === 0) {
+              error = 'Reduce transform requires non-empty array';
+              return;
+            }
+            const reduceFn = new Function('acc', 'item', 'index', `"use strict"; return (${node.code})`);
+            // Provide initial value of 0 for safety
+            result = inputData.reduce((acc, item, index) => reduceFn(acc, item, index), 0);
+          } else {
+            error = 'Reduce transform requires array input';
+            return;
+          }
+          break;
+
+        case 'sudolang':
+          // Sudolang is not implemented yet - just pass through
+          result = inputData;
+          error = 'Sudolang transform not yet implemented - passing through data';
+          break;
+
+        default:
+          result = inputData;
+      }
+
+      output = result;
+      updateNodeData(node.id, 'output', result);
+    } catch (e) {
+      error = e instanceof Error ? e.message : String(e);
+      output = '';
+    } finally {
+      isProcessing = false;
+    }
+  }
+
+  function updateCode(event: Event) {
+    const target = event.target as HTMLTextAreaElement;
+    canvasStore.updateNode(node.id, { code: target.value });
+  }
+
+  function updateTransformType(event: Event) {
+    const target = event.target as HTMLSelectElement;
+    const newType = target.value as TransformNode['transformType'];
+    canvasStore.updateNode(node.id, { transformType: newType });
+  }
+
+  function getPlaceholder(type: TransformNode['transformType']): string {
+    switch (type) {
+      case 'map':
+        return 'item * 2';
+      case 'filter':
+        return 'item > 10';
+      case 'reduce':
+        return 'acc + item';
+      case 'sudolang':
+        return '// Sudolang code';
+      default:
+        return '';
+    }
+  }
+</script>
+
+<Box class="transform-node" surface={2} border radius={3} shadow={2} style="border-color: var(--accent)" {tui}>
+  <Box class="node-header" surface={3} {tui}>
+    <span class="node-icon">🔄</span>
+    <Text class="node-title">{node.label || 'Transform'}</Text>
+  </Box>
+  
+  <Box class="node-body" pad={3}>
+    <div class="control-group">
+      <label for="transform-type-{node.id}">Type:</label>
+      <Select
+        {tui}
+        id="transform-type-{node.id}"
+        value={node.transformType}
+        onchange={updateTransformType}
+      >
+        <option value="map">Map</option>
+        <option value="filter">Filter</option>
+        <option value="reduce">Reduce</option>
+        <option value="sudolang">Sudolang (planned)</option>
+      </Select>
+    </div>
+
+    <div class="control-group">
+      <label for="code-{node.id}">Code:</label>
+      <textarea
+        id="code-{node.id}"
+        value={node.code}
+        oninput={updateCode}
+        placeholder={getPlaceholder(node.transformType)}
+        rows="4"
+        class="code-textarea"
+      ></textarea>
+    </div>
+
+    {#if error}
+      <Box class="error-message" surface={1} pad={2} radius={2}>
+        <Text class="error-text">{error}</Text>
+      </Box>
+    {/if}
+
+    {#if isProcessing}
+      <Box class="status-processing" surface={1} pad={2} radius={2}>
+        <Text variant={2}>Processing...</Text>
+      </Box>
+    {:else if output !== ''}
+      <Box class="output-preview" surface={1} pad={2} radius={2}>
+        <Text class="output-label">Output:</Text>
+        <Text mono variant={1} class="output-pre">{typeof output === 'object' ? JSON.stringify(output, null, 2) : String(output)}</Text>
+      </Box>
+    {/if}
+  </Box>
+  
+  <!-- Input and output ports -->
+  <div class="ports">
+    {#each node.inputs as port}
+      <div class="port input-port" data-port-id={port.id}>
+        <span class="port-label">{port.name}</span>
+      </div>
+    {/each}
+    
+    {#each node.outputs as port}
+      <div class="port output-port" data-port-id={port.id}>
+        <span class="port-label">{port.name}</span>
+      </div>
+    {/each}
+  </div>
+</Box>
+
+<style>
+  :global(.transform-node) {
+    min-width: 320px;
+    max-width: 450px;
+  }
+
+  :global(.transform-node .node-header) {
+    padding: var(--space-2) var(--space-3);
+    border-bottom: 1px solid var(--border-color);
+    display: flex;
+    align-items: center;
+    gap: var(--space-2);
+    border-radius: var(--radius-3) var(--radius-3) 0 0;
+  }
+
+  .node-icon {
+    font-size: 18px;
+  }
+
+  :global(.transform-node .node-title) {
+    font-weight: 600;
+    font-size: var(--font-size-1);
+  }
+
+  :global(.transform-node .node-body) {
+    padding: var(--space-3);
+  }
+
+  .control-group {
+    margin-bottom: var(--space-3);
+  }
+
+  label {
+    display: block;
+    margin-bottom: var(--space-1);
+    font-size: var(--font-size-0);
+    color: var(--text-2);
+  }
+
+  .code-textarea {
+    width: 100%;
+    padding: var(--space-2);
+    background: var(--surface-1);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-2);
+    color: var(--text-1);
+    font-family: var(--font-mono);
+    font-size: var(--font-size-0);
+    resize: vertical;
+    box-sizing: border-box;
+  }
+
+  .code-textarea::placeholder {
+    color: var(--text-3);
+  }
+
+  .code-textarea:focus {
+    outline: none;
+    border-color: var(--brand);
+  }
+
+  :global(.transform-node .error-message) {
+    margin-top: var(--space-2);
+    border: 1px solid var(--error);
+  }
+
+  :global(.transform-node .error-text) {
+    font-size: var(--font-size-0);
+    color: var(--error);
+  }
+
+  :global(.transform-node .status-processing) {
+    margin-top: var(--space-2);
+  }
+
+  :global(.transform-node .output-preview) {
+    margin-top: var(--space-2);
+    max-height: 150px;
+    overflow-y: auto;
+  }
+
+  :global(.transform-node .output-label) {
+    display: block;
+    margin-bottom: var(--space-1);
+    font-size: var(--font-size-0);
+    font-weight: 600;
+    color: var(--brand);
+  }
+
+  :global(.transform-node .output-pre) {
+    display: block;
+    font-size: var(--font-size-0);
+    white-space: pre-wrap;
+    word-break: break-word;
+  }
+
+  .ports {
+    position: relative;
+  }
+
+  .port {
+    position: absolute;
+    width: 12px;
+    height: 12px;
+    background: var(--brand);
+    border: 2px solid var(--surface-2);
+    border-radius: 50%;
+    cursor: crosshair;
+  }
+
+  .input-port {
+    left: -8px;
+    top: 50%;
+    transform: translateY(-50%);
+  }
+
+  .output-port {
+    right: -8px;
+    top: 50%;
+    transform: translateY(-50%);
+  }
+
+  .port-label {
+    display: none;
+  }
+</style>

package/src/lib/core/index.ts

@@ -0,0 +1,31 @@
+// RuneBook Core - Terminal Observer Module
+// Main entry point for event capture and observability
+
+export { TerminalObserver, createObserver, defaultObserverConfig } from './observer';
+export type { ObserverConfig } from './types';
+export type { TerminalObserverEvent, EventType, ShellType } from './types';
+export { createEventStore } from './storage';
+export type { EventStore } from './storage';
+export { createShellAdapter, detectShellType } from './shell-adapters';
+export type { ShellAdapter } from './shell-adapters';
+export {
+  sanitizeEnv,
+  redactSecretsFromText,
+  isSecretKey,
+  redactValue,
+  validateRedaction,
+} from './redaction';
+
+// Re-export types for convenience
+export type {
+  CommandStartEvent,
+  CommandEndEvent,
+  StdoutChunkEvent,
+  StderrChunkEvent,
+  ExitStatusEvent,
+  CwdChangeEvent,
+  EnvChangeEvent,
+  SessionStartEvent,
+  SessionEndEvent,
+} from './types';
+

package/src/lib/core/observer.ts

@@ -0,0 +1,278 @@
+// Terminal Observer - Main coordinator for event capture
+// Orchestrates shell adapters, event storage, and configuration
+
+import { createShellAdapter, detectShellType } from './shell-adapters';
+import { createEventStore } from './storage';
+import type {
+  ObserverConfig,
+  TerminalObserverEvent,
+  EventType,
+  ShellType,
+} from './types';
+import type { ShellAdapter } from './shell-adapters';
+import type { EventStore } from './storage';
+
+// Re-export ObserverConfig for convenience
+export type { ObserverConfig } from './types';
+
+export class TerminalObserver {
+  private config: ObserverConfig;
+  private adapter: ShellAdapter | null = null;
+  private store: EventStore | null = null;
+  private sessionId: string;
+
+  constructor(config: Partial<ObserverConfig> = {}) {
+    this.sessionId = config.sessionId || `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    
+    this.config = {
+      enabled: false, // Opt-in by default
+      redactSecrets: true,
+      usePluresDB: false,
+      chunkSize: 4096,
+      maxEvents: 10000,
+      retentionDays: 30,
+      ...config,
+      sessionId: this.sessionId,
+      shellType: config.shellType || detectShellType(),
+    };
+  }
+
+  /**
+   * Initialize the observer with storage and shell adapter
+   */
+  async initialize(): Promise<void> {
+    if (!this.config.enabled) {
+      return;
+    }
+
+    // Create event store
+    this.store = createEventStore(this.config);
+
+    // Create shell adapter
+    this.adapter = createShellAdapter(this.config.shellType);
+
+    // Initialize adapter
+    await this.adapter.initialize(this.config, this.store);
+  }
+
+  /**
+   * Start capturing events
+   */
+  async start(): Promise<void> {
+    if (!this.config.enabled) {
+      throw new Error('Observer is not enabled. Set enabled: true in config.');
+    }
+
+    if (!this.adapter || !this.store) {
+      await this.initialize();
+    }
+
+    if (this.adapter) {
+      await this.adapter.start();
+    }
+  }
+
+  /**
+   * Stop capturing events
+   */
+  async stop(): Promise<void> {
+    if (this.adapter) {
+      await this.adapter.stop();
+    }
+  }
+
+  /**
+   * Check if observer is active
+   */
+  isActive(): boolean {
+    return this.adapter?.isActive() || false;
+  }
+
+  /**
+   * Get the shell hook script for manual integration
+   */
+  getHookScript(): string {
+    if (!this.adapter) {
+      this.adapter = createShellAdapter(this.config.shellType);
+    }
+    return this.adapter.getHookScript();
+  }
+
+  /**
+   * Programmatically capture a command execution
+   * Useful when shell hooks are not available
+   */
+  async captureCommand(
+    command: string,
+    args: string[],
+    cwd: string,
+    env: Record<string, string>
+  ): Promise<string> {
+    if (!this.config.enabled || !this.adapter || !this.store) {
+      throw new Error('Observer not initialized or not enabled');
+    }
+
+    // Use adapter's programmatic capture
+    const { BashAdapter } = await import('./shell-adapters/bash.js');
+    const { ZshAdapter } = await import('./shell-adapters/zsh.js');
+    
+    if (this.adapter instanceof BashAdapter) {
+      return await (this.adapter as any).captureCommand(command, args, cwd, env);
+    }
+    
+    if (this.adapter instanceof ZshAdapter) {
+      return await (this.adapter as any).captureCommand(command, args, cwd, env);
+    }
+
+    throw new Error('Programmatic capture not supported for this shell adapter');
+  }
+
+  /**
+   * Programmatically capture command result
+   */
+  async captureCommandResult(
+    commandId: string,
+    stdout: string,
+    stderr: string,
+    exitCode: number
+  ): Promise<void> {
+    if (!this.config.enabled || !this.adapter || !this.store) {
+      return;
+    }
+
+    const { BashAdapter } = await import('./shell-adapters/bash.js');
+    const { ZshAdapter } = await import('./shell-adapters/zsh.js');
+    
+    if (this.adapter instanceof BashAdapter) {
+      await (this.adapter as any).captureCommandResult(commandId, stdout, stderr, exitCode);
+      return;
+    }
+    
+    if (this.adapter instanceof ZshAdapter) {
+      await (this.adapter as any).captureCommandResult(commandId, stdout, stderr, exitCode);
+      return;
+    }
+  }
+
+  /**
+   * Get events from storage
+   */
+  async getEvents(
+    type?: EventType,
+    since?: number,
+    limit?: number
+  ): Promise<TerminalObserverEvent[]> {
+    if (!this.store) {
+      await this.initialize();
+    }
+    
+    if (!this.store) {
+      return [];
+    }
+
+    return await this.store.getEvents(type, since, limit);
+  }
+
+  /**
+   * Get events for a specific command
+   */
+  async getEventsByCommand(commandId: string): Promise<TerminalObserverEvent[]> {
+    if (!this.store) {
+      await this.initialize();
+    }
+    
+    if (!this.store) {
+      return [];
+    }
+
+    return await this.store.getEventsByCommand(commandId);
+  }
+
+  /**
+   * Get events for current session
+   */
+  async getEventsBySession(limit?: number): Promise<TerminalObserverEvent[]> {
+    if (!this.store) {
+      await this.initialize();
+    }
+    
+    if (!this.store) {
+      return [];
+    }
+
+    return await this.store.getEventsBySession(this.sessionId, limit);
+  }
+
+  /**
+   * Get storage statistics
+   */
+  async getStats() {
+    if (!this.store) {
+      await this.initialize();
+    }
+    
+    if (!this.store) {
+      return {
+        totalEvents: 0,
+        eventsByType: {},
+        sessions: 0,
+      };
+    }
+
+    return await this.store.getStats();
+  }
+
+  /**
+   * Clear old events
+   */
+  async clearEvents(days?: number): Promise<void> {
+    if (!this.store) {
+      await this.initialize();
+    }
+    
+    if (!this.store) {
+      return;
+    }
+
+    const olderThan = days
+      ? Date.now() - (days * 24 * 60 * 60 * 1000)
+      : undefined;
+
+    await this.store.clearEvents(olderThan);
+  }
+
+  /**
+   * Update configuration
+   */
+  updateConfig(updates: Partial<ObserverConfig>): void {
+    this.config = { ...this.config, ...updates };
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): ObserverConfig {
+    return { ...this.config };
+  }
+}
+
+/**
+ * Create a terminal observer instance
+ */
+export function createObserver(config: Partial<ObserverConfig> = {}): TerminalObserver {
+  return new TerminalObserver(config);
+}
+
+/**
+ * Default observer configuration
+ */
+export const defaultObserverConfig: ObserverConfig = {
+  enabled: false,
+  redactSecrets: true,
+  usePluresDB: false,
+  chunkSize: 4096,
+  maxEvents: 10000,
+  retentionDays: 30,
+  shellType: detectShellType(),
+};
+