ugly-app 0.1.620 → 0.1.621

package/src/native/facades/net.ts

@@ -0,0 +1,50 @@
+import { NativeUnavailableError } from '../protocol.js';
+import type { Platform } from '../contract-meta.js';
+
+export interface UglySocket {
+  onConnect(cb: () => void): void;
+  onData(cb: (chunk: Uint8Array) => void): void;
+  onClose(cb: () => void): void;
+  onError(cb: (err: string) => void): void;
+  write(data: Uint8Array | string): void;
+  end(): void;
+  close(): void;
+}
+export interface UglyServer {
+  port: number;
+  onConnection(cb: (s: UglySocket) => void): void;
+  close(): void;
+}
+
+interface NetBridge {
+  connect(host: string, port: number): UglySocket;
+  listen(port?: number): Promise<UglyServer>;
+}
+
+export interface NetFacade {
+  connect(host: string, port: number): UglySocket;
+  listen(port?: number): Promise<UglyServer>;
+}
+
+export function createNetFacade(
+  getBridge: () => NetBridge | undefined,
+  platform: Platform,
+  ensure: () => Promise<void>,
+): NetFacade {
+  const guard = (): NetBridge => {
+    if (platform === 'web') throw new NativeUnavailableError('net.connect');
+    const b = getBridge();
+    if (!b) throw new NativeUnavailableError('net.connect');
+    return b;
+  };
+  return {
+    connect(host, port) {
+      void ensure();
+      return guard().connect(host, port);
+    },
+    listen(port) {
+      void ensure();
+      return guard().listen(port);
+    },
+  };
+}

package/src/native/facades/process.ts

@@ -0,0 +1,37 @@
+import { NativeUnavailableError } from '../protocol.js';
+import type { Platform } from '../contract-meta.js';
+import type { SpawnOpts } from '../contract.js';
+
+export interface UglyProcess {
+  onStdout(cb: (chunk: string) => void): void;
+  onStderr(cb: (chunk: string) => void): void;
+  onExit(cb: (code: number | null) => void): void;
+  onError(cb: (err: string) => void): void;
+  write(data: string): void;
+  closeStdin(): void;
+  kill(signal?: string): void;
+}
+
+interface ProcessBridge {
+  spawn(cmd: string, args: string[], opts?: SpawnOpts): UglyProcess;
+}
+
+export interface ProcessFacade {
+  spawn(cmd: string, args: string[], opts?: SpawnOpts): UglyProcess;
+}
+
+export function createProcessFacade(
+  getBridge: () => ProcessBridge | undefined,
+  platform: Platform,
+  ensure: () => Promise<void>,
+): ProcessFacade {
+  return {
+    spawn(cmd, args, opts) {
+      if (platform !== 'desktop') throw new NativeUnavailableError('process.spawn');
+      void ensure(); // fire the permission check; the desktop daemon also enforces
+      const bridge = getBridge();
+      if (!bridge) throw new NativeUnavailableError('process.spawn');
+      return bridge.spawn(cmd, args, opts);
+    },
+  };
+}

package/src/native/facades/studio.ts

