@positronic/cloudflare 0.0.2 → 0.0.4

package/src/manifest.ts

@@ -1,69 +0,0 @@
-import type { Brain } from '@positronic/core';
-
-interface BrainImportStrategy {
-  import(name: string): Promise<Brain | undefined>;
-  list(): string[];
-}
-
-class StaticManifestStrategy implements BrainImportStrategy {
-  constructor(private manifest: Record<string, Brain>) {}
-
-  async import(name: string): Promise<Brain | undefined> {
-    return this.manifest[name];
-  }
-
-  list(): string[] {
-    return Object.keys(this.manifest);
-  }
-}
-
-class DynamicImportStrategy implements BrainImportStrategy {
-  constructor(private brainsDir: string) {}
-
-  async import(name: string): Promise<Brain | undefined> {
-    try {
-      const module = await import(`${this.brainsDir}/${name}.ts`);
-      return module.default;
-    } catch (e) {
-      console.error(`Failed to import brain ${name}:`, e);
-      return undefined;
-    }
-  }
-
-  list(): string[] {
-    // For dynamic imports, we can't easily list files at runtime in a worker environment
-    // This would need to be handled differently, perhaps by generating a list at build time
-    console.warn('DynamicImportStrategy.list() is not implemented - returning empty array');
-    return [];
-  }
-}
-
-export class PositronicManifest {
-  private importStrategy: BrainImportStrategy;
-
-  constructor(options: {
-    staticManifest?: Record<string, Brain>;
-    brainsDir?: string;
-  }) {
-    if (options.staticManifest && options.brainsDir) {
-      throw new Error(
-        'Cannot provide both staticManifest and brainsDir - choose one import strategy'
-      );
-    }
-    if (!options.staticManifest && !options.brainsDir) {
-      throw new Error('Must provide either staticManifest or brainsDir');
-    }
-
-    this.importStrategy = options.staticManifest
-      ? new StaticManifestStrategy(options.staticManifest)
-      : new DynamicImportStrategy(options.brainsDir!);
-  }
-
-  async import(name: string): Promise<Brain | undefined> {
-    return this.importStrategy.import(name);
-  }
-
-  list(): string[] {
-    return this.importStrategy.list();
-  }
-}

package/src/monitor-do.ts

