pikiloop 0.4.0

package/dist/agent/mcp/oauth.js

@@ -0,0 +1,353 @@
+/**
+ * MCP OAuth 2.1 + Dynamic Client Registration subsystem.
+ *
+ * Implements the MCP auth spec flow for remote HTTP MCP servers:
+ *   1. Discover auth server (Protected Resource Metadata + WWW-Authenticate header).
+ *   2. Fetch Authorization Server Metadata.
+ *   3. Register client dynamically (RFC 7591) if no pre-registered client_id.
+ *   4. Drive authorization_code + PKCE — returns auth URL for user's browser.
+ *   5. Exchange code for tokens on callback.
+ *   6. Refresh tokens when expired.
+ *
+ * Tokens are persisted via the token store (setting.json `extensions.mcpTokens`).
+ * State for in-flight authorizations is kept in memory only.
+ */
+import crypto from 'node:crypto';
+import { loadUserConfig, saveUserConfig, } from '../../core/config/user-config.js';
+// ---------------------------------------------------------------------------
+// Token store (setting.json-backed)
+// ---------------------------------------------------------------------------
+export function getMcpToken(serverId) {
+    const cfg = loadUserConfig();
+    return cfg.extensions?.mcpTokens?.[serverId];
+}
+export function saveMcpToken(serverId, token) {
+    const cfg = loadUserConfig();
+    const extensions = cfg.extensions ?? {};
+    const mcpTokens = { ...(extensions.mcpTokens ?? {}) };
+    mcpTokens[serverId] = token;
+    saveUserConfig({ ...cfg, extensions: { ...extensions, mcpTokens } });
+}
+export function deleteMcpToken(serverId) {
+    const cfg = loadUserConfig();
+    const tokens = { ...(cfg.extensions?.mcpTokens ?? {}) };
+    if (!(serverId in tokens))
+        return false;
+    delete tokens[serverId];
+    saveUserConfig({ ...cfg, extensions: { ...cfg.extensions, mcpTokens: tokens } });
+    return true;
+}
+export function hasValidMcpToken(serverId) {
+    const token = getMcpToken(serverId);
+    if (!token?.accessToken)
+        return false;
+    if (token.expiresAt && token.expiresAt < Date.now() + 30_000)
+        return false;
+    return true;
+}
+// ---------------------------------------------------------------------------
+// PKCE helpers
+// ---------------------------------------------------------------------------
+function randomUrlSafe(bytes) {
+    return crypto.randomBytes(bytes).toString('base64url');
+}
+function pkceChallenge(verifier) {
+    return crypto.createHash('sha256').update(verifier).digest('base64url');
+}
+// ---------------------------------------------------------------------------
+// Discovery
+// ---------------------------------------------------------------------------
+async function fetchJson(url, init, timeoutMs = 8_000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { ...init, signal: controller.signal });
+        if (!res.ok)
+            throw new Error(`${url} responded ${res.status}`);
+        return await res.json();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Discover the authorization server for a remote MCP resource and the
+ * canonical `resource` indicator the AS will validate against.
+ *
+ * Strategy:
+ *   1. Try GET {resourceBase}/.well-known/oauth-protected-resource (RFC 9728).
+ *   2. Fall back to probing the MCP endpoint for a 401 with WWW-Authenticate
+ *      and follow the resource_metadata link.
+ *   3. Last resort: treat the origin as the AS and the input URL as the
+ *      canonical resource.
+ */
+async function discoverAuthorizationServer(resourceUrl) {
+    const origin = new URL(resourceUrl).origin;
+    const adopt = (meta) => {
+        const as = meta.authorization_servers?.[0];
+        if (!as)
+            return null;
+        return {
+            authorizationServer: as,
+            canonicalResource: meta.resource || resourceUrl,
+        };
+    };
+    // Strategy 1: Protected Resource Metadata at the origin
+    try {
+        const meta = await fetchJson(`${origin}/.well-known/oauth-protected-resource`);
+        const out = adopt(meta);
+        if (out)
+            return out;
+    }
+    catch { /* try next */ }
+    // Strategy 2: probe resource for WWW-Authenticate, follow resource_metadata
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 8_000);
+        const res = await fetch(resourceUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Accept: 'application/json, text/event-stream' },
+            body: JSON.stringify({ jsonrpc: '2.0', id: 0, method: 'initialize', params: {} }),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (res.status === 401) {
+            const auth = res.headers.get('www-authenticate') || '';
+            // A header may declare resource_metadata twice; prefer the most specific
+            // (last) match since servers commonly emit both origin-level and
+            // per-resource paths in one header.
+            const matches = [...auth.matchAll(/resource_metadata="([^"]+)"/gi)];
+            const link = matches.length ? matches[matches.length - 1][1] : null;
+            if (link) {
+                const meta = await fetchJson(link);
+                const out = adopt(meta);
+                if (out)
+                    return out;
+            }
+        }
+    }
+    catch { /* fall through */ }
+    // Last resort: assume the resource origin is itself the authorization server
+    return { authorizationServer: origin, canonicalResource: resourceUrl };
+}
+async function fetchAuthorizationServerMetadata(issuer) {
+    // Try OAuth AS metadata first (RFC 8414), then OIDC fallback
+    const candidates = [
+        `${issuer.replace(/\/$/, '')}/.well-known/oauth-authorization-server`,
+        `${issuer.replace(/\/$/, '')}/.well-known/openid-configuration`,
+    ];
+    let lastErr;
+    for (const url of candidates) {
+        try {
+            return await fetchJson(url);
+        }
+        catch (e) {
+            lastErr = e;
+        }
+    }
+    throw new Error(`no AS metadata at ${issuer}: ${lastErr}`);
+}
+async function registerClient(registrationEndpoint, redirectUri, clientName) {
+    const body = {
+        client_name: clientName,
+        redirect_uris: [redirectUri],
+        grant_types: ['authorization_code', 'refresh_token'],
+        response_types: ['code'],
+        token_endpoint_auth_method: 'none',
+        application_type: 'native',
+    };
+    return fetchJson(registrationEndpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+}
+async function resolveEndpoints(auth, resourceUrl) {
+    if (auth.type !== 'mcp-oauth')
+        throw new Error('not an mcp-oauth auth spec');
+    if (auth.authorizationEndpoint && auth.tokenEndpoint) {
+        return {
+            authorizationEndpoint: auth.authorizationEndpoint,
+            tokenEndpoint: auth.tokenEndpoint,
+            registrationEndpoint: auth.registrationEndpoint,
+            canonicalResource: resourceUrl,
+        };
+    }
+    const discovered = await discoverAuthorizationServer(resourceUrl);
+    const meta = await fetchAuthorizationServerMetadata(discovered.authorizationServer);
+    return {
+        authorizationEndpoint: meta.authorization_endpoint,
+        tokenEndpoint: meta.token_endpoint,
+        registrationEndpoint: meta.registration_endpoint,
+        issuer: meta.issuer,
+        canonicalResource: discovered.canonicalResource,
+    };
+}
+// ---------------------------------------------------------------------------
+// Pending state (in-memory, short-lived)
+// ---------------------------------------------------------------------------
+const pendingFlows = new Map();
+const PENDING_TTL_MS = 10 * 60 * 1000;
+function sweepPending() {
+    const now = Date.now();
+    for (const [state, flow] of pendingFlows) {
+        if (now - flow.createdAt > PENDING_TTL_MS)
+            pendingFlows.delete(state);
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API: start authorization, handle callback, refresh
+// ---------------------------------------------------------------------------
+/**
+ * Kick off an OAuth flow for the given MCP server.
+ *
+ * @param serverId  The catalog id / installed-extension key.
+ * @param auth      The auth spec from registry.
+ * @param resourceUrl  The MCP server URL (http transport url).
+ * @param redirectUri  Callback URL (http://localhost:<port>/api/extensions/mcp/oauth/callback).
+ * @param clientName  Human-readable client name shown to the provider.
+ */
+export async function startAuthorization(opts) {
+    sweepPending();
+    const { serverId, auth, resourceUrl, redirectUri, clientName } = opts;
+    if (auth.type !== 'mcp-oauth')
+        throw new Error(`server ${serverId} is not mcp-oauth`);
+    const endpoints = await resolveEndpoints(auth, resourceUrl);
+    const canonicalResource = endpoints.canonicalResource;
+    let clientId = auth.clientId;
+    let clientSecret;
+    if (!clientId) {
+        if (!endpoints.registrationEndpoint) {
+            throw new Error(`server ${serverId} has no client_id and no dynamic registration endpoint`);
+        }
+        const reg = await registerClient(endpoints.registrationEndpoint, redirectUri, clientName);
+        clientId = reg.client_id;
+        clientSecret = reg.client_secret;
+    }
+    const state = randomUrlSafe(32);
+    const codeVerifier = randomUrlSafe(48);
+    const codeChallenge = pkceChallenge(codeVerifier);
+    const params = new URLSearchParams({
+        response_type: 'code',
+        client_id: clientId,
+        redirect_uri: redirectUri,
+        state,
+        code_challenge: codeChallenge,
+        code_challenge_method: 'S256',
+        resource: canonicalResource,
+    });
+    if (auth.scopes?.length)
+        params.set('scope', auth.scopes.join(' '));
+    const authUrl = `${endpoints.authorizationEndpoint}${endpoints.authorizationEndpoint.includes('?') ? '&' : '?'}${params.toString()}`;
+    pendingFlows.set(state, {
+        state,
+        codeVerifier,
+        serverId,
+        resource: canonicalResource,
+        clientId,
+        clientSecret,
+        tokenEndpoint: endpoints.tokenEndpoint,
+        authorizationEndpoint: endpoints.authorizationEndpoint,
+        registrationEndpoint: endpoints.registrationEndpoint,
+        redirectUri,
+        createdAt: Date.now(),
+    });
+    return { authUrl, state };
+}
+/**
+ * Exchange the authorization code for tokens and persist the result.
+ */
+export async function completeAuthorization(opts) {
+    const flow = pendingFlows.get(opts.state);
+    if (!flow)
+        throw new Error('unknown or expired oauth state');
+    pendingFlows.delete(opts.state);
+    const body = new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: opts.code,
+        redirect_uri: flow.redirectUri,
+        client_id: flow.clientId,
+        code_verifier: flow.codeVerifier,
+        resource: flow.resource,
+    });
+    if (flow.clientSecret)
+        body.set('client_secret', flow.clientSecret);
+    const res = await fetch(flow.tokenEndpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
+        body: body.toString(),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`token exchange failed (${res.status}): ${text.slice(0, 200)}`);
+    }
+    const token = await res.json();
+    const record = {
+        accessToken: token.access_token,
+        tokenType: token.token_type || 'Bearer',
+        refreshToken: token.refresh_token,
+        expiresAt: token.expires_in ? Date.now() + (token.expires_in * 1000) : undefined,
+        scope: token.scope,
+        clientId: flow.clientId,
+        clientSecret: flow.clientSecret,
+        authorizationEndpoint: flow.authorizationEndpoint,
+        tokenEndpoint: flow.tokenEndpoint,
+        registrationEndpoint: flow.registrationEndpoint,
+        resource: flow.resource,
+    };
+    saveMcpToken(flow.serverId, record);
+    return { ok: true, serverId: flow.serverId };
+}
+/**
+ * Refresh an expired token. Returns the updated record or null if refresh failed
+ * (e.g., no refresh_token available, or refresh rejected).
+ */
+export async function refreshMcpToken(serverId) {
+    const token = getMcpToken(serverId);
+    if (!token?.refreshToken)
+        return null;
+    const body = new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: token.refreshToken,
+        client_id: token.clientId,
+        resource: token.resource,
+    });
+    if (token.clientSecret)
+        body.set('client_secret', token.clientSecret);
+    try {
+        const res = await fetch(token.tokenEndpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
+            body: body.toString(),
+        });
+        if (!res.ok)
+            return null;
+        const next = await res.json();
+        const updated = {
+            ...token,
+            accessToken: next.access_token,
+            tokenType: next.token_type || token.tokenType,
+            refreshToken: next.refresh_token || token.refreshToken,
+            expiresAt: next.expires_in ? Date.now() + (next.expires_in * 1000) : undefined,
+            scope: next.scope || token.scope,
+        };
+        saveMcpToken(serverId, updated);
+        return updated;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Inject Authorization: Bearer headers for remote MCP configs that have a token.
+ * Called by bridge.ts before handing merged config to agents.
+ */
+export function injectOAuthHeaders(name, config) {
+    const token = getMcpToken(name);
+    if (!token?.accessToken)
+        return config.headers || {};
+    return {
+        ...(config.headers || {}),
+        Authorization: `${token.tokenType || 'Bearer'} ${token.accessToken}`,
+    };
+}

