dominds 1.2.5 → 1.2.7

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

@@ -0,0 +1,228 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APP_LOCK_REL_PATH = void 0;
+exports.parseAppLockFile = parseAppLockFile;
+exports.loadAppLockFile = loadAppLockFile;
+exports.upsertLockedApp = upsertLockedApp;
+exports.writeAppLockFileIfChanged = writeAppLockFileIfChanged;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const yaml_1 = __importDefault(require("yaml"));
+exports.APP_LOCK_REL_PATH = node_path_1.default.join('.minds', 'app-lock.yaml');
+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 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') {
+            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` };
+    }
+    const pkgKeys = Object.keys(pkg);
+    for (const k of pkgKeys) {
+        if (k !== 'name' && k !== 'version') {
+            return { ok: false, errorText: `Invalid ${at}.package: unknown key '${k}'` };
+        }
+    }
+    const name = asString(pkg['name']);
+    if (!name || name.trim() === '') {
+        return { ok: false, errorText: `Invalid ${at}.package.name: required` };
+    }
+    const versionRaw = pkg['version'] ?? null;
+    const version = asNullableString(versionRaw);
+    if (version === null) {
+        if (versionRaw !== null) {
+            return { ok: false, errorText: `Invalid ${at}.package.version: expected string|null` };
+        }
+    }
+    else if (version.trim() === '') {
+        return { ok: false, errorText: `Invalid ${at}.package.version: must not be empty` };
+    }
+    return {
+        ok: true,
+        entry: {
+            id,
+            source: sourceParsed.source,
+            package: { name, 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}'`);
+        }
+        byId.set(e.id, e);
+    }
+    const apps = [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+    return { schemaVersion: 1, apps };
+}
+function parseAppLockFile(parsed, filePathAbs) {
+    if (!isRecord(parsed)) {
+        return { ok: false, errorText: `Invalid app-lock.yaml: expected object (${filePathAbs})` };
+    }
+    const keys = Object.keys(parsed);
+    for (const k of keys) {
+        if (k !== 'schemaVersion' && k !== 'apps') {
+            return { ok: false, errorText: `Invalid app-lock.yaml: unknown key '${k}' (${filePathAbs})` };
+        }
+    }
+    const schemaVersion = parsed['schemaVersion'];
+    if (schemaVersion !== 1) {
+        return {
+            ok: false,
+            errorText: `Unsupported app-lock.yaml schemaVersion: ${String(schemaVersion)} (${filePathAbs})`,
+        };
+    }
+    const appsRaw = parsed['apps'];
+    if (!Array.isArray(appsRaw)) {
+        return {
+            ok: false,
+            errorText: `Invalid app-lock.yaml: apps must be an array (${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);
+    }
+    try {
+        return { ok: true, file: canonicalizeLockFile({ schemaVersion: 1, apps }) };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            errorText: `${err instanceof Error ? err.message : String(err)} (${filePathAbs})`,
+        };
+    }
+}
+async function loadAppLockFile(params) {
+    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, exports.APP_LOCK_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, 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)}`,
+        };
+    }
+    const lockParsed = parseAppLockFile(parsed, filePathAbs);
+    if (!lockParsed.ok)
+        return { kind: 'error', filePathAbs, errorText: lockParsed.errorText };
+    return { kind: 'ok', filePathAbs, exists: true, file: lockParsed.file };
+}
+function upsertLockedApp(params) {
+    const existingEntry = params.existing.apps.find((a) => a.id === params.next.id) ?? null;
+    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);
+    if (idx >= 0)
+        apps[idx] = params.next;
+    else
+        apps.push(params.next);
+    return canonicalizeLockFile({ schemaVersion: 1, apps });
+}
+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))
+            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 });
+    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, exports.APP_LOCK_REL_PATH);
+    const yamlText = yaml_1.default.stringify(canonical);
+    await promises_1.default.writeFile(filePathAbs, yamlText, 'utf-8');
+}

package/dist/apps/assigned-port.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStableAssignedPort = resolveStableAssignedPort;
+exports.resolveStableAssignedPortWithReason = resolveStableAssignedPortWithReason;
+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.assignedPort)) {
+            reserved.add(app.assignedPort);
+        }
+    }
+    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 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 assignedPort for app '${params.appId}': no bindable port in ${STABLE_PORT_RANGE_START}-${STABLE_PORT_RANGE_END}`);
+}
+/**
+ * Resolve a stable non-zero assignedPort for an app frontend.
+ *
+ * - If the app has no frontend, returns null.
+ * - If an existing assignedPort exists, keeps it when still valid/bindable.
+ * - If existing assignedPort collides or is not bindable, reassigns deterministically.
+ * - Otherwise, tries installJson.frontend.defaultPort when it is bindable.
+ * - Falls back to a deterministic stable-range allocator.
+ */
+async function resolveStableAssignedPort(params) {
+    const resolved = await resolveStableAssignedPortWithReason(params);
+    return resolved.assignedPort;
+}
+async function resolveStableAssignedPortWithReason(params) {
+    if (!params.installJson.frontend) {
+        return { assignedPort: null, reason: 'no_frontend' };
+    }
+    const reservedPorts = collectReservedPorts(params.existingApps, params.appId);
+    if (isPositivePort(params.existingAssignedPort)) {
+        if (reservedPorts.has(params.existingAssignedPort)) {
+            return {
+                assignedPort: await pickDeterministicAvailablePort({
+                    appId: params.appId,
+                    reservedPorts,
+                }),
+                reason: 'reassigned_from_existing_conflict',
+            };
+        }
+        if (!(await canBindPort(params.existingAssignedPort))) {
+            return {
+                assignedPort: await pickDeterministicAvailablePort({
+                    appId: params.appId,
+                    reservedPorts,
+                }),
+                reason: 'reassigned_from_existing_unbindable',
+            };
+        }
+        return { assignedPort: params.existingAssignedPort, reason: 'kept_existing' };
+    }
+    const defaultPort = params.installJson.frontend.defaultPort;
+    if (isPositivePort(defaultPort) &&
+        !reservedPorts.has(defaultPort) &&
+        (await canBindPort(defaultPort))) {
+        return { assignedPort: defaultPort, reason: 'selected_default' };
+    }
+    return {
+        assignedPort: await pickDeterministicAvailablePort({
+            appId: params.appId,
+            reservedPorts,
+        }),
+        reason: 'allocated_stable_range',
+    };
+}