dominds 1.3.0 → 1.4.1

package/README.md

@@ -69,9 +69,16 @@ Dominds is an AI-powered DevOps framework that creates autonomous agentic teams
 
 ### Prerequisites
 
-- **Node.js (with npm bundled)**: Version 22.x or later
+- **Node.js (with npm bundled)**: Version 24.x LTS
+- **npm (if used directly)**: Use the npm bundled with your installed Node.js 24 LTS; current minimum in this repo is `11.9.0`, and newer versions are allowed.
 - **LLM provider configured for your team**: Dominds ships with a built-in provider catalog [main/llm/defaults.yaml](./main/llm/defaults.yaml) including Codex (ChatGPT) and Anthropic, plus several Anthropic-compatible endpoints (e.g. MiniMax, Z.ai, BigModel). You’ll need valid credentials for at least one provider.
-- **pnpm (optional)**: Recommended only if you’re developing Dominds itself.
+- **pnpm (optional)**: Recommended only if you’re developing Dominds itself. Prefer enabling the pinned CLI once via `npm run setup:pm`. If Corepack shims cannot be enabled in your environment, install `pnpm@10` manually.
+
+For repo development, initialize the package manager once after `nvm use --lts`:
+
+```bash
+npm run setup:pm
+```
 
 ### Install Dominds
 

package/README.zh.md

@@ -23,9 +23,16 @@ Dominds 是一款面向开发运作（DevOps）场景的智能体框架，它将
 
 ### 环境要求
 
-- **Node.js（含 npm）**：版本 22.x 及以上
+- **Node.js（含 npm）**：版本 24.x LTS
+- **npm（如直接使用）**：使用当前安装的 Node.js 24 LTS 自带 npm；本仓库当前最低要求为 `11.9.0`，更高版本也允许。
 - **至少一个可用的 LLM 服务提供商**：Dominds 内置提供商目录（路径：[main/llm/defaults.yaml](./main/llm/defaults.yaml)），需为其中至少一个提供商配置有效凭证（通过环境变量设置）。
-- **pnpm（可选）**：仅在开发 Dominds 本体时推荐安装。
+- **pnpm（可选）**：仅在开发 Dominds 本体时推荐使用。优先执行一次 `npm run setup:pm` 启用并缓存仓库固定的 pnpm；若你的环境无法启用 Corepack shim，再手动安装 `pnpm@10`。
+
+开发本仓库时，建议在 `nvm use --lts` 之后先执行一次：
+
+```bash
+npm run setup:pm
+```
 
 ### 安装 Dominds
 

package/dist/apps/app-lock-file.js

@@ -6,7 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.APP_LOCK_REL_PATH = void 0;
 exports.parseAppLockFile = parseAppLockFile;
 exports.loadAppLockFile = loadAppLockFile;
+exports.findLockedApp = findLockedApp;
 exports.upsertLockedApp = upsertLockedApp;
+exports.removeLockedApp = removeLockedApp;
 exports.writeAppLockFileIfChanged = writeAppLockFileIfChanged;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -24,53 +26,18 @@ function asNullableString(v) {
         return null;
     return typeof v === 'string' ? v : null;
 }
