@guuey/config 0.1.0

package/dist/hosting.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Guuey hosted control-plane types — agent sizing, deployment
+ * lifecycle, and the streaming events Guuey's backend emits during
+ * deploys.
+ *
+ * These types describe Guuey hosting concerns: `DeployTarget`
+ * includes the `'ggui'` vendor literal, `DeployEvent` is streamed by
+ * Guuey's AppSync subscription, and `HostingConfig` is a shape on
+ * `guuey.json`. They lived in `@ggui-ai/protocol` until 2026-04-18
+ * as a historical artefact — they were never vendor-neutral wire
+ * types. Relocated here as part of the overlay-type cleanup in the
+ * two-file manifest model. See
+ * `docs/plans/2026-04-17-ggui-oss-split.md` §8 for the lock.
+ *
+ * Open packages must not import from this module. Consumers today
+ * are all closed (`@guuey-private/types`, `cloud/`). If an open
+ * package ever needs one of these types, re-evaluate the
+ * classification before adding the import — most likely the open
+ * code should not depend on hosted-control-plane shapes at all.
+ */
+/**
+ * Agent container size — describes workload intensity.
+ * Developers pick a size; Guuey maps it to CPU/memory internally.
+ *
+ * Exported as a tuple so `schema.ts` can reuse the same canonical list
+ * when building the `deploy.size` zod enum. Keeping one source of truth
+ * for the literal set avoids the two drifting — the hosting type and
+ * the `guuey.json` overlay must always agree on what sizes exist.
+ */
+export declare const AGENT_SIZES: readonly ["xs", "sm", "md", "lg", "xl"];
+export type AgentSize = (typeof AGENT_SIZES)[number];
+/**
+ * Deployment target — where the agent runs. `'ggui'` is the Guuey
+ * hosted platform; the other literals are recognised but not
+ * first-party.
+ */
+export type DeployTarget = 'ggui' | 'fly' | 'railway' | 'self';
+/**
+ * Deployment lifecycle status — superset of all states.
+ *
+ * Transient states (building, pushing, deploying, health_checking)
+ * exist only in {@link DeployEvent} streams. The backend stores only
+ * settled states (not_deployed, live, failed, stopped, rolled_back).
+ * The persisted enum is intentionally narrower.
+ */
+export type DeploymentStatus = 'not_deployed' | 'building' | 'pushing' | 'deploying' | 'health_checking' | 'live' | 'failed' | 'stopped' | 'rolled_back';
+/**
+ * Progress event emitted during deployment.
+ * Streamed to CLI and Platform Dashboard via AppSync subscription.
+ */
+export interface DeployEvent {
+    /** App being deployed */
+    appId: string;
+    /** Unique build identifier */
+    buildId: string;
+    /** Current deployment phase */
+    status: DeploymentStatus;
+    /** Human-readable progress message */
+    message: string;
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** Deployment version number (set when deploying or later) */
+    version?: number;
+    /** Live endpoint URL (set when status = 'live') */
+    url?: string;
+    /** Error details (set when status = 'failed') */
+    error?: string;
+}
+/**
+ * Hosting configuration field in `guuey.json`.
+ */
+export interface HostingConfig {
+    /** Agent container size (default: 'xs' for free, 'sm' for paid) */
+    size?: AgentSize;
+    /** Deployment target (default: 'ggui') */
+    target?: DeployTarget;
+}
+//# sourceMappingURL=hosting.d.ts.map

package/dist/hosting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosting.d.ts","sourceRoot":"","sources":["../src/hosting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,yCAA0C,CAAC;AACnE,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,GAAG,MAAM,CAAC;AAE/D;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GACxB,cAAc,GACd,UAAU,GACV,SAAS,GACT,WAAW,GACX,iBAAiB,GACjB,MAAM,GACN,QAAQ,GACR,SAAS,GACT,aAAa,CAAC;AAElB;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,yBAAyB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB"}

package/dist/hosting.js

