dominds 1.2.5 → 1.2.7

package/dist/server/prompts-routes.js

@@ -0,0 +1,545 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetBuiltinPrompts = handleGetBuiltinPrompts;
+exports.handleGetWorkspacePrompts = handleGetWorkspacePrompts;
+exports.handleGetPromptCatalog = handleGetPromptCatalog;
+exports.handleSaveWorkspacePrompt = handleSaveWorkspacePrompt;
+exports.handleTeamMgmtManual = handleTeamMgmtManual;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const log_1 = require("../log");
+const log = (0, log_1.createLogger)('prompts-routes');
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function requireNonEmptyString(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value : null;
+}
+function parseSaveWorkspacePromptTemplateRequest(raw) {
+    if (!isRecord(raw))
+        return null;
+    const groupKey = requireNonEmptyString(raw['groupKey']);
+    const uiLanguageRaw = raw['uiLanguage'];
+    const uiLanguage = uiLanguageRaw === 'zh' || uiLanguageRaw === 'en' ? uiLanguageRaw : null;
+    const name = requireNonEmptyString(raw['name']);
+    const content = requireNonEmptyString(raw['content']);
+    if (!groupKey || !uiLanguage || !name || !content)
+        return null;
+    const fileNameRaw = raw['fileName'];
+    const fileName = typeof fileNameRaw === 'string' && fileNameRaw.trim() !== '' ? fileNameRaw : undefined;
+    const descriptionRaw = raw['description'];
+    const description = typeof descriptionRaw === 'string' && descriptionRaw.trim() !== '' ? descriptionRaw : undefined;
+    return { name, uiLanguage, fileName, description, content, groupKey };
+}
+function buildWorkspaceTemplateTokenFromName(name) {
+    return sanitizeWorkspaceTemplateFileName(name);
+}
+function buildWorkspaceTemplateTokenFromFileName(fileName) {
+    return sanitizeWorkspaceTemplateFileName(fileName);
+}
+function parseCatalogYaml(rawText) {
+    try {
+        const parsed = yaml_1.default.parse(rawText);
+        if (!isRecord(parsed))
+            return null;
+        const out = {};
+        for (const [k, v] of Object.entries(parsed)) {
+            if (!isRecord(v))
+                continue;
+            out[k] = {
+                name: typeof v['name'] === 'string' ? v['name'] : undefined,
+                'name-zh': typeof v['name-zh'] === 'string' ? v['name-zh'] : undefined,
+                snippets: v['snippets'],
+            };
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+async function loadCatalogFromPath(abs) {
+    try {
+        const raw = await promises_1.default.readFile(abs, 'utf-8');
+        return parseCatalogYaml(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function stripLangSuffixFromSnippetId(id) {
+    if (id.endsWith('.zh.md'))
+        return id.slice(0, -'.zh.md'.length);
+    if (id.endsWith('.en.md'))
+        return id.slice(0, -'.en.md'.length);
+    if (id.endsWith('.md'))
+        return id.slice(0, -'.md'.length);
+    return id;
+}
+async function buildPromptCatalog() {
+    const builtin = await readBuiltinPromptTemplates();
+    const workspace = await readWorkspacePromptTemplates();
+    const serverRoot = path_1.default.resolve(__dirname, '..', '..');
+    const builtinCatalogAbs = path_1.default.resolve(serverRoot, 'dist', 'snippets', 'catalog.yaml');
+    const builtinCatalogFallbackAbs = path_1.default.resolve(serverRoot, 'snippets', 'catalog.yaml');
+    const rtwsRoot = path_1.default.resolve(process.cwd());
+    const workspaceCatalogAbs = path_1.default.resolve(rtwsRoot, '.minds', 'prompts', 'catalog.yaml');
+    const builtinCatalog = (await loadCatalogFromPath(builtinCatalogAbs)) ??
+        (await loadCatalogFromPath(builtinCatalogFallbackAbs));
+    const workspaceCatalog = await loadCatalogFromPath(workspaceCatalogAbs);
+    if (!builtinCatalog && !workspaceCatalog) {
+        return [
+            {
+                key: 'all',
+                titleI18n: { en: 'All', zh: '全部' },
+                templates: [...builtin, ...workspace],
+            },
+        ];
+    }
+    const builtinByToken = new Map();
+    for (const tpl of builtin) {
+        const p = typeof tpl.path === 'string' ? tpl.path : '';
+        if (!p.startsWith('snippets/'))
+            continue;
+        const noExt = stripLangSuffixFromSnippetId(p);
+        const token = noExt.replace(/^snippets\//, '');
+        if (!builtinByToken.has(token))
+            builtinByToken.set(token, tpl);
+    }
+    const workspaceByGroupAndToken = new Map();
+    for (const tpl of workspace) {
+        const p = typeof tpl.path === 'string' ? tpl.path : '';
+        if (!p.startsWith('.minds/prompts/'))
+            continue;
+        const rel = p.slice('.minds/prompts/'.length);
+        const parts = rel.split('/').filter((x) => x !== '');
+        const groupKey = parts[0];
+        const rest = parts.slice(1).join('/');
+        if (!groupKey || !rest)
+            continue;
+        const token = stripLangSuffixFromSnippetId(rest);
+        const k = `${groupKey}/${token}`;
+        if (!workspaceByGroupAndToken.has(k))
+            workspaceByGroupAndToken.set(k, tpl);
+    }
+    const keys = [];
+    if (builtinCatalog) {
+        keys.push(...Object.keys(builtinCatalog));
+    }
+    if (workspaceCatalog) {
+        for (const k of Object.keys(workspaceCatalog)) {
+            if (!keys.includes(k))
+                keys.push(k);
+        }
+    }
+    const groups = [];
+    for (const groupKey of keys) {
+        const metaBuiltin = builtinCatalog ? builtinCatalog[groupKey] : undefined;
+        const metaWorkspace = workspaceCatalog ? workspaceCatalog[groupKey] : undefined;
+        const titleEn = metaWorkspace?.name ?? metaBuiltin?.name ?? groupKey;
+        const titleZh = metaWorkspace?.['name-zh'] ??
+            metaBuiltin?.['name-zh'] ??
+            metaWorkspace?.name ??
+            metaBuiltin?.name ??
+            groupKey;
+        const templates = [];
+        if (metaBuiltin && Array.isArray(metaBuiltin.snippets)) {
+            for (const raw of metaBuiltin.snippets) {
+                if (typeof raw !== 'string')
+                    continue;
+                const token = raw.trim();
+                if (!token)
+                    continue;
+                const tpl = builtinByToken.get(token);
+                if (tpl)
+                    templates.push(tpl);
+            }
+        }
+        if (metaWorkspace && Array.isArray(metaWorkspace.snippets)) {
+            for (const raw of metaWorkspace.snippets) {
+                if (typeof raw !== 'string')
+                    continue;
+                const token = raw.trim();
+                if (!token)
+                    continue;
+                const tpl = workspaceByGroupAndToken.get(`${groupKey}/${token}`);
+                if (tpl)
+                    templates.push(tpl);
+            }
+        }
+        if (templates.length === 0)
+            continue;
+        // If a workspace template uses the same display name as a builtin template,
+        // prefer the workspace version to support "override" via same-name saves.
+        const workspaceNames = new Set();
+        for (const tpl of templates) {
+            if (tpl.source === 'workspace')
+                workspaceNames.add(tpl.name);
+        }
+        const filtered = [];
+        const seenNames = new Set();
+        for (const tpl of templates) {
+            if (tpl.source === 'builtin' && workspaceNames.has(tpl.name)) {
+                continue;
+            }
+            if (seenNames.has(tpl.name)) {
+                continue;
+            }
+            seenNames.add(tpl.name);
+            filtered.push(tpl);
+        }
+        groups.push({ key: groupKey, titleI18n: { en: titleEn, zh: titleZh }, templates: filtered });
+    }
+    if (groups.length === 0) {
+        return [
+            {
+                key: 'all',
+                titleI18n: { en: 'All', zh: '全部' },
+                templates: [...builtin, ...workspace],
+            },
+        ];
+    }
+    return groups;
+}
+function parseTeamMgmtManualRequest(raw) {
+    if (!isRecord(raw))
+        return null;
+    const uiLanguageRaw = raw['uiLanguage'];
+    const uiLanguage = uiLanguageRaw === 'zh' || uiLanguageRaw === 'en' ? uiLanguageRaw : null;
+    if (!uiLanguage)
+        return null;
+    const topicsValue = raw['topics'];
+    if (topicsValue === undefined) {
+        return { uiLanguage, topics: undefined };
+    }
+    if (!Array.isArray(topicsValue))
+        return null;
+    const topics = [];
+    for (const v of topicsValue) {
+        if (typeof v !== 'string')
+            return null;
+        topics.push(v);
+    }
+    return { uiLanguage, topics };
+}
+function safeTemplateIdFromPath(relPath) {
+    return relPath.replace(/\\/g, '/');
+}
+function stripOptionalBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+function parseFrontmatter(rawText) {
+    const normalized = stripOptionalBom(rawText).replace(/\r\n/g, '\n');
+    const m = normalized.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!m)
+        return { kind: 'none', body: rawText };
+    const fmText = m[1] ?? '';
+    const body = m[2] ?? '';
+    try {
+        const parsed = yaml_1.default.parse(fmText);
+        if (!isRecord(parsed))
+            return { kind: 'none', body };
+        const name = typeof parsed['name'] === 'string' ? parsed['name'] : undefined;
+        const description = typeof parsed['description'] === 'string' ? parsed['description'] : undefined;
+        return { kind: 'parsed', body, name, description };
+    }
+    catch {
+        return { kind: 'none', body };
+    }
+}
+function safeBasenameToName(filename) {
+    const base = filename.replace(/\.md$/i, '').trim();
+    return base === '' ? filename : base;
+}
+function ensureInsideDir(dirAbs, candidateAbs) {
+    return candidateAbs === dirAbs || candidateAbs.startsWith(dirAbs + path_1.default.sep);
+}
+async function listMarkdownFilesRecursively(dirAbs) {
+    const out = [];
+    const walk = async (abs) => {
+        let entries;
+        try {
+            entries = await promises_1.default.readdir(abs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            const childAbs = path_1.default.join(abs, ent.name);
+            if (ent.isDirectory()) {
+                await walk(childAbs);
+                continue;
+            }
+            if (ent.isFile() && ent.name.toLowerCase().endsWith('.md')) {
+                out.push(childAbs);
+            }
+        }
+    };
+    await walk(dirAbs);
+    return out;
+}
+async function readBuiltinPromptTemplates() {
+    const serverRoot = path_1.default.resolve(__dirname, '..', '..');
+    const candidates = [
+        path_1.default.resolve(serverRoot, 'dist', 'snippets'),
+        path_1.default.resolve(serverRoot, 'snippets'),
+    ];
+    let snippetsDir = null;
+    for (const dir of candidates) {
+        try {
+            const st = await promises_1.default.stat(dir);
+            if (st.isDirectory()) {
+                snippetsDir = dir;
+                break;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!snippetsDir)
+        return [];
+    const files = await listMarkdownFilesRecursively(snippetsDir);
+    const templates = [];
+    for (const abs of files) {
+        if (path_1.default.basename(abs).toLowerCase() === 'readme.md')
+            continue;
+        try {
+            const raw = await promises_1.default.readFile(abs, 'utf-8');
+            const parsed = parseFrontmatter(raw);
+            const rel = path_1.default.relative(snippetsDir, abs).replace(/\\/g, '/');
+            templates.push({
+                id: `builtin:${safeTemplateIdFromPath(rel)}`,
+                name: parsed.kind === 'parsed' && parsed.name
+                    ? parsed.name
+                    : safeBasenameToName(path_1.default.basename(abs)),
+                description: parsed.kind === 'parsed' ? parsed.description : undefined,
+                content: parsed.kind === 'parsed' ? parsed.body : raw,
+                source: 'builtin',
+                path: `snippets/${rel}`,
+            });
+        }
+        catch {
+            // ignore unreadable file
+        }
+    }
+    return templates;
+}
+async function readWorkspacePromptTemplates() {
+    const rtwsRoot = path_1.default.resolve(process.cwd());
+    const promptsDir = path_1.default.resolve(rtwsRoot, '.minds', 'prompts');
+    const files = await listMarkdownFilesRecursively(promptsDir);
+    const templates = [];
+    for (const abs of files) {
+        try {
+            const raw = await promises_1.default.readFile(abs, 'utf-8');
+            const parsed = parseFrontmatter(raw);
+            const rel = path_1.default.relative(promptsDir, abs).replace(/\\/g, '/');
+            templates.push({
+                id: `workspace:${safeTemplateIdFromPath(rel)}`,
+                name: parsed.kind === 'parsed' && parsed.name
+                    ? parsed.name
+                    : safeBasenameToName(path_1.default.basename(abs)),
+                description: parsed.kind === 'parsed' ? parsed.description : undefined,
+                content: parsed.kind === 'parsed' ? parsed.body : raw,
+                source: 'workspace',
+                path: `.minds/prompts/${rel}`,
+            });
+        }
+        catch {
+            // ignore
+        }
+    }
+    return templates;
+}
+function sanitizeWorkspaceTemplateFileName(name) {
+    const trimmed = name.trim();
+    const base = trimmed.replace(/[^a-zA-Z0-9\-_\u4e00-\u9fff]+/g, '-').replace(/-+/g, '-');
+    const safe = base.replace(/^[-_]+/, '').replace(/[-_]+$/, '');
+    return safe === '' ? 'prompt' : safe;
+}
+async function upsertWorkspaceCatalogEntry(promptsDirAbs, groupKey, token) {
+    const catalogAbs = path_1.default.resolve(promptsDirAbs, 'catalog.yaml');
+    let catalog = {};
+    try {
+        const raw = await promises_1.default.readFile(catalogAbs, 'utf-8');
+        const parsed = parseCatalogYaml(raw);
+        if (parsed)
+            catalog = parsed;
+    }
+    catch {
+        // ignore
+    }
+    const existing = catalog[groupKey];
+    const meta = isRecord(existing) ? { ...existing } : {};
+    const prevSnippets = meta['snippets'];
+    const snippets = [];
+    if (Array.isArray(prevSnippets)) {
+        for (const item of prevSnippets) {
+            if (typeof item === 'string' && item.trim() !== '')
+                snippets.push(item.trim());
+        }
+    }
+    if (!snippets.includes(token))
+        snippets.push(token);
+    meta['snippets'] = snippets;
+    catalog[groupKey] = meta;
+    await promises_1.default.mkdir(promptsDirAbs, { recursive: true });
+    await promises_1.default.writeFile(catalogAbs, yaml_1.default.stringify(catalog), 'utf-8');
+}
+async function handleGetBuiltinPrompts() {
+    try {
+        const templates = await readBuiltinPromptTemplates();
+        return { success: true, templates };
+    }
+    catch (error) {
+        log.error('Failed to read builtin prompts', error);
+        return { success: false, error: 'Failed to load builtin prompts' };
+    }
+}
+async function handleGetWorkspacePrompts() {
+    try {
+        const templates = await readWorkspacePromptTemplates();
+        return { success: true, templates };
+    }
+    catch (error) {
+        log.error('Failed to read workspace prompts', error);
+        return { success: false, error: 'Failed to load workspace prompts' };
+    }
+}
+async function handleGetPromptCatalog() {
+    try {
+        const groups = await buildPromptCatalog();
+        return { success: true, groups };
+    }
+    catch (error) {
+        log.error('Failed to build prompt catalog', error);
+        return { success: false, error: 'Failed to load prompt catalog' };
+    }
+}
+async function handleSaveWorkspacePrompt(rawBody) {
+    let parsed;
+    try {
+        parsed = rawBody ? JSON.parse(rawBody) : {};
+    }
+    catch {
+        return { success: false, error: 'Invalid JSON body' };
+    }
+    const req = parseSaveWorkspacePromptTemplateRequest(parsed);
+    if (!req)
+        return { success: false, error: 'Invalid request body' };
+    const rtwsRoot = path_1.default.resolve(process.cwd());
+    const promptsDir = path_1.default.resolve(rtwsRoot, '.minds', 'prompts');
+    const safeName = typeof req.fileName === 'string' && req.fileName.trim() !== ''
+        ? sanitizeWorkspaceTemplateFileName(req.fileName)
+        : sanitizeWorkspaceTemplateFileName(req.name);
+    const langSuffix = req.uiLanguage;
+    const fileBasename = safeName.endsWith(`.${langSuffix}`) ? safeName : `${safeName}.${langSuffix}`;
+    const groupKey = sanitizeWorkspaceTemplateFileName(req.groupKey);
+    const fileAbs = path_1.default.resolve(promptsDir, groupKey, `${fileBasename}.md`);
+    if (!ensureInsideDir(promptsDir, fileAbs)) {
+        return { success: false, error: 'Invalid template name' };
+    }
+    try {
+        await promises_1.default.mkdir(path_1.default.dirname(fileAbs), { recursive: true });
+        const headerData = { name: req.name.trim() };
+        if (typeof req.description === 'string' && req.description.trim() !== '') {
+            headerData['description'] = req.description.trim();
+        }
+        const header = yaml_1.default.stringify(headerData).trimEnd();
+        const serialized = `---\n${header}\n---\n\n${req.content.trimEnd()}\n`;
+        await promises_1.default.writeFile(fileAbs, serialized, 'utf-8');
+        await upsertWorkspaceCatalogEntry(promptsDir, groupKey, typeof req.fileName === 'string' && req.fileName.trim() !== ''
+            ? buildWorkspaceTemplateTokenFromFileName(req.fileName)
+            : buildWorkspaceTemplateTokenFromName(req.name));
+        const rel = path_1.default.relative(promptsDir, fileAbs).replace(/\\/g, '/');
+        return {
+            success: true,
+            template: {
+                id: `workspace:${safeTemplateIdFromPath(rel)}`,
+                name: req.name.trim(),
+                description: typeof req.description === 'string' ? req.description : undefined,
+                content: req.content,
+                source: 'workspace',
+                path: `.minds/prompts/${rel}`,
+            },
+        };
+    }
+    catch (error) {
+        log.error('Failed to save workspace prompt', error);
+        return { success: false, error: 'Failed to save prompt template' };
+    }
+}
+async function handleTeamMgmtManual(rawBody) {
+    let parsed;
+    try {
+        parsed = rawBody ? JSON.parse(rawBody) : {};
+    }
+    catch {
+        return { success: false, error: 'Invalid JSON body' };
+    }
+    const req = parseTeamMgmtManualRequest(parsed);
+    if (!req)
+        return { success: false, error: 'Invalid request body' };
+    try {
+        const { getTool } = await Promise.resolve().then(() => __importStar(require('../tools/registry')));
+        const tool = getTool('team_mgmt_manual');
+        if (!tool || tool.type !== 'func') {
+            return { success: false, error: 'team_mgmt_manual tool not available' };
+        }
+        const fakeDlg = {
+            getLastUserLanguageCode: () => req.uiLanguage,
+        };
+        const { Team } = await Promise.resolve().then(() => __importStar(require('../team')));
+        const caller = new Team.Member({
+            id: 'webui',
+            name: 'WebUI',
+            read_dirs: ['.minds/**'],
+            write_dirs: ['.minds/**'],
+        });
+        const markdown = await tool.call(fakeDlg, caller, { topics: req.topics ?? [] });
+        return { success: true, markdown: String(markdown) };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'Failed to load team manual';
+        log.error('Failed to call team_mgmt_manual', error);
+        return { success: false, error: msg };
+    }
+}

package/dist/server/server-core.js

@@ -90,6 +90,10 @@ class HttpServerCore {
                     return;
                 }
             }
+            // Backend-direct workspace file preview page.
+            if (await (0, api_routes_1.handleWorkspaceFilePreviewPage)(req, res, pathname)) {
+                return;
+            }
             // Handle API routes
             if (pathname.startsWith('/api/')) {
                 const authCheck = (0, auth_1.getHttpAuthCheck)(req, this.config.auth ?? { kind: 'disabled' });

package/dist/server/websocket-handler.js

@@ -99,6 +99,7 @@ async function queueUserSupplementAtGenerationBoundary(dialog, prompt) {
         msgId: prompt.msgId,
         grammar: prompt.grammar,
         userLanguageCode: prompt.userLanguageCode,
+        origin: 'user',
     });
     (0, evt_registry_1.postDialogEvent)(dialog, {
         type: 'queue_user_msg_evt',
@@ -199,6 +200,9 @@ async function handleWebSocketMessage(ws, packet) {
             case 'get_problems':
                 await handleGetProblems(ws, packet);
                 break;
+            case 'clear_resolved_problems':
+                await handleClearResolvedProblems(ws, packet);
+                break;
             case 'create_dialog':
                 await handleCreateDialog(ws, packet);
                 break;
@@ -516,6 +520,18 @@ async function handleGetProblems(ws, packet) {
     const _req = packet;
     ws.send(JSON.stringify((0, problems_1.createProblemsSnapshotMessage)()));
 }
+async function handleClearResolvedProblems(ws, packet) {
+    if (packet.type !== 'clear_resolved_problems') {
+        throw new Error('Internal error: handleClearResolvedProblems called with non clear_resolved_problems packet');
+    }
+    const _req = packet;
+    const removedCount = (0, problems_1.clearResolvedProblems)();
+    ws.send(JSON.stringify({
+        type: 'clear_resolved_problems_result',
+        removedCount,
+        timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+    }));
+}
 async function handleSetUiLanguage(ws, packet) {
     if (packet.type !== 'set_ui_language') {
         throw new Error('Internal error: handleSetUiLanguage called with non set_ui_language packet');
@@ -1214,6 +1230,7 @@ async function handleUserAnswer2Q4H(ws, packet) {
                 msgId: effectivePrompt.msgId,
                 grammar: effectivePrompt.grammar,
                 userLanguageCode: effectivePrompt.userLanguageCode,
+                origin: 'user',
                 q4hAnswerCallIds: askHumanCallIds,
                 runControl: undefined,
             });