@columenlabs/lumen-ai 0.1.196 → 0.1.198

package/README.md

@@ -273,3 +273,13 @@ const routes = workspaceRoutes({ base: '/api/assistant', owner: callerOf, store:
 ```
 
 Budget: one frame is one row (at most 1.5 MB of rows, 10,000 rows, 50 columns), so a run writes one row; every read has a LIMIT (30 workspaces, 12 tabs each, 100 frames). Columns are typed from their values (number, date, text); a list of words, or short text from a small set, becomes a tags column (chips). The kit's `WorkspacesProvider` takes `recipes` to offer + New tab from a recipe in the tab bar.
+
+### Web data and pushed datasets (no server code runs)
+
+Three more ways rows reach a tab, all on a free Workers plan (no Dynamic Workers):
+
+- **Fetch recipe** (`{kind: 'fetch', requests: [{url, method?, key?}], each?: {values}, rows?, pick?}`): declarative web reads the product runs on its server. `{field}` holes in a URL fill from each value of `each` (text fills `{value}`); `fetchCalls` expands them (at most `FETCH_CALLS`, 50 a run) and `fetchedRows` turns the answers into rows, the `each` value's fields first, then `pick`'s dotted paths (`current.temperature_2m`). A data key is named (`key`), never sent: the product adds it server side.
+- **Browser script** (`{kind: 'script', runtime: 'browser', code, requests?}`): JavaScript that runs in the person's page. The kit's `runBrowserFrame` loads `<base>/sandbox` (this package's `SANDBOX_HTML`, served with `SANDBOX_CSP`: `connect-src 'none'`) in an iframe with `sandbox="allow-scripts"`, runs the code in a Web Worker there (stopped at `BROWSER_RUN_MS`, 30 s), and saves what it returns with `PUT /frames/:id/rows` (one write, the frame's caps checked). The code is the body of `async (fetched, hub) => rows`: `fetched` holds the answers to its `requests`, `hub.fetch(url, {key})` makes one more read through the product's proxy (`fetch` in `workspaceRoutes`, `POST <base>/fetch`). The server never runs it: `refresh` refuses it (409, open the tab), and `refreshAll` lists such tabs as `browser`.
+- **Pushed dataset** (`store.pushFrame(owner, {name, rows, mode, by, key?})`): rows an outside agent wrangled (a CSV parsed by `parseCsv`, at most `CSV_BYTES` a call, the rest as `append` parts; with `key`, an appended row replaces the one with its key). Origin `harness`, no recipe; `by` names the agent and the tab's status bar reads "Pushed by Claude Code · 4 min ago". `removeFrame` deletes one with its tabs.
+
+`workspaceRoutes` lets `call`, `fetch` and browser `script` recipes through to the product's `allow`; server `sql` and `script` are refused.

package/dist/workspaces/frame.d.ts

@@ -28,3 +28,13 @@ export declare function applyEdits(columns: FrameColumn[], data: FrameCell[][],
     data: FrameCell[][];
     edits: FrameEdit[];
 };
+/** A frame's rows back as objects keyed by their column labels (what a CSV push appends to). */
+export declare function asObjects(columns: FrameColumn[], data: FrameCell[][]): Row[];
+/** Most CSV text one call takes (bigger goes as `append` parts). */
+export declare const CSV_BYTES = 1000000;
+/**
+ * CSV text (RFC 4180: quoted fields, `""` for a quote, CRLF or LF) as rows keyed by the header.
+ * A numeral becomes a number, but one with a leading zero (`02134`, a zip) stays text; `types`
+ * says a column's type outright. Empty cells are blank.
+ */
+export declare function parseCsv(text: string, types?: Record<string, 'number' | 'text'>): Row[];

package/dist/workspaces/frame.js

@@ -124,3 +124,80 @@ export function applyEdits(columns, data, edits) {
     }
     return { data: rows, edits: kept };
 }
+/** A frame's rows back as objects keyed by their column labels (what a CSV push appends to). */
+export function asObjects(columns, data) {
+    return data.map((r) => Object.fromEntries(columns.map((c, i) => [c.label, r[i] ?? null])));
+}
+/** Most CSV text one call takes (bigger goes as `append` parts). */
+export const CSV_BYTES = 1_000_000;
+const NUMERAL = /^[-−]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?$/i;
+/**
+ * CSV text (RFC 4180: quoted fields, `""` for a quote, CRLF or LF) as rows keyed by the header.
+ * A numeral becomes a number, but one with a leading zero (`02134`, a zip) stays text; `types`
+ * says a column's type outright. Empty cells are blank.
+ */
+export function parseCsv(text, types = {}) {
+    if (text.length > CSV_BYTES)
+        throw new FrameError(`The CSV is ${Math.round(text.length / 1000)} KB: send at most ${CSV_BYTES / 1000} KB a call, the rest as append parts.`);
+    const records = [];
+    let field = '';
+    let rec = [];
+    let quoted = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (quoted) {
+            if (ch === '"' && text[i + 1] === '"') {
+                field += '"';
+                i++;
+            }
+            else if (ch === '"')
+                quoted = false;
+            else
+                field += ch;
+        }
+        else if (ch === '"' && field === '')
+            quoted = true;
+        else if (ch === ',') {
+            rec.push(field);
+            field = '';
+        }
+        else if (ch === '\n' || ch === '\r') {
+            if (ch === '\r' && text[i + 1] === '\n')
+                i++;
+            rec.push(field);
+            field = '';
+            if (rec.length > 1 || rec[0] !== '')
+                records.push(rec);
+            rec = [];
+        }
+        else
+            field += ch;
+    }
+    if (quoted)
+        throw new FrameError('The CSV has a quote that never closes.');
+    if (field !== '' || rec.length) {
+        rec.push(field);
+        records.push(rec);
+    }
+    const [header, ...body] = records;
+    if (!header?.length)
+        throw new FrameError('The CSV has no header row.');
+    const names = header.map((h, i) => h.trim() || `Column ${i + 1}`);
+    return body.map((r) => Object.fromEntries(names.map((n, i) => {
+        const raw = (r[i] ?? '').trim();
+        if (raw === '')
+            return [n, null];
+        const want = types[n];
+        if (want === 'text')
+            return [n, raw];
+        const numeric = NUMERAL.test(raw) && !/^[-−]?0\d/.test(raw);
+        if (want === 'number' || numeric) {
+            const v = Number(raw.replace('−', '-').replace(/[,$%\s]/g, ''));
+            if (Number.isFinite(v))
+                return [n, v];
+            if (want === 'number')
+                throw new FrameError(`${n} holds numbers: "${raw}" is not one.`);
+        }
+        return [n, raw];
+    })));
+}

package/dist/workspaces/index.d.ts

@@ -2,9 +2,10 @@
  * Workspaces: a person's pages of tabs, each a table over rows a recipe pulled, run again on demand.
  * `createWorkspaces` is the store (any SQLite), `workspaceRoutes` the HTTP the kit's pages call.
  */
-export { FrameError, applyEdits, asRows, coerce, dedupeEdits, toFrame } from './frame.js';
+export { CSV_BYTES, FrameError, applyEdits, asObjects, asRows, coerce, dedupeEdits, parseCsv, toFrame, } from './frame.js';
 export type { Row } from './frame.js';
 export { FRAME_BYTES, MAX_FRAMES, MAX_TABS, MAX_WORKSPACES, RUN_MS, createWorkspaces, d1Sql, doSql, recipeText, workspaceMigrations, } from './store.js';
 export type { RecipeRunner, SqlRunner, WorkspaceRead, WorkspaceTables, Workspaces, WorkspacesOptions, } from './store.js';
 export { workspaceRoutes } from './routes.js';
+export { SANDBOX_CSP, SANDBOX_HTML, sandboxResponse } from './sandbox.js';
 export type { WorkspaceRoutesOptions } from './routes.js';

package/dist/workspaces/index.js

@@ -2,6 +2,7 @@
  * Workspaces: a person's pages of tabs, each a table over rows a recipe pulled, run again on demand.
  * `createWorkspaces` is the store (any SQLite), `workspaceRoutes` the HTTP the kit's pages call.
  */
-export { FrameError, applyEdits, asRows, coerce, dedupeEdits, toFrame } from './frame.js';
+export { CSV_BYTES, FrameError, applyEdits, asObjects, asRows, coerce, dedupeEdits, parseCsv, toFrame, } from './frame.js';
 export { FRAME_BYTES, MAX_FRAMES, MAX_TABS, MAX_WORKSPACES, RUN_MS, createWorkspaces, d1Sql, doSql, recipeText, workspaceMigrations, } from './store.js';
 export { workspaceRoutes } from './routes.js';
+export { SANDBOX_CSP, SANDBOX_HTML, sandboxResponse } from './sandbox.js';

package/dist/workspaces/routes.d.ts

@@ -8,7 +8,8 @@
  *   GET    /workspaces/:id                one, with its frames' heads
  *   PATCH  /workspaces/:id {name?, app?}
  *   DELETE /workspaces/:id
- *   POST   /workspaces/:id/tabs {name, recipe}   a new tab from a recipe (runs it once)
+ *   POST   /workspaces/:id/tabs {name, recipe, start?}   a new tab from a recipe (runs it once;
+ *                                        `start.formulas`: formula columns its layout starts with)
  *   POST   /workspaces/:id/refresh        runs every tab's recipe again, one after another
  *   PUT    /workspaces/:id/tabs/:tab {name?, config?}
  *   DELETE /workspaces/:id/tabs/:tab
@@ -19,11 +20,15 @@
  *   POST   /frames/:id/refresh            runs its recipe again
  *   GET|PUT /frames/:id/script            its recipe
  *   PATCH  /frames/:id/cells {edits}      hand edits
+ *   PUT    /frames/:id/rows {rows | error, ms}   a browser recipe's run: its rows, or why it failed
+ *   GET    /sandbox                       the page a browser recipe runs in (./sandbox.ts)
+ *   POST   /fetch {url, method?, body?, key?}    one web read for a browser script, through the
+ *                                        product's proxy (`fetch`; 404 when it has none)
  *
  * Every call needs a caller; writes must be same-origin JSON, since a signed-in browser session is
  * a cookie and a foreign page must not reach a person's data.
  */
-import { frameScriptSchema } from '@columenlabs/lumen-ui-types/frames';
+import { type FrameFetch, frameScriptSchema } from '@columenlabs/lumen-ui-types/frames';
 import { z } from 'zod';
 import type { Workspaces } from './store.js';
 type Awaitable<T> = T | Promise<T>;
@@ -36,6 +41,16 @@ export interface WorkspaceRoutesOptions {
     owner: (req: Request) => Awaitable<string | null>;
     /** Which recipes this product runs; a recipe it refuses answers 422 with the reason. */
     allow?: (recipe: z.infer<typeof frameScriptSchema>, req: Request) => Awaitable<string | null>;
+    /**
+     * One web read for a browser script (`hub.fetch`): the product checks the host against its
+     * allowlist, adds a named data key server side, bounds the time and size, and answers the
+     * status and body. Left out, `/fetch` is 404 and browser scripts read nothing.
+     */
+    fetch?: (call: FrameFetch, req: Request) => Promise<{
+        status: number;
+        body: unknown;
+        error?: string;
+    }>;
 }
 export declare function workspaceRoutes(opts: WorkspaceRoutesOptions): (req: Request) => Promise<Response>;
 export {};

package/dist/workspaces/routes.js

@@ -8,7 +8,8 @@
  *   GET    /workspaces/:id                one, with its frames' heads
  *   PATCH  /workspaces/:id {name?, app?}
  *   DELETE /workspaces/:id
- *   POST   /workspaces/:id/tabs {name, recipe}   a new tab from a recipe (runs it once)
+ *   POST   /workspaces/:id/tabs {name, recipe, start?}   a new tab from a recipe (runs it once;
+ *                                        `start.formulas`: formula columns its layout starts with)
  *   POST   /workspaces/:id/refresh        runs every tab's recipe again, one after another
  *   PUT    /workspaces/:id/tabs/:tab {name?, config?}
  *   DELETE /workspaces/:id/tabs/:tab
@@ -19,26 +20,49 @@
  *   POST   /frames/:id/refresh            runs its recipe again
  *   GET|PUT /frames/:id/script            its recipe
  *   PATCH  /frames/:id/cells {edits}      hand edits
+ *   PUT    /frames/:id/rows {rows | error, ms}   a browser recipe's run: its rows, or why it failed
+ *   GET    /sandbox                       the page a browser recipe runs in (./sandbox.ts)
+ *   POST   /fetch {url, method?, body?, key?}    one web read for a browser script, through the
+ *                                        product's proxy (`fetch`; 404 when it has none)
  *
  * Every call needs a caller; writes must be same-origin JSON, since a signed-in browser session is
  * a cookie and a foreign page must not reach a person's data.
  */
-import { frameEditSchema, frameName, frameScriptSchema } from '@columenlabs/lumen-ui-types/frames';
-import { customViewConfigSchema } from '@columenlabs/lumen-ui-types/views';
+import { FRAME_ROWS, frameEditSchema, frameName, frameScriptSchema, runsInBrowser, } from '@columenlabs/lumen-ui-types/frames';
+import { customViewConfigSchema, viewFormulaSchema, } from '@columenlabs/lumen-ui-types/views';
 import { z } from 'zod';
 import { FrameError } from './frame.js';
+import { sandboxResponse } from './sandbox.js';
 const HEADERS = { 'content-type': 'application/json', 'cache-control': 'no-store' };
 const json = (body, status = 200) => new Response(JSON.stringify(body), { status, headers: HEADERS });
 const fail = (error, status) => json({ error }, status);
 const createSchema = z.object({ name: frameName, app: z.string().max(40).optional() });
 const patchSchema = z.object({ name: frameName.optional(), app: z.string().max(40).optional() });
 const addTabSchema = z.object({ name: frameName, recipe: frameScriptSchema });
+const newTabSchema = addTabSchema.extend({
+    /** Formula columns its default layout starts with (dew point over temperature and humidity). */
+    start: z.object({ formulas: z.array(viewFormulaSchema).max(10) }).optional(),
+});
 const putTabSchema = z.object({
     name: frameName.optional(),
     config: customViewConfigSchema.nullable().optional(),
 });
 const cellsSchema = z.object({ edits: z.array(frameEditSchema).min(1).max(200) });
 const scriptSchema = z.object({ script: frameScriptSchema });
+const rowsSchema = z.object({
+    rows: z.array(z.record(z.string(), z.unknown())).max(FRAME_ROWS).optional(),
+    error: z.string().max(2000).optional(),
+    ms: z.number().min(0).max(600_000).optional(),
+});
+const fetchSchema = z.object({
+    url: z.string().url().max(2000),
+    method: z.enum(['GET', 'POST']).optional(),
+    body: z.string().max(20_000).optional(),
+    key: z
+        .string()
+        .regex(/^[a-z0-9_-]{1,40}$/i)
+        .optional(),
+});
 export function workspaceRoutes(opts) {
     const base = opts.base.replace(/\/$/, '');
     return async (req) => {
@@ -68,8 +92,9 @@ export function workspaceRoutes(opts) {
             return parsed.data;
         };
         const allowed = async (recipe) => {
-            if (recipe.kind !== 'call')
-                throw new FrameError('Recipes here are one call to an app tool.', 422);
+            // The server runs app calls and declarative web reads; code runs only in the browser.
+            if (recipe.kind === 'sql' || (recipe.kind === 'script' && !runsInBrowser(recipe)))
+                throw new FrameError('Recipes here are an app call, web reads, or a script that runs in your browser.', 422);
             const why = opts.allow ? await opts.allow(recipe, req) : null;
             if (why)
                 throw new FrameError(why, 422);
@@ -102,9 +127,9 @@ export function workspaceRoutes(opts) {
                 }
                 else if (sub === 'tabs') {
                     if (!tab && m === 'POST') {
-                        const p = await body(addTabSchema);
+                        const p = await body(newTabSchema);
                         await allowed(p.recipe);
-                        return json(await s.addTab(owner, id, { name: p.name, recipe: p.recipe }));
+                        return json(await s.addTab(owner, id, { name: p.name, recipe: p.recipe, start: p.start }));
                     }
                     if (tab && m === 'PUT') {
                         const p = await body(putTabSchema);
@@ -118,6 +143,13 @@ export function workspaceRoutes(opts) {
                         return json(await s.removeTab(owner, id, tab));
                 }
             }
+            if (root === 'sandbox' && !id && m === 'GET')
+                return sandboxResponse();
+            if (root === 'fetch' && !id && m === 'POST') {
+                if (!opts.fetch)
+                    return fail('not_found', 404);
+                return json(await opts.fetch(await body(fetchSchema), req));
+            }
             if (root === 'frames') {
                 if (!id) {
                     if (m === 'GET')
@@ -149,6 +181,9 @@ export function workspaceRoutes(opts) {
                         return json(await s.setScript(owner, id, p.script));
                     }
                 }
+                else if (sub === 'rows' && m === 'PUT') {
+                    return json(await s.putRows(owner, id, await body(rowsSchema)));
+                }
                 else if (sub === 'cells' && m === 'PATCH') {
                     return json(await s.editCells(owner, id, (await body(cellsSchema)).edits));
                 }

package/dist/workspaces/sandbox.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The page a browser recipe runs in (`GET <base>/sandbox`). The kit's runner loads it in an
+ * iframe with `sandbox="allow-scripts"`: an opaque origin, so no cookies, storage or hub calls,
+ * and this response's own policy reaches nothing (`connect-src 'none'`). The script itself runs
+ * in a Web Worker inside it, so the page can stop it (a loop that never ends) at its time limit.
+ * Its only way out is `hub.fetch(url)`, a message to the parent, which asks the product's fetch
+ * proxy (allowlisted hosts, keys added server side) and posts the answer back.
+ *
+ * Messages (parent ⇄ page): `run {code, fetched}` → `done {result} | {error}`;
+ * page → parent `fetch {id, url, init}` → parent → page `fetched {id, result} | {id, error}`.
+ */
+/** The page: starts the worker and passes messages between it and the parent. */
+export declare const SANDBOX_HTML: string;
+/** Its policy: inline and eval for the person's code, a blob worker, and no network at all. */
+export declare const SANDBOX_CSP = "default-src 'none'; script-src 'unsafe-inline' 'unsafe-eval' blob:; worker-src blob:; connect-src 'none'; img-src 'none'; frame-ancestors 'self'; base-uri 'none'; form-action 'none'";
+/** The sandbox page as a response. */
+export declare function sandboxResponse(): Response;

package/dist/workspaces/sandbox.js

@@ -0,0 +1,65 @@
+/**
+ * The page a browser recipe runs in (`GET <base>/sandbox`). The kit's runner loads it in an
+ * iframe with `sandbox="allow-scripts"`: an opaque origin, so no cookies, storage or hub calls,
+ * and this response's own policy reaches nothing (`connect-src 'none'`). The script itself runs
+ * in a Web Worker inside it, so the page can stop it (a loop that never ends) at its time limit.
+ * Its only way out is `hub.fetch(url)`, a message to the parent, which asks the product's fetch
+ * proxy (allowlisted hosts, keys added server side) and posts the answer back.
+ *
+ * Messages (parent ⇄ page): `run {code, fetched}` → `done {result} | {error}`;
+ * page → parent `fetch {id, url, init}` → parent → page `fetched {id, result} | {id, error}`.
+ */
+/** The worker's code: runs the person's script as an async function of `fetched` and `hub`. */
+const WORKER = `
+const waiting = new Map();
+let next = 0;
+const hub = {
+  fetch(url, init) {
+    return new Promise((ok, no) => {
+      const id = ++next;
+      waiting.set(id, { ok, no });
+      postMessage({ type: 'fetch', id, url: String(url), init: init || {} });
+    });
+  },
+};
+onmessage = async (e) => {
+  const m = e.data || {};
+  if (m.type === 'fetched') {
+    const w = waiting.get(m.id);
+    waiting.delete(m.id);
+    if (w) m.error ? w.no(new Error(m.error)) : w.ok(m.result);
+    return;
+  }
+  if (m.type !== 'run') return;
+  try {
+    const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+    const out = await new AsyncFunction('fetched', 'hub', m.code)(m.fetched, hub);
+    postMessage({ type: 'done', result: JSON.parse(JSON.stringify(out === undefined ? null : out)) });
+  } catch (err) {
+    postMessage({ type: 'done', error: String((err && err.message) || err) });
+  }
+};`;
+/** The page: starts the worker and passes messages between it and the parent. */
+export const SANDBOX_HTML = `<!doctype html><meta charset="utf-8"><title>Recipe</title><script>
+const worker = new Worker(URL.createObjectURL(new Blob([${JSON.stringify(WORKER)}], { type: 'text/javascript' })));
+worker.onmessage = (e) => parent.postMessage(e.data, '*');
+worker.onerror = (e) => parent.postMessage({ type: 'done', error: e.message || 'The script failed.' }, '*');
+addEventListener('message', (e) => { if (e.source === parent) worker.postMessage(e.data); });
+parent.postMessage({ type: 'ready' }, '*');
+</script>`;
+/** Its policy: inline and eval for the person's code, a blob worker, and no network at all. */
+export const SANDBOX_CSP = "default-src 'none'; script-src 'unsafe-inline' 'unsafe-eval' blob:; worker-src blob:; connect-src 'none'; img-src 'none'; frame-ancestors 'self'; base-uri 'none'; form-action 'none'";
+/** The sandbox page as a response. */
+export function sandboxResponse() {
+    return new Response(SANDBOX_HTML, {
+        headers: {
+            'content-type': 'text/html; charset=utf-8',
+            'content-security-policy': SANDBOX_CSP,
+            'cache-control': 'private, max-age=3600',
+            'x-content-type-options': 'nosniff',
+            'referrer-policy': 'no-referrer',
+            // Framed by the app's own pages only (a product's default may be DENY).
+            'x-frame-options': 'SAMEORIGIN',
+        },
+    });
+}

package/dist/workspaces/store.d.ts

@@ -13,7 +13,7 @@
  */
 import { type FrameChoice, type FrameData, type FrameEditInput, type FrameMeta, type FrameScript } from '@columenlabs/lumen-ui-types/frames';
 import type { CustomViewConfig } from '@columenlabs/lumen-ui-types/views';
-import type { Workspace, WorkspaceSummary } from '@columenlabs/lumen-ui-types/workspaces';
+import type { Workspace, WorkspaceSummary, WorkspaceTab } from '@columenlabs/lumen-ui-types/workspaces';
 type Row = Record<string, unknown>;
 /** The SQL a store needs: the same shape as `lumen-tasks`' `SqlRunner`, so one runner serves both. */
 export interface SqlRunner {
@@ -87,6 +87,7 @@ export declare function createWorkspaces(opts: WorkspacesOptions): {
         name: string;
         recipe: FrameScript;
         by?: 'you' | 'assistant';
+        start?: WorkspaceTab['start'];
     }): Promise<{
         workspace: WorkspaceRead;
         tab: string;
@@ -101,6 +102,7 @@ export declare function createWorkspaces(opts: WorkspacesOptions): {
         ran: number;
         failed: string[];
         rows: number;
+        browser: string[];
     }>;
     frames(owner: string): Promise<{
         frames: FrameChoice[];
@@ -120,6 +122,32 @@ export declare function createWorkspaces(opts: WorkspacesOptions): {
     }>;
     /** A new recipe for a frame: kept only if it runs. */
     setScript(owner: string, id: string, script: FrameScript): Promise<FrameData>;
+    /**
+     * A browser run's result: the rows its script gave (or why it failed), saved as the frame's
+     * rows with the hand edits put back. Only a frame whose recipe runs in the browser takes them.
+     */
+    putRows(owner: string, id: string, p: {
+        rows?: unknown[];
+        error?: string;
+        ms?: number;
+    }): Promise<FrameData>;
+    /**
+     * A dataset an outside agent pushes (a CSV it wrangled): rows only, no recipe. `replace`
+     * writes the rows; `append` adds them, and with `key` a row whose key is already there
+     * replaces it. One frame per name among pushed ones; the rows pass the same caps as a run.
+     */
+    pushFrame(owner: string, p: {
+        name: string;
+        rows: Row[];
+        mode: 'replace' | 'append';
+        by: string;
+        key?: string;
+    }): Promise<FrameData>;
+    /** Deletes a frame and every tab that shows it (a pushed dataset the agent takes away). */
+    removeFrame(owner: string, id: string): Promise<{
+        ok: true;
+        tabs: number;
+    }>;
     editCells(owner: string, id: string, edits: FrameEditInput[]): Promise<FrameData>;
 };
 export type Workspaces = ReturnType<typeof createWorkspaces>;

package/dist/workspaces/store.js

@@ -11,8 +11,8 @@
  *   spaces: owner, id, name, app, tabs (JSON), created_at, updated_at
  *   frames: owner, id, name, head (JSON: meta + recipe), rows (JSON), edits (JSON), at
  */
-import { FRAME_RUNS, } from '@columenlabs/lumen-ui-types/frames';
-import { FrameError, applyEdits, asRows, coerce, dedupeEdits, toFrame } from './frame.js';
+import { FRAME_RUNS, runsInBrowser, } from '@columenlabs/lumen-ui-types/frames';
+import { FrameError, applyEdits, asObjects, asRows, coerce, dedupeEdits, toFrame } from './frame.js';
 /** A Durable Object's SQLite (`ctx.storage.sql`). */
 export function doSql(sql) {
     return {
@@ -61,14 +61,21 @@ const parse = (v, d) => {
         return d;
     }
 };
-const metaOf = ({ script: _s, ...m }) => m;
+/** A frame's meta as pages read it, with what makes it (the tab's icon, where ↻ runs). */
+const metaOf = ({ script, ...m }) => ({
+    ...m,
+    recipe: script?.kind,
+    browser: runsInBrowser(script) || undefined,
+});
 /** The recipe's text as the person reads it: `jobs.list` and its arguments. */
 export function recipeText(s) {
     if (!s)
         return 'nothing (rows written once)';
     if (s.kind === 'call')
         return `${s.fn} ${JSON.stringify(s.args)}`;
-    return s.kind === 'sql' ? 'a SQL query' : 'a script';
+    if (s.kind === 'fetch')
+        return `web reads ${JSON.stringify(s.requests.map((r) => r.url))}`;
+    return s.kind === 'sql' ? 'a SQL query' : runsInBrowser(s) ? 'a browser script' : 'a script';
 }
 export function createWorkspaces(opts) {
     const t = opts.tables ?? TABLES;
@@ -147,9 +154,17 @@ export function createWorkspaces(opts) {
         const { head, data } = await getFrame(owner, id);
         if (!head.script)
             throw new FrameError('This tab was written once: it has no recipe to run.', 409);
+        if (runsInBrowser(head.script))
+            throw new FrameError('This tab runs in your browser: open the tab to refresh.', 409);
         return runInto(owner, head, data.edits ?? [], head.script, by, data.rows);
     }
     async function runInto(owner, head, edits, script, by, lastRows) {
+        if (runsInBrowser(script)) {
+            // No server code runs: the browser runs it on ↻ and saves its rows (`putRows`).
+            const next = { ...head, script, mode: 'asof', error: undefined };
+            await writeFrame(owner, next, lastRows, edits);
+            return { meta: metaOf(next), rows: lastRows, edits };
+        }
         const started = Date.now();
         const at = now();
         try {
@@ -190,19 +205,24 @@ export function createWorkspaces(opts) {
         }
     }
     /** A new frame from a recipe, run once (a failed run keeps the frame with its error). */
-    async function newFrame(owner, name, recipe, by) {
+    async function roomForFrame(owner) {
         const [{ n } = { n: 0 }] = await db.all(`SELECT COUNT(*) AS n FROM (SELECT 1 FROM ${t.frames} WHERE owner = ? LIMIT ${MAX_FRAMES})`, owner);
         if (Number(n) >= MAX_FRAMES)
             throw new FrameError(`You keep ${MAX_FRAMES} tabs of data, the most: delete some first.`, 409);
+    }
+    async function newFrame(owner, name, recipe, by) {
+        await roomForFrame(owner);
+        const browser = runsInBrowser(recipe);
         const head = {
             id: newId('fr'),
             name,
             columns: [],
             rows: 0,
-            mode: 'live',
+            // Web reads change on their own, so they run only when asked; app reads are live.
+            mode: browser || recipe.kind === 'fetch' ? 'asof' : 'live',
             kind: 'snapshot',
             at: now(),
-            origin: 'assistant',
+            origin: browser ? 'script' : 'assistant',
             script: recipe,
         };
         await runInto(owner, head, [], recipe, by, []);
@@ -214,6 +234,9 @@ export function createWorkspaces(opts) {
         columns: h.columns,
         at: h.at,
         origin: h.origin ?? 'assistant',
+        recipe: h.script?.kind,
+        by: h.by,
+        rows: h.rows,
     });
     /** A frame no tab shows but a card links (a recipe added from + Data) still counts as used. */
     async function dropFrameIfUnused(owner, frame) {
@@ -291,6 +314,7 @@ export function createWorkspaces(opts) {
                 name: p.name,
                 source: { frame: head.id },
                 config: null,
+                ...(p.start?.formulas.length ? { start: p.start } : {}),
             };
             const saved = await saveSpace(owner, { ...w, tabs: [...w.tabs, tab] });
             const hs = await heads(owner, saved.tabs.flatMap((x) => ('frame' in x.source ? [x.source.frame] : [])));
@@ -333,9 +357,19 @@ export function createWorkspaces(opts) {
             let ran = 0;
             let rows = 0;
             const failed = [];
+            // Tabs whose recipe runs in the browser: the page runs each one it shows.
+            const browser = [];
+            const hs = await heads(owner, w.tabs.flatMap((x) => ('frame' in x.source ? [x.source.frame] : [])));
             for (const x of w.tabs) {
                 if (!('frame' in x.source))
                     continue;
+                const h = hs.get(x.source.frame);
+                if (!h?.script)
+                    continue;
+                if (runsInBrowser(h.script)) {
+                    browser.push(x.name);
+                    continue;
+                }
                 try {
                     const d = await refresh(owner, x.source.frame);
                     ran++;
@@ -345,7 +379,7 @@ export function createWorkspaces(opts) {
                     failed.push(x.name);
                 }
             }
-            return { ran, failed, rows };
+            return { ran, failed, rows, browser };
         },
         async frames(owner) {
             const rows = await db.all(`SELECT head FROM ${t.frames} WHERE owner = ? LIMIT ${MAX_FRAMES}`, owner);
@@ -377,6 +411,106 @@ export function createWorkspaces(opts) {
             const { head, data } = await getFrame(owner, id);
             return runInto(owner, head, data.edits ?? [], script, 'you', data.rows);
         },
+        /**
+         * A browser run's result: the rows its script gave (or why it failed), saved as the frame's
+         * rows with the hand edits put back. Only a frame whose recipe runs in the browser takes them.
+         */
+        async putRows(owner, id, p) {
+            const { head, data } = await getFrame(owner, id);
+            if (!runsInBrowser(head.script))
+                throw new FrameError('Only a browser recipe saves rows here.', 409);
+            const at = now();
+            const ms = Math.max(0, Math.round(p.ms ?? 0));
+            if (p.error !== undefined) {
+                const error = p.error.slice(0, 300) || 'The script failed.';
+                const failed = {
+                    ...head,
+                    error,
+                    runs: [
+                        { at, rows: 0, ms, ok: false, by: 'you', error },
+                        ...(head.runs ?? []),
+                    ].slice(0, FRAME_RUNS),
+                };
+                await writeFrame(owner, failed, data.rows, data.edits ?? []);
+                return { meta: metaOf(failed), rows: data.rows, edits: data.edits ?? [] };
+            }
+            const { columns, data: rows } = toFrame(asRows(p.rows ?? []));
+            const put = applyEdits(columns, rows, data.edits ?? []);
+            const next = {
+                ...head,
+                columns,
+                rows: put.data.length,
+                at,
+                by: 'you',
+                error: undefined,
+                edited: put.edits.length || undefined,
+                runs: [
+                    { at, rows: put.data.length, ms, ok: true, by: 'you' },
+                    ...(head.runs ?? []),
+                ].slice(0, FRAME_RUNS),
+            };
+            await writeFrame(owner, next, put.data, put.edits);
+            return { meta: metaOf(next), rows: put.data, edits: put.edits };
+        },
+        /**
+         * A dataset an outside agent pushes (a CSV it wrangled): rows only, no recipe. `replace`
+         * writes the rows; `append` adds them, and with `key` a row whose key is already there
+         * replaces it. One frame per name among pushed ones; the rows pass the same caps as a run.
+         */
+        async pushFrame(owner, p) {
+            const same = await db.all(`SELECT id, head FROM ${t.frames} WHERE owner = ? AND name = ? LIMIT ${MAX_FRAMES}`, owner, p.name);
+            const pushed = same.find((r) => parse(r.head, null)?.origin === 'harness');
+            const found = pushed ? await getFrame(owner, String(pushed.id)) : null;
+            if (!found)
+                await roomForFrame(owner);
+            let all = p.rows;
+            if (found && p.mode === 'append') {
+                const before = asObjects(found.head.columns, found.data.rows);
+                if (p.key) {
+                    const k = p.key;
+                    const fresh = new Set(p.rows.map((r) => String(r[k] ?? '')));
+                    all = [...before.filter((r) => !fresh.has(String(r[k] ?? ''))), ...p.rows];
+                }
+                else
+                    all = [...before, ...p.rows];
+            }
+            const { columns, data } = toFrame(all);
+            const at = now();
+            const head = {
+                ...(found?.head ?? {
+                    id: newId('fr'),
+                    kind: 'snapshot',
+                    mode: 'static',
+                    origin: 'harness',
+                    script: null,
+                }),
+                name: p.name,
+                columns,
+                rows: data.length,
+                at,
+                by: p.by.slice(0, 60),
+                error: undefined,
+                edited: undefined,
+            };
+            await writeFrame(owner, head, data, []);
+            return { meta: metaOf(head), rows: data, edits: [] };
+        },
+        /** Deletes a frame and every tab that shows it (a pushed dataset the agent takes away). */
+        async removeFrame(owner, id) {
+            await getFrame(owner, id);
+            const rows = await db.all(`SELECT id, name, app, tabs, created_at, updated_at FROM ${t.spaces} WHERE owner = ? LIMIT ${MAX_WORKSPACES}`, owner);
+            let tabs = 0;
+            for (const r of rows) {
+                const w = spaceOf(r);
+                const keep = w.tabs.filter((x) => !('frame' in x.source && x.source.frame === id));
+                if (keep.length === w.tabs.length)
+                    continue;
+                tabs += w.tabs.length - keep.length;
+                await saveSpace(owner, { ...w, tabs: keep });
+            }
+            await db.run(`DELETE FROM ${t.frames} WHERE owner = ? AND id = ?`, owner, id);
+            return { ok: true, tabs };
+        },
         async editCells(owner, id, edits) {
             const { head, data } = await getFrame(owner, id);
             const at = now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@columenlabs/lumen-ai",
-  "version": "0.1.196",
+  "version": "0.1.198",
   "description": "Lumen's assistant and agent parts: a chat assistant's server (Claude tiers, tools over MCP, the web, hand off, spend caps), serving an MCP server from a Worker, read-only tool sets and metered tool calls.",
   "license": "MIT",
   "type": "module",
@@ -52,8 +52,8 @@
     "@ai-sdk/openai": "4.0.108",
     "@anthropic-ai/sdk": "0.133.0",
     "@cloudflare/think": "0.23.0",
-    "@columenlabs/lumen-ops": "0.1.196",
-    "@columenlabs/lumen-ui-types": "0.1.196",
+    "@columenlabs/lumen-ops": "0.1.198",
+    "@columenlabs/lumen-ui-types": "0.1.198",
     "agents": "0.32.0",
     "ai": "7.0.162",
     "just-bash": "3.6.0",