@@ -0,0 +1,73 @@
+import { NativeUnavailableError } from '../protocol.js';
+import type { NativePlatform } from '../protocol.js';
+import type { Platform } from '../contract-meta.js';
+import type { UpdateStatus } from '../contract.js';
+
+export interface StudioFacade {
+  window: {
+    minimize(): Promise<void>;
+    maximizeToggle(): Promise<boolean>;
+    close(): Promise<void>;
+    isMaximized(): Promise<boolean>;
+  };
+  fullscreen: { toggle(): Promise<boolean>; is(): Promise<boolean> };
+  zoom: { get(): Promise<number>; set(level: number): Promise<void> };
+  update: {
+    check(): Promise<UpdateStatus>;
+    download(): Promise<UpdateStatus>;
+    install(): Promise<void>;
+    getStatus(): Promise<UpdateStatus>;
+  };
+  dialog: { openDirectory(): Promise<string | null> };
+  revealInFolder(path: string): Promise<void>;
+  app: { version(): Promise<string>; platform(): NativePlatform };
+  openProjectInNewWindow(path: string): Promise<void>;
+}
+
+type StudioBridge = Partial<{
+  window: StudioFacade['window'];
+  fullscreen: StudioFacade['fullscreen'];
+  zoom: StudioFacade['zoom'];
+  update: StudioFacade['update'];
+  dialog: StudioFacade['dialog'];
+  revealInFolder: (p: string) => Promise<void>;
+  getAppVersion: () => Promise<string>;
+  openProjectInNewWindow: (p: string) => Promise<void>;
+}>;
+
+export function createStudioFacade(getBridge: () => StudioBridge | undefined, platform: Platform): StudioFacade {
+  const b = () => getBridge();
+  const noop = async (): Promise<void> => {};
+  const unavailable = (ch: string): never => {
+    throw new NativeUnavailableError(ch);
+  };
+  return {
+    window: {
+      minimize: async () => (b()?.window ? b()!.window!.minimize() : noop()),
+      maximizeToggle: async () => (b()?.window ? b()!.window!.maximizeToggle() : false),
+      close: async () => (b()?.window ? b()!.window!.close() : noop()),
+      isMaximized: async () => (b()?.window ? b()!.window!.isMaximized() : false),
+    },
+    fullscreen: {
+      toggle: async () => (b()?.fullscreen ? b()!.fullscreen!.toggle() : false),
+      is: async () => (b()?.fullscreen ? b()!.fullscreen!.is() : false),
+    },
+    zoom: {
+      get: async () => (b()?.zoom ? b()!.zoom!.get() : 0),
+      set: async (l) => (b()?.zoom ? b()!.zoom!.set(l) : noop()),
+    },
+    update: {
+      check: async () => (b()?.update ? b()!.update!.check() : unavailable('studio.update.check')),
+      download: async () => (b()?.update ? b()!.update!.download() : unavailable('studio.update.download')),
+      install: async () => (b()?.update ? b()!.update!.install() : unavailable('studio.update.install')),
+      getStatus: async () => (b()?.update ? b()!.update!.getStatus() : unavailable('studio.update.getStatus')),
+    },
+    dialog: { openDirectory: async () => (b()?.dialog ? b()!.dialog!.openDirectory() : null) },
+    revealInFolder: async (p) => (b()?.revealInFolder ? b()!.revealInFolder!(p) : unavailable('studio.revealInFolder')),
+    app: {
+      version: async () => (b()?.getAppVersion ? b()!.getAppVersion!() : ''),
+      platform: () => platform as NativePlatform,
+    },
+    openProjectInNewWindow: async (p) => (b()?.openProjectInNewWindow ? b()!.openProjectInNewWindow!(p) : noop()),
+  };
+}

package/src/native/index.ts

@@ -1,7 +1,28 @@
 export type {
-  NativeContract, Channel, NativeEvent, PayloadOf, ResultOf, DataOf, WorkoutLAState, CardioLAState,
+  NativeContract,
+  Channel,
+  NativeEvent,
+  PayloadOf,
+  ResultOf,
+  DataOf,
+  Namespace,
+  WorkoutLAState,
+  CardioLAState,
+  HostDirent,
+  HostStat,
+  UpdateStatus,
+  GrantState,
+  SpawnOpts,
+  SafeAreaInsets,
 } from './contract.js';
+export { namespaceOf } from './contract.js';
+export type { Platform, Fallback } from './contract-meta.js';
+export { CHANNEL_FALLBACK, NAMESPACES, fallbackFor } from './contract-meta.js';
 export type { NativePlatform, UglyNative } from './protocol.js';
-export { NativeUnavailableError } from './protocol.js';
-export { native, nativePlatform, isNativeAvailable } from './wrapper.js';
+export { NativeUnavailableError, PermissionDeniedError } from './protocol.js';
 export { installUglyNative } from './install.js';
+export { native, permissions, nativePlatform, isNativeAvailable } from './wrapper.js';
+export type { PermissionsFacade } from './permissions.js';
+export type { UglyProcess } from './facades/process.js';
+export type { UglySocket, UglyServer } from './facades/net.js';
+export type { StudioFacade } from './facades/studio.js';

package/src/native/install.test.ts

@@ -1,3 +1,4 @@
+// @vitest-environment jsdom
 import { describe, it, expect, vi } from 'vitest';
 import { buildUglyNative } from './install';
 
@@ -56,6 +57,13 @@ describe('buildUglyNative', () => {
     await expect(p).resolves.toBeNull();
   });
 
