@ghostchain1/ghost-config 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GhostChain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,15 @@
-# Temporary Holding Version
+# @ghostchain1/ghost-config
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+@ghostchain1/ghost-config
+
+## Installation
+
+```bash
+npm install @ghostchain1/ghost-config
+```
+
+Part of the [GhostOS](https://github.com/ghostmode25/GhostOS) monorepo.
+
+## License
+
+MIT

package/dist/contracts.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveGhostContractAddress(key: string, env?: Record<string, string | undefined>, legacyVariable?: string): string | undefined;
+export declare function requireGhostContractAddress(key: string, env?: Record<string, string | undefined>, legacyVariable?: string): string;
+//# sourceMappingURL=contracts.d.ts.map

package/dist/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../src/contracts.ts"],"names":[],"mappings":"AAkBA,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,MAAM,EACX,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,EACrD,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,GAAG,SAAS,CAepB;AAED,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,MAAM,EACX,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,EACrD,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAQR"}

package/dist/contracts.js

@@ -0,0 +1,37 @@
+import { resolveGhostNetwork } from "./env.js";
+const NETWORK_PREFIX = {
+    devnet: "DEVNET",
+    testnet: "TESTNET",
+    mainnet: "MAINNET",
+};
+const ADDRESS_PATTERN = /^0x[0-9a-fA-F]{40}$/;
+function normalizeContractKey(key) {
+    const normalized = key.replaceAll("-", "_").toUpperCase();
+    if (!/^[A-Z0-9]+(?:_[A-Z0-9]+)*$/.test(normalized)) {
+        throw new Error(`Invalid Ghost contract key "${key}".`);
+    }
+    return normalized;
+}
+export function resolveGhostContractAddress(key, env = process.env, legacyVariable) {
+    const network = resolveGhostNetwork(env);
+    const contractKey = normalizeContractKey(key);
+    const scopedVariable = `${NETWORK_PREFIX[network]}_${contractKey}_ADDRESS`;
+    const value = env[scopedVariable] ??
+        (network === "devnet" && legacyVariable ? env[legacyVariable] : undefined);
+    if (value === undefined || value.trim() === "") {
+        return undefined;
+    }
+    if (!ADDRESS_PATTERN.test(value)) {
+        throw new Error(`${scopedVariable} must contain a 20-byte hexadecimal address.`);
+    }
+    return value;
+}
+export function requireGhostContractAddress(key, env = process.env, legacyVariable) {
+    const address = resolveGhostContractAddress(key, env, legacyVariable);
+    if (!address || /^0x0{40}$/i.test(address)) {
+        const network = resolveGhostNetwork(env);
+        const variable = `${NETWORK_PREFIX[network]}_${normalizeContractKey(key)}_ADDRESS`;
+        throw new Error(`${variable} must be set to a deployed contract address.`);
+    }
+    return address;
+}

package/dist/env.d.ts

@@ -0,0 +1,35 @@
+import { type GhostChainEndpoints, type GhostChainKey } from "@ghostchain1/ghost-chain-registry";
+export declare const GHOST_NETWORKS: readonly ["devnet", "testnet", "mainnet"];
+export type GhostNetwork = (typeof GHOST_NETWORKS)[number];
+export type GhostRuntimeEndpoints = Record<Exclude<GhostChainKey, "ghostl3-litvybz">, GhostChainEndpoints> & Partial<Record<"ghostl3-litvybz", GhostChainEndpoints>>;
+export interface GhostRuntimeConfig {
+    network: GhostNetwork;
+    chainId: number;
+    /**
+     * Chain IDs for the ACTIVE network — resolved from the nine-network matrix
+     * (plus the LitVybz app-chain identity). Not the mainnet GHOST_CHAIN_IDS
+     * constants: devnet/testnet/mainnet each have their own L1/L2/L3 IDs.
+     */
+    chainIds: {
+        ghostchain: number;
+        ghostl2: number;
+        ghostl3: number;
+        "ghostl3-litvybz": number;
+    };
+    endpoints: GhostRuntimeEndpoints;
+    rpcUrl: string;
+    wsUrl: string;
+    explorerUrl?: string;
+    apiUrl?: string;
+    gatewayUrl?: string;
+    authUrl?: string;
+    postgresHost: string;
+    postgresPort: number;
+    redisUrl: string;
+}
+export declare function resolveGhostNetwork(env?: Record<string, string | undefined>): GhostNetwork;
+export declare function createGhostRuntimeConfig(env?: Record<string, string | undefined>): GhostRuntimeConfig;
+export declare function requireGhostChainEndpoints(config: Pick<GhostRuntimeConfig, "endpoints" | "network">, key: GhostChainKey): GhostChainEndpoints;
+export declare function logActiveGhostNetwork(network: GhostNetwork, log?: (message: string) => void): void;
+export declare const env: GhostRuntimeConfig;
+//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,mBAAmB,EACxB,KAAK,aAAa,EACnB,MAAM,mCAAmC,CAAC;AAE3C,eAAO,MAAM,cAAc,2CAA4C,CAAC;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAC3D,MAAM,MAAM,qBAAqB,GAAG,MAAM,CACxC,OAAO,CAAC,aAAa,EAAE,iBAAiB,CAAC,EACzC,mBAAmB,CACpB,GACC,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC;AAE1D,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,QAAQ,EAAE;QACR,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,iBAAiB,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,SAAS,EAAE,qBAAqB,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAkBD,wBAAgB,mBAAmB,CACjC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,YAAY,CAgCd;AA2KD,wBAAgB,wBAAwB,CACtC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,kBAAkB,CAwDpB;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,WAAW,GAAG,SAAS,CAAC,EACzD,GAAG,EAAE,aAAa,GACjB,mBAAmB,CAUrB;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,YAAY,EACrB,GAAG,GAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAmB,GAC5C,IAAI,CAEN;AAED,eAAO,MAAM,GAAG,oBAA6B,CAAC"}

package/dist/env.js

@@ -0,0 +1,219 @@
+import { GHOST_CHAIN_IDS, GHOST_CHAIN_KEYS, GHOST_TARGET_CHAIN_IDS, getChainByKey, } from "@ghostchain1/ghost-chain-registry";
+export const GHOST_NETWORKS = ["devnet", "testnet", "mainnet"];
+const NETWORK_PREFIX = {
+    devnet: "DEVNET",
+    testnet: "TESTNET",
+    mainnet: "MAINNET",
+};
+const CORE_CHAIN_KEYS = ["ghostchain", "ghostl2", "ghostl3"];
+function hasValue(value) {
+    return value !== undefined && value.trim() !== "";
+}
+function firstValue(...values) {
+    return values.find(hasValue);
+}
+export function resolveGhostNetwork(env = process.env) {
+    const value = env.GHOST_NETWORK;
+    if (!hasValue(value)) {
+        const legacyEnvironment = firstValue(env.GHOST_ENV, env.ENVIRONMENT, env.NET_ENV);
+        if (env.NODE_ENV === "production" ||
+            legacyEnvironment === "testnet" ||
+            legacyEnvironment === "mainnet") {
+            throw new Error("GHOST_NETWORK must be explicitly set to devnet, testnet, or mainnet outside local devnet.");
+        }
+        return "devnet";
+    }
+    if (!GHOST_NETWORKS.includes(value)) {
+        throw new Error(`Invalid GHOST_NETWORK "${value}". Allowed values: ${GHOST_NETWORKS.join(", ")}.`);
+    }
+    const network = value;
+    for (const marker of [env.GHOST_ENV, env.ENVIRONMENT, env.NET_ENV]) {
+        if (hasValue(marker) &&
+            GHOST_NETWORKS.includes(marker) &&
+            marker !== network) {
+            throw new Error(`GHOST_NETWORK=${network} conflicts with environment marker ${marker}.`);
+        }
+    }
+    return network;
+}
+function parseUrl(value, variable, allowedProtocols, network) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error(`${variable} must be a valid absolute URL.`);
+    }
+    if (!allowedProtocols.includes(parsed.protocol)) {
+        throw new Error(`${variable} must use ${allowedProtocols.join(" or ")}; received ${parsed.protocol}.`);
+    }
+    if (network === "mainnet" &&
+        [
+            "localhost",
+            "127.0.0.1",
+            "::1",
+            "[::1]",
+            "192.168.122.205",
+            "10.50.10.103",
+            "10.50.10.131",
+            "10.50.20.186",
+            "10.50.30.174",
+        ].includes(parsed.hostname)) {
+        throw new Error(`${variable} cannot point to a devnet or testnet endpoint on mainnet.`);
+    }
+    return value;
+}
+function resolveChainEndpoint(key, network, env) {
+    const chain = getChainByKey(key);
+    const prefix = NETWORK_PREFIX[network];
+    const chainName = key.replaceAll("-", "_").toUpperCase();
+    const rpcVariable = `${prefix}_${chainName}_RPC_URL`;
+    const wsVariable = `${prefix}_${chainName}_WS_URL`;
+    const explorerVariable = `${prefix}_${chainName}_EXPLORER_URL`;
+    const rpcUrl = firstValue(key === "ghostchain" ? env[`${prefix}_RPC_URL`] : undefined, env[rpcVariable], network === "devnet"
+        ? (env[chain.rpcEnvVar] ??
+            (key === "ghostl3-litvybz" ? env.L3_RPC_URL : undefined) ??
+            chain.defaultRpcUrl)
+        : undefined);
+    const wsUrl = firstValue(key === "ghostchain" ? env[`${prefix}_WS_URL`] : undefined, env[wsVariable], network === "devnet"
+        ? (env[chain.wsEnvVar] ??
+            (key === "ghostl3-litvybz" ? env.L3_WS_URL : undefined) ??
+            chain.defaultWsUrl)
+        : undefined);
+    const explorerUrl = firstValue(key === "ghostchain" ? env[`${prefix}_EXPLORER_URL`] : undefined, env[explorerVariable], network === "devnet"
+        ? (env[chain.explorerEnvVar] ??
+            (key === "ghostl3-litvybz" ? env.L3_EXPLORER_URL : undefined) ??
+            chain.defaultExplorerUrl)
+        : undefined);
+    if (key === "ghostl3-litvybz" && !hasValue(rpcUrl) && !hasValue(wsUrl)) {
+        return undefined;
+    }
+    if (!hasValue(rpcUrl)) {
+        throw new Error(`Missing ${rpcVariable}${key === "ghostchain" ? ` or ${prefix}_RPC_URL` : ""} for GHOST_NETWORK=${network}.`);
+    }
+    if (!hasValue(wsUrl)) {
+        throw new Error(`Missing ${wsVariable}${key === "ghostchain" ? ` or ${prefix}_WS_URL` : ""} for GHOST_NETWORK=${network}.`);
+    }
+    const endpoints = {
+        rpcUrl: parseUrl(rpcUrl, rpcVariable, ["http:", "https:"], network),
+        wsUrl: parseUrl(wsUrl, wsVariable, ["ws:", "wss:"], network),
+    };
+    if (hasValue(explorerUrl)) {
+        endpoints.explorerUrl = parseUrl(explorerUrl, explorerVariable, ["http:", "https:"], network);
+    }
+    return endpoints;
+}
+function resolveNetworkChainId(network, env) {
+    const variable = `${NETWORK_PREFIX[network]}_CHAIN_ID`;
+    // Canonical L1 identity for this environment (nine-network matrix).
+    const expected = GHOST_TARGET_CHAIN_IDS[network].ghostchain;
+    const value = env[variable];
+    if (!hasValue(value)) {
+        if (network !== "devnet") {
+            throw new Error(`${variable} is required for GHOST_NETWORK=${network}.`);
+        }
+        return expected;
+    }
+    const chainId = Number(value);
+    if (!Number.isSafeInteger(chainId) || chainId !== expected) {
+        throw new Error(`${variable} must match the registered GhostChain L1 chain ID for ${network} (${expected}); received "${value}".`);
+    }
+    return chainId;
+}
+/**
+ * Per-network chain IDs for the active network — resolved from the
+ * nine-network matrix with `GHOST_{ENV}_{LAYER}_CHAIN_ID` overrides for
+ * in-flight re-provisions. `L1_CHAIN_ID` / `{PREFIX}_CHAIN_ID` remains the
+ * canonical L1 override (validated by resolveNetworkChainId).
+ */
+function resolveChainIdsForNetwork(network, env) {
+    const override = (suffix) => {
+        const raw = env[`GHOST_${network.toUpperCase()}_${suffix}`];
+        if (!hasValue(raw))
+            return undefined;
+        const parsed = Number(raw);
+        return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+    };
+    return {
+        ...GHOST_CHAIN_IDS,
+        ghostchain: resolveNetworkChainId(network, env),
+        ghostl2: override("L2_CHAIN_ID") ?? GHOST_TARGET_CHAIN_IDS[network].ghostl2,
+        ghostl3: override("L3_CHAIN_ID") ?? GHOST_TARGET_CHAIN_IDS[network].ghostl3,
+    };
+}
+function assertMainnetConfiguration(env) {
+    const unsafeName = /(?:PRIVATE_KEY|MNEMONIC|SEED|SIGNING_KEY|FAUCET|MOCK|TEST_TOKEN|DATABASE|DEBUG|API_KEY|SECRET|CREDENTIAL|CONTRACT|ADDRESS)/i;
+    const unsafeSetting = Object.entries(env).find(([name, value]) => {
+        if (!hasValue(value)) {
+            return false;
+        }
+        return ((/^(?:DEVNET|TESTNET)_/i.test(name) && unsafeName.test(name)) ||
+            (/_(?:DEVNET|TESTNET)$/i.test(name) && unsafeName.test(name)));
+    });
+    if (unsafeSetting) {
+        throw new Error(`${unsafeSetting[0]} is a devnet/testnet-only setting and cannot be present when GHOST_NETWORK=mainnet.`);
+    }
+}
+export function createGhostRuntimeConfig(env = process.env) {
+    const network = resolveGhostNetwork(env);
+    if (network === "mainnet" && env.GHOST_PRODUCTION !== "true") {
+        throw new Error("GHOST_PRODUCTION=true is required when GHOST_NETWORK=mainnet.");
+    }
+    if (network === "mainnet") {
+        assertMainnetConfiguration(env);
+    }
+    const endpoints = {};
+    for (const key of GHOST_CHAIN_KEYS) {
+        const endpoint = resolveChainEndpoint(key, network, env);
+        if (endpoint) {
+            endpoints[key] = endpoint;
+        }
+    }
+    for (const key of CORE_CHAIN_KEYS) {
+        if (!endpoints[key]) {
+            throw new Error(`Missing ${network} RPC configuration for ${key}.`);
+        }
+    }
+    const prefix = NETWORK_PREFIX[network];
+    const chainIds = resolveChainIdsForNetwork(network, env);
+    const chainId = chainIds.ghostchain;
+    const l1Endpoints = endpoints.ghostchain;
+    const apiUrl = env[`${prefix}_API_URL`] ??
+        (network === "devnet" ? (env.API_URL ?? env.NEXT_PUBLIC_API_URL) : undefined);
+    const gatewayUrl = env[`${prefix}_GATEWAY_URL`] ?? (network === "devnet" ? env.GATEWAY_URL : undefined);
+    const authUrl = env[`${prefix}_AUTH_URL`] ?? (network === "devnet" ? env.NEXT_PUBLIC_AUTH_URL : undefined);
+    return {
+        network,
+        chainId,
+        chainIds,
+        endpoints,
+        rpcUrl: l1Endpoints.rpcUrl,
+        wsUrl: l1Endpoints.wsUrl,
+        explorerUrl: l1Endpoints.explorerUrl,
+        apiUrl: hasValue(apiUrl)
+            ? parseUrl(apiUrl, `${prefix}_API_URL`, ["http:", "https:"], network)
+            : undefined,
+        gatewayUrl: hasValue(gatewayUrl)
+            ? parseUrl(gatewayUrl, `${prefix}_GATEWAY_URL`, ["http:", "https:"], network)
+            : undefined,
+        authUrl: hasValue(authUrl)
+            ? parseUrl(authUrl, `${prefix}_AUTH_URL`, ["http:", "https:"], network)
+            : undefined,
+        postgresHost: env.POSTGRES_HOST ?? "127.0.0.1",
+        postgresPort: Number(env.POSTGRES_PORT ?? "5432"),
+        redisUrl: env.REDIS_URL ?? "redis://127.0.0.1:6379",
+    };
+}
+export function requireGhostChainEndpoints(config, key) {
+    const endpoints = config.endpoints[key];
+    if (!endpoints) {
+        const prefix = NETWORK_PREFIX[config.network];
+        const chainName = key.replaceAll("-", "_").toUpperCase();
+        throw new Error(`${prefix}_${chainName}_RPC_URL and ${prefix}_${chainName}_WS_URL are required to use ${key} on ${config.network}.`);
+    }
+    return endpoints;
+}
+export function logActiveGhostNetwork(network, log = console.info) {
+    log(`Active GhostOS network: ${network}`);
+}
+export const env = createGhostRuntimeConfig();