@@ -0,0 +1,30 @@
+/**
+ * Guuey hosted control-plane types — agent sizing, deployment
+ * lifecycle, and the streaming events Guuey's backend emits during
+ * deploys.
+ *
+ * These types describe Guuey hosting concerns: `DeployTarget`
+ * includes the `'ggui'` vendor literal, `DeployEvent` is streamed by
+ * Guuey's AppSync subscription, and `HostingConfig` is a shape on
+ * `guuey.json`. They lived in `@ggui-ai/protocol` until 2026-04-18
+ * as a historical artefact — they were never vendor-neutral wire
+ * types. Relocated here as part of the overlay-type cleanup in the
+ * two-file manifest model. See
+ * `docs/plans/2026-04-17-ggui-oss-split.md` §8 for the lock.
+ *
+ * Open packages must not import from this module. Consumers today
+ * are all closed (`@guuey-private/types`, `cloud/`). If an open
+ * package ever needs one of these types, re-evaluate the
+ * classification before adding the import — most likely the open
+ * code should not depend on hosted-control-plane shapes at all.
+ */
+/**
+ * Agent container size — describes workload intensity.
+ * Developers pick a size; Guuey maps it to CPU/memory internally.
+ *
+ * Exported as a tuple so `schema.ts` can reuse the same canonical list
+ * when building the `deploy.size` zod enum. Keeping one source of truth
+ * for the literal set avoids the two drifting — the hosting type and
+ * the `guuey.json` overlay must always agree on what sizes exist.
+ */
+export const AGENT_SIZES = ['xs', 'sm', 'md', 'lg', 'xl'];

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `@guuey/config` — schemas + loaders for `guuey.json` (the merged
+ * platform config file).
+ *
+ * Post-2026-05-25 slice 7.2: `agent.json` was merged into
+ * `guuey.json#agent`. See `docs/plans/2026-05-25-platform-architecture.md`
+ * §3.1 + §14.2 for the canonical shape + field-by-field migration.
+ *
+ * Consumers: `@guuey/cli`, guuey backend (cliApi handlers,
+ * nocode-runtime, deploy-controller), framework adapters under
+ * `oss/packages/frameworks/*`.
+ */
+export * from './schema.js';
+export * from './agent.js';
+export * from './app.js';
+export * from './ggui.js';
+export * from './loader.js';
+export * from './hosting.js';
+export * from './system-prompt.js';
+export * from './registry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+/**
+ * `@guuey/config` — schemas + loaders for `guuey.json` (the merged
+ * platform config file).
+ *
+ * Post-2026-05-25 slice 7.2: `agent.json` was merged into
+ * `guuey.json#agent`. See `docs/plans/2026-05-25-platform-architecture.md`
+ * §3.1 + §14.2 for the canonical shape + field-by-field migration.
+ *
+ * Consumers: `@guuey/cli`, guuey backend (cliApi handlers,
+ * nocode-runtime, deploy-controller), framework adapters under
+ * `oss/packages/frameworks/*`.
+ */
+export * from './schema.js';
+export * from './agent.js';
+export * from './app.js';
+export * from './ggui.js';
+export * from './loader.js';
+export * from './hosting.js';
+export * from './system-prompt.js';
+export * from './registry.js';

package/dist/loader.d.ts

