ugly-app 0.1.619 → 0.1.621

package/src/native/web-adapter.ts

@@ -0,0 +1,118 @@
+import type { Channel, NativeEvent, DataOf, SafeAreaInsets } from './contract.js';
+import { fallbackFor } from './contract-meta.js';
+import { NativeUnavailableError } from './protocol.js';
+
+type Emit = <E extends NativeEvent>(event: E, data: DataOf<E>) => void;
+
+// In-tab alarm timers (web fallback only; cleared on tab close).
+const alarmTimers = new Map<string, ReturnType<typeof setTimeout>>();
+let gpsWatchId: number | null = null;
+let webAudio: HTMLAudioElement | null = null;
+
+function readSafeArea(): SafeAreaInsets {
+  const cs = getComputedStyle(document.documentElement);
+  const px = (v: string): number => parseInt(v || '0', 10) || 0;
+  return {
+    top: px(cs.getPropertyValue('--sat')),
+    right: 0,
+    bottom: 0,
+    left: 0,
+  };
+}
+
+export async function webInvoke(channel: Channel, payload: unknown, emit: Emit): Promise<unknown> {
+  switch (channel) {
+    case 'clipboard.write':
+      await navigator.clipboard.writeText((payload as { text: string }).text);
+      return undefined;
+    case 'clipboard.read':
+      return { text: await navigator.clipboard.readText() };
+    case 'system.openExternal':
+      window.open((payload as { url: string }).url, '_blank', 'noopener');
+      return undefined;
+    case 'system.share':
+      if (navigator.share) await navigator.share(payload as ShareData);
+      return undefined;
+    case 'badge.set': {
+      const n = (payload as { count: number }).count;
+      const navAny = navigator as unknown as {
+        setAppBadge?: (n?: number) => Promise<void>;
+        clearAppBadge?: () => Promise<void>;
+      };
+      if (n > 0) await navAny.setAppBadge?.(n);
+      else await navAny.clearAppBadge?.();
+      return undefined;
+    }
+    case 'ui.getSafeArea':
+      return readSafeArea();
+    case 'gps.start': {
+      if (gpsWatchId != null) navigator.geolocation.clearWatch(gpsWatchId);
+      gpsWatchId = navigator.geolocation.watchPosition(
+        (pos) =>
+          emit('gps.position', {
+            lat: pos.coords.latitude,
+            lng: pos.coords.longitude,
+            accuracy: pos.coords.accuracy,
+            timestamp: pos.timestamp,
+            altitude: pos.coords.altitude ?? undefined,
+            speed: pos.coords.speed ?? undefined,
+            course: pos.coords.heading ?? undefined,
+          }),
+        () => {},
+        { enableHighAccuracy: true },
+      );
+      return undefined;
+    }
+    case 'gps.stop':
+      if (gpsWatchId != null) {
+        navigator.geolocation.clearWatch(gpsWatchId);
+        gpsWatchId = null;
+      }
+      return undefined;
+    case 'alarm.schedule': {
+      const p = payload as { id: string; delaySeconds: number; title?: string; body?: string };
+      const existing = alarmTimers.get(p.id);
+      if (existing) clearTimeout(existing);
+      alarmTimers.set(
+        p.id,
+        setTimeout(() => {
+          alarmTimers.delete(p.id);
+          if ('Notification' in window && Notification.permission === 'granted') {
+            new Notification(p.title ?? 'Alarm', { body: p.body });
+          }
+          emit('alarm.fired', { id: p.id });
+        }, p.delaySeconds * 1000),
+      );
+      return undefined;
+    }
+    case 'alarm.cancel': {
+      const id = (payload as { id?: string }).id;
+      if (id) {
+        const t = alarmTimers.get(id);
+        if (t) clearTimeout(t);
+        alarmTimers.delete(id);
+      } else {
+        for (const t of alarmTimers.values()) clearTimeout(t);
+        alarmTimers.clear();
+      }
+      return undefined;
+    }
+    case 'alarm.playAudio': {
+      const p = payload as { base64: string; mimeType?: string };
+      webAudio = new Audio(`data:${p.mimeType ?? 'audio/wav'};base64,${p.base64}`);
+      await webAudio.play().catch(() => {});
+      return undefined;
+    }
+    case 'capture.screenshot': {
+      // Best-effort capture requires a user-gesture-driven display capture; declared
+      // web-capable but gated by a gesture, so treat as unavailable until wired by a caller.
+      throw new NativeUnavailableError(channel);
+    }
+    default: {
+      const fb = fallbackFor(channel, 'web');
+      if (fb === 'throw') throw new NativeUnavailableError(channel);
+      // 'noop' / 'web'-but-unimplemented (liveActivity, tts, push, …) resolve silently.
+      return undefined;
+    }
+  }
+}

