dominds 1.2.4 → 1.2.6

package/dist/apps/resolution-file.js

@@ -0,0 +1,370 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APPS_RESOLUTION_REL_PATH = exports.DEFAULT_APPS_RESOLUTION_STRATEGY = void 0;
+exports.loadAppsResolutionFile = loadAppsResolutionFile;
+exports.writeAppsResolutionFile = writeAppsResolutionFile;
+exports.writeAppsResolutionFileIfChanged = writeAppsResolutionFileIfChanged;
+exports.findResolvedApp = findResolvedApp;
+exports.upsertResolvedApp = upsertResolvedApp;
+exports.removeResolvedApp = removeResolvedApp;
+exports.setResolvedAppUserEnabled = setResolvedAppUserEnabled;
+exports.setResolvedAppAssignedPort = setResolvedAppAssignedPort;
+exports.applyEffectiveEnabledToResolvedApps = applyEffectiveEnabledToResolvedApps;
+exports.applyAssignedPortToResolvedApps = applyAssignedPortToResolvedApps;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const app_json_1 = require("./app-json");
+exports.DEFAULT_APPS_RESOLUTION_STRATEGY = {
+    order: ['local'],
+    localRoots: ['dominds-apps'],
+};
+exports.APPS_RESOLUTION_REL_PATH = path_1.default.join('.apps', 'resolution.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 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 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 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 userEnabledRaw = v['userEnabled'];
+    const userEnabled = userEnabledRaw === undefined ? enabled : asBool(userEnabledRaw);
+    if (userEnabled === null) {
+        return { ok: false, errorText: `Invalid ${at}.userEnabled: expected boolean` };
+    }
+    const assignedPortRaw = v['assignedPort'] ?? null;
+    const assignedPort = asNullableNumber(assignedPortRaw);
+    if (assignedPort === null) {
+        if (assignedPortRaw !== null) {
+            return { ok: false, errorText: `Invalid ${at}.assignedPort: expected number|null` };
+        }
+    }
+    else {
+        if (!Number.isInteger(assignedPort) || assignedPort <= 0) {
+            return { ok: false, errorText: `Invalid ${at}.assignedPort: expected positive integer|null` };
+        }
+    }
+    const sourceParsed = parseSource(v['source'], `${at}.source`);
+    if (!sourceParsed.ok)
+        return sourceParsed;
+    const installJsonRaw = v['installJson'];
+    const installJsonParsed = (0, app_json_1.parseDomindsAppInstallJson)(installJsonRaw);
+    if (!installJsonParsed.ok) {
+        return { ok: false, errorText: `Invalid ${at}.installJson: ${installJsonParsed.errorText}` };
+    }
+    return {
+        ok: true,
+        entry: {
+            id,
+            enabled,
+            userEnabled,
+            source: sourceParsed.source,
+            assignedPort,
+            installJson: installJsonParsed.json,
+        },
+    };
+}
+async function loadAppsResolutionFile(params) {
+    const filePathAbs = path_1.default.resolve(params.rtwsRootAbs, exports.APPS_RESOLUTION_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 resolution.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 resolution.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);
+    }
+    const strategyRaw = parsed['resolutionStrategy'];
+    const resolutionStrategy = (() => {
+        if (strategyRaw === undefined)
+            return undefined;
+        const parsedStrategy = parseResolutionStrategy(strategyRaw, 'resolutionStrategy');
+        if (!parsedStrategy.ok)
+            return parsedStrategy;
+        return { ok: true, value: parsedStrategy.strategy };
+    })();
+    if (resolutionStrategy && !resolutionStrategy.ok) {
+        return { kind: 'error', filePathAbs, errorText: resolutionStrategy.errorText };
+    }
+    const file = resolutionStrategy
+        ? {
+            schemaVersion: 1,
+            resolutionStrategy: resolutionStrategy.value,
+            apps,
+        }
+        : { schemaVersion: 1, apps };
+    return { kind: 'ok', filePathAbs, file };
+}
+async function writeAppsResolutionFile(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.APPS_RESOLUTION_REL_PATH);
+    const yamlText = yaml_1.default.stringify(params.file);
+    await promises_1.default.writeFile(filePathAbs, yamlText, 'utf-8');
+}
+async function writeAppsResolutionFileIfChanged(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.APPS_RESOLUTION_REL_PATH);
+    const yamlText = yaml_1.default.stringify(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 findResolvedApp(file, appId) {
+    const found = file.apps.find((a) => a.id === appId);
+    return found ?? null;
+}
+function upsertResolvedApp(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);
+    const resolutionStrategy = params.existing.resolutionStrategy;
+    return resolutionStrategy !== undefined
+        ? { schemaVersion: 1, resolutionStrategy, apps }
+        : { schemaVersion: 1, apps };
+}
+function removeResolvedApp(params) {
+    if (!params.existing.apps.some((a) => a.id === params.appId))
+        return params.existing;
+    const apps = params.existing.apps.filter((a) => a.id !== params.appId);
+    const resolutionStrategy = params.existing.resolutionStrategy;
+    return resolutionStrategy !== undefined
+        ? { schemaVersion: 1, resolutionStrategy, apps }
+        : { schemaVersion: 1, apps };
+}
+function setResolvedAppUserEnabled(params) {
+    const existingApp = findResolvedApp(params.existing, params.appId);
+    if (!existingApp)
+        return params.existing;
+    if (existingApp.userEnabled === params.userEnabled && existingApp.enabled === params.userEnabled)
+        return params.existing;
+    const apps = params.existing.apps.map((a) => a.id === params.appId
+        ? { ...a, userEnabled: params.userEnabled, enabled: params.userEnabled }
+        : a);
+    const resolutionStrategy = params.existing.resolutionStrategy;
+    return resolutionStrategy !== undefined
+        ? { schemaVersion: 1, resolutionStrategy, apps }
+        : { schemaVersion: 1, apps };
+}
+function setResolvedAppAssignedPort(params) {
+    if (params.assignedPort !== null) {
+        if (!Number.isInteger(params.assignedPort) || params.assignedPort <= 0) {
+            throw new Error(`Invalid assignedPort: expected positive integer|null (got ${params.assignedPort})`);
+        }
+    }
+    const existingApp = findResolvedApp(params.existing, params.appId);
+    if (!existingApp)
+        return params.existing;
+    if (existingApp.assignedPort === params.assignedPort)
+        return params.existing;
+    const apps = params.existing.apps.map((a) => a.id === params.appId ? { ...a, assignedPort: params.assignedPort } : a);
+    const resolutionStrategy = params.existing.resolutionStrategy;
+    return resolutionStrategy !== undefined
+        ? { schemaVersion: 1, resolutionStrategy, apps }
+        : { schemaVersion: 1, apps };
+}
+function applyEffectiveEnabledToResolvedApps(params) {
+    let changed = false;
+    const apps = params.existing.apps.map((a) => {
+        const effectiveEnabled = params.effectiveEnabledById.get(a.id);
+        if (effectiveEnabled === undefined || effectiveEnabled === a.enabled)
+            return a;
+        changed = true;
+        return { ...a, enabled: effectiveEnabled };
+    });
+    if (!changed)
+        return params.existing;
+    const resolutionStrategy = params.existing.resolutionStrategy;
+    return resolutionStrategy !== undefined
+        ? { schemaVersion: 1, resolutionStrategy, apps }
+        : { schemaVersion: 1, apps };
+}
+function applyAssignedPortToResolvedApps(params) {
+    let changed = false;
+    const apps = params.existing.apps.map((a) => {
+        const assignedPort = params.assignedPortById.get(a.id);
+        if (assignedPort === undefined || assignedPort === a.assignedPort)
+            return a;
+        if (assignedPort !== null) {
+            if (!Number.isInteger(assignedPort) || assignedPort <= 0) {
+                throw new Error(`Invalid assignedPort writeback for '${a.id}': ${String(assignedPort)}`);
+            }
+        }
+        changed = true;
+        return { ...a, assignedPort };
+    });
+    if (!changed)
+        return params.existing;
+    const resolutionStrategy = params.existing.resolutionStrategy;
+    return resolutionStrategy !== undefined
+        ? { schemaVersion: 1, resolutionStrategy, apps }
+        : { schemaVersion: 1, apps };
+}

