dominds 1.6.3 → 1.6.5

package/dist/apps/installed-file.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTALLED_APPS_REL_PATH = void 0;
+exports.loadInstalledAppsFile = loadInstalledAppsFile;
+exports.writeInstalledAppsFile = writeInstalledAppsFile;
+exports.upsertInstalledApp = upsertInstalledApp;
+exports.removeInstalledApp = removeInstalledApp;
+exports.setAppEnabled = setAppEnabled;
+exports.setAppRuntimePort = setAppRuntimePort;
+exports.findInstalledApp = findInstalledApp;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const time_1 = require("../shared/utils/time");
+exports.INSTALLED_APPS_REL_PATH = path_1.default.join('.apps', 'installed.yaml');
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function asString(v) {
+    return typeof v === 'string' ? v : null;
+}
+function asBool(v) {
+    return typeof v === 'boolean' ? v : null;
+}
+function asNullableNumber(v) {
+    if (v === null)
+        return null;
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    return 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 spec = asString(v['spec']);
+        if (!spec || spec.trim() === '')
+            return { ok: false, errorText: `Invalid ${at}.spec: required` };
+        return { ok: true, source: { kind, spec } };
+    }
+    const pathAbs = asString(v['pathAbs']);
+    if (!pathAbs || pathAbs.trim() === '')
+        return { ok: false, errorText: `Invalid ${at}.pathAbs: required` };
+    return { ok: true, source: { kind, pathAbs } };
+}
+function parseRuntime(v, at) {
+    if (!isRecord(v))
+        return { ok: false, errorText: `Invalid ${at}: expected object` };
+    const portRaw = v['port'];
+    const port = asNullableNumber(portRaw);
+    if (port === null) {
+        if (portRaw !== null) {
+            return { ok: false, errorText: `Invalid ${at}.port: expected number|null` };
+        }
+        return { ok: true, runtime: { port: null } };
+    }
+    if (port < 0 || !Number.isInteger(port))
+        return { ok: false, errorText: `Invalid ${at}.port: expected non-negative integer|null` };
+    return { ok: true, runtime: { port: port } };
+}
+function parseEntry(v, at) {
+    if (!isRecord(v))
+        return { ok: false, errorText: `Invalid ${at}: expected object` };
+    const id = asString(v['id']);
+    if (!id || id.trim() === '')
+        return { ok: false, errorText: `Invalid ${at}.id: required` };
+    const enabled = asBool(v['enabled']);
+    if (enabled === null)
+        return { ok: false, errorText: `Invalid ${at}.enabled: boolean required` };
+    const installedAt = asString(v['installedAt']);
+    const updatedAt = asString(v['updatedAt']);
+    if (!installedAt || installedAt.trim() === '')
+        return { ok: false, errorText: `Invalid ${at}.installedAt: required` };
+    if (!updatedAt || updatedAt.trim() === '')
+        return { ok: false, errorText: `Invalid ${at}.updatedAt: required` };
+    const sourceParsed = parseSource(v['source'], `${at}.source`);
+    if (!sourceParsed.ok)
+        return sourceParsed;
+    const runtimeParsed = parseRuntime(v['runtime'] ?? { port: null }, `${at}.runtime`);
+    if (!runtimeParsed.ok)
+        return runtimeParsed;
+    // installJson is validated by install/update command on write. On read we keep permissive:
+    // kernel will fail fast later if it needs a missing field.
+    const installJson = v['installJson'];
+    if (!isRecord(installJson))
+        return { ok: false, errorText: `Invalid ${at}.installJson: expected object` };
+    return {
+        ok: true,
+        entry: {
+            id,
+            enabled,
+            source: sourceParsed.source,
+            runtime: runtimeParsed.runtime,
+            installJson: installJson,
+            installedAt,
+            updatedAt,
+        },
+    };
+}
+async function loadInstalledAppsFile(params) {
+    const filePathAbs = path_1.default.resolve(params.rtwsRootAbs, exports.INSTALLED_APPS_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, file: { schemaVersion: 1, apps: [] } };
+        }
+        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)}`,
+        };
+    }
+    if (!isRecord(parsed)) {
+        return { kind: 'error', filePathAbs, errorText: 'Invalid installed.yaml: expected object' };
+    }
+    const schemaVersion = parsed['schemaVersion'];
+    if (schemaVersion !== 1) {
+        return {
+            kind: 'error',
+            filePathAbs,
+            errorText: `Unsupported schemaVersion: ${String(schemaVersion)}`,
+        };
+    }
+    const appsRaw = parsed['apps'];
+    if (!Array.isArray(appsRaw)) {
+        return {
+            kind: 'error',
+            filePathAbs,
+            errorText: 'Invalid installed.yaml: apps must be an array',
+        };
+    }
+    const apps = [];
+    for (let i = 0; i < appsRaw.length; i += 1) {
+        const e = parseEntry(appsRaw[i], `apps[${i}]`);
+        if (!e.ok)
+            return { kind: 'error', filePathAbs, errorText: e.errorText };
+        apps.push(e.entry);
+    }
+    return { kind: 'ok', filePathAbs, file: { schemaVersion: 1, apps } };
+}
+async function writeInstalledAppsFile(params) {
+    const dirAbs = path_1.default.resolve(params.rtwsRootAbs, '.apps');
+    await promises_1.default.mkdir(dirAbs, { recursive: true });
+    const filePathAbs = path_1.default.resolve(params.rtwsRootAbs, exports.INSTALLED_APPS_REL_PATH);
+    const yamlText = yaml_1.default.stringify(params.file);
+    await promises_1.default.writeFile(filePathAbs, yamlText, 'utf-8');
+}
+function upsertInstalledApp(params) {
+    const apps = [...params.existing.apps];
+    const idx = apps.findIndex((a) => a.id === params.next.id);
+    if (idx >= 0) {
+        apps[idx] = params.next;
+    }
+    else {
+        apps.push(params.next);
+    }
+    return { schemaVersion: 1, apps };
+}
+function removeInstalledApp(params) {
+    return { schemaVersion: 1, apps: params.existing.apps.filter((a) => a.id !== params.appId) };
+}
+function setAppEnabled(params) {
+    const now = (0, time_1.formatUnifiedTimestamp)(new Date());
+    const apps = params.existing.apps.map((a) => a.id === params.appId ? { ...a, enabled: params.enabled, updatedAt: now } : a);
+    return { schemaVersion: 1, apps };
+}
+function setAppRuntimePort(params) {
+    const existingApp = findInstalledApp(params.existing, params.appId);
+    if (!existingApp)
+        return params.existing;
+    if (existingApp.runtime.port === params.port)
+        return params.existing;
+    const now = (0, time_1.formatUnifiedTimestamp)(new Date());
+    const apps = params.existing.apps.map((a) => a.id === params.appId
+        ? { ...a, runtime: { ...a.runtime, port: params.port }, updatedAt: now }
+        : a);
+    return { schemaVersion: 1, apps };
+}
+function findInstalledApp(file, appId) {
+    const found = file.apps.find((a) => a.id === appId);
+    return found ?? null;
+}

package/dist/apps/runtime-port.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStableAppRuntimePort = resolveStableAppRuntimePort;
+const node_net_1 = __importDefault(require("node:net"));
+const STABLE_PORT_RANGE_START = 43000;
+const STABLE_PORT_RANGE_END = 49999;
+const PORT_MAX = 65535;
+function isPositivePort(value) {
+    return (typeof value === 'number' &&
+        Number.isInteger(value) &&
+        value > 0 &&
+        value <= PORT_MAX &&
+        Number.isFinite(value));
+}
+function hashAppId(appId) {
+    // FNV-1a 32-bit hash for deterministic port probing order.
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < appId.length; i += 1) {
+        hash ^= appId.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+function collectReservedPorts(existingApps, appId) {
+    const reserved = new Set();
+    for (const app of existingApps) {
+        if (app.id === appId)
+            continue;
+        if (isPositivePort(app.runtime.port)) {
+            reserved.add(app.runtime.port);
+        }
+    }
+    return reserved;
+}
+async function canBindPort(port) {
+    return await new Promise((resolve) => {
+        const server = node_net_1.default.createServer();
+        server.unref();
+        const finish = (ok) => {
+            server.removeAllListeners('error');
+            server.removeAllListeners('listening');
+            resolve(ok);
+        };
+        server.once('error', () => {
+            finish(false);
+        });
+        server.once('listening', () => {
+            server.close(() => finish(true));
+        });
+        server.listen({ host: '127.0.0.1', port, exclusive: true });
+    });
+}
+async function pickDeterministicAvailablePort(params) {
+    const rangeSize = STABLE_PORT_RANGE_END - STABLE_PORT_RANGE_START + 1;
+    if (rangeSize <= 0) {
+        throw new Error('Invalid stable app runtime port range configuration');
+    }
+    const baseHash = hashAppId(params.appId);
+    for (let i = 0; i < rangeSize; i += 1) {
+        const candidate = STABLE_PORT_RANGE_START + ((baseHash + i) % rangeSize);
+        if (params.reservedPorts.has(candidate))
+            continue;
+        if (await canBindPort(candidate))
+            return candidate;
+    }
+    throw new Error(`Failed to allocate stable runtime port for app '${params.appId}': no bindable port in ${STABLE_PORT_RANGE_START}-${STABLE_PORT_RANGE_END}`);
+}
+async function resolveStableAppRuntimePort(params) {
+    if (!params.installJson.frontend)
+        return null;
+    const reservedPorts = collectReservedPorts(params.existingApps, params.appId);
+    if (isPositivePort(params.existingRuntimePort)) {
+        if (reservedPorts.has(params.existingRuntimePort)) {
+            throw new Error(`Invalid installed apps state: runtime port ${params.existingRuntimePort} for '${params.appId}' collides with another installed app`);
+        }
+        return params.existingRuntimePort;
+    }
+    const defaultPort = params.installJson.frontend.defaultPort;
+    if (isPositivePort(defaultPort) &&
+        !reservedPorts.has(defaultPort) &&
+        (await canBindPort(defaultPort))) {
+        return defaultPort;
+    }
+    return await pickDeterministicAvailablePort({
+        appId: params.appId,
+        reservedPorts,
+    });
+}

package/dist/course-transition.js

@@ -0,0 +1,200 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClearedMindInvalidationNotice = buildClearedMindInvalidationNotice;
+exports.notifyWaitingDialogsOfClearedMind = notifyWaitingDialogsOfClearedMind;
+const dialog_global_registry_1 = require("./dialog-global-registry");
+const dialog_instance_registry_1 = require("./dialog-instance-registry");
+const log_1 = require("./log");
+const persistence_1 = require("./persistence");
+const runtime_language_1 = require("./shared/runtime-language");
+const inter_dialog_format_1 = require("./shared/utils/inter-dialog-format");
+const pending_tellask_reminder_1 = require("./tools/pending-tellask-reminder");
+function buildClearedMindInvalidationNotice(language) {
+    if (language === 'zh') {
+        return '系统反馈：诉请对象已清理头脑并开启新一程对话；本轮诉请已失效，请基于最新完整上下文重新诉请祂。';
+    }
+    return 'System notice: the callee cleared its mind and started a new course; this tellask round is no longer valid. Re-tellask with the latest complete context.';
+}
+async function loadWaitingOwnerRecords(dialog) {
+    const allDialogIds = await persistence_1.DialogPersistence.listAllDialogIds('running');
+    const results = [];
+    for (const candidateId of allDialogIds) {
+        if (candidateId.rootId !== dialog.id.rootId) {
+            continue;
+        }
+        const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(candidateId, 'running');
+        const matching = pending.filter((record) => record.subdialogId === dialog.id.selfId);
+        if (matching.length === 0) {
+            continue;
+        }
+        results.push({
+            ownerDialogId: candidateId,
+            pendingRecords: matching,
+        });
+    }
+    return results;
+}
+function resolveOwnerDialogFromCurrentTree(currentDialog, ownerDialogId) {
+    if (currentDialog.id.selfId === currentDialog.id.rootId) {
+        const rootDialog = currentDialog;
+        if (ownerDialogId === rootDialog.id.selfId) {
+            return rootDialog;
+        }
+        return rootDialog.lookupDialog(ownerDialogId);
+    }
+    // Rationale: in this code path, every non-root dialog is a SubDialog. Prefer the live
+    // in-memory root tree first so existing dialog objects receive state/message updates.
+    const rootDialog = currentDialog.rootDialog;
+    if (ownerDialogId === rootDialog.id.selfId) {
+        return rootDialog;
+    }
+    return rootDialog.lookupDialog(ownerDialogId);
+}
+async function resolveOwnerDialog(currentDialog, rootId, ownerDialogId) {
+    const live = resolveOwnerDialogFromCurrentTree(currentDialog, ownerDialogId.selfId);
+    if (live) {
+        return live;
+    }
+    const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(rootId, 'running');
+    if (!rootDialog) {
+        return undefined;
+    }
+    if (ownerDialogId.selfId === rootDialog.id.selfId) {
+        return rootDialog;
+    }
+    return await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, ownerDialogId, 'running');
+}
+async function syncPendingTellaskReminderOrThrow(ownerDialog) {
+    const changed = await (0, pending_tellask_reminder_1.syncPendingTellaskReminderState)(ownerDialog);
+    if (!changed) {
+        return;
+    }
+    await ownerDialog.processReminderUpdates();
+}
+async function reviveOwnerDialogIfReady(ownerDialog) {
+    const hasQ4H = await ownerDialog.hasPendingQ4H();
+    const hasPendingSubdialogs = await ownerDialog.hasPendingSubdialogs();
+    if (hasQ4H || hasPendingSubdialogs) {
+        return;
+    }
+    if (ownerDialog.id.selfId === ownerDialog.id.rootId) {
+        const hasRegistryEntry = dialog_global_registry_1.globalDialogRegistry.get(ownerDialog.id.rootId) !== undefined;
+        await persistence_1.DialogPersistence.setNeedsDrive(ownerDialog.id, true, ownerDialog.status);
+        if (hasRegistryEntry) {
+            dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(ownerDialog.id.rootId, {
+                source: 'kernel_driver_supply_response',
+                reason: 'callee_cleared_mind_invalidated_pending_waiters',
+            });
+            return;
+        }
+    }
+    const { driveDialogStream } = await Promise.resolve().then(() => __importStar(require('./llm/kernel-driver')));
+    void driveDialogStream(ownerDialog, undefined, true, {
+        suppressDiligencePush: ownerDialog.disableDiligencePush,
+        source: 'kernel_driver_supply_response_parent_revive',
+        reason: 'callee_cleared_mind_invalidated_pending_waiters',
+    });
+}
+async function notifyWaitingDialogsOfClearedMind(dialog) {
+    if (dialog.status !== 'running') {
+        return 0;
+    }
+    const waitingOwners = await loadWaitingOwnerRecords(dialog);
+    if (waitingOwners.length === 0) {
+        return 0;
+    }
+    const language = (0, runtime_language_1.getWorkLanguage)();
+    const responseBody = buildClearedMindInvalidationNotice(language);
+    let totalInvalidated = 0;
+    for (const owner of waitingOwners) {
+        const ownerDialog = await resolveOwnerDialog(dialog, dialog.id.rootId, owner.ownerDialogId);
+        if (!ownerDialog) {
+            throw new Error(`Failed to restore owner dialog while invalidating cleared-mind tellask waiters: root=${dialog.id.rootId} owner=${owner.ownerDialogId.valueOf()} callee=${dialog.id.valueOf()}`);
+        }
+        const pendingOutcome = await persistence_1.DialogPersistence.mutatePendingSubdialogs(ownerDialog.id, (previous) => {
+            const next = previous.filter((record) => record.subdialogId !== dialog.id.selfId);
+            return { kind: 'replace', records: next };
+        }, undefined, ownerDialog.status);
+        for (const pendingRecord of owner.pendingRecords) {
+            const requesterId = ownerDialog.agentId;
+            const response = (0, inter_dialog_format_1.formatTeammateResponseContent)({
+                callName: pendingRecord.callName,
+                responderId: dialog.agentId,
+                requesterId,
+                mentionList: pendingRecord.mentionList,
+                sessionSlug: pendingRecord.sessionSlug,
+                tellaskContent: pendingRecord.tellaskContent,
+                responseBody,
+                status: 'failed',
+                language,
+            });
+            await ownerDialog.receiveTeammateResponse(dialog.agentId, pendingRecord.callName, pendingRecord.mentionList, pendingRecord.tellaskContent, 'failed', dialog.id, {
+                response,
+                agentId: dialog.agentId,
+                callId: pendingRecord.callId,
+                originMemberId: requesterId,
+                sessionSlug: pendingRecord.sessionSlug,
+            });
+            const immediateMirror = {
+                type: 'tellask_result_msg',
+                role: 'tool',
+                responderId: dialog.agentId,
+                mentionList: pendingRecord.mentionList,
+                tellaskContent: pendingRecord.tellaskContent,
+                status: 'failed',
+                callId: pendingRecord.callId,
+                content: response,
+            };
+            await ownerDialog.addChatMessages(immediateMirror);
+            totalInvalidated += 1;
+        }
+        try {
+            await syncPendingTellaskReminderOrThrow(ownerDialog);
+        }
+        catch (err) {
+            log_1.log.error('Failed to sync pending-tellask reminder after cleared-mind invalidation', err, {
+                rootId: dialog.id.rootId,
+                calleeDialogId: dialog.id.selfId,
+                ownerDialogId: ownerDialog.id.selfId,
+            });
+            throw err;
+        }
+        if (pendingOutcome.records.length === 0) {
+            await reviveOwnerDialogIfReady(ownerDialog);
+        }
+    }
+    return totalInvalidated;
+}

package/dist/dialog.js

@@ -1,4 +1,37 @@
 "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;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DialogStore = exports.RootDialog = exports.SubDialog = exports.Dialog = exports.DialogID = void 0;
 /**
@@ -663,6 +696,8 @@ class Dialog {
                 runControl: runControlSpec,
             });
         }
+        const { notifyWaitingDialogsOfClearedMind } = await Promise.resolve().then(() => __importStar(require('./course-transition')));
+        await notifyWaitingDialogsOfClearedMind(this);
     }
     // Proxy methods for DialogStore - route calls through dialog object instead of direct dlgStore access
     async receiveFuncResult(result) {