@dinoxx/dinox-cli 1.0.20 → 1.0.22

package/dist/commands/boxes/index.js

@@ -1,41 +1,39 @@
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
-import { loadConfig } from '../../config/store.js';
-import { resolveConfig } from '../../config/resolve.js';
-import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
-import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
 import { registerCommandGroup } from '../descriptor/register.js';
-import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
-import { buildBoxAddDryRunPreview } from '../writeDryRun.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { buildBoxAddDryRunPreview, buildBoxMutationDryRunPreview } from '../writeDryRun.js';
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
-import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
 import { addBox, inspectAddBox, listBoxes } from './repo.js';
-const BOX_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
-async function syncBeforeBoxCommand(db, offline, timeoutMs) {
-    if (offline) {
-        return;
-    }
-    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
-    await syncNoteTokenIndex(db);
+import { getBoxStats, getBoxTree, inspectBoxCleanup, mergeBox, moveBox, renameBox, } from './operations.js';
+const BOX_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+async function runBoxList(context) {
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime, { syncTokenIndex: true });
+        printSuccess(await listBoxes(runtime.db, { userId: identity.userId }));
+    });
 }
-async function withBoxDb(context, run) {
-    const rawConfig = await loadConfig();
-    const config = resolveConfig(rawConfig);
-    const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? config.sync.timeoutMs;
-    const offline = Boolean(context.globals.offline);
-    const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
-    try {
-        await run({ db, config, rawConfig, offline, timeoutMs, stale });
-    }
-    finally {
-        await db.close().catch(() => undefined);
-    }
+async function runBoxTree(context) {
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime, { syncTokenIndex: true });
+        printSuccess({
+            stale: commandStale(runtime),
+            tree: await getBoxTree(runtime.db, { userId: identity.userId }),
+        });
+    });
 }
