@runappsai/sdk 0.5.0 → 0.6.1

package/src/idb-sync/remote.ts

@@ -0,0 +1,59 @@
+// idb-sync/remote.ts — the sync engine's storage, over the files API.
+//
+// Shards are plain JSON files in the user's file space for the app, so
+// they share its quota, billing and deletion with everything else the
+// app stores for that user. Conditional reads (304) and writes (412 /
+// 409) come from the files API, which checks them against the store.
+
+import type { FilesService } from "../files.js";
+import type { APIError } from "../errors.js";
+import type { SyncRemote } from "./engine.js";
+
+export class FilesRemote implements SyncRemote {
+  constructor(private readonly files: FilesService) {}
+
+  async list(prefix: string): Promise<{ path: string; etag: string }[]> {
+    const out: { path: string; etag: string }[] = [];
+    let cursor: string | undefined;
+    do {
+      const page = await this.files.list({ prefix, limit: 1000, ...(cursor ? { cursor } : {}) });
+      for (const f of page.files) if (f.etag) out.push({ path: f.path, etag: f.etag });
+      cursor = page.next_cursor;
+    } while (cursor);
+    return out;
+  }
+
+  async getJSON(path: string, ifNoneMatch?: string) {
+    const r = await this.files.readJSON(path, ifNoneMatch ? { ifNoneMatch } : undefined);
+    if (r.notModified) return { status: "unchanged" as const };
+    if (r.value === undefined) return { status: "missing" as const };
+    return { status: "ok" as const, value: r.value, etag: r.etag ?? "" };
+  }
+
+  async putJSON(path: string, value: unknown, cond: { ifMatch?: string; ifNoneMatch?: boolean }) {
+    try {
+      const obj = await this.files.put(path, JSON.stringify(value), {
+        contentType: "application/json",
+        ...(cond.ifMatch ? { ifMatch: cond.ifMatch } : {}),
+        ...(cond.ifNoneMatch ? { ifNoneMatch: true } : {}),
+      });
+      return { status: "ok" as const, etag: obj.etag ?? "", serverTime: obj.last_modified ? Date.parse(obj.last_modified) : undefined };
+    } catch (e) {
+      const code = (e as APIError).statusCode;
+      if (code === 412 || code === 409) return { status: "conflict" as const };
+      throw e;
+    }
+  }
+
+  async putBlob(path: string, blob: Blob): Promise<void> {
+    try {
+      await this.files.put(path, blob, { contentType: blob.type || "application/octet-stream", ifNoneMatch: true });
+    } catch (e) {
+      if ((e as APIError).statusCode !== 409) throw e; // already stored: same bytes, same name
+    }
+  }
+
+  getBlob(path: string): Promise<Blob> {
+    return this.files.get(path);
+  }
+}

package/src/index.ts

@@ -34,6 +34,19 @@ export {
   type ActivitySnapshot,
 } from "./activity-tracker.js";
 export { BrowserAuth, type BrowserAuthOptions, type BrowserUser } from "./browser-auth.js";
+// IndexedDB sync — on by default in apps; exported for status UIs and
+// for tests that drive the engine with their own storage.
+export {
+  SyncEngine,
+  FilesRemote,
+  installIndexedDBHook,
+  type SyncOptions,
+  type SyncState,
+  type DbChange,
+  type SyncRemote,
+  type SyncDeps,
+} from "./idb-sync/index.js";
+export type { SyncStateEvent, DbChangeEvent } from "./events.js";
 export { APIError } from "./errors.js";
 export type { Usage } from "./types.js";
 

package/src/models.ts

@@ -105,7 +105,7 @@ export class ModelsService {
 
   /**
    * List models available on the gateway. Pass `{ capability: "..." }` to
-   * filter server-side.
+   * filter server-side. Needs no sign-in or key.
    */
   async list(
     opts: ModelListOptions = {},
@@ -115,7 +115,9 @@ export class ModelsService {
     if (opts.capability) {
       path += `?capability=${encodeURIComponent(opts.capability)}`;
     }
-    const resp = await this.transport.getJSON<{ data: Model[] }>(path, init);
+    // The catalogue is public: no token, so listing models never sends a
+    // signed-out user to sign in.
+    const resp = await this.transport.getPublicJSON<{ data: Model[] }>(path, init);
     return resp.data;
   }
 }

package/src/transport.ts

@@ -145,24 +145,47 @@ export class Transport {
     return (await resp.json()) as T;
   }
 
+  /** GET a public path: no Authorization header, so it never fetches a
+   *  token — in browser sign-in mode that would send a signed-out user to
+   *  the sign-in page just to read the model catalogue. */
+  async getPublicJSON<T>(
+    path: string,
+    init?: { signal?: AbortSignal },
+  ): Promise<T> {
+    const resp = await this.fetchImpl(this.baseURL + path, {
+      method: "GET",
+      cache: "no-store",
+      ...(init?.signal ? { signal: init.signal } : {}),
+    });
+    if (!resp.ok) {
+      throw await this.parseError(resp);
+    }
+    return (await resp.json()) as T;
+  }
+
   /** GET path; return raw bytes + content-type (for video/audio downloads)
    *  and the ETag of those bytes, when the server sends one. */
   async getRaw(
     path: string,
-    init?: { signal?: AbortSignal },
-  ): Promise<{ data: Uint8Array; contentType: string; etag?: string }> {
-    const resp = await this.fetchWithAuthRetry(path, async () => ({
-      method: "GET",
-      headers: await this.authHeaders(),
-      signal: init?.signal,
-    }));
+    init?: { signal?: AbortSignal; ifNoneMatch?: string },
+  ): Promise<{ data: Uint8Array; contentType: string; etag?: string; notModified?: boolean; serverTime?: number }> {
+    const resp = await this.fetchWithAuthRetry(path, async () => {
+      const headers: Record<string, string> = await this.authHeaders();
+      if (init?.ifNoneMatch) headers["If-None-Match"] = `"${init.ifNoneMatch.replace(/"/g, "")}"`;
+      return { method: "GET", headers, signal: init?.signal };
+    });
+    const serverTime = parseServerDate(resp.headers.get("date"));
+    if (resp.status === 304) {
+      const etag = (resp.headers.get("etag") ?? "").replace(/"/g, "") || init?.ifNoneMatch;
+      return { data: new Uint8Array(0), contentType: "", etag, notModified: true, serverTime };
+    }
     if (!resp.ok) {
       throw await this.parseError(resp);
     }
     const buf = new Uint8Array(await resp.arrayBuffer());
     const contentType = resp.headers.get("content-type") ?? "";
     const etag = (resp.headers.get("etag") ?? "").replace(/"/g, "") || undefined;
-    return { data: buf, contentType, etag };
+    return { data: buf, contentType, etag, serverTime };
   }
 
   /** POST a multipart/form-data body. Used by audio.transcribe and image.edit. */
@@ -290,3 +313,10 @@ export class Transport {
     return new APIError(resp.status, type, message);
   }
 }
+
+/** The server's clock from a Date header, as ms since epoch. */
+export function parseServerDate(h: string | null): number | undefined {
+  if (!h) return undefined;
+  const t = Date.parse(h);
+  return Number.isNaN(t) ? undefined : t;
+}