@guuey/config 0.1.0 → 0.1.2

package/dist/mcp-proxy.d.ts

@@ -1,123 +0,0 @@
-/**
- * `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

@@ -1 +0,0 @@
-{"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

@@ -1,133 +0,0 @@
-/**
- * `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);
-}

package/dist/mcp-servers.d.ts

@@ -1,173 +0,0 @@
-/**
- * `mcpServers` — Guuey hosted overlay shape for relayed MCP server
- * declarations.
- *
- * Relocated 2026-04-21 from `@ggui-ai/protocol/types/credential.ts`
- * as part of the OSS split §8.2 classification fix (mirror of the
- * 2026-04-21 `mcp-proxy` split). The `McpServerAuthConfig` type
- * previously lived in the open protocol package with a docstring
- * that said "Auth config in guuey.json mcpServers entries" — an
- * overlay-shape type in an open package, exactly the pattern the
- * mcp-proxy split closed.
- *
- * ## The classification decision
- *
- * `mcpServers` is the declaration block a developer adds to
- * `guuey.json` to tell Guuey hosting: *"for this project, relay
- * these HTTP MCP servers through the Guuey bridge, authenticating
- * each via the credential stored under this `serviceId`."* That is
- * platform-layer plumbing — the Guuey bridge registers the
- * declaration with the Guuey-hosted WebSocket gateway, and the
- * Guuey mcp-proxy Lambda resolves `auth.serviceId` against the
- * platform's UserCredential store. An OSS-only `ggui serve`
- * deployment has no analog for `auth.serviceId` because there is no
- * Guuey credential store.
- *
- * Per §8.2: the OSS `ggui` server does NOT read `guuey.json`.
- * Consumers that need this overlay value (the closed `guuey` CLI's
- * `guuey dev` command, the closed `@guuey/bridge` package, Guuey-
- * hosted Lambdas) are the only call sites allowed to import from
- * this package. Open packages that historically read
- * `McpServerAuthConfig` (`@ggui-ai/server`'s auth-relay code) now
- * inline the minimal structural shape they actually use.
- *
- * ## Scope of this module
- *
- * - {@link CredentialInjection} + {@link CredentialInjectionConfig}
- *   — runtime injection-mode descriptors, used here as
- *   `McpServerAuth.injection` and also exported from
- *   `@ggui-ai/protocol/types/credential.ts` for cloud-side runtime
- *   consumers. The overlap is intentional and minor (10 lines of
- *   literal-union type) — duplicating inline keeps this private
- *   package dep-minimal (zod-only). If the two ever drift, the
- *   consolidation fix is to add `@ggui-ai/protocol` as a workspace
- *   dep here; today the duplication is cheaper than that cross-
- *   boundary edge.
- * - {@link McpServerAuthConfig} — auth block on a single
- *   `mcpServers` entry. `serviceId` references the Guuey
- *   credential store; `preInject` + `injection` tune how the relay
- *   writes the placeholder.
- * - {@link McpServerEntryConfig} — a single mcpServers entry
- *   (`{ url, auth? }`). `url` is the HTTP MCP server endpoint.
- * - {@link McpServersConfig} — the top-level record keyed by MCP
- *   server name (`gmail`, `calendar`, future `slack`, …). Exactly
- *   the shape `guuey.json#mcpServers` carries.
- *
- * ## Strictness
- *
- * Zod validation matches the rest of `guuey.json`: strict objects,
- * non-empty strings, URL validation on `url`. 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';
-/**
- * Injection mode — how the Guuey mcp-proxy splices the resolved
- * credential into the outbound HTTP request to the upstream MCP
- * server. Duplicated minor from
- * `@ggui-ai/protocol/types/credential.ts#CredentialInjection`; see
- * module docstring for the duplication rationale.
- */
-declare const CredentialInjectionSchema: z.ZodEnum<{
-    bearer_header: "bearer_header";
-    api_key_header: "api_key_header";
-    query_param: "query_param";
-    custom_header: "custom_header";
-}>;
-/** Full injection config — `mode` + per-mode tunables. */
-declare const CredentialInjectionConfigSchema: z.ZodObject<{
-    mode: z.ZodEnum<{
-        bearer_header: "bearer_header";
-        api_key_header: "api_key_header";
-        query_param: "query_param";
-        custom_header: "custom_header";
-    }>;
-    headerName: z.ZodOptional<z.ZodString>;
-    paramName: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-/**
- * Auth block on a single `mcpServers` entry. All fields are
- * optional at the block level — a server without `auth` is relayed
- * without credential injection (public MCP endpoint).
- */
-declare const McpServerAuthSchema: z.ZodObject<{
-    serviceId: z.ZodString;
-    preInject: z.ZodOptional<z.ZodBoolean>;
-    injection: z.ZodOptional<z.ZodObject<{
-        mode: z.ZodEnum<{
-            bearer_header: "bearer_header";
-            api_key_header: "api_key_header";
-            query_param: "query_param";
-            custom_header: "custom_header";
-        }>;
-        headerName: z.ZodOptional<z.ZodString>;
-        paramName: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-/**
- * A single `mcpServers` entry. `url` is the HTTP MCP server
- * endpoint; `auth` scopes the credential injection.
- */
-declare const McpServerEntrySchema: z.ZodObject<{
-    url: z.ZodURL;
-    auth: z.ZodOptional<z.ZodObject<{
-        serviceId: z.ZodString;
-        preInject: z.ZodOptional<z.ZodBoolean>;
-        injection: z.ZodOptional<z.ZodObject<{
-            mode: z.ZodEnum<{
-                bearer_header: "bearer_header";
-                api_key_header: "api_key_header";
-                query_param: "query_param";
-                custom_header: "custom_header";
-            }>;
-            headerName: z.ZodOptional<z.ZodString>;
-            paramName: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-/**
- * The `mcpServers` section of `guuey.json`. Keys are MCP server
- * display names (`gmail`, `calendar`, future `slack`, …) —
- * arbitrary strings, by design. New servers are additive; a fixed
- * literal union would force a schema change every time a new MCP
- * server integration lands.
- */
-export declare const McpServersSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
-    url: z.ZodURL;
-    auth: z.ZodOptional<z.ZodObject<{
-        serviceId: z.ZodString;
-        preInject: z.ZodOptional<z.ZodBoolean>;
-        injection: z.ZodOptional<z.ZodObject<{
-            mode: z.ZodEnum<{
-                bearer_header: "bearer_header";
-                api_key_header: "api_key_header";
-                query_param: "query_param";
-                custom_header: "custom_header";
-            }>;
-            headerName: z.ZodOptional<z.ZodString>;
-            paramName: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>>;
-/** Runtime injection-mode descriptor type. */
-export type CredentialInjection = z.infer<typeof CredentialInjectionSchema>;
-/** Injection-config block type. */
-export type CredentialInjectionConfig = z.infer<typeof CredentialInjectionConfigSchema>;
-/** Auth-block type on an `mcpServers` entry. */
-export type McpServerAuthConfig = z.infer<typeof McpServerAuthSchema>;
-/** Single-entry type inside the `mcpServers` record. */
-export type McpServerEntryConfig = z.infer<typeof McpServerEntrySchema>;
-/** Full `mcpServers` overlay type derived from the zod schema. */
-export type McpServersConfig = z.infer<typeof McpServersSchema>;
-/**
- * Parse a raw JSON value into a validated {@link McpServersConfig}.
- * Throws a `ZodError` on invalid input.
- */
-export declare function parseMcpServers(raw: unknown): McpServersConfig;
-/** Safe-parse variant — see {@link parseMcpServers}. */
-export declare function safeParseMcpServers(raw: unknown): ReturnType<typeof McpServersSchema.safeParse>;
-export {};
-//# sourceMappingURL=mcp-servers.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-servers.d.ts","sourceRoot":"","sources":["../src/mcp-servers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB;;;;;EAK7B,CAAC;AAEH,0DAA0D;AAC1D,QAAA,MAAM,+BAA+B;;;;;;;;;kBAMnC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;kBA4BvB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;kBAKxB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;mBAG5B,CAAC;AAEF,8CAA8C;AAC9C,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,mCAAmC;AACnC,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,gDAAgD;AAChD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,wDAAwD;AACxD,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,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-servers.js

@@ -1,147 +0,0 @@
-/**
- * `mcpServers` — Guuey hosted overlay shape for relayed MCP server
- * declarations.
- *
- * Relocated 2026-04-21 from `@ggui-ai/protocol/types/credential.ts`
- * as part of the OSS split §8.2 classification fix (mirror of the
- * 2026-04-21 `mcp-proxy` split). The `McpServerAuthConfig` type
- * previously lived in the open protocol package with a docstring
- * that said "Auth config in guuey.json mcpServers entries" — an
- * overlay-shape type in an open package, exactly the pattern the
- * mcp-proxy split closed.
- *
- * ## The classification decision
- *
- * `mcpServers` is the declaration block a developer adds to
- * `guuey.json` to tell Guuey hosting: *"for this project, relay
- * these HTTP MCP servers through the Guuey bridge, authenticating
- * each via the credential stored under this `serviceId`."* That is
- * platform-layer plumbing — the Guuey bridge registers the
- * declaration with the Guuey-hosted WebSocket gateway, and the
- * Guuey mcp-proxy Lambda resolves `auth.serviceId` against the
- * platform's UserCredential store. An OSS-only `ggui serve`
- * deployment has no analog for `auth.serviceId` because there is no
- * Guuey credential store.
- *
- * Per §8.2: the OSS `ggui` server does NOT read `guuey.json`.
- * Consumers that need this overlay value (the closed `guuey` CLI's
- * `guuey dev` command, the closed `@guuey/bridge` package, Guuey-
- * hosted Lambdas) are the only call sites allowed to import from
- * this package. Open packages that historically read
- * `McpServerAuthConfig` (`@ggui-ai/server`'s auth-relay code) now
- * inline the minimal structural shape they actually use.
- *
- * ## Scope of this module
- *
- * - {@link CredentialInjection} + {@link CredentialInjectionConfig}
- *   — runtime injection-mode descriptors, used here as
- *   `McpServerAuth.injection` and also exported from
- *   `@ggui-ai/protocol/types/credential.ts` for cloud-side runtime
- *   consumers. The overlap is intentional and minor (10 lines of
- *   literal-union type) — duplicating inline keeps this private
- *   package dep-minimal (zod-only). If the two ever drift, the
- *   consolidation fix is to add `@ggui-ai/protocol` as a workspace
- *   dep here; today the duplication is cheaper than that cross-
- *   boundary edge.
- * - {@link McpServerAuthConfig} — auth block on a single
- *   `mcpServers` entry. `serviceId` references the Guuey
- *   credential store; `preInject` + `injection` tune how the relay
- *   writes the placeholder.
- * - {@link McpServerEntryConfig} — a single mcpServers entry
- *   (`{ url, auth? }`). `url` is the HTTP MCP server endpoint.
- * - {@link McpServersConfig} — the top-level record keyed by MCP
- *   server name (`gmail`, `calendar`, future `slack`, …). Exactly
- *   the shape `guuey.json#mcpServers` carries.
- *
- * ## Strictness
- *
- * Zod validation matches the rest of `guuey.json`: strict objects,
- * non-empty strings, URL validation on `url`. 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';
-/**
- * Injection mode — how the Guuey mcp-proxy splices the resolved
- * credential into the outbound HTTP request to the upstream MCP
- * server. Duplicated minor from
- * `@ggui-ai/protocol/types/credential.ts#CredentialInjection`; see
- * module docstring for the duplication rationale.
- */
-const CredentialInjectionSchema = z.enum([
-    'bearer_header',
-    'api_key_header',
-    'query_param',
-    'custom_header',
-]);
-/** Full injection config — `mode` + per-mode tunables. */
-const CredentialInjectionConfigSchema = z.strictObject({
-    mode: CredentialInjectionSchema,
-    /** Header name for `api_key_header` / `custom_header`. Default: `X-API-Key`. */
-    headerName: z.string().min(1).optional(),
-    /** Query param name for `query_param`. Default: `api_key`. */
-    paramName: z.string().min(1).optional(),
-});
-/**
- * Auth block on a single `mcpServers` entry. All fields are
- * optional at the block level — a server without `auth` is relayed
- * without credential injection (public MCP endpoint).
- */
-const McpServerAuthSchema = z.strictObject({
-    /**
-     * Service ID referenced against the Guuey platform's
-     * UserCredential store. This is a Guuey-platform concept — an
-     * OSS-only deployment has no equivalent lookup.
-     */
-    serviceId: z.string().min(1),
-    /**
-     * Pre-inject placeholder before the first upstream request
-     * (skips the 401 → consent → retry dance for cases where the
-     * user has already linked the credential). Default: `false`.
-     */
-    preInject: z.boolean().optional(),
-    /**
-     * Override the injection mode. Falls back to the
-     * `McpServiceConfig` table entry keyed by `serviceId`, which
-     * defaults to `bearer_header`.
-     */
-    injection: CredentialInjectionConfigSchema.optional(),
-    /**
-     * Optional OAuth scope hint forwarded to the hosted bridge at
-     * connect time. The platform consumes this when minting tokens
-     * against the upstream MCP server. Preserved here (2026-04-21)
-     * for wire-compat with `@guuey/bridge`'s existing inline shape,
-     * which flows `auth.scopes` through the bridge WebSocket config
-     * message.
-     */
-    scopes: z.array(z.string().min(1)).optional(),
-});
-/**
- * A single `mcpServers` entry. `url` is the HTTP MCP server
- * endpoint; `auth` scopes the credential injection.
- */
-const McpServerEntrySchema = z.strictObject({
-    /** HTTP MCP server endpoint. */
-    url: z.url(),
-    /** Optional auth block — omit for public endpoints. */
-    auth: McpServerAuthSchema.optional(),
-});
-/**
- * The `mcpServers` section of `guuey.json`. Keys are MCP server
- * display names (`gmail`, `calendar`, future `slack`, …) —
- * arbitrary strings, by design. New servers are additive; a fixed
- * literal union would force a schema change every time a new MCP
- * server integration lands.
- */
-export const McpServersSchema = z.record(z.string().min(1), McpServerEntrySchema);
-/**
- * Parse a raw JSON value into a validated {@link McpServersConfig}.
- * Throws a `ZodError` on invalid input.
- */
-export function parseMcpServers(raw) {
-    return McpServersSchema.parse(raw);
-}
-/** Safe-parse variant — see {@link parseMcpServers}. */
-export function safeParseMcpServers(raw) {
-    return McpServersSchema.safeParse(raw);
-}