-async function runBoxList(context) {
-    await withBoxDb(context, async ({ db, offline, timeoutMs }) => {
-        await syncBeforeBoxCommand(db, offline, timeoutMs);
-        printSuccess(await listBoxes(db));
+async function runBoxStats(context) {
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime, { syncTokenIndex: true });
+        printSuccess({
+            stale: commandStale(runtime),
+            ...(await getBoxStats(runtime.db, { userId: identity.userId })),
+        });
     });
 }
 async function runBoxAdd(context) {
@@ -43,22 +41,22 @@ async function runBoxAdd(context) {
     const optionName = typeof context.options.name === 'string' ? context.options.name : undefined;
     const name = (nameArg ?? optionName ?? '').trim();
     if (!name) {
-        throw new DinoxError('Box name is required. Use `dino box add <name>` or `dino box add --name <name>`.');
+        throw new DinoxError('Box path is required. Use `dino box add <path>` or `dino box add --name <path>`.');
     }
     if (nameArg && optionName && nameArg.trim() !== optionName.trim()) {
-        throw new DinoxError('Conflicting box name values from positional argument and --name option.');
+        throw new DinoxError('Conflicting box path values from positional argument and --name option.');
     }
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-    await withBoxDb(context, async ({ db, config, rawConfig, offline, timeoutMs, stale }) => {
-        const identity = await resolveAuthIdentity(rawConfig, config);
-        await syncBeforeBoxCommand(db, offline, timeoutMs);
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime, { syncTokenIndex: true });
         const description = typeof context.options.description === 'string' ? context.options.description : undefined;
         const color = typeof context.options.color === 'string' ? context.options.color : undefined;
         if (Boolean(context.options.dryRun)) {
             printDryRunPreview(buildBoxAddDryRunPreview({
-                config,
-                offline,
-                ...(await inspectAddBox(db, {
+                config: runtime.config,
+                offline: runtime.offline,
+                ...(await inspectAddBox(runtime.db, {
                     name,
                     userId: identity.userId,
                     description,
@@ -67,27 +65,131 @@ async function runBoxAdd(context) {
             }));
             return;
         }
-        const result = await addBox(db, {
+        const result = await addBox(runtime.db, {
             name,
             userId: identity.userId,
             description,
             color,
         });
-        if (!offline && !config.powersync.uploadBaseUrl) {
-            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
-        }
-        if (!offline) {
-            await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
-        }
-        const payload = { ok: true, stale: offline ? true : stale, ...result };
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        const payload = { ok: true, stale: commandStale(runtime), ...result };
         if (structuredOutput) {
             printSuccess(payload);
             return;
         }
         printHumanReadableLine(result.id);
-        if (stale && !offline) {
-            printHumanReadableLine('warning: sync timed out; results may be stale');
+        printStaleCacheWarning(runtime, 'warning: sync timed out; results may be stale');
+    });
+}
+async function withBoxWriteRuntime(context, run) {
+    return withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime, { syncTokenIndex: true });
+        return run({ runtime, userId: identity.userId });
+    });
+}
+function requireArg(value, message) {
+    const trimmed = value?.trim() ?? '';
+    if (!trimmed) {
+        throw new DinoxError(message);
+    }
+    return trimmed;
+}
+async function runBoxRename(context) {
+    const path = requireArg(context.args.path, 'Box path is required');
+    const newName = requireArg(context.args.newName, 'New box name is required');
+    await withBoxWriteRuntime(context, async ({ runtime, userId }) => {
+        const result = await renameBox(runtime.db, { path, newName, userId }, { dryRun: Boolean(context.options.dryRun) });
+        if (Boolean(context.options.dryRun)) {
+            printDryRunPreview(buildBoxMutationDryRunPreview({
+                config: runtime.config,
+                offline: runtime.offline,
+                command: 'dino box rename',
+                action: 'rename_box',
+                risk: 'write',
+                summary: `Rename zettel box "${result.fromPath}" to "${result.toPath}".`,
+                inputs: { path, new_name: newName },
+                changes: { updated_boxes: result.updatedBoxes },
+            }));
+            return;
+        }
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        printSuccess({ ok: true, stale: commandStale(runtime), ...result });
+    });
+}
+async function runBoxMove(context) {
+    const path = requireArg(context.args.path, 'Box path is required');
+    const to = typeof context.options.to === 'string' ? context.options.to.trim() : '';
+    if (!to) {
+        throw new DinoxError('--to is required');
+    }
+    await withBoxWriteRuntime(context, async ({ runtime, userId }) => {
+        const result = await moveBox(runtime.db, { path, to, userId }, { dryRun: Boolean(context.options.dryRun) });
+        if (Boolean(context.options.dryRun)) {
+            printDryRunPreview(buildBoxMutationDryRunPreview({
+                config: runtime.config,
+                offline: runtime.offline,
+                command: 'dino box move',
+                action: 'move_box',
+                risk: 'write',
+                summary: `Move zettel box "${result.fromPath}" to "${result.toPath}".`,
+                inputs: { path, to },
+                changes: { updated_boxes: result.updatedBoxes },
+            }));
+            return;
+        }
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        printSuccess({ ok: true, stale: commandStale(runtime), ...result });
+    });
+}
+async function runBoxMerge(context) {
+    const from = requireArg(context.args.from, 'Source box path is required');
+    const to = requireArg(context.args.to, 'Target box path is required');
+    await withBoxWriteRuntime(context, async ({ runtime, userId }) => {
+        const result = await mergeBox(runtime.db, { from, to, userId }, { dryRun: Boolean(context.options.dryRun) });
+        if (Boolean(context.options.dryRun)) {
+            printDryRunPreview(buildBoxMutationDryRunPreview({
+                config: runtime.config,
+                offline: runtime.offline,
+                command: 'dino box merge',
+                action: 'merge_box',
+                risk: 'high-risk-write',
+                summary: `Merge zettel box subtree "${result.fromPath}" into "${result.toPath}".`,
+                inputs: { from, to },
+                changes: {
+                    soft_deleted_box_ids: result.softDeletedBoxIds,
+                    updated_notes: result.updatedNotes,
+                },
+            }));
+            return;
         }
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        printSuccess({ ok: true, stale: commandStale(runtime), ...result });
+    });
+}
+async function runBoxCleanup(context) {
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime, { syncTokenIndex: true });
+        const result = await inspectBoxCleanup(runtime.db, { userId: identity.userId });
+        if (Boolean(context.options.dryRun)) {
+            printDryRunPreview(buildBoxMutationDryRunPreview({
+                config: runtime.config,
+                offline: runtime.offline,
+                command: 'dino box cleanup',
+                action: 'cleanup_boxes',
+                risk: 'write',
+                summary: `Inspect zettel box cleanup candidates (${result.issues.length} issues).`,
+                inputs: {},
+                targets: result.issues,
+            }));
+            return;
+        }
+        printSuccess({ stale: commandStale(runtime), ...result });
     });
 }
 export const boxCommandGroup = {
@@ -105,7 +207,7 @@ export const boxCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Box list payload',
-                    fields: ['id', 'name', 'description'],
+                    fields: ['id', 'name', 'path', 'parentId', 'description', 'color'],
                 },
                 examples: ['dino box list --format json'],
             },
@@ -113,10 +215,10 @@ export const boxCommandGroup = {
         },
         {
             name: 'add',
-            description: 'Create a zettel box, restoring a deleted row when possible',
-            arguments: [{ syntax: '[name]', description: 'Box name' }],
+            description: 'Create a zettel box path, restoring deleted path nodes when possible',
+            arguments: [{ syntax: '[path]', description: 'Box path, for example Work/Inbox' }],
             options: [
-                { flags: '--name <string>', description: 'Box name (alternative to positional name)' },
+                { flags: '--name <string>', description: 'Box path (alternative to positional path)' },
                 { flags: '--description <string>', description: 'Box purpose/usage description' },
                 { flags: '--color <string>', description: 'Box color' },
                 { flags: '--dry-run', description: 'Preview the write without executing it' },
@@ -129,12 +231,130 @@ export const boxCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Box creation acknowledgement',
-                    fields: ['id', 'name', 'description', 'color', 'restored', 'stale'],
+                    fields: ['id', 'name', 'path', 'parentId', 'description', 'color', 'restored', 'createdNodes', 'restoredNodes', 'stale'],
                 },
-                examples: ['dino box add "Inbox" --description "用于存放待整理的想法和资料" --format json --dry-run'],
+                examples: ['dino box add "Work/Inbox" --description "用于存放待整理的想法和资料" --format json --dry-run'],
             },
             action: runBoxAdd,
         },
+        {
+            name: 'tree',
+            description: 'Show zettel boxes as a hierarchy tree',
+            schema: {
+                path: 'box.tree',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: BOX_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Nested zettel box tree payload',
+                    fields: ['tree.id', 'tree.name', 'tree.path', 'tree.parentId', 'tree.children', 'stale'],
+                },
+                examples: ['dino box tree --format json'],
+            },
+            action: runBoxTree,
+        },
+        {
+            name: 'stats',
+            description: 'Show zettel box note counts and empty-box status',
+            schema: {
+                path: 'box.stats',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: BOX_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Zettel box statistics payload',
+                    fields: ['totalBoxes', 'emptyBoxes', 'boxes.id', 'boxes.path', 'boxes.directNoteCount', 'boxes.descendantNoteCount', 'boxes.latestNoteUpdatedAt', 'boxes.isEmpty', 'stale'],
+                },
+                examples: ['dino box stats --format json'],
+            },
+            action: runBoxStats,
+        },
+        {
+            name: 'rename',
+            description: 'Rename a zettel box and cascade descendant paths',
+            arguments: [
+                { syntax: '<path>', description: 'Existing box path' },
+                { syntax: '<new-name>', description: 'New leaf name' },
+            ],
+            options: [{ flags: '--dry-run', description: 'Preview the write without executing it' }],
+            schema: {
+                path: 'box.rename',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: BOX_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Zettel box rename result',
+                    fields: ['id', 'fromPath', 'toPath', 'updatedBoxes', 'stale'],
+                },
+                examples: ['dino box rename "Work/Inbox" "Ideas" --format json --dry-run'],
+            },
+            action: runBoxRename,
+        },
+        {
+            name: 'move',
+            description: 'Move a zettel box under another parent and cascade descendant paths',
+            arguments: [{ syntax: '<path>', description: 'Existing box path' }],
+            options: [
+                { flags: '--to <parent-path>', description: 'Target parent box path', required: true, type: 'string' },
+                { flags: '--dry-run', description: 'Preview the write without executing it' },
+            ],
+            schema: {
+                path: 'box.move',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: BOX_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Zettel box move result',
+                    fields: ['id', 'fromPath', 'toPath', 'updatedBoxes', 'stale'],
+                },
+                examples: ['dino box move "Inbox" --to "Work" --format json --dry-run'],
+            },
+            action: runBoxMove,
+        },
+        {
+            name: 'merge',
+            description: 'Merge a zettel box subtree into another box and soft-delete the source subtree',
+            arguments: [
+                { syntax: '<from>', description: 'Source box path' },
+                { syntax: '<to>', description: 'Target box path' },
+            ],
+            options: [{ flags: '--dry-run', description: 'Preview the write without executing it' }],
+            schema: {
+                path: 'box.merge',
+                risk: 'high-risk-write',
+                auth: 'required',
+                globalOptions: BOX_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Zettel box merge result',
+                    fields: ['fromId', 'toId', 'fromPath', 'toPath', 'softDeletedBoxIds', 'updatedNotes', 'stale'],
+                },
+                examples: ['dino box merge "Work/Inbox" "Work/Archive" --format json --dry-run'],
+            },
+            action: runBoxMerge,
+        },
+        {
+            name: 'cleanup',
+            description: 'Inspect zettel box cleanup candidates',
+            options: [{ flags: '--dry-run', description: 'Preview cleanup candidates without writing' }],
+            schema: {
+                path: 'box.cleanup',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: BOX_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Zettel box cleanup inspection payload',
+                    fields: ['issues', 'emptyBoxes', 'duplicatePaths', 'orphanParents', 'deletedWithActiveChildren', 'stale'],
+                },
+                examples: ['dino box cleanup --format json --dry-run'],
+            },
+            action: runBoxCleanup,
+        },
     ],
 };
 export function registerBoxesCommand(program) {

package/dist/commands/boxes/model.d.ts

@@ -0,0 +1,34 @@
+export declare const MAX_BOX_NAME_LENGTH = 500;
+export declare const MAX_BOX_PATH_LENGTH = 2000;
+export declare const MAX_BOX_DESCRIPTION_LENGTH = 200000;
+export declare const MAX_BOX_COLOR_LENGTH = 200;
+export type BoxListItem = {
+    id: string;
+    name: string;
+    path: string;
+    parentId: string | null;
+    description: string;
+    color: string;
+};
+export type MutableBoxNode = {
+    id: string;
+    name: string;
+    path: string;
+    parentId: string | null;
+    description: string;
+    color: string;
+    isDel: number | null;
+    userNo: string;
+};
+export type TableInfoRow = {
+    name: string | null;
+};
+export declare const REQUIRED_ZETTEL_BOX_COLUMNS: string[];
+export declare const REQUIRED_NOTE_BOX_COLUMNS: string[];
+export declare function canonicalizeBoxPath(value: string): string;
+export declare function normalizeBoxLookupKey(value: string): string;
+export declare function trimString(value: string | null | undefined): string;
+export declare function toNullableId(value: string | null | undefined): string | null;
+export declare function getLeafName(path: string): string;
+export declare function assertMaxLength(label: string, value: string, maxLength: number): void;
+export declare function parseStoredBoxIds(raw: string | null): string[];

package/dist/commands/boxes/model.js

@@ -0,0 +1,78 @@
+export const MAX_BOX_NAME_LENGTH = 500;
+export const MAX_BOX_PATH_LENGTH = 2000;
+export const MAX_BOX_DESCRIPTION_LENGTH = 200_000;
+export const MAX_BOX_COLOR_LENGTH = 200;
+export const REQUIRED_ZETTEL_BOX_COLUMNS = [
+    'id',
+    'name',
+    'path',
+    'parent_id',
+    'description',
+    'color',
+    'priority',
+    'is_show',
+    'cover_url',
+    'created_at',
+    'updated_at',
+    'extra_data',
+    'user_no',
+    'is_del',
+];
+export const REQUIRED_NOTE_BOX_COLUMNS = [
+    'id',
+    'zettel_boxes',
+    'updated_at',
+    'version',
+    'is_del',
+];
+export function canonicalizeBoxPath(value) {
+    return value
+        .split(/[\\/]+/g)
+        .map((segment) => segment.trim())
+        .filter(Boolean)
+        .join('/');
+}
+export function normalizeBoxLookupKey(value) {
+    return canonicalizeBoxPath(value).toLowerCase();
+}
+export function trimString(value) {
+    return value?.trim() ?? '';
+}
+export function toNullableId(value) {
+    const trimmed = trimString(value);
+    return trimmed ? trimmed : null;
+}
+export function getLeafName(path) {
+    return path.split('/').at(-1) ?? path;
+}
+export function assertMaxLength(label, value, maxLength) {
+    if (value.length > maxLength) {
+        throw new DinoxError(`${label} must be at most ${maxLength} characters`);
+    }
+}
+export function parseStoredBoxIds(raw) {
+    if (!raw) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        const result = [];
+        const seen = new Set();
+        for (const value of parsed) {
+            const normalized = String(value).trim();
+            if (!normalized || seen.has(normalized)) {
+                continue;
+            }
+            seen.add(normalized);
+            result.push(normalized);
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+import { DinoxError } from '../../utils/errors.js';

package/dist/commands/boxes/operations.d.ts

@@ -0,0 +1,86 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { BoxListItem } from './model.js';
+export type BoxTreeNode = BoxListItem & {
+    children: BoxTreeNode[];
+};
+export type BoxStatsItem = BoxListItem & {
+    directNoteCount: number;
+    descendantNoteCount: number;
+    latestNoteUpdatedAt: string | null;
+    isEmpty: boolean;
+};
+export type BoxStatsResult = {
+    totalBoxes: number;
+    emptyBoxes: number;
+    boxes: BoxStatsItem[];
+};
+export type BoxCleanupIssue = {
+    type: 'empty_box' | 'duplicate_path' | 'orphan_parent' | 'deleted_with_active_children';
+    id: string;
+    path: string;
+    name: string;
+    parentId: string | null;
+    detail: string;
+    duplicateIds?: string[];
+    childIds?: string[];
+};
+export type BoxCleanupResult = {
+    issues: BoxCleanupIssue[];
+    emptyBoxes: number;
+    duplicatePaths: number;
+    orphanParents: number;
+    deletedWithActiveChildren: number;
+};
+export type BoxRenameInput = {
+    path: string;
+    newName: string;
+    userId: string;
+};
+export type BoxMoveInput = {
+    path: string;
+    to: string;
+    userId: string;
+};
+export type BoxMergeInput = {
+    from: string;
+    to: string;
+    userId: string;
+};
+export type BoxReadInput = {
+    userId?: string;
+};
+export type BoxSubtreeChange = {
+    id: string;
+    fromPath: string;
+    toPath: string;
+};
+export type BoxRenameMoveResult = {
+    id: string;
+    fromPath: string;
+    toPath: string;
+    updatedBoxes: BoxSubtreeChange[];
+};
+export type BoxMergeResult = {
+    fromId: string;
+    toId: string;
+    fromPath: string;
+    toPath: string;
+    softDeletedBoxIds: string[];
+    updatedNotes: Array<{
+        id: string;
+        before: string[];
+        after: string[];
+    }>;
+};
+export declare function getBoxTree(db: AbstractPowerSyncDatabase, input?: BoxReadInput): Promise<BoxTreeNode[]>;
+export declare function getBoxStats(db: AbstractPowerSyncDatabase, input?: BoxReadInput): Promise<BoxStatsResult>;
+export declare function inspectBoxCleanup(db: AbstractPowerSyncDatabase, input?: BoxReadInput): Promise<BoxCleanupResult>;
+export declare function renameBox(db: AbstractPowerSyncDatabase, input: BoxRenameInput, options?: {
+    dryRun?: boolean;
+}): Promise<BoxRenameMoveResult>;
+export declare function moveBox(db: AbstractPowerSyncDatabase, input: BoxMoveInput, options?: {
+    dryRun?: boolean;
+}): Promise<BoxRenameMoveResult>;
+export declare function mergeBox(db: AbstractPowerSyncDatabase, input: BoxMergeInput, options?: {
+    dryRun?: boolean;
+}): Promise<BoxMergeResult>;