ink-framework-lightos 0.1.0-alpha.12 → 0.1.0-alpha.14

package/ink-native.json

@@ -9,6 +9,15 @@
     ],
     "src/push.ts": [
       "light-sdk-push"
+    ],
+    "src/push-hooks.ts": [
+      "light-sdk-push"
+    ],
+    "src/push-delivery.ts": [
+      "light-sdk-push"
+    ],
+    "src/tool-manager.ts": [
+      "light-sdk-tool-manager"
     ]
   }
 }

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "ink-framework-lightos",
-  "version": "0.1.0-alpha.12",
+  "version": "0.1.0-alpha.14",
   "exports": {
     ".": "./src/index.ts",
     "./ringtone": "./src/ringtone.ts",
-    "./push": "./src/push.ts"
+    "./push": "./src/push.ts",
+    "./push/delivery": "./src/push-delivery.ts",
+    "./tool-manager": "./src/tool-manager.ts"
   },
   "peerDependencies": {
-    "ink": "npm:ink-framework@0.1.0-alpha.12",
+    "ink": "npm:ink-framework@0.1.0-alpha.14",
     "react": "19.2.8"
   },
   "license": "MIT",
@@ -19,6 +21,7 @@
   "files": [
     "src",
     "*.json",
-    "*.ts"
+    "*.ts",
+    "*.md"
   ]
 }

package/src/push-delivery.ts

@@ -0,0 +1,44 @@
+import { callNative, NativeError } from "ink/native";
+
+export interface PushMessage {
+  id: string;
+  groupKey: string;
+  title: string;
+  body: string;
+  route: string;
+  receivedAt: number;
+}
+export function fields(value: unknown) {
+  if (typeof value !== "object" || value === null) throw new NativeError("protocol", "Invalid push state");
+  return {
+    text(name: string) {
+      const field: unknown = Reflect.get(value, name);
+      if (typeof field !== "string") throw new NativeError("protocol", `Invalid push ${name}`);
+      return field;
+    },
+    time(name: string) {
+      const field: unknown = Reflect.get(value, name);
+      if (typeof field !== "number" || !Number.isSafeInteger(field) || field < 0) throw new NativeError("protocol", `Invalid push ${name}`);
+      return field;
+    },
+  };
+}
+export function decodeMessage(value: unknown): PushMessage {
+  const item = fields(value);
+  return { id: item.text("id"), groupKey: item.text("groupKey"), title: item.text("title"), body: item.text("body"), route: item.text("route"), receivedAt: item.time("receivedAtMs") };
+}
+export interface PushDelivery { messages: readonly PushMessage[]; cancelled: readonly string[] }
+export function decodePushDelivery(value: unknown): PushDelivery {
+  if (typeof value !== "object" || value === null || !("messages" in value) || !Array.isArray(value.messages)
+    || !("cancelled" in value) || !Array.isArray(value.cancelled)) throw new TypeError("Invalid push delivery");
+  return {
+    messages: value.messages.map(decodeMessage),
+    cancelled: value.cancelled.map((key: unknown) => {
+      if (typeof key !== "string") throw new TypeError("Invalid cancelled push group");
+      return key;
+    }),
+  };
+}
+export async function setPushTask(task: { id: string } | null): Promise<void> {
+  await callNative("background", "set-push-task", { task: task?.id ?? null });
+}

package/src/push-hooks.ts

