agent-canvas 0.1.44 → 0.2.0

package/daemon/src/websocket.test.ts

@@ -1,99 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { SessionManager } from "./session";
-import { createWebSocketManager, type CanvasSocket, type WSData } from "./websocket";
-
-const testDirectories: string[] = [];
-
-afterEach(() => {
-  for (const directory of testDirectories.splice(0)) {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-class FakeSocket implements CanvasSocket {
-  readonly sent: string[] = [];
-  closed = false;
-
-  constructor(readonly data: WSData) {}
-
-  send(message: string) {
-    this.sent.push(message);
-  }
-
-  close() {
-    this.closed = true;
-  }
-
-  ping() {}
-}
-
-function createSessionManager(): SessionManager {
-  const directory = mkdtempSync(join(tmpdir(), "agent-canvas-websocket-test-"));
-  testDirectories.push(directory);
-  const manager = new SessionManager(directory);
-  manager.upsert(
-    "session",
-    new Map([["architecture.jsx", "<Section title=\"Architecture\" />"]]),
-    directory,
-  );
-  return manager;
-}
-
-describe("canvas render errors", () => {
-  test("delivers an error that arrived before the CLI watcher connected", () => {
-    const sessionManager = createSessionManager();
-    const websocket = createWebSocketManager(sessionManager);
-    const browser = new FakeSocket({ type: "browser", sessionId: "session" });
-    websocket.handlers.open(browser);
-
-    websocket.handlers.message(browser, JSON.stringify({
-      type: "render-error",
-      error: {
-        revision: 1,
-        filename: "architecture.jsx",
-        message: "Cannot read properties of undefined (reading 'map')",
-      },
-    }));
-
-    const watcher = new FakeSocket({ type: "wait", sessionId: "session" });
-    websocket.handlers.open(watcher);
-
-    expect(watcher.sent).toHaveLength(1);
-    expect(JSON.parse(watcher.sent[0])).toEqual({
-      type: "render-error",
-      error: {
-        revision: 1,
-        filename: "architecture.jsx",
-        message: "Cannot read properties of undefined (reading 'map')",
-      },
-    });
-    expect(watcher.closed).toBe(true);
-    expect(sessionManager.get("session")?.revisions[0].hasFeedback).toBe(false);
-  });
-
-  test("drops a pending error when a new revision is pushed", () => {
-    const sessionManager = createSessionManager();
-    const websocket = createWebSocketManager(sessionManager);
-    const browser = new FakeSocket({ type: "browser", sessionId: "session" });
-    websocket.handlers.open(browser);
-    websocket.handlers.message(browser, JSON.stringify({
-      type: "render-error",
-      error: { revision: 1, filename: "architecture.jsx", message: "Broken revision" },
-    }));
-
-    sessionManager.upsert(
-      "session",
-      new Map([["architecture.jsx", "<Section title=\"Fixed\" />"]]),
-      "/project",
-    );
-    websocket.broadcastPlanUpdate("session");
-
-    const watcher = new FakeSocket({ type: "wait", sessionId: "session" });
-    websocket.handlers.open(watcher);
-    expect(watcher.sent).toEqual([]);
-    expect(watcher.closed).toBe(false);
-  });
-});

package/daemon/src/websocket.ts

@@ -1,211 +0,0 @@
-import type { SessionManager, RemoteFeedbackEntry } from "./session";
-
-export type WSData = { type: "browser" | "wait"; sessionId: string };
-
-export interface CanvasSocket {
-  data: WSData;
-  send(message: string): unknown;
-  close(): void;
-  ping(): unknown;
-}
-
-interface CanvasRenderError {
-  revision: number;
-  filename: string;
-  message: string;
-  stack?: string;
-  componentStack?: string;
-}
-
-function isCanvasRenderError(value: unknown): value is CanvasRenderError {
-  return typeof value === "object" && value !== null
-    && "revision" in value && Number.isInteger(value.revision)
-    && "filename" in value && typeof value.filename === "string"
-    && "message" in value && typeof value.message === "string"
-    && (!("stack" in value) || value.stack === undefined || typeof value.stack === "string")
-    && (!("componentStack" in value) || value.componentStack === undefined || typeof value.componentStack === "string");
-}
-
-export function createWebSocketManager(sessionManager: SessionManager) {
-  const browserSockets = new Map<string, Set<CanvasSocket>>();
-  const waitSockets = new Map<string, Set<CanvasSocket>>();
-  const pendingRenderErrors = new Map<string, CanvasRenderError>();
-
-  function broadcastPlanUpdate(sessionId: string) {
-    pendingRenderErrors.delete(sessionId);
-    const sockets = browserSockets.get(sessionId);
-    if (!sockets) return;
-    const session = sessionManager.get(sessionId);
-    if (!session) return;
-    const payload = JSON.stringify({
-      type: "plan-updated",
-      currentRevision: session.currentRevision,
-      revisions: session.revisions,
-    });
-    for (const ws of sockets) {
-      ws.send(payload);
-    }
-  }
-
-  function broadcastRevisionUpdate(sessionId: string) {
-    const sockets = browserSockets.get(sessionId);
-    if (!sockets) return;
-    const session = sessionManager.get(sessionId);
-    if (!session) return;
-    const payload = JSON.stringify({
-      type: "revision-updated",
-      revisions: session.revisions,
-    });
-    for (const ws of sockets) {
-      ws.send(payload);
-    }
-  }
-
-  function broadcastRemoteFeedback(sessionId: string, revision: number, entries: RemoteFeedbackEntry[]) {
-    const sockets = browserSockets.get(sessionId);
-    if (!sockets || sockets.size === 0) return;
-    const payload = JSON.stringify({
-      type: "remote-feedback",
-      revision,
-      entries,
-    });
-    for (const ws of sockets) {
-      ws.send(payload);
-    }
-  }
-
-  function broadcastWatcherStatus(sessionId: string) {
-    const sockets = browserSockets.get(sessionId);
-    if (!sockets) return;
-    const watching = (waitSockets.get(sessionId)?.size ?? 0) > 0;
-    const payload = JSON.stringify({ type: "watcher-status", watching });
-    for (const ws of sockets) {
-      ws.send(payload);
-    }
-  }
-
-  function deliverPendingRenderError(sessionId: string): boolean {
-    const error = pendingRenderErrors.get(sessionId);
-    const waiters = waitSockets.get(sessionId);
-    if (!error || !waiters || waiters.size === 0) return false;
-
-    pendingRenderErrors.delete(sessionId);
-    waitSockets.delete(sessionId);
-    const payload = JSON.stringify({ type: "render-error", error });
-    for (const waiter of waiters) {
-      waiter.send(payload);
-      waiter.close();
-    }
-    broadcastWatcherStatus(sessionId);
-    return true;
-  }
-
-  // Ping wait sockets periodically to detect dead connections.
-  // We can't rely on ws.close() triggering the close handler for dead sockets,
-  // so we manually remove dead sockets and broadcast status.
-  const PING_INTERVAL = 5_000;
-  const pongReceived = new WeakSet<CanvasSocket>();
-
-  function removeWaitSocket(ws: CanvasSocket, sessionId: string) {
-    const sockets = waitSockets.get(sessionId);
-    if (sockets) {
-      sockets.delete(ws);
-      if (sockets.size === 0) waitSockets.delete(sessionId);
-    }
-    try { ws.close(); } catch {}
-    broadcastWatcherStatus(sessionId);
-  }
-
-  setInterval(() => {
-    for (const [sessionId, sockets] of waitSockets) {
-      for (const ws of sockets) {
-        if (!pongReceived.has(ws)) {
-          // No pong since last ping — connection is dead
-          removeWaitSocket(ws, sessionId);
-          continue;
-        }
-        pongReceived.delete(ws);
-        try { ws.ping(); } catch {
-          removeWaitSocket(ws, sessionId);
-        }
-      }
-    }
-  }, PING_INTERVAL);
-
-  const handlers = {
-    open(ws: CanvasSocket) {
-      const { type, sessionId } = ws.data;
-      const map = type === "browser" ? browserSockets : waitSockets;
-      if (!map.has(sessionId)) map.set(sessionId, new Set());
-      map.get(sessionId)!.add(ws);
-      if (type === "browser") {
-        // Send current watcher status to newly connected browser
-        const watching = (waitSockets.get(sessionId)?.size ?? 0) > 0;
-        ws.send(JSON.stringify({ type: "watcher-status", watching }));
-      } else {
-        // CLI waiter connected — notify browsers
-        pongReceived.add(ws); // Give it a free pass on first interval
-        if (!deliverPendingRenderError(sessionId)) {
-          broadcastWatcherStatus(sessionId);
-        }
-      }
-    },
-    message(ws: CanvasSocket, message: string | Buffer) {
-      const { type, sessionId } = ws.data;
-      if (type === "browser") {
-        try {
-          const data = JSON.parse(typeof message === "string" ? message : new TextDecoder().decode(message));
-          if (data.type === "submit") {
-            const feedback = data.feedback as string;
-
-            const session = sessionManager.get(sessionId);
-            if (session) {
-              sessionManager.saveFeedback(sessionId, session.currentRevision, feedback);
-              broadcastRevisionUpdate(sessionId);
-
-              const waiters = waitSockets.get(sessionId);
-              if (waiters && waiters.size > 0) {
-                sessionManager.consumeFeedback(sessionId, session.currentRevision);
-                broadcastRevisionUpdate(sessionId);
-                const payload = JSON.stringify({ type: "submit", feedback });
-                for (const waiter of waiters) {
-                  waiter.send(payload);
-                  waiter.close();
-                }
-                waitSockets.delete(sessionId);
-              }
-            }
-          }
-          if (data.type === "render-error" && isCanvasRenderError(data.error)) {
-            const session = sessionManager.get(sessionId);
-            if (
-              session
-              && data.error.revision === session.currentRevision
-              && session.canvasFiles.includes(data.error.filename)
-            ) {
-              pendingRenderErrors.set(sessionId, data.error);
-              deliverPendingRenderError(sessionId);
-            }
-          }
-        } catch {}
-      }
-    },
-    pong(ws: CanvasSocket) {
-      if (ws.data.type === "wait") {
-        pongReceived.add(ws);
-      }
-    },
-    close(ws: CanvasSocket) {
-      const { type, sessionId } = ws.data;
-      const map = type === "browser" ? browserSockets : waitSockets;
-      map.get(sessionId)?.delete(ws);
-      if (map.get(sessionId)?.size === 0) map.delete(sessionId);
-      if (type === "wait") {
-        // CLI waiter disconnected — notify browsers
-        broadcastWatcherStatus(sessionId);
-      }
-    },
-  };
-
-  return { handlers, broadcastPlanUpdate, broadcastRevisionUpdate, broadcastWatcherStatus, broadcastRemoteFeedback };
-}

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "allowImportingTsExtensions": true,
-    "noEmit": true,
-    "types": ["@types/bun"]
-  },
-  "include": ["bin/**/*"]
-}

package/workers/canvas-share/README.md

@@ -1,159 +0,0 @@
-# canvas-share
-
-Cloudflare Worker that hosts shared agent-canvas snapshots.
-
-## Architecture
-
-- **R2 (`BLOBS`)** stores share payloads, compiled canvas JS, JSX source, and reviewer-uploaded annotation images.
-- **KV (`FEEDBACK`)** stores individual feedback entries (sortable keys for `since` queries) and rate limit counters (TTL 120s).
-- **Static assets (`ASSETS`)** serve runtime bundles (`runtime.js`, `components.js`, `preact-compat.js`, `client.js`, `client.css`) — these are mirrored from `daemon/dist/` automatically by `bun run build`.
-
-Validation is enforced with [Zod](https://zod.dev). Limits are centralized in [`src/types.ts`](src/types.ts).
-
-## Infrastructure as code
-
-The Cloudflare config is defined programmatically in [`oblaka.ts`](oblaka.ts)
-using [`oblaka-iac`](https://github.com/contember/oblaka). The committed
-[`oblaka.ts`](oblaka.ts) is the source of truth; `wrangler.jsonc` is
-auto-generated and **gitignored** — never edit it by hand.
-
-| Command | Generates | Used for |
-|---|---|---|
-| `bun run oblaka` | `wrangler.jsonc` (env `local`) | local dev via Miniflare |
-| `bun run oblaka:stage` | `wrangler.jsonc` (env `stage`) | staging deploy |
-| `bun run oblaka:prod` | `wrangler.jsonc` (env `prod`) | production deploy |
-
-`oblaka-iac` auto-prefixes R2 bucket and KV namespace names with the env
-(e.g. `canvas-share-blobs` becomes `stage-canvas-share-blobs`) so the same
-config produces isolated stage and prod resources.
-
-## Local development
-
-```bash
-cd workers/canvas-share
-bun install
-
-# Build daemon bundles AND auto-copy them into ./public/assets
-cd ../..
-bun run build
-
-# Start the worker locally via Miniflare (no Cloudflare account needed).
-# `bun run dev` runs `oblaka` first to regenerate wrangler.jsonc, then
-# starts wrangler dev --local.
-cd workers/canvas-share
-bun run dev
-
-# Point the daemon at it
-cd ../..
-CANVAS_SHARE_ENDPOINT=http://127.0.0.1:8787 bun bin/agent-canvas.ts daemon restart
-```
-
-Then click **Share** on any revision in the canvas UI.
-
-## Testing
-
-```bash
-cd workers/canvas-share
-bun test            # unit tests for validation, util
-bun run typecheck   # typecheck src/
-```
-
-## Continuous deployment
-
-The repo ships GitHub Actions workflows that deploy the worker automatically:
-
-| Workflow | Trigger | Env |
-|---|---|---|
-| `deploy-worker-stage.yml` | Push to `main` touching `workers/canvas-share/**`, `daemon/client/**`, or `daemon/build.ts` | `stage` |
-| `deploy-worker-prod.yml` | Version tag push (`v*`) | `prod` |
-
-Both call the reusable `deploy-worker.yml` which:
-
-1. Installs deps + builds the daemon runtime bundles (auto-mirrored into `public/assets/`)
-2. Runs `bunx oblaka oblaka.ts --env <env> --remote` to create or update the R2 bucket and KV namespace on Cloudflare
-3. Sets `SHARE_AUTH_TOKEN` via `wrangler secret bulk` (skipped if no token is configured for the env)
-4. Runs `bunx wrangler deploy`
-
-### Required GitHub secrets
-
-| Secret | Purpose |
-|---|---|
-| `CLOUDFLARE_API_TOKEN` | Token with Workers + R2 + KV permissions on the target account |
-| `CLOUDFLARE_ACCOUNT_ID` | Account id the worker deploys to |
-| `SHARE_AUTH_TOKEN_STAGE` | Bearer token daemons must use to POST to stage (optional) |
-| `SHARE_AUTH_TOKEN_PROD` | Bearer token daemons must use to POST to prod (optional) |
-
-Both stage and prod use the same Cloudflare account; oblaka auto-prefixes resource names so stage and prod get separate `stage-canvas-share-blobs` and `prod-canvas-share-blobs` buckets (same for KV).
-
-Use GitHub Environments (`Settings → Environments → stage / prod`) to gate prod deploys behind a manual approval if you want belt-and-suspenders safety.
-
-## Manual production deploy
-
-If you'd rather deploy by hand instead of via CI:
-
-1. (Recommended) Generate a shared bearer token to gate share creation:
-   ```bash
-   openssl rand -hex 32 | bunx wrangler secret put SHARE_AUTH_TOKEN --env prod
-   ```
-   Without this, anyone on the internet can pump shares into your R2 bucket.
-   Set the same value as `CANVAS_SHARE_AUTH_TOKEN` on the daemon side.
-
-2. (Optional) Override default 30-day share expiration:
-   ```bash
-   echo "604800" | bunx wrangler secret put SHARE_TTL_SECONDS --env prod  # 7 days
-   ```
-
-3. Build daemon bundles + deploy. The deploy script regenerates
-   `wrangler.jsonc` for the target env, then runs `wrangler deploy`.
-   The R2 bucket and KV namespace are created automatically by oblaka
-   on first deploy:
-   ```bash
-   cd ../..
-   bun run build
-   cd workers/canvas-share
-   bun run deploy:prod   # or deploy:stage
-   ```
-
-4. Configure the daemon:
-   ```bash
-   export CANVAS_SHARE_ENDPOINT=https://canvas-share.<subdomain>.workers.dev
-   export CANVAS_SHARE_AUTH_TOKEN=<the token you generated>
-   bunx agent-canvas daemon restart
-   ```
-
-The Share button in the canvas UI lights up once the daemon sees `CANVAS_SHARE_ENDPOINT`.
-
-## Endpoints
-
-| Method | Path                               | Purpose                                         | Auth                |
-|--------|------------------------------------|-------------------------------------------------|---------------------|
-| GET    | `/health`                          | Health check                                    | none                |
-| POST   | `/shares`                          | Create a new share                              | `SHARE_AUTH_TOKEN`  |
-| POST   | `/shares/:shareId/revoke`          | Revoke / delete a share                         | `ownerToken`        |
-| GET    | `/shares/:shareId/feedback?since=` | List feedback entries (called by daemon poller) | none (capability)   |
-| GET    | `/s/:shareId`                      | HTML shell for reviewers                        | none (capability)   |
-| GET    | `/s/:shareId/meta`                 | Share metadata                                  | none                |
-| GET    | `/s/:shareId/canvas/:filename`     | Serve compiled canvas JS / JSX source           | none                |
-| POST   | `/s/:shareId/feedback`             | Submit feedback (called by reviewer browser)    | none                |
-| POST   | `/s/:shareId/upload`               | Upload annotation image                         | none                |
-| GET    | `/s/:shareId/uploads/:filename`    | Serve uploaded image                            | none                |
-
-## Rate limits
-
-Per-IP, per-minute, sliding window (KV-backed). Tweak in [`src/types.ts`](src/types.ts).
-
-| Bucket          | Limit |
-|-----------------|-------|
-| Share creation  | 5/min |
-| Feedback POST   | 20/min/share |
-| Upload          | 30/min/share |
-
-## Security model
-
-- **Capability URLs** — anyone with `/s/:shareId` (24-char hex, ~96 bits entropy) has full view+comment access. Brute-forcing is impractical.
-- **Owner token** — returned to the daemon at create time, required to revoke. Stored in the daemon's session metadata so the canvas author can revoke from the Share dialog.
-- **Optional shared bearer token** (`SHARE_AUTH_TOKEN`) — gates share creation so only authorized daemons can push to the worker.
-- **No reviewer auth** — reviewers self-report a name (stored locally in their browser), there is no signup. Suitable for "send to a colleague" flows, **not** public publishing.
-- **Per-share TTL** — defaults to 30 days. Expired shares 404 and are eventually purged by KV's TTL.
-- **Size limits** — share payload max 2 MB, feedback body max 256 KB, image upload max 5 MB.
-- **Validation** — all incoming bodies are validated by Zod schemas before any storage write.

package/workers/canvas-share/oblaka.ts

@@ -1,56 +0,0 @@
-import { define, KVNamespace, R2Bucket, Worker } from 'oblaka-iac'
-
-/**
- * Per-environment overrides. `local` is what `bunx oblaka oblaka.ts` uses
- * when generating wrangler.jsonc for `wrangler dev --local`. `stage` and
- * `prod` are picked when running `bunx oblaka oblaka.ts --env stage|prod`
- * for actual Cloudflare deploys.
- *
- * Secrets (SHARE_AUTH_TOKEN, SHARE_TTL_SECONDS overrides, etc.) are NOT
- * declared here — set them with `wrangler secret put` after deploy.
- */
-const vars = {
-	local: {
-		// Empty share auth in local dev so smoke tests don't need a token.
-	},
-	stage: {},
-	prod: {},
-}
-
-export default define(({ env }) => {
-	if (!(env in vars)) {
-		throw new Error(`Unknown environment ${env}`)
-	}
-
-	const blobs = new R2Bucket({
-		name: 'canvas-share-blobs',
-	})
-
-	const feedback = new KVNamespace({
-		name: 'canvas-share-feedback',
-	})
-
-	return new Worker({
-		dir: '.',
-		name: 'canvas-share',
-		main: './src/index.ts',
-		compatibility_flags: ['nodejs_compat'],
-		compatibility_date: '2025-01-01',
-		observability: { enabled: true },
-		// Runtime bundles (preact-compat, runtime, components, client.js + css)
-		// are mirrored here from daemon/dist/ by `bun run build` in the repo
-		// root. The worker serves them via the ASSETS binding.
-		assets: {
-			directory: './public',
-			binding: 'ASSETS',
-		},
-		bindings: {
-			BLOBS: blobs,
-			FEEDBACK: feedback,
-		},
-		vars: {
-			ENVIRONMENT: env,
-			...vars[env as keyof typeof vars],
-		},
-	})
-})

package/workers/canvas-share/package.json

@@ -1,25 +0,0 @@
-{
-  "name": "canvas-share",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "oblaka": "bunx oblaka oblaka.ts",
-    "oblaka:stage": "bunx oblaka oblaka.ts --env stage",
-    "oblaka:prod": "bunx oblaka oblaka.ts --env prod",
-    "dev": "bun run oblaka && wrangler dev --local",
-    "deploy:stage": "bun run oblaka:stage && wrangler deploy --env stage",
-    "deploy:prod": "bun run oblaka:prod && wrangler deploy --env prod",
-    "typecheck": "tsc --noEmit",
-    "test": "bun test"
-  },
-  "dependencies": {
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250101.0",
-    "oblaka-iac": "latest",
-    "typescript": "^5.6.0",
-    "wrangler": "^4.24.0"
-  }
-}