package/src/native/wrapper.test.ts

@@ -30,4 +30,26 @@ describe('native wrapper', () => {
     native.gps.onPosition(cb);
     expect(subscribe).toHaveBeenCalledWith('gps.position', cb);
   });
+
+  it('capture/clipboard (non-gated) invoke the right channels', async () => {
+    const { invoke } = installFakeNative();
+    const { native } = await import('./wrapper');
+    await native.capture.screenshot();
+    await native.clipboard.write({ text: 'a' });
+    expect(invoke).toHaveBeenCalledWith('capture.screenshot', undefined);
+    expect(invoke).toHaveBeenCalledWith('clipboard.write', { text: 'a' });
+  });
+
+  it('fs.readFile ensures the fs permission then invokes', async () => {
+    const granted: Record<string, string> = { fs: 'full' };
+    const invoke = vi.fn(async (channel: string) => {
+      if (channel === 'permissions.query') return { granted: { ...granted } };
+      if (channel === 'fs.readFile') return { content: 'hello' };
+      return undefined;
+    });
+    (globalThis as unknown as { UglyNative: unknown }).UglyNative = { platform: 'desktop', invoke, subscribe: () => () => {} };
+    const { native } = await import('./wrapper');
+    expect(await native.fs.readFile('/x')).toBe('hello');
+    expect(invoke).toHaveBeenCalledWith('fs.readFile', { path: '/x' });
+  });
 });

package/src/native/wrapper.ts

@@ -1,28 +1,178 @@
-import type { DataOf, PayloadOf } from './contract.js';
+import type { Channel, DataOf, PayloadOf, ResultOf } from './contract.js';
 import type { NativePlatform } from './protocol.js';
+import { NativeUnavailableError } from './protocol.js';
 import { installUglyNative } from './install.js';
+import { createPermissions } from './permissions.js';
+import { createProcessFacade } from './facades/process.js';
+import { createNetFacade } from './facades/net.js';
+import { createStudioFacade } from './facades/studio.js';
 
 const n = () => installUglyNative();