@@ -0,0 +1,81 @@
+import { fields, decodeMessage, type PushMessage } from "./push-delivery";
+import { useEffect, useMemo, useRef, useState } from "ink/internal/react";
+import { NativeError } from "ink/native";
+import { attachNativeController } from "ink/native/controller";
+
+export interface PushState {
+  status: "idle" | "registering" | "synchronising" | "ready" | "error";
+  endpoint: string;
+  registeredAt: number;
+  openedKey: string;
+  messages: readonly PushMessage[];
+  error: Error | null;
+}
+export interface PushRegistration {
+  url: string;
+  bearerToken?: string;
+  encryptionKey?: string;
+}
+export interface PushOptions {
+  foregroundGroup?: string | null;
+}
+const initial: PushState = { status: "idle", endpoint: "", registeredAt: 0, openedKey: "", messages: [], error: null };
+function decode(value: unknown): PushState {
+  const field = fields(value);
+  const status = field.text("status");
+  if (status !== "idle" && status !== "registering" && status !== "synchronising" && status !== "ready" && status !== "error") throw new NativeError("protocol", "Invalid push status");
+  if (typeof value !== "object" || value === null || !("messages" in value) || !Array.isArray(value.messages)) throw new NativeError("protocol", "Invalid push messages");
+  let error: Error | null = null;
+  if (status === "error") {
+    if (!("error" in value) || typeof value.error !== "object" || value.error === null) throw new NativeError("protocol", "Invalid push error");
+    const detail = fields(value.error);
+    error = new NativeError(detail.text("kind"), detail.text("message"), "retryable" in value.error && value.error.retryable === true);
+  }
+  return { status, endpoint: field.text("endpoint"), registeredAt: field.time("registeredAtMs"), openedKey: field.text("openedKey"), error,
+    messages: value.messages.map(decodeMessage) };
+}
+
+export function usePush({ foregroundGroup = null }: PushOptions = {}) {
+  const [state, setState] = useState(initial);
+  const [ready, setReady] = useState(false);
+  const controller = useRef<ReturnType<typeof attachNativeController> | null>(null);
+  useEffect(() => {
+    setState(initial);
+    setReady(false);
+    const fail = (error: unknown) => setState({ ...initial, status: "error", error: error instanceof Error ? error : new Error(String(error)) });
+    const attachment = attachNativeController("notifications", { kind: "light-push" }, value => {
+      try { setState(decode(value)); } catch (error) { fail(error); }
+    });
+    controller.current = attachment;
+    void attachment.ready.then(() => {
+      if (controller.current === attachment) setReady(true);
+    }, error => { if (controller.current === attachment) fail(error); });
+    return () => {
+      controller.current = null;
+      void attachment.dispose().catch(error => console.error("Could not release push inbox", error));
+    };
+  }, []);
+  useEffect(() => {
+    const attachment = controller.current;
+    if (!attachment) return;
+    let active = true;
+    void attachment.call("foreground", { groupKey: foregroundGroup }).catch(error => {
+      if (active) setState(current => ({ ...current, status: "error", error: error instanceof Error ? error : new Error(String(error)) }));
+    });
+    return () => { active = false; };
+  }, [foregroundGroup]);
+  const commands = useMemo(() => {
+    const call = async (operation: string, payload: unknown = {}) => {
+      if (!controller.current) throw new NativeError("unavailable", "Push inbox is not attached");
+      await controller.current.call(operation, payload);
+    };
+    return {
+      register: (options: PushRegistration) => call("register", options),
+      retry: () => call("retry"), unregister: () => call("unregister"),
+      dismiss: (groupKey: string) => call("dismiss", { groupKey }), clear: () => call("clear"),
+      notifyForeground: (groupKey: string) => call("foreground-message", { groupKey }),
+    };
+  }, []);
+  return { state, ready, ...commands };
+}
+

package/src/push.ts

