@dinoxx/dinox-cli 1.0.2 → 1.0.4

package/README.md

@@ -88,7 +88,7 @@ dino info
 ## 第 1 步：登录
 
 ```bash
-dino auth login "Bearer <你的token>"
+dino auth login "<你的token>"
 ```
 
 ## 第 2 步：同步
@@ -176,6 +176,7 @@ dino box add --name "Inbox" --description "用于存放待整理的想法和资
 
 ```bash
 dino prompt list
+dino prompt add --name "周报助手" --cmd "请基于本周笔记输出一份简洁周报"
 ```
 
 ## 5.5 配置
@@ -252,7 +253,7 @@ dino note create --title "测试" --content "@.\note.md"
 你还没有完成登录。执行：
 
 ```bash
-dino auth login "Bearer <token>"
+dino auth login "<token>"
 ```
 
 ## Q2：创建笔记时报 `Unknown tags` 或 `Unknown zettel box names`
@@ -281,17 +282,13 @@ dino box add "你的卡片盒"
 
 ## 8.2 `auth` 命令
 
-### `dino auth login <authorization>`
+### `dino auth login <token>`
 
 保存授权信息并验证连接。
 
 | 参数 | 必填 | 说明 |
 | --- | --- | --- |
-| `<authorization>` | 是 | 完整 Authorization 头值，例如：`"Bearer <token>"` |
-
-| 选项 | 必填 | 说明 |
-| --- | --- | --- |
-| `--no-verify` | 否 | 只保存登录信息，不做凭证交换与初始同步验证。 |
+| `<token>` | 是 | 登录 token，直接传 token 字符串（不需要 `Bearer` 前缀）。 |
 
 支持全局参数：`--json`、`--sync-timeout`
 
@@ -454,6 +451,18 @@ dino box add "你的卡片盒"
 | `--offline` | 否 | 跳过 connect/sync，仅用本地缓存。 |
 | `--sync-timeout <ms>` | 否 | 覆盖连接/同步超时毫秒。 |
 
+### `dino prompt add [options]`
+
+新增 Prompt（写入 `c_cmd`）。
+
+| 选项 | 必填 | 说明 |
+| --- | --- | --- |
+| `--name <string>` | 是 | Prompt 名称。 |
+| `--cmd <string>` | 是 | Prompt 指令内容。 |
+| `--json` | 否 | 输出 machine-readable YAML。 |
+| `--offline` | 否 | 跳过 connect/sync，仅用本地缓存。 |
+| `--sync-timeout <ms>` | 否 | 覆盖连接/同步超时毫秒。 |
+
 ## 8.8 `config` 命令
 
 ### `dino config get [key]`

package/dist/commands/auth/index.js

@@ -8,6 +8,7 @@ import { printYaml } from '../../utils/output.js';
 import { refreshAndPersistAuthIdentity } from '../../auth/userInfo.js';
 import { connectPowerSync, getStatusSnapshot } from '../../powersync/runtime.js';
 import { fetchCredentialsWithAuthorization } from '../../powersync/connector.js';
