@phuetz/code-buddy 1.6.0 → 2.0.0

package/dist/server/routes/tools.js

@@ -4,19 +4,31 @@
  * Handles tool listing and execution API endpoints.
  */
 import { Router } from 'express';
-import { requireScope, asyncHandler, ApiServerError } from '../middleware/index.js';
-import { createServerAgent } from '../agent-adapter.js';
+import { requireScope, requireLocalAnonymousAccess, asyncHandler, ApiServerError, } from '../middleware/index.js';
+import { buildHttpRequestSessionKey, withHttpSessionAgent, } from '../http-agent-sessions.js';
+import { WRITE_TOOL_NAMES } from '../../security/write-policy.js';
+import { getPolicyManager } from '../../security/tool-policy/policy-manager.js';
+import { getToolGroups } from '../../security/tool-policy/tool-groups.js';
 /** Extract flat info from nested CodeBuddyTool shape */
 function toToolInfo(tool) {
+    const definition = tool.definition;
+    const name = definition.function.name;
+    const policyDecision = getPolicyManager().checkTool(name);
     return {
-        name: tool.function.name,
-        description: tool.function.description || '',
-        category: 'general',
-        parameters: tool.function.parameters || {},
-        requiresConfirmation: false,
-        isDestructive: false,
+        name,
+        description: definition.function.description || '',
+        category: tool.metadata.category || 'general',
+        parameters: definition.function.parameters || {},
+        // REST has no interactive callback. Require an explicit `confirmed:true`
+        // for all known write tools as well as tools the active policy marks confirm.
+        requiresConfirmation: WRITE_TOOL_NAMES.has(name) || policyDecision.action === 'confirm',
+        isDestructive: getToolGroups(name).includes('group:dangerous'),
     };
 }
+function enabledTool(registry, name) {
+    const tool = registry.getTool(name);
+    return tool?.isEnabled() ? tool : undefined;
+}
 // Lazy load the tool registry
 let toolRegistryInstance = null;
 async function getToolRegistry() {
@@ -28,23 +40,25 @@ async function getToolRegistry() {
     }
     return toolRegistryInstance;
 }