@@ -1,123 +1,2 @@
-import { useEffect, useMemo, useRef, useState } from "react";
-import { callNative, NativeError } from "ink/native";
-import { attachNativeController } from "ink/native/controller";
-
-export interface PushMessage {
-  id: string;
-  groupKey: string;
-  title: string;
-  body: string;
-  route: string;
-  receivedAt: number;
-}
-export interface PushState {
-  status: "idle" | "registering" | "synchronising" | "ready" | "error";
-  endpoint: string;
-  registeredAt: number;
-  openedKey: string;
-  messages: readonly PushMessage[];
-  error: Error | null;
-}
-export interface PushRegistration {
-  url: string;
-  bearerToken?: string;
-  encryptionKey?: string;
-  fetchOnWake?: boolean;
-}
-export interface PushOptions {
-  foregroundGroup?: string | null;
-}
-const initial: PushState = { status: "idle", endpoint: "", registeredAt: 0, openedKey: "", messages: [], error: null };
-function fields(value: unknown) {
-  if (typeof value !== "object" || value === null) throw new NativeError("protocol", "Invalid push state");
-  return {
-    text(name: string) {
-      const field: unknown = Reflect.get(value, name);
-      if (typeof field !== "string") throw new NativeError("protocol", `Invalid push ${name}`);
-      return field;
-    },
-    time(name: string) {
-      const field: unknown = Reflect.get(value, name);
-      if (typeof field !== "number" || !Number.isSafeInteger(field) || field < 0) throw new NativeError("protocol", `Invalid push ${name}`);
-      return field;
-    },
-  };
-}
-function decodeMessage(value: unknown): PushMessage {
-  const item = fields(value);
-  return { id: item.text("id"), groupKey: item.text("groupKey"), title: item.text("title"), body: item.text("body"), route: item.text("route"), receivedAt: item.time("receivedAtMs") };
-}
-function decode(value: unknown): PushState {
-  const field = fields(value);
-  const status = field.text("status");
-  if (status !== "idle" && status !== "registering" && status !== "synchronising" && status !== "ready" && status !== "error") throw new NativeError("protocol", "Invalid push status");
-  if (typeof value !== "object" || value === null || !("messages" in value) || !Array.isArray(value.messages)) throw new NativeError("protocol", "Invalid push messages");
-  let error: Error | null = null;
-  if (status === "error") {
-    if (!("error" in value) || typeof value.error !== "object" || value.error === null) throw new NativeError("protocol", "Invalid push error");
-    const detail = fields(value.error);
-    error = new NativeError(detail.text("kind"), detail.text("message"), "retryable" in value.error && value.error.retryable === true);
-  }
-  return { status, endpoint: field.text("endpoint"), registeredAt: field.time("registeredAtMs"), openedKey: field.text("openedKey"), error,
-    messages: value.messages.map(decodeMessage) };
-}
-
-export function usePush({ foregroundGroup = null }: PushOptions = {}) {
-  const [state, setState] = useState(initial);
-  const [ready, setReady] = useState(false);
-  const controller = useRef<ReturnType<typeof attachNativeController> | null>(null);
-  useEffect(() => {
-    setState(initial);
-    setReady(false);
-    const fail = (error: unknown) => setState({ ...initial, status: "error", error: error instanceof Error ? error : new Error(String(error)) });
-    const attachment = attachNativeController("notifications", { kind: "light-push" }, value => {
-      try { setState(decode(value)); } catch (error) { fail(error); }
-    });
-    controller.current = attachment;
-    void attachment.ready.then(() => {
-      if (controller.current === attachment) setReady(true);
-    }, error => { if (controller.current === attachment) fail(error); });
-    return () => {
-      controller.current = null;
-      void attachment.dispose().catch(error => console.error("Could not release push inbox", error));
-    };
-  }, []);
-  useEffect(() => {
-    const attachment = controller.current;
-    if (!attachment) return;
-    let active = true;
-    void attachment.call("foreground", { groupKey: foregroundGroup }).catch(error => {
-      if (active) setState(current => ({ ...current, status: "error", error: error instanceof Error ? error : new Error(String(error)) }));
-    });
-    return () => { active = false; };
-  }, [foregroundGroup]);
-  const commands = useMemo(() => {
-    const call = async (operation: string, payload: unknown = {}) => {
-      if (!controller.current) throw new NativeError("unavailable", "Push inbox is not attached");
-      await controller.current.call(operation, payload);
-    };
-    return {
-      register: (options: PushRegistration) => call("register", options),
-      retry: () => call("retry"), unregister: () => call("unregister"),
-      dismiss: (groupKey: string) => call("dismiss", { groupKey }), clear: () => call("clear"),
-      notifyForeground: (groupKey: string) => call("foreground-message", { groupKey }),
-    };
-  }, []);
-  return { state, ready, ...commands };
-}
-
-export interface PushDelivery { messages: readonly PushMessage[]; cancelled: readonly string[] }
-export function decodePushDelivery(value: unknown): PushDelivery {
-  if (typeof value !== "object" || value === null || !("messages" in value) || !Array.isArray(value.messages)
-    || !("cancelled" in value) || !Array.isArray(value.cancelled)) throw new TypeError("Invalid push delivery");
-  return {
-    messages: value.messages.map(decodeMessage),
-    cancelled: value.cancelled.map((key: unknown) => {
-      if (typeof key !== "string") throw new TypeError("Invalid cancelled push group");
-      return key;
-    }),
-  };
-}
-export async function setPushTask(task: { id: string } | null): Promise<void> {
-  await callNative("background", "set-push-task", { task: task?.id ?? null });
-}
+export { usePush, type PushState, type PushRegistration, type PushOptions } from "./push-hooks";
+export { decodePushDelivery, setPushTask, type PushDelivery, type PushMessage } from "./push-delivery";

