@dinoxx/dinox-cli 1.0.14 → 1.0.16

package/dist/powersync/connector.js

@@ -1,3 +1,5 @@
+import { createTimeoutSignal, mergeAbortSignals } from '../utils/abort.js';
+import { toAuthorizationHeaderValue } from '../utils/authToken.js';
 /**
  * Connector that fetches PowerSync credentials from your backend.
  * This is injectable for testability.
@@ -23,7 +25,7 @@ export class PowerSyncConnector {
         await this.uploader(database);
     }
 }
-export async function fetchCredentialsWithAuthorization({ authorization, endpoint, credentialsUrl, signal, }) {
+export async function fetchCredentialsWithAuthorization({ authorization, endpoint, credentialsUrl, timeoutMs, signal, }) {
     if (!authorization) {
         throw new Error('PowerSync credential exchange requires an authorization token');
     }
@@ -33,14 +35,30 @@ export async function fetchCredentialsWithAuthorization({ authorization, endpoin
     if (!credentialsUrl) {
         throw new Error('PowerSync credential exchange requires a token endpoint');
     }
-    const response = await fetch(credentialsUrl, {
-        method: 'GET',
-        headers: {
-            Authorization: authorization,
-            'Content-Type': 'application/json',
-        },
-        signal,
-    });
+    const timeout = typeof timeoutMs === 'number' && Number.isFinite(timeoutMs) && timeoutMs > 0
+        ? createTimeoutSignal(timeoutMs)
+        : null;
+    const requestSignal = mergeAbortSignals([signal, timeout?.signal]);
+    let response;
+    try {
+        response = await fetch(credentialsUrl, {
+            method: 'GET',
+            headers: {
+                Authorization: toAuthorizationHeaderValue(authorization),
+                'Content-Type': 'application/json',
+            },
+            signal: requestSignal,
+        });
+    }
+    catch (error) {
+        if (timeout?.signal.aborted && !signal?.aborted) {
+            throw new Error(`PowerSync credential exchange timed out after ${timeoutMs}ms`);
+        }
+        throw error;
+    }
+    finally {
+        timeout?.cancel();
+    }
     if (!response.ok) {
         const errorText = await response.text().catch(() => '');
         throw new Error(`Received ${response.status} from ${credentialsUrl}: ${errorText}`);

package/dist/powersync/runtime.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import { PowerSyncDatabase } from '@powersync/node';
 import { getDataDir, getPowerSyncDbPath } from '../config/paths.js';
 import { DinoxError } from '../utils/errors.js';
+import { createTimeoutSignal } from '../utils/abort.js';
 import { AppSchema } from './schema/index.js';
 import { PowerSyncConnector, fetchCredentialsWithAuthorization } from './connector.js';
 import { createPowerSyncUploadHandler } from './uploader.js';
@@ -10,14 +11,6 @@ async function ensureDataDir() {
     await fs.mkdir(dir, { recursive: true, mode: 0o700 });
     return dir;
 }
-function createTimeoutSignal(timeoutMs) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    return {
-        signal: controller.signal,
-        cancel: () => clearTimeout(timer),
-    };
-}
 export function getStatusSnapshot(db) {
     const raw = db.currentStatus?.toJSON?.() ?? {};
     const lastSyncedAt = raw.lastSyncedAt instanceof Date ? raw.lastSyncedAt.toISOString() : raw.lastSyncedAt ?? null;
@@ -55,7 +48,7 @@ export async function openPowerSyncDatabase() {
 }
 function assertConfigured(config) {
     if (!config.auth.authorization) {
-        throw new DinoxError('Not logged in. Run: dino auth login <authorization>');
+        throw new DinoxError('Not logged in. Run: dino auth login <token>');
     }
 }
 export async function connectPowerSync(args) {
@@ -70,6 +63,7 @@ export async function connectPowerSync(args) {
             uploadBaseUrl: args.config.powersync.uploadBaseUrl,
             uploadV4Path: args.config.powersync.uploadV4Path,
             uploadV2Path: args.config.powersync.uploadV2Path,
+            timeoutMs: args.timeoutMs,
         })
         : undefined;
     const connector = new PowerSyncConnector(async () => {
@@ -77,6 +71,7 @@ export async function connectPowerSync(args) {
             authorization: args.config.auth.authorization,
             endpoint: args.config.powersync.endpoint,
             credentialsUrl: args.config.powersync.tokenEndpoint,
+            timeoutMs: args.timeoutMs,
         });
     }, uploader);
     await db.connect(connector);

package/dist/powersync/uploader.d.ts

@@ -4,4 +4,5 @@ export declare function createPowerSyncUploadHandler(options: {
     uploadBaseUrl: string;
     uploadV4Path: string;
     uploadV2Path: string;
+    timeoutMs?: number;
 }): UploadHandler;

package/dist/powersync/uploader.js

@@ -1,4 +1,6 @@
 import { UpdateType } from '@powersync/common';
+import { createTimeoutSignal, mergeAbortSignals } from '../utils/abort.js';
+import { toAuthorizationHeaderValue } from '../utils/authToken.js';
 const FATAL_RESPONSE_CODES = [/^22...$/, /^23...$/, /^42501$/];
 function shouldFallbackToLegacy(status) {
     return status === 404 || status === 405;
@@ -45,14 +47,34 @@ function isFatalUploadError(error) {
     return typeof code === 'string' && FATAL_RESPONSE_CODES.some(regex => regex.test(code));
 }
 async function dispatchMutation(options) {
-    const response = await fetch(options.url, {
-        method: options.method,
-        headers: {
-            Authorization: options.authorization,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(options.payload),
-    });
+    const timeout = typeof options.timeoutMs === 'number' && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+        ? createTimeoutSignal(options.timeoutMs)
+        : null;
+    const requestSignal = mergeAbortSignals([options.signal, timeout?.signal]);
+    let response;
+    try {
+        response = await fetch(options.url, {
+            method: options.method,
+            headers: {
+                Authorization: toAuthorizationHeaderValue(options.authorization),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(options.payload),
+            signal: requestSignal,
+        });
+    }
+    catch (error) {
+        if (timeout?.signal.aborted && !options.signal?.aborted) {
+            const err = new Error(`PowerSync upload timed out (${options.method} ${options.url}) after ${options.timeoutMs}ms`);
+            err.name = 'PowerSyncUploadError';
+            err.status = 408;
+            throw err;
+        }
+        throw error;
+    }
+    finally {
+        timeout?.cancel();
+    }
     if (response.ok) {
         return;
     }
@@ -75,11 +97,11 @@ async function uploadTransaction(args) {
         switch (op.op) {
             case UpdateType.PUT:
                 try {
-                    await dispatchMutation({ authorization: args.authorization, url: primaryUrl, method: 'PUT', payload: record });
+                    await dispatchMutation({ authorization: args.authorization, url: primaryUrl, method: 'PUT', payload: record, timeoutMs: args.timeoutMs });
                 }
                 catch (error) {
                     if (shouldFallbackToLegacy(error?.status)) {
-                        await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method: 'PUT', payload: record });
+                        await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method: 'PUT', payload: record, timeoutMs: args.timeoutMs });
                     }
                     else {
                         throw error;
@@ -88,11 +110,11 @@ async function uploadTransaction(args) {
                 break;
             case UpdateType.PATCH:
                 try {
-                    await dispatchMutation({ authorization: args.authorization, url: primaryUrl, method: 'PATCH', payload: record });
+                    await dispatchMutation({ authorization: args.authorization, url: primaryUrl, method: 'PATCH', payload: record, timeoutMs: args.timeoutMs });
                 }
                 catch (error) {
                     if (shouldFallbackToLegacy(error?.status)) {
-                        await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method: 'PATCH', payload: record });
+                        await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method: 'PATCH', payload: record, timeoutMs: args.timeoutMs });
                     }
                     else {
                         throw error;
@@ -100,7 +122,7 @@ async function uploadTransaction(args) {
                 }
                 break;
             case UpdateType.DELETE:
-                await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method: 'DELETE', payload: record });
+                await dispatchMutation({ authorization: args.authorization, url: fallbackUrl, method: 'DELETE', payload: record, timeoutMs: args.timeoutMs });
                 break;
             default:
                 break;
@@ -120,6 +142,7 @@ export function createPowerSyncUploadHandler(options) {
                 uploadBaseUrl: options.uploadBaseUrl,
                 uploadV4Path: options.uploadV4Path,
                 uploadV2Path: options.uploadV2Path,
+                timeoutMs: options.timeoutMs,
             });
             await transaction.complete();
         }

package/dist/utils/abort.d.ts

@@ -0,0 +1,6 @@
+export type TimeoutSignal = {
+    signal: AbortSignal;
+    cancel: () => void;
+};
+export declare function createTimeoutSignal(timeoutMs: number): TimeoutSignal;
+export declare function mergeAbortSignals(signals: Array<AbortSignal | undefined>): AbortSignal | undefined;

package/dist/utils/abort.js

@@ -0,0 +1,23 @@
+export function createTimeoutSignal(timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    // Best-effort: don't keep the process alive solely for the timeout.
+    if (typeof timer.unref === 'function') {
+        timer.unref();
+    }
+    return {
+        signal: controller.signal,
+        cancel: () => clearTimeout(timer),
+    };
+}
+export function mergeAbortSignals(signals) {
+    const filtered = signals.filter(Boolean);
+    if (filtered.length === 0) {
+        return undefined;
+    }
+    if (filtered.length === 1) {
+        return filtered[0];
+    }
+    // Node.js 20+ supports AbortSignal.any().
+    return AbortSignal.any(filtered);
+}

package/dist/utils/authToken.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeAuthToken(value: unknown): string | undefined;
+export declare function toAuthorizationHeaderValue(token: string): string;

package/dist/utils/authToken.js

@@ -0,0 +1,23 @@
+export function normalizeAuthToken(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (trimmed.toLowerCase().startsWith('bearer ')) {
+        const withoutPrefix = trimmed.slice('bearer '.length).trim();
+        return withoutPrefix || undefined;
+    }
+    return trimmed;
+}
+export function toAuthorizationHeaderValue(token) {
+    // Backend expects a standard Authorization header. Be defensive: callers may pass
+    // a full "Bearer ..." header value or a raw token.
+    const normalized = normalizeAuthToken(token);
+    if (!normalized) {
+        throw new Error('Missing auth token');
+    }
+    return `Bearer ${normalized}`;
+}

package/dist/utils/syncTimeout.d.ts

@@ -0,0 +1 @@
+export declare function parseSyncTimeoutMs(value: unknown): number | undefined;

package/dist/utils/syncTimeout.js

@@ -0,0 +1,19 @@
+import { DinoxError } from './errors.js';
+export function parseSyncTimeoutMs(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const text = typeof value === 'string' ? value.trim() : typeof value === 'number' ? String(value) : '';
+    if (!text) {
+        return undefined;
+    }
+    // Commander options are typically strings; be strict and fail fast for non-integers.
+    if (!/^\d+$/.test(text)) {
+        throw new DinoxError('--sync-timeout must be a positive integer');
+    }
+    const parsed = Number(text);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw new DinoxError('--sync-timeout must be a positive integer');
+    }
+    return parsed;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {