@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/server/auth/device-session-context.d.ts

@@ -0,0 +1,9 @@
+export interface DeviceSessionIdentity {
+    readonly deviceId?: string;
+    readonly profile?: 'agent' | 'companion';
+    readonly identity?: 'owner';
+    readonly amr?: readonly string[];
+}
+/** Companion integration seam: signed identity of the current WS turn only. */
+export declare function getDeviceSessionIdentity(): DeviceSessionIdentity | undefined;
+export declare function withDeviceSessionIdentity<T>(identity: DeviceSessionIdentity, run: () => Promise<T>): Promise<T>;

package/dist/server/auth/device-session-context.js

@@ -0,0 +1,13 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const context = new AsyncLocalStorage();
+/** Companion integration seam: signed identity of the current WS turn only. */
+export function getDeviceSessionIdentity() {
+    return context.getStore();
+}
+export function withDeviceSessionIdentity(identity, run) {
+    return context.run(Object.freeze({
+        ...identity,
+        ...(identity.amr ? { amr: Object.freeze([...identity.amr]) } : {}),
+    }), run);
+}
+//# sourceMappingURL=device-session-context.js.map

package/dist/server/auth/device-store.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+export declare const PAIRING_TTL_MS: number;
+export declare const DEVICE_NONCE_TTL_MS = 60000;
+declare const deviceSchema: z.ZodObject<{
+    deviceId: z.ZodString;
+    deviceName: z.ZodString;
+    publicKeyJwk: z.ZodObject<{
+        kty: z.ZodLiteral<"EC">;
+        crv: z.ZodLiteral<"P-256">;
+        x: z.ZodString;
+        y: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        y: string;
+        x: string;
+        kty: "EC";
+        crv: "P-256";
+    }, {
+        y: string;
+        x: string;
+        kty: "EC";
+        crv: "P-256";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    lastVerifiedAt: z.ZodOptional<z.ZodString>;
+    revokedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    updatedAt: string;
+    createdAt: string;
+    deviceId: string;
+    deviceName: string;
+    publicKeyJwk: {
+        y: string;
+        x: string;
+        kty: "EC";
+        crv: "P-256";
+    };
+    lastVerifiedAt?: string | undefined;
+    revokedAt?: string | undefined;
+}, {
+    updatedAt: string;
+    createdAt: string;
+    deviceId: string;
+    deviceName: string;
+    publicKeyJwk: {
+        y: string;
+        x: string;
+        kty: "EC";
+        crv: "P-256";
+    };
+    lastVerifiedAt?: string | undefined;
+    revokedAt?: string | undefined;
+}>;
+export type AuthDevice = z.infer<typeof deviceSchema>;
+export type DeviceAudit = (action: 'device_register' | 'device_verify' | 'device_revoke', allowed: boolean) => void;
+export declare class DeviceAuthError extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+/** Only public keys persist; nonces are bounded, process-local and lost on restart. */
+export declare class DeviceAuthStore {
+    readonly file: string;
+    private readonly now;
+    private readonly nonces;
+    private readonly audit;
+    constructor(file?: string, now?: () => number, audit?: DeviceAudit);
+    private update;
+    list(): AuthDevice[];
+    isActive(deviceId: string): boolean;
+    /** Local CLI only. There is deliberately no HTTP endpoint for issuing codes. */
+    createPairing(): {
+        pairingCode: string;
+        expiresAt: string;
+    };
+    register(pairingCode: unknown, deviceName: unknown, publicKeyJwk: unknown): Promise<{
+        deviceId: string;
+    }>;
+    challenge(deviceId: unknown): {
+        nonce: string;
+        expiresAt: string;
+    };
+    verify(deviceId: unknown, nonce: unknown, signature: unknown, secret: string): Promise<{
+        token: string;
+    }>;
+    revoke(deviceId: string): void;
+    rename(deviceId: string, deviceName: string): void;
+}
+export declare function getDeviceAuthStore(): DeviceAuthStore;
+export {};

package/dist/server/auth/device-store.js

@@ -0,0 +1,261 @@
+import { createHash, randomBytes, randomInt, randomUUID, webcrypto } from 'node:crypto';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+import { auditLogger } from '../../security/audit-logger.js';
+import { readDeviceStoreFile, updateDeviceStoreFile } from '../../utils/device-store-file.js';
+import { generateToken } from './jwt.js';
+export const PAIRING_TTL_MS = 10 * 60_000;
+export const DEVICE_NONCE_TTL_MS = 60_000;
+const CODE_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+const publicKeySchema = z.object({
+    kty: z.literal('EC'), crv: z.literal('P-256'),
+    x: z.string().regex(/^[A-Za-z0-9_-]{43}$/),
+    y: z.string().regex(/^[A-Za-z0-9_-]{43}$/),
+});
+const nameSchema = z.string().trim().min(1).max(80).regex(/^[^\p{Cc}\p{Cf}<>]*$/u);
+const deviceSchema = z.object({
+    deviceId: z.string().uuid(), deviceName: nameSchema,
+    publicKeyJwk: publicKeySchema,
+    createdAt: z.string().datetime(), updatedAt: z.string().datetime(),
+    lastVerifiedAt: z.string().datetime().optional(), revokedAt: z.string().datetime().optional(),
+});
+const authDataSchema = z.object({
+    devices: z.array(deviceSchema),
+    pairings: z.array(z.object({ hash: z.string(), expiresAt: z.number() })),
+});
+export class DeviceAuthError extends Error {
+    status;
+    constructor(status) {
+        super(status === 400 ? 'Invalid pairing request' : status === 401 ? 'Authentication failed' : 'Device authentication unavailable');
+        this.status = status;
+    }
+}
+function authData(envelope) {
+    if (envelope.deviceAuth === undefined)
+        return { devices: [], pairings: [] };
+    const parsed = authDataSchema.safeParse(envelope.deviceAuth);
+    if (!parsed.success)
+        throw new DeviceAuthError(503);
+    return parsed.data;
+}
+function pairingHash(code) {
+    return createHash('sha256').update(code).digest('hex');
+}
+/** Accept JOSE/P1363 and Android's native, minimally encoded ASN.1 DER. */
+function signatureCandidates(encoded) {
+    if (encoded.length > 100 || !/^[A-Za-z0-9_+/-]+={0,2}$/.test(encoded))
+        throw new DeviceAuthError(401);
+    const bytes = Buffer.from(encoded, 'base64url');
+    const normalized = encoded.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    if (bytes.toString('base64url') !== normalized)
+        throw new DeviceAuthError(401);
+    const candidates = bytes.length === 64 ? [bytes] : [];
+    // P-256 DER always uses short lengths (at most 72 bytes in total).
+    if (bytes.length < 8 || bytes.length > 72 || bytes[0] !== 0x30 || bytes[1] !== bytes.length - 2)
+        return candidates;
+    let cursor = 2;
+    const raw = Buffer.alloc(64);
+    for (let component = 0; component < 2; component++) {
+        if (bytes[cursor++] !== 0x02)
+            return candidates;
+        const length = bytes[cursor++];
+        if (!length || length > 33 || cursor + length > bytes.length)
+            return candidates;
+        let integer = bytes.subarray(cursor, cursor + length);
+        cursor += length;
+        const first = integer[0];
+        if (first === undefined || (first & 0x80) !== 0)
+            return candidates;
+        if (integer.length > 1 && first === 0) {
+            const second = integer[1];
+            if (second === undefined || (second & 0x80) === 0)
+                return candidates;
+            integer = integer.subarray(1);
+        }
+        if (integer.length > 32)
+            return candidates;
+        integer.copy(raw, (component + 1) * 32 - integer.length);
+    }
+    if (cursor === bytes.length)
+        candidates.push(raw);
+    return candidates;
+}
+/** Only public keys persist; nonces are bounded, process-local and lost on restart. */
+export class DeviceAuthStore {
+    file;
+    now;
+    nonces = new Map();
+    audit;
+    constructor(file = join(homedir(), '.codebuddy', 'devices.json'), now = Date.now, audit) {
+        this.file = file;
+        this.now = now;
+        if (audit)
+            this.audit = audit;
+        else {
+            auditLogger.init({ logDir: join(dirname(file), 'audit') });
+            this.audit = (action, allowed) => auditLogger.log({
+                action, decision: allowed ? 'allow' : 'block', source: 'device-auth',
+            });
+        }
+    }
+    update(fn) {
+        return updateDeviceStoreFile(this.file, envelope => {
+            const data = authData(envelope);
+            const result = fn(data);
+            envelope.deviceAuth = data;
+            return result;
+        });
+    }
+    list() {
+        return authData(readDeviceStoreFile(this.file)).devices;
+    }
+    isActive(deviceId) {
+        try {
+            return this.list().some(device => device.deviceId === deviceId && !device.revokedAt);
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Local CLI only. There is deliberately no HTTP endpoint for issuing codes. */
+    createPairing() {
+        return this.update(data => {
+            data.pairings = data.pairings.filter(code => code.expiresAt > this.now());
+            if (data.pairings.length >= 20)
+                throw new DeviceAuthError(503);
+            let pairingCode;
+            do {
+                pairingCode = Array.from({ length: 8 }, () => CODE_ALPHABET[randomInt(CODE_ALPHABET.length)]).join('');
+            } while (data.pairings.some(code => code.hash === pairingHash(pairingCode)));
+            const expiresAt = this.now() + PAIRING_TTL_MS;
+            data.pairings.push({ hash: pairingHash(pairingCode), expiresAt });
+            return { pairingCode, expiresAt: new Date(expiresAt).toISOString() };
+        });
+    }
+    async register(pairingCode, deviceName, publicKeyJwk) {
+        let allowed = false;
+        try {
+            const name = nameSchema.safeParse(deviceName);
+            const key = publicKeySchema.safeParse(publicKeyJwk);
+            if (typeof pairingCode !== 'string' || !/^[A-HJ-NP-Z2-9]{8}$/.test(pairingCode)
+                || !name.success || !key.success || (publicKeyJwk && typeof publicKeyJwk === 'object' && 'd' in publicKeyJwk)) {
+                throw new DeviceAuthError(400);
+            }
+            try {
+                await webcrypto.subtle.importKey('jwk', key.data, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['verify']);
+            }
+            catch {
+                throw new DeviceAuthError(400);
+            }
+            const result = this.update(data => {
+                const index = data.pairings.findIndex(code => code.hash === pairingHash(pairingCode) && code.expiresAt > this.now());
+                if (index < 0)
+                    throw new DeviceAuthError(400);
+                data.pairings.splice(index, 1);
+                const deviceId = randomUUID();
+                const date = new Date(this.now()).toISOString();
+                data.devices.push({ deviceId, deviceName: name.data, publicKeyJwk: key.data, createdAt: date, updatedAt: date });
+                return { deviceId };
+            });
+            allowed = true;
+            return result;
+        }
+        finally {
+            this.audit('device_register', allowed);
+        }
+    }
+    challenge(deviceId) {
+        if (typeof deviceId !== 'string' || !this.isActive(deviceId))
+            throw new DeviceAuthError(401);
+        for (const [id, entry] of this.nonces)
+            if (entry.expiresAt <= this.now())
+                this.nonces.delete(id);
+        if (this.nonces.size >= 1000 && !this.nonces.has(deviceId))
+            throw new DeviceAuthError(503);
+        const nonce = randomBytes(32).toString('base64url');
+        const expiresAt = this.now() + DEVICE_NONCE_TTL_MS;
+        this.nonces.set(deviceId, { nonce, expiresAt });
+        return { nonce, expiresAt: new Date(expiresAt).toISOString() };
+    }
+    async verify(deviceId, nonce, signature, secret) {
+        let allowed = false;
+        try {
+            if (typeof deviceId !== 'string' || typeof nonce !== 'string' || typeof signature !== 'string')
+                throw new DeviceAuthError(401);
+            const challenge = this.nonces.get(deviceId);
+            if (!challenge || challenge.nonce !== nonce)
+                throw new DeviceAuthError(401);
+            // Consume before any async crypto work, including failed signature attempts.
+            this.nonces.delete(deviceId);
+            if (challenge.expiresAt <= this.now())
+                throw new DeviceAuthError(401);
+            const candidates = signatureCandidates(signature);
+            const device = this.list().find(item => item.deviceId === deviceId && !item.revokedAt);
+            if (!device)
+                throw new DeviceAuthError(401);
+            const key = await webcrypto.subtle.importKey('jwk', device.publicKeyJwk, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['verify']);
+            let valid = false;
+            for (const candidate of candidates) {
+                if (await webcrypto.subtle.verify({ name: 'ECDSA', hash: 'SHA-256' }, key, candidate, Buffer.from(`${deviceId}.${nonce}`, 'utf8'))) {
+                    valid = true;
+                    break;
+                }
+            }
+            if (!valid)
+                throw new DeviceAuthError(401);
+            if (!secret || secret === 'change-me-in-production')
+                throw new DeviceAuthError(503);
+            // Re-read inside the transaction: revoke may have run during verification.
+            const token = this.update(data => {
+                const current = data.devices.find(item => item.deviceId === deviceId && !item.revokedAt);
+                if (!current)
+                    throw new DeviceAuthError(401);
+                current.lastVerifiedAt = new Date(this.now()).toISOString();
+                return generateToken({
+                    sub: deviceId, type: 'user', scopes: ['chat', 'chat:stream', 'sessions', 'tools'],
+                    amr: ['biometric', 'device'], profile: 'agent', identity: 'owner',
+                }, secret, '1h');
+            });
+            allowed = true;
+            return { token };
+        }
+        finally {
+            this.audit('device_verify', allowed);
+        }
+    }
+    revoke(deviceId) {
+        let allowed = false;
+        try {
+            this.update(data => {
+                const device = data.devices.find(item => item.deviceId === deviceId);
+                if (!device)
+                    throw new DeviceAuthError(401);
+                device.revokedAt ??= new Date(this.now()).toISOString();
+                device.updatedAt = device.revokedAt;
+            });
+            this.nonces.delete(deviceId);
+            allowed = true;
+        }
+        finally {
+            this.audit('device_revoke', allowed);
+        }
+    }
+    rename(deviceId, deviceName) {
+        const name = nameSchema.safeParse(deviceName);
+        if (!name.success)
+            throw new DeviceAuthError(400);
+        this.update(data => {
+            const device = data.devices.find(item => item.deviceId === deviceId);
+            if (!device)
+                throw new DeviceAuthError(401);
+            device.deviceName = name.data;
+            device.updatedAt = new Date(this.now()).toISOString();
+        });
+    }
+}
+let store;
+export function getDeviceAuthStore() {
+    return store ??= new DeviceAuthStore();
+}
+//# sourceMappingURL=device-store.js.map

package/dist/server/auth/device-token.d.ts

@@ -0,0 +1,3 @@
+import type { JwtPayload } from '../types.js';
+/** Legacy tokens do not touch the device store. */
+export declare function isDeviceAccessTokenActive(payload: JwtPayload): boolean;

package/dist/server/auth/device-token.js

@@ -0,0 +1,6 @@
+import { getDeviceAuthStore } from './device-store.js';
+/** Legacy tokens do not touch the device store. */
+export function isDeviceAccessTokenActive(payload) {
+    return !Array.isArray(payload.amr) || !payload.amr.includes('device') || (Number.isFinite(payload.exp) && payload.exp * 1000 > Date.now() && getDeviceAuthStore().isActive(payload.sub));
+}
+//# sourceMappingURL=device-token.js.map

package/dist/server/auth/jwt.js

@@ -146,6 +146,10 @@ export function refreshToken(token, secret, expiresIn = '24h') {
     if (!payload) {
         return null;
     }
+    // Device tokens require a fresh key proof after one hour. In particular,
+    // never turn them into legacy tokens that lose the revocation marker.
+    if (Array.isArray(payload.amr) && payload.amr.includes('device'))
+        return null;
     return generateToken({
         sub: payload.sub,
         scopes: payload.scopes,

package/dist/server/index.d.ts

@@ -1,13 +1,3 @@
-/**
- * API Server
- *
- * Main entry point for the Code Buddy REST API and WebSocket server.
- *
- * Usage:
- *   npm run server
- *   # or
- *   codebuddy server --port 3000
- */
 import { Application } from 'express';
 import { Server as HttpServer } from 'http';
 import type { ServerConfig } from './types.js';

package/dist/server/index.js

@@ -1,3 +1,4 @@
+import { createA2AJsonRpcRoutes } from './routes/a2a-jsonrpc.js';
 /**
  * API Server
  *
@@ -16,6 +17,7 @@ import cors from 'cors';
 import { createServer } from 'http';
 import { createServer as createHttpsServer, Server as HttpsServer } from 'https';
 import { resolveServerTlsOptions } from './tls-config.js';
+import { createDeviceAuthRoutes } from './routes/device-auth.js';
 const _require = createRequire(import.meta.url);
 let SERVER_VERSION = '0.0.0';
 try {
@@ -176,6 +178,10 @@ function createApp(config, cognitiveHub) {
             ],
         }));
     }
+    // Separate opt-in peer bearer auth, bounded parser and rate limit; existing REST/JWT routes unchanged.
+    if (process.env.CODEBUDDY_A2A_PEERS) {
+        app.use(createA2AJsonRpcRoutes({ publicUrl: process.env.CODEBUDDY_A2A_PUBLIC_URL ?? `http://127.0.0.1:${config.port}/a2a/v1` }));
+    }
     // Body parsing
     app.use(express.json({ limit: config.maxRequestSize }));
     app.use(express.urlencoded({ extended: true, limit: config.maxRequestSize }));
@@ -203,6 +209,8 @@ function createApp(config, cognitiveHub) {
             res.status(404).end();
         });
     }
+    // Android pairs with a local code and proves key possession before JWT auth.
+    app.use('/api/auth/device', createDeviceAuthRoutes(config.jwtSecret));
     // Authentication (applied after public health/metrics/mobile endpoints)
     app.use(createAuthMiddleware(config));
     // A2A routes (auth-based, exempt from CSRF) — must be mounted BEFORE CSRF middleware
@@ -1191,6 +1199,22 @@ export async function startServer(userConfig = {}) {
             logger.info(`Metrics Dashboard: ${baseUrl}/api/metrics/dashboard`);
             logger.info(`Docs: ${baseUrl}/api/docs`);
             logger.info(`WebSocket: ${config.websocketEnabled ? 'Enabled (/ws)' : 'Disabled'}`);
+            // Fleet rooms (opt-in): persistent signed messages between members. Wired
+            // after listen so auth audiences use the port actually bound.
+            if (config.websocketEnabled && process.env.CODEBUDDY_FLEET_ROOMS === 'true') {
+                try {
+                    const address = server.address();
+                    const port = address && typeof address === 'object' ? address.port : config.port;
+                    const { startFleetRooms } = await import('../fleet/rooms/room-server.js');
+                    server._fleetRooms =
+                        startFleetRooms({ port });
+                }
+                catch (error) {
+                    logger.warn('[fleet-rooms] not enabled', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
             // Sensory nervous-system bridge (opt-in): ingress for the Rust buddy-sense
             // daemon → internal event bus → reactions. Loopback-only.
             if (process.env.CODEBUDDY_SENSORY === 'true' && !sensoryWired) {
@@ -1236,6 +1260,9 @@ export async function startServer(userConfig = {}) {
                         logger.warn(`[respond-policy] ${warning}`);
                     }
                     const responseDecider = createResponseDecider({ chimeIn: responsePolicy.chimeIn });
+                    const { setVoiceResponseDecider } = await import('../sensory/voice-loop.js');
+                    setVoiceResponseDecider(responseDecider);
+                    sensoryTeardown.push(() => setVoiceResponseDecider(undefined));
                     {
                         const { shouldWireVisionReaction, wireVisionReaction } = await import('../sensory/vision-reaction.js');
                         if (shouldWireVisionReaction({ camera: process.env.CODEBUDDY_SENSORY_CAMERA, token: sensoryToken })) {
@@ -2044,6 +2071,7 @@ export async function stopServer(server) {
         const unwireCognition = server
             ._unwireCognition;
         unwireCognition?.();
+        server._fleetRooms?.stop();
         // Detach the channel-A2A bridge handler + shut down the
         // ChannelManager so polling loops (Telegram, Discord, ...) stop.
         const bridgeStop = server

package/dist/server/middleware/auth.js

@@ -5,6 +5,7 @@
  */
 import { validateApiKey, hasScope as _hasScope } from '../auth/api-keys.js';
 import { verifyToken } from '../auth/jwt.js';
+import { isDeviceAccessTokenActive } from '../auth/device-token.js';
 import { API_ERRORS } from '../types.js';
 // Re-export for external use
 export const hasScope = _hasScope;
@@ -84,7 +85,7 @@ export function createAuthMiddleware(config) {
         }
         // Try JWT token
         const payload = verifyToken(token, config.jwtSecret);
-        if (!payload) {
+        if (!payload || !isDeviceAccessTokenActive(payload)) {
             return res.status(401).json({
                 ...API_ERRORS.UNAUTHORIZED,
                 message: 'Invalid or expired token',
@@ -195,7 +196,7 @@ export function optionalAuth(config) {
         }
         // Try JWT
         const payload = verifyToken(token, config.jwtSecret);
-        if (payload) {
+        if (payload && isDeviceAccessTokenActive(payload)) {
             req.auth = {
                 keyId: payload.type === 'api_key' ? payload.sub : undefined,
                 userId: payload.sub,

package/dist/server/routes/a2a-jsonrpc.d.ts

@@ -0,0 +1,9 @@
+import { Router } from 'express';
+import { type A2APeers } from '../../protocols/a2a/peer-config.js';
+import type { TaskExecutor } from '../../protocols/a2a/index.js';
+export declare function createA2AJsonRpcRoutes(options: {
+    publicUrl: string;
+    peers?: A2APeers;
+    executor?: TaskExecutor;
+    timeoutMs?: number;
+}): Router;

package/dist/server/routes/a2a-jsonrpc.js

@@ -0,0 +1,66 @@
+import express, { Router } from 'express';
+import { randomUUID } from 'node:crypto';
+import { A2AJsonRpcAdapter, rpcError } from '../../protocols/a2a/jsonrpc-v1.js';
+import { authenticateA2APeer, readA2APeers, validateA2AUrl } from '../../protocols/a2a/peer-config.js';
+import { createCodeBuddyTaskExecutor } from '../../protocols/a2a/codebuddy-executor.js';
+import { buildCodeBuddyAgentCard } from './a2a-protocol.js';
+import { initializeToolRegistry } from '../../codebuddy/tools.js';
+import { getPeerMethodHandler } from '../websocket/peer-method-registry.js';
+import { createRouteRateLimiter } from '../middleware/rate-limit.js';
+export function createA2AJsonRpcRoutes(options) {
+    const peers = options.peers ?? readA2APeers();
+    const url = validateA2AUrl(options.publicUrl).href;
+    const router = Router();
+    const identities = new WeakMap();
+    const allowedTools = ['view_file', 'list_directory', 'search'];
+    const executor = options.executor ?? createCodeBuddyTaskExecutor({ allowedTools, executeTool: async (name, args, task) => {
+            const invoke = getPeerMethodHandler('peer.tool.invoke');
+            if (!invoke)
+                return { success: false, error: 'Read-only peer bridge unavailable' };
+            // Reuse all three existing gates: operator allowlist, fleetSafe, real workspace containment.
+            const result = await invoke({ tool: name, args }, { connectionId: `a2a:${task.metadata?.peerId ?? 'unknown'}`,
+                scopes: ['peer:invoke'], traceId: randomUUID(), depth: 0 });
+            if (!result || typeof result !== 'object' || typeof result.output !== 'string' || result.error || result.success === false) {
+                return { success: false, error: 'Read-only peer bridge returned an invalid or failed result' };
+            }
+            return { success: true, output: result.output };
+        } });
+    if (!options.executor)
+        initializeToolRegistry();
+    const adapter = new A2AJsonRpcAdapter(executor, options.timeoutMs, Object.keys(peers).length);
+    const localCard = buildCodeBuddyAgentCard();
+    const card = { name: localCard.name, description: 'Code Buddy read-only A2A text subset; filesystem access requires configured peer workspace and permissions.',
+        version: localCard.version, supportedInterfaces: [{ url, protocolBinding: 'JSONRPC', protocolVersion: '1.0' }],
+        capabilities: { streaming: false, pushNotifications: false }, defaultInputModes: ['text/plain'], defaultOutputModes: ['text/plain'],
+        skills: localCard.skills.filter(skill => ['code-search', 'code-read'].includes(skill.id)),
+        securitySchemes: { bearer: { type: 'http', scheme: 'bearer' } }, security: [{ bearer: [] }] };
+    router.get(['/.well-known/agent-card.json', '/.well-known/agent.json'], (_req, res) => res.json(card));
+    router.post('/a2a/v1', (req, res, next) => {
+        const peer = authenticateA2APeer(peers, req.headers.authorization);
+        if (!peer) {
+            res.status(401).json({ error: 'A2A peer authentication required' });
+            return;
+        }
+        identities.set(req, peer);
+        next();
+    }, createRouteRateLimiter({ windowMs: 60000, maxRequests: 10, keyPrefix: 'a2a-jsonrpc-v1', keyGenerator: req => identities.get(req) ?? 'unauthorized' }), express.json({ limit: '1mb' }), async (req, res, next) => {
+        try {
+            const version = req.headers['a2a-version'];
+            if (Array.isArray(version)) {
+                res.json(rpcError(req.body?.id, -32602, 'Invalid A2A-Version'));
+                return;
+            }
+            res.json(await adapter.handle(identities.get(req), req.body, version));
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    const errors = (error, _req, res, _next) => {
+        const tooLarge = error?.type === 'entity.too.large';
+        res.status(tooLarge ? 413 : 400).json(rpcError(null, tooLarge ? -32600 : -32700, tooLarge ? 'Body exceeds 1 MiB' : 'Invalid A2A request'));
+    };
+    router.use(errors);
+    return router;
+}
+//# sourceMappingURL=a2a-jsonrpc.js.map

package/dist/server/routes/a2a-protocol.d.ts

@@ -9,4 +9,16 @@
  * - POST /api/a2a/tasks/:id/cancel — Cancel a task
  */
 import { Router } from 'express';
+import { type AgentCard } from '../../protocols/a2a/index.js';
+/**
+ * Code Buddy's local AgentCard. The skills declared here are the ONLY
+ * capabilities a remote peer can invoke against this instance via
+ * /tasks/send. They must stay in lockstep with the fleet-safe tool list
+ * (see `src/tools/metadata.ts:fleetSafe`) — declaring `code-edit` here
+ * while the executor only exposes read tools would be a dishonest card.
+ *
+ * Mutating skills (write/exec) intentionally NOT exposed in V1; they
+ * require an upgraded scope + per-peer quota that lives in the V2 backlog.
+ */
+export declare function buildCodeBuddyAgentCard(): AgentCard;
 export declare function createA2AProtocolRoutes(): Router;

package/dist/server/routes/a2a-protocol.js

@@ -24,7 +24,7 @@ import { initializeToolRegistry } from '../../codebuddy/tools.js';
  * Mutating skills (write/exec) intentionally NOT exposed in V1; they
  * require an upgraded scope + per-peer quota that lives in the V2 backlog.
  */
-function buildCodeBuddyAgentCard() {
+export function buildCodeBuddyAgentCard() {
     return createAgentCard({
         name: 'Code Buddy',
         description: 'Multi-provider AI coding agent. A2A inbound surface is read-only: search, view, web fetch, codebase analysis, reasoning. Mutating skills (edit/exec) require an upgraded scope and are not exposed by default.',

package/dist/server/routes/device-auth.d.ts

@@ -0,0 +1,4 @@
+import { Router } from 'express';
+import { type DeviceAuthStore } from '../auth/device-store.js';
+/** Public proof-of-possession endpoints; code issuance remains local to the CLI. */
+export declare function createDeviceAuthRoutes(secret: string, store?: DeviceAuthStore): Router;

package/dist/server/routes/device-auth.js

@@ -0,0 +1,40 @@
+import { Router } from 'express';
+import { DeviceAuthError, getDeviceAuthStore } from '../auth/device-store.js';
+import { createRouteRateLimiter } from '../middleware/rate-limit.js';
+/** Public proof-of-possession endpoints; code issuance remains local to the CLI. */
+export function createDeviceAuthRoutes(secret, store) {
+    const router = Router();
+    router.use((_req, res, next) => {
+        res.setHeader('Cache-Control', 'no-store');
+        next();
+    });
+    const getStore = () => store ?? getDeviceAuthStore();
+    for (const route of ['register', 'challenge', 'verify']) {
+        const limit = createRouteRateLimiter({
+            maxRequests: 10, windowMs: 60_000, keyPrefix: `device-auth:${route}`,
+            // Do not trust arbitrary X-Forwarded-For on these unauthenticated routes.
+            keyGenerator: req => req.socket.remoteAddress ?? 'unknown',
+            handler: (_req, res) => { res.status(429).json({ error: 'Too many requests' }); },
+        });
+        const handle = async (req, res) => {
+            const body = req.body && typeof req.body === 'object' && !Array.isArray(req.body)
+                ? req.body : {};
+            try {
+                const service = getStore();
+                const result = route === 'register'
+                    ? await service.register(body.pairingCode, body.deviceName, body.publicKeyJwk)
+                    : route === 'challenge'
+                        ? service.challenge(body.deviceId)
+                        : await service.verify(body.deviceId, body.nonce, body.signature, secret);
+                res.json(result);
+            }
+            catch (error) {
+                const failure = error instanceof DeviceAuthError ? error : new DeviceAuthError(503);
+                res.status(failure.status).json({ error: failure.message });
+            }
+        };
+        router.post(`/${route}`, limit, handle);
+    }
+    return router;
+}
+//# sourceMappingURL=device-auth.js.map