@dinoxx/dinox-cli 2.2.0 → 2.4.0

package/dist/commands/schema/renderSkills.js

@@ -5,6 +5,10 @@ import { listCommandSchemas } from './spec.js';
 const SECTION_ORDER = [
     { title: 'Auth', paths: ['auth.login', 'auth.logout', 'auth.status'] },
     { title: 'Daemon', paths: ['daemon.start', 'daemon.status', 'daemon.restart', 'daemon.stop'] },
+    {
+        title: 'Agent Gateways',
+        paths: ['gateway.detect', 'gateway.add', 'gateway.list', 'gateway.remove', 'gateway.status', 'gateway.reload', 'gateway.mcp'],
+    },
     { title: 'Doctor', paths: ['doctor'] },
     { title: 'Sync', paths: ['sync'] },
     { title: 'Schema', paths: ['schema'] },
@@ -15,7 +19,9 @@ const SECTION_ORDER = [
     { title: 'Tags', paths: ['tag.list', 'tag.tree', 'tag.stats', 'tag.add', 'tag.rename', 'tag.move', 'tag.merge', 'tag.suggest', 'tag.cleanup'] },
     { title: 'Card Boxes (Zettel Boxes)', paths: ['box.list', 'box.add', 'box.tree', 'box.stats', 'box.rename', 'box.move', 'box.merge', 'box.cleanup'] },
     { title: 'Prompts', paths: ['prompt.list', 'prompt.add'] },
-    { title: 'Saved Views', paths: ['view.list', 'view.get', 'view.fields', 'view.query', 'view.count', 'view.create', 'view.update', 'view.delete'] },
+    { title: 'Saved Views', paths: ['view.list', 'view.get', 'view.fields', 'view.query', 'view.count', 'view.analytics', 'view.note-detail', 'view.create', 'view.update', 'view.delete'] },
+    { title: 'Properties', paths: ['prop.list', 'prop.get', 'prop.create', 'prop.update', 'prop.delete', 'prop.migrate-options', 'prop.show', 'prop.set', 'prop.fill', 'prop.slots'] },
+    { title: 'Note Templates', paths: ['template.list', 'template.get', 'template.create', 'template.update', 'template.delete'] },
     { title: 'Storage', paths: ['storage.list', 'storage.test', 'storage.upload', 'storage.stats'] },
     { title: 'Config', paths: ['config.get', 'config.set'] },
     { title: 'Info', paths: ['info'] },
@@ -95,13 +101,34 @@ const GENERATED_COMMAND_SECTIONS = {
     },
     'skill:dino-manage-views': {
         title: 'Command Reference',
-        paths: ['view.list', 'view.get', 'view.fields', 'view.query', 'view.count', 'view.create', 'view.update', 'view.delete'],
-        intro: 'Use these commands as the canonical Dinox CLI interface for saved table view management and queries.',
+        paths: ['view.list', 'view.get', 'view.fields', 'view.query', 'view.count', 'view.analytics', 'view.note-detail', 'view.create', 'view.update', 'view.delete'],
+        intro: 'Use these commands as the canonical Dinox CLI interface for saved views (table, list, card), their analytics, and note-detail embeds.',
         notes: [
-            'Run `view fields` before authoring `prop.*` filters, columns, or sorts; select and multi-select filters store stable option IDs.',
-            'Pass canonical filter/config JSON through `@file` and run create, update, or delete with `--dry-run` first.',
+            'Run `view fields` before authoring `prop.*` filters, columns, or sorts; select, status, and multi-select filters store stable option IDs.',
+            'Pass filter/config JSON through `@file` and run create, update, or delete with `--dry-run` first; the dry run executes the real write in a rolled-back transaction.',
             'When executing an online command from this surface, add `--sync-timeout 20000` and keep the host timeout 5-10 seconds higher.',
             'Follow `nextOffset` while `hasMore` is true before claiming a query result is complete.',
+            'A view with `valid: false` was written by a newer client; read its raw JSON from `data.view`, and change only metadata unless you rebuild a valid config.',
+        ],
+    },
+    'skill:dino-manage-properties': {
+        title: 'Command Reference',
+        paths: ['prop.list', 'prop.get', 'prop.create', 'prop.update', 'prop.delete', 'prop.migrate-options', 'prop.show', 'prop.set', 'prop.fill', 'prop.slots'],
+        intro: 'Use these commands as the canonical Dinox CLI interface for property definitions and note property values.',
+        notes: [
+            'Run `prop list` before writing values: types, option ids, and config decide how a value is coerced.',
+            'Every write supports `--dry-run`, which runs the real write in a rolled-back transaction and shows the resulting properties.',
+            'When executing an online command from this surface, add `--sync-timeout 20000` and keep the host timeout 5-10 seconds higher.',
+            '`prop migrate-options` rewrites notes and views; real writes require `--confirm --expected-count <n>` from the dry run.',
+        ],
+    },
+    'skill:dino-manage-properties:templates': {
+        title: 'Template Command Reference',
+        paths: ['template.list', 'template.get', 'template.create', 'template.update', 'template.delete'],
+        intro: 'Note templates hold content plus the ordered property keys a new note declares; create notes from them with `dino note create --template <id>`.',
+        notes: [
+            'Run template writes with `--dry-run` first.',
+            'When executing an online command from this surface, add `--sync-timeout 20000` and keep the host timeout 5-10 seconds higher.',
         ],
     },
     'ref:dino-note:search-and-read': {
@@ -123,6 +150,7 @@ const GENERATED_COMMAND_SECTIONS = {
         intro: 'Use this generated command surface as the canonical interface for note creation.',
         notes: [
             'Use `--boxes` for public box input.',
+            '`--template <id>` hydrates the template content and declares its property keys as empty slots; `--properties` writes initial values atomically with the note.',
             'Prefer `--type note` unless the user explicitly wants a `crawl` note.',
             'Run the same command with `--sync-timeout 20000 --dry-run --format json` first and keep the host timeout 5-10 seconds higher.',
         ],

package/dist/commands/schema/spec.js

@@ -3,6 +3,7 @@ import { boxCommandGroup } from '../boxes/index.js';
 import { commandSchemasFromGroupDescriptor } from '../descriptor/register.js';
 import { standaloneCommandSchemaFromDescriptor } from '../descriptor/register.js';
 import { configCommandGroup } from '../config/index.js';
+import { gatewayCommandGroup } from '../gateway/index.js';
 import { daemonCommandGroup } from '../../daemon/index.js';
 import { doctorCommandDescriptor } from '../doctor.js';
 import { graphCommandGroup } from '../graph/index.js';
@@ -10,17 +11,20 @@ import { infoCommandDescriptor } from '../info/index.js';
 import { metaCommandGroup } from '../meta/index.js';
 import { noteCommandGroup } from '../notes/index.js';
 import { promptCommandGroup } from '../prompt/index.js';
+import { propertyCommandGroup } from '../properties/index.js';
 import { savedViewCommandGroup } from '../savedViews/index.js';
 import { schemaCommandMetadata } from './commandMetadata.js';
 import { skillsCommandGroup } from '../skills/index.js';
 import { syncCommandDescriptor } from '../sync.js';
 import { storageCommandGroup } from '../storage/index.js';
 import { tagCommandGroup } from '../tags/index.js';
+import { templateCommandGroup } from '../templates/index.js';
 import { todoCommandGroup } from '../todo/index.js';
 import { updateCommandDescriptor } from '../update.js';
 export const COMMAND_SCHEMAS = [
     ...commandSchemasFromGroupDescriptor(authCommandGroup),
     ...commandSchemasFromGroupDescriptor(configCommandGroup),
+    ...commandSchemasFromGroupDescriptor(gatewayCommandGroup),
     ...commandSchemasFromGroupDescriptor(daemonCommandGroup),
     standaloneCommandSchemaFromDescriptor(doctorCommandDescriptor),
     standaloneCommandSchemaFromDescriptor(syncCommandDescriptor),
@@ -33,6 +37,8 @@ export const COMMAND_SCHEMAS = [
     ...commandSchemasFromGroupDescriptor(boxCommandGroup),
     ...commandSchemasFromGroupDescriptor(promptCommandGroup),
     ...commandSchemasFromGroupDescriptor(savedViewCommandGroup),
+    ...commandSchemasFromGroupDescriptor(propertyCommandGroup),
+    ...commandSchemasFromGroupDescriptor(templateCommandGroup),
     ...commandSchemasFromGroupDescriptor(storageCommandGroup),
     ...commandSchemasFromGroupDescriptor(noteCommandGroup),
     ...commandSchemasFromGroupDescriptor(graphCommandGroup),

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

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import type { CommandGroupDescriptor } from '../descriptor/types.js';
+export declare const templateCommandGroup: CommandGroupDescriptor;
+export declare function registerTemplateCommands(program: Command): void;

package/dist/commands/templates/index.js

@@ -0,0 +1,290 @@
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { readStringOrFile } from '../../utils/argValue.js';
+import { printDryRunPreview } from '../../utils/dryRun.js';
+import { DinoxError } from '../../utils/errors.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
+import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
+import { isPropertyKeyValid } from '../../vendor/electron/shared/index.js';
+import { registerCommandGroup } from '../descriptor/register.js';
+import { assertExclusive, collectOption, parsePositiveIntegerOption, readJsonOption, requiredArgument, } from '../domain/options.js';
+import { parseListInput } from '../notes/runtime.js';
+import { commandStale, printStaleCacheWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS, } from '../schema/globalOptions.js';
+import { WRITE_DURABILITY_OPTION } from '../writeDurability.js';
+import { serializeNoteTemplateContent } from './model.js';
+import { createNoteTemplate, deleteNoteTemplate, getNoteTemplate, listNoteTemplates, previewCreateNoteTemplate, previewDeleteNoteTemplate, previewUpdateNoteTemplate, updateNoteTemplate, } from './repo.js';
+const TEMPLATE_GLOBAL_OPTIONS = [
+    ...FORMAT_OPTIONS,
+    ...OFFLINE_OPTIONS,
+    ...REQUIRE_SYNC_OPTIONS,
+    ...SYNC_TIMEOUT_OPTIONS,
+];
+const DRY_RUN_OPTION = { flags: '--dry-run', description: 'Run the write in a rolled-back transaction and preview the result', type: 'boolean' };
+function templateLine(template) {
+    return `${template.id}\t${template.name}\t${template.propertyKeys.join(',')}`;
+}
+/** Template output without the raw content string (the Tiptap `document` carries it). */
+function templateOutput(template) {
+    const { content: _content, ...rest } = template;
+    return rest;
+}
+async function readTemplateContent(options) {
+    assertExclusive([
+        [options.content !== undefined && options.contentJson !== undefined, '--content cannot be used with --content-json'],
+        [Boolean(options.clearContent) && (options.content !== undefined || options.contentJson !== undefined), '--clear-content cannot be used with --content or --content-json'],
+    ]);
+    if (options.clearContent)
+        return '';
+    if (typeof options.content === 'string') {
+        const markdown = await readStringOrFile(options.content);
+        return serializeNoteTemplateContent(convertMarkdownToNoteContent(markdown).contentJson);
+    }
+    if (options.contentJson !== undefined) {
+        return serializeNoteTemplateContent(await readJsonOption(options.contentJson, '--content-json', 'template.create'));
+    }
+    return undefined;
+}
+async function readPropertyKeys(options) {
+    assertExclusive([[Boolean(options.clearPropertyKeys) && (options.propertyKey !== undefined || options.propertyKeys !== undefined), '--clear-property-keys cannot be combined with --property-key or --property-keys']]);
+    if (options.clearPropertyKeys)
+        return [];
+    const keys = [
+        ...(Array.isArray(options.propertyKey) ? options.propertyKey : []),
+        ...(typeof options.propertyKeys === 'string' ? parseListInput(await readStringOrFile(options.propertyKeys), '--property-keys') : []),
+    ];
+    if (options.propertyKey === undefined && options.propertyKeys === undefined)
+        return undefined;
+    const invalid = keys.find((key) => !isPropertyKeyValid(key));
+    if (invalid !== undefined)
+        throw new DinoxError(`Invalid property key: ${invalid}`, { code: 'USAGE_ERROR' });
+    return [...new Set(keys)];
+}
+async function readWriteInput(options) {
+    const [content, propertyKeys] = await Promise.all([readTemplateContent(options), readPropertyKeys(options)]);
+    return {
+        ...(typeof options.name === 'string' ? { name: options.name } : {}),
+        ...(propertyKeys === undefined ? {} : { propertyKeys }),
+        ...(content === undefined ? {} : { content }),
+    };
+}
+async function withTemplateRuntime(context, run) {
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
+        await run(runtime, identity.userId);
+    });
+}
+async function finishWrite(runtime, options, payload, line) {
+    const receipt = await waitForMutationUpload(runtime, { durability: options.durability });
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess({ ok: true, stale: commandStale(runtime), ...payload, ...receipt });
+        return;
+    }
+    printHumanReadableLine(line);
+    printStaleCacheWarning(runtime);
+}
+async function runTemplateList(context) {
+    const limit = context.options.limit;
+    await withTemplateRuntime(context, async (runtime, userId) => {
+        const templates = await listNoteTemplates(runtime.db, { userId, limit });
+        if (getRequestedStructuredOutputFormat()) {
+            printSuccess({
+                ok: true,
+                stale: commandStale(runtime),
+                count: templates.length,
+                templates: templates.map(({ content: _content, document: _document, ...summary }) => summary),
+            });
+            return;
+        }
+        for (const template of templates)
+            printHumanReadableLine(templateLine(template));
+        if (templates.length === 0)
+            printHumanReadableLine('No note templates found.');
+        printStaleCacheWarning(runtime);
+    });
+}
+async function runTemplateGet(context) {
+    const id = requiredArgument(context.args.id, 'Template id');
+    await withTemplateRuntime(context, async (runtime, userId) => {
+        const template = await getNoteTemplate(runtime.db, { userId, id });
+        printSuccess({ ok: true, stale: commandStale(runtime), template: templateOutput(template) });
+    });
+}
+async function runTemplateCreate(context) {
+    const options = context.options;
+    const name = typeof options.name === 'string' ? options.name.trim() : '';
+    if (!name)
+        throw new DinoxError('Template name is required. Use --name <string>.', { code: 'USAGE_ERROR' });
+    const patch = await readWriteInput(options);
+    await withTemplateRuntime(context, async (runtime, userId) => {
+        const input = { ...patch, userId, name };
+        if (options.dryRun) {
+            const preview = await previewCreateNoteTemplate(runtime.db, input);
+            printDryRunPreview({
+                dry_run: true,
+                command: 'dino template create',
+                action: 'create_note_template',
+                risk: 'write',
+                summary: `Create note template "${name}".`,
+                changes: { before: null, after: templateOutput(preview.after) },
+            }, runtime);
+            return;
+        }
+        const template = await createNoteTemplate(runtime.db, input);
+        await finishWrite(runtime, options, { template: templateOutput(template) }, template.id);
+    });
+}
+async function runTemplateUpdate(context) {
+    const id = requiredArgument(context.args.id, 'Template id');
+    const options = context.options;
+    const patch = await readWriteInput(options);
+    if (Object.keys(patch).length === 0) {
+        throw new DinoxError('At least one note-template field must be updated', { code: 'USAGE_ERROR' });
+    }
+    await withTemplateRuntime(context, async (runtime, userId) => {
+        const input = { ...patch, userId, id };
+        if (options.dryRun) {
+            const preview = await previewUpdateNoteTemplate(runtime.db, input);
+            printDryRunPreview({
+                dry_run: true,
+                command: 'dino template update',
+                action: 'update_note_template',
+                risk: 'write',
+                summary: `Update note template "${preview.before.name}".`,
+                targets: [{ id: preview.before.id, name: preview.before.name }],
+                changes: { before: templateOutput(preview.before), after: templateOutput(preview.after) },
+            }, runtime);
+            return;
+        }
+        const template = await updateNoteTemplate(runtime.db, input);
+        await finishWrite(runtime, options, { template: templateOutput(template) }, template.id);
+    });
+}
+async function runTemplateDelete(context) {
+    const id = requiredArgument(context.args.id, 'Template id');
+    const options = context.options;
+    await withTemplateRuntime(context, async (runtime, userId) => {
+        if (options.dryRun) {
+            const preview = await previewDeleteNoteTemplate(runtime.db, { userId, id });
+            printDryRunPreview({
+                dry_run: true,
+                command: 'dino template delete',
+                action: 'delete_note_template',
+                risk: 'write',
+                summary: `Soft-delete note template "${preview.before.name}".`,
+                targets: [{ id: preview.before.id, name: preview.before.name }],
+            }, runtime);
+            return;
+        }
+        const template = await deleteNoteTemplate(runtime.db, { userId, id });
+        await finishWrite(runtime, options, { deleted: true, template: templateOutput(template) }, `Deleted ${template.id}`);
+    });
+}
+const CONTENT_OPTIONS = [
+    { flags: '--content <string|@file>', description: 'Template content as Markdown; {{date}} {{time}} {{datetime}} {{location}} tokens are filled when a note is created', type: 'string' },
+    { flags: '--content-json <json|@file>', description: 'Template content as a Tiptap doc JSON', type: 'string' },
+];
+const PROPERTY_KEY_OPTIONS = [
+    { flags: '--property-key <key>', description: 'Property key declared on notes created from the template (repeatable, ordered)', parser: collectOption, type: 'string[]' },
+    { flags: '--property-keys <string|@file>', description: 'Property keys as a JSON array or comma/newline-separated list', type: 'string' },
+];
+const TEMPLATE_WRITE_FIELDS = ['template', 'durability', 'upload_queue_remaining', 'stale'];
+export const templateCommandGroup = {
+    name: 'template',
+    description: 'Manage note templates (content plus the property keys new notes declare)',
+    commands: [
+        {
+            name: 'list',
+            description: 'List note templates',
+            options: [
+                { flags: '--limit <n>', description: 'Maximum returned templates (1-2000)', parser: parsePositiveIntegerOption, type: 'number', defaultValue: 500 },
+            ],
+            schema: {
+                path: 'template.list',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: TEMPLATE_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Template summaries in priority order', fields: ['stale', 'count', 'templates'] },
+                examples: ['dino template list --format json'],
+            },
+            action: runTemplateList,
+        },
+        {
+            name: 'get',
+            description: 'Get one note template with its Tiptap document',
+            arguments: [{ syntax: '<id>', description: 'Template id' }],
+            schema: {
+                path: 'template.get',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: TEMPLATE_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Template detail', fields: ['stale', 'template'] },
+                examples: ['dino template get <id> --format json'],
+            },
+            action: runTemplateGet,
+        },
+        {
+            name: 'create',
+            description: 'Create a note template',
+            options: [
+                { flags: '--name <string>', description: 'Template name', required: true, type: 'string' },
+                ...CONTENT_OPTIONS,
+                ...PROPERTY_KEY_OPTIONS,
+                WRITE_DURABILITY_OPTION,
+                DRY_RUN_OPTION,
+            ],
+            schema: {
+                path: 'template.create',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: TEMPLATE_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Created template', fields: TEMPLATE_WRITE_FIELDS },
+                examples: [
+                    'dino template create --name "Book" --property-key 作者 --property-key rating --content @book.md --format json --dry-run',
+                ],
+            },
+            action: runTemplateCreate,
+        },
+        {
+            name: 'update',
+            description: 'Update a note template; fields you do not pass are left as stored',
+            arguments: [{ syntax: '<id>', description: 'Template id' }],
+            options: [
+                { flags: '--name <string>', description: 'Rename the template', type: 'string' },
+                ...CONTENT_OPTIONS,
+                { flags: '--clear-content', description: 'Make the template property-only', type: 'boolean' },
+                ...PROPERTY_KEY_OPTIONS,
+                { flags: '--clear-property-keys', description: 'Remove all property keys', type: 'boolean' },
+                WRITE_DURABILITY_OPTION,
+                DRY_RUN_OPTION,
+            ],
+            schema: {
+                path: 'template.update',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: TEMPLATE_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Updated template', fields: TEMPLATE_WRITE_FIELDS },
+                examples: ['dino template update <id> --property-keys "作者,rating,状态" --format json'],
+            },
+            action: runTemplateUpdate,
+        },
+        {
+            name: 'delete',
+            description: 'Soft-delete a note template',
+            arguments: [{ syntax: '<id>', description: 'Template id' }],
+            options: [WRITE_DURABILITY_OPTION, DRY_RUN_OPTION],
+            schema: {
+                path: 'template.delete',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: TEMPLATE_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Deleted template', fields: ['deleted', ...TEMPLATE_WRITE_FIELDS] },
+                examples: ['dino template delete <id> --format json --dry-run'],
+            },
+            action: runTemplateDelete,
+        },
+    ],
+};
+export function registerTemplateCommands(program) {
+    registerCommandGroup(program, templateCommandGroup);
+}

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

@@ -1,44 +1,13 @@
 import { type TiptapNode } from '../notes/contentEngine.js';
-export declare const NOTE_TEMPLATE_PROPERTY_DEF_VERSION = 1;
-export declare const MAX_NOTE_TEMPLATE_PROPERTY_KEYS = 50;
+import { type NoteTemplateRow, type NoteTemplateSummary } from '../../vendor/electron/shared/index.js';
+export { MAX_NOTE_TEMPLATE_PROPERTY_KEYS, NOTE_TEMPLATE_PROPERTY_DEF_VERSION, parseNoteTemplatePropertyKeys, sanitizeNoteTemplatePropertyKeys, serializeNoteTemplatePropertyKeys, type NoteTemplateRow, type NoteTemplateSummary, } from '../../vendor/electron/shared/index.js';
 export declare const MAX_NOTE_TEMPLATE_CONTENT_LENGTH = 200000;
-export type NoteTemplatePropertyDef = {
-    version: typeof NOTE_TEMPLATE_PROPERTY_DEF_VERSION;
-    keys: string[];
-};
-export type NoteTemplateRow = {
-    id: string;
-    user_id: string | null;
-    name: string | null;
-    content: string | null;
-    priority: number | null;
-    is_show: number | null;
-    extra_data: string | null;
-    property_def: string | null;
-    insert_at: string | null;
-    update_at: string | null;
-    is_del: number | null;
-};
-export type NoteTemplateSummary = {
-    id: string;
-    name: string;
-    propertyKeys: string[];
-    content: string;
-    hasContent: boolean;
-    isShow: boolean;
-    priority: number;
-    updateAt: string | null;
-};
 export type NoteTemplateTokenValues = {
     date: string;
     datetime: string;
     time: string;
     location: string;
 };
-export declare function isNotePropertyKeyValid(value: unknown): value is string;
-export declare function validateNoteTemplatePropertyKeys(keys: readonly unknown[]): string[];
-export declare function parseNoteTemplatePropertyDef(raw: string | null | undefined): NoteTemplatePropertyDef | null;
-export declare function serializeNoteTemplatePropertyDef(keys: readonly string[]): string | null;
 export declare function isNoteTemplateDocumentEmpty(document: TiptapNode | null | undefined): boolean;
 export declare function parseNoteTemplateContent(raw: string | null | undefined): TiptapNode | null;
 export declare function serializeNoteTemplateContent(document: unknown): string;
@@ -47,4 +16,13 @@ export declare function hydrateNoteTemplateDocument(document: TiptapNode, option
     now?: Date;
     location?: string;
 }): TiptapNode;
-export declare function mapNoteTemplateRow(row: NoteTemplateRow): NoteTemplateSummary;
+/**
+ * Resolves stored template content into a Tiptap doc the way desktop does: stringified doc
+ * JSON first, legacy Markdown second. Returns null for blank content.
+ */
+export declare function resolveStoredTemplateDocument(raw: string | null | undefined): TiptapNode | null;
+export type NoteTemplateDetail = NoteTemplateSummary & {
+    /** Content as a Tiptap doc (legacy Markdown converted); null when the template has none. */
+    document: TiptapNode | null;
+};
+export declare function mapNoteTemplateRow(row: NoteTemplateRow): NoteTemplateDetail;

package/dist/commands/templates/model.js

@@ -1,7 +1,11 @@
+// Note template content helpers. Rows and property-key envelopes follow the vendored desktop
+// model (src/vendor/electron/shared/note-templates.ts); this module owns the Tiptap content
+// contract and `{{date}}`-style token hydration used when a note is created from a template.
 import { projectNoteContent } from '../notes/contentEngine.js';
+import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
 import { DinoxError } from '../../utils/errors.js';
-export const NOTE_TEMPLATE_PROPERTY_DEF_VERSION = 1;
-export const MAX_NOTE_TEMPLATE_PROPERTY_KEYS = 50;
+import { mapNoteTemplateRow as mapDesktopNoteTemplateRow, } from '../../vendor/electron/shared/index.js';
+export { MAX_NOTE_TEMPLATE_PROPERTY_KEYS, NOTE_TEMPLATE_PROPERTY_DEF_VERSION, parseNoteTemplatePropertyKeys, sanitizeNoteTemplatePropertyKeys, serializeNoteTemplatePropertyKeys, } from '../../vendor/electron/shared/index.js';
 export const MAX_NOTE_TEMPLATE_CONTENT_LENGTH = 200_000;
 const MAX_TIPTAP_NODE_DEPTH = 100;
 const MAX_TIPTAP_NODE_COUNT = 10_000;
@@ -24,74 +28,6 @@ function formatError(message, code, details) {
 function isPlainRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
-export function isNotePropertyKeyValid(value) {
-    if (typeof value !== 'string')
-        return false;
-    const trimmed = value.trim();
-    if (!trimmed || trimmed !== value || trimmed.length > 64)
-        return false;
-    if (trimmed === '__proto__')
-        return false;
-    return !trimmed.includes('.') && !/[\n\r\t]/.test(trimmed);
-}
-export function validateNoteTemplatePropertyKeys(keys) {
-    if (keys.length > MAX_NOTE_TEMPLATE_PROPERTY_KEYS) {
-        throw formatError(`Note templates support at most ${MAX_NOTE_TEMPLATE_PROPERTY_KEYS} property keys`, 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', { maxKeys: MAX_NOTE_TEMPLATE_PROPERTY_KEYS, receivedKeys: keys.length });
-    }
-    const seen = new Set();
-    const validated = [];
-    for (const key of keys) {
-        if (!isNotePropertyKeyValid(key)) {
-            throw formatError('Note template property_def contains an invalid property key', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', {
-                key,
-            });
-        }
-        if (seen.has(key)) {
-            throw formatError('Note template property_def contains duplicate property keys', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', {
-                key,
-            });
-        }
-        seen.add(key);
-        validated.push(key);
-    }
-    return validated;
-}
-export function parseNoteTemplatePropertyDef(raw) {
-    const value = raw?.trim() ?? '';
-    if (!value)
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(value);
-    }
-    catch (cause) {
-        throw formatError('Note template property_def must be valid JSON', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', {
-            cause: cause instanceof Error ? cause.message : String(cause),
-        });
-    }
-    if (!isPlainRecord(parsed)) {
-        throw formatError('Note template property_def must be a versioned object', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF');
-    }
-    if (parsed.version !== NOTE_TEMPLATE_PROPERTY_DEF_VERSION) {
-        throw formatError(`Unsupported note template property_def version: ${String(parsed.version)}`, 'NOTE_TEMPLATE_UNSUPPORTED_PROPERTY_DEF_VERSION', { supportedVersion: NOTE_TEMPLATE_PROPERTY_DEF_VERSION, receivedVersion: parsed.version });
-    }
-    if (!Array.isArray(parsed.keys)) {
-        throw formatError('Note template property_def keys must be an array', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF');
-    }
-    return {
-        version: NOTE_TEMPLATE_PROPERTY_DEF_VERSION,
-        keys: validateNoteTemplatePropertyKeys(parsed.keys),
-    };
-}
-export function serializeNoteTemplatePropertyDef(keys) {
-    const validated = validateNoteTemplatePropertyKeys(keys);
-    if (validated.length === 0)
-        return null;
-    return JSON.stringify({
-        version: NOTE_TEMPLATE_PROPERTY_DEF_VERSION,
-        keys: validated,
-    });
-}
 function assertTiptapNode(value, state, depth) {
     if (depth > MAX_TIPTAP_NODE_DEPTH) {
         throw formatError(`Note template content exceeds the maximum node depth of ${MAX_TIPTAP_NODE_DEPTH}`, 'NOTE_TEMPLATE_INVALID_CONTENT');
@@ -222,18 +158,38 @@ export function hydrateNoteTemplateDocument(document, options = {}) {
     const values = buildNoteTemplateTokenValues(options.now, options.location ?? '');
     return hydrateTemplateNode(document, values) ?? { type: 'doc', content: [] };
 }
+/**
+ * Resolves stored template content into a Tiptap doc the way desktop does: stringified doc
+ * JSON first, legacy Markdown second. Returns null for blank content.
+ */
+export function resolveStoredTemplateDocument(raw) {
+    const value = raw?.trim() ?? '';
+    if (!value)
+        return null;
+    if (/^[{[]/.test(value)) {
+        try {
+            const parsed = JSON.parse(value);
+            if (isPlainRecord(parsed) && parsed.type === 'doc' && Array.isArray(parsed.content)) {
+                return parseNoteTemplateContent(value);
+            }
+            if (isPlainRecord(parsed) && Array.isArray(parsed.content)) {
+                return parseNoteTemplateContent(JSON.stringify({ type: 'doc', content: parsed.content }));
+            }
+        }
+        catch {
+            // Not JSON: fall through to the Markdown reading.
+        }
+    }
+    return convertMarkdownToNoteContent(value).contentJson;
+}
 export function mapNoteTemplateRow(row) {
-    const propertyDef = parseNoteTemplatePropertyDef(row.property_def);
-    const document = parseNoteTemplateContent(row.content);
-    const content = document ? serializeNoteTemplateContent(document) : '';
-    return {
-        id: row.id,
-        name: (row.name ?? '').trim(),
-        propertyKeys: propertyDef?.keys ?? [],
-        content,
-        hasContent: Boolean(content),
-        isShow: Number(row.is_show ?? 0) === 1,
-        priority: Number.isFinite(row.priority) ? Math.trunc(Number(row.priority)) : 0,
-        updateAt: row.update_at ?? null,
-    };
+    const summary = mapDesktopNoteTemplateRow(row);
+    let document = null;
+    try {
+        document = resolveStoredTemplateDocument(summary.content);
+    }
+    catch {
+        document = null;
+    }
+    return { ...summary, document };
 }

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

@@ -0,0 +1,53 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type NoteTemplateDetail } from './model.js';
+export declare function listNoteTemplates(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    limit?: number;
+}): Promise<NoteTemplateDetail[]>;
+export declare function getNoteTemplate(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    id: string;
+}): Promise<NoteTemplateDetail>;
+export type NoteTemplateWriteInput = {
+    name?: string;
+    propertyKeys?: string[];
+    /** Serialized Tiptap doc JSON; '' clears the content. */
+    content?: string | null;
+};
+declare function runCreate(db: AbstractPowerSyncDatabase, input: NoteTemplateWriteInput & {
+    userId: string;
+    name: string;
+}): Promise<NoteTemplateDetail>;
+declare function runUpdate(db: AbstractPowerSyncDatabase, input: NoteTemplateWriteInput & {
+    userId: string;
+    id: string;
+}): Promise<NoteTemplateDetail>;
+declare function runDelete(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    id: string;
+}): Promise<NoteTemplateDetail>;
+export declare const createNoteTemplate: typeof runCreate;
+export declare const updateNoteTemplate: typeof runUpdate;
+export declare const deleteNoteTemplate: typeof runDelete;
+export declare function previewCreateNoteTemplate(db: AbstractPowerSyncDatabase, input: NoteTemplateWriteInput & {
+    userId: string;
+    name: string;
+}): Promise<{
+    before: null;
+    after: NoteTemplateDetail;
+}>;
+export declare function previewUpdateNoteTemplate(db: AbstractPowerSyncDatabase, input: NoteTemplateWriteInput & {
+    userId: string;
+    id: string;
+}): Promise<{
+    before: NoteTemplateDetail;
+    after: NoteTemplateDetail;
+}>;
+export declare function previewDeleteNoteTemplate(db: AbstractPowerSyncDatabase, input: {
+    userId: string;
+    id: string;
+}): Promise<{
+    before: NoteTemplateDetail;
+    after: null;
+}>;
+export {};