dominds 1.2.5 → 1.2.7

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/apps/teammates.js

@@ -8,22 +8,123 @@ const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
 const enabled_apps_1 = require("./enabled-apps");
+const manifest_1 = require("./manifest");
 const override_paths_1 = require("./override-paths");
+const package_info_1 = require("./package-info");
 function isRecord(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
+async function loadEnabledAppDependencyGraph(params) {
+    const enabledIds = new Set(params.enabledApps.map((app) => app.id));
+    const out = new Map();
+    for (const app of params.enabledApps) {
+        try {
+            const pkgInfo = await (0, package_info_1.readPackageInfo)({ packageRootAbs: app.packageRootAbs });
+            const loaded = await (0, manifest_1.loadDomindsAppManifest)({
+                packageRootAbs: app.packageRootAbs,
+                manifestRelPath: pkgInfo.manifestRelPath,
+            });
+            if (loaded.kind !== 'ok') {
+                out.set(app.id, new Set());
+                continue;
+            }
+            const deps = new Set();
+            for (const dep of loaded.manifest.dependencies ?? []) {
+                const depId = dep.id.trim();
+                if (depId === '' || !enabledIds.has(depId))
+                    continue;
+                deps.add(depId);
+            }
+            out.set(app.id, deps);
+        }
+        catch {
+            // Fail-open for override owner discovery: unresolved owner deps just don't contribute overrides.
+            out.set(app.id, new Set());
+        }
+    }
+    return out;
+}
+function computeOverrideOwnersByTarget(params) {
+    const packageRootByAppId = new Map();
+    const ownersByDep = new Map();
+    for (const app of params.enabledApps) {
+        packageRootByAppId.set(app.id, app.packageRootAbs);
+    }
+    for (const [ownerId, depIds] of params.depGraphByOwner.entries()) {
+        for (const depId of depIds) {
+            const owners = ownersByDep.get(depId);
+            if (owners) {
+                owners.push(ownerId);
+            }
+            else {
+                ownersByDep.set(depId, [ownerId]);
+            }
+        }
+    }
+    const result = new Map();
+    for (const targetApp of params.enabledApps) {
+        const targetId = targetApp.id;
+        const depthByOwner = new Map();
+        const queue = [];
+        for (const ownerId of ownersByDep.get(targetId) ?? []) {
+            if (ownerId === targetId)
+                continue;
+            depthByOwner.set(ownerId, 1);
+            queue.push({ ownerId, depth: 1 });
+        }
+        // Use shortest dependency distance from target to owner so traversal remains bounded
+        // even when enabled apps contain dependency cycles.
+        for (let i = 0; i < queue.length; i += 1) {
+            const current = queue[i];
+            const nextOwners = ownersByDep.get(current.ownerId) ?? [];
+            for (const nextOwnerId of nextOwners) {
+                if (nextOwnerId === targetId)
+                    continue;
+                const nextDepth = current.depth + 1;
+                const prevDepth = depthByOwner.get(nextOwnerId);
+                if (prevDepth !== undefined && prevDepth <= nextDepth)
+                    continue;
+                depthByOwner.set(nextOwnerId, nextDepth);
+                queue.push({ ownerId: nextOwnerId, depth: nextDepth });
+            }
+        }
+        const owners = [...depthByOwner.entries()]
+            .sort((a, b) => {
+            if (a[1] !== b[1])
+                return b[1] - a[1];
+            return a[0].localeCompare(b[0]);
+        })
+            .map(([ownerId]) => {
+            const packageRootAbs = packageRootByAppId.get(ownerId);
+            if (!packageRootAbs)
+                return null;
+            return { appId: ownerId, packageRootAbs };
+        })
+            .filter((owner) => owner !== null);
+        result.set(targetId, owners);
+    }
+    return result;
+}
 async function loadEnabledAppTeammates(params) {
     const snap = await (0, enabled_apps_1.loadEnabledAppsSnapshot)({ rtwsRootAbs: params.rtwsRootAbs });
+    const enabledApps = snap.enabledApps.map((app) => ({
+        id: app.id,
+        packageRootAbs: app.installJson.package.rootAbs,
+    }));
+    const depGraphByOwner = await loadEnabledAppDependencyGraph({ enabledApps });
+    const overrideOwnersByTarget = computeOverrideOwnersByTarget({ enabledApps, depGraphByOwner });
     const out = [];
     for (const app of snap.enabledApps) {
         const rel = app.installJson.contributes?.teammatesYamlRelPath;
         if (!rel)
             continue;
-        // Workspace overrides (new root + legacy root).
+        const appOverrideOwners = overrideOwnersByTarget.get(app.id) ?? [];
+        // Priority: rtws override > app override (integrator-provided) > app defaults.
         const override = await (0, override_paths_1.resolveAppOverrideFileAbs)({
             rtwsRootAbs: params.rtwsRootAbs,
             appId: app.id,
             appRelPath: rel,
+            appOverrideOwners,
         });
         const filePathAbs = override.kind === 'found'
             ? override.filePathAbs

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) {