package/dist/ghostos.d.ts

@@ -0,0 +1,63 @@
+import { type GhostNetwork } from "./env.js";
+/**
+ * GhostOS namespaced configuration (`GHOSTOS_*`).
+ *
+ * This module is a compatibility adapter, not a second configuration system:
+ * every `GHOSTOS_*` key falls back to the pre-existing variable that already
+ * owns the setting (for example `GHOST_NETWORK`, `GHOST_AI_LLM_URL`,
+ * `GHOST_ROOT`) so current deployments keep working unchanged. When both are
+ * set, the `GHOSTOS_*` name wins and invalid values are surfaced instead of
+ * silently ignored.
+ *
+ * Secrets are never resolved here; secret material is referenced by file path
+ * (systemd `LoadCredential=`) or injected by Vault at runtime.
+ */
+export declare const GHOSTOS_ENVIRONMENTS: readonly ["development", "test", "staging", "production"];
+export type GhostOSEnvironment = (typeof GHOSTOS_ENVIRONMENTS)[number];
+/** Autonomy levels understood by the GhostOS assistant (`ghostos/assistant`). */
+export type GhostAiAutonomy = "L0" | "L1" | "L2";
+/**
+ * Map a `GHOSTOS_AI_AUTONOMY_MODE` value onto the assistant's `L0|L1|L2`.
+ * Unknown values throw: silently defaulting an autonomy level would be a
+ * safety bug.
+ */
+export declare function toGhostAiAutonomy(value: string): GhostAiAutonomy;
+export interface GhostOSConfig {
+    env: GhostOSEnvironment;
+    /** Repository / installation root (`GHOSTOS_ROOT`, legacy `GHOST_ROOT`). */
+    root?: string;
+    configDir: string;
+    dataDir: string;
+    logDir: string;
+    api: {
+        host: string;
+        port: number;
+    };
+    ai: {
+        enabled: boolean;
+        provider: "local" | "gateway";
+        model?: string;
+        /** OpenAI-compatible endpoint (`GHOSTOS_AI_ENDPOINT`, legacy `GHOST_AI_LLM_URL`). */
+        endpoint?: string;
+        autonomy: GhostAiAutonomy;
+    };
+    serviceDiscoveryEnabled: boolean;
+    healthCheckEnabled: boolean;
+    metricsEnabled: boolean;
+    /** Optional event bus / NATS URL (`GHOSTOS_EVENT_BUS_URL`). */
+    eventBusUrl?: string;
+    chain: {
+        /** Reuses the existing chain-routing resolver (`GHOSTOS_CHAIN_ENV`, legacy `GHOST_NETWORK`). */
+        env: GhostNetwork;
+        rpcUrl?: string;
+        chainId?: number;
+    };
+}
+export declare function resolveGhostOSConfig(env?: Record<string, string | undefined>): GhostOSConfig;
+/**
+ * Variables a GhostOS host must provide before core services start, when the
+ * corresponding feature is enabled. Used by deployment preflight checks; this
+ * list is additive and does not change service-level validation.
+ */
+export declare function requiredGhostOSVariables(config: GhostOSConfig): string[];
+//# sourceMappingURL=ghostos.d.ts.map