-// Lazy load the agent for tool execution
-let agentInstance = null;
-async function getAgent() {
-    if (!agentInstance) {
-        agentInstance = await createServerAgent();
-    }
-    return agentInstance;
+function requestSessionKey(req, sessionId) {
+    return buildHttpRequestSessionKey(req, sessionId);
 }
 const router = Router();
+// `--no-auth` is useful for a loopback-only robot stack, but must never turn a
+// network bind into an anonymous remote-code/file API. This gate covers list,
+// single execution, and batch execution before any registry is initialized.
+router.use(requireLocalAnonymousAccess);
 /**
  * GET /api/tools
  * List all available tools
  */
 router.get('/', requireScope('tools'), asyncHandler(async (req, res) => {
     const registry = await getToolRegistry();
-    const tools = registry.getAllTools();
-    const toolInfos = tools.map(toToolInfo);
+    const toolInfos = registry
+        .getAllTools()
+        .map((definition) => enabledTool(registry, definition.function.name))
+        .filter((tool) => Boolean(tool))
+        .map(toToolInfo);
     res.json({
         tools: toolInfos,
         total: toolInfos.length,
@@ -57,12 +71,11 @@ router.get('/', requireScope('tools'), asyncHandler(async (req, res) => {
  */
 router.get('/categories', requireScope('tools'), asyncHandler(async (req, res) => {
     const registry = await getToolRegistry();
-    const tools = registry.getAllTools();
+    const tools = registry
+        .getAllTools()
+        .filter((definition) => enabledTool(registry, definition.function.name));
     const categories = new Map();
-    for (const tool of tools) {
-        const category = 'general';
-        categories.set(category, (categories.get(category) || 0) + 1);
-    }
+    categories.set('general', tools.length);
     res.json({
         categories: Object.fromEntries(categories),
     });
@@ -74,7 +87,7 @@ router.get('/categories', requireScope('tools'), asyncHandler(async (req, res) =
 router.get('/:name', requireScope('tools'), asyncHandler(async (req, res) => {
     const name = req.params.name;
     const registry = await getToolRegistry();
-    const tool = registry.getTool(name);
+    const tool = enabledTool(registry, name);
     if (!tool) {
         throw ApiServerError.notFound(`Tool '${name}'`);
     }
@@ -93,12 +106,12 @@ router.post('/:name/execute', requireScope('tools:execute'), asyncHandler(async
         throw ApiServerError.forbidden('Tool execution requires tools:execute scope');
     }
     const registry = await getToolRegistry();
-    const tool = registry.getTool(name);
+    const tool = enabledTool(registry, name);
     if (!tool) {
         throw ApiServerError.notFound(`Tool '${name}'`);
     }
     // Check if tool requires confirmation and it wasn't provided
-    if (tool.requiresConfirmation && !body.confirmed) {
+    if (toToolInfo(tool).requiresConfirmation && !body.confirmed) {
         res.status(200).json({
             toolName: name,
             success: false,
@@ -108,13 +121,18 @@ router.post('/:name/execute', requireScope('tools:execute'), asyncHandler(async
         });
         return;
     }
+    const sessionKey = requestSessionKey(req, body.sessionId);
     try {
-        const agent = await getAgent();
-        const result = await agent.executeToolByName(name, body.parameters || {});
+        const result = await withHttpSessionAgent(sessionKey, (agent) => agent.executeToolByName(name, body.parameters || {}));
+        const { publishToolResultWidget } = await import('../../widgets/canvas-publish.js');
+        const published = await publishToolResultWidget(result);
         const response = {
             toolName: name,
             success: result.success,
             output: result.output,
+            ...(result.data !== undefined ? { data: result.data } : {}),
+            ...(published.widgetHtml ? { widgetHtml: published.widgetHtml } : {}),
+            ...(published.canvasId ? { canvasId: published.canvasId, canvasPath: published.canvasPath ?? undefined } : {}),
             error: result.error,
             executionTime: Date.now() - startTime,
         };
@@ -137,7 +155,7 @@ router.post('/:name/execute', requireScope('tools:execute'), asyncHandler(async
  */
 router.post('/batch', requireScope('tools:execute'), asyncHandler(async (req, res) => {
     const startTime = Date.now();
-    const { tools } = req.body;
+    const { tools, sessionId } = req.body;
     if (!Array.isArray(tools) || tools.length === 0) {
         throw ApiServerError.badRequest('Tools must be a non-empty array');
     }
@@ -145,53 +163,54 @@ router.post('/batch', requireScope('tools:execute'), asyncHandler(async (req, re
         throw ApiServerError.badRequest('Maximum 10 tools per batch');
     }
     const registry = await getToolRegistry();
-    const agent = await getAgent();
-    const results = [];
-    for (const toolRequest of tools) {
-        const toolStartTime = Date.now();
-        const tool = registry.getTool(toolRequest.name);
-        if (!tool) {
-            results.push({
-                toolName: toolRequest.name,
-                success: false,
-                error: `Tool '${toolRequest.name}' not found`,
-                executionTime: Date.now() - toolStartTime,
-            });
-            continue;
+    const sessionKey = requestSessionKey(req, sessionId);
+    const results = await withHttpSessionAgent(sessionKey, async (agent) => {
+        const batchResults = [];
+        for (const toolRequest of tools) {
+            const toolStartTime = Date.now();
+            const tool = enabledTool(registry, toolRequest.name);
+            if (!tool) {
+                batchResults.push({
+                    toolName: toolRequest.name,
+                    success: false,
+                    error: `Tool '${toolRequest.name}' not found`,
+                    executionTime: Date.now() - toolStartTime,
+                });
+                continue;
+            }
+            // Batch cannot present an interactive confirmation prompt.
+            if (toToolInfo(tool).requiresConfirmation) {
+                batchResults.push({
+                    toolName: toolRequest.name,
+                    success: false,
+                    error: 'Tool requires confirmation and cannot be executed in batch mode',
+                    requiresConfirmation: true,
+                    executionTime: Date.now() - toolStartTime,
+                });
+                continue;
+            }
+            try {
+                const result = await agent.executeToolByName(toolRequest.name, toolRequest.parameters || {});
+                batchResults.push({
+                    toolName: toolRequest.name,
+                    success: result.success,
+                    output: result.output,
+                    error: result.error,
+                    executionTime: Date.now() - toolStartTime,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                batchResults.push({
+                    toolName: toolRequest.name,
+                    success: false,
+                    error: message,
+                    executionTime: Date.now() - toolStartTime,
+                });
+            }
         }
-        // Skip tools requiring confirmation in batch mode
-        // Note: CodeBuddyTool doesn't carry requiresConfirmation; skip for now
-        // eslint-disable-next-line no-constant-condition
-        if (false) {
-            results.push({
-                toolName: toolRequest.name,
-                success: false,
-                error: 'Tool requires confirmation and cannot be executed in batch mode',
-                requiresConfirmation: true,
-                executionTime: Date.now() - toolStartTime,
-            });
-            continue;
-        }
-        try {
-            const result = await agent.executeToolByName(toolRequest.name, toolRequest.parameters || {});
-            results.push({
-                toolName: toolRequest.name,
-                success: result.success,
-                output: result.output,
-                error: result.error,
-                executionTime: Date.now() - toolStartTime,
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            results.push({
-                toolName: toolRequest.name,
-                success: false,
-                error: message,
-                executionTime: Date.now() - toolStartTime,
-            });
-        }
-    }
+        return batchResults;
+    });
     res.json({
         results,
         totalExecutionTime: Date.now() - startTime,

package/dist/server/routes/webhooks.js

@@ -11,7 +11,7 @@
  *   POST   /api/webhooks/test             — Test a trigger with sample data
  */
 import { Router } from 'express';
-import { asyncHandler } from '../middleware/index.js';
+import { ApiServerError, asyncHandler } from '../middleware/index.js';
 import { logger } from '../../utils/logger.js';
 const router = Router();
 // Lazy-load the WebhookTriggerManager to avoid circular deps
@@ -22,51 +22,6 @@ async function getManager() {
     return manager;
 }
 // ============================================================================
-// POST /api/webhooks/:source — Receive a webhook
-// ============================================================================
-router.post('/:source', asyncHandler(async (req, res) => {
-    const source = String(req.params.source || '');
-    if (!source) {
-        res.status(400).json({ error: 'Source parameter is required' });
-        return;
-    }
-    const headers = {};
-    for (const [key, value] of Object.entries(req.headers)) {
-        if (typeof value === 'string') {
-            headers[key] = value;
-        }
-        else if (Array.isArray(value)) {
-            headers[key] = value[0] || '';
-        }
-    }
-    const manager = await getManager();
-    const result = await manager.handleWebhook(source, headers, req.body);
-    if (result.fired) {
-        logger.info(`Webhook from ${source} triggered: ${result.triggerId} (${result.eventType})`);
-        res.status(200).json({
-            status: 'triggered',
-            triggerId: result.triggerId,
-            eventType: result.eventType,
-            prompt: result.prompt,
-        });
-    }
-    else if (result.error) {
-        logger.warn(`Webhook from ${source} failed: ${result.error}`);
-        res.status(400).json({
-            status: 'error',
-            error: result.error,
-            eventType: result.eventType,
-        });
-    }
-    else {
-        // No matching trigger — acknowledge receipt
-        res.status(200).json({
-            status: 'no_match',
-            eventType: result.eventType,
-        });
-    }
-}));
-// ============================================================================
 // GET /api/webhooks/triggers — List all triggers
 // ============================================================================
 router.get('/triggers', asyncHandler(async (_req, res) => {
@@ -167,6 +122,61 @@ router.post('/test', asyncHandler(async (req, res) => {
     });
 }));
 // ============================================================================
+// POST /api/webhooks/:source — Receive a webhook
+// Keep this parameterized route after every static POST endpoint.
+// ============================================================================
+router.post('/:source', asyncHandler(async (req, res) => {
+    const source = String(req.params.source || '');
+    if (!source) {
+        res.status(400).json({ error: 'Source parameter is required' });
+        return;
+    }
+    const headers = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (typeof value === 'string') {
+            headers[key] = value;
+        }
+        else if (Array.isArray(value)) {
+            headers[key] = value[0] || '';
+        }
+    }
+    const manager = await getManager();
+    const result = await manager.handleWebhook(source, headers, req.body);
+    if (result.fired) {
+        try {
+            const { enqueueWebhookAgentRun } = await import('../webhook-agent-queue.js');
+            const accepted = enqueueWebhookAgentRun({
+                prompt: result.prompt || '',
+                source,
+                triggerId: result.triggerId,
+                eventType: result.eventType,
+            });
+            logger.info(`Webhook from ${source} accepted as agent run ${accepted.runId}`);
+            res.status(202).json({ status: 'accepted', runId: accepted.runId });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`Webhook from ${source} could not be queued: ${message}`);
+            throw ApiServerError.serviceUnavailable(`Webhook agent run was not queued: ${message}`);
+        }
+    }
+    else if (result.error) {
+        logger.warn(`Webhook from ${source} failed: ${result.error}`);
+        res.status(400).json({
+            status: 'error',
+            error: result.error,
+            eventType: result.eventType,
+        });
+    }
+    else {
+        // No matching trigger — acknowledge receipt
+        res.status(200).json({
+            status: 'no_match',
+            eventType: result.eventType,
+        });
+    }
+}));
+// ============================================================================
 // Export
 // ============================================================================
 export function createWebhookRoutes() {

package/dist/server/tunnel-manager.js

@@ -1,5 +1,24 @@
-import * as ngrok from '@ngrok/ngrok';
 import { logger } from '../utils/logger.js';
+/**
+ * Charge @ngrok/ngrok a la demande.
+ *
+ * Le paquet est une dependance normale, mais son binaire natif par plateforme
+ * (@ngrok/ngrok-linux-x64-gnu et consorts) est une dependance OPTIONNELLE de sa
+ * part. Une installation qui omet les optionnelles obtient donc le module sans
+ * son binaire — et un import statique faisait planter le processus au simple
+ * chargement de ce fichier, avant meme qu'on demande un tunnel.
+ */
+async function chargerNgrok() {
+    try {
+        return (await import('@ngrok/ngrok'));
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error("Les tunnels demandent @ngrok/ngrok et son binaire natif, absents de cette " +
+            'installation. Installez-les avec : npm install @ngrok/ngrok. ' +
+            `(cause : ${detail})`);
+    }
+}
 export class TunnelManager {
     static listener = null;
     /**
@@ -22,6 +41,7 @@ export class TunnelManager {
             if (options.domain) {
                 ngrokOptions.domain = options.domain;
             }
+            const ngrok = await chargerNgrok();
             this.listener = await ngrok.forward(ngrokOptions);
             const url = this.listener.url() ?? '';
             logger.info(`ngrok tunnel established at: ${url}`);

package/dist/server/types.d.ts

@@ -117,7 +117,7 @@ export type ApiScope = 'read' | 'chat' | 'chat:stream' | 'tools' | 'tools:execut
  *  routed through the peer-rpc registry). Active routing — caller can
  *  trigger work on the receiver. Pair this scope with fleet:listen if
  *  the caller also wants to observe events. */
- | 'peer:invoke';
+ | 'peer:invoke' | 'cognition:write' | 'cognition:write-local' | 'cognition:write-lan' | 'cognition:write-foreign' | 'cognition:sense' | 'cognition:read' | 'cognition:read-local' | 'cognition:read-lan' | 'cognition:raw' | 'cognition:admin';
 export interface JwtPayload {
     /** Subject (user ID or key ID) */
     sub: string;
@@ -131,6 +131,8 @@ export interface JwtPayload {
     exp: number;
     /** Token type */
     type?: 'api_key' | 'user';
+    /** Optional operator role stamped by `buddy token --role`. */
+    role?: 'user' | 'admin';
 }
 export interface AuthenticatedRequest {
     auth: {
@@ -138,6 +140,8 @@ export interface AuthenticatedRequest {
         userId?: string;
         scopes: ApiScope[];
         type: 'api_key' | 'user';
+        /** True only when the server itself synthesized access for --no-auth mode. */
+        anonymous?: boolean;
     };
 }
 export interface ChatRequest {
@@ -177,6 +181,14 @@ export interface ChatResponse {
     };
     /** Tool calls made */
     toolCalls?: ToolCallResult[];
+    /** Structured tool/widget payload when one was produced */
+    data?: unknown;
+    /** Server-rendered widget HTML (opt-in CODEBUDDY_WIDGETS_AUTO) */
+    widgetHtml?: string;
+    /** Canvas snapshot id when the widget was published */
+    canvasId?: string;
+    /** Path of the published canvas document */
+    canvasPath?: string;
     /** Session ID */
     sessionId?: string;
     /** Cost estimate */
@@ -233,6 +245,8 @@ export interface ToolExecutionRequest {
     confirmed?: boolean;
     /** Execution timeout (ms) */
     timeout?: number;
+    /** Conversation scope shared with chat and other REST tool calls. */
+    sessionId?: string;
 }
 export interface ToolExecutionResponse {
     /** Tool name */
@@ -241,6 +255,14 @@ export interface ToolExecutionResponse {
     success: boolean;
     /** Tool output */
     output?: string;
+    /** Structured payload (e.g. stock_quote `data:{type:'stock'}`) */
+    data?: unknown;
+    /** Server-rendered widget HTML when auto widgets are on */
+    widgetHtml?: string;
+    /** Canvas snapshot id when the widget was published */
+    canvasId?: string;
+    /** Path of the published canvas document */
+    canvasPath?: string;
     /** Error message */
     error?: string;
     /** Requires confirmation */
@@ -259,6 +281,8 @@ export interface ToolCallResult {
     success: boolean;
     /** Tool output */
     output?: string;
+    /** Structured tool payload */
+    data?: unknown;
     /** Error message */
     error?: string;
     /** Execution time (ms) */

package/dist/server/webhook-agent-queue.d.ts

@@ -0,0 +1,12 @@
+export interface WebhookAgentRunInput {
+    prompt: string;
+    source: string;
+    triggerId?: string;
+    eventType?: string;
+}
+export interface AcceptedWebhookAgentRun {
+    runId: string;
+    acceptedAt: string;
+}
+/** Enqueue one real agent turn and return only after the queue accepted it. */
+export declare function enqueueWebhookAgentRun(input: WebhookAgentRunInput): AcceptedWebhookAgentRun;

package/dist/server/webhook-agent-queue.js

@@ -0,0 +1,58 @@
+import { randomUUID } from 'crypto';
+import { runAgentCompletion } from './agent-adapter.js';
+import { buildHttpAgentSessionKey, withHttpSessionAgent } from './http-agent-sessions.js';
+import { logger } from '../utils/logger.js';
+const MAX_PENDING_WEBHOOK_RUNS = 100;
+const pendingRuns = [];
+let processing = false;
+async function executeRun(run) {
+    const sessionKey = buildHttpAgentSessionKey('webhook', run.runId);
+    await withHttpSessionAgent(sessionKey, (agent) => runAgentCompletion(agent, run.prompt, { surface: 'webhook' }));
+}
+async function processQueue() {
+    try {
+        let run = pendingRuns.shift();
+        while (run) {
+            try {
+                await executeRun(run);
+            }
+            catch (error) {
+                logger.error('Webhook agent run failed', error instanceof Error ? error : new Error(String(error)), {
+                    runId: run.runId,
+                    source: run.source,
+                    triggerId: run.triggerId,
+                });
+            }
+            run = pendingRuns.shift();
+        }
+    }
+    finally {
+        processing = false;
+        if (pendingRuns.length > 0)
+            scheduleProcessing();
+    }
+}
+function scheduleProcessing() {
+    if (processing)
+        return;
+    processing = true;
+    queueMicrotask(() => void processQueue());
+}
+/** Enqueue one real agent turn and return only after the queue accepted it. */
+export function enqueueWebhookAgentRun(input) {
+    if (!input.prompt.trim()) {
+        throw new Error('Webhook trigger produced an empty agent prompt');
+    }
+    if (pendingRuns.length >= MAX_PENDING_WEBHOOK_RUNS) {
+        throw new Error('Webhook agent queue is full');
+    }
+    const accepted = {
+        ...input,
+        runId: `webhook_${randomUUID()}`,
+        acceptedAt: new Date().toISOString(),
+    };
+    pendingRuns.push(accepted);
+    scheduleProcessing();
+    return { runId: accepted.runId, acceptedAt: accepted.acceptedAt };
+}
+//# sourceMappingURL=webhook-agent-queue.js.map

package/dist/server/websocket/cognition-bridge.d.ts

@@ -0,0 +1,13 @@
+import { CognitiveHub } from '../../cognition/cognitive-hub.js';
+export interface CognitionBridgeOptions {
+    /** Maximum live workspace events retained for one connection. */
+    subscriptionCapacity?: number;
+    /** Stop streaming full events once the socket reaches this queued byte count. */
+    maxBufferedBytes?: number;
+    backpressurePollMs?: number;
+}
+/**
+ * Wire the process-local CognitiveHub into the existing WebSocket gateway.
+ * Returns a complete, idempotent unwire function for tests and server shutdown.
+ */
+export declare function wireCognitionBridge(hub: CognitiveHub, options?: CognitionBridgeOptions): () => void;