+  it('web platform routes clipboard.read through the web-adapter', async () => {
+    (navigator as unknown as { clipboard: unknown }).clipboard = { readText: async () => 'zz' };
+    const n = buildUglyNative(fakeWin({}));
+    expect(n.platform).toBe('web');
+    expect(await n.invoke('clipboard.read', undefined)).toEqual({ text: 'zz' });
+  });
+
   it('delivers events to subscribers', () => {
     const win = fakeWin({});
     const n = buildUglyNative(win);

package/src/native/install.ts

@@ -1,7 +1,6 @@
 import type { Channel, NativeEvent, PayloadOf, ResultOf, DataOf } from './contract.js';
-import { CHANNEL_WEB_FALLBACK } from './contract.js';
 import type { UglyNative, UglyNativeWindow } from './protocol.js';
-import { NativeUnavailableError } from './protocol.js';
+import { webInvoke } from './web-adapter.js';
 
 type WinLike = UglyNativeWindow & {
   addEventListener(type: string, cb: (e: unknown) => void): void;
@@ -10,6 +9,16 @@ type WinLike = UglyNativeWindow & {
 };
 
 export function buildUglyNative(win: WinLike): UglyNative {
+  // Native→web event bus: dispatch a uniform CustomEvent the subscriber reads.
+  const emit = <E extends NativeEvent>(event: E, data: DataOf<E>): void => {
+    const detail = { event, data };
+    const ev =
+      typeof CustomEvent === 'function'
+        ? new CustomEvent('uglyNative', { detail })
+        : ({ type: 'uglyNative', detail } as unknown as Event);
+    win.dispatchEvent(ev);
+  };
+
   // ── invoke transport (priority: desktop -> ios -> android -> web) ──
   let platform: UglyNative['platform'];
   let rawInvoke: (channel: string, payload: unknown) => Promise<unknown>;
@@ -44,12 +53,7 @@ export function buildUglyNative(win: WinLike): UglyNative {
       });
   } else {
     platform = 'web';
-    rawInvoke = (channel) => {
-      if (CHANNEL_WEB_FALLBACK[channel as Channel] === 'throw') {
-        return Promise.reject(new NativeUnavailableError(channel));
-      }
-      return Promise.resolve(undefined);
-    };
+    rawInvoke = (channel, payload) => webInvoke(channel as Channel, payload, emit);
   }
 
   // ── events: single 'uglyNative' CustomEvent carrying {event, data} ──

package/src/native/permissions.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createPermissions } from './permissions';
+import { PermissionDeniedError } from './protocol';
+
+// A fake transport that models grants accumulating via permissions.request.
+function fakeInvoke() {
+  const granted: Record<string, string> = {};
+  return vi.fn(async (channel: string, payload: unknown) => {
+    if (channel === 'permissions.request') {
+      const grants = (payload as { grants: Record<string, string | boolean> }).grants;
+      for (const [k, v] of Object.entries(grants)) granted[k] = v === true ? 'granted' : String(v);
+      return { granted: { ...granted } };
+    }
+    if (channel === 'permissions.query') return { granted: { ...granted } };
+    if (channel === 'permissions.revoke') {
+      delete granted[(payload as { namespace: string }).namespace];
+      return undefined;
+    }
+    return undefined;
+  });
+}
+
+describe('permissions facade', () => {
+  it('ensure throws for ungranted daemon namespace, passes after grant', async () => {
+    const invoke = fakeInvoke();
+    const perms = createPermissions(invoke, 'desktop');
+    await expect(perms.ensure('fs')).rejects.toBeInstanceOf(PermissionDeniedError);
+    await perms.request({ fs: 'scoped' });
+    await expect(perms.ensure('fs')).resolves.toBeUndefined();
+  });
+  it('ensure is a no-op for app namespaces (gps)', async () => {
+    const invoke = fakeInvoke();
+    const perms = createPermissions(invoke, 'ios');
+    await expect(perms.ensure('gps')).resolves.toBeUndefined();
+    expect(invoke).not.toHaveBeenCalled();
+  });
+  it('daemon namespace on web always throws', async () => {
+    const invoke = fakeInvoke();
+    const perms = createPermissions(invoke, 'web');
+    await expect(perms.ensure('secrets')).rejects.toBeInstanceOf(PermissionDeniedError);
+  });
+});

package/src/native/permissions.ts

@@ -0,0 +1,53 @@
+import type { Namespace, GrantState } from './contract.js';
+import type { Platform } from './contract-meta.js';
+import { PermissionDeniedError } from './protocol.js';
+
+// Namespaces gated by explicit grants (daemon capabilities). OS-backed and app
+// namespaces are not pre-gated here (the OS prompts at call time).
+const GATED: ReadonlySet<Namespace> = new Set<Namespace>([
+  'fs',
+  'secrets',
+  'serve',
+  'workers',
+  'net',
+  'process',
+]);
+
+type Invoke = (channel: string, payload: unknown) => Promise<unknown>;
+
+export interface PermissionsFacade {
+  request(grants: Partial<Record<Namespace, GrantState | boolean>>): Promise<Record<string, GrantState>>;
+  query(): Promise<Record<string, GrantState>>;
+  revoke(namespace: Namespace): Promise<void>;
+  ensure(namespace: Namespace): Promise<void>;
+}
+
+export function createPermissions(invoke: Invoke, platform: Platform): PermissionsFacade {
+  const cache = new Map<Namespace, GrantState>();
+  const facade: PermissionsFacade = {
+    async request(grants) {
+      const res = (await invoke('permissions.request', { grants })) as { granted: Record<string, GrantState> };
+      for (const [k, v] of Object.entries(res.granted)) cache.set(k as Namespace, v);
+      return res.granted;
+    },
+    async query() {
+      const res = (await invoke('permissions.query', undefined)) as { granted: Record<string, GrantState> };
+      for (const [k, v] of Object.entries(res.granted)) cache.set(k as Namespace, v);
+      return res.granted;
+    },
+    async revoke(namespace) {
+      await invoke('permissions.revoke', { namespace });
+      cache.delete(namespace);
+    },
+    async ensure(namespace) {
+      if (!GATED.has(namespace)) return;
+      if (platform === 'web') throw new PermissionDeniedError(namespace);
+      const cached = cache.get(namespace);
+      if (cached && cached !== 'denied' && cached !== 'prompt') return;
+      const granted = await facade.query();
+      const state = granted[namespace];
+      if (!state || state === 'denied' || state === 'prompt') throw new PermissionDeniedError(namespace);
+    },
+  };
+  return facade;
+}

package/src/native/protocol.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import { PermissionDeniedError, NativeUnavailableError } from './protocol';
+
+describe('protocol errors', () => {
+  it('PermissionDeniedError carries the namespace', () => {
+    const e = new PermissionDeniedError('fs');
+    expect(e).toBeInstanceOf(Error);
+    expect(e.namespace).toBe('fs');
+    expect(e.message).toContain('fs');
+  });
+  it('NativeUnavailableError carries the channel', () => {
+    const e = new NativeUnavailableError('process.spawn');
+    expect(e.message).toContain('process.spawn');
+  });
+});

package/src/native/protocol.ts

@@ -1,4 +1,4 @@
-import type { Channel, NativeEvent, PayloadOf, ResultOf, DataOf } from './contract.js';
+import type { Channel, NativeEvent, PayloadOf, ResultOf, DataOf, Namespace } from './contract.js';
 
 export type NativePlatform = 'ios' | 'android' | 'desktop' | 'web';
 
@@ -9,6 +9,15 @@ export class NativeUnavailableError extends Error {
   }
 }
 
