@dinoxx/dinox-cli 1.0.22 → 1.1.0

package/dist/utils/tiptapMarkdownSyntax.js

@@ -0,0 +1,249 @@
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+const markdownParser = unified().use(remarkParse).use(remarkGfm);
+export function escapeLiteralMarkdownText(value) {
+    return value.replace(/[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/g, '\\$&');
+}
+function mergeRanges(ranges) {
+    const sorted = ranges
+        .filter((range) => range.end > range.start)
+        .sort((left, right) => left.start - right.start || left.end - right.end);
+    const merged = [];
+    for (const range of sorted) {
+        const previous = merged[merged.length - 1];
+        if (!previous || range.start > previous.end) {
+            merged.push({ ...range });
+            continue;
+        }
+        previous.end = Math.max(previous.end, range.end);
+    }
+    return merged;
+}
+export function isMarkdownOffsetInRanges(offset, ranges) {
+    return ranges.some((range) => offset >= range.start && offset < range.end);
+}
+export function isMarkdownOffsetInSortedRanges(offset, ranges) {
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const middle = low + Math.floor((high - low) / 2);
+        const range = ranges[middle];
+        if (offset < range.start) {
+            high = middle - 1;
+            continue;
+        }
+        if (offset >= range.end) {
+            low = middle + 1;
+            continue;
+        }
+        return true;
+    }
+    return false;
+}
+function findMarkdownRangeAtOffset(offset, ranges) {
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const middle = low + Math.floor((high - low) / 2);
+        const range = ranges[middle];
+        if (offset < range.start) {
+            high = middle - 1;
+            continue;
+        }
+        if (offset >= range.end) {
+            low = middle + 1;
+            continue;
+        }
+        return range;
+    }
+    return null;
+}
+export function findMarkdownCodeRanges(source) {
+    const ranges = [];
+    const stack = [markdownParser.parse(source)];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'code' || node.type === 'inlineCode') {
+            const start = node.position?.start?.offset;
+            const end = node.position?.end?.offset;
+            if (typeof start === 'number' && typeof end === 'number' && end > start) {
+                ranges.push({ start, end });
+            }
+            continue;
+        }
+        if (Array.isArray(node.children)) {
+            stack.push(...node.children);
+        }
+    }
+    return mergeRanges(ranges);
+}
+function findLinkDestinationEnd(source, start) {
+    let depth = 1;
+    let quote = null;
+    for (let index = start; index < source.length; index += 1) {
+        const char = source[index];
+        if (char === '\\') {
+            index += 1;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === '(')
+            depth += 1;
+        if (char === ')') {
+            depth -= 1;
+            if (depth === 0)
+                return index + 1;
+        }
+        if (char === '\n' && depth === 1)
+            return start;
+    }
+    return start;
+}
+function findHtmlTagEnd(source, start) {
+    let quote = null;
+    for (let index = start + 1; index < source.length; index += 1) {
+        const char = source[index];
+        if (quote) {
+            if (char === quote && source[index - 1] !== '\\')
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === '>')
+            return index + 1;
+    }
+    return start;
+}
+const VOID_HTML_ELEMENTS = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+]);
+function parseHtmlTag(source, start, end) {
+    const raw = source.slice(start, end);
+    const match = raw.match(/^<\s*(\/?)\s*([A-Za-z][A-Za-z0-9:-]*)(?=[\s/>])/);
+    if (!match) {
+        return null;
+    }
+    const name = match[2].toLowerCase();
+    return {
+        name,
+        closing: match[1] === '/',
+        selfClosing: /\/\s*>$/.test(raw) || VOID_HTML_ELEMENTS.has(name),
+    };
+}
+function findHtmlElementEnd(source, start, openingTagEnd) {
+    const opening = parseHtmlTag(source, start, openingTagEnd);
+    if (!opening || opening.closing || opening.selfClosing) {
+        return openingTagEnd;
+    }
+    let depth = 1;
+    for (let cursor = openingTagEnd; cursor < source.length;) {
+        const nextTagStart = source.indexOf('<', cursor);
+        if (nextTagStart === -1) {
+            return openingTagEnd;
+        }
+        if (source.startsWith('<!--', nextTagStart)) {
+            const commentEnd = source.indexOf('-->', nextTagStart + 4);
+            cursor = commentEnd === -1 ? source.length : commentEnd + 3;
+            continue;
+        }
+        const tagEnd = findHtmlTagEnd(source, nextTagStart);
+        if (tagEnd <= nextTagStart) {
+            cursor = nextTagStart + 1;
+            continue;
+        }
+        const tag = parseHtmlTag(source, nextTagStart, tagEnd);
+        if (!tag || tag.name !== opening.name) {
+            cursor = tagEnd;
+            continue;
+        }
+        if (tag.closing) {
+            depth -= 1;
+            if (depth === 0) {
+                return tagEnd;
+            }
+        }
+        else if (!tag.selfClosing) {
+            depth += 1;
+        }
+        cursor = tagEnd;
+    }
+    return openingTagEnd;
+}
+function findBareUrlEnd(source, start) {
+    let index = start;
+    while (index < source.length && !/[\s<>"']/.test(source[index])) {
+        index += 1;
+    }
+    return index;
+}
+export function findMarkdownLiteralRanges(source) {
+    const codeRanges = findMarkdownCodeRanges(source);
+    const ranges = [...codeRanges];
+    for (let index = 0; index < source.length;) {
+        const containingCodeRange = findMarkdownRangeAtOffset(index, codeRanges);
+        if (containingCodeRange) {
+            index = containingCodeRange.end;
+            continue;
+        }
+        if (source.startsWith('<!--', index)) {
+            const closing = source.indexOf('-->', index + 4);
+            const end = closing === -1 ? source.length : closing + 3;
+            ranges.push({ start: index, end });
+            index = end;
+            continue;
+        }
+        if (source[index] === '<' && /[A-Za-z!/?]/.test(source[index + 1] ?? '')) {
+            const tagEnd = findHtmlTagEnd(source, index);
+            if (tagEnd > index) {
+                const elementEnd = findHtmlElementEnd(source, index, tagEnd);
+                ranges.push({ start: index, end: elementEnd });
+                index = elementEnd;
+                continue;
+            }
+        }
+        if (source[index] === ']' && source[index + 1] === '(') {
+            const end = findLinkDestinationEnd(source, index + 2);
+            if (end > index + 2) {
+                ranges.push({ start: index + 1, end });
+                index = end;
+                continue;
+            }
+        }
+        const isUrlStart = source.startsWith('https://', index) ||
+            source.startsWith('http://', index) ||
+            source.startsWith('www.', index);
+        if (isUrlStart) {
+            const end = findBareUrlEnd(source, index);
+            ranges.push({ start: index, end });
+            index = end;
+            continue;
+        }
+        index += 1;
+    }
+    return mergeRanges(ranges);
+}

package/dist/utils/tokenize.js

@@ -1,11 +1,13 @@
-import { Jieba } from '@node-rs/jieba';
-import { dict } from '@node-rs/jieba/dict.js';
+import { createRequire } from 'node:module';
+const requireModule = createRequire(import.meta.url);
 let jieba = null;
 function ensureJiebaReady() {
     if (jieba) {
         return;
     }
     try {
+        const { Jieba } = requireModule('@node-rs/jieba');
+        const { dict } = requireModule('@node-rs/jieba/dict.js');
         jieba = Jieba.withDict(dict);
     }
     catch (error) {
@@ -24,10 +26,30 @@ function normalizeToken(token) {
     }
     return normalized;
 }
+function isAsciiText(text) {
+    return /^[\x00-\x7F]*$/.test(text);
+}
+function tokenizeAscii(text, limit) {
+    const tokens = [];
+    for (const match of text.matchAll(/[A-Za-z0-9]+(?:[._'-][A-Za-z0-9]+)*/g)) {
+        const normalized = normalizeToken(match[0]);
+        if (!normalized) {
+            continue;
+        }
+        tokens.push(normalized);
+        if (tokens.length >= limit) {
+            break;
+        }
+    }
+    return tokens;
+}
 export function tokenizeWithJieba(text, limit = 500) {
     if (!text || limit <= 0) {
         return [];
     }
+    if (isAsciiText(text)) {
+        return tokenizeAscii(text, limit);
+    }
     ensureJiebaReady();
     const raw = jieba.cutForSearch(text, false);
     const tokens = [];

package/dist/utils/updateNotice.js

@@ -1,7 +1,10 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { getDataDir } from '../config/paths.js';
 const PACKAGE_NAME = '@dinoxx/dinox-cli';
 const LATEST_VERSION_URL = 'https://registry.npmjs.org/@dinoxx%2Fdinox-cli/latest';
-let cachedUpdateNotice = null;
-let lastCheckedAt = 0;
+const UPDATE_CACHE_FILENAME = 'update-notice.json';
+let cachedLookup = null;
 const UPDATE_CACHE_TTL_MS = 5 * 60 * 1000;
 function parseSemverParts(version) {
     const base = version.trim().split('-', 1)[0] ?? '';
@@ -44,21 +47,66 @@ async function fetchLatestPublishedVersion(fetchImpl = fetch) {
         clearTimeout(timeout);
     }
 }
-export async function getUpdateNotice(currentVersion, fetchImpl = fetch) {
-    const now = Date.now();
-    if (cachedUpdateNotice && now - lastCheckedAt < UPDATE_CACHE_TTL_MS) {
-        return cachedUpdateNotice.current === currentVersion ? cachedUpdateNotice : null;
-    }
-    const latestVersion = await fetchLatestPublishedVersion(fetchImpl);
-    lastCheckedAt = now;
+function buildNotice(currentVersion, latestVersion) {
     if (!latestVersion || !isVersionNewer(latestVersion, currentVersion)) {
-        cachedUpdateNotice = null;
         return null;
     }
-    cachedUpdateNotice = {
+    return {
         current: currentVersion,
         latest: latestVersion,
         message: `Update available for ${PACKAGE_NAME}: ${currentVersion} -> ${latestVersion}`,
     };
-    return cachedUpdateNotice;
+}
+function getUpdateCachePath() {
+    return path.join(getDataDir(), UPDATE_CACHE_FILENAME);
+}
+async function readPersistentLookup(now) {
+    try {
+        const raw = await fsp.readFile(getUpdateCachePath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        const checkedAt = typeof parsed.checkedAt === 'number' ? parsed.checkedAt : 0;
+        if (!Number.isFinite(checkedAt) || now - checkedAt >= UPDATE_CACHE_TTL_MS) {
+            return null;
+        }
+        return {
+            checkedAt,
+            latestVersion: typeof parsed.latestVersion === 'string' ? parsed.latestVersion : null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function writePersistentLookup(cache) {
+    const cachePath = getUpdateCachePath();
+    const dir = path.dirname(cachePath);
+    const tmpPath = path.join(dir, `${UPDATE_CACHE_FILENAME}.${process.pid}.${Date.now()}.tmp`);
+    try {
+        await fsp.mkdir(dir, { recursive: true, mode: 0o700 });
+        await fsp.writeFile(tmpPath, `${JSON.stringify(cache)}\n`, { mode: 0o600 });
+        await fsp.rename(tmpPath, cachePath);
+    }
+    catch {
+        await fsp.rm(tmpPath, { force: true }).catch(() => undefined);
+    }
+}
+export async function getUpdateNotice(currentVersion, fetchImpl = fetch) {
+    const now = Date.now();
+    const usePersistentCache = fetchImpl === fetch;
+    if (cachedLookup && now - cachedLookup.checkedAt < UPDATE_CACHE_TTL_MS) {
+        return buildNotice(currentVersion, cachedLookup.latestVersion);
+    }
+    if (usePersistentCache) {
+        const persisted = await readPersistentLookup(now);
+        if (persisted) {
+            cachedLookup = persisted;
+            return buildNotice(currentVersion, persisted.latestVersion);
+        }
+    }
+    const latestVersion = await fetchLatestPublishedVersion(fetchImpl);
+    cachedLookup = { checkedAt: now, latestVersion };
+    if (usePersistentCache) {
+        await writePersistentLookup(cachedLookup);
+    }
+    return buildNotice(currentVersion, latestVersion);
 }

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "1.0.22",
+  "version": "1.1.0",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/add-shebang.mjs",
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && node scripts/add-shebang.mjs",
     "dev": "tsx src/dinox.ts",
     "prepublishOnly": "pnpm run build",
-    "publish:npm": "sh ./publish-npm.sh",
+    "publish:npm": "sh ./publish-npm.sh --no-bump",
     "publish:npm:dry-run": "sh ./publish-npm.sh --dry-run",
     "skills:check": "tsx scripts/check-skills.ts",
     "skills:sync:standalone": "tsx scripts/sync-standalone-skills-repo.ts",
     "skills:sync": "tsx scripts/sync-skills-reference.ts",
     "start": "node dist/dinox.js",
-    "test": "node --test --import tsx test/*.test.ts"
+    "test": "node scripts/run-tests.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json"
   },
   "keywords": [],
   "author": "",
@@ -30,13 +31,13 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=20"
+    "node": "^20.18.1 || >=22.0.0 <26.0.0"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1021.0",
     "@node-rs/jieba": "^2.0.1",
-    "@powersync/common": "^1.47.0",
-    "@powersync/node": "^0.17.1",
+    "@powersync/common": "^1.57.0",
+    "@powersync/node": "^0.19.2",
     "@tiptap/core": "^3.20.0",
     "@tiptap/extension-blockquote": "^3.20.0",
     "@tiptap/extension-bold": "^3.20.0",
@@ -71,12 +72,13 @@
     "strip-markdown": "^6.0.0",
     "unified": "^11.0.5",
     "uuidv7": "^1.0.2",
-    "yaml": "^2.8.2"
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@types/node": "^24.0.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^20.19.0",
     "tsx": "^4.20.3",
     "typescript": "^5.9.3"
   },
-  "packageManager": "pnpm@11.5.0"
+  "packageManager": "pnpm@10.34.5"
 }

package/dist/commands/mcp/auth.d.ts

@@ -1,4 +0,0 @@
-import type { IncomingHttpHeaders } from 'node:http';
-export declare function isLoopbackHost(host: string): boolean;
-export declare function resolveMCPAuthToken(tokenOption: unknown, envToken?: string | undefined): string | undefined;
-export declare function isAuthorizedMCPRequest(headers: IncomingHttpHeaders, expectedToken?: string): boolean;

package/dist/commands/mcp/auth.js

@@ -1,75 +0,0 @@
-import { timingSafeEqual } from 'node:crypto';
-import { DinoxError } from '../../utils/errors.js';
-const AUTH_HEADER_RE = /^Bearer\s+(.+)$/i;
-export function isLoopbackHost(host) {
-    const normalized = host.trim().toLowerCase();
-    return normalized === '127.0.0.1' || normalized === 'localhost' || normalized === '::1';
-}
-export function resolveMCPAuthToken(tokenOption, envToken = process.env.DINOX_MCP_TOKEN) {
-    if (tokenOption !== undefined && tokenOption !== null) {
-        if (typeof tokenOption !== 'string') {
-            throw new DinoxError('--token must be a non-empty string');
-        }
-        const parsed = tokenOption.trim();
-        if (!parsed) {
-            throw new DinoxError('--token must be a non-empty string');
-        }
-        return parsed;
-    }
-    const fromEnv = envToken?.trim() ?? '';
-    return fromEnv || undefined;
-}
-function readHeaderTokenValue(value) {
-    if (typeof value === 'string') {
-        const parsed = value.trim();
-        return parsed || undefined;
-    }
-    if (!Array.isArray(value)) {
-        return undefined;
-    }
-    for (const item of value) {
-        const parsed = item.trim();
-        if (parsed) {
-            return parsed;
-        }
-    }
-    return undefined;
-}
-function readBearerToken(headers) {
-    const authorization = readHeaderTokenValue(headers.authorization);
-    if (!authorization) {
-        return undefined;
-    }
-    const match = authorization.match(AUTH_HEADER_RE);
-    if (!match) {
-        return undefined;
-    }
-    const token = match[1]?.trim() ?? '';
-    return token || undefined;
-}
-function readMCPToken(headers) {
-    const bearer = readBearerToken(headers);
-    if (bearer) {
-        return bearer;
-    }
-    const raw = readHeaderTokenValue(headers['x-dinox-token']);
-    return raw?.trim() || undefined;
-}
-function secureTokenEquals(left, right) {
-    const leftBuffer = Buffer.from(left);
-    const rightBuffer = Buffer.from(right);
-    if (leftBuffer.length !== rightBuffer.length) {
-        return false;
-    }
-    return timingSafeEqual(leftBuffer, rightBuffer);
-}
-export function isAuthorizedMCPRequest(headers, expectedToken) {
-    if (!expectedToken) {
-        return true;
-    }
-    const provided = readMCPToken(headers);
-    if (!provided) {
-        return false;
-    }
-    return secureTokenEquals(provided, expectedToken);
-}

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

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

package/dist/commands/mcp/index.js

@@ -1,86 +0,0 @@
-import { startMCPServer } from './server.js';
-import { mcpTools } from './tools.js';
-import { isLoopbackHost, resolveMCPAuthToken } from './auth.js';
-import { DEFAULT_MCP_PORT } from './types.js';
-import { DinoxError } from '../../utils/errors.js';
-import { printHumanReadableLine } from '../../utils/output.js';
-function parsePort(value) {
-    if (value === undefined || value === null || value === '') {
-        return DEFAULT_MCP_PORT;
-    }
-    if (typeof value !== 'string') {
-        throw new DinoxError('--port must be a valid port number');
-    }
-    const trimmed = value.trim();
-    if (!/^\d+$/.test(trimmed)) {
-        throw new DinoxError('--port must be a valid port number');
-    }
-    const parsed = Number(trimmed);
-    if (!Number.isFinite(parsed) || parsed < 1 || parsed > 65535) {
-        throw new DinoxError('--port must be between 1 and 65535');
-    }
-    return Math.trunc(parsed);
-}
-function parseHost(value) {
-    if (value === undefined || value === null || value === '') {
-        return '127.0.0.1';
-    }
-    if (typeof value !== 'string') {
-        throw new DinoxError('--host must be a valid hostname or IP address');
-    }
-    const trimmed = value.trim();
-    if (!trimmed) {
-        throw new DinoxError('--host must be a valid hostname or IP address');
-    }
-    return trimmed;
-}
-export function registerMCPCommands(program) {
-    const mcp = program.command('mcp').description('MCP (Model Context Protocol) server');
-    mcp
-        .command('serve')
-        .description('Start MCP server for AI agent integration')
-        .option('--host <string>', 'bind address (default: 127.0.0.1)')
-        .option('--port <number>', `server port (default: ${DEFAULT_MCP_PORT})`)
-        .option('--token <string>', 'auth token (or DINOX_MCP_TOKEN env var)')
-        .action(async (options) => {
-        const port = parsePort(options.port);
-        const host = parseHost(options.host);
-        const token = resolveMCPAuthToken(options.token);
-        const loopback = isLoopbackHost(host);
-        if (!loopback && !token) {
-            throw new DinoxError('--token (or DINOX_MCP_TOKEN) is required when --host is non-loopback');
-        }
-        printHumanReadableLine('Starting Dinox MCP server...');
-        printHumanReadableLine(`Host: ${host}`);
-        printHumanReadableLine(`Port: ${port}`);
-        printHumanReadableLine(`Auth: ${token ? 'enabled' : 'disabled (loopback only)'}`);
-        printHumanReadableLine('Protocol: Model Context Protocol (MCP)');
-        if (!loopback) {
-            printHumanReadableLine('warning: binding to a non-loopback host may expose your local data; use firewall/auth as needed');
-        }
-        printHumanReadableLine('');
-        printHumanReadableLine('Available tools:');
-        for (const tool of mcpTools) {
-            printHumanReadableLine(`  - ${tool.name}`);
-        }
-        printHumanReadableLine('');
-        const { server, mcpServer } = await startMCPServer(port, host, token);
-        let shuttingDown = false;
-        const shutdown = async () => {
-            if (shuttingDown)
-                return;
-            shuttingDown = true;
-            await new Promise((resolve) => server.close(() => resolve()));
-            await mcpServer.close();
-        };
-        process.on('SIGINT', () => {
-            void shutdown().finally(() => process.exit(0));
-        });
-        process.on('SIGTERM', () => {
-            void shutdown().finally(() => process.exit(0));
-        });
-    });
-    mcp.action((_options, command) => {
-        command.outputHelp();
-    });
-}