dominds 1.6.7 → 1.7.0

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

@@ -150,7 +150,7 @@ async function notifyWaitingDialogsOfClearedMind(dialog) {
         }, undefined, ownerDialog.status);
         for (const pendingRecord of owner.pendingRecords) {
             const requesterId = ownerDialog.agentId;
-            const response = (0, inter_dialog_format_1.formatTeammateResponseContent)({
+            const response = (0, inter_dialog_format_1.formatTellaskResponseContent)({
                 callName: pendingRecord.callName,
                 responderId: dialog.agentId,
                 requesterId,
@@ -161,23 +161,51 @@ async function notifyWaitingDialogsOfClearedMind(dialog) {
                 status: 'failed',
                 language,
             });
-            await ownerDialog.receiveTeammateResponse(dialog.agentId, pendingRecord.callName, pendingRecord.mentionList, pendingRecord.tellaskContent, 'failed', dialog.id, {
+            const carryoverOriginCourse = pendingRecord.callingCourse;
+            const carryoverContent = carryoverOriginCourse !== undefined && carryoverOriginCourse !== ownerDialog.currentCourse
+                ? (0, inter_dialog_format_1.formatTellaskCarryoverResultContent)({
+                    originCourse: carryoverOriginCourse,
+                    callName: pendingRecord.callName,
+                    responderId: dialog.agentId,
+                    mentionList: pendingRecord.mentionList,
+                    sessionSlug: pendingRecord.sessionSlug,
+                    tellaskContent: pendingRecord.tellaskContent,
+                    responseBody,
+                    status: 'failed',
+                    language,
+                })
+                : undefined;
+            await ownerDialog.receiveTellaskResponse(dialog.agentId, pendingRecord.callName, pendingRecord.mentionList, pendingRecord.tellaskContent, 'failed', dialog.id, {
                 response,
                 agentId: dialog.agentId,
                 callId: pendingRecord.callId,
                 originMemberId: requesterId,
+                originCourse: carryoverOriginCourse,
+                carryoverContent,
                 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,
-            };
+            const immediateMirror = carryoverContent !== undefined
+                ? {
+                    type: 'tellask_carryover_result_msg',
+                    role: 'user',
+                    content: carryoverContent,
+                    originCourse: carryoverOriginCourse,
+                    responderId: dialog.agentId,
+                    callName: pendingRecord.callName,
+                    tellaskContent: pendingRecord.tellaskContent,
+                    status: 'failed',
+                    callId: pendingRecord.callId,
+                }
+                : {
+                    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;
         }

package/dist/dialog-fork.js

@@ -100,12 +100,14 @@ function isPersistedMessageRecord(record) {
         case 'human_text_record':
         case 'func_call_record':
         case 'func_result_record':
-        case 'teammate_call_result_record':
-        case 'teammate_response_record':
+        case 'tellask_call_result_record':
+        case 'tellask_response_record':
+        case 'tellask_carryover_result_record':
             return true;
         case 'web_search_call_record':
         case 'quest_for_sup_record':
-        case 'teammate_call_anchor_record':
+        case 'tellask_call_carryover_record':
+        case 'tellask_call_anchor_record':
         case 'gen_start_record':
         case 'gen_finish_record':
         case 'subdialog_created_record':
@@ -172,9 +174,11 @@ function rewriteRecordForFork(record, newRootId) {
         case 'web_search_call_record':
         case 'human_text_record':
         case 'quest_for_sup_record':
-        case 'teammate_call_result_record':
-        case 'teammate_call_anchor_record':
-        case 'teammate_response_record':
+        case 'tellask_call_result_record':
+        case 'tellask_call_carryover_record':
+        case 'tellask_call_anchor_record':
+        case 'tellask_response_record':
+        case 'tellask_carryover_result_record':
         case 'gen_start_record':
         case 'gen_finish_record':
             return record;

package/dist/dialog.js

@@ -143,7 +143,7 @@ class Dialog {
         this.disableDiligencePush = false;
         // Current callId for tellask call correlation
         // - Set during teammate_call_finish_evt (from tellask-special function calls)
-        // - Retrieved during inline call-result emission (for receiveTeammateCallResult callId parameter)
+        // - Retrieved during inline call-result emission (for receiveTellaskCallResult callId parameter)
         // - Enables frontend to attach result INLINE to the calling section
         // - NOT used for teammate tellasks (which use calleeDialogId instead)
         this._currentCallId = null;
@@ -792,14 +792,14 @@ class Dialog {
     /**
      * Receive call result with callId for inline correlation
      */
-    async receiveTeammateCallResult(responderId, callName, mentionList, tellaskContent, result, status, callId) {
-        return await this.dlgStore.receiveTeammateCallResult(this, responderId, callName, mentionList, tellaskContent, result, status, callId);
+    async receiveTellaskCallResult(responderId, callName, mentionList, tellaskContent, result, status, callId) {
+        return await this.dlgStore.receiveTellaskCallResult(this, responderId, callName, mentionList, tellaskContent, result, status, callId);
     }
     /**
      * Receive teammate response (separate bubble for @teammate tellasks)
      */
-    async receiveTeammateResponse(responderId, callName, mentionList, tellaskContent, status, subdialogId, options) {
-        return await this.dlgStore.receiveTeammateResponse(this, responderId, callName, mentionList, tellaskContent, status, subdialogId, options);
+    async receiveTellaskResponse(responderId, callName, mentionList, tellaskContent, status, subdialogId, options) {
+        return await this.dlgStore.receiveTellaskResponse(this, responderId, callName, mentionList, tellaskContent, status, subdialogId, options);
     }
     async updateQuestions4Human(questions) {
         return await this.dlgStore.updateQuestions4Human(this, questions);
@@ -871,7 +871,7 @@ class Dialog {
             // Emit virtual generating_start_evt for subdialog response bubble
             await this.notifyGeneratingStart();
             const rawResponse = response;
-            // Emit TeammateResponseEvent
+            // Emit TellaskResponseEvent
             const evt = (() => {
                 switch (callName) {
                     case 'tellask':
@@ -880,7 +880,7 @@ class Dialog {
                                 `(dialogId=${this.id.selfId}, subdialogId=${subdialogId.selfId}, callId=${callId})`);
                         }
                         return {
-                            type: 'teammate_response_evt',
+                            type: 'tellask_response_evt',
                             responderId,
                             calleeDialogId: subdialogId.selfId,
                             callName,
@@ -896,7 +896,7 @@ class Dialog {
                         };
                     case 'tellaskSessionless':
                         return {
-                            type: 'teammate_response_evt',
+                            type: 'tellask_response_evt',
                             responderId,
                             calleeDialogId: subdialogId.selfId,
                             callName,
@@ -911,7 +911,7 @@ class Dialog {
                         };
                     case 'freshBootsReasoning':
                         return {
-                            type: 'teammate_response_evt',
+                            type: 'tellask_response_evt',
                             responderId,
                             calleeDialogId: subdialogId.selfId,
                             callName,
@@ -930,7 +930,7 @@ class Dialog {
             await this.notifyGeneratingFinish();
         }
         catch (err) {
-            log_1.log.warn('Failed to post teammate_response_evt event', undefined, {
+            log_1.log.warn('Failed to post tellask_response_evt event', undefined, {
                 error: err,
                 message: err instanceof Error ? err.message : String(err),
             });
@@ -1144,11 +1144,11 @@ class DialogStore {
     /**
      * Receive call result with callId for inline correlation
      */
-    async receiveTeammateCallResult(_dialog, _responderId, _callName, _mentionList, _tellaskContent, _result, _status, _callId) { }
+    async receiveTellaskCallResult(_dialog, _responderId, _callName, _mentionList, _tellaskContent, _result, _status, _callId) { }
     /**
      * Receive teammate response (separate bubble for @teammate tellasks)
      */
-    async receiveTeammateResponse(_dialog, _responderId, _callName, _mentionList, _tellaskContent, _status, _subdialogId, _options) { }
+    async receiveTellaskResponse(_dialog, _responderId, _callName, _mentionList, _tellaskContent, _status, _subdialogId, _options) { }
     async updateQuestions4Human(_dialog, _questions) { }
     /**
      * Load Questions for Human state from storage