dominds 1.2.5 → 1.2.7

package/dist/apps/enabled-apps.js

@@ -1,19 +1,484 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadEnabledAppsSnapshot = loadEnabledAppsSnapshot;
-const installed_file_1 = require("./installed-file");
-async function loadEnabledAppsSnapshot(params) {
-    const loaded = await (0, installed_file_1.loadInstalledAppsFile)({ rtwsRootAbs: params.rtwsRootAbs });
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const assigned_port_1 = require("./assigned-port");
+const manifest_1 = require("./manifest");
+const package_info_1 = require("./package-info");
+const resolution_file_1 = require("./resolution-file");
+const run_app_json_1 = require("./run-app-json");
+async function fileExists(filePathAbs) {
+    try {
+        await promises_1.default.access(filePathAbs);
+        return true;
+    }
+    catch (err) {
+        const isEnoent = typeof err === 'object' &&
+            err !== null &&
+            'code' in err &&
+            err.code === 'ENOENT';
+        if (isEnoent)
+            return false;
+        throw err;
+    }
+}
+async function dirExists(dirPathAbs) {
+    try {
+        const st = await promises_1.default.stat(dirPathAbs);
+        return st.isDirectory();
+    }
+    catch (err) {
+        const isEnoent = typeof err === 'object' &&
+            err !== null &&
+            'code' in err &&
+            err.code === 'ENOENT';
+        if (isEnoent)
+            return false;
+        throw err;
+    }
+}
+async function tryLoadRtwsAppManifestDeps(params) {
+    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, '.minds', 'app.yaml');
+    if (!(await fileExists(filePathAbs)))
+        return [];
+    const loaded = await (0, manifest_1.loadDomindsAppManifest)({
+        packageRootAbs: params.rtwsRootAbs,
+        manifestRelPath: '.minds/app.yaml',
+    });
     if (loaded.kind === 'error') {
-        throw new Error(`Failed to load installed apps file: ${loaded.errorText} (${loaded.filePathAbs})`);
+        throw new Error(`Failed to load rtws app manifest: ${loaded.errorText} (${loaded.filePathAbs})`);
     }
-    const enabledApps = loaded.file.apps
+    return loaded.manifest.dependencies ?? [];
+}
+function indexOverlayApps(params) {
+    const byId = new Map();
+    const extras = [];
+    for (const e of params.overlayApps) {
+        if (byId.has(e.id)) {
+            // Loud: duplicate IDs means non-deterministic overrides.
+            throw new Error(`Invalid apps resolution overlay: duplicate app id '${e.id}'`);
+        }
+        byId.set(e.id, e);
+        extras.push(e);
+    }
+    return { byId, extras };
+}
+function normalizeStrategy(raw) {
+    const order = raw?.order ??
+        resolution_file_1.DEFAULT_APPS_RESOLUTION_STRATEGY.order ??
+        ['local'];
+    const localRoots = raw?.localRoots ??
+        resolution_file_1.DEFAULT_APPS_RESOLUTION_STRATEGY.localRoots ?? ['dominds-apps'];
+    if (order.length === 0) {
+        throw new Error(`Invalid ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: resolutionStrategy.order must not be empty`);
+    }
+    if (localRoots.length === 0) {
+        throw new Error(`Invalid ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: resolutionStrategy.localRoots must not be empty`);
+    }
+    const orderSet = new Set(order);
+    if (orderSet.size !== order.length) {
+        throw new Error(`Invalid ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: resolutionStrategy.order has duplicates`);
+    }
+    const localRootsSet = new Set(localRoots);
+    if (localRootsSet.size !== localRoots.length) {
+        throw new Error(`Invalid ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: resolutionStrategy.localRoots has duplicates`);
+    }
+    return { order, localRoots };
+}
+function getResolutionHint(params) {
+    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, resolution_file_1.APPS_RESOLUTION_REL_PATH);
+    const action = params.hasResolutionFile ? 'Edit' : 'Create';
+    return (`${action} ${filePathAbs} to configure 'resolutionStrategy'. ` +
+        `Default local root is 'dominds-apps' (rtws-relative) and expects local apps at '<root>/<appId>/'.`);
+}
+async function resolveLocalAppPackageRootAbs(params) {
+    for (const root of params.localRoots) {
+        const rootAbs = node_path_1.default.isAbsolute(root) ? root : node_path_1.default.resolve(params.rtwsRootAbs, root);
+        const candidateAbs = node_path_1.default.resolve(rootAbs, params.appId);
+        if (await dirExists(candidateAbs))
+            return candidateAbs;
+    }
+    return null;
+}
+async function resolveAppManifestDepsFromInstalledApp(params) {
+    const pkgInfo = await (0, package_info_1.readPackageInfo)({ packageRootAbs: params.packageRootAbs });
+    const loaded = await (0, manifest_1.loadDomindsAppManifest)({
+        packageRootAbs: params.packageRootAbs,
+        manifestRelPath: pkgInfo.manifestRelPath,
+    });
+    if (loaded.kind === 'error') {
+        throw new Error(`Failed to load app manifest for '${params.appId}': ${loaded.errorText} (${loaded.filePathAbs})`);
+    }
+    return loaded.manifest.dependencies ?? [];
+}
+async function resolveAppsFromRtwsHierarchy(params) {
+    const issues = [];
+    const pushIssue = (issue) => {
+        issues.push(issue);
+    };
+    const resolvedById = new Map();
+    const depsByAppId = new Map();
+    const requiredById = new Map();
+    const requiredByParents = new Map();
+    const missingRequired = new Set();
+    const fatalApps = new Set();
+    const addRequiredByParent = (depId, parentId) => {
+        const existing = requiredByParents.get(depId);
+        if (existing) {
+            existing.add(parentId);
+            return;
+        }
+        requiredByParents.set(depId, new Set([parentId]));
+    };
+    const mergeRequiredFlag = (id, required) => {
+        const prev = requiredById.get(id);
+        if (prev === undefined) {
+            requiredById.set(id, required);
+            return true;
+        }
+        if (prev === true)
+            return false;
+        if (required === true) {
+            requiredById.set(id, true);
+            return true;
+        }
+        return false;
+    };
+    const queue = [];
+    const enqueue = (id, required, parentId) => {
+        const changed = mergeRequiredFlag(id, required);
+        if (parentId && required)
+            addRequiredByParent(id, parentId);
+        if (changed)
+            queue.push(id);
+    };
+    try {
+        const rootDeps = await tryLoadRtwsAppManifestDeps({ rtwsRootAbs: params.rtwsRootAbs });
+        for (const dep of rootDeps) {
+            enqueue(dep.id, dep.optional !== true, 'rtws');
+        }
+    }
+    catch (err) {
+        pushIssue({
+            kind: 'app_manifest_load_failed',
+            severity: 'error',
+            message: 'Failed to load rtws app manifest (.minds/app.yaml); app dependencies will not be resolved.',
+            detail: {
+                appId: 'rtws',
+                manifestRelPath: '.minds/app.yaml',
+                errorText: err instanceof Error ? err.message : String(err),
+            },
+        });
+    }
+    // Also treat explicitly enabled overlay apps as roots so their own transitive dependencies
+    // are resolved and missing-required issues can be surfaced.
+    for (const e of params.overlay.extras) {
+        if (!e.userEnabled)
+            continue;
+        enqueue(e.id, true, 'resolution_overlay');
+    }
+    const resolveMissingApp = async (appId) => {
+        for (const item of params.strategy.order) {
+            if (item === 'local') {
+                const packageRootAbs = await resolveLocalAppPackageRootAbs({
+                    rtwsRootAbs: params.rtwsRootAbs,
+                    appId,
+                    localRoots: params.strategy.localRoots,
+                });
+                if (!packageRootAbs) {
+                    continue;
+                }
+                const installJson = await (0, run_app_json_1.runDomindsAppJsonViaLocalPackage)({ packageRootAbs });
+                if (installJson.appId !== appId) {
+                    throw new Error(`App id mismatch for local package '${packageRootAbs}': expected '${appId}', got '${installJson.appId}'`);
+                }
+                const source = { kind: 'local', pathAbs: packageRootAbs };
+                return {
+                    id: appId,
+                    enabled: true,
+                    userEnabled: true,
+                    source,
+                    assignedPort: null,
+                    installJson,
+                };
+            }
+            if (item === 'npx') {
+                throw new Error(`Apps resolution strategy 'npx' is not supported yet for missing app '${appId}'. ` +
+                    `Install it explicitly so it appears in ${resolution_file_1.APPS_RESOLUTION_REL_PATH}.`);
+            }
+            const _exhaustive = item;
+            throw new Error(`Unreachable: unknown resolution strategy item: ${String(_exhaustive)}`);
+        }
+        return null;
+    };
+    while (queue.length > 0) {
+        const appId = queue.shift();
+        if (!appId)
+            break;
+        if (resolvedById.has(appId) || missingRequired.has(appId) || fatalApps.has(appId)) {
+            continue;
+        }
+        const required = requiredById.get(appId) ?? true;
+        const overlayEntry = params.overlay.byId.get(appId) ?? null;
+        let entry = overlayEntry;
+        if (!entry) {
+            try {
+                entry = await resolveMissingApp(appId);
+            }
+            catch (err) {
+                if (required) {
+                    const roots = params.strategy.localRoots
+                        .map((r) => (node_path_1.default.isAbsolute(r) ? r : node_path_1.default.resolve(params.rtwsRootAbs, r)))
+                        .join(', ');
+                    pushIssue({
+                        kind: 'required_dependency_missing',
+                        severity: 'error',
+                        message: `Required app dependency '${appId}' failed to resolve.`,
+                        detail: {
+                            appId,
+                            searchedLocalRootsAbs: roots,
+                            hint: getResolutionHint({
+                                rtwsRootAbs: params.rtwsRootAbs,
+                                hasResolutionFile: params.hasResolutionFile,
+                            }),
+                            errorText: err instanceof Error ? err.message : String(err),
+                            requiredBy: [...(requiredByParents.get(appId) ?? new Set())].sort(),
+                        },
+                    });
+                    missingRequired.add(appId);
+                }
+                continue;
+            }
+        }
+        if (!entry) {
+            if (required) {
+                const roots = params.strategy.localRoots
+                    .map((r) => (node_path_1.default.isAbsolute(r) ? r : node_path_1.default.resolve(params.rtwsRootAbs, r)))
+                    .join(', ');
+                pushIssue({
+                    kind: 'required_dependency_missing',
+                    severity: 'error',
+                    message: `Required app dependency '${appId}' is missing.`,
+                    detail: {
+                        appId,
+                        searchedLocalRootsAbs: roots,
+                        hint: getResolutionHint({
+                            rtwsRootAbs: params.rtwsRootAbs,
+                            hasResolutionFile: params.hasResolutionFile,
+                        }),
+                        requiredBy: [...(requiredByParents.get(appId) ?? new Set())].sort(),
+                    },
+                });
+                missingRequired.add(appId);
+            }
+            continue;
+        }
+        resolvedById.set(appId, entry);
+        if (!entry.userEnabled) {
+            if (required) {
+                pushIssue({
+                    kind: 'required_dependency_disabled',
+                    severity: 'error',
+                    message: `Required app dependency '${appId}' is disabled.`,
+                    detail: {
+                        appId,
+                        resolutionFileRelPath: resolution_file_1.APPS_RESOLUTION_REL_PATH,
+                        requiredBy: [...(requiredByParents.get(appId) ?? new Set())].sort(),
+                        hint: getResolutionHint({
+                            rtwsRootAbs: params.rtwsRootAbs,
+                            hasResolutionFile: params.hasResolutionFile,
+                        }),
+                    },
+                });
+            }
+            continue;
+        }
+        let manifestDeps;
+        try {
+            manifestDeps = await resolveAppManifestDepsFromInstalledApp({
+                appId,
+                packageRootAbs: entry.installJson.package.rootAbs,
+            });
+        }
+        catch (err) {
+            pushIssue({
+                kind: 'app_manifest_load_failed',
+                severity: 'error',
+                message: `Failed to load app manifest for '${appId}'.`,
+                detail: {
+                    appId,
+                    packageRootAbs: entry.installJson.package.rootAbs,
+                    errorText: err instanceof Error ? err.message : String(err),
+                },
+            });
+            fatalApps.add(appId);
+            continue;
+        }
+        const edges = manifestDeps.map((d) => ({
+            depId: d.id,
+            required: d.optional !== true,
+        }));
+        depsByAppId.set(appId, edges);
+        for (const e of edges) {
+            enqueue(e.depId, e.required, appId);
+        }
+    }
+    const effectiveEnabledById = new Map();
+    for (const [id, entry] of resolvedById.entries()) {
+        effectiveEnabledById.set(id, entry.userEnabled && !fatalApps.has(id));
+    }
+    // Fixed-point disable propagation: if an enabled app has a required dependency that is missing
+    // or effectively disabled, the app becomes effectively disabled.
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [appId, entry] of resolvedById.entries()) {
+            if (!effectiveEnabledById.get(appId))
+                continue;
+            if (!entry.userEnabled)
+                continue;
+            const edges = depsByAppId.get(appId) ?? [];
+            for (const edge of edges) {
+                if (!edge.required)
+                    continue;
+                const depId = edge.depId;
+                const depResolved = resolvedById.get(depId) ?? null;
+                const depEnabled = depResolved ? (effectiveEnabledById.get(depId) ?? false) : false;
+                const depMissing = !depResolved && missingRequired.has(depId);
+                if (depMissing || !depEnabled) {
+                    effectiveEnabledById.set(appId, false);
+                    pushIssue({
+                        kind: 'app_effectively_disabled_due_to_required_dependency',
+                        severity: 'error',
+                        message: `App '${appId}' is effectively disabled due to missing/disabled required dependency '${depId}'.`,
+                        detail: {
+                            appId,
+                            dependencyId: depId,
+                            dependencyState: depMissing
+                                ? 'missing'
+                                : depResolved && depResolved.userEnabled === false
+                                    ? 'disabled'
+                                    : 'effectively_disabled',
+                        },
+                    });
+                    changed = true;
+                    break;
+                }
+            }
+        }
+    }
+    const assignedPortById = new Map();
+    const resolvedEntriesForPort = [...resolvedById.values()];
+    for (const [appId, entry] of resolvedById.entries()) {
+        if (!effectiveEnabledById.get(appId))
+            continue;
+        const assigned = await (0, assigned_port_1.resolveStableAssignedPortWithReason)({
+            appId,
+            installJson: entry.installJson,
+            existingApps: resolvedEntriesForPort,
+            existingAssignedPort: entry.assignedPort,
+        });
+        assignedPortById.set(appId, assigned.assignedPort);
+        if (assigned.assignedPort !== entry.assignedPort) {
+            const nextEntry = { ...entry, assignedPort: assigned.assignedPort };
+            resolvedById.set(appId, nextEntry);
+            const idx = resolvedEntriesForPort.findIndex((a) => a.id === appId);
+            if (idx >= 0) {
+                resolvedEntriesForPort[idx] = nextEntry;
+            }
+        }
+        if (assigned.reason === 'reassigned_from_existing_conflict' ||
+            assigned.reason === 'reassigned_from_existing_unbindable') {
+            pushIssue({
+                kind: 'assigned_port_reassigned',
+                severity: 'warning',
+                message: `App '${appId}' assignedPort was reassigned due to runtime port conflict.`,
+                detail: {
+                    appId,
+                    previousAssignedPort: entry.assignedPort,
+                    reassignedToPort: assigned.assignedPort,
+                    reason: assigned.reason,
+                    resolutionFileRelPath: resolution_file_1.APPS_RESOLUTION_REL_PATH,
+                },
+            });
+        }
+    }
+    const out = [];
+    for (const [appId, entry] of resolvedById.entries()) {
+        if (!effectiveEnabledById.get(appId))
+            continue;
+        out.push(entry.enabled ? entry : { ...entry, enabled: true });
+    }
+    return { apps: out, issues, effectiveEnabledById, assignedPortById };
+}
+async function loadAppsResolutionOverlay(params) {
+    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, resolution_file_1.APPS_RESOLUTION_REL_PATH);
+    const hasResolutionFile = await fileExists(filePathAbs);
+    if (!hasResolutionFile) {
+        const emptyFile = { schemaVersion: 1, apps: [] };
+        return {
+            overlay: indexOverlayApps({ overlayApps: [] }),
+            resolutionFile: emptyFile,
+            strategy: normalizeStrategy(undefined),
+            hasResolutionFile,
+        };
+    }
+    const loaded = await (0, resolution_file_1.loadAppsResolutionFile)({ rtwsRootAbs: params.rtwsRootAbs });
+    if (loaded.kind === 'error') {
+        throw new Error(`Failed to load apps resolution file overlay: ${loaded.errorText} (${loaded.filePathAbs})`);
+    }
+    return {
+        overlay: indexOverlayApps({ overlayApps: loaded.file.apps }),
+        resolutionFile: loaded.file,
+        strategy: normalizeStrategy(loaded.file.resolutionStrategy),
+        hasResolutionFile,
+    };
+}
+async function loadEffectiveAppsResolution(params) {
+    const loaded = await loadAppsResolutionOverlay({ rtwsRootAbs: params.rtwsRootAbs });
+    const resolved = await resolveAppsFromRtwsHierarchy({
+        rtwsRootAbs: params.rtwsRootAbs,
+        overlay: loaded.overlay,
+        strategy: loaded.strategy,
+        hasResolutionFile: loaded.hasResolutionFile,
+    });
+    if (loaded.hasResolutionFile) {
+        const withEffectiveEnabled = (0, resolution_file_1.applyEffectiveEnabledToResolvedApps)({
+            existing: loaded.resolutionFile,
+            effectiveEnabledById: resolved.effectiveEnabledById,
+        });
+        const nextResolutionFile = (0, resolution_file_1.applyAssignedPortToResolvedApps)({
+            existing: withEffectiveEnabled,
+            assignedPortById: resolved.assignedPortById,
+        });
+        if (nextResolutionFile !== loaded.resolutionFile) {
+            await (0, resolution_file_1.writeAppsResolutionFileIfChanged)({
+                rtwsRootAbs: params.rtwsRootAbs,
+                file: nextResolutionFile,
+            });
+        }
+    }
+    return { apps: resolved.apps, issues: resolved.issues };
+}
+async function loadEnabledAppsSnapshot(params) {
+    const loaded = await loadEffectiveAppsResolution({ rtwsRootAbs: params.rtwsRootAbs });
+    const enabledApps = loaded.apps
         .filter((a) => a.enabled)
         .map((a) => ({
+        // Note: installJson.frontend.defaultPort may be 0 (meaning "runtime decides"); do not pass 0 as runtimePort.
         id: a.id,
-        runtimePort: a.runtime.port,
+        runtimePort: a.assignedPort ??
+            (a.installJson.frontend &&
+                a.installJson.frontend.defaultPort &&
+                a.installJson.frontend.defaultPort > 0
+                ? a.installJson.frontend.defaultPort
+                : null),
         installJson: a.installJson,
         source: a.source,
     }));
-    return { enabledApps };
+    return { enabledApps, issues: loaded.issues };
 }