+const inv = <C extends Channel>(c: C, p: PayloadOf<C>): Promise<ResultOf<C>> =>
+  n().invoke(c, p) as Promise<ResultOf<C>>;
+
+export const permissions = createPermissions((c, p) => n().invoke(c as never, p as never), n().platform);
+
+// Desktop daemon bridges (process/net/studio + fs bytes) hang off window.UglyDesktop.
+interface DesktopBridges {
+  process?: unknown;
+  net?: unknown;
+  studio?: unknown;
+  fsBytes?: {
+    readFileBytes(path: string): Promise<Uint8Array>;
+    writeFileBytes(path: string, bytes: Uint8Array): Promise<void>;
+  };
+}
+const desktopBridge = (): DesktopBridges | undefined =>
+  (globalThis as unknown as { UglyDesktop?: DesktopBridges }).UglyDesktop;
 
 export const native = {
+  permissions,
+  capture: {
+    screenshot: () => inv('capture.screenshot', undefined),
+  },
   gps: {
-    start: (p: PayloadOf<'gps.start'>) => n().invoke('gps.start', p),
-    stop: () => n().invoke('gps.stop', undefined),
+    start: (p: PayloadOf<'gps.start'>) => inv('gps.start', p),
+    stop: () => inv('gps.stop', undefined),
     onPosition: (cb: (d: DataOf<'gps.position'>) => void) => n().subscribe('gps.position', cb),
   },
+  liveActivity: {
+    startWorkout: (p: PayloadOf<'liveActivity.startWorkout'>) => inv('liveActivity.startWorkout', p),
+    updateWorkout: (p: PayloadOf<'liveActivity.updateWorkout'>) => inv('liveActivity.updateWorkout', p),
+    endWorkout: () => inv('liveActivity.endWorkout', undefined),
+    startCardio: (p: PayloadOf<'liveActivity.startCardio'>) => inv('liveActivity.startCardio', p),
+    updateCardio: (p: PayloadOf<'liveActivity.updateCardio'>) => inv('liveActivity.updateCardio', p),
+    endCardio: () => inv('liveActivity.endCardio', undefined),
+  },
   alarm: {
-    schedule: (p: PayloadOf<'alarm.schedule'>) => n().invoke('alarm.schedule', p),
-    cancel: (p: PayloadOf<'alarm.cancel'>) => n().invoke('alarm.cancel', p),
-    playAudio: (p: PayloadOf<'alarm.playAudio'>) => n().invoke('alarm.playAudio', p),
+    schedule: (p: PayloadOf<'alarm.schedule'>) => inv('alarm.schedule', p),
+    cancel: (p: PayloadOf<'alarm.cancel'>) => inv('alarm.cancel', p),
+    playAudio: (p: PayloadOf<'alarm.playAudio'>) => inv('alarm.playAudio', p),
     onFired: (cb: (d: DataOf<'alarm.fired'>) => void) => n().subscribe('alarm.fired', cb),
   },
-  liveActivity: {
-    startWorkout: (p: PayloadOf<'liveActivity.startWorkout'>) => n().invoke('liveActivity.startWorkout', p),
-    updateWorkout: (p: PayloadOf<'liveActivity.updateWorkout'>) => n().invoke('liveActivity.updateWorkout', p),
-    endWorkout: () => n().invoke('liveActivity.endWorkout', undefined),
-    startCardio: (p: PayloadOf<'liveActivity.startCardio'>) => n().invoke('liveActivity.startCardio', p),
-    updateCardio: (p: PayloadOf<'liveActivity.updateCardio'>) => n().invoke('liveActivity.updateCardio', p),
-    endCardio: () => n().invoke('liveActivity.endCardio', undefined),
+  tts: {
+    start: (p: PayloadOf<'tts.start'>) => inv('tts.start', p),
+    pause: () => inv('tts.pause', undefined),
+    resume: () => inv('tts.resume', undefined),
+    stop: () => inv('tts.stop', undefined),
+    onState: (cb: (d: DataOf<'tts.state'>) => void) => n().subscribe('tts.state', cb),
+  },
+  push: {
+    register: () => inv('push.register', undefined),
+    onToken: (cb: (d: DataOf<'push.token'>) => void) => n().subscribe('push.token', cb),
+    onNotificationClick: (cb: (d: DataOf<'push.notificationClick'>) => void) =>
+      n().subscribe('push.notificationClick', cb),
+  },
+  clipboard: {
+    write: (p: PayloadOf<'clipboard.write'>) => inv('clipboard.write', p),
+    read: () => inv('clipboard.read', undefined),
+  },
+  system: {
+    openExternal: (p: PayloadOf<'system.openExternal'>) => inv('system.openExternal', p),
+    share: (p: PayloadOf<'system.share'>) => inv('system.share', p),
+  },
+  badge: {
+    set: (p: PayloadOf<'badge.set'>) => inv('badge.set', p),
+  },
+  ui: {
+    getSafeArea: () => inv('ui.getSafeArea', undefined),
+    onKeyboardHeight: (cb: (d: DataOf<'keyboard.height'>) => void) => n().subscribe('keyboard.height', cb),
+    onSafeAreaInsets: (cb: (d: DataOf<'safeArea.insets'>) => void) => n().subscribe('safeArea.insets', cb),
+  },
+  fs: {
+    readFile: async (path: string) => {
+      await permissions.ensure('fs');
+      return (await inv('fs.readFile', { path })).content;
+    },
+    writeFile: async (path: string, content: string) => {
+      await permissions.ensure('fs');
+      return inv('fs.writeFile', { path, content });
+    },
+    mkdir: async (path: string, recursive = false) => {
+      await permissions.ensure('fs');
+      return inv('fs.mkdir', { path, recursive });
+    },
+    rm: async (path: string, opts: { recursive?: boolean; force?: boolean } = {}) => {
+      await permissions.ensure('fs');
+      return inv('fs.rm', { path, ...opts });
+    },
+    rename: async (from: string, to: string) => {
+      await permissions.ensure('fs');
+      return inv('fs.rename', { from, to });
+    },
+    readdir: async (path: string) => {
+      await permissions.ensure('fs');
+      return (await inv('fs.readdir', { path })).entries;
+    },
+    stat: async (path: string) => {
+      await permissions.ensure('fs');
+      return inv('fs.stat', { path });
+    },
+    exists: async (path: string) => {
+      await permissions.ensure('fs');
+      return (await inv('fs.exists', { path })).exists;
+    },
+    realpath: async (path: string) => {
+      await permissions.ensure('fs');
+      return (await inv('fs.realpath', { path })).path;
+    },
+    readFileBytes: async (path: string): Promise<Uint8Array> => {
+      await permissions.ensure('fs');
+      const fb = desktopBridge()?.fsBytes;
+      if (!fb) throw new NativeUnavailableError('fs.readFileBytes');
+      return fb.readFileBytes(path);
+    },
+    writeFileBytes: async (path: string, bytes: Uint8Array): Promise<void> => {
+      await permissions.ensure('fs');
+      const fb = desktopBridge()?.fsBytes;
+      if (!fb) throw new NativeUnavailableError('fs.writeFileBytes');
+      return fb.writeFileBytes(path, bytes);
+    },
+  },
+  process: createProcessFacade(() => desktopBridge()?.process as never, n().platform, () => permissions.ensure('process')),
+  net: createNetFacade(() => desktopBridge()?.net as never, n().platform, () => permissions.ensure('net')),
+  studio: createStudioFacade(() => desktopBridge()?.studio as never, n().platform),
+  secrets: {
+    get: async (key: string) => {
+      await permissions.ensure('secrets');
+      return (await inv('secrets.get', { key })).value;
+    },
+    set: async (key: string, value: string) => {
+      await permissions.ensure('secrets');
+      return inv('secrets.set', { key, value });
+    },
+    delete: async (key: string) => {
+      await permissions.ensure('secrets');
+      return inv('secrets.delete', { key });
+    },
+    list: async () => {
+      await permissions.ensure('secrets');
+      return (await inv('secrets.list', undefined)).keys;
+    },
+  },
+  serve: {
+    start: async (dir?: string) => {
+      await permissions.ensure('serve');
+      return inv('serve.start', { dir });
+    },
+    stop: async (port: number) => {
+      await permissions.ensure('serve');
+      return inv('serve.stop', { port });
+    },
+  },
+  workers: {
+    register: async (path: string, boot = false) => {
+      await permissions.ensure('workers');
+      return (await inv('workers.register', { path, boot })).id;
+    },
+    unregister: async (id: string) => {
+      await permissions.ensure('workers');
+      return inv('workers.unregister', { id });
+    },
+    list: async () => {
+      await permissions.ensure('workers');
+      return (await inv('workers.list', undefined)).ids;
+    },
   },
 };
 

package/src/search/server/WebRetriever.ts

@@ -11,17 +11,22 @@ import type { Retriever, RetrievalResult, RetrieveOptions } from '../shared/Retr
 export interface WebSearchLike {
   search(
     params: { query: string; limit?: number },
-    options?: { userId?: string },
+    options?: { userId?: string; token?: string },
   ): Promise<{ items: { url: string; title: string; snippet: string }[] }>;
   summarize?(
     params: { url?: string; text?: string },
-    options?: { userId?: string },
+    options?: { userId?: string; token?: string },
   ): Promise<{ output: string }>;
 }
 
 export interface WebRetrieverOptions {
   /** Bill the search proxy to this user (charge context). */
   userId?: string;
+  /**
+   * The end user's ugly.bot session JWT. When set, the search proxy bills the
+   * USER (not the app owner). Omit for the default owner-billed behavior.
+   */
+  userToken?: string;
   /** Default result count. */
   limit?: number;
 }
@@ -46,7 +51,7 @@ export class WebRetriever implements Retriever {
     const limit = o?.limit ?? this.opts.limit ?? 8;
     const { items } = await this.provider.search(
       { query, limit },
-      { userId: this.opts.userId },
+      { userId: this.opts.userId, token: this.opts.userToken },
     );
     const n = Math.max(items.length, 1);
     return items.map((it, i) => ({
@@ -69,7 +74,7 @@ export class WebRetriever implements Retriever {
       try {
         const { output } = await this.provider.summarize(
           { url: result.source.url },
-          { userId: this.opts.userId },
+          { userId: this.opts.userId, token: this.opts.userToken },
         );
         if (output) return output;
       } catch {

package/src/server/ai/providers/UglyBotWebSearchProvider.ts

@@ -23,9 +23,15 @@ import type { WebSearchOptions, WebSearchProvider } from '../types.js';
 
 const DEFAULT_SEARCH_PROXY_URL = 'https://api.ugly.bot/v1/search';
 
-function resolveSearchEndpoint(op: string): { url: string; token: string } {
+function resolveSearchEndpoint(
+  op: string,
+  userToken?: string,
+): { url: string; token: string } {
   const base = process.env['SEARCH_PROXY_URL'] ?? DEFAULT_SEARCH_PROXY_URL;
+  // A user session JWT (when supplied) bills the user via resolveChargePayer;
+  // otherwise fall back to the app's owner-billed proxy token.
   const token =
+    userToken ??
     process.env['SEARCH_PROXY_TOKEN'] ??
     process.env['UGLY_BOT_TOKEN'] ??
     '';
@@ -42,8 +48,9 @@ function resolveSearchEndpoint(op: string): { url: string; token: string } {
 async function searchProxyRequest<T>(
   op: string,
   body: Record<string, unknown>,
+  userToken?: string,
 ): Promise<T> {
-  const { url, token } = resolveSearchEndpoint(op);
+  const { url, token } = resolveSearchEndpoint(op, userToken);
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), 30_000);
   try {
@@ -90,6 +97,7 @@ export const uglyBotWebSearchProvider: WebSearchProvider = {
         { query: params.query, limit: params.limit },
         options?.userId,
       ),
+      options?.token,
     );
   },
 
@@ -103,6 +111,7 @@ export const uglyBotWebSearchProvider: WebSearchProvider = {
         { url: params.url, text: params.text },
         options?.userId,
       ),
+      options?.token,
     );
     return {
       output: result.summary,
@@ -117,6 +126,7 @@ export const uglyBotWebSearchProvider: WebSearchProvider = {
     return searchProxyRequest<WebSearchOutput>(
       'enrich-web',
       withChargeContext({ query: params.query }, options?.userId),
+      options?.token,
     );
   },
 
@@ -127,6 +137,7 @@ export const uglyBotWebSearchProvider: WebSearchProvider = {
     return searchProxyRequest<WebSearchOutput>(
       'enrich-news',
       withChargeContext({ query: params.query }, options?.userId),
+      options?.token,
     );
   },
 };

package/src/server/ai/types.ts

@@ -210,6 +210,13 @@ export interface ImageGenProvider {
 
 export interface WebSearchOptions {
   userId?: string;
+  /**
+   * The end user's ugly.bot session JWT. When set, the search proxy is called
+   * with THIS token instead of the app's `SEARCH_PROXY_TOKEN`, so ugly.bot bills
+   * the user (via `resolveChargePayer`) instead of the app owner. Omit to keep
+   * the default owner-billed behavior.
+   */
+  token?: string;
 }
 
 export interface WebSearchProvider {