-function parseSource(v, at) {
-    if (!isRecord(v))
-        return { ok: false, errorText: `Invalid ${at}: expected object` };
-    const kind = asString(v['kind']);
-    if (kind !== 'npx' && kind !== 'local') {
-        return { ok: false, errorText: `Invalid ${at}.kind: expected 'npx'|'local'` };
-    }
-    if (kind === 'npx') {
-        const keys = Object.keys(v);
-        for (const k of keys) {
-            if (k !== 'kind' && k !== 'spec') {
-                return { ok: false, errorText: `Invalid ${at}: unknown key '${k}'` };
-            }
-        }
-        const spec = asString(v['spec']);
-        if (!spec || spec.trim() === '') {
-            return { ok: false, errorText: `Invalid ${at}.spec: required` };
-        }
-        return { ok: true, source: { kind, spec } };
-    }
-    const keys = Object.keys(v);
-    for (const k of keys) {
-        if (k !== 'kind' && k !== 'pathAbs') {
-            return { ok: false, errorText: `Invalid ${at}: unknown key '${k}'` };
-        }
-    }
-    const pathAbs = asString(v['pathAbs']);
-    if (!pathAbs || pathAbs.trim() === '') {
-        return { ok: false, errorText: `Invalid ${at}.pathAbs: required` };
-    }
-    return { ok: true, source: { kind, pathAbs } };
-}
 function parseEntry(v, at) {
     if (!isRecord(v))
         return { ok: false, errorText: `Invalid ${at}: expected object` };
     const keys = Object.keys(v);
     for (const k of keys) {
-        if (k !== 'id' && k !== 'source' && k !== 'package') {
+        if (k !== 'id' && k !== 'package') {
             return { ok: false, errorText: `Invalid ${at}: unknown key '${k}'` };
         }
     }
     const id = asString(v['id']);
     if (!id || id.trim() === '')
         return { ok: false, errorText: `Invalid ${at}.id: required` };
-    const sourceParsed = parseSource(v['source'], `${at}.source`);
-    if (!sourceParsed.ok)
-        return sourceParsed;
     const pkg = v['package'];
     if (!isRecord(pkg)) {
         return { ok: false, errorText: `Invalid ${at}.package: expected object` };
@@ -98,22 +65,23 @@ function parseEntry(v, at) {
     return {
         ok: true,
         entry: {
-            id,
-            source: sourceParsed.source,
-            package: { name, version },
+            id: id.trim(),
+            package: { name: name.trim(), version },
         },
     };
 }
 function canonicalizeLockFile(file) {
     const byId = new Map();
-    for (const e of file.apps) {
-        if (byId.has(e.id)) {
-            throw new Error(`Invalid ${exports.APP_LOCK_REL_PATH}: duplicate app id '${e.id}'`);
+    for (const entry of file.apps) {
+        if (byId.has(entry.id)) {
+            throw new Error(`Invalid ${exports.APP_LOCK_REL_PATH}: duplicate app id '${entry.id}'`);
         }
-        byId.set(e.id, e);
+        byId.set(entry.id, entry);
     }
-    const apps = [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
-    return { schemaVersion: 1, apps };
+    return {
+        schemaVersion: 1,
+        apps: [...byId.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    };
 }
 function parseAppLockFile(parsed, filePathAbs) {
     if (!isRecord(parsed)) {
@@ -141,10 +109,10 @@ function parseAppLockFile(parsed, filePathAbs) {
     }
     const apps = [];
     for (let i = 0; i < appsRaw.length; i += 1) {
-        const e = parseEntry(appsRaw[i], `apps[${i}]`);
-        if (!e.ok)
-            return { ok: false, errorText: `${e.errorText} (${filePathAbs})` };
-        apps.push(e.entry);
+        const parsedEntry = parseEntry(appsRaw[i], `apps[${i}]`);
+        if (!parsedEntry.ok)
+            return { ok: false, errorText: `${parsedEntry.errorText} (${filePathAbs})` };
+        apps.push(parsedEntry.entry);
     }
     try {
         return { ok: true, file: canonicalizeLockFile({ schemaVersion: 1, apps }) };
@@ -192,33 +160,41 @@ async function loadAppLockFile(params) {
         return { kind: 'error', filePathAbs, errorText: lockParsed.errorText };
     return { kind: 'ok', filePathAbs, exists: true, file: lockParsed.file };
 }
+function findLockedApp(file, appId) {
+    return file.apps.find((entry) => entry.id === appId) ?? null;
+}
 function upsertLockedApp(params) {
-    const existingEntry = params.existing.apps.find((a) => a.id === params.next.id) ?? null;
+    const existingEntry = findLockedApp(params.existing, params.next.id);
     if (existingEntry && (0, node_util_1.isDeepStrictEqual)(existingEntry, params.next))
         return params.existing;
     const apps = [...params.existing.apps];
-    const idx = apps.findIndex((a) => a.id === params.next.id);
+    const idx = apps.findIndex((entry) => entry.id === params.next.id);
     if (idx >= 0)
         apps[idx] = params.next;
     else
         apps.push(params.next);
     return canonicalizeLockFile({ schemaVersion: 1, apps });
 }
+function removeLockedApp(params) {
+    if (!params.existing.apps.some((entry) => entry.id === params.appId))
+        return params.existing;
+    return canonicalizeLockFile({
+        schemaVersion: 1,
+        apps: params.existing.apps.filter((entry) => entry.id !== params.appId),
+    });
+}
 async function writeAppLockFileIfChanged(params) {
     const canonical = canonicalizeLockFile(params.file);
     const loaded = await loadAppLockFile({ rtwsRootAbs: params.rtwsRootAbs });
     if (loaded.kind === 'error') {
-        // Avoid overwriting user edits if the existing file is corrupt.
         throw new Error(`Failed to read ${exports.APP_LOCK_REL_PATH}: ${loaded.errorText}`);
     }
     if (loaded.exists) {
-        const prevCanonical = canonicalizeLockFile(loaded.file);
-        if ((0, node_util_1.isDeepStrictEqual)(prevCanonical, canonical))
+        if ((0, node_util_1.isDeepStrictEqual)(canonicalizeLockFile(loaded.file), canonical))
             return;
     }
-    else {
-        if (canonical.apps.length === 0)
-            return;
+    else if (canonical.apps.length === 0) {
+        return;
     }
     const mindsDirAbs = node_path_1.default.resolve(params.rtwsRootAbs, '.minds');
     await promises_1.default.mkdir(mindsDirAbs, { recursive: true });

package/dist/apps/configuration-file.js

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APPS_CONFIGURATION_REL_PATH = exports.DEFAULT_APPS_RESOLUTION_STRATEGY = void 0;
+exports.parseResolutionStrategy = parseResolutionStrategy;
+exports.loadAppsConfigurationFile = loadAppsConfigurationFile;
+exports.writeAppsConfigurationFile = writeAppsConfigurationFile;
+exports.writeAppsConfigurationFileIfChanged = writeAppsConfigurationFileIfChanged;
+exports.isAppDisabledInConfiguration = isAppDisabledInConfiguration;
+exports.setAppDisabledInConfiguration = setAppDisabledInConfiguration;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = __importDefault(require("yaml"));
+exports.DEFAULT_APPS_RESOLUTION_STRATEGY = {
+    order: ['local'],
+    localRoots: ['dominds-apps'],
+};
+exports.APPS_CONFIGURATION_REL_PATH = node_path_1.default.join('.apps', 'configuration.yaml');
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function asString(v) {
+    return typeof v === 'string' ? v : null;
+}
+function parseResolutionStrategy(v, at) {
+    if (!isRecord(v))
+        return { ok: false, errorText: `Invalid ${at}: expected object` };
+    const keys = Object.keys(v);
+    for (const k of keys) {
+        if (k !== 'order' && k !== 'localRoots') {
+            return { ok: false, errorText: `Invalid ${at}: unknown key '${k}'` };
+        }
+    }
+    const orderRaw = v['order'];
+    const order = (() => {
+        if (orderRaw === undefined)
+            return undefined;
+        if (!Array.isArray(orderRaw)) {
+            return { ok: false, errorText: `Invalid ${at}.order: expected array` };
+        }
+        const out = [];
+        for (let i = 0; i < orderRaw.length; i += 1) {
+            const item = orderRaw[i];
+            if (item !== 'local' && item !== 'npx') {
+                return {
+                    ok: false,
+                    errorText: `Invalid ${at}.order[${i}]: expected 'local'|'npx'`,
+                };
+            }
+            out.push(item);
+        }
+        if (out.length === 0) {
+            return { ok: false, errorText: `Invalid ${at}.order: must not be empty` };
+        }
+        return { ok: true, value: out };
+    })();
+    if (order && !order.ok)
+        return order;
+    const localRootsRaw = v['localRoots'];
+    const localRoots = (() => {
+        if (localRootsRaw === undefined)
+            return undefined;
+        if (!Array.isArray(localRootsRaw)) {
+            return { ok: false, errorText: `Invalid ${at}.localRoots: expected array` };
+        }
+        const out = [];
+        for (let i = 0; i < localRootsRaw.length; i += 1) {
+            const item = localRootsRaw[i];
+            if (typeof item !== 'string' || item.trim() === '') {
+                return {
+                    ok: false,
+                    errorText: `Invalid ${at}.localRoots[${i}]: expected non-empty string`,
+                };
+            }
+            out.push(item.trim());
+        }
+        if (out.length === 0) {
+            return { ok: false, errorText: `Invalid ${at}.localRoots: must not be empty` };
+        }
+        return { ok: true, value: out };
+    })();
+    if (localRoots && !localRoots.ok)
+        return localRoots;
+    return {
+        ok: true,
+        strategy: {
+            order: order ? order.value : undefined,
+            localRoots: localRoots ? localRoots.value : undefined,
+        },
+    };
+}
+function canonicalizeConfigurationFile(file) {
+    const disabledApps = file.disabledApps
+        ? [
+            ...new Set(file.disabledApps.map((appId) => appId.trim()).filter((appId) => appId !== '')),
+        ].sort()
+        : [];
+    return {
+        schemaVersion: 1,
+        resolutionStrategy: file.resolutionStrategy,
+        disabledApps: disabledApps.length > 0 ? disabledApps : undefined,
+    };
+}
+function parseConfigurationFile(parsed, filePathAbs) {
+    if (!isRecord(parsed)) {
+        return { ok: false, errorText: `Invalid configuration.yaml: expected object (${filePathAbs})` };
+    }
+    const keys = Object.keys(parsed);
+    for (const k of keys) {
+        if (k !== 'schemaVersion' && k !== 'resolutionStrategy' && k !== 'disabledApps') {
+            return {
+                ok: false,
+                errorText: `Invalid configuration.yaml: unknown key '${k}' (${filePathAbs})`,
+            };
+        }
+    }
+    const schemaVersion = parsed['schemaVersion'];
+    if (schemaVersion !== 1) {
+        return {
+            ok: false,
+            errorText: `Unsupported configuration.yaml schemaVersion: ${String(schemaVersion)} (${filePathAbs})`,
+        };
+    }
+    const strategyRaw = parsed['resolutionStrategy'];
+    const resolutionStrategy = (() => {
+        if (strategyRaw === undefined)
+            return undefined;
+        const strategy = parseResolutionStrategy(strategyRaw, 'resolutionStrategy');
+        if (!strategy.ok)
+            return strategy;
+        return { ok: true, value: strategy.strategy };
+    })();
+    if (resolutionStrategy && !resolutionStrategy.ok) {
+        return { ok: false, errorText: `${resolutionStrategy.errorText} (${filePathAbs})` };
+    }
+    const disabledRaw = parsed['disabledApps'];
+    const disabledApps = (() => {
+        if (disabledRaw === undefined)
+            return undefined;
+        if (!Array.isArray(disabledRaw)) {
+            return {
+                ok: false,
+                errorText: `Invalid disabledApps: expected array (${filePathAbs})`,
+            };
+        }
+        const out = [];
+        for (let i = 0; i < disabledRaw.length; i += 1) {
+            const item = asString(disabledRaw[i]);
+            if (!item || item.trim() === '') {
+                return {
+                    ok: false,
+                    errorText: `Invalid disabledApps[${i}]: expected non-empty string (${filePathAbs})`,
+                };
+            }
+            out.push(item.trim());
+        }
+        return { ok: true, value: out };
+    })();
+    if (disabledApps && !disabledApps.ok)
+        return disabledApps;
+    return {
+        ok: true,
+        file: canonicalizeConfigurationFile({
+            schemaVersion: 1,
+            resolutionStrategy: resolutionStrategy ? resolutionStrategy.value : undefined,
+            disabledApps: disabledApps ? disabledApps.value : undefined,
+        }),
+    };
+}
+async function loadAppsConfigurationFile(params) {
+    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, exports.APPS_CONFIGURATION_REL_PATH);
+    let raw;
+    try {
+        raw = await promises_1.default.readFile(filePathAbs, 'utf-8');
+    }
+    catch (err) {
+        const isEnoent = typeof err === 'object' &&
+            err !== null &&
+            'code' in err &&
+            err.code === 'ENOENT';
+        if (isEnoent) {
+            return {
+                kind: 'ok',
+                filePathAbs,
+                exists: false,
+                file: { schemaVersion: 1 },
+            };
+        }
+        return {
+            kind: 'error',
+            filePathAbs,
+            errorText: err instanceof Error ? err.message : String(err),
+        };
+    }
+    let parsed;
+    try {
+        parsed = yaml_1.default.parse(raw);
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            filePathAbs,
+            errorText: `Failed to parse YAML: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const cfg = parseConfigurationFile(parsed, filePathAbs);
+    if (!cfg.ok) {
+        return { kind: 'error', filePathAbs, errorText: cfg.errorText };
+    }
+    return {
+        kind: 'ok',
+        filePathAbs,
+        exists: true,
+        file: cfg.file,
+    };
+}
+async function writeAppsConfigurationFile(params) {
+    const dirAbs = node_path_1.default.resolve(params.rtwsRootAbs, '.apps');
+    await promises_1.default.mkdir(dirAbs, { recursive: true });
+    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, exports.APPS_CONFIGURATION_REL_PATH);
+    const yamlText = yaml_1.default.stringify(canonicalizeConfigurationFile(params.file));
+    await promises_1.default.writeFile(filePathAbs, yamlText, 'utf-8');
+}
+async function writeAppsConfigurationFileIfChanged(params) {
+    const dirAbs = node_path_1.default.resolve(params.rtwsRootAbs, '.apps');
+    await promises_1.default.mkdir(dirAbs, { recursive: true });
+    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, exports.APPS_CONFIGURATION_REL_PATH);
+    const yamlText = yaml_1.default.stringify(canonicalizeConfigurationFile(params.file));
+    try {
+        const prev = await promises_1.default.readFile(filePathAbs, 'utf-8');
+        if (prev === yamlText)
+            return;
+    }
+    catch (err) {
+        const isEnoent = typeof err === 'object' &&
+            err !== null &&
+            'code' in err &&
+            err.code === 'ENOENT';
+        if (!isEnoent)
+            throw err;
+    }
+    await promises_1.default.writeFile(filePathAbs, yamlText, 'utf-8');
+}
+function isAppDisabledInConfiguration(file, appId) {
+    return (file.disabledApps ?? []).includes(appId);
+}
+function setAppDisabledInConfiguration(params) {
+    const appId = params.appId.trim();
+    if (appId === '')
+        return params.existing;
+    const disabledSet = new Set(params.existing.disabledApps ?? []);
+    if (params.disabled)
+        disabledSet.add(appId);
+    else
+        disabledSet.delete(appId);
+    const next = canonicalizeConfigurationFile({
+        schemaVersion: 1,
+        resolutionStrategy: params.existing.resolutionStrategy,
+        disabledApps: [...disabledSet],
+    });
+    const prev = canonicalizeConfigurationFile(params.existing);
+    if (yaml_1.default.stringify(prev) === yaml_1.default.stringify(next))
+        return params.existing;
+    return next;
+}