@@ -0,0 +1,70 @@
+import { GuueyJsonV1 } from './schema.js';
+/** How many parent directories `findGuueyJson` will walk by default. */
+export declare const DEFAULT_FIND_MAX_DEPTH = 8;
+/**
+ * Walk up from `startDir` (default: `process.cwd()`) looking for a
+ * `guuey.json`. Returns the absolute path to the first match, or
+ * `null` if no file is found within `maxDepth` levels.
+ *
+ * Stops when the filesystem root is reached, regardless of `maxDepth`.
+ * Never throws — a missing file is a valid result (not in a guuey project),
+ * not an error.
+ */
+export declare function findGuueyJson(startDir?: string, maxDepth?: number): string | null;
+/**
+ * Read + parse `guuey.json` from `path`. Throws if the file is missing,
+ * unreadable, malformed JSON, or fails schema validation.
+ *
+ * Does NOT resolve `agent.systemPrompt.file` references. Use
+ * {@link loadGuueyJson} for file resolution.
+ */
+export declare function readGuueyJsonFile(path: string): GuueyJsonV1;
+/**
+ * Write a `guuey.json` to disk at `path` with stable 2-space indentation
+ * and a trailing newline.
+ *
+ * Validates the document against {@link GuueyJsonV1} before writing — bad
+ * data never lands on disk.
+ */
+export declare function writeGuueyJsonFile(path: string, doc: GuueyJsonV1): void;
+/**
+ * Result of resolving file-references inside a `guuey.json` document.
+ *
+ * `doc` is the original document (with `{ file: '...' }` references intact);
+ * `resolvedSystemPrompt` is the inlined string the pod will use at boot.
+ */
+export interface ResolvedGuueyJson {
+    /** The original parsed document. */
+    doc: GuueyJsonV1;
+    /**
+     * The resolved system prompt — either the inline string from
+     * `agent.systemPrompt`, or the file contents when it was a
+     * `{ file: '...' }` reference, or `undefined` when no prompt was set
+     * (caller falls back to `GUUEY_DEFAULT_SYSTEM_PROMPT`).
+     */
+    resolvedSystemPrompt: string | undefined;
+    /** Absolute path the document was loaded from (for diagnostics). */
+    sourcePath: string;
+}
+/**
+ * Load + parse `guuey.json` from `path`, then resolve any
+ * `agent.systemPrompt.file` reference into an inlined string.
+ *
+ * The resolved prompt is returned alongside the parsed document so callers
+ * can choose how to use it. The deploy snapshot inlines it into a string
+ * shape; the pod runtime reads the resolved prompt directly.
+ *
+ * Throws if the file is missing, unreadable, malformed, fails schema
+ * validation, OR the systemPrompt.file path resolves to a missing or
+ * unreadable file.
+ */
+export declare function loadGuueyJson(path: string): ResolvedGuueyJson;
+/**
+ * Build the snapshot the deploy upload + pod boot consume.
+ *
+ * Replaces `agent.systemPrompt = { file }` with `agent.systemPrompt = <inlined>`
+ * so the snapshot is self-contained. Returns a deep-cloned document
+ * (caller mutations don't leak back).
+ */
+export declare function buildDeploySnapshot(loaded: ResolvedGuueyJson): GuueyJsonV1;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAuBA,OAAO,EAEL,WAAW,EAEZ,MAAM,aAAa,CAAC;AAErB,wEAAwE;AACxE,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,GAAE,MAAsB,EAChC,QAAQ,GAAE,MAA+B,GACxC,MAAM,GAAG,IAAI,CAUf;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAa3D;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,IAAI,CAIvE;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,oCAAoC;IACpC,GAAG,EAAE,WAAW,CAAC;IACjB;;;;;OAKG;IACH,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAI7D;AAyCD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,GAAG,WAAW,CAM1E"}

package/dist/loader.js