package/src/tool-manager.ts

@@ -0,0 +1,89 @@
+import { useEffect, useState } from "ink/internal/react";
+import { callNative, callNativeBytes, NativeError } from "ink/native";
+
+export interface SharedFile {
+  name: string;
+  path: string;
+  uri: string;
+  isFile: boolean;
+  size: number;
+  lastModified: number;
+}
+
+function decodeFiles(source: string): SharedFile[] {
+  const files: unknown = JSON.parse(source);
+  if (!Array.isArray(files)) throw new NativeError("protocol", "Invalid shared file list");
+  return files.map((file: unknown) => {
+    if (typeof file !== "object" || file === null
+      || !["name", "path", "uri"].every(key => typeof Reflect.get(file, key) === "string")
+      || typeof Reflect.get(file, "isFile") !== "boolean"
+      || !["size", "lastModified"].every(key => {
+        const value: unknown = Reflect.get(file, key);
+        return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+      })) throw new NativeError("protocol", "Invalid shared file");
+    return file as SharedFile;
+  });
+}
+
+export async function setSharedFilesTask(task: { id: string } | null): Promise<void> {
+  await callNative("background", "set-shared-files-task", { task: task?.id ?? null });
+}
+
+export const sharedFiles = {
+  async list(path = ""): Promise<SharedFile[]> {
+    return decodeFiles(await callNative("tool-manager", "list", { path }));
+  },
+  async exists(path: string): Promise<boolean> {
+    return await callNative("tool-manager", "exists", { path }) === "true";
+  },
+  async readBytes(path: string, options: { offset?: number; length?: number; signal?: AbortSignal } = {}): Promise<Uint8Array> {
+    if (options.offset !== undefined && (!Number.isSafeInteger(options.offset) || options.offset < 0)) throw new RangeError("Invalid shared file offset");
+    if (options.length !== undefined && (!Number.isSafeInteger(options.length) || options.length < 0 || options.length > 524_288)) throw new RangeError("Shared reads accept up to 512 KiB");
+    return (await callNativeBytes("tool-manager", "read", { path, offset: options.offset, length: options.length }, { signal: options.signal })).bytes;
+  },
+  async writeBytes(path: string, bytes: Uint8Array): Promise<void> {
+    await callNativeBytes("tool-manager", "write", { path }, { bytes });
+  },
+  async copyFrom(path: string, source: string, options: { signal?: AbortSignal } = {}): Promise<void> {
+    await callNative("tool-manager", "copy-from", { path, source }, { signal: options.signal, timeoutMs: 600_000 });
+  },
+  async readText(path: string): Promise<string> {
+    return await callNative("tool-manager", "read-text", { path });
+  },
+  async writeText(path: string, text: string): Promise<void> {
+    await callNative("tool-manager", "write-text", { path, text });
+  },
+  async remove(path: string): Promise<boolean> {
+    return await callNative("tool-manager", "remove", { path }) === "true";
+  },
+  async mkdir(path: string): Promise<void> {
+    await callNative("tool-manager", "mkdir", { path });
+  },
+};
+
+export function useSharedFiles(path = "") {
+  const [state, setState] = useState<{ files: SharedFile[]; loading: boolean; error: Error | null }>({
+    files: [], loading: true, error: null,
+  });
+  useEffect(() => {
+    const controller = new AbortController();
+    setState({ files: [], loading: true, error: null });
+    void (async () => {
+      let revision = -1;
+      while (!controller.signal.aborted) {
+        const next = Number(await callNative("tool-manager", "observe", { revision }, { signal: controller.signal }));
+        if (!Number.isSafeInteger(next) || next < 0) throw new NativeError("protocol", "Invalid shared file state");
+        if (next !== revision) {
+          const files = await sharedFiles.list(path);
+          if (!controller.signal.aborted) setState({ files, loading: false, error: null });
+        }
+        revision = next;
+      }
+    })().catch(error => {
+      if (!controller.signal.aborted) setState(current => ({ ...current, loading: false,
+        error: error instanceof Error ? error : new Error(String(error)) }));
+    });
+    return () => controller.abort();
+  }, [path]);
+  return state;
+}