@akira-tl/forgerelay 1.2.4 → 1.3.0

package/dist/cli/config/domains/domain-cli.js

@@ -0,0 +1,468 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parseConfigSource } from "../../../runtime/config/definition/definition.js";
+import { externalMcpConfigDefinition } from "../../../runtime/config/definition/external-mcp.js";
+import { hooksConfigDefinition } from "../../../mcp/hooks/config.js";
+import { languageServersConfigDefinition } from "../../../runtime/config/definition/language-servers.js";
+import { ExternalMcpConfigRegistry } from "../../../runtime/config/external-mcp-registry.js";
+import { resolveHooksConfig } from "../../../runtime/config/resolution/hooks.js";
+import { resolveLanguageServersConfig } from "../../../runtime/config/resolution/language-servers.js";
+import { assertConfigResolutionValid } from "../../../runtime/config/resolution/resolver.js";
+import { ConfigSourceRuntime } from "../../../runtime/config/runtime/source-refresh.js";
+import { forgerelayConfigDir, writeConfigJsonFile, writeConfigTextFile } from "../../../runtime/config/user-config.js";
+import { ProjectContextResolver } from "../../../workspaces/state/project-context.js";
+import { canonicalSubagentProfileDocument, canonicalSubagentProfileValueFromDocument, resolveSubagentProfilesConfigSources, } from "../../../subagents/profiles.js";
+import { runConfigInspection } from "../inspect.js";
+import { parseConfigScopeArgs } from "../scope.js";
+import { runConfigContextCommand } from "./context-cli.js";
+const JSON_DOMAIN_ADAPTERS = {
+    mcp: {
+        cliName: "mcp",
+        resolutionDomain: "mcp",
+        definition: externalMcpConfigDefinition,
+        fileName: "mcp.json",
+        rootField: "servers",
+        diskShape: "object",
+        resolve: resolveMcpConfiguration,
+    },
+    lsp: {
+        cliName: "lsp",
+        resolutionDomain: "language-servers",
+        definition: languageServersConfigDefinition,
+        fileName: "language-servers.json",
+        rootField: "servers",
+        diskShape: "keyed-root",
+        resolve: resolveLanguageServerConfiguration,
+    },
+};
+export async function runConfigDomainCommand(domain, args) {
+    if (domain === "context") {
+        await runConfigContextCommand(args);
+        return true;
+    }
+    const adapter = JSON_DOMAIN_ADAPTERS[domain];
+    if (adapter) {
+        await runJsonDomainCommand(adapter, args);
+        return true;
+    }
+    if (domain === "hooks") {
+        if (args[0] === "list" || args[0] === "help" || args[0] === "--help" || args[0] === "-h" || args[0] === undefined) {
+            return false;
+        }
+        await runHookDomainCommand(args);
+        return true;
+    }
+    if (domain === "subagents") {
+        await runSubagentDomainCommand(args);
+        return true;
+    }
+    return false;
+}
+async function runHookDomainCommand(args) {
+    const [command, ...rest] = args;
+    if (command === "check" || command === "sources" || command === "explain") {
+        process.exitCode = await runDomainInspection("hooks", "hooks", command, rest);
+        return;
+    }
+    if (command === "get") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length !== 1)
+            throw new Error("Usage: forgerelay config hooks get hooks.<name> [scope]");
+        const resolution = await resolveHookConfiguration(parsed.scope);
+        printConfiguredEntry(resolution, normalizeDomainLogicalPath("hooks", "hooks", parsed.rest[0]));
+        return;
+    }
+    if (command === "set") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length < 2)
+            throw new Error("Usage: forgerelay config hooks set hooks.<name>[.<field>] <value> [scope]");
+        const [logicalPath, ...valueParts] = parsed.rest;
+        const segments = domainLogicalSegments("hooks", "hooks", logicalPath);
+        const name = safeResourceName(segments[1] ?? "");
+        const target = await domainWriteTarget(parsed.scope, join("hooks", `${name}.json`));
+        const rawValue = valueParts.join(" ").trim();
+        if (!rawValue)
+            throw new Error(`Missing value for ${logicalPath}.`);
+        const candidate = segments.length === 2
+            ? coerceConfigValue(rawValue)
+            : mutateExistingJson(target.path, segments.slice(2), coerceConfigValue(rawValue), "set");
+        if (!isRecord(candidate))
+            throw new Error(`hooks.${name} must be a JSON object.`);
+        writeHookTarget(target, name, candidate);
+        return;
+    }
+    if (command === "unset") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length !== 1)
+            throw new Error("Usage: forgerelay config hooks unset hooks.<name>.<field> [scope]");
+        const segments = domainLogicalSegments("hooks", "hooks", parsed.rest[0]);
+        if (segments.length < 3)
+            throw new Error("Use `config hooks remove <name>` to delete a complete Hook.");
+        const name = safeResourceName(segments[1]);
+        const target = await domainWriteTarget(parsed.scope, join("hooks", `${name}.json`));
+        const candidate = mutateExistingJson(target.path, segments.slice(2), undefined, "unset");
+        writeHookTarget(target, name, candidate);
+        return;
+    }
+    if (command === "remove") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length !== 1)
+            throw new Error("Usage: forgerelay config hooks remove <name> [scope]");
+        const name = safeResourceName(parsed.rest[0]);
+        const target = await domainWriteTarget(parsed.scope, join("hooks", `${name}.json`));
+        rmSync(target.path, { force: true });
+        console.log(`Removed ${target.path}`);
+        return;
+    }
+    throw new Error(`Unknown config hooks command: ${command ?? ""}`);
+}
+async function runSubagentDomainCommand(args) {
+    const [command, ...rest] = args;
+    if (command === "check" || command === "sources" || command === "explain") {
+        process.exitCode = await runDomainInspection("subagents", "profiles", command, rest);
+        return;
+    }
+    if (command === "get") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length !== 1)
+            throw new Error("Usage: forgerelay config subagents get profiles.<name> [scope]");
+        const resolution = await resolveSubagentConfiguration(parsed.scope);
+        printConfiguredEntry(resolution, normalizeDomainLogicalPath("subagents", "profiles", parsed.rest[0]));
+        return;
+    }
+    if (command === "set") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length < 2)
+            throw new Error("Usage: forgerelay config subagents set profiles.<name>[.<field>] <value> [scope]");
+        const [logicalPath, ...valueParts] = parsed.rest;
+        const segments = domainLogicalSegments("subagents", "profiles", logicalPath);
+        const name = safeResourceName(segments[1] ?? "");
+        const target = await subagentWriteTarget(parsed.scope, name);
+        const rawValue = valueParts.join(" ").trim();
+        if (!rawValue)
+            throw new Error(`Missing value for ${logicalPath}.`);
+        const candidate = segments.length === 2
+            ? coerceConfigValue(rawValue)
+            : mutateExistingSubagent(target.path, segments.slice(2), coerceConfigValue(rawValue), "set");
+        writeSubagentTarget(target, name, candidate);
+        return;
+    }
+    if (command === "unset") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length !== 1)
+            throw new Error("Usage: forgerelay config subagents unset profiles.<name>.<field> [scope]");
+        const segments = domainLogicalSegments("subagents", "profiles", parsed.rest[0]);
+        if (segments.length < 3)
+            throw new Error("Use `config subagents remove <name>` to delete a complete profile.");
+        const name = safeResourceName(segments[1]);
+        const target = await subagentWriteTarget(parsed.scope, name);
+        const candidate = mutateExistingSubagent(target.path, segments.slice(2), undefined, "unset");
+        writeSubagentTarget(target, name, candidate);
+        return;
+    }
+    if (command === "remove") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length !== 1)
+            throw new Error("Usage: forgerelay config subagents remove <name> [scope]");
+        const name = safeResourceName(parsed.rest[0]);
+        const target = await subagentWriteTarget(parsed.scope, name);
+        rmSync(target.path, { force: true });
+        console.log(`Removed ${target.path}`);
+        return;
+    }
+    throw new Error(`Unknown config subagents command: ${command ?? ""}`);
+}
+async function runJsonDomainCommand(adapter, args) {
+    const [command, ...rest] = args;
+    if (command === "check" || command === "sources" || command === "explain") {
+        process.exitCode = await runDomainInspection(adapter.resolutionDomain, adapter.rootField, command, rest);
+        return;
+    }
+    if (command === "get") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length !== 1) {
+            throw new Error(`Usage: forgerelay config ${adapter.cliName} get <logical-path> [--project <path>|--global]`);
+        }
+        const logicalPath = normalizeDomainLogicalPath(adapter.resolutionDomain, adapter.rootField, parsed.rest[0]);
+        const resolution = await adapter.resolve(parsed.scope);
+        printConfiguredEntry(resolution, logicalPath);
+        return;
+    }
+    if (command === "set") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length < 2) {
+            throw new Error(`Usage: forgerelay config ${adapter.cliName} set <logical-path> <value> [--project <path>|--global]`);
+        }
+        const [logicalPath, ...valueParts] = parsed.rest;
+        const path = storagePathSegments(adapter, logicalPath);
+        const rawValue = valueParts.join(" ").trim();
+        if (!rawValue)
+            throw new Error(`Missing value for ${logicalPath}.`);
+        const target = await domainWriteTarget(parsed.scope, adapter.fileName);
+        const next = readJsonObject(target.path, domainFallback(adapter));
+        setNestedValue(next, path, coerceConfigValue(rawValue));
+        writeJsonDomainTarget(adapter, target, next);
+        return;
+    }
+    if (command === "unset") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length !== 1) {
+            throw new Error(`Usage: forgerelay config ${adapter.cliName} unset <logical-path> [--project <path>|--global]`);
+        }
+        const target = await domainWriteTarget(parsed.scope, adapter.fileName);
+        const next = readJsonObject(target.path, domainFallback(adapter));
+        const path = storagePathSegments(adapter, parsed.rest[0]);
+        if (isCompleteJsonResourcePath(adapter, path)) {
+            throw new Error(`Use \`config ${adapter.cliName} remove <name>\` to delete a complete resource.`);
+        }
+        deleteNestedValue(next, path);
+        writeJsonDomainTarget(adapter, target, next);
+        return;
+    }
+    if (command === "remove") {
+        const parsed = parseConfigScopeArgs(rest);
+        if (parsed.rest.length !== 1) {
+            throw new Error(`Usage: forgerelay config ${adapter.cliName} remove <name> [--project <path>|--global]`);
+        }
+        const target = await domainWriteTarget(parsed.scope, adapter.fileName);
+        const next = readJsonObject(target.path, domainFallback(adapter));
+        const resourcePath = adapter.diskShape === "keyed-root"
+            ? [parsed.rest[0]]
+            : [adapter.rootField, parsed.rest[0]];
+        deleteNestedValue(next, resourcePath);
+        writeJsonDomainTarget(adapter, target, next);
+        return;
+    }
+    throw new Error(`Unknown config ${adapter.cliName} command: ${command ?? ""}`);
+}
+async function runDomainInspection(domain, rootField, command, args) {
+    const inspectionArgs = command === "explain"
+        ? [command, ...normalizeDomainExplainArgs(domain, rootField, args)]
+        : [command, ...args];
+    return runConfigInspection(inspectionArgs, domain);
+}
+function printConfiguredEntry(resolution, logicalPath) {
+    assertConfigResolutionValid(resolution);
+    const entry = Object.values(resolution.entries).find((candidate) => candidate.logicalPath === logicalPath);
+    if (!entry || entry.tombstone)
+        throw new Error(`Unknown configuration logical path: ${logicalPath}.`);
+    console.log(JSON.stringify(entry.effective.effectiveValue, null, 2));
+}
+async function resolveMcpConfiguration(scope) {
+    const configDir = forgerelayConfigDir();
+    const registry = new ExternalMcpConfigRegistry({ configDir, environment: process.env });
+    if (scope.mode === "global")
+        return registry.resolveConfiguration();
+    const project = await new ProjectContextResolver(configDir).inspect(scope.projectRoot);
+    return registry.resolveConfiguration({
+        projectSharedConfigDir: project.sharedConfigDir,
+        ...(project.localConfigDir ? { projectLocalConfigDir: project.localConfigDir } : {}),
+    });
+}
+async function resolveHookConfiguration(scope) {
+    const configDir = forgerelayConfigDir();
+    if (scope.mode === "global")
+        return resolveHooksConfig({ configDir });
+    const project = await new ProjectContextResolver(configDir).inspect(scope.projectRoot);
+    return resolveHooksConfig({
+        configDir,
+        ...(project.localConfigDir
+            ? { project: { sharedConfigDir: project.sharedConfigDir, localConfigDir: project.localConfigDir } }
+            : { projectSharedConfigDir: project.sharedConfigDir }),
+    });
+}
+async function subagentWriteTarget(scope, name) {
+    const resolution = await resolveSubagentConfiguration(scope);
+    const entry = resolution.entries[`profiles.${name}`];
+    const targetScope = scope.mode === "global" ? "user" : "project";
+    const candidate = entry
+        ? [entry.effective, ...entry.shadowed].find((value) => value.source.scope === targetScope &&
+            value.source.id.startsWith(`canonical:${targetScope}:subagent:`) &&
+            value.source.location !== undefined)
+        : undefined;
+    if (candidate?.source.location) {
+        return { scope: targetScope, path: candidate.source.location };
+    }
+    return domainWriteTarget(scope, join("subagents", `${name}.md`));
+}
+async function resolveSubagentConfiguration(scope) {
+    const configDir = forgerelayConfigDir();
+    const sourceRuntime = new ConfigSourceRuntime();
+    if (scope.mode === "global") {
+        return resolveSubagentProfilesConfigSources({ configDir, sourceRuntime });
+    }
+    const project = await new ProjectContextResolver(configDir).inspect(scope.projectRoot);
+    return resolveSubagentProfilesConfigSources({
+        configDir,
+        sourceRuntime,
+        projectSharedConfigDir: project.sharedConfigDir,
+        ...(project.localConfigDir ? { projectLocalConfigDir: project.localConfigDir } : {}),
+    });
+}
+async function resolveLanguageServerConfiguration(scope) {
+    const configDir = forgerelayConfigDir();
+    if (scope.mode === "global") {
+        return resolveLanguageServersConfig({ configDir, environment: process.env });
+    }
+    const project = await new ProjectContextResolver(configDir).inspect(scope.projectRoot);
+    return resolveLanguageServersConfig({
+        configDir,
+        environment: process.env,
+        ...(project.localConfigDir
+            ? { project: { sharedConfigDir: project.sharedConfigDir, localConfigDir: project.localConfigDir } }
+            : { projectSharedConfigDir: project.sharedConfigDir }),
+    });
+}
+function writeJsonDomainTarget(adapter, target, value) {
+    const validated = parseConfigSource(adapter.definition, target.scope, value);
+    const diskValue = adapter.diskShape === "keyed-root" ? value : validated;
+    mkdirSync(dirname(target.path), { recursive: true });
+    writeConfigJsonFile(target.path, diskValue, 0o600);
+    console.log(`Updated ${target.path}`);
+}
+function writeHookTarget(target, name, value) {
+    parseConfigSource(hooksConfigDefinition, target.scope, value, name);
+    mkdirSync(dirname(target.path), { recursive: true });
+    writeConfigJsonFile(target.path, value, 0o600);
+    console.log(`Updated ${target.path}`);
+}
+function writeSubagentTarget(target, name, value) {
+    const document = canonicalSubagentProfileDocument(name, value);
+    mkdirSync(dirname(target.path), { recursive: true });
+    writeConfigTextFile(target.path, document, 0o600);
+    console.log(`Updated ${target.path}`);
+}
+function mutateExistingJson(path, nestedPath, value, action) {
+    if (!existsSync(path))
+        throw new Error(`Configuration resource does not exist: ${path}`);
+    const next = readJsonObject(path, {});
+    if (action === "set")
+        setNestedValue(next, nestedPath, value);
+    else
+        deleteNestedValue(next, nestedPath);
+    return next;
+}
+function mutateExistingSubagent(path, nestedPath, value, action) {
+    if (!existsSync(path))
+        throw new Error(`Subagent Profile does not exist: ${path}`);
+    const current = canonicalSubagentProfileValueFromDocument(readFileSync(path, "utf8"), path);
+    if (!isRecord(current))
+        throw new Error(`Subagent Profile is not editable: ${path}`);
+    const next = structuredClone(current);
+    if (action === "set")
+        setNestedValue(next, nestedPath, value);
+    else
+        deleteNestedValue(next, nestedPath);
+    return next;
+}
+async function domainWriteTarget(scope, fileName) {
+    const configDir = forgerelayConfigDir();
+    if (scope.mode === "global")
+        return { scope: "user", path: join(configDir, fileName) };
+    const project = await new ProjectContextResolver(configDir).inspect(scope.projectRoot);
+    return { scope: "project", path: join(project.sharedConfigDir, fileName) };
+}
+function domainFallback(adapter) {
+    return adapter.diskShape === "keyed-root" ? {} : { [adapter.rootField]: {} };
+}
+function readJsonObject(path, fallback) {
+    if (!existsSync(path))
+        return structuredClone(fallback);
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!isRecord(parsed))
+        throw new Error(`Configuration source must be a JSON object: ${path}`);
+    return structuredClone(parsed);
+}
+function safeResourceName(value) {
+    const name = value.trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name) || name === "." || name === "..") {
+        throw new Error(`Invalid configuration resource name: ${value}.`);
+    }
+    return name;
+}
+function isCompleteJsonResourcePath(adapter, path) {
+    return adapter.diskShape === "keyed-root"
+        ? path.length === 1
+        : path.length === 2 && path[0] === adapter.rootField;
+}
+function storagePathSegments(adapter, logicalPath) {
+    const segments = domainLogicalSegments(adapter.resolutionDomain, adapter.rootField, logicalPath);
+    if (segments[0] !== adapter.rootField || segments.length < 2) {
+        throw new Error(`${adapter.cliName} logical paths must start with ${adapter.rootField}.<name>.`);
+    }
+    return adapter.diskShape === "keyed-root" ? segments.slice(1) : segments;
+}
+function domainLogicalSegments(domain, rootField, logicalPath) {
+    const normalized = normalizeDomainLogicalPath(domain, rootField, logicalPath);
+    return normalized.slice(`${domain}.`.length).split(".").filter(Boolean);
+}
+function normalizeDomainLogicalPath(domain, rootField, logicalPath) {
+    const normalized = logicalPath.trim();
+    if (!normalized)
+        throw new Error(`Invalid ${domain} logical path: ${logicalPath}.`);
+    const fullyQualifiedRoot = `${domain}.${rootField}`;
+    if (normalized === fullyQualifiedRoot || normalized.startsWith(`${fullyQualifiedRoot}.`))
+        return normalized;
+    return `${domain}.${normalized}`;
+}
+function normalizeDomainExplainArgs(domain, rootField, args) {
+    const normalized = [];
+    let logicalPathSeen = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--project") {
+            normalized.push(arg);
+            const project = args[index + 1];
+            if (project !== undefined) {
+                normalized.push(project);
+                index += 1;
+            }
+            continue;
+        }
+        if (arg === "--global" || arg === "--json") {
+            normalized.push(arg);
+            continue;
+        }
+        if (!logicalPathSeen) {
+            normalized.push(normalizeDomainLogicalPath(domain, rootField, arg));
+            logicalPathSeen = true;
+            continue;
+        }
+        normalized.push(arg);
+    }
+    return normalized;
+}
+function coerceConfigValue(rawValue) {
+    try {
+        return JSON.parse(rawValue);
+    }
+    catch {
+        return rawValue;
+    }
+}
+function setNestedValue(target, path, value) {
+    let current = target;
+    for (const segment of path.slice(0, -1)) {
+        const existing = current[segment];
+        if (existing !== undefined && !isRecord(existing)) {
+            throw new Error(`Cannot set ${path.join(".")}: ${segment} is not an object.`);
+        }
+        const next = existing ?? {};
+        current[segment] = next;
+        current = next;
+    }
+    current[path[path.length - 1]] = value;
+}
+function deleteNestedValue(target, path) {
+    let current = target;
+    for (const segment of path.slice(0, -1)) {
+        const existing = current[segment];
+        if (!isRecord(existing))
+            return;
+        current = existing;
+    }
+    delete current[path[path.length - 1]];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/cli/config/general.js

@@ -0,0 +1,174 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { forgerelayConfigDir, loadForgeRelayFiles, writeConfigJsonFile, writeForgeRelayConfig, } from "../../runtime/config/user-config.js";
+import { parseConfigSource } from "../../runtime/config/definition/definition.js";
+import { generalConfigDefinition } from "../../runtime/config/definition/general-config.js";
+import { resolveGeneralConfig } from "../../runtime/config/resolution/general.js";
+import { readJsonConfigSource } from "../../runtime/config/resolution/project-sources.js";
+import { assertConfigResolutionValid } from "../../runtime/config/resolution/resolver.js";
+import { ProjectContextResolver } from "../../workspaces/state/project-context.js";
+import { normalizeOptionalPublicBaseUrl } from "../setup-support.js";
+import { parseConfigScopeArgs } from "./scope.js";
+export function renderGeneralConfigHelp() {
+    return [
+        "ForgeRelay config",
+        "",
+        "Usage:",
+        "  forgerelay config get [--project <path>|--global]",
+        "  forgerelay config set <logical-path> <value> [--project <path>|--global]",
+        "  forgerelay config unset <logical-path> [--project <path>|--global]",
+        "  forgerelay config check [--project <path>|--global] [--json]",
+        "  forgerelay config sources [--project <path>|--global] [--json]",
+        "  forgerelay config explain <logical-path> [--project <path>|--global] [--json]",
+        "  forgerelay config migrate [--dry-run] [--project <path>|--global]",
+        "  forgerelay config context <get|set|unset|check|sources|explain> ...",
+        "  forgerelay config <mcp|hooks|lsp|subagents> <get|set|unset|remove|check|sources|explain> ...",
+    ].join("\n");
+}
+export async function runGeneralConfigGet(args) {
+    const parsed = parseConfigScopeArgs(args);
+    if (parsed.rest.length > 0)
+        throw new Error(`Unknown config get option: ${parsed.rest[0]}`);
+    const resolution = await resolveGeneralConfigForScope(parsed.scope);
+    assertConfigResolutionValid(resolution);
+    console.log(JSON.stringify(resolution.values, null, 2));
+}
+export async function resolveGeneralConfigForScope(scope) {
+    const configDir = forgerelayConfigDir();
+    const userSource = await readJsonConfigSource({
+        id: "user:config",
+        scope: "user",
+        location: join(configDir, "config.json"),
+    });
+    const project = scope.mode === "project"
+        ? await new ProjectContextResolver(configDir).inspect(scope.projectRoot)
+        : undefined;
+    const projectSource = project
+        ? await readJsonConfigSource({
+            id: "project:config",
+            scope: "project",
+            location: join(project.sharedConfigDir, "config.json"),
+        })
+        : undefined;
+    const projectLocalSource = project?.localConfigDir
+        ? await readJsonConfigSource({
+            id: "project-local:config",
+            scope: "project-local",
+            location: join(project.localConfigDir, "config.json"),
+        })
+        : undefined;
+    return resolveGeneralConfig({
+        env: process.env,
+        ...(userSource ? { userSource } : {}),
+        ...(projectSource ? { projectSource } : {}),
+        ...(projectLocalSource ? { projectLocalSource } : {}),
+    });
+}
+export async function runGeneralConfigSet(args) {
+    const parsed = parseConfigScopeArgs(args);
+    if (parsed.rest.length < 2) {
+        throw new Error("Usage: forgerelay config set <logical-path> <value> [--project <path>|--global]");
+    }
+    const [logicalPath, ...valueParts] = parsed.rest;
+    const path = generalPathSegments(logicalPath);
+    const rawValue = valueParts.join(" ").trim();
+    if (!rawValue)
+        throw new Error(`Missing value for ${logicalPath}.`);
+    const target = await generalConfigWriteTarget(parsed.scope);
+    const next = readGeneralConfigTarget(target);
+    setNestedValue(next, path, coerceConfigValue(path, rawValue));
+    console.log(`Updated ${writeGeneralConfigTarget(target, next)}`);
+}
+export async function runGeneralConfigUnset(args) {
+    const parsed = parseConfigScopeArgs(args);
+    if (parsed.rest.length !== 1) {
+        throw new Error("Usage: forgerelay config unset <logical-path> [--project <path>|--global]");
+    }
+    const path = generalPathSegments(parsed.rest[0]);
+    const target = await generalConfigWriteTarget(parsed.scope);
+    const next = readGeneralConfigTarget(target);
+    deleteNestedValue(next, path);
+    console.log(`Updated ${writeGeneralConfigTarget(target, next)}`);
+}
+async function generalConfigWriteTarget(scope) {
+    const configDir = forgerelayConfigDir();
+    if (scope.mode === "global") {
+        return { scope: "user", path: join(configDir, "config.json") };
+    }
+    const project = await new ProjectContextResolver(configDir).inspect(scope.projectRoot);
+    return { scope: "project", path: join(project.sharedConfigDir, "config.json") };
+}
+function readGeneralConfigTarget(target) {
+    if (target.scope === "user") {
+        return structuredClone(loadForgeRelayFiles().config);
+    }
+    if (!existsSync(target.path))
+        return {};
+    const parsed = JSON.parse(readFileSync(target.path, "utf8"));
+    if (!isRecord(parsed))
+        throw new Error(`General configuration must be a JSON object: ${target.path}`);
+    return structuredClone(parsed);
+}
+function writeGeneralConfigTarget(target, value) {
+    if (target.scope === "user") {
+        return writeForgeRelayConfig(value);
+    }
+    const validated = parseConfigSource(generalConfigDefinition, "project", value);
+    mkdirSync(dirname(target.path), { recursive: true });
+    writeConfigJsonFile(target.path, validated, 0o600);
+    return target.path;
+}
+function generalPathSegments(logicalPath) {
+    const normalized = logicalPath.trim();
+    const path = normalized.startsWith("config.") ? normalized.slice("config.".length) : normalized;
+    const segments = path.split(".").filter(Boolean);
+    if (segments.length === 0)
+        throw new Error(`Invalid General Config logical path: ${logicalPath}.`);
+    return segments;
+}
+function coerceConfigValue(path, rawValue) {
+    let value;
+    try {
+        value = JSON.parse(rawValue);
+    }
+    catch {
+        value = rawValue;
+    }
+    if (path.length === 1 && path[0] === "publicBaseUrl" && typeof value === "string") {
+        return normalizeOptionalPublicBaseUrl(value);
+    }
+    return value;
+}
+function setNestedValue(target, path, value) {
+    let current = target;
+    for (const segment of path.slice(0, -1)) {
+        const existing = current[segment];
+        if (existing !== undefined && !isRecord(existing)) {
+            throw new Error(`Cannot set config.${path.join(".")}: config.${segment} is not an object.`);
+        }
+        const next = existing ?? {};
+        current[segment] = next;
+        current = next;
+    }
+    current[path[path.length - 1]] = value;
+}
+function deleteNestedValue(target, path) {
+    const parents = [];
+    let current = target;
+    for (const segment of path.slice(0, -1)) {
+        const existing = current[segment];
+        if (!isRecord(existing))
+            return;
+        parents.push({ object: current, key: segment });
+        current = existing;
+    }
+    delete current[path[path.length - 1]];
+    for (const parent of parents.reverse()) {
+        const value = parent.object[parent.key];
+        if (isRecord(value) && Object.keys(value).length === 0)
+            delete parent.object[parent.key];
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}