@positronic/cloudflare 0.0.2

package/src/index.ts

@@ -0,0 +1,11 @@
+export {
+  BrainRunnerDO,
+  setBrainRunner,
+  setManifest,
+  getManifest,
+} from './brain-runner-do.js';
+export { MonitorDO } from './monitor-do.js';
+export { ScheduleDO } from './schedule-do.js';
+export { PositronicManifest } from './manifest.js';
+export { default as api } from './api.js';
+export { CloudflareR2Loader } from './r2-loader.js';

package/src/manifest.ts

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,268 @@
+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/node-index.ts

@@ -0,0 +1,15 @@
+/**
+ * Node.js-compatible exports from @positronic/cloudflare
+ * This file is used when importing from Node.js environments (like the CLI)
+ * and excludes any Cloudflare Workers-specific modules.
+ */
+
+// Only export modules that don't depend on cloudflare:workers
+export { PositronicManifest } from './manifest.js';
+export { CloudflareR2Loader } from './r2-loader.js';
+export { CloudflareDevServer } from './dev-server.js';
+// Export with standard name for CLI to use
+export { CloudflareDevServer as DevServer } from './dev-server.js';
+
+// Note: We do NOT export BrainRunnerDO, MonitorDO, or api here
+// because they depend on cloudflare:workers runtime

package/src/r2-loader.ts

@@ -0,0 +1,27 @@
+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();
+  }
+}