@dinoxx/dinox-cli 1.0.19 → 1.0.20

package/dist/auth/userInfo.d.ts

@@ -5,6 +5,8 @@ export type AuthIdentity = {
     email: string | null;
     syncedAt: string;
 };
+export declare function buildPendingAuthConfig(rawConfig: DinoxConfig, authorization: string): DinoxConfig;
+export declare function mergeAuthIdentityIntoConfig(rawConfig: DinoxConfig, authorization: string, identity: AuthIdentity): DinoxConfig;
 export declare function fetchUserInfoWithAuthorization(input: {
     authorization: string;
     config: ResolvedDinoxConfig;

package/dist/auth/userInfo.js

@@ -3,6 +3,33 @@ import { DinoxError } from '../utils/errors.js';
 import { createTimeoutSignal, mergeAbortSignals } from '../utils/abort.js';
 import { toAuthorizationHeaderValue } from '../utils/authToken.js';
 const AUTH_CODE_OK = '000000';
+export function buildPendingAuthConfig(rawConfig, authorization) {
+    return {
+        ...rawConfig,
+        auth: {
+            ...(rawConfig.auth ?? {}),
+            authorization,
+            userId: undefined,
+            username: undefined,
+            email: undefined,
+            userInfoSyncedAt: undefined,
+        },
+    };
+}
+export function mergeAuthIdentityIntoConfig(rawConfig, authorization, identity) {
+    const pendingConfig = buildPendingAuthConfig(rawConfig, authorization);
+    return {
+        ...pendingConfig,
+        auth: {
+            ...(pendingConfig.auth ?? {}),
+            authorization,
+            userId: identity.userId,
+            username: identity.username,
+            email: identity.email,
+            userInfoSyncedAt: identity.syncedAt,
+        },
+    };
+}
 function normalizeOptionalString(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -105,17 +132,7 @@ export async function refreshAndPersistAuthIdentity(rawConfig, resolvedConfig) {
         authorization,
         config: resolvedConfig,
     });
-    const nextConfig = {
-        ...rawConfig,
-        auth: {
-            ...(rawConfig.auth ?? {}),
-            authorization: rawConfig.auth?.authorization ?? authorization,
-            userId: identity.userId,
-            username: identity.username,
-            email: identity.email,
-            userInfoSyncedAt: identity.syncedAt,
-        },
-    };
+    const nextConfig = mergeAuthIdentityIntoConfig(rawConfig, authorization, identity);
     await saveConfig(nextConfig);
     return identity;
 }

package/dist/commands/auth/index.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
-import { refreshAndPersistAuthIdentity } from '../../auth/userInfo.js';
-import { getPowerSyncDbPath } from '../../config/paths.js';
+import { buildPendingAuthConfig, fetchUserInfoWithAuthorization, mergeAuthIdentityIntoConfig, } from '../../auth/userInfo.js';
+import { getLegacyPowerSyncDbPath, getPowerSyncDbPath } from '../../config/paths.js';
 import { loadConfig, saveConfig } from '../../config/store.js';
 import { resolveConfig } from '../../config/resolve.js';
 import { fetchCredentialsWithAuthorization } from '../../powersync/connector.js';
@@ -26,10 +26,9 @@ async function runAuthLogin(context) {
     if (!rawToken) {
         throw new DinoxError('Token is required');
     }
-    const config = await loadConfig();
-    config.auth = { ...(config.auth ?? {}), authorization: rawToken };
-    await saveConfig(config);
-    const resolved = resolveConfig(config);
+    const previousConfig = await loadConfig();
+    const pendingConfig = buildPendingAuthConfig(previousConfig, rawToken);
+    const resolved = resolveConfig(pendingConfig);
     const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? resolved.sync.timeoutMs;
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
     await fetchCredentialsWithAuthorization({
@@ -38,19 +37,26 @@ async function runAuthLogin(context) {
         credentialsUrl: resolved.powersync.tokenEndpoint,
         timeoutMs,
     });
-    const identity = await refreshAndPersistAuthIdentity(config, resolved);
-    const { db, dbPath, stale } = await connectPowerSync({
+    const identity = await fetchUserInfoWithAuthorization({
+        authorization: rawToken,
         config: resolved,
+        timeoutMs,
+    });
+    const verifiedConfig = mergeAuthIdentityIntoConfig(previousConfig, rawToken, identity);
+    const verifiedResolved = resolveConfig(verifiedConfig);
+    const { db, dbPath, stale } = await connectPowerSync({
+        config: verifiedResolved,
         offline: false,
         timeoutMs,
     });
     try {
         await runSingleSyncPass(db, timeoutMs);
+        await saveConfig(verifiedConfig);
         const status = getStatusSnapshot(db);
         const result = {
             ok: true,
             verified: true,
-            endpoint: resolved.powersync.endpoint,
+            endpoint: verifiedResolved.powersync.endpoint,
             dbPath,
             stale,
             lastSyncedAt: status.lastSyncedAt,
@@ -78,6 +84,7 @@ async function runAuthLogin(context) {
 async function runAuthLogout(context) {
     const options = context.options;
     const config = await loadConfig();
+    const currentUserId = config.auth?.userId;
     if (config.auth) {
         config.auth.authorization = undefined;
         config.auth.userId = undefined;
@@ -87,7 +94,8 @@ async function runAuthLogout(context) {
     }
     await saveConfig(config);
     if (options.clearLocalDb) {
-        await removeSqliteArtifacts(getPowerSyncDbPath());
+        await removeSqliteArtifacts(getPowerSyncDbPath(currentUserId));
+        await removeSqliteArtifacts(getLegacyPowerSyncDbPath());
     }
     if (getRequestedStructuredOutputFormat()) {
         printSuccess({
@@ -103,7 +111,7 @@ async function runAuthStatus(context) {
     const offline = Boolean(context.globals.offline);
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
     const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? resolved.sync.timeoutMs;
-    const dbPath = getPowerSyncDbPath();
+    const dbPath = getPowerSyncDbPath(resolved.auth.userId);
     const base = {
         loggedIn: Boolean(resolved.auth.authorization),
         authorization: redactAuthorization(resolved.auth.authorization),

package/dist/commands/mcp/server.js

@@ -216,7 +216,8 @@ export class MCPServer {
             case 'dinox_search_notes': {
                 const keyword = typeof args.query === 'string' ? args.query : '';
                 const tagsExpression = typeof args.tags === 'string' ? args.tags.trim() : '';
-                const { names: boxNames, matchEmpty: matchEmptyBoxes } = parseBoxFilter(args.box);
+                const rawBoxes = args.boxes ?? args.box;
+                const { names: boxNames, matchEmpty: matchEmptyBoxes } = parseBoxFilter(rawBoxes);
                 const zettelBoxIds = await resolveZettelBoxIdsForSearch(this.db, boxNames);
                 const daysInput = typeof args.days === 'number' ? String(args.days) : args.days;
                 const { createdAtFrom, createdAtTo } = parseCreatedAtRange({

package/dist/commands/storage/repo.d.ts

@@ -151,7 +151,7 @@ export declare function inspectStorageTest(db: AbstractPowerSyncDatabase, input:
 export declare function testStorageUpload(db: AbstractPowerSyncDatabase, input: {
     userId: string;
     storageId?: string;
-}, deps?: Pick<UploadDeps, 'uploadBytes'>): Promise<StorageTestResult>;
+}, deps?: Pick<UploadDeps, 'deleteObject' | 'uploadBytes'>): Promise<StorageTestResult>;
 export declare function uploadFileToStorage(db: AbstractPowerSyncDatabase, input: {
     userId: string;
     filePath: string;

package/dist/commands/storage/repo.js

@@ -515,12 +515,13 @@ export async function getStorageStats(db, userId) {
       COUNT(1) AS file_count
     FROM c_resource
     WHERE (is_del IS NULL OR is_del = 0)
+      AND TRIM(COALESCE(user_id, '')) = ?
       AND TRIM(COALESCE(storage_provider, '')) <> ''
       AND TRIM(COALESCE(storage_provider, '')) <> 'local'
       AND TRIM(COALESCE(status, '')) = 'uploaded'
     GROUP BY storage_provider, bucket
     ORDER BY total_bytes DESC, provider ASC, bucket ASC
-    `, []);
+    `, [userId]);
     const configs = await listStoredCustomStorageConfigs(db, userId);
     const configsByKey = new Map();
     const configsByProvider = new Map();
@@ -639,6 +640,7 @@ export async function testStorageUpload(db, input, deps) {
         throw new DinoxError(`Storage config not found: ${plan.storage.id}`);
     }
     const uploadBytes = deps?.uploadBytes ?? defaultUploadBytes;
+    const deleteObject = deps?.deleteObject ?? defaultDeleteObject;
     const payload = Buffer.from(`dinox-cli storage test\nprovider=${storage.provider}\nuser=${input.userId}\ncreated_at=${new Date().toISOString()}\n`, 'utf8');
     await uploadBytes({
         body: payload,
@@ -647,6 +649,23 @@ export async function testStorageUpload(db, input, deps) {
         contentType: plan.contentType,
         storage,
     });
+    try {
+        await deleteObject({
+            bucket: storage.bucket,
+            key: plan.storageKey,
+            storage,
+        });
+    }
+    catch (error) {
+        throw new DinoxError('Storage test uploaded the temporary object but failed to clean it up.', {
+            cause: error,
+            code: 'STORAGE_TEST_CLEANUP_FAILED',
+            details: {
+                storageKey: plan.storageKey,
+                bucket: storage.bucket,
+            },
+        });
+    }
     return {
         storageConfigId: storage.id,
         aliasName: storage.aliasName,

package/dist/config/paths.d.ts

@@ -1,4 +1,5 @@
 export declare function getConfigDir(): string;
 export declare function getConfigFilePath(): string;
 export declare function getDataDir(): string;
-export declare function getPowerSyncDbPath(): string;
+export declare function getLegacyPowerSyncDbPath(): string;
+export declare function getPowerSyncDbPath(userId?: string | null): string;

package/dist/config/paths.js

@@ -1,6 +1,9 @@
 import os from 'node:os';
 import path from 'node:path';
 const POWERSYNC_DB_FILENAME = 'dinox-cli.sqlite';
+function normalizeUserPathSegment(userId) {
+    return encodeURIComponent(userId.trim());
+}
 function resolveConfigHome() {
     if (process.env.DINOX_CONFIG_DIR) {
         return process.env.DINOX_CONFIG_DIR;
@@ -35,6 +38,13 @@ export function getConfigFilePath() {
 export function getDataDir() {
     return path.join(resolveDataHome(), 'dinox');
 }
-export function getPowerSyncDbPath() {
+export function getLegacyPowerSyncDbPath() {
     return path.join(getDataDir(), POWERSYNC_DB_FILENAME);
 }
+export function getPowerSyncDbPath(userId) {
+    const normalizedUserId = typeof userId === 'string' ? userId.trim() : '';
+    if (!normalizedUserId) {
+        return getLegacyPowerSyncDbPath();
+    }
+    return path.join(getDataDir(), 'users', normalizeUserPathSegment(normalizedUserId), POWERSYNC_DB_FILENAME);
+}

package/dist/config/resolve.js

@@ -35,13 +35,15 @@ export function resolveConfig(raw) {
     const envUploadV4Path = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_V4_PATH);
     const envUploadV2Path = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_V2_PATH);
     const envTimeoutMs = parsePositiveInt(process.env.DINOX_SYNC_TIMEOUT_MS);
+    const effectiveAuth = envAuth ?? fileAuth;
+    const canReusePersistedIdentity = !envAuth || envAuth === fileAuth;
     return {
         auth: {
-            authorization: envAuth ?? fileAuth,
-            userId: fileUserId,
-            username: fileUsername,
-            email: fileEmail,
-            userInfoSyncedAt: fileUserInfoSyncedAt,
+            authorization: effectiveAuth,
+            userId: canReusePersistedIdentity ? fileUserId : undefined,
+            username: canReusePersistedIdentity ? fileUsername : undefined,
+            email: canReusePersistedIdentity ? fileEmail : undefined,
+            userInfoSyncedAt: canReusePersistedIdentity ? fileUserInfoSyncedAt : undefined,
         },
         powersync: {
             endpoint: POWERSYNC_DEFAULT_ENDPOINT,

package/dist/powersync/runtime.d.ts

@@ -25,7 +25,7 @@ export declare function getStatusSnapshot(db: AbstractPowerSyncDatabase): {
     };
     raw: SyncStatusOptions;
 };
-export declare function openPowerSyncDatabase(): Promise<{
+export declare function openPowerSyncDatabase(userId?: string | null): Promise<{
     db: PowerSyncDatabase;
     dbPath: string;
 }>;

package/dist/powersync/runtime.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises';
+import path from 'node:path';
 import { PowerSyncDatabase } from '@powersync/node';
 import { getDataDir, getPowerSyncDbPath } from '../config/paths.js';
 import { DinoxError } from '../utils/errors.js';
@@ -33,9 +34,10 @@ export function getStatusSnapshot(db) {
         raw,
     };
 }
-export async function openPowerSyncDatabase() {
+export async function openPowerSyncDatabase(userId) {
     await ensureDataDir();
-    const dbPath = getPowerSyncDbPath();
+    const dbPath = getPowerSyncDbPath(userId);
+    await fs.mkdir(path.dirname(dbPath), { recursive: true, mode: 0o700 });
     const db = new PowerSyncDatabase({
         schema: AppSchema,
         database: {
@@ -52,7 +54,7 @@ function assertConfigured(config) {
     }
 }
 export async function connectPowerSync(args) {
-    const { db, dbPath } = await openPowerSyncDatabase();
+    const { db, dbPath } = await openPowerSyncDatabase(args.config.auth.userId);
     if (args.offline) {
         return { db, dbPath, stale: true };
     }

package/package.json

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