dominds 1.8.11 → 1.9.0

package/dist/apps/app-json.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDomindsAppInstallJson = parseDomindsAppInstallJson;
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function asString(v) {
+    return typeof v === 'string' ? v : null;
+}
+function asNullableString(v) {
+    if (v === null)
+        return null;
+    return typeof v === 'string' ? v : null;
+}
+function isI18nText(v) {
+    return isRecord(v) && typeof v['zh'] === 'string' && typeof v['en'] === 'string';
+}
+function isJsonSchema(v) {
+    // Dominds JsonSchema is intentionally permissive: it's a passthrough dictionary.
+    return isRecord(v);
+}
+function parseToolJson(v, at) {
+    if (!isRecord(v))
+        return { ok: false, errorText: `Invalid ${at}: expected object` };
+    const name = asString(v['name']);
+    if (!name || name.trim() === '')
+        return { ok: false, errorText: `Invalid ${at}.name: required` };
+    const description = asString(v['description']) ?? undefined;
+    const descriptionI18n = v['descriptionI18n'];
+    if (descriptionI18n !== undefined && !isI18nText(descriptionI18n)) {
+        return { ok: false, errorText: `Invalid ${at}.descriptionI18n: expected {zh,en} string` };
+    }
+    const parameters = v['parameters'];
+    if (!isJsonSchema(parameters))
+        return { ok: false, errorText: `Invalid ${at}.parameters: expected JSON schema object` };
+    return {
+        ok: true,
+        tool: {
+            name,
+            description,
+            descriptionI18n: descriptionI18n,
+            parameters,
+        },
+    };
+}
+function parseToolsetJson(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 descriptionI18n = v['descriptionI18n'];
+    if (descriptionI18n !== undefined && !isI18nText(descriptionI18n)) {
+        return { ok: false, errorText: `Invalid ${at}.descriptionI18n: expected {zh,en} string` };
+    }
+    const toolsRaw = v['tools'];
+    if (!Array.isArray(toolsRaw))
+        return { ok: false, errorText: `Invalid ${at}.tools: expected array` };
+    const tools = [];
+    for (let i = 0; i < toolsRaw.length; i += 1) {
+        const parsed = parseToolJson(toolsRaw[i], `${at}.tools[${i}]`);
+        if (!parsed.ok)
+            return parsed;
+        tools.push(parsed.tool);
+    }
+    return {
+        ok: true,
+        toolset: {
+            id,
+            descriptionI18n: descriptionI18n,
+            tools,
+        },
+    };
+}
+function parseDialogRunControlJson(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 descriptionI18n = v['descriptionI18n'];
+    if (descriptionI18n !== undefined && !isI18nText(descriptionI18n)) {
+        return { ok: false, errorText: `Invalid ${at}.descriptionI18n: expected {zh,en} string` };
+    }
+    return {
+        ok: true,
+        control: {
+            id,
+            descriptionI18n: descriptionI18n,
+        },
+    };
+}
+function parseReminderOwnerJson(v, at) {
+    if (!isRecord(v))
+        return { ok: false, errorText: `Invalid ${at}: expected object` };
+    const ref = asString(v['ref']);
+    if (!ref || ref.trim() === '')
+        return { ok: false, errorText: `Invalid ${at}.ref: required` };
+    const managedByTool = asString(v['managedByTool']) ?? undefined;
+    const updateExample = asString(v['updateExample']) ?? undefined;
+    return {
+        ok: true,
+        owner: {
+            ref,
+            managedByTool,
+            updateExample,
+        },
+    };
+}
+function parseDomindsAppInstallJson(v) {
+    if (!isRecord(v)) {
+        return { ok: false, errorText: 'Invalid app --dominds-app output: expected object' };
+    }
+    const schemaVersion = v['schemaVersion'];
+    if (schemaVersion !== 1) {
+        return { ok: false, errorText: `Unsupported app json schemaVersion: ${String(schemaVersion)}` };
+    }
+    const appId = asString(v['appId']);
+    if (!appId || appId.trim() === '')
+        return { ok: false, errorText: 'Invalid app json: appId required' };
+    const displayName = asString(v['displayName']) ?? undefined;
+    const pkg = v['package'];
+    if (!isRecord(pkg))
+        return { ok: false, errorText: 'Invalid app json: package must be an object' };
+    const packageName = asString(pkg['name']);
+    const packageVersion = asNullableString(pkg['version']);
+    const rootAbs = asString(pkg['rootAbs']);
+    if (!packageName || packageName.trim() === '')
+        return { ok: false, errorText: 'Invalid app json: package.name required' };
+    if (packageVersion === null) {
+        // ok
+    }
+    else if (!packageVersion || packageVersion.trim() === '') {
+        return { ok: false, errorText: 'Invalid app json: package.version must be string|null' };
+    }
+    if (!rootAbs || rootAbs.trim() === '')
+        return { ok: false, errorText: 'Invalid app json: package.rootAbs required' };
+    const host = v['host'];
+    if (!isRecord(host))
+        return { ok: false, errorText: 'Invalid app json: host must be an object' };
+    const hostKind = asString(host['kind']);
+    if (hostKind !== 'node_module')
+        return { ok: false, errorText: "Invalid app json: host.kind must be 'node_module'" };
+    const moduleRelPath = asString(host['moduleRelPath']);
+    const exportName = asString(host['exportName']);
+    if (!moduleRelPath || moduleRelPath.trim() === '')
+        return { ok: false, errorText: 'Invalid app json: host.moduleRelPath required' };
+    if (!exportName || exportName.trim() === '')
+        return { ok: false, errorText: 'Invalid app json: host.exportName required' };
+    const frontendRaw = v['frontend'];
+    let frontend;
+    if (frontendRaw !== undefined) {
+        if (!isRecord(frontendRaw))
+            return { ok: false, errorText: 'Invalid app json: frontend must be an object' };
+        const kind = asString(frontendRaw['kind']);
+        if (kind !== 'http')
+            return { ok: false, errorText: "Invalid app json: frontend.kind must be 'http'" };
+        const defaultPortRaw = frontendRaw['defaultPort'];
+        const defaultPort = defaultPortRaw === undefined
+            ? undefined
+            : typeof defaultPortRaw === 'number' && Number.isFinite(defaultPortRaw)
+                ? Math.floor(defaultPortRaw)
+                : null;
+        if (defaultPort === null || (defaultPort !== undefined && defaultPort < 0)) {
+            return {
+                ok: false,
+                errorText: 'Invalid app json: frontend.defaultPort must be a non-negative number',
+            };
+        }
+        const basePath = asString(frontendRaw['basePath']) ?? undefined;
+        const wsPath = asString(frontendRaw['wsPath']) ?? undefined;
+        frontend = { kind: 'http', defaultPort, basePath, wsPath };
+    }
+    const contributesRaw = v['contributes'];
+    let contributes;
+    if (contributesRaw !== undefined) {
+        if (!isRecord(contributesRaw))
+            return { ok: false, errorText: 'Invalid app json: contributes must be an object' };
+        const teammatesYamlRelPath = asString(contributesRaw['teammatesYamlRelPath']) ?? undefined;
+        const toolsetsRaw = contributesRaw['toolsets'];
+        let toolsets;
+        if (toolsetsRaw !== undefined) {
+            if (!Array.isArray(toolsetsRaw))
+                return { ok: false, errorText: 'Invalid app json: contributes.toolsets must be an array' };
+            toolsets = [];
+            for (let i = 0; i < toolsetsRaw.length; i += 1) {
+                const parsed = parseToolsetJson(toolsetsRaw[i], `contributes.toolsets[${i}]`);
+                if (!parsed.ok)
+                    return parsed;
+                toolsets.push(parsed.toolset);
+            }
+        }
+        const dialogRunControlsRaw = contributesRaw['dialogRunControls'];
+        let dialogRunControls;
+        if (dialogRunControlsRaw !== undefined) {
+            if (!Array.isArray(dialogRunControlsRaw)) {
+                return {
+                    ok: false,
+                    errorText: 'Invalid app json: contributes.dialogRunControls must be an array',
+                };
+            }
+            dialogRunControls = [];
+            for (let i = 0; i < dialogRunControlsRaw.length; i += 1) {
+                const parsed = parseDialogRunControlJson(dialogRunControlsRaw[i], `contributes.dialogRunControls[${i}]`);
+                if (!parsed.ok)
+                    return parsed;
+                dialogRunControls.push(parsed.control);
+            }
+        }
+        const reminderOwnersRaw = contributesRaw['reminderOwners'];
+        let reminderOwners;
+        if (reminderOwnersRaw !== undefined) {
+            if (!Array.isArray(reminderOwnersRaw)) {
+                return {
+                    ok: false,
+                    errorText: 'Invalid app json: contributes.reminderOwners must be an array',
+                };
+            }
+            reminderOwners = [];
+            for (let i = 0; i < reminderOwnersRaw.length; i += 1) {
+                const parsed = parseReminderOwnerJson(reminderOwnersRaw[i], `contributes.reminderOwners[${i}]`);
+                if (!parsed.ok)
+                    return parsed;
+                reminderOwners.push(parsed.owner);
+            }
+        }
+        contributes = { teammatesYamlRelPath, toolsets, dialogRunControls, reminderOwners };
+    }
+    return {
+        ok: true,
+        json: {
+            schemaVersion: 1,
+            appId,
+            displayName,
+            package: { name: packageName, version: packageVersion, rootAbs },
+            host: { kind: 'node_module', moduleRelPath, exportName },
+            frontend,
+            contributes,
+        },
+    };
+}

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/apps-host/app-host-contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });