@sparkvault/sdk-mobile 1.0.0 → 1.0.2

package/src/ingots.ts

@@ -26,6 +26,12 @@ export interface UploadOptions {
    * Missing path segments are find-or-created. Omitted means the vault root.
    */
   folder?: string;
+  /**
+   * Existing folder id to upload into (e.g. "fld_xxx"). Use when the target
+   * folder is already known by id; mutually exclusive with `folder` (path).
+   * Omitted means the vault root.
+   */
+  folderId?: string;
   onProgress?: UploadProgressCallback;
   abortSignal?: AbortSignal;
 }
@@ -89,8 +95,6 @@ interface IngotAuditLogEntry {
 
 interface IngotAuditLogsResponse {
   entries?: IngotAuditLogEntry[];
-  logs?: IngotAuditLogEntry[];
-  cursor?: string;
   next_cursor?: string;
 }
 
@@ -123,6 +127,7 @@ export class MobileIngotsClient {
       contentType: options.contentType,
       sizeBytes: options.fileSize,
       folder: options.folder,
+      folderId: options.folderId,
     });
 
     await this.tus.uploadFromUri({
@@ -456,10 +461,10 @@ export class MobileIngotsClient {
         : `/vaults/${vaultId}/ingots/${ingotId}/audit-logs`,
       { vat }
     );
-    const entries = response.data.entries ?? response.data.logs ?? [];
+    const entries = response.data.entries ?? [];
     return {
       logs: entries.map(entry => this.toAccessLog(entry)),
-      next_cursor: response.data.cursor ?? response.data.next_cursor,
+      next_cursor: response.data.next_cursor,
     };
   }
 
@@ -489,14 +494,19 @@ export class MobileIngotsClient {
     contentType: string;
     sizeBytes: number;
     folder?: string;
+    folderId?: string;
   }): Promise<IngotUploadInitResponse> {
     const body: Record<string, unknown> = {
       name: options.name,
       content_type: options.contentType,
       size_bytes: options.sizeBytes,
     };
+    // folder_path (find-or-create) and folder_id (existing folder) are
+    // mutually exclusive server-side; a path takes precedence when both given.
     if (options.folder) {
       body.folder_path = options.folder;
+    } else if (options.folderId) {
+      body.folder_id = options.folderId;
     }
     const response = await this.http.post<IngotUploadInitResponse>(
       `/vaults/${options.vaultId}/ingots`,

package/src/platform-domains.generated.ts

@@ -0,0 +1,17 @@
+// GENERATED FILE — do not edit by hand.
+// Source of truth: packages/app-sdk/src/platform-domains.js
+// Regenerate with: pnpm --filter @sparkvault/sdk-mobile build
+
+export const SPARKVAULT_ROOT_DOMAIN = "sparkvault.com";
+
+export const SPARKVAULT_PLATFORM_SV_HOSTS: readonly string[] = Object.freeze([
+  "auth.sv",
+  "x.sv",
+  "files.sv",
+  "file.sv",
+  "send.sv",
+  "spark.sv",
+  "by.sv",
+  "at.sv",
+  "db.sv",
+]);

package/src/tus.ts

@@ -73,6 +73,12 @@ function ensureNotAborted(signal?: AbortSignal): void {
 }
 
 function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  // base64ToBytes returns exactly-sized buffers, so the chunk hot path is a
+  // zero-copy unwrap; copy only when the view spans part of a larger buffer.
+  // Aliasing is safe: chunks are sent then discarded, never mutated.
+  if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+    return bytes.buffer as ArrayBuffer;
+  }
   const copy = new Uint8Array(bytes.byteLength);
   copy.set(bytes);
   return copy.buffer;
@@ -223,10 +229,11 @@ export class MobileTusUploader {
     const debug = options.debug;
     const cleanUri = options.fileUri.split('#')[0];
     let bytesUploaded = 0;
+    let uploadUrl: string | null = null;
 
     try {
       debug?.log(`Starting TUS upload for ${options.filename}`);
-      const uploadUrl = await createTusUpload(
+      uploadUrl = await createTusUpload(
         this.config,
         parsed,
         options.fileSize,
@@ -267,6 +274,18 @@ export class MobileTusUploader {
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
       debug?.error(`Upload failed: ${getErrorMessage(error)}`);
+
+      // A cancelled session must be terminated server-side: the tus DELETE is
+      // what lets Forge remove already-written chunk objects (otherwise they
+      // are orphaned in S3 — nothing else cleans them up) and settle
+      // partial-transfer billing, matching the web client's abort semantics.
+      const cancelled =
+        options.abortSignal?.aborted === true ||
+        (err instanceof TusUploadError && err.phase === 'cancelled');
+      if (cancelled && uploadUrl) {
+        this.terminateUpload(uploadUrl, parsed.istk, debug);
+      }
+
       if (err instanceof TusUploadError) throw err;
       throw TusUploadError.fromError(error, {
         filename: options.filename,
@@ -276,6 +295,28 @@ export class MobileTusUploader {
     }
   }
 
+  /**
+   * Best-effort tus termination after a cancelled upload. Fire-and-forget so
+   * cancel UX stays instant and the cancellation error still propagates — a
+   * failed DELETE only means the orphaned session waits for server-side
+   * expiry. Deliberately NOT bound to the (already aborted) upload signal,
+   * which would kill the DELETE before it left the device.
+   */
+  private terminateUpload(uploadUrl: string, istk: string, debug?: DebugLogger): void {
+    void this.config
+      .fetch(uploadUrl, {
+        method: 'DELETE',
+        headers: {
+          'Tus-Resumable': TUS_VERSION,
+          'X-ISTK': istk,
+        },
+        timeoutMs: this.config.tusPostTimeoutMs,
+      })
+      .catch(err => {
+        debug?.log(`TUS termination after cancel failed: ${getErrorMessage(err)}`);
+      });
+  }
+
   private async readChunk(
     fileReader: MobileFileReader,
     fileUri: string,

package/src/validation.ts

@@ -25,13 +25,20 @@ export function validateFolderId(folderId: string): void {
   }
 }
 
+/** Windows reserved filenames that cannot be used. */
+const WINDOWS_RESERVED_NAMES = new Set([
+  'CON', 'PRN', 'AUX', 'NUL',
+  'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
+  'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9',
+]);
+
+/**
+ * Sanitize a filename to prevent path traversal and other security issues:
+ * removes null bytes and control characters, strips path traversal sequences,
+ * replaces directory separators, strips leading dots (hidden files), and
+ * prefixes Windows reserved names. Falls back to 'file' when nothing remains.
+ */
 export function sanitizeFilename(filename: string): string {
-  const reservedNames = new Set([
-    'CON', 'PRN', 'AUX', 'NUL',
-    'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
-    'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9',
-  ]);
-
   let sanitized = filename
     .replace(/\0/g, '')
     .replace(/[\x00-\x1f\x7f]/g, '')
@@ -41,7 +48,7 @@ export function sanitizeFilename(filename: string): string {
     .trim();
 
   const baseName = sanitized.split('.')[0].toUpperCase();
-  if (reservedNames.has(baseName)) {
+  if (WINDOWS_RESERVED_NAMES.has(baseName)) {
     sanitized = `_${sanitized}`;
   }
 

package/src/vaults.ts

@@ -257,20 +257,6 @@ export class MobileVaultsClient {
     return response.data;
   }
 
-  /**
-   * @deprecated Use enableUploadPortal() or enableUploadWidget().
-   */
-  async enableUpload(vaultId: string, vmk: string): Promise<UploadPortalEnabled> {
-    return this.enableUploadPortal(vaultId, vmk);
-  }
-
-  /**
-   * @deprecated Use disableUploadPortal() or disableUploadWidget().
-   */
-  async disableUpload(vaultId: string): Promise<UploadPortalDisabled> {
-    return this.disableUploadPortal(vaultId);
-  }
-
   async updateUploadConfig(
     vaultId: string,
     config: {