@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/server/routes/mobile.js

@@ -1,5 +1,6 @@
 import { Router } from 'express';
 import crypto from 'crypto';
+import { EventEmitter } from 'events';
 import path from 'path';
 import fs from 'fs';
 import { logger } from '../../utils/logger.js';
@@ -36,6 +37,11 @@ function rotatePairingCode() {
     }
     activePairingCode = nextCode;
     activePairingCodeExpiresAt = Date.now() + getPairingCodeTtlMs();
+    mobileEventBus.emit('event', {
+        type: 'pairing_rotated',
+        pairingCodeExpiresAt: activePairingCodeExpiresAt,
+        timestamp: Date.now(),
+    });
     return activePairingCode;
 }
 function ensureActivePairingCodeFresh() {
@@ -44,6 +50,15 @@ function ensureActivePairingCodeFresh() {
     }
 }
 export const followupDrafts = [];
+// ──────────────────────────────────────────────────────────────────────────
+// Mobile event bus — emits SSE-pushed events for mobile clients.
+// ──────────────────────────────────────────────────────────────────────────
+export const mobileEventBus = new EventEmitter();
+mobileEventBus.setMaxListeners(50);
+/** Check whether dispatch is enabled via environment variable. */
+export function isDispatchEnabled() {
+    return process.env.CODEBUDDY_MOBILE_ALLOW_DISPATCH === 'true';
+}
 function pruneExpiredTokens(now = Date.now()) {
     for (const [token, tokenData] of activeTokens) {
         if (now > tokenData.expiresAt) {
@@ -158,7 +173,8 @@ mobileRouter.get('/followup-drafts', loopbackOnlyMiddleware, (req, res) => {
     res.json({ ok: true, drafts: followupDrafts });
 });
 // POST /api/mobile/followup-draft/:id/approve: local operator approves a draft.
-// Approval is a review-gate marker only — it NEVER dispatches or executes work.
+// When CODEBUDDY_MOBILE_ALLOW_DISPATCH is OFF (default), approval is a
+// review-gate marker only — it never dispatches or executes work.
 mobileRouter.post('/followup-draft/:id/approve', loopbackOnlyMiddleware, (req, res) => {
     const draft = followupDrafts.find((d) => d.id === req.params.id);
     if (!draft) {
@@ -175,6 +191,12 @@ mobileRouter.post('/followup-draft/:id/approve', loopbackOnlyMiddleware, (req, r
     draft.status = 'approved';
     draft.approvedBy = reviewer;
     draft.approvedAt = Date.now();
+    mobileEventBus.emit('event', {
+        type: 'draft_status_changed',
+        draftId: draft.id,
+        status: draft.status,
+        timestamp: Date.now(),
+    });
     res.json({
         ok: true,
         message: 'Draft approved by local operator. No work is dispatched automatically — execution stays local and explicit.',
@@ -194,8 +216,52 @@ mobileRouter.post('/followup-draft/:id/cancel', loopbackOnlyMiddleware, (req, re
     }
     draft.status = 'cancelled';
     draft.cancelledAt = Date.now();
+    mobileEventBus.emit('event', {
+        type: 'draft_status_changed',
+        draftId: draft.id,
+        status: draft.status,
+        timestamp: Date.now(),
+    });
     res.json({ ok: true, message: 'Draft cancelled by local operator.', draft });
 });
+// POST /api/mobile/followup-draft/:id/dispatch: local operator dispatches an
+// approved draft to the agent. Gated behind CODEBUDDY_MOBILE_ALLOW_DISPATCH.
+mobileRouter.post('/followup-draft/:id/dispatch', loopbackOnlyMiddleware, (req, res) => {
+    if (!isDispatchEnabled()) {
+        res.status(403).json({
+            ok: false,
+            error: 'Dispatch is disabled. Set CODEBUDDY_MOBILE_ALLOW_DISPATCH=true to enable.',
+        });
+        return;
+    }
+    const draft = followupDrafts.find((d) => d.id === req.params.id);
+    if (!draft) {
+        res.status(404).json({ ok: false, error: 'Draft not found' });
+        return;
+    }
+    if (draft.status !== 'approved') {
+        res.status(409).json({
+            ok: false,
+            error: `Draft must be approved before dispatch (status: ${draft.status})`,
+        });
+        return;
+    }
+    draft.status = 'dispatched';
+    draft.dispatchedAt = Date.now();
+    mobileEventBus.emit('event', {
+        type: 'draft_status_changed',
+        draftId: draft.id,
+        status: draft.status,
+        timestamp: Date.now(),
+    });
+    // Emit a dispatch queue entry for the agent to pick up.
+    mobileEventBus.emit('dispatch', { draftId: draft.id, prompt: draft.prompt });
+    res.json({
+        ok: true,
+        message: 'Draft dispatched to agent for execution.',
+        draft,
+    });
+});
 // 1. POST /api/mobile/pair: Validate pairing request and issue short-lived token
 mobileRouter.post('/pair', (req, res) => {
     const code = typeof req.body?.code === 'string' ? req.body.code.trim() : '';
@@ -221,6 +287,49 @@ mobileRouter.post('/pair', (req, res) => {
         expiresAt,
     });
 });
+// ──────────────────────────────────────────────────────────────────────────
+// SSE push endpoint — authenticated via mobile bearer token (query param
+// fallback for EventSource API which doesn't support Authorization header).
+// Pushes: draft_status_changed, snapshot_available, pairing_rotated.
+// ──────────────────────────────────────────────────────────────────────────
+const HEARTBEAT_INTERVAL_MS = 30_000;
+mobileRouter.get('/events', (req, res) => {
+    // Auth: prefer Authorization header, fall back to ?token= query param.
+    const authHeader = req.headers.authorization;
+    let token;
+    if (authHeader && authHeader.startsWith('Bearer ')) {
+        token = authHeader.substring(7).trim();
+    }
+    else if (typeof req.query.token === 'string') {
+        token = req.query.token.trim();
+    }
+    if (!token || !isValidToken(token)) {
+        res.status(401).json({ ok: false, error: 'Unauthorized: Invalid or expired pairing token' });
+        return;
+    }
+    // SSE headers.
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders();
+    const sendSSE = (payload) => {
+        res.write(`data: ${JSON.stringify(payload)}\n\n`);
+    };
+    // Heartbeat to keep the connection alive.
+    const heartbeat = setInterval(() => {
+        sendSSE({ type: 'heartbeat', timestamp: Date.now() });
+    }, HEARTBEAT_INTERVAL_MS);
+    // Forward bus events to this SSE client.
+    const onEvent = (payload) => {
+        sendSSE(payload);
+    };
+    mobileEventBus.on('event', onEvent);
+    // Cleanup on disconnect.
+    req.on('close', () => {
+        clearInterval(heartbeat);
+        mobileEventBus.off('event', onEvent);
+    });
+});
 // Apply mobile auth middleware to all remaining routes
 mobileRouter.use(mobileAuthMiddleware);
 // 2. GET /api/mobile/snapshot: Return active run snapshot summary
@@ -331,6 +440,12 @@ async function enqueuePendingFollowupDraft(prompt, query, source) {
         createdAt: Date.now(),
     };
     followupDrafts.push(savedDraft);
+    mobileEventBus.emit('event', {
+        type: 'draft_status_changed',
+        draftId: savedDraft.id,
+        status: savedDraft.status,
+        timestamp: Date.now(),
+    });
     return savedDraft;
 }
 // 5. POST /api/mobile/followup-draft: Save a local operator followup review draft

package/dist/server/tls-config.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Optional TLS for the API server.
+ *
+ * The mobile-supervision endpoint (`/api/mobile`) rides the main HTTP server.
+ * To expose it off-device securely it can be served over HTTPS. This is purely
+ * transport security — it does not change any product gate (the dispatch gate
+ * `CODEBUDDY_MOBILE_ALLOW_DISPATCH` is untouched).
+ *
+ * Behaviour, gated by env (HTTP stays the default — no env, no TLS):
+ *  - `CODEBUDDY_HTTPS=1` (or `CODEBUDDY_MOBILE_TLS=1`) enables HTTPS.
+ *  - `CODEBUDDY_TLS_CERT` / `CODEBUDDY_TLS_KEY` = paths to a PEM cert/key. This
+ *    is the standard production approach (Let's Encrypt / reverse proxy / the
+ *    operator provisions the cert).
+ *  - If TLS is enabled but no cert is provided, a dev self-signed cert is
+ *    generated via `openssl` (if on PATH) into `~/.codebuddy/tls/` and reused.
+ *  - If TLS is enabled but it cannot be satisfied (cert unreadable, or openssl
+ *    absent), this **throws** with a clear message. It never silently falls back
+ *    to plain HTTP — an operator who asked for TLS must not be downgraded.
+ *
+ * Uses only Node built-ins (`https`, `fs`, `child_process`) — no new dependency.
+ */
+export interface ServerTlsOptions {
+    cert: string | Buffer;
+    key: string | Buffer;
+}
+/** Whether HTTPS is requested for the API server. */
+export declare function isTlsEnabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Resolve TLS options for the server, or `null` when TLS is not requested.
+ *
+ * Returns `null` (HTTP, unchanged default) when neither `CODEBUDDY_HTTPS` nor
+ * `CODEBUDDY_MOBILE_TLS` is set. Throws a clear error if TLS is requested but
+ * cannot be satisfied — it never downgrades to HTTP behind the operator's back.
+ */
+export declare function resolveServerTlsOptions(env?: NodeJS.ProcessEnv): ServerTlsOptions | null;

package/dist/server/tls-config.js

@@ -0,0 +1,142 @@
+/**
+ * Optional TLS for the API server.
+ *
+ * The mobile-supervision endpoint (`/api/mobile`) rides the main HTTP server.
+ * To expose it off-device securely it can be served over HTTPS. This is purely
+ * transport security — it does not change any product gate (the dispatch gate
+ * `CODEBUDDY_MOBILE_ALLOW_DISPATCH` is untouched).
+ *
+ * Behaviour, gated by env (HTTP stays the default — no env, no TLS):
+ *  - `CODEBUDDY_HTTPS=1` (or `CODEBUDDY_MOBILE_TLS=1`) enables HTTPS.
+ *  - `CODEBUDDY_TLS_CERT` / `CODEBUDDY_TLS_KEY` = paths to a PEM cert/key. This
+ *    is the standard production approach (Let's Encrypt / reverse proxy / the
+ *    operator provisions the cert).
+ *  - If TLS is enabled but no cert is provided, a dev self-signed cert is
+ *    generated via `openssl` (if on PATH) into `~/.codebuddy/tls/` and reused.
+ *  - If TLS is enabled but it cannot be satisfied (cert unreadable, or openssl
+ *    absent), this **throws** with a clear message. It never silently falls back
+ *    to plain HTTP — an operator who asked for TLS must not be downgraded.
+ *
+ * Uses only Node built-ins (`https`, `fs`, `child_process`) — no new dependency.
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { logger } from '../utils/logger.js';
+/** Truthy env flag check — accepts `1`, `true`, `yes`, `on` (case-insensitive). */
+function isEnvTrue(value) {
+    if (!value)
+        return false;
+    const v = value.trim().toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+/** Whether HTTPS is requested for the API server. */
+export function isTlsEnabled(env = process.env) {
+    return isEnvTrue(env.CODEBUDDY_HTTPS) || isEnvTrue(env.CODEBUDDY_MOBILE_TLS);
+}
+function tlsDir() {
+    const home = process.env.CODEBUDDY_HOME || os.homedir();
+    return path.join(home, '.codebuddy', 'tls');
+}
+function hasOpenssl() {
+    try {
+        execFileSync('openssl', ['version'], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Generate (once) and return a dev self-signed cert/key under `~/.codebuddy/tls/`.
+ * Reuses an existing pair if both files are present. Throws if openssl is absent.
+ */
+function ensureDevSelfSignedCert() {
+    const dir = tlsDir();
+    const certPath = path.join(dir, 'dev-cert.pem');
+    const keyPath = path.join(dir, 'dev-key.pem');
+    if (fs.existsSync(certPath) && fs.existsSync(keyPath)) {
+        return { cert: fs.readFileSync(certPath), key: fs.readFileSync(keyPath) };
+    }
+    if (!hasOpenssl()) {
+        throw new Error('TLS is enabled (CODEBUDDY_HTTPS) but no cert/key was provided and `openssl` ' +
+            'is not available on PATH to generate a dev self-signed certificate. ' +
+            'Provide CODEBUDDY_TLS_CERT and CODEBUDDY_TLS_KEY (PEM paths), or install openssl.');
+    }
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        execFileSync('openssl', [
+            'req',
+            '-x509',
+            '-newkey',
+            'rsa:2048',
+            '-nodes',
+            '-keyout',
+            keyPath,
+            '-out',
+            certPath,
+            '-subj',
+            '/CN=localhost',
+            '-days',
+            '365',
+        ], { stdio: 'ignore' });
+        // Restrict the private key to the owner.
+        try {
+            fs.chmodSync(keyPath, 0o600);
+        }
+        catch {
+            /* best-effort on platforms without POSIX perms */
+        }
+    }
+    catch (err) {
+        throw new Error('TLS is enabled (CODEBUDDY_HTTPS) but generating a dev self-signed certificate ' +
+            `with openssl failed: ${err instanceof Error ? err.message : String(err)}. ` +
+            'Provide CODEBUDDY_TLS_CERT and CODEBUDDY_TLS_KEY (PEM paths) instead.');
+    }
+    logger.warn(`TLS: generated a dev self-signed certificate at ${certPath}. ` +
+        'This is for development/off-device testing only — use a real cert ' +
+        '(CODEBUDDY_TLS_CERT / CODEBUDDY_TLS_KEY) in production.');
+    return { cert: fs.readFileSync(certPath), key: fs.readFileSync(keyPath) };
+}
+/**
+ * Resolve TLS options for the server, or `null` when TLS is not requested.
+ *
+ * Returns `null` (HTTP, unchanged default) when neither `CODEBUDDY_HTTPS` nor
+ * `CODEBUDDY_MOBILE_TLS` is set. Throws a clear error if TLS is requested but
+ * cannot be satisfied — it never downgrades to HTTP behind the operator's back.
+ */
+export function resolveServerTlsOptions(env = process.env) {
+    if (!isTlsEnabled(env)) {
+        return null;
+    }
+    const certPath = env.CODEBUDDY_TLS_CERT?.trim();
+    const keyPath = env.CODEBUDDY_TLS_KEY?.trim();
+    // One of the two paths set but not the other → operator misconfiguration.
+    if ((certPath && !keyPath) || (!certPath && keyPath)) {
+        throw new Error('TLS is enabled (CODEBUDDY_HTTPS) but only one of CODEBUDDY_TLS_CERT / ' +
+            'CODEBUDDY_TLS_KEY is set. Provide both, or neither (to use a dev self-signed cert).');
+    }
+    if (certPath && keyPath) {
+        let cert;
+        let key;
+        try {
+            cert = fs.readFileSync(certPath);
+        }
+        catch (err) {
+            throw new Error(`TLS is enabled but CODEBUDDY_TLS_CERT (${certPath}) could not be read: ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+        }
+        try {
+            key = fs.readFileSync(keyPath);
+        }
+        catch (err) {
+            throw new Error(`TLS is enabled but CODEBUDDY_TLS_KEY (${keyPath}) could not be read: ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { cert, key };
+    }
+    // TLS requested with no explicit cert — generate/reuse a dev self-signed cert.
+    return ensureDevSelfSignedCert();
+}
+//# sourceMappingURL=tls-config.js.map

package/dist/server/tunnel-manager.d.ts

@@ -0,0 +1,20 @@
+export interface TunnelOptions {
+    port: number;
+    authtoken?: string;
+    domain?: string;
+}
+export declare class TunnelManager {
+    private static listener;
+    /**
+     * Start an ngrok tunnel forwarding to the specified port.
+     */
+    static startTunnel(options: TunnelOptions): Promise<string>;
+    /**
+     * Stop the active ngrok tunnel.
+     */
+    static stopTunnel(): Promise<void>;
+    /**
+     * Get the URL of the currently active tunnel, if any.
+     */
+    static getActiveTunnelUrl(): string | null;
+}

package/dist/server/tunnel-manager.js

@@ -0,0 +1,58 @@
+import * as ngrok from '@ngrok/ngrok';
+import { logger } from '../utils/logger.js';
+export class TunnelManager {
+    static listener = null;
+    /**
+     * Start an ngrok tunnel forwarding to the specified port.
+     */
+    static async startTunnel(options) {
+        if (this.listener) {
+            logger.warn('A tunnel is already running. Disconnecting existing tunnel.');
+            await this.stopTunnel();
+        }
+        try {
+            logger.info(`Starting ngrok tunnel for port ${options.port}...`);
+            const ngrokOptions = {
+                addr: options.port,
+                authtoken_from_env: true,
+            };
+            if (options.authtoken) {
+                ngrokOptions.authtoken = options.authtoken;
+            }
+            if (options.domain) {
+                ngrokOptions.domain = options.domain;
+            }
+            this.listener = await ngrok.forward(ngrokOptions);
+            const url = this.listener.url() ?? '';
+            logger.info(`ngrok tunnel established at: ${url}`);
+            return url;
+        }
+        catch (error) {
+            logger.error('Failed to start ngrok tunnel', { error });
+            throw error;
+        }
+    }
+    /**
+     * Stop the active ngrok tunnel.
+     */
+    static async stopTunnel() {
+        if (this.listener) {
+            try {
+                await this.listener.close();
+                this.listener = null;
+                logger.info('ngrok tunnel closed.');
+            }
+            catch (error) {
+                logger.error('Failed to close ngrok tunnel', { error });
+                throw error;
+            }
+        }
+    }
+    /**
+     * Get the URL of the currently active tunnel, if any.
+     */
+    static getActiveTunnelUrl() {
+        return this.listener ? this.listener.url() ?? null : null;
+    }
+}
+//# sourceMappingURL=tunnel-manager.js.map

package/dist/server/websocket/fleet-bridge.js

@@ -178,4 +178,9 @@ export function broadcastChatSessionEnd(payload) {
 export function broadcastChatSessionGoal(payload) {
     broadcastFleetEvent('fleet:chat-session:goal', { ...payload });
 }
+// Wire up the agent runtime hooks (breaks circular dependency #2)
+import { registerFleetBroadcaster } from '../../agent/execution/tool-hooks.js';
+registerFleetBroadcaster(broadcastFleetEvent);
+import { registerSessionFleetBroadcaster } from '../../agent/multi-agent/session-fleet-bridge.js';
+registerSessionFleetBroadcaster(broadcastFleetEvent);
 //# sourceMappingURL=fleet-bridge.js.map

package/dist/services/prompt-builder.d.ts

@@ -12,6 +12,7 @@
 import { EnhancedMemory, PersistentMemoryManager } from "../memory/index.js";
 import { PromptCacheManager } from "../optimization/prompt-cache.js";
 import { MoltbotHooksManager } from "../hooks/moltbot-hooks.js";
+import { type ContextRegistry } from "../context/project-context.js";
 import { type QueryComplexity } from "../agent/execution/query-classifier.js";
 export interface PromptBuilderConfig {
     yoloMode: boolean;
@@ -39,6 +40,7 @@ export interface BuildOptions {
     includeWritingRules?: boolean;
     includeCodingStyle?: boolean;
     includeWorkflowRules?: boolean;
+    includeExecutionDiscipline?: boolean;
     includeVariation?: boolean;
 }
 export declare class PromptBuilder {
@@ -47,7 +49,16 @@ export declare class PromptBuilder {
     private memory?;
     private moltbotHooksManager?;
     private persistentMemory?;
+    /**
+     * Dedup registry for project-instruction files, recreated fresh at the start
+     * of each system-prompt build. The JIT context pass reads it (via
+     * `getContextRegistry()`) so files already injected at startup are not
+     * re-injected when a tool later touches a file in the same tree.
+     */
+    private contextRegistry;
     constructor(config: PromptBuilderConfig, promptCacheManager: PromptCacheManager, memory?: EnhancedMemory | undefined, moltbotHooksManager?: MoltbotHooksManager | undefined, persistentMemory?: PersistentMemoryManager | undefined);
+    /** The registry from the most recent system-prompt build (for the JIT pass). */
+    getContextRegistry(): ContextRegistry | null;
     /**
      * Build the system prompt for the agent. The optional `options`
      * parameter gates per-block injection. All gates default to `true`