@@ -0,0 +1,144 @@
+/**
+ * Node-only filesystem helpers for `guuey.json`.
+ *
+ * Pure-parse helpers (`parseGuueyJson` / `safeParseGuueyJson`) live in
+ * `./schema.ts` and are safe to import from non-Node contexts. This
+ * module adds the file-resolution layer: reading `guuey.json` from disk,
+ * inlining `agent.systemPrompt.file` references, and producing the
+ * snapshot the deploy upload + pod boot both read.
+ *
+ * Intended callers:
+ *
+ * - `@guuey/cli` — `guuey deploy` reads + inlines + POSTs the snapshot.
+ * - `@guuey/cli` — `guuey pull` writes back from a hosted record.
+ * - Guuey control-plane services that re-validate a submitted snapshot
+ *   server-side before persisting to `AgentDeployment`.
+ * - `nocode-runtime` / `@guuey/host` — pod reads the snapshot back at boot
+ *   (from the env-injected JSON, not directly from disk).
+ *
+ * The open `ggui` ecosystem must NOT import from this package — `guuey.json`
+ * is Guuey platform config, not protocol shape.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { GUUEY_JSON_FILENAME, parseGuueyJson, } from './schema.js';
+/** How many parent directories `findGuueyJson` will walk by default. */
+export const DEFAULT_FIND_MAX_DEPTH = 8;
+/**
+ * Walk up from `startDir` (default: `process.cwd()`) looking for a
+ * `guuey.json`. Returns the absolute path to the first match, or
+ * `null` if no file is found within `maxDepth` levels.
+ *
+ * Stops when the filesystem root is reached, regardless of `maxDepth`.
+ * Never throws — a missing file is a valid result (not in a guuey project),
+ * not an error.
+ */
+export function findGuueyJson(startDir = process.cwd(), maxDepth = DEFAULT_FIND_MAX_DEPTH) {
+    let dir = resolve(startDir);
+    for (let i = 0; i <= maxDepth; i++) {
+        const candidate = join(dir, GUUEY_JSON_FILENAME);
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Read + parse `guuey.json` from `path`. Throws if the file is missing,
+ * unreadable, malformed JSON, or fails schema validation.
+ *
+ * Does NOT resolve `agent.systemPrompt.file` references. Use
+ * {@link loadGuueyJson} for file resolution.
+ */
+export function readGuueyJsonFile(path) {
+    if (!existsSync(path)) {
+        throw new Error(`guuey.json not found at ${path}`);
+    }
+    const raw = readFileSync(path, 'utf-8');
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`guuey.json at ${path} is not valid JSON: ${msg}`);
+    }
+    return parseGuueyJson(json);
+}
+/**
+ * Write a `guuey.json` to disk at `path` with stable 2-space indentation
+ * and a trailing newline.
+ *
+ * Validates the document against {@link GuueyJsonV1} before writing — bad
+ * data never lands on disk.
+ */
+export function writeGuueyJsonFile(path, doc) {
+    const validated = parseGuueyJson(doc);
+    const serialized = JSON.stringify(validated, null, 2) + '\n';
+    writeFileSync(path, serialized, 'utf-8');
+}
+/**
+ * Load + parse `guuey.json` from `path`, then resolve any
+ * `agent.systemPrompt.file` reference into an inlined string.
+ *
+ * The resolved prompt is returned alongside the parsed document so callers
+ * can choose how to use it. The deploy snapshot inlines it into a string
+ * shape; the pod runtime reads the resolved prompt directly.
+ *
+ * Throws if the file is missing, unreadable, malformed, fails schema
+ * validation, OR the systemPrompt.file path resolves to a missing or
+ * unreadable file.
+ */
+export function loadGuueyJson(path) {
+    const doc = readGuueyJsonFile(path);
+    const resolvedSystemPrompt = resolveSystemPrompt(doc, path);
+    return { doc, resolvedSystemPrompt, sourcePath: path };
+}
+/**
+ * Resolve `agent.systemPrompt` to a final string (or undefined).
+ *
+ * - Absent → undefined (caller applies platform default).
+ * - Inline string → returned as-is.
+ * - `{ file }` → resolved relative to `guueyJsonPath`'s directory, file read.
+ *
+ * File paths must be relative + must not escape the project root (no
+ * `..` traversal). Absolute paths are rejected — keeps the snapshot
+ * portable across deploy environments.
+ */
+function resolveSystemPrompt(doc, guueyJsonPath) {
+    const sp = doc.agent.systemPrompt;
+    if (sp === undefined)
+        return undefined;
+    if (typeof sp === 'string')
+        return sp;
+    // sp = { file: '...' }
+    if (isAbsolute(sp.file)) {
+        throw new Error(`agent.systemPrompt.file must be a relative path (got absolute: ${sp.file})`);
+    }
+    if (sp.file.split('/').includes('..')) {
+        throw new Error(`agent.systemPrompt.file must not traverse parent directories (got: ${sp.file})`);
+    }
+    const baseDir = dirname(guueyJsonPath);
+    const resolved = resolve(baseDir, sp.file);
+    if (!existsSync(resolved)) {
+        throw new Error(`agent.systemPrompt.file references missing file: ${sp.file} (resolved to ${resolved})`);
+    }
+    return readFileSync(resolved, 'utf-8');
+}
+/**
+ * Build the snapshot the deploy upload + pod boot consume.
+ *
+ * Replaces `agent.systemPrompt = { file }` with `agent.systemPrompt = <inlined>`
+ * so the snapshot is self-contained. Returns a deep-cloned document
+ * (caller mutations don't leak back).
+ */
+export function buildDeploySnapshot(loaded) {
+    const cloned = JSON.parse(JSON.stringify(loaded.doc));
+    if (loaded.resolvedSystemPrompt !== undefined) {
+        cloned.agent.systemPrompt = loaded.resolvedSystemPrompt;
+    }
+    return cloned;
+}

package/dist/mcp-proxy.d.ts

