@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/mcp/transports.js

@@ -1,4 +1,7 @@
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport as SDKSSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { StdioClientTransport, getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { createOAuthProvider } from "./mcp-oauth-provider.js";
 import { EventEmitter } from "events";
 import axios from "axios";
 import { logger } from '../utils/logger.js';
@@ -14,7 +17,7 @@ export class StdioTransport {
     async connect() {
         // Create transport with environment variables to suppress verbose output
         const env = {
-            ...process.env,
+            ...(this.config.inheritEnv === false ? getDefaultEnvironment() : process.env),
             ...this.config.env,
             // Try to suppress verbose output from mcp-remote
             MCP_REMOTE_QUIET: '1',
@@ -25,6 +28,7 @@ export class StdioTransport {
         const transportConfig = {
             command: this.config.command,
             args: this.config.args || [],
+            cwd: this.config.cwd,
             env,
             // The SDK default is stderr:'inherit', which lets a noisy MCP server
             // (startup banners, progress logs) write raw bytes into the CLI's own
@@ -46,10 +50,14 @@ export class StdioTransport {
     }
     async disconnect() {
         if (this.transport) {
-            await this.transport.close();
-            this.transport = undefined;
+            try {
+                await this.transport.close();
+            }
+            finally {
+                this.transport = undefined;
+            }
         }
-        // The StdioClientTransport from the SDK is expected to terminate the child process.
+        // SDK close() ends stdin, then SIGTERM/SIGKILL the child it spawned.
     }
     getType() {
         return 'stdio';
@@ -69,6 +77,7 @@ export class HttpTransport extends EventEmitter {
     async connect() {
         this.client = axios.create({
             baseURL: this.config.url,
+            maxRedirects: 0,
             headers: {
                 'Content-Type': 'application/json',
                 ...this.config.headers
@@ -93,35 +102,28 @@ export class HttpTransport extends EventEmitter {
         return 'http';
     }
 }
-export class SSETransport extends EventEmitter {
+export class SSETransport {
     config;
-    connected = false;
+    transport;
     constructor(config) {
-        super();
         this.config = config;
-        if (!config.url) {
-            throw new Error('URL is required for SSE MCP transport. Specify the server URL in your MCP configuration.');
-        }
+        if (!config.url)
+            throw new Error('URL is required for SSE MCP transport');
     }
     async connect() {
-        return new Promise((resolve, reject) => {
-            try {
-                // For Node.js environment, we'll use a simple HTTP-based approach
-                // In a real implementation, you'd use a proper SSE library like 'eventsource'
-                this.connected = true;
-                resolve(new SSEClientTransport(this.config.url));
-            }
-            catch (error) {
-                reject(error);
-            }
+        this.transport = new SDKSSEClientTransport(new URL(this.config.url), {
+            requestInit: { headers: this.config.headers, redirect: 'error' },
+            eventSourceInit: { fetch: (url, init) => {
+                    const headers = new Headers(init?.headers);
+                    for (const [key, value] of Object.entries(this.config.headers ?? {}))
+                        headers.set(key, value);
+                    return fetch(url, { ...init, headers, redirect: 'error' });
+                } },
         });
+        return this.transport;
     }
-    async disconnect() {
-        this.connected = false;
-    }
-    getType() {
-        return 'sse';
-    }
+    async disconnect() { await this.transport?.close(); this.transport = undefined; }
+    getType() { return 'sse'; }
 }
 // Custom HTTP Transport implementation
 class HttpClientTransport extends EventEmitter {
@@ -156,105 +158,114 @@ class HttpClientTransport extends EventEmitter {
         }
     }
 }
-// Custom SSE Transport implementation
-class SSEClientTransport extends EventEmitter {
-    url;
-    onclose;
-    onerror;
-    onmessage;
-    sessionId;
-    constructor(url) {
-        super();
-        this.url = url;
-    }
-    async start() {
-        // SSE transport is event-driven, so we're always "started"
-    }
-    async close() {
-        // Nothing to close for basic SSE transport
-    }
-    async send(message, _options) {
-        // For bidirectional communication over SSE, we typically use HTTP POST
-        // for sending messages and SSE for receiving
-        try {
-            const response = await axios.post(this.url.replace('/sse', '/rpc'), message, {
-                headers: { 'Content-Type': 'application/json' }
-            });
-            if (this.onmessage && response.data) {
-                this.onmessage(response.data);
-            }
-        }
-        catch (error) {
-            const err = new Error(`SSE transport error: ${error}`);
-            if (this.onerror) {
-                this.onerror(err);
-            }
-            throw err;
-        }
-    }
-}
 export class StreamableHttpTransport extends EventEmitter {
     config;
-    connected = false;
+    transport;
+    oauthProvider;
     constructor(config) {
         super();
         this.config = config;
-        if (!config.url) {
+        if (!config.url)
             throw new Error('URL is required for streamable_http transport');
-        }
     }
     async connect() {
-        return new Promise((resolve, reject) => {
-            try {
-                this.connected = true;
-                resolve(new StreamableHttpClientTransport(this.config.url, this.config.headers));
-            }
-            catch (error) {
-                reject(error);
-            }
+        const url = new URL(this.config.url);
+        if (!['http:', 'https:'].includes(url.protocol)) {
+            throw new Error('Streamable HTTP MCP requires an HTTP(S) URL');
+        }
+        const provider = this.config.auth?.type === 'oauth' ? createOAuthProvider(this.config.url, this.config.auth) : undefined;
+        this.oauthProvider = provider;
+        this.transport = new StreamableHTTPClientTransport(url, {
+            requestInit: { headers: this.config.headers, redirect: 'error' },
+            ...(provider ? { authProvider: provider } : {}),
         });
+        provider?.attachTransport(this.transport);
+        return this.transport;
     }
     async disconnect() {
-        this.connected = false;
+        this.oauthProvider?.abortAuthorization();
+        this.oauthProvider = undefined;
+        const transport = this.transport;
+        this.transport = undefined;
+        await transport?.close();
     }
     getType() {
         return 'streamable_http';
     }
 }
-// Custom Streamable HTTP Transport implementation for GitHub Copilot MCP
-class StreamableHttpClientTransport extends EventEmitter {
-    url;
-    headers;
-    onclose;
-    onerror;
-    onmessage;
-    sessionId;
-    constructor(url, headers) {
-        super();
-        this.url = url;
-        this.headers = headers;
-    }
-    async start() {
-        // Streamable HTTP transport is connection-less, so we're always "started"
-    }
-    async close() {
-        // Nothing to close for streamable HTTP transport
+/** Resolve references only at connection time; missing credentials fail closed. */
+export function resolveMCPTransport(config) {
+    const resolve = (value) => value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, key) => {
+        const result = process.env[key];
+        if (!result)
+            throw new Error(`Missing MCP environment reference: ${key}`);
+        return result;
+    });
+    const map = (values) => values && Object.fromEntries(Object.entries(values).map(([k, v]) => [k, resolve(v)]));
+    const resolved = { ...config, command: config.command && resolve(config.command), cwd: config.cwd && resolve(config.cwd),
+        args: config.args?.map(resolve), env: map(config.env), headers: map(config.headers), url: config.url && resolve(config.url) };
+    if (resolved.url) {
+        let url;
+        try {
+            url = new URL(resolved.url);
+        }
+        catch {
+            throw new Error('Invalid MCP endpoint configuration');
+        }
+        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+            throw new Error('MCP requires HTTP(S) without embedded credentials, query or fragment');
     }
-    async send(_message, _options) {
-        logger.warn('StreamableHttpTransport: SSE endpoints require persistent connections, not suitable for MCP request-response pattern');
-        logger.debug('StreamableHttpTransport: Message that would be sent', { message: _message });
-        // For now, throw an error to indicate the transport type is not compatible
-        // with the MCP protocol's request-response pattern
-        throw new Error('StreamableHttpTransport: SSE endpoints are not compatible with MCP request-response pattern. GitHub Copilot MCP may require a different integration approach.');
+    if (config.auth) {
+        const auth = { ...config.auth,
+            serverId: config.auth.serverId && resolve(config.auth.serverId),
+            clientId: config.auth.clientId && resolve(config.auth.clientId),
+            clientMetadataUrl: config.auth.clientMetadataUrl && resolve(config.auth.clientMetadataUrl),
+            redirectUri: config.auth.redirectUri && resolve(config.auth.redirectUri) };
+        if (auth.redirectUri) {
+            // The authorization code must only ever come back to the local callback server.
+            let redirect;
+            try {
+                redirect = new URL(auth.redirectUri);
+            }
+            catch {
+                throw new Error('MCP OAuth redirectUri must be a loopback http URL');
+            }
+            // Hostname localhost is allowed so a CIMD document's redirect_uris can match.
+            // The callback server still binds 127.0.0.1 only — a browser that resolves
+            // localhost to ::1 will not hit it. Use 127.0.0.1 when the metadata says so.
+            if (redirect.protocol !== 'http:' || !['127.0.0.1', 'localhost'].includes(redirect.hostname))
+                throw new Error('MCP OAuth redirectUri must be a loopback http URL');
+        }
+        if (auth.clientMetadataUrl) {
+            let meta;
+            try {
+                meta = new URL(auth.clientMetadataUrl);
+            }
+            catch {
+                throw new Error('MCP OAuth clientMetadataUrl must be an https URL with a document path');
+            }
+            if (meta.protocol !== 'https:' || meta.pathname === '/')
+                throw new Error('MCP OAuth clientMetadataUrl must be an https URL with a document path');
+        }
+        return { ...resolved, auth };
     }
+    return resolved;
 }
-export function createTransport(config) {
+export function createTransport(input) {
+    const config = resolveMCPTransport(input);
+    if (config.auth?.type === 'oauth' && config.type !== 'streamable_http') {
+        throw new Error(`MCP OAuth is only supported on streamable_http (got ${config.type}); refusing to connect without the authProvider.`);
+    }
     switch (config.type) {
         case 'stdio':
             return new StdioTransport(config);
         case 'http':
+            logger.warn('MCP http /rpc transport is deprecated; use legacy_rpc explicitly or streamable_http for MCP HTTP');
+            return new HttpTransport(config);
+        case 'legacy_rpc':
             return new HttpTransport(config);
         case 'sse':
+        case 'sse_sdk':
             return new SSETransport(config);
         case 'streamable_http':
             return new StreamableHttpTransport(config);

package/dist/mcp/types.d.ts

@@ -15,6 +15,11 @@ export interface MCPServerConfig {
     maxRetries?: number;
     /** Optional: Enable/disable this server (default: true) */
     enabled?: boolean;
+    /** Exact names and star globs; exclusions win. Empty include denies every tool. */
+    toolFilter?: {
+        include?: string[];
+        exclude?: string[];
+    };
 }
 export type ServerStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
 export interface MCPTool {

package/dist/media/comfyui-recipe-contract.d.ts

@@ -473,12 +473,6 @@ export declare const comfyUIRecipeSchema: z.ZodObject<{
         name?: string | undefined;
         url?: string | undefined;
     };
-    schemaVersion: 1;
-    fallback: {
-        id: string;
-        reason?: string | undefined;
-        version?: string | undefined;
-    }[];
     resources: {
         tier: "high" | "low" | "balanced" | "extreme";
         maxConcurrency: number;
@@ -486,6 +480,12 @@ export declare const comfyUIRecipeSchema: z.ZodObject<{
         minRamMiB: number;
         estimatedSeconds?: number | undefined;
     };
+    schemaVersion: 1;
+    fallback: {
+        id: string;
+        reason?: string | undefined;
+        version?: string | undefined;
+    }[];
     bindings: {
         prompt: {
             input: string;
@@ -573,7 +573,6 @@ export declare const comfyUIRecipeSchema: z.ZodObject<{
         name?: string | undefined;
         url?: string | undefined;
     };
-    schemaVersion: 1;
     resources: {
         tier: "high" | "low" | "balanced" | "extreme";
         minVramMiB: number;
@@ -581,6 +580,7 @@ export declare const comfyUIRecipeSchema: z.ZodObject<{
         maxConcurrency?: number | undefined;
         estimatedSeconds?: number | undefined;
     };
+    schemaVersion: 1;
     bindings: {
         prompt: {
             input: string;

package/dist/memory/facts-memory.d.ts

@@ -63,8 +63,18 @@ export declare const ReconciliationActionSchema: z.ZodObject<{
     } | undefined;
 }>;
 export type ReconciliationAction = z.infer<typeof ReconciliationActionSchema>;
+/** Keep concurrent command sessions on their own provider, including an explicit offline scope. */
+export declare function withFactsMemorySessionClient<T>(client: CodeBuddyClient | null, action: () => T): T;
+/**
+ * Async generators execute on next/return/throw, not when they are created.
+ * Scope every resumption so model/tool/cleanup work belongs to this agent,
+ * while consumers outside a yielded event keep their own async context.
+ */
+export declare function bindFactsMemorySession<T>(client: CodeBuddyClient, iterator: AsyncGenerator<T, void, unknown>): AsyncGenerator<T, void, unknown>;
+export declare function setFactsMemorySessionClient(client: CodeBuddyClient | null): void;
 export declare class FactsMemoryService {
-    private client;
+    private readonly explicitClient;
+    private fallbackClient;
     constructor(client?: CodeBuddyClient);
     isAvailable(): Promise<boolean>;
     private getClient;

package/dist/memory/facts-memory.js

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { z } from 'zod';
 import { logger } from '../utils/logger.js';
 import { CodeBuddyClient } from '../codebuddy/client.js';
@@ -30,20 +31,58 @@ export const ReconciliationActionSchema = z.object({
     targetIndex: z.number().optional(),
     fact: FactSchema.optional()
 });
+/**
+ * Client of the live session (the provider and endpoint the user actually
+ * started with). Without it, reconciliation fell back to environment
+ * auto-detection and could send project memories to a different, cloud
+ * provider than the local session (e.g. xAI because GROK_API_KEY was set while
+ * the CLI ran on --base-url http://127.0.0.1:11434/v1).
+ */
+let sessionClient = null;
+const sessionScope = new AsyncLocalStorage();
+/** Keep concurrent command sessions on their own provider, including an explicit offline scope. */
+export function withFactsMemorySessionClient(client, action) {
+    return sessionScope.run({ client }, action);
+}
+/**
+ * Async generators execute on next/return/throw, not when they are created.
+ * Scope every resumption so model/tool/cleanup work belongs to this agent,
+ * while consumers outside a yielded event keep their own async context.
+ */
+export function bindFactsMemorySession(client, iterator) {
+    return {
+        next(...args) { return withFactsMemorySessionClient(client, () => iterator.next(...args)); },
+        return(value) { return withFactsMemorySessionClient(client, () => iterator.return(value)); },
+        throw(error) { return withFactsMemorySessionClient(client, () => iterator.throw(error)); },
+        [Symbol.asyncIterator]() { return this; },
+        async [Symbol.asyncDispose]() {
+            await withFactsMemorySessionClient(client, () => iterator.return());
+        },
+    };
+}
+export function setFactsMemorySessionClient(client) {
+    sessionClient = client;
+}
 export class FactsMemoryService {
-    client = null;
+    explicitClient;
+    fallbackClient = null;
     constructor(client) {
-        if (client) {
-            this.client = client;
-        }
+        this.explicitClient = client ?? null;
     }
     async isAvailable() {
         const client = await this.getClient();
         return client !== null;
     }
     async getClient() {
-        if (this.client)
-            return this.client;
+        if (this.explicitClient)
+            return this.explicitClient;
+        const scoped = sessionScope.getStore();
+        if (scoped)
+            return scoped.client;
+        if (sessionClient)
+            return sessionClient;
+        if (this.fallbackClient)
+            return this.fallbackClient;
         // Skip auto-detecting client in unit tests to prevent timeouts/real API calls
         if (process.env.NODE_ENV === 'test' || process.env.VITEST) {
             return null;
@@ -53,8 +92,8 @@ export class FactsMemoryService {
             logger.warn('[FactsMemory] No LLM provider configuration found.');
             return null;
         }
-        this.client = new CodeBuddyClient(detected.apiKey, detected.defaultModel, detected.baseURL);
-        return this.client;
+        this.fallbackClient = new CodeBuddyClient(detected.apiKey, detected.defaultModel, detected.baseURL);
+        return this.fallbackClient;
     }
     /**
      * Extract atom facts from a conversation or context block.

package/dist/memory/memory-candidate-queue.d.ts

@@ -72,7 +72,7 @@ export interface MemoryCandidateStats {
     total: number;
     byStatus: Record<MemoryCandidateStatus, number>;
 }
-export declare function getMemoryCandidateQueue(workDir?: string): MemoryCandidateQueue;
+export declare function getMemoryCandidateQueue(workDir?: string, botId?: string): MemoryCandidateQueue;
 export declare function resetMemoryCandidateQueues(): void;
 export declare class MemoryCandidateQueue {
     private workDir;
@@ -80,7 +80,7 @@ export declare class MemoryCandidateQueue {
     private filePath;
     private candidates;
     private loaded;
-    constructor(workDir?: string, memoryManager?: PersistentMemoryManager | undefined);
+    constructor(workDir?: string, memoryManager?: PersistentMemoryManager | undefined, botId?: string);
     propose(input: ProposeMemoryCandidateInput): ProposeMemoryCandidateResult;
     list(status?: MemoryCandidateStatus): MemoryCandidate[];
     get(id: string): MemoryCandidate | null;

package/dist/memory/memory-candidate-queue.js

@@ -22,10 +22,10 @@ const VALID_CATEGORIES = [
     'custom',
 ];
 const registry = new Map();
-export function getMemoryCandidateQueue(workDir = process.cwd()) {
-    const key = path.resolve(workDir);
+export function getMemoryCandidateQueue(workDir = process.cwd(), botId) {
+    const key = JSON.stringify([path.resolve(workDir), botId ?? '']);
     if (!registry.has(key)) {
-        registry.set(key, new MemoryCandidateQueue(key));
+        registry.set(key, new MemoryCandidateQueue(path.resolve(workDir), botId ? getMemoryManager(undefined, botId, workDir) : undefined, botId));
         if (registry.size > 20) {
             const firstKey = registry.keys().next().value;
             if (firstKey)
@@ -43,10 +43,10 @@ export class MemoryCandidateQueue {
     filePath;
     candidates = [];
     loaded = false;
-    constructor(workDir = process.cwd(), memoryManager) {
+    constructor(workDir = process.cwd(), memoryManager, botId) {
         this.workDir = workDir;
         this.memoryManager = memoryManager;
-        this.filePath = path.join(workDir, '.codebuddy', 'memory-candidates.json');
+        this.filePath = path.join(workDir, '.codebuddy', botId ? `memory-candidates-${encodeURIComponent(botId)}.json` : 'memory-candidates.json');
     }
     propose(input) {
         this.load();
@@ -122,7 +122,7 @@ export class MemoryCandidateQueue {
             throw new Error('Accepted memory key cannot be empty.');
         if (!value)
             throw new Error('Accepted memory value cannot be empty.');
-        const manager = this.memoryManager ?? getMemoryManager();
+        const manager = this.memoryManager ?? getMemoryManager(undefined, undefined, this.workDir);
         await manager.initialize();
         const write = await manager.remember(key, value, {
             scope,

package/dist/memory/persistent-memory.d.ts

@@ -53,6 +53,15 @@ export interface MemoryWriteResult {
     category?: MemoryCategory;
     usage: MemoryUsage;
     message: string;
+    /**
+     * Outcome of the optional LLM fact reconciliation, separate from the primary
+     * write: `failed` means the memory was still written directly and existing
+     * memories were restored unchanged.
+     */
+    reconciliation?: {
+        status: 'applied' | 'skipped' | 'failed';
+        reason?: string;
+    };
 }
 export declare class MemoryWriteRejectedError extends Error {
     readonly code: 'memory_limit_exceeded' | 'memory_security_rejected';
@@ -164,6 +173,8 @@ export declare class PersistentMemoryManager extends EventEmitter {
      * poking the private maps. Does NOT reinforce (unlike getRelevantMemories).
      */
     listMemories(scope: MemoryScope): Memory[];
+    /** Guard the result, including model renames/omissions, rather than trusting DELETE alone. */
+    private guardReconciliation;
     /**
      * Ebbinghaus forgetting pass (recoverable): memories whose retention decayed
      * below the threshold are appended to a sibling `*.archive.md`, then removed.
@@ -250,12 +261,6 @@ export declare class PersistentMemoryManager extends EventEmitter {
     };
     private assertScopeReadable;
 }
-/**
- * Get the memory manager. With no `botId`, returns the global singleton (default
- * — CLI / desktop / server behavior unchanged). With a `botId` (multi-bot
- * channels), returns a per-bot instance whose memory files live under
- * `~/.codebuddy/bots/<botId>/`, so bots never share each other's `remember` facts.
- */
-export declare function getMemoryManager(config?: Partial<MemoryConfig>, botId?: string): PersistentMemoryManager;
+export declare function getMemoryManager(config?: Partial<MemoryConfig>, botId?: string, cwd?: string): PersistentMemoryManager;
 export declare function resetMemoryManagerForTests(): void;
-export declare function initializeMemory(config?: Partial<MemoryConfig>): Promise<PersistentMemoryManager>;
+export declare function initializeMemory(config?: Partial<MemoryConfig>, cwd?: string): Promise<PersistentMemoryManager>;