package/dist/apps/manifest.js

@@ -15,6 +15,29 @@ function isRecord(v) {
 function asOptionalString(v) {
     return typeof v === 'string' ? v : undefined;
 }
+function asOptionalBool(v) {
+    return typeof v === 'boolean' ? v : undefined;
+}
+function parseDependencies(raw, at, filePathAbs) {
+    if (!Array.isArray(raw)) {
+        return { ok: false, errorText: `Invalid ${at}: expected array (${filePathAbs})` };
+    }
+    const deps = [];
+    for (let i = 0; i < raw.length; i += 1) {
+        const item = raw[i];
+        const itemAt = `${at}[${i}]`;
+        if (!isRecord(item)) {
+            return { ok: false, errorText: `Invalid ${itemAt}: expected object (${filePathAbs})` };
+        }
+        const id = typeof item['id'] === 'string' ? item['id'].trim() : '';
+        if (id === '') {
+            return { ok: false, errorText: `Invalid ${itemAt}.id: required (${filePathAbs})` };
+        }
+        const optional = asOptionalBool(item['optional']);
+        deps.push({ id, optional });
+    }
+    return { ok: true, value: deps };
+}
 function normalizeMountPath(raw) {
     const trimmed = raw.trim();
     if (trimmed === '' || trimmed === '/')
@@ -48,6 +71,19 @@ function parseDomindsAppManifest(parsed, filePathAbs) {
             errorText: `Invalid manifest id: non-empty string required (${filePathAbs})`,
         };
     }
+    // dependencies
+    const depsRaw = parsed['dependencies'];
+    const dependencies = (() => {
+        if (depsRaw === undefined)
+            return undefined;
+        const parsedDeps = parseDependencies(depsRaw, 'dependencies', filePathAbs);
+        if (!parsedDeps.ok)
+            return parsedDeps;
+        return { ok: true, value: parsedDeps.value };
+    })();
+    if (dependencies && !dependencies.ok) {
+        return { ok: false, errorText: dependencies.errorText };
+    }
     const contributesRaw = parsed['contributes'];
     const contributes = (() => {
         if (contributesRaw === undefined)
@@ -200,6 +236,7 @@ function parseDomindsAppManifest(parsed, filePathAbs) {
         apiVersion,
         kind,
         id,
+        dependencies: dependencies ? dependencies.value : undefined,
         name,
         description,
         contributes: contributes ? contributes.value : undefined,

package/dist/apps/override-paths.js

@@ -24,11 +24,11 @@ async function isRegularFile(filePathAbs) {
     }
 }
 /**
- * Resolve a workspace override file path for a given app-relative file path.
+ * Resolve an app asset override file path for a given app-relative file path.
  *
  * Priority order (read-time):
  * 1) `<rtws>/.apps/override/<app-id>/<rel>`
- * 2) `<rtws>/.apps/<app-id>/<rel>` (legacy)
+ * 2) `<integrator-app-root>/.apps/override/<app-id>/<rel>` (in provided order)
  */
 async function resolveAppOverrideFileAbs(params) {
     const normalized = normalizeRelNoTraversal(params.appRelPath);
@@ -36,11 +36,24 @@ async function resolveAppOverrideFileAbs(params) {
         return { kind: 'none' };
     const preferredAbs = path_1.default.resolve(params.rtwsRootAbs, '.apps', 'override', params.appId, normalized);
     if (await isRegularFile(preferredAbs)) {
-        return { kind: 'found', filePathAbs: preferredAbs, source: 'override' };
+        return {
+            kind: 'found',
+            filePathAbs: preferredAbs,
+            source: 'rtws_override',
+            ownerAppId: null,
+        };
     }
-    const legacyAbs = path_1.default.resolve(params.rtwsRootAbs, '.apps', params.appId, normalized);
-    if (await isRegularFile(legacyAbs)) {
-        return { kind: 'found', filePathAbs: legacyAbs, source: 'legacy_override' };
+    const owners = params.appOverrideOwners ?? [];
+    for (const owner of owners) {
+        const candidateAbs = path_1.default.resolve(owner.packageRootAbs, '.apps', 'override', params.appId, normalized);
+        if (await isRegularFile(candidateAbs)) {
+            return {
+                kind: 'found',
+                filePathAbs: candidateAbs,
+                source: 'app_override',
+                ownerAppId: owner.appId,
+            };
+        }
     }
     return { kind: 'none' };
 }

package/dist/apps/problems.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileAppsResolutionIssuesToProblems = reconcileAppsResolutionIssuesToProblems;
+const problems_1 = require("../problems");
+const time_1 = require("../shared/utils/time");
+const APPS_PROBLEM_PREFIX = 'apps/apps_resolution/';
+function sanitizeProblemIdSegment(segment) {
+    return segment.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+function asNonEmptyString(v) {
+    if (typeof v !== 'string')
+        return null;
+    const trimmed = v.trim();
+    return trimmed === '' ? null : trimmed;
+}
+function buildAppsIssueProblemId(issue) {
+    const kindSeg = sanitizeProblemIdSegment(issue.kind);
+    const appId = asNonEmptyString(issue.detail['appId']);
+    const depId = asNonEmptyString(issue.detail['dependencyId']);
+    if (appId && depId) {
+        return `${APPS_PROBLEM_PREFIX}${kindSeg}/${sanitizeProblemIdSegment(appId)}/${sanitizeProblemIdSegment(depId)}`;
+    }
+    if (appId) {
+        return `${APPS_PROBLEM_PREFIX}${kindSeg}/${sanitizeProblemIdSegment(appId)}`;
+    }
+    return `${APPS_PROBLEM_PREFIX}${kindSeg}`;
+}
+function reconcileAppsResolutionIssuesToProblems(params) {
+    const now = (0, time_1.formatUnifiedTimestamp)(new Date());
+    const desired = [];
+    for (const issue of params.issues) {
+        desired.push({
+            kind: 'generic_problem',
+            source: 'system',
+            id: buildAppsIssueProblemId(issue),
+            severity: issue.severity,
+            timestamp: now,
+            message: issue.message,
+            detail: { text: JSON.stringify(issue.detail, null, 2) },
+        });
+    }
+    (0, problems_1.reconcileProblemsByPrefix)(APPS_PROBLEM_PREFIX, desired);
+}