package/dist/agent/mcp/registry.js

@@ -0,0 +1,119 @@
+/**
+ * MCP extension registry — curated recommended servers, recommended skills, community search.
+ *
+ * Schema supports three transport × auth combinations:
+ *   - stdio  + none         (local, zero-config)
+ *   - stdio  + credentials  (local, needs API key/token)
+ *   - http   + none         (rare)
+ *   - http   + credentials  (remote with API key)
+ *   - http   + mcp-oauth    (remote SaaS via MCP OAuth spec)
+ *
+ * For MCP-OAuth servers, `authorizationEndpoint` / `tokenEndpoint` can be
+ * pre-declared (fast path) or omitted (discovered via MCP Protected Resource
+ * Metadata at `<url>/.well-known/oauth-protected-resource`).
+ */
+// ---------------------------------------------------------------------------
+// Recommended MCP servers + skill repos — data lives in src/catalog/
+//
+// This module owns the *types* and helper functions. Edit
+// `src/catalog/mcp-servers.ts` and `src/catalog/skill-repos.ts` to add or hide
+// entries; the arrays below are just pointers back at that catalog.
+// ---------------------------------------------------------------------------
+import { MCP_SERVERS, SKILL_REPOS } from '../../catalog/index.js';
+const RECOMMENDED_MCP_SERVERS = MCP_SERVERS;
+const RECOMMENDED_SKILL_REPOS = SKILL_REPOS;
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export function getRecommendedMcpServers() {
+    return RECOMMENDED_MCP_SERVERS;
+}
+export function getRecommendedMcpServer(id) {
+    return RECOMMENDED_MCP_SERVERS.find(s => s.id === id);
+}
+export function getRecommendedSkillRepos() {
+    return RECOMMENDED_SKILL_REPOS;
+}
+/**
+ * Search the official MCP Registry API for servers.
+ * Falls back to npm search if the registry is unreachable.
+ */
+export async function searchMcpServers(query, limit = 20) {
+    if (!query.trim())
+        return [];
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 8_000);
+    try {
+        const url = `https://registry.modelcontextprotocol.io/v0.1/servers?search=${encodeURIComponent(query)}&limit=${limit}`;
+        const res = await fetch(url, { signal: controller.signal });
+        clearTimeout(timer);
+        if (res.ok) {
+            const data = await res.json();
+            if (Array.isArray(data?.servers)) {
+                return data.servers.map((s) => ({
+                    name: s.name || s.display_name || '',
+                    description: s.description || '',
+                    npmPackage: s.npm_package || undefined,
+                    source: s.repository || s.url || undefined,
+                    stars: typeof s.stars === 'number' ? s.stars : undefined,
+                })).filter((s) => s.name);
+            }
+            if (Array.isArray(data)) {
+                return data.slice(0, limit).map((s) => ({
+                    name: s.name || '',
+                    description: s.description || '',
+                    source: s.repository || s.url || undefined,
+                })).filter((s) => s.name);
+            }
+        }
+    }
+    catch {
+        clearTimeout(timer);
+    }
+    try {
+        const npmUrl = `https://registry.npmjs.org/-/v1/search?text=mcp+server+${encodeURIComponent(query)}&size=${limit}`;
+        const controller2 = new AbortController();
+        const timer2 = setTimeout(() => controller2.abort(), 5_000);
+        const res = await fetch(npmUrl, { signal: controller2.signal });
+        clearTimeout(timer2);
+        if (res.ok) {
+            const data = await res.json();
+            if (Array.isArray(data.objects)) {
+                return data.objects.map((o) => ({
+                    name: o.package?.name || '',
+                    description: o.package?.description || '',
+                    npmPackage: o.package?.name,
+                })).filter((s) => s.name);
+            }
+        }
+    }
+    catch { /* fallback failed */ }
+    return [];
+}
+/**
+ * Search for skills via npm search (`agent skill` keywords).
+ */
+export async function searchSkills(query, limit = 20) {
+    if (!query.trim())
+        return [];
+    try {
+        const npmUrl = `https://registry.npmjs.org/-/v1/search?text=agent+skill+${encodeURIComponent(query)}&size=${limit}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 5_000);
+        const res = await fetch(npmUrl, { signal: controller.signal });
+        clearTimeout(timer);
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        if (Array.isArray(data.objects)) {
+            return data.objects.map((o) => ({
+                name: o.package?.name || '',
+                description: o.package?.description || '',
+                source: o.package?.links?.repository || o.package?.name || '',
+                author: o.package?.publisher?.username,
+            })).filter((s) => s.name);
+        }
+    }
+    catch { /* unreachable */ }
+    return [];
+}