@@ -0,0 +1,123 @@
+/**
+ * `mcpProxies` — Guuey hosted overlay shape for managed MCP relays.
+ *
+ * Relocated 2026-04-21 from `@ggui-ai/protocol/types/mcp-proxy.ts` as
+ * part of the OSS split §8.2 classification fix. These types describe
+ * a GUUEY HOSTING CONCEPT (a managed proxy that relays MCP calls with
+ * upstream OAuth linking), not a vendor-neutral protocol shape, and
+ * therefore belong in the closed `@guuey/config`
+ * package alongside the rest of `guuey.json`.
+ *
+ * ## The classification decision
+ *
+ * `mcpProxies` is the declaration block a developer adds to
+ * `guuey.json` to tell Guuey hosting: *"on behalf of this project,
+ * relay these external MCP providers, using this OAuth linking
+ * config, exposing these discovered servers."* That is
+ * platform-layer plumbing — Guuey runs the relay, handles the
+ * credential storage, dispatches the discovery — and it does not
+ * describe anything an OSS-only `ggui` deployment emits or consumes.
+ *
+ * Per §8.2: the OSS `ggui` server does NOT read `guuey.json`.
+ * Consumers that need overlay values (the closed `guuey` CLI,
+ * Guuey-hosted Lambdas, the Guuey-internal control-plane UI) are
+ * the only call sites allowed to import from this package. Open
+ * packages that historically read `mcpProxies` (`@ggui-ai/server`'s
+ * Claude-passthrough feature) retain their feature code but inline
+ * the minimal structural shape they actually use — it stays a
+ * Guuey-platform plumbing path, not a protocol contract.
+ *
+ * ## Scope of this module
+ *
+ * - {@link McpProxyLinkingConfig} — upstream OAuth config for
+ *   proxies that relay calls on behalf of an external account
+ *   (e.g. Claude.ai). Keys surface in the Guuey control plane's
+ *   credential-linking UI.
+ * - {@link McpProxyConfig} — a single proxy's discovery + proxy
+ *   URL pattern + optional server filter + optional linking block.
+ * - {@link McpProxiesConfig} — the top-level record keyed by
+ *   proxy id (`claude_ai`, `guuey`, future `omo`...). Exactly the
+ *   shape `guuey.json#mcpProxies` carries.
+ *
+ * ## Vendor-neutral constants stay in `@ggui-ai/protocol`
+ *
+ * Claude.ai-specific constants and discovery-response wire types
+ * (`CLAUDE_AI_*`, `DiscoveredMcpServer`, `ClaudeAiDiscoveryResponse`)
+ * remain in `@ggui-ai/protocol/types/mcp-proxy.ts` — those describe
+ * Anthropic's public API, not Guuey-overlay config.
+ *
+ * ## Strictness
+ *
+ * Zod validation matches the rest of `guuey.json`: strict objects,
+ * non-empty strings, URL validation on linking endpoints. Unknown
+ * keys on nested objects fail parse (prevents silent drift toward
+ * a "what else can we stuff into guuey.json" shape).
+ */
+import { z } from 'zod';
+/**
+ * OAuth linking config for proxies that relay on behalf of an
+ * external account. Omit for proxies where Guuey session auth is
+ * the only identity needed (e.g. a Guuey-native proxy).
+ */
+declare const McpProxyLinkingSchema: z.ZodObject<{
+    authUrl: z.ZodURL;
+    tokenUrl: z.ZodURL;
+    scopes: z.ZodArray<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    manualRedirectUrl: z.ZodOptional<z.ZodURL>;
+}, z.core.$strict>;
+/**
+ * Configuration for a single MCP proxy in `guuey.json#mcpProxies`.
+ *
+ * `discovery` + `proxy` are both URL-valued, but `proxy` is a URL
+ * PATTERN (contains `{server_id}` which is substituted at call
+ * time). Both are validated as URLs — `{server_id}` is accepted
+ * by URL parsers as opaque path segment.
+ */
+declare const McpProxyConfigSchema: z.ZodObject<{
+    discovery: z.ZodURL;
+    proxy: z.ZodURL;
+    linking: z.ZodOptional<z.ZodObject<{
+        authUrl: z.ZodURL;
+        tokenUrl: z.ZodURL;
+        scopes: z.ZodArray<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        manualRedirectUrl: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strict>>;
+    servers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * The `mcpProxies` section of `guuey.json`. Keys are proxy
+ * identifiers (`claude_ai`, `guuey`, future `omo`, …).
+ *
+ * Record shape intentionally — new proxy ids are additive; a fixed
+ * literal union here would force a schema change every time a new
+ * hosted-relay integration lands.
+ */
+export declare const McpProxiesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    discovery: z.ZodURL;
+    proxy: z.ZodURL;
+    linking: z.ZodOptional<z.ZodObject<{
+        authUrl: z.ZodURL;
+        tokenUrl: z.ZodURL;
+        scopes: z.ZodArray<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        manualRedirectUrl: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strict>>;
+    servers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>>;
+/** Linking block type derived from the zod schema. */
+export type McpProxyLinkingConfig = z.infer<typeof McpProxyLinkingSchema>;
+/** Single-proxy config type derived from the zod schema. */
+export type McpProxyConfig = z.infer<typeof McpProxyConfigSchema>;
+/** Full `mcpProxies` overlay type derived from the zod schema. */
+export type McpProxiesConfig = z.infer<typeof McpProxiesSchema>;
+/**
+ * Parse a raw JSON value into a validated {@link McpProxiesConfig}.
+ * Throws a `ZodError` on invalid input.
+ */
+export declare function parseMcpProxies(raw: unknown): McpProxiesConfig;
+/** Safe-parse variant — see {@link parseMcpProxies}. */
+export declare function safeParseMcpProxies(raw: unknown): ReturnType<typeof McpProxiesSchema.safeParse>;
+export {};
+//# sourceMappingURL=mcp-proxy.d.ts.map

package/dist/mcp-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-proxy.d.ts","sourceRoot":"","sources":["../src/mcp-proxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,QAAA,MAAM,qBAAqB;;;;;;kBAuBzB,CAAC;AAEH;;;;;;;GAOG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;kBAmBxB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;mBAG5B,CAAC;AAEF,sDAAsD;AACtD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,4DAA4D;AAC5D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,kEAAkE;AAClE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,CAE9D;AAED,wDAAwD;AACxD,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,OAAO,GACX,UAAU,CAAC,OAAO,gBAAgB,CAAC,SAAS,CAAC,CAE/C"}

package/dist/mcp-proxy.js

@@ -0,0 +1,133 @@
+/**
+ * `mcpProxies` — Guuey hosted overlay shape for managed MCP relays.
+ *
+ * Relocated 2026-04-21 from `@ggui-ai/protocol/types/mcp-proxy.ts` as
+ * part of the OSS split §8.2 classification fix. These types describe
+ * a GUUEY HOSTING CONCEPT (a managed proxy that relays MCP calls with
+ * upstream OAuth linking), not a vendor-neutral protocol shape, and
+ * therefore belong in the closed `@guuey/config`
+ * package alongside the rest of `guuey.json`.
+ *
+ * ## The classification decision
+ *
+ * `mcpProxies` is the declaration block a developer adds to
+ * `guuey.json` to tell Guuey hosting: *"on behalf of this project,
+ * relay these external MCP providers, using this OAuth linking
+ * config, exposing these discovered servers."* That is
+ * platform-layer plumbing — Guuey runs the relay, handles the
+ * credential storage, dispatches the discovery — and it does not
+ * describe anything an OSS-only `ggui` deployment emits or consumes.
+ *
+ * Per §8.2: the OSS `ggui` server does NOT read `guuey.json`.
+ * Consumers that need overlay values (the closed `guuey` CLI,
+ * Guuey-hosted Lambdas, the Guuey-internal control-plane UI) are
+ * the only call sites allowed to import from this package. Open
+ * packages that historically read `mcpProxies` (`@ggui-ai/server`'s
+ * Claude-passthrough feature) retain their feature code but inline
+ * the minimal structural shape they actually use — it stays a
+ * Guuey-platform plumbing path, not a protocol contract.
+ *
+ * ## Scope of this module
+ *
+ * - {@link McpProxyLinkingConfig} — upstream OAuth config for
+ *   proxies that relay calls on behalf of an external account
+ *   (e.g. Claude.ai). Keys surface in the Guuey control plane's
+ *   credential-linking UI.
+ * - {@link McpProxyConfig} — a single proxy's discovery + proxy
+ *   URL pattern + optional server filter + optional linking block.
+ * - {@link McpProxiesConfig} — the top-level record keyed by
+ *   proxy id (`claude_ai`, `guuey`, future `omo`...). Exactly the
+ *   shape `guuey.json#mcpProxies` carries.
+ *
+ * ## Vendor-neutral constants stay in `@ggui-ai/protocol`
+ *
+ * Claude.ai-specific constants and discovery-response wire types
+ * (`CLAUDE_AI_*`, `DiscoveredMcpServer`, `ClaudeAiDiscoveryResponse`)
+ * remain in `@ggui-ai/protocol/types/mcp-proxy.ts` — those describe
+ * Anthropic's public API, not Guuey-overlay config.
+ *
+ * ## Strictness
+ *
+ * Zod validation matches the rest of `guuey.json`: strict objects,
+ * non-empty strings, URL validation on linking endpoints. Unknown
+ * keys on nested objects fail parse (prevents silent drift toward
+ * a "what else can we stuff into guuey.json" shape).
+ */
+import { z } from 'zod';
+/**
+ * OAuth linking config for proxies that relay on behalf of an
+ * external account. Omit for proxies where Guuey session auth is
+ * the only identity needed (e.g. a Guuey-native proxy).
+ */
+const McpProxyLinkingSchema = z.strictObject({
+    /** OAuth authorize endpoint. */
+    authUrl: z.url(),
+    /** OAuth token endpoint. */
+    tokenUrl: z.url(),
+    /**
+     * OAuth scopes to request. Empty array means "use the upstream's
+     * default scope set"; it does NOT mean "no scopes at all."
+     */
+    scopes: z.array(z.string().min(1)),
+    /**
+     * OAuth client_id to use. When omitted, the proxy uses a
+     * well-known public client_id (e.g. Claude Code's registered
+     * client for Claude.ai).
+     */
+    clientId: z.string().min(1).optional(),
+    /**
+     * Manual redirect URL for environments without a localhost
+     * callback. The upstream AS redirects here and renders the
+     * authorization code for the user to copy-paste. Used by
+     * production web flows.
+     */
+    manualRedirectUrl: z.url().optional(),
+});
+/**
+ * Configuration for a single MCP proxy in `guuey.json#mcpProxies`.
+ *
+ * `discovery` + `proxy` are both URL-valued, but `proxy` is a URL
+ * PATTERN (contains `{server_id}` which is substituted at call
+ * time). Both are validated as URLs — `{server_id}` is accepted
+ * by URL parsers as opaque path segment.
+ */
+const McpProxyConfigSchema = z.strictObject({
+    /** Discovery URL — fetches available MCP servers for this proxy. */
+    discovery: z.url(),
+    /**
+     * Proxy URL pattern — `{server_id}` is substituted with the
+     * discovered server id at relay time. Validated as URL; the
+     * placeholder survives URL parsing as an opaque path segment.
+     */
+    proxy: z.url(),
+    /**
+     * OAuth linking config for upstream account linking. Omit for
+     * Guuey-native proxies where the session token is sufficient.
+     */
+    linking: McpProxyLinkingSchema.optional(),
+    /**
+     * Filter which discovered servers to expose, matched by display
+     * name. When omitted, all discovered servers are exposed.
+     */
+    servers: z.array(z.string().min(1)).optional(),
+});
+/**
+ * The `mcpProxies` section of `guuey.json`. Keys are proxy
+ * identifiers (`claude_ai`, `guuey`, future `omo`, …).
+ *
+ * Record shape intentionally — new proxy ids are additive; a fixed
+ * literal union here would force a schema change every time a new
+ * hosted-relay integration lands.
+ */
+export const McpProxiesSchema = z.record(z.string().min(1), McpProxyConfigSchema);
+/**
+ * Parse a raw JSON value into a validated {@link McpProxiesConfig}.
+ * Throws a `ZodError` on invalid input.
+ */
+export function parseMcpProxies(raw) {
+    return McpProxiesSchema.parse(raw);
+}
+/** Safe-parse variant — see {@link parseMcpProxies}. */
+export function safeParseMcpProxies(raw) {
+    return McpProxiesSchema.safeParse(raw);
+}