ugly-app 0.1.708 → 0.1.709

package/src/native/facades/browse.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import { createBrowseFacade } from './browse.js';
+
+function mock() {
+  const calls: Array<{ channel: string; payload: unknown }> = [];
+  let ensureCount = 0;
+  const invoke = async (channel: string, payload: unknown): Promise<unknown> => {
+    calls.push({ channel, payload });
+    if (channel === 'browse.open' || channel === 'browse.navigate' || channel === 'browse.info')
+      return { id: 's1', url: 'u', title: 't' };
+    if (channel === 'browse.extract' || channel === 'browse.content')
+      return { url: 'u', title: 't', format: 'readability', content: '', length: 0 };
+    if (channel === 'browse.links') return [];
+    if (channel === 'browse.waitForSelector') return true;
+    if (channel === 'browse.screenshot') return 'data:image/png;base64,AAAA';
+    return undefined;
+  };
+  const ensure = async (): Promise<void> => {
+    ensureCount += 1;
+  };
+  return { calls, facade: createBrowseFacade(invoke, ensure), ensureCount: () => ensureCount };
+}
+
+describe('browse facade → channel mapping', () => {
+  it('maps every method to its channel + payload and gates each on ensure()', async () => {
+    const m = mock();
+    const { facade, calls } = m;
+    await facade.extract('https://x/', { format: 'html' });
+    await facade.open('https://x/', { waitMs: 10 });
+    await facade.navigate('s1', 'https://y/');
+    await facade.click('s1', '#a');
+    await facade.type('s1', '#a', 'hi', { clear: true, submit: true });
+    await facade.waitForSelector('s1', '#a', 500);
+    await facade.content('s1', { format: 'text' });
+    await facade.links('s1');
+    await facade.eval('s1', '1+1');
+    await facade.screenshot('s1');
+    await facade.info('s1');
+    await facade.close('s1');
+
+    expect(calls.map((c) => c.channel)).toEqual([
+      'browse.extract',
+      'browse.open',
+      'browse.navigate',
+      'browse.click',
+      'browse.type',
+      'browse.waitForSelector',
+      'browse.content',
+      'browse.links',
+      'browse.eval',
+      'browse.screenshot',
+      'browse.info',
+      'browse.close',
+    ]);
+    expect(calls[0].payload).toEqual({ url: 'https://x/', opts: { format: 'html' } });
+    expect(calls[2].payload).toEqual({ id: 's1', url: 'https://y/', opts: undefined });
+    expect(calls[3].payload).toEqual({ id: 's1', selector: '#a' });
+    expect(calls[4].payload).toEqual({ id: 's1', selector: '#a', text: 'hi', opts: { clear: true, submit: true } });
+    expect(calls[5].payload).toEqual({ id: 's1', selector: '#a', timeoutMs: 500 });
+    expect(calls[8].payload).toEqual({ id: 's1', expression: '1+1' });
+    // ensure() fires once per call (12 calls).
+    expect(m.ensureCount()).toBe(12);
+  });
+});

package/src/native/proxy.ts

