@spheredata/sdk 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spheredata/sdk",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "publishConfig": { "access": "public" },
   "description": "SPHERE client SDK — talks to the SPHERE backend (auth, metered agent, account).",
   "keywords": ["sphere", "spheredata", "sdk", "ai", "agent", "metering", "wallet", "synthetic-data"],

package/sphere-client.js

@@ -212,6 +212,31 @@ export function createSphere(opts = {}) {
     return `${base}?redirect_to=${encodeURIComponent(redirectTo)}`;
   }
 
+  // Complete a hosted OAuth flow: when the backend redirects back to a surface's
+  // `redirect_to`, it appends the tokens as query params
+  // (?access_token=…&refresh_token=…&expires_in=…). Parse them and persist a
+  // session, exactly as signIn would. Returns true if a session was established,
+  // false if no oauth tokens were present (so callers can no-op on a normal load).
+  // `input` may be a query string ("?a=b" or "a=b"), a URLSearchParams, or omitted
+  // to read globalThis.location.search. The user profile isn't in the redirect, so
+  // the bundle's user is null until the next getAccount().
+  function completeOAuth(input) {
+    const params =
+      input instanceof URLSearchParams ? input
+      : typeof input === "string" ? new URLSearchParams(input.replace(/^\?/, ""))
+      : (typeof globalThis !== "undefined" && globalThis.location)
+        ? new URLSearchParams(globalThis.location.search)
+        : new URLSearchParams();
+    const access_token = params.get("access_token");
+    if (!access_token) return false;
+    saveBundle(bundleFromAuthResponse({
+      access_token,
+      refresh_token: params.get("refresh_token"),
+      expires_in: params.get("expires_in"),
+    }));
+    return true;
+  }
+
   // --- AI -------------------------------------------------------------------
   // Ask the model through SPHERE. Metered to the user's wallet under this portal.
   async function ask(messages, { model, max_tokens } = {}) {
@@ -316,12 +341,114 @@ export function createSphere(opts = {}) {
     return data; // { ok:true, charged, op, bytes, cost_usd, balance_usd }
   }
 
+  // --- synthetic-dataset upload (direct-to-GCS via AgentDrive) --------------
+  // NODE / ELECTRON ONLY (CLI + desktop) — not the browser. Per file:
+  //   1. begin  → backend mints a GCS resumable-session URL (the AgentDrive
+  //               credential stays server-side; the client never sees it),
+  //   2. PUT bytes DIRECTLY to GCS (bytes never transit the SPHERE backend),
+  //   3. commit → backend finalizes the artifact.
+  // Large files (e.g. 1 GiB scrna.csv) stream from disk via fs.openAsBlob — never
+  // loaded whole into memory. fs/path are imported lazily so the SDK still imports
+  // cleanly in the browser (where upload isn't offered).
+  const CONTENT_TYPES = {
+    csv: "text/csv", tsv: "text/tab-separated-values",
+    parquet: "application/vnd.apache.parquet", json: "application/json",
+    txt: "text/plain", html: "text/html",
+  };
+  const guessType = (name) =>
+    CONTENT_TYPES[String(name).toLowerCase().split(".").pop()] || "application/octet-stream";
+
+  // Upload one file. `file` is { name?, path } (a local file, streamed) OR
+  // { name, body, size, contentType? } (a pre-read Blob/Buffer + byte length).
+  // Returns the AgentDrive artifact { id, path, url, size_bytes, hash, ... }.
+  async function uploadFile(dataset, file, defaultContentType) {
+    if (!dataset) throw new Error("uploadFile: dataset name required");
+    let { name, body, size } = file || {};
+    if (file?.path) {
+      // openAsBlob lives on node:fs (not node:fs/promises) — gives a streaming
+      // Blob backed by the file, so large files are never read into memory.
+      const { openAsBlob } = await import("node:fs");
+      const blob = await openAsBlob(file.path);
+      body = blob;
+      size = blob.size;
+      if (!name) name = (await import("node:path")).basename(file.path);
+    }
+    if (!name) throw new Error("uploadFile: file.name or file.path required");
+    if (!(size > 0)) throw new Error(`uploadFile: "${name}" has no readable bytes`);
+    const contentType = file?.contentType || defaultContentType || guessType(name);
+
+    const begin = await authedFetch(`${fnBase}/upload-begin${q}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ dataset, filename: name, content_type: contentType, size_bytes: size }),
+    });
+    const b = await begin.json().catch(() => ({}));
+    if (!begin.ok) throw new Error(b?.error || `upload-begin failed: ${begin.status}`);
+
+    // Direct PUT to the GCS session URL — NO Authorization header (the URL is the
+    // credential). `duplex` is required by undici for a streamed body; ignored for Blobs.
+    const put = await doFetch(b.upload_url, {
+      method: "PUT",
+      headers: { "Content-Type": contentType, "Content-Range": `bytes 0-${size - 1}/${size}` },
+      body,
+      duplex: "half",
+    });
+    if (put.status < 200 || put.status >= 300) {
+      throw new Error(`GCS upload failed for "${name}": ${put.status}`);
+    }
+
+    const commit = await authedFetch(`${fnBase}/upload-commit${q}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ upload_id: b.upload_id }),
+    });
+    const c = await commit.json().catch(() => ({}));
+    if (!commit.ok) throw new Error(c?.error || `upload-commit failed: ${commit.status}`);
+    return c.artifact;
+  }
+
+  // Upload a whole synthetic dataset (its files). `files` is an array of the per-file
+  // shapes above. Files upload sequentially; `onProgress({done,total,name,artifact})`
+  // fires after each. Returns { dataset, artifacts }.
+  async function uploadDataset(dataset, files, { onProgress, contentType } = {}) {
+    if (!dataset) throw new Error("uploadDataset: dataset name required");
+    if (!Array.isArray(files) || files.length === 0) {
+      throw new Error("uploadDataset: a non-empty files[] is required");
+    }
+    const artifacts = [];
+    for (let i = 0; i < files.length; i++) {
+      const art = await uploadFile(dataset, files[i], contentType);
+      artifacts.push(art);
+      if (onProgress) onProgress({ done: i + 1, total: files.length, name: files[i].name, artifact: art });
+    }
+    return { dataset, artifacts };
+  }
+
+  // List the datasets uploaded under this portal (shared catalog). Returns
+  // [{ dataset, file_count, total_bytes, updated_at, files:[{name,path,url,...}] }].
+  async function listDatasets() {
+    const r = await authedFetch(`${fnBase}/datasets${q}`, {});
+    const data = await r.json().catch(() => ({}));
+    if (!r.ok) throw new Error(data?.error || `datasets failed: ${r.status}`);
+    return data.datasets || [];
+  }
+
+  // List datasets across ALL portals/labs — the cross-lab marketplace. Each item
+  // carries its source `portal` plus the same shape as listDatasets().
+  async function listMarketplace() {
+    const r = await authedFetch(`${fnBase}/marketplace`, {});
+    const data = await r.json().catch(() => ({}));
+    if (!r.ok) throw new Error(data?.error || `marketplace failed: ${r.status}`);
+    return data.datasets || [];
+  }
+
   return {
     portal, appId, apiBase,
-    signUp, signIn, signOut, oauthUrl,
+    signUp, signIn, signOut, oauthUrl, completeOAuth,
     ask, streamAgent,
     getAccount, getBalance,
     listCredits, buyCredits, redeem, charge,
+    uploadFile, uploadDataset, listDatasets, listMarketplace,
     // NOTE: reflects token PRESENCE, not validity — a present-but-expired token
     // returns true here and is refreshed lazily on the next call.
     isSignedIn: () => !!loadBundle()?.access_token,