@akira-tl/forgerelay 1.1.2 → 1.2.0

package/dist/runtime/config/inspection/live.js

@@ -0,0 +1,77 @@
+import { liveGeneralConfigState } from "../config.js";
+import { ExternalMcpConfigRegistry } from "../external-mcp-registry.js";
+import { resolveHooksConfig } from "../resolution/hooks.js";
+import { resolveLanguageServersConfig } from "../resolution/language-servers.js";
+import { resolveSubagentProfilesConfigSources } from "../../../subagents/profiles.js";
+import { resolveProjectContext } from "../../../workspaces/state/project-context.js";
+export async function liveWorkspaceConfigPanelState(config, workspaceRoot) {
+    const general = liveGeneralConfigState(config);
+    const restartRequired = Object.values(general.applied.fields)
+        .filter((field) => field.restartRequired)
+        .map((field) => ({
+        logicalPath: field.logicalPath,
+        configuredValue: field.configuredValue,
+        appliedValue: field.appliedValue,
+    }));
+    const project = await resolveProjectContext(config.configDir, workspaceRoot);
+    const mcp = new ExternalMcpConfigRegistry({
+        configDir: config.configDir,
+        environment: process.env,
+        sourceRuntime: config.configRuntime.sources,
+    }).resolveConfiguration({
+        projectSharedConfigDir: project.sharedConfigDir,
+        projectLocalConfigDir: project.localConfigDir,
+    });
+    const languageServers = await resolveLanguageServersConfig({
+        configDir: config.configDir,
+        project,
+        environment: process.env,
+        sourceRuntime: config.configRuntime.sources,
+    });
+    const hooks = await resolveHooksConfig({
+        configDir: config.configDir,
+        project,
+        sourceRuntime: config.configRuntime.sources,
+    });
+    const subagents = resolveSubagentProfilesConfigSources({
+        configDir: config.configDir,
+        sourceRuntime: config.configRuntime.sources,
+        projectSharedConfigDir: project.sharedConfigDir,
+        projectLocalConfigDir: project.localConfigDir,
+    });
+    const issues = uniqueLiveIssues([mcp, languageServers, hooks, subagents]);
+    if (restartRequired.length === 0 && !general.source && issues.length === 0)
+        return undefined;
+    return {
+        ...(restartRequired.length > 0 ? { restartRequired } : {}),
+        ...(general.source ? { source: general.source } : {}),
+        ...(issues.length > 0 ? { issues } : {}),
+    };
+}
+function uniqueLiveIssues(domains) {
+    const seen = new Set();
+    const issues = [];
+    for (const domain of domains) {
+        for (const diagnostic of domain.diagnostics) {
+            if (diagnostic.severity !== "error")
+                continue;
+            const issue = liveIssue(domain.domain, diagnostic);
+            const key = `${issue.domain}\0${issue.code}\0${issue.source}\0${issue.message}\0${issue.usingLastKnownGood}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            issues.push(issue);
+        }
+    }
+    return issues.sort((left, right) => left.domain.localeCompare(right.domain) || left.source.localeCompare(right.source) || left.code.localeCompare(right.code));
+}
+function liveIssue(domain, diagnostic) {
+    return {
+        domain,
+        severity: "error",
+        code: diagnostic.code,
+        source: diagnostic.source.location ?? diagnostic.source.id,
+        usingLastKnownGood: diagnostic.usingLastKnownGood === true,
+        message: diagnostic.message,
+    };
+}

package/dist/runtime/config/resolution/general.js

@@ -0,0 +1,93 @@
+import { generalConfigDefinition } from "../definition/general-config.js";
+import { resolveConfigDomain } from "./resolver.js";
+export function resolveGeneralConfig(input = {}) {
+    const env = input.env ?? process.env;
+    const sources = [];
+    appendFileSource(sources, {
+        expectedScope: "user",
+        prepared: input.userSource,
+        value: input.user,
+        sourcePath: input.userSourcePath,
+    });
+    appendFileSource(sources, {
+        expectedScope: "project",
+        prepared: input.projectSource,
+        value: input.project,
+        sourcePath: input.projectSourcePath,
+    });
+    appendFileSource(sources, {
+        expectedScope: "project-local",
+        prepared: input.projectLocalSource,
+        value: input.projectLocal,
+        sourcePath: input.projectLocalSourcePath,
+    });
+    sources.push(environmentSource(env));
+    if (input.cli !== undefined) {
+        sources.push({
+            id: "runtime:cli",
+            scope: "runtime",
+            kind: "cli",
+            priority: 20,
+            value: input.cli,
+        });
+    }
+    return resolveConfigDomain({
+        definition: generalConfigDefinition,
+        sources,
+        environment: env,
+    });
+}
+function appendFileSource(sources, input) {
+    if (input.prepared !== undefined && input.value !== undefined) {
+        throw new Error(`General configuration received duplicate ${input.expectedScope} sources.`);
+    }
+    if (input.prepared !== undefined) {
+        if (input.prepared.scope !== input.expectedScope || input.prepared.kind !== "file") {
+            throw new Error(`General configuration ${input.expectedScope} source must be a file source at the matching scope.`);
+        }
+        sources.push(input.prepared);
+        return;
+    }
+    if (input.value === undefined)
+        return;
+    sources.push({
+        id: `${input.expectedScope}:config`,
+        scope: input.expectedScope,
+        kind: "file",
+        location: input.sourcePath,
+        priority: 0,
+        value: input.value,
+    });
+}
+function environmentSource(env) {
+    const values = {};
+    try {
+        for (const [name, field] of Object.entries(generalConfigDefinition.fields)) {
+            const readEnv = field.runtimeOverride?.readEnv;
+            if (!readEnv)
+                continue;
+            const value = readEnv(env);
+            if (value !== undefined)
+                values[name] = value;
+        }
+        return {
+            id: "runtime:environment",
+            scope: "runtime",
+            kind: "environment",
+            priority: 10,
+            value: values,
+        };
+    }
+    catch (error) {
+        return {
+            id: "runtime:environment",
+            scope: "runtime",
+            kind: "environment",
+            priority: 10,
+            error: {
+                code: "invalid_source",
+                message: error instanceof Error ? error.message : "Runtime environment configuration is invalid.",
+            },
+        };
+    }
+}

package/dist/runtime/config/resolution/hooks.js

@@ -0,0 +1,315 @@
+import { join } from "node:path";
+import { hooksConfigDefinition, normalizeLegacyHookEntries, } from "../../../mcp/hooks/config.js";
+import { ConfigSourceRuntime } from "../runtime/source-refresh.js";
+import { refreshLegacyUserConfigField } from "./project-sources.js";
+import { resolveConfigDomain } from "./resolver.js";
+const CANONICAL_PRIORITY = 100;
+const LEGACY_PRIORITY = 0;
+const LEGACY_DEPRECATION = {
+    since: "1.2.0",
+    removeIn: "1.4.0",
+    replacement: "hooks/",
+};
+export async function resolveHooksConfig(input) {
+    const sources = [];
+    const refreshDiagnostics = [];
+    const sourceRuntime = input.sourceRuntime ?? new ConfigSourceRuntime();
+    if (input.legacyUser && isRecord(input.legacyUser) && Object.keys(input.legacyUser).length > 0) {
+        sources.push({
+            id: "legacy:user:hooks",
+            scope: "user",
+            kind: "file",
+            priority: LEGACY_PRIORITY,
+            ...(input.configDir ? { location: join(input.configDir, "config.json/hooks") } : {}),
+            normalized: true,
+            deprecation: LEGACY_DEPRECATION,
+            value: { hooks: normalizeLegacyHookEntries(input.legacyUser) },
+        });
+    }
+    if (input.configDir) {
+        const legacyInline = readLegacyInlineHooks(sourceRuntime, input.configDir);
+        if (legacyInline.source)
+            sources.push(legacyInline.source);
+        if (legacyInline.diagnostic)
+            refreshDiagnostics.push(legacyInline.diagnostic);
+        const legacyUserFile = readLegacyHookAggregate(sourceRuntime, "legacy:user:hooks.json", "user", join(input.configDir, "hooks.json"));
+        if (legacyUserFile.source)
+            sources.push(legacyUserFile.source);
+        if (legacyUserFile.diagnostic)
+            refreshDiagnostics.push(legacyUserFile.diagnostic);
+        appendHookDirectory(sources, refreshDiagnostics, sourceRuntime, "user", join(input.configDir, "hooks"));
+    }
+    const sharedConfigDir = input.project?.sharedConfigDir ?? input.projectSharedConfigDir;
+    if (sharedConfigDir) {
+        const legacyProject = readLegacyHookAggregate(sourceRuntime, "legacy:project:hooks.json", "project", join(sharedConfigDir, "hooks.json"));
+        if (legacyProject.source)
+            sources.push(legacyProject.source);
+        if (legacyProject.diagnostic)
+            refreshDiagnostics.push(legacyProject.diagnostic);
+        appendHookDirectory(sources, refreshDiagnostics, sourceRuntime, "project", join(sharedConfigDir, "hooks"));
+    }
+    if (input.project) {
+        appendHookDirectory(sources, refreshDiagnostics, sourceRuntime, "project-local", join(input.project.localConfigDir, "hooks"));
+    }
+    const resolution = resolveConfigDomain({
+        definition: hooksConfigDefinition,
+        sources,
+    });
+    resolution.diagnostics = mergeDiagnostics(resolution.diagnostics, refreshDiagnostics);
+    return resolution;
+}
+export function effectiveHookConfigEntries(resolution) {
+    const hooks = isRecord(resolution.values.hooks) ? resolution.values.hooks : {};
+    const entries = Object.entries(hooks).flatMap(([name, value]) => {
+        const provenance = resolution.entries[`hooks.${name}`];
+        if (!provenance || !Array.isArray(value))
+            return [];
+        const scope = provenance.effective.source.scope;
+        if (scope !== "user" && scope !== "project" && scope !== "project-local")
+            return [];
+        return [{
+                name,
+                scope,
+                sourcePriority: provenance.effective.source.priority,
+                ...(provenance.effective.source.location ? { sourceLocation: provenance.effective.source.location } : {}),
+                entries: value,
+            }];
+    });
+    return entries.sort((left, right) => {
+        const scope = hookScopeRank(left.scope) - hookScopeRank(right.scope);
+        if (scope !== 0)
+            return scope;
+        const priority = left.sourcePriority - right.sourcePriority;
+        if (priority !== 0)
+            return priority;
+        const leftOrder = left.entries[0]?.order ?? Number.MAX_SAFE_INTEGER;
+        const rightOrder = right.entries[0]?.order ?? Number.MAX_SAFE_INTEGER;
+        if (leftOrder !== rightOrder)
+            return leftOrder - rightOrder;
+        const location = (left.sourceLocation ?? "").localeCompare(right.sourceLocation ?? "");
+        return location !== 0 ? location : left.name.localeCompare(right.name);
+    });
+}
+function hookScopeRank(scope) {
+    return scope === "user" ? 0 : scope === "project" ? 1 : 2;
+}
+function appendHookDirectory(sources, diagnostics, sourceRuntime, scope, directory) {
+    const refreshed = sourceRuntime.refreshDirectory({
+        key: `hooks:${scope}:${directory}`,
+        directory,
+        include: (name) => name.endsWith(".json"),
+        parse: (_name, content) => JSON.parse(content),
+        parseIssue: {
+            code: "invalid_source",
+            message: "Hook configuration file is not valid JSON.",
+        },
+        readIssue: {
+            code: "invalid_source",
+            message: "Hook configuration file could not be read.",
+        },
+        validate: (value, name, location) => {
+            const entryKey = name.slice(0, -5);
+            const validation = resolveConfigDomain({
+                definition: hooksConfigDefinition,
+                sources: [canonicalHookSource(scope, location, entryKey, value)],
+            });
+            const error = validation.diagnostics.find((diagnostic) => diagnostic.severity === "error");
+            if (!error)
+                return undefined;
+            return {
+                code: error.code === "missing_environment" ? "missing_environment" : "invalid_source",
+                message: error.message,
+            };
+        },
+    });
+    if (refreshed.state === "invalid" && refreshed.issue) {
+        diagnostics.push({
+            severity: "error",
+            code: refreshed.issue.code,
+            source: {
+                id: `canonical:${scope}:hooks-directory`,
+                scope,
+                kind: "file",
+                location: refreshed.directory,
+                priority: CANONICAL_PRIORITY,
+            },
+            message: refreshed.issue.message,
+            diagnosticChanged: refreshed.diagnosticChanged,
+        });
+    }
+    for (const unit of refreshed.units) {
+        const location = unit.status.path;
+        const entryKey = unit.name.slice(0, -5);
+        if (unit.value !== undefined) {
+            const source = canonicalHookSource(scope, location, entryKey, unit.value);
+            sources.push(source);
+            if (unit.status.state === "invalid" && unit.issue) {
+                diagnostics.push({
+                    severity: "error",
+                    code: unit.issue.code,
+                    source: sourceReference(source),
+                    message: unit.issue.message,
+                    usingLastKnownGood: true,
+                    diagnosticChanged: unit.status.diagnosticChanged,
+                });
+            }
+            continue;
+        }
+        if (unit.status.state === "invalid") {
+            sources.push(invalidHookSource(scope, location, entryKey, unit.issue?.message ?? "Hook configuration file is invalid.", unit.issue?.code));
+        }
+    }
+}
+function canonicalHookSource(scope, location, entryKey, value) {
+    return {
+        id: `canonical:${scope}:hook:${entryKey}`,
+        scope,
+        kind: "file",
+        location,
+        priority: CANONICAL_PRIORITY,
+        entryKey,
+        shadowsLowerPriorityKeys: [`hooks.${entryKey}`],
+        value,
+    };
+}
+function invalidHookSource(scope, location, entryKey, message, code = "invalid_source") {
+    return {
+        id: `canonical:${scope}:hook:${entryKey}`,
+        scope,
+        kind: "file",
+        location,
+        priority: CANONICAL_PRIORITY,
+        entryKey,
+        shadowsLowerPriorityKeys: [`hooks.${entryKey}`],
+        error: { code, message },
+    };
+}
+function readLegacyInlineHooks(sourceRuntime, configDir) {
+    const location = join(configDir, "config.json");
+    const refreshed = refreshLegacyUserConfigField({
+        sourceRuntime,
+        configDir,
+        field: "hooks",
+        parse: (value) => value === undefined ? undefined : normalizeLegacyHookEntries(value),
+        invalidMessage: "Legacy inline Hook configuration is invalid.",
+    });
+    if (refreshed.status.state === "missing")
+        return {};
+    const source = refreshed.value === undefined
+        ? undefined
+        : legacyHookSource("legacy:user:config-hooks", "user", location, refreshed.value);
+    if (refreshed.status.state !== "invalid" || !refreshed.issue)
+        return source ? { source } : {};
+    if (refreshed.issueScope === "container")
+        return source ? { source } : {};
+    if (source) {
+        return {
+            source,
+            diagnostic: {
+                severity: "error",
+                code: refreshed.issue.code,
+                source: sourceReference(source),
+                message: refreshed.issue.message,
+                usingLastKnownGood: refreshed.status.usingLastKnownGood,
+                diagnosticChanged: refreshed.status.diagnosticChanged,
+            },
+        };
+    }
+    return {
+        source: {
+            id: "legacy:user:config-hooks",
+            scope: "user",
+            kind: "file",
+            location,
+            priority: LEGACY_PRIORITY,
+            deprecation: LEGACY_DEPRECATION,
+            error: {
+                code: refreshed.issue.code,
+                message: refreshed.issue.message,
+            },
+        },
+    };
+}
+function readLegacyHookAggregate(sourceRuntime, id, scope, location) {
+    const refreshed = sourceRuntime.refreshFile({
+        key: `hooks:${id}:${location}`,
+        path: location,
+        parse: (raw) => normalizeLegacyHookEntries(JSON.parse(raw)),
+        parseIssue: { code: "invalid_source", message: "Legacy Hook configuration is invalid." },
+        readIssue: { code: "invalid_source", message: "Legacy Hook configuration could not be read." },
+        validate: (value) => {
+            const validation = resolveConfigDomain({
+                definition: hooksConfigDefinition,
+                sources: [legacyHookSource(id, scope, location, value)],
+            });
+            const error = validation.diagnostics.find((diagnostic) => diagnostic.severity === "error");
+            return error ? { code: "invalid_source", message: error.message } : undefined;
+        },
+    });
+    if (refreshed.status.state === "missing")
+        return {};
+    if (refreshed.value !== undefined) {
+        const source = legacyHookSource(id, scope, location, refreshed.value);
+        if (refreshed.status.state !== "invalid" || !refreshed.issue)
+            return { source };
+        return {
+            source,
+            diagnostic: {
+                severity: "error",
+                code: refreshed.issue.code,
+                source: sourceReference(source),
+                message: refreshed.issue.message,
+                usingLastKnownGood: true,
+                diagnosticChanged: refreshed.status.diagnosticChanged,
+            },
+        };
+    }
+    return {
+        source: {
+            id,
+            scope,
+            kind: "file",
+            location,
+            priority: LEGACY_PRIORITY,
+            deprecation: LEGACY_DEPRECATION,
+            error: {
+                code: refreshed.issue?.code ?? "invalid_source",
+                message: refreshed.issue?.message ?? "Legacy Hook configuration is invalid.",
+            },
+        },
+    };
+}
+function legacyHookSource(id, scope, location, value) {
+    return {
+        id,
+        scope,
+        kind: "file",
+        location,
+        priority: LEGACY_PRIORITY,
+        normalized: true,
+        deprecation: LEGACY_DEPRECATION,
+        value: { hooks: value },
+    };
+}
+function sourceReference(source) {
+    return {
+        id: source.id,
+        scope: source.scope,
+        kind: source.kind,
+        ...(source.location ? { location: source.location } : {}),
+        priority: source.priority,
+    };
+}
+function mergeDiagnostics(left, right) {
+    const seen = new Set();
+    return [...left, ...right].filter((diagnostic) => {
+        const key = `${diagnostic.source.id}\0${diagnostic.code}\0${diagnostic.message}\0${diagnostic.usingLastKnownGood === true}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}