+import { runSingleSyncPass } from '../../powersync/syncPass.js';
 function parseSyncTimeoutMs(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -32,8 +33,7 @@ export function registerAuthCommands(program) {
         .command('login')
         .description('Save authorization token and verify PowerSync connectivity')
         .argument('<authorization>', 'full Authorization header value (e.g. "Bearer <token>")')
-        .option('--no-verify', 'skip credential exchange and initial sync')
-        .action(async (authorization, options, command) => {
+        .action(async (authorization, _options, command) => {
         const auth = authorization?.trim();
         if (!auth) {
             throw new DinoxError('Authorization token is required');
@@ -45,20 +45,6 @@ export function registerAuthCommands(program) {
         const globals = command.optsWithGlobals?.() ?? {};
         const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? resolved.sync.timeoutMs;
         const jsonOutput = Boolean(globals.json);
-        if (!options.verify) {
-            const result = {
-                ok: true,
-                verified: false,
-                authorization: redactAuthorization(auth),
-            };
-            if (jsonOutput) {
-                printYaml(result);
-            }
-            else {
-                console.log('Login saved (verification skipped).');
-            }
-            return;
-        }
         // 1) Token exchange sanity check.
         await fetchCredentialsWithAuthorization({
             authorization: auth,
@@ -74,6 +60,7 @@ export function registerAuthCommands(program) {
             timeoutMs,
         });
         try {
+            await runSingleSyncPass(db, timeoutMs);
             const status = getStatusSnapshot(db);
             const result = {
                 ok: true,

package/dist/commands/prompt/index.js

@@ -4,7 +4,8 @@ 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 { listPrompts } from './repo.js';
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { addPrompt, listPrompts } from './repo.js';
 function parseSyncTimeoutMs(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -45,6 +46,58 @@ export function registerPromptCommands(program) {
         .option('--offline', 'skip connect/sync and only use local cache')
         .option('--sync-timeout <ms>', 'override sync/connect timeout (milliseconds)')
         .action(runPromptListCommand);
+    prompt
+        .command('add')
+        .description('Create a new prompt in c_cmd')
+        .option('--name <string>', 'prompt name')
+        .option('--cmd <string>', 'prompt command/prompt text')
+        .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 (options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(options.offline ?? globals.offline);
+        const jsonOutput = Boolean(options.json ?? globals.json);
+        const name = typeof options.name === 'string' ? options.name.trim() : '';
+        const cmd = typeof options.cmd === 'string' ? options.cmd.trim() : '';
+        if (!name) {
+            throw new DinoxError('Prompt name is required. Use `dino prompt add --name <name> --cmd <cmd>`.');
+        }
+        if (!cmd) {
+            throw new DinoxError('Prompt cmd is required. Use `dino prompt add --name <name> --cmd <cmd>`.');
+        }
+        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 syncBeforePromptCommand(db, offline, timeoutMs);
+            const result = await addPrompt(db, {
+                name,
+                cmd,
+                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, 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);
+        }
+    });
     prompt.action((_options, command) => {
         command.outputHelp();
     });

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

@@ -3,4 +3,16 @@ export type PromptListItem = {
     name: string;
     cmd: string;
 };
+export type AddPromptInput = {
+    name: string;
+    cmd: string;
+    userId: string;
+};
+export type AddPromptResult = {
+    id: string;
+    name: string;
+    cmd: string;
+    restored: boolean;
+};
 export declare function listPrompts(db: AbstractPowerSyncDatabase): Promise<PromptListItem[]>;
+export declare function addPrompt(db: AbstractPowerSyncDatabase, input: AddPromptInput): Promise<AddPromptResult>;

package/dist/commands/prompt/repo.js

@@ -1,3 +1,39 @@
+import { generateId } from '../../utils/id.js';
+import { DinoxError } from '../../utils/errors.js';
+function normalizeText(value) {
+    return value.trim();
+}
+function normalizeLookup(value) {
+    return normalizeText(value).toLowerCase();
+}
+async function getPromptColumns(db) {
+    const rows = await db.getAll('PRAGMA table_info(c_cmd)', []);
+    return new Set(rows.map((row) => row.name).filter(Boolean));
+}
+async function listPromptRowsForWrite(db, columnNames) {
+    const isDelExpr = columnNames.has('is_del') ? 'is_del' : 'NULL';
+    const userIdExpr = columnNames.has('user_id') ? `TRIM(COALESCE(user_id, ''))` : `''`;
+    const activeFirstExpr = columnNames.has('is_del')
+        ? 'CASE WHEN is_del IS NULL OR is_del = 0 THEN 0 ELSE 1 END'
+        : '0';
+    const updateOrderExpr = columnNames.has('update_at') ? 'update_at DESC,' : '';
+    const insertOrderExpr = columnNames.has('insert_at') ? 'insert_at DESC,' : '';
+    return db.getAll(`
+    SELECT
+      TRIM(COALESCE(id, '')) AS id,
+      TRIM(COALESCE(name, '')) AS name,
+      TRIM(COALESCE(cmd, '')) AS cmd,
+      ${isDelExpr} AS is_del,
+      ${userIdExpr} AS user_id
+    FROM c_cmd
+    WHERE TRIM(COALESCE(id, '')) <> ''
+    ORDER BY
+      ${activeFirstExpr} ASC,
+      ${updateOrderExpr}
+      ${insertOrderExpr}
+      id DESC
+    `, []);
+}
 export async function listPrompts(db) {
     const rows = await db.getAll(`
     SELECT DISTINCT
@@ -16,3 +52,113 @@ export async function listPrompts(db) {
     }))
         .filter((row) => row.name.length > 0 && row.cmd.length > 0);
 }
+export async function addPrompt(db, input) {
+    const name = normalizeText(input.name);
+    if (!name) {
+        throw new DinoxError('Prompt name is required');
+    }
+    const cmd = normalizeText(input.cmd);
+    if (!cmd) {
+        throw new DinoxError('Prompt cmd is required');
+    }
+    const userId = normalizeText(input.userId);
+    const nameLookup = normalizeLookup(name);
+    const cmdLookup = normalizeLookup(cmd);
+    const columnNames = await getPromptColumns(db);
+    const requiredColumns = ['id', 'name', 'cmd'];
+    const missingRequired = requiredColumns.filter((column) => !columnNames.has(column));
+    if (missingRequired.length > 0) {
+        throw new DinoxError(`c_cmd table is missing required columns: ${missingRequired.join(', ')}`);
+    }
+    if (columnNames.has('user_id') && !userId) {
+        throw new DinoxError('c_cmd insert requires user_id. Missing persisted userId. Run `dino auth login` first.');
+    }
+    const rows = await listPromptRowsForWrite(db, columnNames);
+    const samePromptRows = rows.filter((row) => {
+        return normalizeLookup(row.name ?? '') === nameLookup && normalizeLookup(row.cmd ?? '') === cmdLookup;
+    });
+    const activeRows = samePromptRows.filter((row) => row.is_del !== 1);
+    if (activeRows.length > 0) {
+        const ids = activeRows.map((row) => row.id?.trim() ?? '').filter(Boolean);
+        throw new DinoxError(`Prompt already exists: ${name}`, {
+            details: {
+                type: 'prompt_exists',
+                name,
+                cmd,
+                ids,
+                question: 'This prompt already exists. Do you want to keep using the existing prompt?',
+            },
+        });
+    }
+    const timestamp = new Date().toISOString();
+    const deletedRow = samePromptRows.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('cmd', cmd);
+        setValue('is_del', 0);
+        setValue('update_at', timestamp);
+        setValue('user_id', userId);
+        if (setParts.length > 0) {
+            params.push(deletedRow.id);
+            await db.execute(`
+        UPDATE c_cmd
+        SET ${setParts.join(', ')}
+        WHERE id = ?
+        `, params);
+        }
+        return {
+            id: deletedRow.id,
+            name,
+            cmd,
+            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('cmd', cmd);
+    pushInsert('zone', '');
+    pushInsert('type', 'custom');
+    pushInsert('priority', 0);
+    pushInsert('is_show', 1);
+    pushInsert('description', '');
+    pushInsert('extra_data', '{}');
+    pushInsert('user_id', userId);
+    pushInsert('insert_at', timestamp);
+    pushInsert('update_at', timestamp);
+    pushInsert('is_del', 0);
+    pushInsert('template_id', '');
+    pushInsert('meta_data', '{}');
+    pushInsert('output', 'markdown');
+    pushInsert('output_param', '{}');
+    pushInsert('category', '');
+    const insertColumns = insertEntries.map(([column]) => column);
+    const placeholders = insertColumns.map(() => '?').join(', ');
+    const insertParams = insertEntries.map(([, value]) => value);
+    await db.execute(`
+    INSERT INTO c_cmd (${insertColumns.join(', ')})
+    VALUES (${placeholders})
+    `, insertParams);
+    return {
+        id,
+        name,
+        cmd,
+        restored: false,
+    };
+}

package/dist/commands/sync.js

@@ -2,8 +2,8 @@ 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, getStatusSnapshot, waitForIdleDataFlow } from '../powersync/runtime.js';
-import { syncNoteTokenIndex } from '../powersync/tokenIndex.js';
+import { connectPowerSync, getStatusSnapshot } from '../powersync/runtime.js';
+import { runSingleSyncPass } from '../powersync/syncPass.js';
 function parseSyncTimeoutMs(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -29,16 +29,15 @@ export function registerSyncCommand(program) {
             timeoutMs,
         });
         try {
-            const idle = await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
-            const tokenIndex = await syncNoteTokenIndex(db);
+            const syncPass = await runSingleSyncPass(db, timeoutMs);
             const status = getStatusSnapshot(db);
             const payload = {
                 ok: true,
                 dbPath,
                 stale,
-                idle,
+                idle: syncPass.idle,
                 uploadEnabled: Boolean(config.powersync.uploadBaseUrl),
-                tokenIndex,
+                tokenIndex: syncPass.tokenIndex,
                 status,
             };
             if (jsonOutput) {

package/dist/powersync/syncPass.d.ts

@@ -0,0 +1,7 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type NoteTokenIndexResult } from './tokenIndex.js';
+export type SyncPassResult = {
+    idle: boolean;
+    tokenIndex: NoteTokenIndexResult;
+};
+export declare function runSingleSyncPass(db: AbstractPowerSyncDatabase, timeoutMs: number): Promise<SyncPassResult>;

package/dist/powersync/syncPass.js

@@ -0,0 +1,10 @@
+import { waitForIdleDataFlow } from './runtime.js';
+import { syncNoteTokenIndex } from './tokenIndex.js';
+export async function runSingleSyncPass(db, timeoutMs) {
+    const idle = await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
+    const tokenIndex = await syncNoteTokenIndex(db);
+    return {
+        idle,
+        tokenIndex,
+    };
+}

package/package.json

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