+export class PermissionDeniedError extends Error {
+  readonly namespace: Namespace;
+  constructor(namespace: Namespace) {
+    super(`uglyNative.${namespace}.* requires the "${namespace}" permission (not granted)`);
+    this.name = 'PermissionDeniedError';
+    this.namespace = namespace;
+  }
+}
+
 export interface UglyNative {
   readonly platform: NativePlatform;
   invoke<C extends Channel>(channel: C, payload: PayloadOf<C>): Promise<ResultOf<C>>;

package/src/native/web-adapter.test.ts

@@ -0,0 +1,27 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { webInvoke } from './web-adapter';
+import { NativeUnavailableError } from './protocol';
+
+describe('web-adapter', () => {
+  beforeEach(() => {
+    (navigator as unknown as { clipboard: unknown }).clipboard = {
+      writeText: vi.fn().mockResolvedValue(undefined),
+      readText: vi.fn().mockResolvedValue('hi'),
+    };
+  });
+  it('clipboard.write delegates to navigator.clipboard.writeText', async () => {
+    await webInvoke('clipboard.write', { text: 'yo' }, () => {});
+    expect((navigator.clipboard as { writeText: ReturnType<typeof vi.fn> }).writeText).toHaveBeenCalledWith('yo');
+  });
+  it('clipboard.read returns navigator.clipboard.readText', async () => {
+    const r = await webInvoke('clipboard.read', undefined, () => {});
+    expect(r).toEqual({ text: 'hi' });
+  });
+  it('fs.readFile throws NativeUnavailableError on web', async () => {
+    await expect(webInvoke('fs.readFile', { path: '/x' }, () => {})).rejects.toBeInstanceOf(NativeUnavailableError);
+  });
+  it('liveActivity.endWorkout is a silent noop-ish resolve (no throw)', async () => {
+    await expect(webInvoke('liveActivity.endWorkout', undefined, () => {})).resolves.toBeUndefined();
+  });
+});

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' });
+  });
 });