package/dist/ghostos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ghostos.d.ts","sourceRoot":"","sources":["../src/ghostos.ts"],"names":[],"mappings":"AACA,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,UAAU,CAAC;AAElE;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,oBAAoB,2DAA4D,CAAC;AAC9F,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvE,iFAAiF;AACjF,MAAM,MAAM,eAAe,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAcjD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAQhE;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,kBAAkB,CAAC;IACxB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACpC,EAAE,EAAE;QACF,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;QAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,qFAAqF;QACrF,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,eAAe,CAAC;KAC3B,CAAC;IACF,uBAAuB,EAAE,OAAO,CAAC;IACjC,kBAAkB,EAAE,OAAO,CAAC;IAC5B,cAAc,EAAE,OAAO,CAAC;IACxB,+DAA+D;IAC/D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE;QACL,gGAAgG;QAChG,GAAG,EAAE,YAAY,CAAC;QAClB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAMD,wBAAgB,oBAAoB,CAClC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,aAAa,CAqFf;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,EAAE,CAYxE"}

package/dist/ghostos.js

@@ -0,0 +1,163 @@
+import { environmentOfChainId } from "@ghostchain1/ghost-chain-registry";
+import { resolveGhostNetwork } from "./env.js";
+/**
+ * GhostOS namespaced configuration (`GHOSTOS_*`).
+ *
+ * This module is a compatibility adapter, not a second configuration system:
+ * every `GHOSTOS_*` key falls back to the pre-existing variable that already
+ * owns the setting (for example `GHOST_NETWORK`, `GHOST_AI_LLM_URL`,
+ * `GHOST_ROOT`) so current deployments keep working unchanged. When both are
+ * set, the `GHOSTOS_*` name wins and invalid values are surfaced instead of
+ * silently ignored.
+ *
+ * Secrets are never resolved here; secret material is referenced by file path
+ * (systemd `LoadCredential=`) or injected by Vault at runtime.
+ */
+export const GHOSTOS_ENVIRONMENTS = ["development", "test", "staging", "production"];
+const AUTONOMY_ALIASES = {
+    l0: "L0",
+    l1: "L1",
+    l2: "L2",
+    // Directive-specified friendly aliases mapped onto the assistant's levels.
+    suggest: "L0",
+    observe: "L0",
+    approval_required: "L0",
+    develop: "L1",
+    merge: "L2",
+};
+/**
+ * Map a `GHOSTOS_AI_AUTONOMY_MODE` value onto the assistant's `L0|L1|L2`.
+ * Unknown values throw: silently defaulting an autonomy level would be a
+ * safety bug.
+ */
+export function toGhostAiAutonomy(value) {
+    const mapped = AUTONOMY_ALIASES[value.trim().toLowerCase()];
+    if (!mapped) {
+        throw new Error(`Unknown autonomy level "${value}". Allowed: ${Object.keys(AUTONOMY_ALIASES).join(", ")}.`);
+    }
+    return mapped;
+}
+function hasValue(value) {
+    return value !== undefined && value.trim() !== "";
+}
+export function resolveGhostOSConfig(env = process.env) {
+    // The existing resolver already validates GHOST_NETWORK and its legacy
+    // markers, and requires explicit network selection outside local devnet.
+    const chainEnv = resolveGhostNetwork({
+        ...env,
+        GHOST_NETWORK: firstValue(env.GHOSTOS_CHAIN_ENV, env.GHOST_NETWORK) ?? env.GHOST_NETWORK,
+    });
+    const aiProvider = firstValue(env.GHOSTOS_AI_PROVIDER, "local");
+    if (aiProvider !== "local" && aiProvider !== "gateway") {
+        throw new Error(`GHOSTOS_AI_PROVIDER must be local or gateway; received "${aiProvider}".`);
+    }
+    const autonomyValue = firstValue(env.GHOSTOS_AI_AUTONOMY_MODE, "approval_required");
+    const rpcUrl = firstValue(env.GHOSTOS_RPC_URL, env.RPC_URL);
+    const chainIdRaw = firstValue(env.GHOSTOS_CHAIN_ID, env.CHAIN_ID);
+    let chainId;
+    if (hasValue(chainIdRaw)) {
+        chainId = Number(chainIdRaw);
+        if (!Number.isSafeInteger(chainId) || chainId <= 0) {
+            throw new Error(`GHOSTOS_CHAIN_ID must be a positive integer; received "${chainIdRaw}".`);
+        }
+        // Nine-network enforcement: the configured chain ID must be one of the
+        // nine active GhostOS identities AND must belong to the configured chain
+        // environment. Obsolete legacy IDs (901/903) and cross-environment pairings
+        // (e.g. mainnet chain ID on devnet) are rejected here.
+        const idEnvironment = environmentOfChainId(chainId);
+        if (!idEnvironment) {
+            throw new Error(`GHOSTOS_CHAIN_ID=${chainId} is not a registered GhostOS chain ID (nine-network matrix); ` +
+                `legacy fixed IDs 901/903 are obsolete.`);
+        }
+        if (idEnvironment !== chainEnv) {
+            throw new Error(`GHOSTOS_CHAIN_ID=${chainId} belongs to ${idEnvironment} but GHOSTOS_CHAIN_ENV=${chainEnv}; ` +
+                `cross-environment chain IDs are forbidden.`);
+        }
+    }
+    const config = {
+        env: parseEnvironment(env),
+        configDir: firstValue(env.GHOSTOS_CONFIG_DIR, "/etc/ghostos"),
+        dataDir: firstValue(env.GHOSTOS_DATA_DIR, "/var/lib/ghostos"),
+        logDir: firstValue(env.GHOSTOS_LOG_DIR, "/var/log/ghostos"),
+        api: {
+            host: firstValue(env.GHOSTOS_API_HOST, "127.0.0.1"),
+            port: hasValue(env.GHOSTOS_API_PORT)
+                ? parsePort("GHOSTOS_API_PORT", env.GHOSTOS_API_PORT)
+                : 8080,
+        },
+        ai: {
+            enabled: hasValue(env.GHOSTOS_AI_ENABLED)
+                ? parseBoolean("GHOSTOS_AI_ENABLED", env.GHOSTOS_AI_ENABLED)
+                : true,
+            provider: aiProvider,
+            endpoint: firstValue(env.GHOSTOS_AI_ENDPOINT, env.GHOST_AI_LLM_URL),
+            autonomy: toGhostAiAutonomy(autonomyValue),
+        },
+        serviceDiscoveryEnabled: hasValue(env.GHOSTOS_SERVICE_DISCOVERY_ENABLED)
+            ? parseBoolean("GHOSTOS_SERVICE_DISCOVERY_ENABLED", env.GHOSTOS_SERVICE_DISCOVERY_ENABLED)
+            : true,
+        healthCheckEnabled: hasValue(env.GHOSTOS_HEALTH_CHECK_ENABLED)
+            ? parseBoolean("GHOSTOS_HEALTH_CHECK_ENABLED", env.GHOSTOS_HEALTH_CHECK_ENABLED)
+            : true,
+        metricsEnabled: hasValue(env.GHOSTOS_METRICS_ENABLED)
+            ? parseBoolean("GHOSTOS_METRICS_ENABLED", env.GHOSTOS_METRICS_ENABLED)
+            : true,
+        eventBusUrl: firstValue(env.GHOSTOS_EVENT_BUS_URL, env.NATS_URL),
+        chain: {
+            env: chainEnv,
+            rpcUrl,
+            chainId,
+        },
+    };
+    const root = firstValue(env.GHOSTOS_ROOT, env.GHOST_ROOT);
+    if (hasValue(root))
+        config.root = root;
+    const model = firstValue(env.GHOSTOS_AI_MODEL);
+    if (hasValue(model))
+        config.ai.model = model;
+    return config;
+}
+/**
+ * Variables a GhostOS host must provide before core services start, when the
+ * corresponding feature is enabled. Used by deployment preflight checks; this
+ * list is additive and does not change service-level validation.
+ */
+export function requiredGhostOSVariables(config) {
+    const required = [];
+    if (config.chain.env !== "devnet" && !hasValue(config.chain.rpcUrl)) {
+        required.push("GHOSTOS_RPC_URL");
+    }
+    if (config.chain.env !== "devnet" && config.chain.chainId === undefined) {
+        required.push("GHOSTOS_CHAIN_ID");
+    }
+    if (config.ai.provider === "gateway" && !hasValue(config.ai.endpoint)) {
+        required.push("GHOSTOS_AI_ENDPOINT");
+    }
+    return required;
+}
+function firstValue(...values) {
+    return values.find(hasValue);
+}
+function parseBoolean(name, value) {
+    if (value === "true" || value === "1")
+        return true;
+    if (value === "false" || value === "0")
+        return false;
+    throw new Error(`${name} must be true, false, 1 or 0; received "${value}".`);
+}
+function parsePort(name, value) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`${name} must be an integer 1-65535; received "${value}".`);
+    }
+    return port;
+}
+function parseEnvironment(env) {
+    const value = firstValue(env.GHOSTOS_ENV, env.NODE_ENV, "development");
+    if (value === "default")
+        return "development"; // bare `node` runs
+    if (!GHOSTOS_ENVIRONMENTS.includes(value)) {
+        throw new Error(`Invalid environment "${value}". Allowed: ${GHOSTOS_ENVIRONMENTS.join(", ")}.`);
+    }
+    return value;
+}