get-db9 0.6.0 → 0.6.1

package/dist/index.js

@@ -12,7 +12,7 @@ var Db9Error = class _Db9Error extends Error {
     let message;
     try {
       const body = await response.json();
-      message = body.message || response.statusText;
+      message = body.message || body.detail || body.error_description || body.error || response.statusText;
     } catch {
       message = response.statusText;
     }
@@ -183,17 +183,7 @@ var FileCredentialStore = class {
     const parsed = parseToml(content);
     const token = parsed["token"];
     if (typeof token !== "string") return null;
-    const creds = { token };
-    if (typeof parsed["is_anonymous"] === "boolean") {
-      creds.is_anonymous = parsed["is_anonymous"];
-    }
-    if (typeof parsed["anonymous_id"] === "string") {
-      creds.anonymous_id = parsed["anonymous_id"];
-    }
-    if (typeof parsed["anonymous_secret"] === "string") {
-      creds.anonymous_secret = parsed["anonymous_secret"];
-    }
-    return creds;
+    return { token };
   }
   async save(credentials) {
     const fs = await import("fs/promises");
@@ -214,15 +204,6 @@ var FileCredentialStore = class {
       if (err.code !== "ENOENT") throw err;
     }
     data["token"] = credentials.token;
-    if (credentials.is_anonymous !== void 0) {
-      data["is_anonymous"] = credentials.is_anonymous;
-    }
-    if (credentials.anonymous_id !== void 0) {
-      data["anonymous_id"] = credentials.anonymous_id;
-    }
-    if (credentials.anonymous_secret !== void 0) {
-      data["anonymous_secret"] = credentials.anonymous_secret;
-    }
     const toml = stringifyToml(
       data
     );
@@ -244,12 +225,7 @@ var MemoryCredentialStore = class {
     return this.credentials ? { ...this.credentials } : null;
   }
   async save(credentials) {
-    this.credentials = {
-      token: credentials.token,
-      is_anonymous: credentials.is_anonymous ?? this.credentials?.is_anonymous,
-      anonymous_id: credentials.anonymous_id ?? this.credentials?.anonymous_id,
-      anonymous_secret: credentials.anonymous_secret ?? this.credentials?.anonymous_secret
-    };
+    this.credentials = { token: credentials.token };
   }
   async clear() {
     this.credentials = null;
@@ -260,6 +236,7 @@ function defaultCredentialStore() {
 }
 
 // src/ws.ts
+import { createHash } from "crypto";
 var FsError = class extends Error {
   code;
   constructor(code, message) {
@@ -268,31 +245,28 @@ var FsError = class extends Error {
     this.code = code;
   }
 };
+var STREAMING_THRESHOLD = 1024 * 1024;
+var DEFAULT_CHUNK_SIZE = 64 * 1024;
 var nextId = 1;
 function nextRequestId() {
   return String(nextId++);
 }
 function toBase64(data) {
   const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(bytes).toString("base64");
-  }
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
+  return Buffer.from(bytes).toString("base64");
 }
 function fromBase64(b64) {
-  if (typeof Buffer !== "undefined") {
-    return new Uint8Array(Buffer.from(b64, "base64"));
-  }
-  const binary = atob(b64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
+  return new Uint8Array(Buffer.from(b64, "base64"));
+}
+function computeChecksum(data) {
+  const hash = createHash("sha256").update(data).digest("hex");
+  return `sha256:${hash}`;
+}
+function encodeBinaryFrame(streamId, chunk) {
+  const frame = Buffer.alloc(8 + chunk.length);
+  frame.writeBigUInt64BE(BigInt(streamId), 0);
+  frame.set(chunk, 8);
+  return frame;
 }
 var FsClient = class _FsClient {
   ws;
@@ -410,9 +384,17 @@ var FsClient = class _FsClient {
     }
     return fromBase64(content);
   }
-  /** Write (overwrite) a file. Returns bytes written. */
+  /**
+   * Write (overwrite) a file. Returns bytes written.
+   *
+   * Automatically uses streaming mode for files >= 1 MB to avoid base64
+   * overhead and bypass the 2 MB JSON frame limit.
+   */
   async writeFile(path, data) {
     const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data instanceof Uint8Array ? data : new Uint8Array(data);
+    if (bytes.byteLength >= STREAMING_THRESHOLD) {
+      return this.writeFileStreaming(path, bytes);
+    }
     const resp = await this.sendAndRecv({
       id: nextRequestId(),
       op: "write",
@@ -461,6 +443,61 @@ var FsClient = class _FsClient {
       this.ws.close();
     }
   }
+  // ── streaming internals ────────────────────────────────────────
+  /**
+   * Write a file using streaming mode (binary frames, no base64).
+   *
+   * Protocol:
+   * 1. Send streaming write request with file size
+   * 2. Receive ready response with stream_id and chunk_size
+   * 3. Send binary frames: [8-byte stream_id BE][chunk_data]
+   * 4. Send stream end with checksum
+   * 5. Receive final write confirmation
+   */
+  async writeFileStreaming(path, bytes) {
+    const requestId = nextRequestId();
+    const readyResp = await this.sendAndRecv({
+      id: requestId,
+      op: "write",
+      path,
+      streaming: true,
+      size: bytes.byteLength
+    });
+    this.expectOk(readyResp);
+    const ready = readyResp.data;
+    if (!ready?.ready) {
+      throw new FsError("PROTOCOL", "server not ready for streaming");
+    }
+    const streamId = ready.stream_id;
+    const chunkSize = ready.chunk_size > 0 ? ready.chunk_size : DEFAULT_CHUNK_SIZE;
+    try {
+      for (let offset = 0; offset < bytes.byteLength; offset += chunkSize) {
+        const chunk = bytes.subarray(offset, offset + chunkSize);
+        const frame = encodeBinaryFrame(streamId, chunk);
+        this.ws.send(frame);
+      }
+    } catch (err) {
+      this.tryAbortStream(streamId);
+      throw new FsError("CONNECTION_ERROR", `send chunk: ${err}`);
+    }
+    const checksum = computeChecksum(bytes);
+    const finalResp = await this.sendAndRecv({
+      id: requestId,
+      stream: "end",
+      stream_id: streamId,
+      checksum
+    });
+    this.expectOk(finalResp);
+    const result = finalResp.data;
+    return result?.written ?? bytes.byteLength;
+  }
+  /** Best-effort abort of an in-progress stream so the server can clean up. */
+  tryAbortStream(streamId) {
+    try {
+      this.ws.send(JSON.stringify({ stream: "abort", stream_id: streamId }));
+    } catch {
+    }
+  }
   // ── internals ──────────────────────────────────────────────────
   sendAndRecv(request) {
     if (this.closed) {
@@ -494,7 +531,7 @@ var FsClient = class _FsClient {
 
 // src/client.ts
 function createDb9Client(options = {}) {
-  const baseUrl = options.baseUrl ?? "https://db9.shared.aws.tidbcloud.com/api";
+  const baseUrl = options.baseUrl ?? "https://db9.ai/api";
   let token = options.token;
   let tokenLoaded = !!token;
   const store = options.credentialStore ?? defaultCredentialStore();
@@ -513,16 +550,10 @@ function createDb9Client(options = {}) {
       tokenLoaded = true;
     }
     if (!token) {
-      const reg = await publicClient.post(
-        "/customer/anonymous-register"
+      throw new Db9Error(
+        "No token available. Run `db9 login` or pass a token via Db9ClientOptions.",
+        401
       );
-      token = reg.token;
-      await store.save({
-        token: reg.token,
-        is_anonymous: reg.is_anonymous,
-        anonymous_id: reg.anonymous_id,
-        anonymous_secret: reg.anonymous_secret
-      });
     }
     return createHttpClient({
       baseUrl,
@@ -533,43 +564,9 @@ function createDb9Client(options = {}) {
       retryDelay: options.retryDelay
     });
   }
-  let refreshPromise = null;
-  async function refreshAnonymousToken() {
-    const creds = await store.load();
-    if (!creds?.anonymous_id || !creds?.anonymous_secret) {
-      throw new Error("Not an anonymous session");
-    }
-    const resp = await publicClient.post(
-      "/customer/anonymous-refresh",
-      {
-        anonymous_id: creds.anonymous_id,
-        anonymous_secret: creds.anonymous_secret
-      }
-    );
-    token = resp.token;
-    await store.save({ ...creds, token: resp.token });
-  }
   async function withAuthRetry(operation) {
     const client = await getAuthClient();
-    try {
-      return await operation(client);
-    } catch (err) {
-      if (!(err instanceof Db9Error) || err.statusCode !== 401) {
-        throw err;
-      }
-      try {
-        if (!refreshPromise) {
-          refreshPromise = refreshAnonymousToken();
-        }
-        await refreshPromise;
-      } catch {
-        throw err;
-      } finally {
-        refreshPromise = null;
-      }
-      const newClient = await getAuthClient();
-      return operation(newClient);
-    }
+    return operation(client);
   }
   const fsWsPort = options.wsPort ?? 5480;
   async function resolveFsConn(dbId) {
@@ -627,44 +624,11 @@ function createDb9Client(options = {}) {
     }
     return { message: raw };
   }
-  async function fetchAnonymousSecret() {
-    return withAuthRetry(
-      (client) => client.post("/customer/anonymous-secret", {})
-    );
-  }
   return {
     auth: {
-      // Public endpoints (no token required)
-      register: (req) => publicClient.post("/customer/register", req),
-      login: (req) => publicClient.post("/customer/login", req),
-      anonymousRegister: () => publicClient.post(
-        "/customer/anonymous-register"
-      ),
-      anonymousRefresh: (req) => publicClient.post(
-        "/customer/anonymous-refresh",
-        req
-      ),
-      // Authenticated endpoints
       me: async () => withAuthRetry(
         (client) => client.get("/customer/me")
-      ),
-      getAnonymousSecret: () => {
-        return fetchAnonymousSecret();
-      },
-      claim: async (req) => withAuthRetry(
-        (client) => client.post("/customer/claim", req)
-      ),
-      ensureAnonymousSecret: async () => {
-        const creds = await store.load();
-        if (!creds?.anonymous_id || creds.anonymous_secret) {
-          return;
-        }
-        const resp = await fetchAnonymousSecret();
-        await store.save({
-          ...creds,
-          anonymous_secret: resp.anonymous_secret
-        });
-      }
+      )
     },
     tokens: {
       list: async () => withAuthRetry(
@@ -844,27 +808,6 @@ function createDb9Client(options = {}) {
       rename: async (dbId, oldPath, newPath) => {
         await withFsClient(dbId, (client) => client.rename(oldPath, newPath));
       }
-    },
-    // ── Device Auth Flow ─────────────────────────────────────────
-    deviceAuth: {
-      /** Start device code flow. Returns codes for user to authorize. */
-      createDeviceCode: () => publicClient.post("/customer/device-code"),
-      /** Poll for device token after user authorizes. Returns token or error status. */
-      pollDeviceToken: async (req) => {
-        try {
-          return await publicClient.post("/customer/device-token", req);
-        } catch (err) {
-          if (err instanceof Db9Error && err.statusCode === 400) {
-            const errorType = err.message;
-            if (errorType === "authorization_pending" || errorType === "expired_token" || errorType === "access_denied") {
-              return { error: errorType };
-            }
-          }
-          throw err;
-        }
-      },
-      /** Submit device verification with user credentials. */
-      verifyDevice: (req) => publicClient.post("/customer/device-verify", req)
     }
   };
 }