@dinoxx/dinox-cli 1.0.22 → 1.1.0

package/dist/commands/boxes/operations.js

@@ -1,18 +1,18 @@
 import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
 import { DinoxError } from '../../utils/errors.js';
 import { nowIsoUtc } from '../../utils/time.js';
-import { MAX_BOX_NAME_LENGTH, MAX_BOX_PATH_LENGTH, REQUIRED_NOTE_BOX_COLUMNS, assertMaxLength, canonicalizeBoxPath, getLeafName, normalizeBoxLookupKey, parseStoredBoxIds, trimString, } from './model.js';
+import { MAX_BOX_NAME_LENGTH, REQUIRED_NOTE_BOX_COLUMNS, assertBoxPathLimits, assertTextLimits, canonicalizeBoxPath, getLeafName, normalizeBoxLookupKey, parseStoredBoxIds, trimString, } from './model.js';
 import { activeBoxNodes, activeNodeByPath, assertCanWriteBox, assertRequiredColumns, assertWritableBoxNodes, descendantsOf, ensureNoPathConflict, getTableColumns, isActiveBoxNode, isDescendantBoxPath, loadAllBoxNodes, requireActivePath, toBoxListItem, } from './store.js';
 function buildSubtreeChanges(args) {
     const newRootPath = canonicalizeBoxPath(args.newRootPath);
     if (!newRootPath) {
         throw new DinoxError('Target box path is required');
     }
-    assertMaxLength('Box path', newRootPath, MAX_BOX_PATH_LENGTH);
     const rootPrefix = `${args.root.path}/`;
     return descendantsOf(args.nodes, args.root).map((node) => {
         const suffix = node.id === args.root.id ? '' : node.path.slice(rootPrefix.length);
         const toPath = suffix ? `${newRootPath}/${suffix}` : newRootPath;
+        assertBoxPathLimits(toPath, 'Target box path');
         return {
             id: node.id,
             fromPath: node.path,
@@ -53,7 +53,8 @@ async function applySubtreePathChanges(args) {
       UPDATE c_zettel_box
       SET name = ?, path = ?, parent_id = ?, updated_at = ?
       WHERE id = ?
-      `, [getLeafName(change.toPath), change.toPath, parentId, args.timestamp, change.id]);
+        AND TRIM(COALESCE(user_no, '')) = ?
+      `, [getLeafName(change.toPath), change.toPath, parentId, args.timestamp, change.id, args.userId]);
     }
 }
 function parseRenameInput(input) {
@@ -66,7 +67,8 @@ function parseRenameInput(input) {
     if (!newName || newName.includes('/')) {
         throw new DinoxError('New box name must be a single path segment');
     }
-    assertMaxLength('Box name', newName, MAX_BOX_NAME_LENGTH);
+    assertBoxPathLimits(path);
+    assertTextLimits('Box name', newName, MAX_BOX_NAME_LENGTH);
     return { path, newName, userId };
 }
 function parseMoveInput(input) {
@@ -79,6 +81,8 @@ function parseMoveInput(input) {
     if (!to) {
         throw new DinoxError('Target parent path is required');
     }
+    assertBoxPathLimits(path);
+    assertBoxPathLimits(to, 'Target parent path');
     return { path, to, userId };
 }
 function parseMergeInput(input) {
@@ -91,6 +95,8 @@ function parseMergeInput(input) {
     if (!to) {
         throw new DinoxError('Target box path is required');
     }
+    assertBoxPathLimits(from, 'Source box path');
+    assertBoxPathLimits(to, 'Target box path');
     return { from, to, userId };
 }
 export async function getBoxTree(db, input = {}) {
@@ -127,13 +133,13 @@ async function loadNoteBoxRows(db, userId) {
     FROM c_note
     WHERE TRIM(COALESCE(id, '')) <> ''
       AND (is_del IS NULL OR is_del = 0)
-      AND (TRIM(COALESCE(user_no, '')) = ? OR TRIM(COALESCE(user_no, '')) = '')
+      AND TRIM(COALESCE(user_no, '')) = ?
     `, [userId]);
 }
 async function loadNoteBoxStats(db, userId) {
     const normalizedUserId = trimString(userId);
     const userFilter = normalizedUserId
-        ? `AND (TRIM(COALESCE(n.user_no, '')) = ? OR TRIM(COALESCE(n.user_no, '')) = '')`
+        ? `AND TRIM(COALESCE(n.user_no, '')) = ?`
         : '';
     const rows = await db.getAll(`
     SELECT
@@ -299,6 +305,7 @@ export async function renameBox(db, input, options = {}) {
                 nodes,
                 changes,
                 newRootParentId: root.parentId,
+                userId: parsed.userId,
                 timestamp: nowIsoUtc(),
             });
         });
@@ -331,6 +338,7 @@ export async function moveBox(db, input, options = {}) {
                 nodes,
                 changes,
                 newRootParentId: targetParent.id,
+                userId: parsed.userId,
                 timestamp: nowIsoUtc(),
             });
         });
@@ -393,14 +401,16 @@ export async function mergeBox(db, input, options = {}) {
           UPDATE c_note
           SET zettel_boxes = ?, updated_at = ?, version = COALESCE(version, 0) + 1
           WHERE id = ?
-          `, [JSON.stringify(note.after), timestamp, note.id]);
+            AND TRIM(COALESCE(user_no, '')) = ?
+          `, [JSON.stringify(note.after), timestamp, note.id, parsed.userId]);
             }
             for (const boxId of softDeletedBoxIds) {
                 await tx.execute(`
           UPDATE c_zettel_box
           SET is_del = 1, updated_at = ?
           WHERE id = ?
-          `, [timestamp, boxId]);
+            AND TRIM(COALESCE(user_no, '')) = ?
+          `, [timestamp, boxId, parsed.userId]);
             }
         });
     }

package/dist/commands/boxes/repo.js

@@ -1,7 +1,7 @@
 import { generateId } from '../../utils/id.js';
 import { DinoxError } from '../../utils/errors.js';
 import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
-import { MAX_BOX_COLOR_LENGTH, MAX_BOX_DESCRIPTION_LENGTH, MAX_BOX_NAME_LENGTH, MAX_BOX_PATH_LENGTH, assertMaxLength, canonicalizeBoxPath, getLeafName, normalizeBoxLookupKey, toNullableId, trimString, } from './model.js';
+import { MAX_BOX_COLOR_LENGTH, MAX_BOX_DESCRIPTION_LENGTH, MAX_BOX_NAME_LENGTH, assertBoxPathLimits, assertTextLimits, canonicalizeBoxPath, getLeafName, normalizeBoxLookupKey, toNullableId, trimString, } from './model.js';
 import { assertCanWriteBox, getTableColumns } from './store.js';
 export { canonicalizeBoxPath } from './model.js';
 function normalizeLookupKey(value) {
@@ -16,10 +16,10 @@ function parseAddBoxInput(input) {
     const name = getLeafName(path);
     const description = trimString(input.description);
     const color = trimString(input.color);
-    assertMaxLength('Box name', name, MAX_BOX_NAME_LENGTH);
-    assertMaxLength('Box path', path, MAX_BOX_PATH_LENGTH);
-    assertMaxLength('Box description', description, MAX_BOX_DESCRIPTION_LENGTH);
-    assertMaxLength('Box color', color, MAX_BOX_COLOR_LENGTH);
+    assertBoxPathLimits(path);
+    assertTextLimits('Box name', name, MAX_BOX_NAME_LENGTH);
+    assertTextLimits('Box description', description, MAX_BOX_DESCRIPTION_LENGTH);
+    assertTextLimits('Box color', color, MAX_BOX_COLOR_LENGTH);
     return {
         userId,
         path,
@@ -28,7 +28,7 @@ function parseAddBoxInput(input) {
         color,
     };
 }
-async function loadBoxNodesByPath(db) {
+async function loadBoxNodesByPath(db, userId) {
     const rows = await db.getAll(`
     SELECT
       TRIM(COALESCE(id, '')) AS id,
@@ -41,12 +41,13 @@ async function loadBoxNodesByPath(db) {
       TRIM(COALESCE(user_no, '')) AS user_no
     FROM c_zettel_box
     WHERE TRIM(COALESCE(id, '')) <> ''
+      AND TRIM(COALESCE(user_no, '')) = ?
     ORDER BY
       CASE WHEN is_del IS NULL OR is_del = 0 THEN 0 ELSE 1 END ASC,
       updated_at DESC,
       created_at DESC,
       id DESC
-    `, []);
+    `, [userId]);
     const nodesByPath = new Map();
     for (const row of rows) {
         const id = trimString(row.id);
@@ -77,7 +78,7 @@ async function loadBoxNodesByPath(db) {
 export async function listBoxes(db, input = {}) {
     const userId = trimString(input.userId);
     const userFilter = userId
-        ? `AND (TRIM(COALESCE(user_no, '')) = ? OR TRIM(COALESCE(user_no, '')) = '')`
+        ? `AND TRIM(COALESCE(user_no, '')) = ?`
         : '';
     const rows = await db.getAll(`
     SELECT DISTINCT
@@ -158,7 +159,8 @@ async function restoreOrUpdateExistingBox(args) {
     UPDATE c_zettel_box
     SET ${assignments.join(', ')}
     WHERE id = ?
-    `, params);
+      AND TRIM(COALESCE(user_no, '')) = ?
+    `, [...params, userId]);
     return wasDeleted;
 }
 async function insertBoxNode(args) {
@@ -186,7 +188,7 @@ export async function addBox(db, input) {
     const parsed = parseAddBoxInput(input);
     const columnNames = await getTableColumns(db, 'c_zettel_box');
     assertCanWriteBox(columnNames, parsed.userId, 'insert');
-    const nodesByPath = await loadBoxNodesByPath(db);
+    const nodesByPath = await loadBoxNodesByPath(db, parsed.userId);
     const existingLeaf = nodesByPath.get(normalizeLookupKey(parsed.path));
     if (existingLeaf && existingLeaf.isDel !== 1) {
         throw buildBoxExistsError(parsed.path, [existingLeaf.id]);
@@ -286,7 +288,7 @@ export async function inspectAddBox(db, input) {
     const parsed = parseAddBoxInput(input);
     const columnNames = await getTableColumns(db, 'c_zettel_box');
     assertCanWriteBox(columnNames, parsed.userId, 'insert');
-    const nodesByPath = await loadBoxNodesByPath(db);
+    const nodesByPath = await loadBoxNodesByPath(db, parsed.userId);
     const existingLeaf = nodesByPath.get(normalizeLookupKey(parsed.path));
     if (existingLeaf && existingLeaf.isDel !== 1) {
         throw buildBoxExistsError(parsed.path, [existingLeaf.id]);

package/dist/commands/boxes/store.js

@@ -20,7 +20,7 @@ export function assertCanWriteBox(columnNames, userId, action) {
 export async function loadAllBoxNodes(db, options = {}) {
     const userId = trimString(options.userId);
     const userFilter = userId
-        ? `AND (TRIM(COALESCE(user_no, '')) = ? OR TRIM(COALESCE(user_no, '')) = '')`
+        ? `AND TRIM(COALESCE(user_no, '')) = ?`
         : '';
     const rows = await db.getAll(`
     SELECT

package/dist/commands/config/index.js

@@ -5,6 +5,7 @@ import { FORMAT_OPTIONS } from '../schema/globalOptions.js';
 import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printSuccess } from '../../utils/output.js';
 import { redactAuthorization } from '../../utils/redact.js';
+import { MAX_SYNC_TIMEOUT_MS, parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
 export function sanitizeConfigForDisplay(config) {
     if (!config || typeof config !== 'object' || Array.isArray(config)) {
         return config;
@@ -13,6 +14,7 @@ export function sanitizeConfigForDisplay(config) {
     const auth = clone?.auth;
     if (auth && typeof auth === 'object') {
         auth.authorization = redactAuthorization(auth.authorization);
+        delete auth.stateRevision;
     }
     delete clone.powersync;
     return clone;
@@ -38,13 +40,13 @@ async function runConfigSet(context) {
         throw new DinoxError(`Unknown config key: ${key}`);
     }
     if (key === 'sync.timeoutMs') {
-        const parsed = Number(value);
-        if (!Number.isFinite(parsed) || parsed <= 0) {
-            throw new DinoxError('sync.timeoutMs must be a positive integer');
+        const parsed = parseSyncTimeoutMs(value, { label: 'sync.timeoutMs' });
+        if (parsed === undefined) {
+            throw new DinoxError(`sync.timeoutMs must be a positive integer no greater than ${MAX_SYNC_TIMEOUT_MS}`);
         }
-        await setConfigValue(key, Math.trunc(parsed));
+        await setConfigValue(key, parsed);
         if (getRequestedStructuredOutputFormat()) {
-            printSuccess({ ok: true, key, value: Math.trunc(parsed) });
+            printSuccess({ ok: true, key, value: parsed });
         }
         return;
     }

package/dist/commands/descriptor/register.js

@@ -1,3 +1,5 @@
+import { DinoxError } from '../../utils/errors.js';
+import { getRequestedStructuredOutputFormat } from '../../utils/output.js';
 import { toSchemaArgument, toSchemaOption } from './types.js';
 function deriveArgumentKey(syntax) {
     const normalized = syntax.trim().replace(/^[<[.]+|[>\].]+$/g, '');
@@ -64,6 +66,13 @@ export function registerCommandGroup(program, group) {
         });
     }
     parent.action((_options, command) => {
+        if (getRequestedStructuredOutputFormat()) {
+            throw new DinoxError(`Missing subcommand for \`dino ${group.name}\``, {
+                code: 'USAGE_ERROR',
+                suggestion: `Run \`dino ${group.name} --help\` to list available subcommands.`,
+                recoverable: true,
+            });
+        }
         command.outputHelp();
     });
     return parent;

package/dist/commands/doctor.d.ts

@@ -0,0 +1,123 @@
+import { Command } from 'commander';
+import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
+import { loadConfig } from '../config/store.js';
+import { resolveConfig } from '../config/resolve.js';
+import type { ResolvedDinoxConfig } from '../config/types.js';
+import { shutdownDaemonForExclusiveAccess } from '../daemon/client.js';
+import { restartDaemonLocked } from '../daemon/index.js';
+import { acquireDaemonStartLock } from '../daemon/pid.js';
+import type { DaemonPidInfo } from '../daemon/pid.js';
+import { type DaemonPingResult } from '../daemon/types.js';
+import { connectPowerSync } from '../powersync/runtime.js';
+import { type NoteTokenIndexInspection } from '../powersync/tokenIndex.js';
+import type { CommandDescriptor, CommandExecutionContext } from './descriptor/types.js';
+type HealthStatus = 'ok' | 'warn' | 'error' | 'skipped';
+type DoctorFix = {
+    target: 'index' | 'upload_queue' | 'daemon';
+    status: HealthStatus;
+    message: string;
+};
+type DoctorPayload = {
+    ok: true;
+    healthy: boolean;
+    fixed: boolean;
+    auth: {
+        status: HealthStatus;
+        logged_in: boolean;
+        verified: boolean;
+        user_id: string | null;
+        username: string | null;
+        email: string | null;
+        error?: string;
+    };
+    sync: {
+        status: HealthStatus;
+        connected: boolean;
+        connecting: boolean;
+        has_synced: boolean;
+        last_synced_at: string | null;
+        upload_queue: number | null;
+        downloading: boolean;
+        uploading: boolean;
+        download_error?: {
+            name: string;
+            message: string;
+        };
+        upload_error?: {
+            name: string;
+            message: string;
+        };
+        error?: string;
+    };
+    index: NoteTokenIndexInspection & {
+        status: HealthStatus;
+    };
+    daemon: {
+        status: HealthStatus;
+        running: boolean;
+        pid: number | null;
+        port: number | null;
+        transport: 'socket';
+        socket_path: string | null;
+        version: string | null;
+        user_id: string | null;
+        authenticated: boolean | null;
+        version_match: boolean | null;
+        account_match: boolean | null;
+        token_match: boolean | null;
+        runtime_config_match: boolean | null;
+        error?: string;
+    };
+    db: {
+        status: HealthStatus;
+        path: string;
+        integrity: 'ok' | 'error' | 'unknown';
+        message?: string;
+    };
+    fixes: DoctorFix[];
+    issues: string[];
+};
+type DoctorRuntime = {
+    db: Awaited<ReturnType<typeof connectPowerSync>>['db'];
+    dbPath: string;
+    config: ResolvedDinoxConfig;
+    authError: string | null;
+    syncError: string | null;
+    offline: boolean;
+    timeoutMs: number;
+    releaseOwner: () => Promise<void>;
+    daemonBefore: DoctorDaemonSnapshot;
+    daemonWasStopped: boolean;
+    releaseDaemonStartLock: () => Promise<void>;
+    daemonStartLockReleased: boolean;
+    released: boolean;
+};
+type DoctorDaemonSnapshot = {
+    info: DaemonPingResult | null;
+    pidInfo: DaemonPidInfo | null;
+    socketExists: boolean;
+};
+type DoctorPreparationDependencies = {
+    loadConfig: typeof loadConfig;
+    resolveConfig: typeof resolveConfig;
+    hydrateAuthIdentity: typeof hydrateResolvedAuthIdentity;
+    acquireDaemonStartLock: typeof acquireDaemonStartLock;
+    captureDaemonSnapshot: typeof captureDaemonSnapshot;
+    shutdownDaemon: typeof shutdownDaemonForExclusiveAccess;
+    connectPowerSync: typeof connectPowerSync;
+    restartDaemon: typeof restartDaemonLocked;
+};
+export declare function prepareDoctorRuntime(context: CommandExecutionContext, overrides?: Partial<DoctorPreparationDependencies>): Promise<DoctorRuntime>;
+declare function captureDaemonSnapshot(): Promise<DoctorDaemonSnapshot>;
+export declare function applyDatabaseFixes(runtime: DoctorRuntime, payload: DoctorPayload): Promise<void>;
+export declare function releaseDoctorRuntime(runtime: DoctorRuntime): Promise<void>;
+export declare function releaseDoctorDaemonStartLock(runtime: DoctorRuntime): Promise<void>;
+type DoctorDaemonDependencies = {
+    restart: typeof restartDaemonLocked;
+    capture: typeof captureDaemonSnapshot;
+};
+export declare function applyDoctorDaemonLifecycle(runtime: DoctorRuntime, payload: DoctorPayload, fixRequested: boolean, dependencies?: DoctorDaemonDependencies): Promise<void>;
+export declare function finalizeDoctorPayload(payload: DoctorPayload): DoctorPayload;
+export declare const doctorCommandDescriptor: CommandDescriptor;
+export declare function registerDoctorCommand(program: Command): void;
+export {};