@dinoxx/dinox-cli 1.0.1 → 1.0.3

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/config/keys.d.ts

@@ -1,6 +1,6 @@
-export declare const CONFIG_KEYS: readonly ["powersync.tokenEndpoint", "powersync.uploadV4Path", "powersync.uploadV2Path", "sync.timeoutMs"];
-export declare const FIXED_CONFIG_KEYS: readonly ["powersync.endpoint", "powersync.uploadBaseUrl"];
-export declare const READABLE_CONFIG_KEYS: readonly ["powersync.tokenEndpoint", "powersync.uploadV4Path", "powersync.uploadV2Path", "sync.timeoutMs", "powersync.endpoint", "powersync.uploadBaseUrl"];
+export declare const CONFIG_KEYS: readonly ["sync.timeoutMs"];
+export declare const FIXED_CONFIG_KEYS: readonly [];
+export declare const READABLE_CONFIG_KEYS: readonly ["sync.timeoutMs"];
 export type ConfigKey = (typeof CONFIG_KEYS)[number];
 export type FixedConfigKey = (typeof FIXED_CONFIG_KEYS)[number];
 export type ReadableConfigKey = (typeof READABLE_CONFIG_KEYS)[number];

package/dist/config/keys.js

@@ -1,10 +1,7 @@
 export const CONFIG_KEYS = [
-    'powersync.tokenEndpoint',
-    'powersync.uploadV4Path',
-    'powersync.uploadV2Path',
     'sync.timeoutMs',
 ];
-export const FIXED_CONFIG_KEYS = ['powersync.endpoint', 'powersync.uploadBaseUrl'];
+export const FIXED_CONFIG_KEYS = [];
 export const READABLE_CONFIG_KEYS = [...CONFIG_KEYS, ...FIXED_CONFIG_KEYS];
 export function isConfigKey(value) {
     return CONFIG_KEYS.includes(value);

package/dist/config/paths.js

@@ -1,5 +1,6 @@
 import os from 'node:os';
 import path from 'node:path';
+const POWERSYNC_DB_FILENAME = 'dinox-cli.sqlite';
 function resolveConfigHome() {
     if (process.env.DINOX_CONFIG_DIR) {
         return process.env.DINOX_CONFIG_DIR;
@@ -35,5 +36,5 @@ export function getDataDir() {
     return path.join(resolveDataHome(), 'dinox');
 }
 export function getPowerSyncDbPath() {
-    return path.join(getDataDir(), 'powersync.sqlite');
+    return path.join(getDataDir(), POWERSYNC_DB_FILENAME);
 }

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,12 +1,14 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/add-shebang.mjs",
     "dev": "tsx src/dinox.ts",
     "prepublishOnly": "npm run build",
+    "publish:npm": "sh scripts/publish-npm.sh",
+    "publish:npm:dry-run": "sh scripts/publish-npm.sh --dry-run",
     "start": "node dist/dinox.js",
     "test": "node --test --import tsx test/**/*.test.ts"
   },