@dinoxx/dinox-cli 1.0.0

package/dist/commands/boxes/index.js

@@ -0,0 +1,107 @@
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { DinoxError } from '../../utils/errors.js';
+import { printYaml } from '../../utils/output.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
+import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { addBox, listBoxes } from './repo.js';
+function parseSyncTimeoutMs(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError('--sync-timeout must be a positive integer');
+    }
+    return Math.trunc(parsed);
+}
+async function syncBeforeBoxCommand(db, offline, timeoutMs) {
+    if (offline) {
+        return;
+    }
+    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
+    await syncNoteTokenIndex(db);
+}
+async function runBoxListCommand(options, command) {
+    const globals = command.optsWithGlobals?.() ?? {};
+    const offline = Boolean(options.offline ?? globals.offline);
+    const config = resolveConfig(await loadConfig());
+    const timeoutMs = parseSyncTimeoutMs(options.syncTimeout ?? globals.syncTimeout) ?? config.sync.timeoutMs;
+    const { db } = await connectPowerSync({ config, offline, timeoutMs });
+    try {
+        await syncBeforeBoxCommand(db, offline, timeoutMs);
+        const boxes = await listBoxes(db);
+        printYaml(boxes);
+    }
+    finally {
+        await db.close().catch(() => undefined);
+    }
+}
+export function registerBoxesCommand(program) {
+    const box = program.command('box').description('Manage zettel boxes');
+    box
+        .command('list')
+        .description('List zettel boxes (id and name) from c_zettel_box')
+        .option('--offline', 'skip connect/sync and only use local cache')
+        .option('--sync-timeout <ms>', 'override sync/connect timeout (milliseconds)')
+        .action(runBoxListCommand);
+    box
+        .command('add')
+        .description('Create a new zettel box in c_zettel_box')
+        .argument('[name]', 'box name')
+        .option('--name <string>', 'box name (alternative to positional name)')
+        .option('--description <string>', 'box purpose/usage description (helps AI route notes to this box)')
+        .option('--color <string>', 'box color')
+        .option('--json', 'output machine-readable YAML')
+        .option('--offline', 'skip connect/sync and only use local cache')
+        .option('--sync-timeout <ms>', 'override sync/connect timeout (milliseconds)')
+        .action(async (nameArg, options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(options.offline ?? globals.offline);
+        const jsonOutput = Boolean(options.json ?? globals.json);
+        const optionName = typeof options.name === 'string' ? 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>`.');
+        }
+        if (nameArg && optionName && nameArg.trim() !== optionName.trim()) {
+            throw new DinoxError('Conflicting box name values from positional argument and --name option.');
+        }
+        const rawConfig = await loadConfig();
+        const config = resolveConfig(rawConfig);
+        const timeoutMs = parseSyncTimeoutMs(options.syncTimeout ?? globals.syncTimeout) ?? config.sync.timeoutMs;
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeBoxCommand(db, offline, timeoutMs);
+            const result = await addBox(db, {
+                name,
+                userId: identity.userId,
+                description: typeof options.description === 'string' ? options.description : undefined,
+                color: typeof options.color === 'string' ? options.color : undefined,
+            });
+            if (!offline && !config.powersync.uploadBaseUrl) {
+                console.log('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 };
+            if (jsonOutput) {
+                printYaml(payload);
+                return;
+            }
+            console.log(result.id);
+            if (stale && !offline) {
+                console.log('warning: sync timed out; results may be stale');
+            }
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    box.action((_options, command) => {
+        command.outputHelp();
+    });
+}

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

@@ -0,0 +1,21 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+export type BoxListItem = {
+    id: string;
+    name: string;
+    description: string;
+};
+export type AddBoxInput = {
+    name: string;
+    userId: string;
+    description?: string;
+    color?: string;
+};
+export type AddBoxResult = {
+    id: string;
+    name: string;
+    description: string;
+    color: string;
+    restored: boolean;
+};
+export declare function listBoxes(db: AbstractPowerSyncDatabase): Promise<BoxListItem[]>;
+export declare function addBox(db: AbstractPowerSyncDatabase, input: AddBoxInput): Promise<AddBoxResult>;

package/dist/commands/boxes/repo.js

@@ -0,0 +1,154 @@
+import { generateId } from '../../utils/id.js';
+import { DinoxError } from '../../utils/errors.js';
+function normalizeName(value) {
+    return value.trim();
+}
+function normalizeLookup(value) {
+    return normalizeName(value).toLowerCase();
+}
+async function getBoxColumns(db) {
+    const rows = await db.getAll('PRAGMA table_info(c_zettel_box)', []);
+    return new Set(rows.map((row) => row.name).filter(Boolean));
+}
+async function listBoxRowsForWrite(db) {
+    return db.getAll(`
+    SELECT
+      TRIM(COALESCE(id, '')) AS id,
+      TRIM(COALESCE(name, '')) AS name,
+      TRIM(COALESCE(description, '')) AS description,
+      TRIM(COALESCE(color, '')) AS color,
+      is_del,
+      TRIM(COALESCE(user_no, '')) AS user_no
+    FROM c_zettel_box
+    WHERE TRIM(COALESCE(id, '')) <> ''
+    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
+    `, []);
+}
+export async function listBoxes(db) {
+    const rows = await db.getAll(`
+    SELECT DISTINCT
+      TRIM(COALESCE(id, '')) AS id,
+      TRIM(COALESCE(name, '')) AS name,
+      TRIM(COALESCE(description, '')) AS description
+    FROM c_zettel_box
+    WHERE (is_del IS NULL OR is_del = 0)
+      AND TRIM(COALESCE(id, '')) <> ''
+    ORDER BY name COLLATE NOCASE ASC, id ASC
+    `, []);
+    return rows
+        .map((row) => ({
+        id: row.id?.trim() ?? '',
+        name: row.name?.trim() ?? '',
+        description: row.description?.trim() ?? '',
+    }))
+        .filter((row) => row.id.length > 0);
+}
+export async function addBox(db, input) {
+    const userId = input.userId.trim();
+    const name = normalizeName(input.name);
+    if (!name) {
+        throw new DinoxError('Box name is required');
+    }
+    const description = normalizeName(input.description ?? '');
+    const color = normalizeName(input.color ?? '');
+    const lookup = normalizeLookup(name);
+    const columnNames = await getBoxColumns(db);
+    const requiredColumns = ['id', 'name', 'user_no'];
+    const missingRequired = requiredColumns.filter((column) => !columnNames.has(column));
+    if (missingRequired.length > 0) {
+        throw new DinoxError(`c_zettel_box table is missing required columns: ${missingRequired.join(', ')}`);
+    }
+    if (!userId) {
+        throw new DinoxError('c_zettel_box insert requires user_no. Missing persisted userId. Run `dino auth login` first.');
+    }
+    const rows = await listBoxRowsForWrite(db);
+    const sameNameRows = rows.filter((row) => normalizeLookup(row.name ?? '') === lookup);
+    const activeRows = sameNameRows.filter((row) => row.is_del !== 1);
+    if (activeRows.length > 0) {
+        const ids = activeRows.map((row) => row.id?.trim() ?? '').filter(Boolean);
+        throw new DinoxError(`Zettel box already exists: ${name}`, {
+            details: {
+                type: 'box_exists',
+                name,
+                ids,
+                question: 'This box already exists. Do you want to keep using the existing box?',
+            },
+        });
+    }
+    const timestamp = new Date().toISOString();
+    const deletedRow = sameNameRows.find((row) => (row.id?.trim() ?? '').length > 0);
+    if (deletedRow?.id) {
+        const setParts = [];
+        const params = [];
+        const setValue = (column, value) => {
+            if (!columnNames.has(column)) {
+                return;
+            }
+            setParts.push(`${column} = ?`);
+            params.push(value);
+        };
+        setValue('name', name);
+        setValue('is_del', 0);
+        setValue('updated_at', timestamp);
+        if (description) {
+            setValue('description', description);
+        }
+        if (color) {
+            setValue('color', color);
+        }
+        setValue('user_no', userId);
+        if (setParts.length > 0) {
+            params.push(deletedRow.id);
+            await db.execute(`
+        UPDATE c_zettel_box
+        SET ${setParts.join(', ')}
+        WHERE id = ?
+        `, params);
+        }
+        return {
+            id: deletedRow.id,
+            name,
+            description: description || (deletedRow.description?.trim() ?? ''),
+            color: color || (deletedRow.color?.trim() ?? ''),
+            restored: true,
+        };
+    }
+    const id = generateId();
+    const insertEntries = [];
+    const pushInsert = (column, value) => {
+        if (!columnNames.has(column)) {
+            return;
+        }
+        insertEntries.push([column, value]);
+    };
+    pushInsert('id', id);
+    pushInsert('name', name);
+    pushInsert('description', description || null);
+    pushInsert('color', color || null);
+    pushInsert('priority', 0);
+    pushInsert('is_show', 1);
+    pushInsert('cover_url', '');
+    pushInsert('created_at', timestamp);
+    pushInsert('updated_at', timestamp);
+    pushInsert('extra_data', '{}');
+    pushInsert('user_no', userId);
+    pushInsert('is_del', 0);
+    const insertColumns = insertEntries.map(([column]) => column);
+    const placeholders = insertColumns.map(() => '?').join(', ');
+    const insertParams = insertEntries.map(([, value]) => value);
+    await db.execute(`
+    INSERT INTO c_zettel_box (${insertColumns.join(', ')})
+    VALUES (${placeholders})
+    `, insertParams);
+    return {
+        id,
+        name,
+        description,
+        color,
+        restored: false,
+    };
+}

package/dist/commands/config/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerConfigCommands(program: Command): void;

package/dist/commands/config/index.js

@@ -0,0 +1,67 @@
+import { isConfigKey, isFixedConfigKey, isReadableConfigKey } from '../../config/keys.js';
+import { getConfigValue, loadConfig, setConfigValue } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { redactAuthorization } from '../../utils/redact.js';
+import { DinoxError } from '../../utils/errors.js';
+import { printYaml } from '../../utils/output.js';
+function redactConfigForDisplay(config) {
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+        return config;
+    }
+    const clone = JSON.parse(JSON.stringify(config));
+    const auth = clone?.auth;
+    if (auth && typeof auth === 'object') {
+        auth.authorization = redactAuthorization(auth.authorization);
+    }
+    return clone;
+}
+function getByPath(value, keyPath) {
+    return keyPath.split('.').reduce((current, segment) => {
+        if (!current || typeof current !== 'object') {
+            return undefined;
+        }
+        return current[segment];
+    }, value);
+}
+export function registerConfigCommands(program) {
+    const configCmd = program.command('config').description('Read and write Dinox configuration');
+    configCmd
+        .command('get')
+        .description('Get configuration value')
+        .argument('[key]', 'config key (dot path)')
+        .action(async (key) => {
+        if (key && !isReadableConfigKey(key)) {
+            throw new DinoxError(`Unknown config key: ${key}`);
+        }
+        if (key && isFixedConfigKey(key)) {
+            const resolved = resolveConfig(await loadConfig());
+            printYaml(getByPath(resolved, key));
+            return;
+        }
+        const value = await getConfigValue(key);
+        const redacted = key ? value : redactConfigForDisplay(value);
+        printYaml(redacted);
+    });
+    configCmd
+        .command('set')
+        .description('Set configuration value')
+        .argument('<key>', 'config key (dot path)')
+        .argument('<value>', 'value')
+        .action(async (key, value) => {
+        if (isFixedConfigKey(key)) {
+            throw new DinoxError(`${key} is fixed and cannot be changed`);
+        }
+        if (!isConfigKey(key)) {
+            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');
+            }
+            await setConfigValue(key, Math.trunc(parsed));
+            return;
+        }
+        await setConfigValue(key, value);
+    });
+}

package/dist/commands/info/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerInfoCommand(program: Command): void;

package/dist/commands/info/index.js

@@ -0,0 +1,20 @@
+import { printYaml } from '../../utils/output.js';
+import { getPackageVersion } from '../../utils/version.js';
+export function registerInfoCommand(program) {
+    program
+        .command('info')
+        .description('Show CLI version info')
+        .action((_options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const jsonOutput = Boolean(globals.json);
+        const payload = {
+            name: 'dino',
+            version: getPackageVersion(),
+        };
+        if (jsonOutput) {
+            printYaml(payload);
+            return;
+        }
+        console.log(payload.version);
+    });
+}

package/dist/commands/notes/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerNoteCommands(program: Command): void;

package/dist/commands/notes/index.js

@@ -0,0 +1,271 @@
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { DinoxError } from '../../utils/errors.js';
+import { readStringOrFile } from '../../utils/argValue.js';
+import { generateId } from '../../utils/id.js';
+import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
+import { printYaml } from '../../utils/output.js';
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
+import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
+import { createNote, getNote, getNoteDetail, resolveZettelBoxIdsForCreate, searchNotes, softDeleteNote, validateTagsForCreate, } from './repo.js';
+import { parseCreatedAtRange } from './searchTime.js';
+function parseSyncTimeoutMs(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError('--sync-timeout must be a positive integer');
+    }
+    return Math.trunc(parsed);
+}
+function parseNoteType(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (normalized === 'note' || normalized === 'crawl') {
+        return normalized;
+    }
+    throw new DinoxError('--type must be one of: note, crawl');
+}
+async function parseStringInput(value) {
+    return readStringOrFile(value);
+}
+function parseListInput(raw, optionName) {
+    const value = raw.trim();
+    if (!value) {
+        return [];
+    }
+    if (value.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(value);
+            if (!Array.isArray(parsed)) {
+                throw new DinoxError(`${optionName} must be a JSON array`);
+            }
+            return Array.from(new Set(parsed
+                .map((entry) => String(entry).trim())
+                .filter((entry) => entry.length > 0)));
+        }
+        catch (error) {
+            if (error instanceof DinoxError) {
+                throw error;
+            }
+            throw new DinoxError(`Invalid list for ${optionName}`, { cause: error });
+        }
+    }
+    return Array.from(new Set(value
+        .split(/[\n,，]/g)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)));
+}
+async function parseStringListInput(value, optionName) {
+    const raw = await readStringOrFile(value);
+    return parseListInput(raw, optionName);
+}
+async function syncBeforeNoteCommand(db, offline, timeoutMs) {
+    if (offline) {
+        return;
+    }
+    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
+    await syncNoteTokenIndex(db);
+}
+export function registerNoteCommands(program) {
+    const note = program.command('note').description('Manage notes');
+    note
+        .command('search')
+        .description('Search notes and return note list for AI agents')
+        .argument('[query]', 'search query')
+        .option('--tags <expr>', 'tag expression with AND/OR/NOT, e.g. \'(work OR life) AND NOT archived\'')
+        .option('--from <date>', 'created_at start (YYYY-MM-DD or ISO datetime)')
+        .option('--to <date>', 'created_at end (YYYY-MM-DD or ISO datetime)')
+        .option('--days <n>', 'recent N days by created_at (cannot be used with --from/--to)')
+        .option('--include-deleted', 'include soft-deleted notes')
+        .action(async (query, options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeNoteCommand(db, offline, timeoutMs);
+            const keyword = query?.trim() ?? '';
+            const tagsExpression = typeof options.tags === 'string' ? options.tags.trim() : '';
+            const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
+                from: options.from,
+                to: options.to,
+                days: options.days,
+            });
+            const rows = await searchNotes(db, keyword, {
+                includeDeleted: Boolean(options.includeDeleted),
+                tagsExpression: tagsExpression || undefined,
+                createdAtFrom,
+                createdAtTo,
+            });
+            printYaml(rows);
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    note
+        .command('get')
+        .description('Get note by id')
+        .argument('<id>', 'note id')
+        .action(async (id, _options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const jsonOutput = Boolean(globals.json);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeNoteCommand(db, offline, timeoutMs);
+            const note = await getNote(db, id);
+            if (!note) {
+                throw new DinoxError(`Note not found: ${id}`);
+            }
+            if (jsonOutput) {
+                printYaml({ stale, note });
+                return;
+            }
+            if (stale && !offline) {
+                console.log('warning: sync timed out; result may be stale');
+            }
+            console.log(`${note.id}`);
+            console.log(`title: ${note.title ?? ''}`);
+            if (note.updated_at) {
+                console.log(`updated_at: ${note.updated_at}`);
+            }
+            if (note.is_del) {
+                console.log('is_del: 1');
+            }
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    note
+        .command('detail')
+        .description('Get full note details by id')
+        .argument('<id>', 'note id')
+        .action(async (id, _options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeNoteCommand(db, offline, timeoutMs);
+            const note = await getNoteDetail(db, id);
+            if (!note) {
+                throw new DinoxError(`Note not found: ${id}`);
+            }
+            printYaml(note);
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    note
+        .command('create')
+        .description('Create a new note')
+        .requiredOption('--title <string>', 'note title')
+        .requiredOption('--content <string|@file>', 'markdown content')
+        .option('--type <note|crawl>', 'note type: note or crawl', 'crawl')
+        .option('--tags <string|@file>', 'tag list (JSON array or comma/newline-separated)')
+        .option('--zettel_boxes <string|@file>', 'zettel box names (JSON array or comma/newline-separated)')
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const jsonOutput = Boolean(globals.json);
+        const rawConfig = await loadConfig();
+        const config = resolveConfig(rawConfig);
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeNoteCommand(db, offline, timeoutMs);
+            const contentMd = await parseStringInput(options.content);
+            const { contentJson, contentText } = convertMarkdownToNoteContent(contentMd);
+            const tagsInput = typeof options.tags === 'string'
+                ? await parseStringListInput(options.tags, '--tags')
+                : [];
+            const tags = await validateTagsForCreate(db, tagsInput);
+            const zettelBoxesOption = typeof options.zettel_boxes === 'string'
+                ? options.zettel_boxes
+                : typeof options.zettelBoxes === 'string'
+                    ? options.zettelBoxes
+                    : undefined;
+            const zettelBoxNames = zettelBoxesOption
+                ? await parseStringListInput(zettelBoxesOption, '--zettel_boxes')
+                : [];
+            const zettelBoxIds = await resolveZettelBoxIdsForCreate(db, zettelBoxNames);
+            const noteType = parseNoteType(options.type);
+            const id = generateId();
+            await createNote(db, {
+                id,
+                title: String(options.title),
+                noteType,
+                contentMd,
+                contentJson,
+                contentText,
+                tags,
+                zettelBoxIds,
+                userId: identity.userId,
+            });
+            if (!offline && !config.powersync.uploadBaseUrl) {
+                console.log('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, id, stale: offline ? true : stale };
+            if (jsonOutput) {
+                printYaml(payload);
+            }
+            else {
+                console.log(id);
+                if (stale && !offline) {
+                    console.log('warning: sync timed out; local cache may be stale');
+                }
+            }
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    note
+        .command('delete')
+        .description('Soft-delete a note (is_del=1)')
+        .argument('<id>', 'note id')
+        .action(async (id, _options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const jsonOutput = Boolean(globals.json);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeNoteCommand(db, offline, timeoutMs);
+            await softDeleteNote(db, id);
+            if (!offline && !config.powersync.uploadBaseUrl) {
+                console.log('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, id, stale: offline ? true : stale };
+            if (jsonOutput) {
+                printYaml(payload);
+            }
+            else {
+                console.log('OK');
+                if (stale && !offline) {
+                    console.log('warning: sync timed out; local cache may be stale');
+                }
+            }
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+}