ugly-app 0.1.620 → 0.1.621

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;
+    },
   },
 };