@@ -79,6 +79,10 @@ export function enableUglyProxy(opts: {
   let connecting: Promise<boolean> | null = null;
   let lastLabel: string | undefined;
   let forceRepick = false;
+  // When set, the next connect targets this specific host (bypassing the picker).
+  // Driven by the 'proxy:connect' event — e.g. opening a recent project that's
+  // stamped with the desktop it lives on, so the phone reaches the right host.
+  let preferredHost: string | null = null;
 
   const setStatus = (state: string, hostLabel?: string): void => {
     void native.invoke('proxy.setStatus' as never, { state, hostLabel } as never).catch(() => {});
@@ -89,14 +93,16 @@ export function enableUglyProxy(opts: {
     if (connecting) return connecting;
     connecting = (async () => {
       try {
-        const existing = forceRepick ? null : client.hostDeviceId();
-        console.error('[uglyproxy] ensureConnected: start', { existing, forceRepick });
+        // A pinned host (preferredHost) wins over the cached one and the picker.
+        const existing = preferredHost ?? (forceRepick ? null : client.hostDeviceId());
+        console.error('[uglyproxy] ensureConnected: start', { existing, preferredHost, forceRepick });
         if (existing) {
-          // Silent reconnect to the previously chosen host.
+          // Direct (re)connect to the cached or pinned host — no picker.
           setStatus('reconnecting', lastLabel);
           await client.connect(existing);
           setStatus('connected', lastLabel);
-          console.error('[uglyproxy] ensureConnected: reconnected', { existing });
+          preferredHost = null;
+          console.error('[uglyproxy] ensureConnected: connected', { existing });
           return true;
         }
         forceRepick = false;
@@ -125,13 +131,26 @@ export function enableUglyProxy(opts: {
   }
 
   // The native drawer's "switch desktop" pill emits this — drop the current host and
-  // re-run the picker.
+  // re-run the picker. Clear any pin so the user's repick isn't overridden.
   native.subscribe('proxy:switch' as never, (() => {
     forceRepick = true;
+    preferredHost = null;
     client.close();
     void ensureConnected();
   }) as never);
 
+  // Pin to a specific host (e.g. opening a recent project stamped with its
+  // desktop). If we're connected elsewhere, drop it so the pinned target wins.
+  native.subscribe('proxy:connect' as never, ((data: unknown) => {
+    const d = data as { deviceId?: string; label?: string } | undefined;
+    if (!d?.deviceId) return;
+    preferredHost = d.deviceId;
+    if (d.label) lastLabel = d.label;
+    forceRepick = false;
+    if (client.isOpen() && client.hostDeviceId() !== d.deviceId) client.close();
+    void ensureConnected();
+  }) as never);
+
   // task.event:<id> subscriptions need a host-side fanout handshake (task.listen) — unlike
   // process/net streams, whose fanout is registered by the spawning invoke. Ref-count per
   // task id so N local subscribers share one host subscription (no duplicate event delivery).

package/src/server/PostgresSchema.ts

@@ -7,6 +7,8 @@
  */
 
 import { getPool } from './Pg.js';
+import { fieldIndexStatements } from './schemaIndexes.js';
+import type { IndexDef } from '../shared/DB.js';
 
 const VALID_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 
@@ -17,10 +19,14 @@ function assertSafeName(name: string): void {
 }
 
 /**
- * Create the collection table + its default JSONB GIN index if they
- * don't exist. Idempotent.
+ * Create the collection table, its default JSONB GIN index, and the btree
+ * expression indexes the collection declares (so `WHERE data->>'field' = $1`
+ * lookups stay index-served instead of seq-scanning). All idempotent.
  */
-export async function ensureTable(collection: string): Promise<void> {
+export async function ensureTable(
+  collection: string,
+  indexes?: IndexDef[],
+): Promise<void> {
   assertSafeName(collection);
   const pool = getPool();
   await pool.query(
@@ -36,6 +42,17 @@ export async function ensureTable(collection: string): Promise<void> {
     `CREATE INDEX IF NOT EXISTS "idx_${collection}_data"
      ON "${collection}" USING GIN (data)`,
   );
+  // Declared field indexes — isolate each so a single failure (e.g. a UNIQUE
+  // index over pre-existing duplicate data) never aborts the rest of the sync.
+  for (const sql of fieldIndexStatements(collection, indexes)) {
+    try {
+      await pool.query(sql);
+    } catch (err) {
+      console.warn(
+        `[PostgresSchema] field index skipped for "${collection}": ${(err as Error).message}`,
+      );
+    }
+  }
 }
 
 export async function tableExists(collection: string): Promise<boolean> {

package/src/server/SchemaCheck.ts

@@ -40,11 +40,15 @@ async function loadSnapshots(): Promise<Record<string, SchemaDescriptor>> {
   return snapshots;
 }
 
-async function upsertSnapshot(name: string, descriptor: SchemaDescriptor): Promise<void> {
+async function upsertSnapshot(
+  name: string,
+  descriptor: SchemaDescriptor,
+  indexes?: IndexDef[],
+): Promise<void> {
   // Invariant: a stored snapshot must imply the table exists. ensureTable is
   // idempotent (CREATE TABLE IF NOT EXISTS + CREATE INDEX IF NOT EXISTS) on
   // the data-proxy side, so this is safe to call on every snapshot write.
-  await ensureTable(name);
+  await ensureTable(name, indexes);
   await Postgres.query(
     `INSERT INTO _schema_snapshots (collection, schema_json, updated_at)
      VALUES ($1, $2, NOW())
@@ -60,11 +64,12 @@ export async function updateAllSnapshots(
     if (!def.schema) continue;
     // Getter-backed collections have no local table — skip schema snapshots.
     if (def.meta?.getter) continue;
+    const indexes = (def as { indexes?: IndexDef[] }).indexes;
     const descriptor = serializeSchema(
       def.schema as z.ZodObject<z.ZodRawShape>,
-      (def as { indexes?: IndexDef[] }).indexes,
+      indexes,
     );
-    await upsertSnapshot(name, descriptor);
+    await upsertSnapshot(name, descriptor, indexes);
   }
 }
 
@@ -175,8 +180,8 @@ export async function autoMigrateNewCollections(
   `);
 
   for (const name of newCollections) {
-    // 1. Create the table via data proxy
-    await ensureTable(name);
+    // 1. Create the table via data proxy (+ its declared field indexes)
+    await ensureTable(name, (defs[name] as { indexes?: IndexDef[] })?.indexes);
 
     // 2. Skip writing a new file if a schema migration for this collection already exists.
     // Auto-baseline can be triggered whenever the _schema_snapshots row is missing

package/src/server/adapter/workers/createWorkersApp.ts

@@ -65,7 +65,8 @@ import type {
   WorkerHandlers,
   WorkerRegistry,
 } from '../../../shared/Api.js';
-import type { CollectionDefRegistry } from '../../../shared/DB.js';
+import type { CollectionDefRegistry, IndexDef } from '../../../shared/DB.js';
+import { fieldIndexStatements } from '../../schemaIndexes.js';
 import { getUglyBotUrl } from '../../../shared/uglyBotUrl.js';
 import type { DbAdapter, PubSubMessage, ServerAdapter } from '../types.js';
 import type { QueueMessage, WorkersEnv } from './cf-types.js';
@@ -1600,6 +1601,17 @@ export function createWorkersApp<R extends AppRegistryBase>(
         await db.query(
           `CREATE INDEX IF NOT EXISTS "idx_${name}_data" ON "${name}" USING GIN (data)`,
         );
+        // Declared btree expression indexes (`((data->>'field'))`) — without
+        // these, `WHERE data->>'field' = $1` reads seq-scan and hang at scale.
+        // Isolate each so one bad index never fails the whole schema sync.
+        const indexes = (ctx.collections?.[name] as { indexes?: IndexDef[] } | undefined)?.indexes;
+        for (const sql of fieldIndexStatements(name, indexes)) {
+          try {
+            await db.query(sql);
+          } catch (err) {
+            console.warn(`[/_init] field index skipped for "${name}": ${(err as Error).message}`);
+          }
+        }
         created.push(name);
       }
       return c.json({ ok: true, ensured: created });

package/src/server/schemaIndexes.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import { fieldIndexStatements } from './schemaIndexes';
+
+describe('fieldIndexStatements', () => {
+  // Regression: the dock-app prod hang. A plain `{ fields: { userId: 1 } }` index
+  // declaration produced NO `((data->>'userId'))` btree index (schemaGen only
+  // handled unique/ttl), so `WHERE data->>'userId' = $1` seq-scanned and hung.
+  it('emits a btree expression index for a plain single-field index', () => {
+    const sql = fieldIndexStatements('dockApp', [{ fields: { userId: 1 } }]);
+    expect(sql).toEqual([
+      `CREATE INDEX IF NOT EXISTS "idx_dockApp_userId" ON "dockApp" ((data->>'userId'))`,
+    ]);
+  });
+
+  it('emits a UNIQUE index (with _unique suffix) for a unique index', () => {
+    const sql = fieldIndexStatements('emailAccount', [{ fields: { email: 1 }, unique: true }]);
+    expect(sql).toEqual([
+      `CREATE UNIQUE INDEX IF NOT EXISTS "idx_emailAccount_email_unique" ON "emailAccount" ((data->>'email'))`,
+    ]);
+  });
+
+  it('emits one statement per declared index', () => {
+    const sql = fieldIndexStatements('voice', [
+      { fields: { userId: 1 } },
+      { fields: { provider: 1 } },
+    ]);
+    expect(sql).toHaveLength(2);
+    expect(sql[1]).toContain(`((data->>'provider'))`);
+  });
+
+  it('skips composite (multi-field) indexes — single-field only', () => {
+    expect(fieldIndexStatements('x', [{ fields: { a: 1, b: 1 } }])).toEqual([]);
+  });
+
+  it('returns [] for no/empty indexes', () => {
+    expect(fieldIndexStatements('x')).toEqual([]);
+    expect(fieldIndexStatements('x', [])).toEqual([]);
+  });
+
+  it('refuses unsafe collection/field names (no SQL injection surface)', () => {
+    expect(fieldIndexStatements('bad-name', [{ fields: { userId: 1 } }])).toEqual([]);
+    expect(fieldIndexStatements('ok', [{ fields: { 'a; DROP TABLE x': 1 } }])).toEqual([]);
+  });
+});

package/src/server/schemaIndexes.ts

@@ -0,0 +1,44 @@
+/**
+ * Single source of truth for the btree expression indexes a collection declares
+ * via `indexes: [{ fields: { <field>: 1 } }]`.
+ *
+ * The default `idx_<c>_data` GIN index covers JSONB containment (`data @> …`),
+ * but it CANNOT serve the scalar lookups the query layer actually emits
+ * (`translateFilter` builds `WHERE data->>'field' = $1`). Without a matching
+ * `((data->>'field'))` btree index, every filtered read on the collection
+ * sequential-scans — invisible on a small table, a hang once it grows past the
+ * 30s statement_timeout.
+ *
+ * Pure string-builder (no pg/pool imports) so it's safe to share across the Node
+ * schema sync (`PostgresSchema.ensureTable`), the Workers `/_init` route, and the
+ * migration generator (`schemaGen`). Statements are idempotent (IF NOT EXISTS) so
+ * every call site can run them on every deploy.
+ */
+import type { IndexDef } from '../shared/DB.js';
+
+const VALID_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+
+/** Raw `CREATE [UNIQUE] INDEX` SQL for each declared single-field index. */
+export function fieldIndexStatements(
+  collection: string,
+  indexes?: IndexDef[],
+): string[] {
+  if (!VALID_NAME.test(collection)) return [];
+  const out: string[] = [];
+  for (const idx of indexes ?? []) {
+    const fields = Object.keys(idx.fields);
+    // Single-field expression indexes only — matches the query layer, which
+    // filters one JSONB field at a time. (Composite indexes aren't emitted.)
+    if (fields.length !== 1) continue;
+    const field = fields[0];
+    if (!VALID_NAME.test(field)) continue;
+    const unique = idx.unique ? 'UNIQUE ' : '';
+    const name = idx.unique
+      ? `idx_${collection}_${field}_unique`
+      : `idx_${collection}_${field}`;
+    out.push(
+      `CREATE ${unique}INDEX IF NOT EXISTS "${name}" ON "${collection}" ((data->>'${field}'))`,
+    );
+  }
+  return out;
+}