@@ -1,268 +0,0 @@
-import { DurableObject } from 'cloudflare:workers';
-import { BRAIN_EVENTS, STATUS } from '@positronic/core';
-import type { BrainEvent } from '@positronic/core';
-
-export interface Env {
-  // Add any environment bindings here as needed
-}
-
-export class MonitorDO extends DurableObject<Env> {
-  private readonly storage: SqlStorage;
-  private eventStreamHandler = new EventStreamHandler();
-
-  constructor(state: DurableObjectState, env: Env) {
-    super(state, env);
-    this.storage = state.storage.sql;
-
-    // Update table schema and indexes
-    this.storage.exec(`
-      CREATE TABLE IF NOT EXISTS brain_runs (
-        run_id TEXT PRIMARY KEY,
-        brain_title TEXT NOT NULL, -- Renamed column
-        brain_description TEXT, -- Renamed column
-        type TEXT NOT NULL,
-        status TEXT NOT NULL,
-        options TEXT,
-        error TEXT,
-        created_at INTEGER NOT NULL,
-        started_at INTEGER,
-        completed_at INTEGER
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_brain_status -- Renamed index
-      ON brain_runs(brain_title, status);
-
-      CREATE INDEX IF NOT EXISTS idx_brain_time -- Renamed index
-      ON brain_runs(created_at DESC);
-    `);
-  }
-
-  handleBrainEvent(event: BrainEvent<any>) {
-    if (
-      event.type === BRAIN_EVENTS.START ||
-      event.type === BRAIN_EVENTS.RESTART ||
-      event.type === BRAIN_EVENTS.COMPLETE ||
-      event.type === BRAIN_EVENTS.ERROR
-    ) {
-      const currentTime = Date.now();
-      const startTime =
-        event.type === BRAIN_EVENTS.START || event.type === BRAIN_EVENTS.RESTART
-          ? currentTime
-          : null;
-      const completeTime =
-        event.type === BRAIN_EVENTS.COMPLETE ||
-        event.type === BRAIN_EVENTS.ERROR
-          ? currentTime
-          : null;
-      const error =
-        event.type === BRAIN_EVENTS.ERROR ? JSON.stringify(event.error) : null;
-
-      // Update SQL insert/update with new column names, read from existing event fields
-      this.storage.exec(
-        `
-        INSERT INTO brain_runs (
-          run_id, brain_title, brain_description, type, status,
-          options, error, created_at, started_at, completed_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT(run_id) DO UPDATE SET
-          type = excluded.type,
-          status = excluded.status,
-          error = excluded.error,
-          completed_at = excluded.completed_at
-      `,
-        event.brainRunId, // Use brainRunId for run_id
-        event.brainTitle, // Read from event field, store in brain_title
-        event.brainDescription || null, // Read from event field, store in brain_description
-        event.type,
-        event.status,
-        JSON.stringify(event.options || {}),
-        error,
-        currentTime,
-        startTime,
-        completeTime
-      );
-
-      this.broadcastRunningBrains();
-    }
-  }
-
-  private async broadcastRunningBrains() {
-    const runningBrains = await this.storage
-      .exec(
-        `
-      SELECT
-        run_id as brainRunId,
-        brain_title as brainTitle,
-        brain_description as brainDescription,
-        type,
-        status,
-        options,
-        error,
-        created_at as createdAt,
-        started_at as startedAt,
-        completed_at as completedAt
-      FROM brain_runs
-      WHERE status = ?
-      ORDER BY created_at DESC
-    `,
-        STATUS.RUNNING
-      )
-      .toArray();
-
-    this.eventStreamHandler.broadcast({ runningBrains });
-  }
-
-  async fetch(request: Request) {
-    const url = new URL(request.url);
-    const encoder = new TextEncoder();
-
-    if (url.pathname === '/watch') {
-      const stream = new ReadableStream({
-        start: async (controller) => {
-          try {
-            const runningBrains = await this.storage
-              .exec(
-                `
-              SELECT
-                run_id as brainRunId,
-                brain_title as brainTitle,
-                brain_description as brainDescription,
-                type,
-                status,
-                options,
-                error,
-                created_at as createdAt,
-                started_at as startedAt,
-                completed_at as completedAt
-              FROM brain_runs
-              WHERE status = ?
-              ORDER BY created_at DESC
-            `,
-                STATUS.RUNNING
-              )
-              .toArray();
-
-            controller.enqueue(
-              encoder.encode(`data: ${JSON.stringify({ runningBrains })}\n\n`)
-            );
-
-            this.eventStreamHandler.subscribe(controller);
-          } catch (err) {
-            console.error('[MONITOR_DO] Error during stream start:', err);
-            controller.close();
-            this.eventStreamHandler.unsubscribe(controller);
-          }
-        },
-        cancel: (controller) => {
-          this.eventStreamHandler.unsubscribe(controller);
-        },
-      });
-
-      return new Response(stream, {
-        headers: {
-          'Content-Type': 'text/event-stream',
-          'Cache-Control': 'no-cache',
-          Connection: 'keep-alive',
-        },
-      });
-    }
-
-    return new Response('Not found', { status: 404 });
-  }
-
-  // No changes needed for getLastEvent, uses run_id
-  getLastEvent(brainRunId: string) {
-    return this.storage
-      .exec(
-        `
-      SELECT * FROM brain_runs WHERE run_id = ?
-    `,
-        brainRunId
-      )
-      .one();
-  }
-
-  // Update history method parameter and query
-  history(brainTitle: string, limit: number = 10) {
-    // Renamed parameter
-    // Update select query with aliases and filter by brain_title
-    return this.storage
-      .exec(
-        `
-      SELECT
-        run_id as brainRunId,
-        brain_title as brainTitle,
-        brain_description as brainDescription,
-        type,
-        status,
-        options,
-        error,
-        created_at as createdAt,
-        started_at as startedAt,
-        completed_at as completedAt
-      FROM brain_runs
-      WHERE brain_title = ? -- Filter by new column name
-      ORDER BY created_at DESC
-      LIMIT ?
-    `,
-        brainTitle,
-        limit
-      )
-      .toArray(); // Use renamed parameter
-  }
-
-  // Get active/running brain runs for a specific brain
-  activeRuns(brainTitle: string) {
-    return this.storage
-      .exec(
-        `
-      SELECT
-        run_id as brainRunId,
-        brain_title as brainTitle,
-        brain_description as brainDescription,
-        type,
-        status,
-        options,
-        error,
-        created_at as createdAt,
-        started_at as startedAt,
-        completed_at as completedAt
-      FROM brain_runs
-      WHERE brain_title = ? AND status = ?
-      ORDER BY created_at DESC
-    `,
-        brainTitle,
-        STATUS.RUNNING
-      )
-      .toArray();
-  }
-}
-
-class EventStreamHandler {
-  private subscribers: Set<ReadableStreamDefaultController> = new Set();
-  private encoder = new TextEncoder();
-
-  subscribe(controller: ReadableStreamDefaultController) {
-    this.subscribers.add(controller);
-  }
-
-  unsubscribe(controller: ReadableStreamDefaultController) {
-    this.subscribers.delete(controller);
-  }
-
-  broadcast(data: any) {
-    const message = `data: ${JSON.stringify(data)}\n\n`;
-    const encodedMessage = this.encoder.encode(message);
-    this.subscribers.forEach((controller) => {
-      try {
-        controller.enqueue(encodedMessage);
-      } catch (e) {
-        console.error(
-          '[MONITOR_DO_SSE] Failed to send message to subscriber, removing.',
-          e
-        );
-        this.unsubscribe(controller);
-      }
-    });
-  }
-}

package/src/r2-loader.ts

@@ -1,27 +0,0 @@
-import type { R2Bucket } from '@cloudflare/workers-types';
-import type { ResourceLoader } from '@positronic/core';
-import { Buffer } from 'buffer';
-
-export class CloudflareR2Loader implements ResourceLoader {
-  constructor(private bucket: R2Bucket) {}
-
-  async load(resourceName: string, type: 'text'): Promise<string>;
-  async load(resourceName: string, type: 'binary'): Promise<Buffer>;
-  async load(
-    resourceName: string,
-    type: 'text' | 'binary' = 'text'
-  ): Promise<string | Buffer> {
-    const object = await this.bucket.get(resourceName);
-
-    if (object === null) {
-      throw new Error(`Resource "${resourceName}" not found in R2 bucket.`);
-    }
-
-    if (type === 'binary') {
-      const arrayBuffer = await object.arrayBuffer();
-      return Buffer.from(arrayBuffer);
-    }
-    // Defaults to text
-    return object.text();
-  }
-}