package/dist/apps/runtime.js

@@ -9,7 +9,7 @@ const registry_1 = require("../tools/registry");
 const client_1 = require("../apps-host/client");
 const dialog_run_controls_1 = require("./dialog-run-controls");
 const enabled_apps_1 = require("./enabled-apps");
-const installed_file_1 = require("./installed-file");
+const problems_1 = require("./problems");
 const log = (0, log_1.createLogger)('apps-runtime');
 let appsHostClient = null;
 const proxyRegisteredAppIds = new Set();
@@ -91,6 +91,7 @@ function registerAppDialogRunControlsForEnabledApps(params) {
 }
 async function registerEnabledAppsToolProxies(params) {
     const snapshot = await (0, enabled_apps_1.loadEnabledAppsSnapshot)({ rtwsRootAbs: params.rtwsRootAbs });
+    (0, problems_1.reconcileAppsResolutionIssuesToProblems)({ issues: snapshot.issues });
     const enabledApps = snapshot.enabledApps.map((a) => ({
         appId: a.id,
         runtimePort: a.runtimePort,
@@ -105,6 +106,7 @@ async function initAppsRuntime(params) {
         throw new Error('Apps runtime already initialized');
     }
     const snapshot = await (0, enabled_apps_1.loadEnabledAppsSnapshot)({ rtwsRootAbs: params.rtwsRootAbs });
+    (0, problems_1.reconcileAppsResolutionIssuesToProblems)({ issues: snapshot.issues });
     const enabledApps = snapshot.enabledApps.map((a) => ({
         appId: a.id,
         runtimePort: a.runtimePort,
@@ -119,24 +121,10 @@ async function initAppsRuntime(params) {
     // Register dialog run controls before websocket handlers start processing user drives.
     registerAppDialogRunControlsForEnabledApps({ enabledApps });
     log.info(`Starting apps-host (${enabledApps.length} enabled apps)`);
-    const started = await (0, client_1.startAppsHost)({
+    const { client } = await (0, client_1.startAppsHost)({
         rtwsRootAbs: params.rtwsRootAbs,
         kernel: params.kernel,
         apps: enabledApps,
     });
-    appsHostClient = started.client;
-    // Persist actual bound ports for enabled apps (especially when runtimePort=0 for ephemeral ports).
-    const loaded = await (0, installed_file_1.loadInstalledAppsFile)({ rtwsRootAbs: params.rtwsRootAbs });
-    if (loaded.kind === 'error') {
-        throw new Error(`Failed to update installed apps runtime ports: ${loaded.errorText} (${loaded.filePathAbs})`);
-    }
-    let nextFile = loaded.file;
-    for (const a of started.ready.apps) {
-        if (!a.frontend)
-            continue;
-        nextFile = (0, installed_file_1.setAppRuntimePort)({ existing: nextFile, appId: a.appId, port: a.frontend.port });
-    }
-    if (nextFile !== loaded.file) {
-        await (0, installed_file_1.writeInstalledAppsFile)({ rtwsRootAbs: params.rtwsRootAbs, file: nextFile });
-    }
+    appsHostClient = client;
 }

package/dist/cli/disable.js

@@ -8,7 +8,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
-const installed_file_1 = require("../apps/installed-file");
+const resolution_file_1 = require("../apps/resolution-file");
 function printHelp() {
     console.log(`Usage:
   dominds disable <appId>
@@ -41,20 +41,24 @@ async function main() {
         return;
     }
     const rtwsRootAbs = process.cwd();
-    const loaded = await (0, installed_file_1.loadInstalledAppsFile)({ rtwsRootAbs });
+    const loaded = await (0, resolution_file_1.loadAppsResolutionFile)({ rtwsRootAbs });
     if (loaded.kind === 'error') {
-        console.error(`Error: failed to read ${installed_file_1.INSTALLED_APPS_REL_PATH}: ${loaded.errorText}`);
+        console.error(`Error: failed to read ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: ${loaded.errorText}`);
         process.exit(1);
         return;
     }
-    const found = (0, installed_file_1.findInstalledApp)(loaded.file, args.appId);
+    const found = (0, resolution_file_1.findResolvedApp)(loaded.file, args.appId);
     if (!found) {
         console.error(`Error: app '${args.appId}' not installed`);
         process.exit(1);
         return;
     }
-    const next = (0, installed_file_1.setAppEnabled)({ existing: loaded.file, appId: args.appId, enabled: false });
-    await (0, installed_file_1.writeInstalledAppsFile)({ rtwsRootAbs, file: next });
+    const next = (0, resolution_file_1.setResolvedAppUserEnabled)({
+        existing: loaded.file,
+        appId: args.appId,
+        userEnabled: false,
+    });
+    await (0, resolution_file_1.writeAppsResolutionFile)({ rtwsRootAbs, file: next });
     console.log(`Disabled app '${args.appId}'`);
 }
 if (require.main === module) {

package/dist/cli/enable.js

@@ -8,14 +8,14 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
-const installed_file_1 = require("../apps/installed-file");
-const runtime_port_1 = require("../apps/runtime-port");
+const assigned_port_1 = require("../apps/assigned-port");
+const resolution_file_1 = require("../apps/resolution-file");
 function printHelp() {
     console.log(`Usage:
   dominds enable <appId> [--port <port>]
 
 Options:
-  --port <port>        Set frontend port (stored in ${installed_file_1.INSTALLED_APPS_REL_PATH})
+  --port <port>        Set frontend port (stored in ${resolution_file_1.APPS_RESOLUTION_REL_PATH}); use 0 to clear
 `);
 }
 function parseArgs(argv) {
@@ -59,38 +59,40 @@ async function main() {
         return;
     }
     const rtwsRootAbs = process.cwd();
-    const loaded = await (0, installed_file_1.loadInstalledAppsFile)({ rtwsRootAbs });
+    const loaded = await (0, resolution_file_1.loadAppsResolutionFile)({ rtwsRootAbs });
     if (loaded.kind === 'error') {
-        console.error(`Error: failed to read ${installed_file_1.INSTALLED_APPS_REL_PATH}: ${loaded.errorText}`);
+        console.error(`Error: failed to read ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: ${loaded.errorText}`);
         process.exit(1);
         return;
     }
-    const found = (0, installed_file_1.findInstalledApp)(loaded.file, args.appId);
+    const found = (0, resolution_file_1.findResolvedApp)(loaded.file, args.appId);
     if (!found) {
         console.error(`Error: app '${args.appId}' not installed`);
         process.exit(1);
         return;
     }
-    let next = (0, installed_file_1.setAppEnabled)({ existing: loaded.file, appId: args.appId, enabled: true });
+    let next = (0, resolution_file_1.setResolvedAppUserEnabled)({
+        existing: loaded.file,
+        appId: args.appId,
+        userEnabled: true,
+    });
     if (args.port !== null) {
-        next = (0, installed_file_1.setAppRuntimePort)({ existing: next, appId: args.appId, port: args.port });
+        next = (0, resolution_file_1.setResolvedAppAssignedPort)({
+            existing: next,
+            appId: args.appId,
+            assignedPort: args.port === 0 ? null : args.port,
+        });
     }
     else {
-        const resolvedPort = await (0, runtime_port_1.resolveStableAppRuntimePort)({
+        const assignedPort = await (0, assigned_port_1.resolveStableAssignedPort)({
             appId: found.id,
             installJson: found.installJson,
-            existingApps: loaded.file.apps,
-            existingRuntimePort: found.runtime.port,
+            existingApps: next.apps,
+            existingAssignedPort: found.assignedPort,
         });
-        if (resolvedPort !== found.runtime.port) {
-            next = (0, installed_file_1.setAppRuntimePort)({
-                existing: next,
-                appId: args.appId,
-                port: resolvedPort,
-            });
-        }
+        next = (0, resolution_file_1.setResolvedAppAssignedPort)({ existing: next, appId: args.appId, assignedPort });
     }
-    await (0, installed_file_1.writeInstalledAppsFile)({ rtwsRootAbs, file: next });
+    await (0, resolution_file_1.writeAppsResolutionFile)({ rtwsRootAbs, file: next });
     console.log(`Enabled app '${args.appId}'`);
 }
 if (require.main === module) {

package/dist/cli/install.js

@@ -13,10 +13,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
-const installed_file_1 = require("../apps/installed-file");
+const app_lock_file_1 = require("../apps/app-lock-file");
+const assigned_port_1 = require("../apps/assigned-port");
+const resolution_file_1 = require("../apps/resolution-file");
 const run_app_json_1 = require("../apps/run-app-json");
-const runtime_port_1 = require("../apps/runtime-port");
-const time_1 = require("../shared/utils/time");
 function printHelp() {
     console.log(`Usage:
   dominds install <spec|path> [--local] [--id <appId>] [--enable] [--force]
@@ -28,7 +28,7 @@ Options:
   --force              Replace existing installed entry with the same id
 
 Notes:
-  - State is stored in ${installed_file_1.INSTALLED_APPS_REL_PATH} under the current rtws (process.cwd()).
+  - State is stored in ${resolution_file_1.APPS_RESOLUTION_REL_PATH} under the current rtws (process.cwd()).
   - dominds installs apps by running '<app> --json' via npx or local package bin.
 `);
 }
@@ -103,9 +103,9 @@ async function main() {
     }
     const localAbs = path_1.default.resolve(rtwsRootAbs, specOrPath);
     const shouldUseLocal = args.local || (await pathIsDirectory(localAbs));
-    const loadedInstalled = await (0, installed_file_1.loadInstalledAppsFile)({ rtwsRootAbs });
-    if (loadedInstalled.kind === 'error') {
-        console.error(`Error: failed to read ${installed_file_1.INSTALLED_APPS_REL_PATH}: ${loadedInstalled.errorText}`);
+    const loadedResolution = await (0, resolution_file_1.loadAppsResolutionFile)({ rtwsRootAbs });
+    if (loadedResolution.kind === 'error') {
+        console.error(`Error: failed to read ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: ${loadedResolution.errorText}`);
         process.exit(1);
         return;
     }
@@ -117,33 +117,55 @@ async function main() {
         process.exit(1);
         return;
     }
-    const prev = loadedInstalled.file.apps.find((a) => a.id === installJson.appId) ?? null;
+    const prev = loadedResolution.file.apps.find((a) => a.id === installJson.appId) ?? null;
     if (prev && !args.force) {
         console.error(`Error: app '${installJson.appId}' already installed. Use 'dominds update ${installJson.appId}' or 'dominds install ... --force'.`);
         process.exit(1);
         return;
     }
-    const now = (0, time_1.formatUnifiedTimestamp)(new Date());
-    const enabled = args.enable || (prev ? prev.enabled : false);
-    const runtimePort = await (0, runtime_port_1.resolveStableAppRuntimePort)({
+    const userEnabled = args.enable || (prev ? prev.userEnabled : false);
+    const enabled = userEnabled;
+    const assignedPort = await (0, assigned_port_1.resolveStableAssignedPort)({
         appId: installJson.appId,
         installJson,
-        existingApps: loadedInstalled.file.apps,
-        existingRuntimePort: prev?.runtime.port ?? null,
+        existingApps: loadedResolution.file.apps,
+        existingAssignedPort: prev?.assignedPort ?? null,
     });
     const entry = {
         id: installJson.appId,
         enabled,
+        userEnabled,
         source: shouldUseLocal
             ? { kind: 'local', pathAbs: localAbs }
             : { kind: 'npx', spec: specOrPath },
-        runtime: { port: runtimePort },
+        assignedPort,
         installJson,
-        installedAt: prev ? prev.installedAt : now,
-        updatedAt: now,
     };
-    const nextFile = (0, installed_file_1.upsertInstalledApp)({ existing: loadedInstalled.file, next: entry });
-    await (0, installed_file_1.writeInstalledAppsFile)({ rtwsRootAbs, file: nextFile });
+    const nextFile = (0, resolution_file_1.upsertResolvedApp)({ existing: loadedResolution.file, next: entry });
+    await (0, resolution_file_1.writeAppsResolutionFile)({ rtwsRootAbs, file: nextFile });
+    try {
+        const loadedLock = await (0, app_lock_file_1.loadAppLockFile)({ rtwsRootAbs });
+        if (loadedLock.kind === 'error') {
+            console.error(`Warning: failed to read .minds/app-lock.yaml: ${loadedLock.errorText}`);
+        }
+        else {
+            const nextLock = (0, app_lock_file_1.upsertLockedApp)({
+                existing: loadedLock.file,
+                next: {
+                    id: entry.id,
+                    source: entry.source,
+                    package: {
+                        name: entry.installJson.package.name,
+                        version: entry.installJson.package.version,
+                    },
+                },
+            });
+            await (0, app_lock_file_1.writeAppLockFileIfChanged)({ rtwsRootAbs, file: nextLock });
+        }
+    }
+    catch (err) {
+        console.error(`Warning: failed to update .minds/app-lock.yaml: ${err instanceof Error ? err.message : String(err)}`);
+    }
     console.log(shouldUseLocal
         ? `Installed app '${entry.id}' from local package: ${localAbs}`
         : `Installed app '${entry.id}' via npx spec: ${specOrPath}`);

package/dist/cli/uninstall.js

@@ -13,7 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
-const installed_file_1 = require("../apps/installed-file");
+const resolution_file_1 = require("../apps/resolution-file");
 function printHelp() {
     console.log(`Usage:
   dominds uninstall <appId> [--purge]
@@ -54,20 +54,20 @@ async function main() {
         return;
     }
     const rtwsRootAbs = process.cwd();
-    const loaded = await (0, installed_file_1.loadInstalledAppsFile)({ rtwsRootAbs });
+    const loaded = await (0, resolution_file_1.loadAppsResolutionFile)({ rtwsRootAbs });
     if (loaded.kind === 'error') {
-        console.error(`Error: failed to read ${installed_file_1.INSTALLED_APPS_REL_PATH}: ${loaded.errorText}`);
+        console.error(`Error: failed to read ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: ${loaded.errorText}`);
         process.exit(1);
         return;
     }
-    const found = (0, installed_file_1.findInstalledApp)(loaded.file, args.appId);
+    const found = (0, resolution_file_1.findResolvedApp)(loaded.file, args.appId);
     if (!found) {
         console.error(`Error: app '${args.appId}' not installed`);
         process.exit(1);
         return;
     }
-    const next = (0, installed_file_1.removeInstalledApp)({ existing: loaded.file, appId: args.appId });
-    await (0, installed_file_1.writeInstalledAppsFile)({ rtwsRootAbs, file: next });
+    const next = (0, resolution_file_1.removeResolvedApp)({ existing: loaded.file, appId: args.appId });
+    await (0, resolution_file_1.writeAppsResolutionFile)({ rtwsRootAbs, file: next });
     if (args.purge) {
         const rtwsAppDirAbs = path_1.default.resolve(rtwsRootAbs, '.apps', args.appId);
         await promises_1.default.rm(rtwsAppDirAbs, { recursive: true, force: true });