@jack200714/mafw 4.5.1

package/gateway/dist/mobile/device-store.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const MAX_DEVICES = 600;
+class DeviceStore {
+    filePath;
+    devices = new Map();
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const raw = fs.readFileSync(this.filePath, 'utf-8');
+                const data = JSON.parse(raw);
+                for (const d of data.devices || []) {
+                    this.devices.set(d.id, d);
+                }
+            }
+        }
+        catch {
+            // Corrupted file — start fresh
+            this.devices.clear();
+        }
+    }
+    save() {
+        const data = {
+            devices: Array.from(this.devices.values()),
+        };
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
+        try {
+            fs.chmodSync(this.filePath, 0o600);
+        }
+        catch { /* Windows: no POSIX perms */ }
+    }
+    register(input) {
+        if (!this.devices.has(input.id) && this.devices.size >= MAX_DEVICES) {
+            throw new Error(`Device limit reached (${MAX_DEVICES})`);
+        }
+        const entry = {
+            id: input.id,
+            fcmToken: input.fcmToken,
+            platform: input.platform,
+            apiTokenHash: input.apiTokenHash,
+            lastSeen: new Date().toISOString(),
+        };
+        this.devices.set(input.id, entry);
+        this.save();
+        return entry;
+    }
+    get(id) {
+        return this.devices.get(id);
+    }
+    list() {
+        return Array.from(this.devices.values());
+    }
+    remove(id) {
+        const existed = this.devices.delete(id);
+        if (existed)
+            this.save();
+        return existed;
+    }
+    /** Update lastSeen timestamp for an existing device (WS connect / heartbeat). */
+    touch(id) {
+        const entry = this.devices.get(id);
+        if (!entry)
+            return false;
+        entry.lastSeen = new Date().toISOString();
+        this.save();
+        return true;
+    }
+    /** Remove devices not seen since cutoff (ISO string). Returns removed IDs. */
+    pruneStale(cutoffIso) {
+        const removed = [];
+        for (const [id, entry] of this.devices) {
+            if (entry.lastSeen < cutoffIso) {
+                this.devices.delete(id);
+                removed.push(id);
+            }
+        }
+        if (removed.length > 0)
+            this.save();
+        return removed;
+    }
+}
+exports.DeviceStore = DeviceStore;

package/gateway/dist/mobile/mdns-advertiser.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * mDNS/DNS-SD advertiser for the MAFW Gateway.
+ *
+ * Broadcasts `_mafw._tcp` service so mobile apps can auto-discover the gateway
+ * on the local network (zero-config LAN connectivity, spec §5.1 P1).
+ *
+ * TXT records carry metadata:
+ *   - version: API version (e.g., "1.0")
+ *   - port: HTTP port
+ *   - ws: WebSocket path (/api/ws)
+ *   - auth: "token" if apiToken required, "open" otherwise
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdnsAdvertiser = void 0;
+const bonjour_service_1 = require("bonjour-service");
+class MdnsAdvertiser {
+    bonjour = null;
+    service = null;
+    start(config) {
+        const instanceName = config.instanceName || require('os').hostname();
+        const txt = {
+            version: '1.0',
+            port: String(config.apiPort),
+            ws: '/api/ws',
+            auth: config.apiToken ? 'token' : 'open',
+        };
+        try {
+            this.bonjour = new bonjour_service_1.Bonjour();
+            this.service = this.bonjour.publish({
+                name: `MAFW ${instanceName}`,
+                type: 'mafw',
+                port: config.apiPort,
+                txt,
+            });
+            console.log(`[mDNS] advertising _mafw._tcp on port ${config.apiPort} (instance: ${instanceName})`);
+        }
+        catch (err) {
+            console.warn('[mDNS] failed to start:', err);
+        }
+    }
+    stop() {
+        if (this.service) {
+            this.service.stop(() => {
+                console.log('[mDNS] stopped');
+            });
+            this.service = null;
+        }
+        if (this.bonjour) {
+            this.bonjour.destroy();
+            this.bonjour = null;
+        }
+    }
+}
+exports.MdnsAdvertiser = MdnsAdvertiser;

package/gateway/dist/mobile/media-proxy.js

@@ -0,0 +1,292 @@
+"use strict";
+/**
+ * Mobile media proxy — exposes MediaAgent capabilities to the mobile app
+ * via simple HTTP endpoints (no A2A protocol knowledge needed on the client).
+ *
+ * Endpoints:
+ *   POST /api/mobile/media/tasks        — multipart upload → A2A SendMessage → task
+ *   POST /api/mobile/media/tasks/:id/ask — follow-up question (auth proxy)
+ *
+ * Security:
+ *   - Auth handled by gateway's authorize() middleware (Bearer/x-api-token/?token=)
+ *   - Reuses MediaAgent's MAX_*_BYTES limits per media type
+ *   - Blocks external URLs (only artifact URLs accepted by MediaAgent)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMobileMediaHandler = createMobileMediaHandler;
+// Reuse size limits from media-agent to stay in sync (single source of truth).
+const media_agent_1 = require("../media/media-agent");
+function maxSizeForType(mediaType) {
+    if (mediaType.startsWith('video/'))
+        return media_agent_1.MAX_VIDEO_BYTES;
+    if (mediaType.startsWith('audio/'))
+        return media_agent_1.MAX_AUDIO_BYTES;
+    return media_agent_1.MAX_IMAGE_BYTES;
+}
+const SUPPORTED_MEDIA_PREFIXES = ['image/', 'video/', 'audio/'];
+/**
+ * Parse a multipart/form-data body. Returns the first file part.
+ * Uses Buffer.indexOf to avoid latin1 string copy on large payloads (I7).
+ * Falls back to latin1 string split for tiny payloads.
+ */
+function parseMultipartFirstFile(raw, boundary) {
+    const boundaryBuf = Buffer.from(`--${boundary}`);
+    const headerSep = Buffer.from('\r\n\r\n');
+    let pos = 0;
+    // Prefer Buffer.indexOf path for large payloads to reduce intermediate string alloc
+    if (raw.length > 1024 * 1024) {
+        while (true) {
+            const bIdx = raw.indexOf(boundaryBuf, pos);
+            if (bIdx < 0)
+                break;
+            const nextB = raw.indexOf(boundaryBuf, bIdx + boundaryBuf.length);
+            const sectionEnd = nextB < 0 ? raw.length : nextB;
+            const headerEnd = raw.indexOf(headerSep, bIdx);
+            if (headerEnd < 0 || headerEnd >= sectionEnd) {
+                pos = bIdx + boundaryBuf.length;
+                continue;
+            }
+            const headerPart = raw.subarray(bIdx, headerEnd).toString('utf8');
+            const bodyStart = headerEnd + headerSep.length;
+            let bodyEnd = sectionEnd;
+            // trim trailing \r\n
+            if (bodyEnd - 2 >= bodyStart && raw[bodyEnd - 2] === 0x0d && raw[bodyEnd - 1] === 0x0a)
+                bodyEnd -= 2;
+            const nameMatch = headerPart.match(/name="([^"]+)"/);
+            const filenameMatch = headerPart.match(/filename="([^"]+)"/);
+            const ctMatch = headerPart.match(/Content-Type:\s*(.+)/i);
+            if (filenameMatch && nameMatch) {
+                return {
+                    name: nameMatch[1],
+                    filename: filenameMatch[1],
+                    contentType: ctMatch?.[1]?.trim() || 'application/octet-stream',
+                    data: Buffer.from(raw.subarray(bodyStart, bodyEnd)),
+                };
+            }
+            pos = bIdx + boundaryBuf.length;
+        }
+        return null;
+    }
+    const sections = raw.toString('latin1').split(`--${boundary}`);
+    for (const section of sections) {
+        if (section.trim() === '' || section.trim() === '--')
+            continue;
+        const headerEnd = section.indexOf('\r\n\r\n');
+        if (headerEnd < 0)
+            continue;
+        const headerPart = section.slice(0, headerEnd);
+        const bodyPart = section.slice(headerEnd + 4);
+        const bodyClean = bodyPart.replace(/\r\n$/, '');
+        const nameMatch = headerPart.match(/name="([^"]+)"/);
+        const filenameMatch = headerPart.match(/filename="([^"]+)"/);
+        const ctMatch = headerPart.match(/Content-Type:\s*(.+)/i);
+        if (filenameMatch && nameMatch) {
+            return {
+                name: nameMatch[1],
+                filename: filenameMatch[1],
+                contentType: ctMatch?.[1]?.trim() || 'application/octet-stream',
+                data: Buffer.from(bodyClean, 'latin1'),
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Read the full request body as a Buffer.
+ */
+function readBodyBuffer(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+    });
+}
+/**
+ * Read the full request body as a string.
+ */
+function readBodyString(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => body += chunk);
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+function jsonResponse(res, status, data) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data));
+}
+/**
+ * Server-side image compression safety net.
+ * Resizes images larger than maxDim pixels on the longest side to JPEG quality 85.
+ * Falls back to original buffer if sharp is not available or compression fails.
+ */
+async function compressImageIfLarger(data, maxDim) {
+    try {
+        // Dynamic import — sharp is an optional peer dependency.
+        // If not installed, skip compression silently (client-side compression is primary).
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const sharpFn = require('sharp');
+        const meta = await sharpFn(data).metadata();
+        const w = meta.width ?? 0;
+        const h = meta.height ?? 0;
+        if (Math.max(w, h) <= maxDim)
+            return data;
+        return await sharpFn(data)
+            .resize({ width: maxDim, height: maxDim, fit: 'inside', withoutEnlargement: true })
+            .jpeg({ quality: 85 })
+            .toBuffer();
+    }
+    catch {
+        // sharp not installed or processing error — pass through original
+        return data;
+    }
+}
+/**
+ * Creates a request handler for the mobile media proxy routes.
+ * Returns true if the request was handled, false if not matched.
+ */
+function createMobileMediaHandler(deps) {
+    const { agent } = deps;
+    return async (req, res) => {
+        // ── POST /api/mobile/media/tasks — multipart upload → A2A task ──
+        if (req.url?.match(/^\/api\/mobile\/media\/tasks(?:\?|$)/) && req.method === 'POST') {
+            // Must be multipart
+            const contentTypeHeader = req.headers['content-type'] || '';
+            if (!contentTypeHeader.includes('multipart/form-data')) {
+                jsonResponse(res, 400, { error: 'Content-Type must be multipart/form-data' });
+                return true;
+            }
+            const boundaryMatch = contentTypeHeader.match(/boundary=(.+)/);
+            if (!boundaryMatch) {
+                jsonResponse(res, 400, { error: 'missing multipart boundary' });
+                return true;
+            }
+            const boundary = boundaryMatch[1];
+            try {
+                // Early header check: reject > max before buffering large body to avoid OOM
+                const clen = parseInt(String(req.headers['content-length'] || '0'), 10);
+                if (clen > 55 * 1024 * 1024) {
+                    jsonResponse(res, 413, { error: 'payload too large' });
+                    return true;
+                }
+                const raw = await readBodyBuffer(req);
+                const file = parseMultipartFirstFile(raw, boundary);
+                if (!file) {
+                    jsonResponse(res, 400, { error: 'no file part in multipart body' });
+                    return true;
+                }
+                // Validate media type
+                if (!SUPPORTED_MEDIA_PREFIXES.some(p => file.contentType.startsWith(p))) {
+                    jsonResponse(res, 415, { error: `Unsupported media type: ${file.contentType}` });
+                    return true;
+                }
+                // Validate size
+                const maxBytes = maxSizeForType(file.contentType);
+                if (file.data.length > maxBytes) {
+                    jsonResponse(res, 413, {
+                        error: `Media exceeds ${(maxBytes / (1024 * 1024)).toFixed(0)}MB limit`,
+                    });
+                    return true;
+                }
+                // Compress images > 1280px as server-side safety net (client may also compress)
+                let uploadData = file.data;
+                if (file.contentType.startsWith('image/') && !file.contentType.includes('svg')) {
+                    uploadData = await compressImageIfLarger(uploadData, 1280);
+                }
+                // Store artifact
+                const artifactId = agent.putArtifactBytes(uploadData, file.contentType);
+                const port = req.socket?.localPort || 3000;
+                const baseUrl = `http://127.0.0.1:${port}`;
+                // Create A2A task via SendMessage
+                const payload = {
+                    jsonrpc: '2.0',
+                    id: 1,
+                    method: 'SendMessage',
+                    params: {
+                        message: {
+                            messageId: `mob-${Date.now()}`,
+                            role: 1,
+                            parts: [
+                                { url: `/a2a/artifacts/${artifactId}`, mediaType: file.contentType, filename: file.filename },
+                            ],
+                        },
+                    },
+                };
+                const result = await agent.handleJsonRpc(payload, { 'a2a-version': '1.0' });
+                const parsed = JSON.parse(result.body);
+                if (parsed?.error) {
+                    jsonResponse(res, result.status || 502, { error: parsed.error });
+                    return true;
+                }
+                const task = parsed?.result?.task;
+                if (!task?.id) {
+                    jsonResponse(res, 502, { error: 'no task returned' });
+                    return true;
+                }
+                jsonResponse(res, 200, {
+                    id: task.id,
+                    contextId: task.contextId,
+                    state: task.status?.state || '',
+                    artifactId,
+                });
+                return true;
+            }
+            catch (err) {
+                jsonResponse(res, 500, { error: err?.message || String(err) });
+                return true;
+            }
+        }
+        // ── POST /api/mobile/media/tasks/:id/ask — follow-up question ──
+        const askMatch = req.url?.match(/^\/api\/mobile\/media\/tasks\/([^/]+)\/ask(?:\?|$)/);
+        if (askMatch && req.method === 'POST') {
+            const taskId = askMatch[1];
+            try {
+                const bodyStr = await readBodyString(req);
+                const { question } = JSON.parse(bodyStr);
+                if (!question || typeof question !== 'string' || !question.trim()) {
+                    jsonResponse(res, 400, { error: 'question is required' });
+                    return true;
+                }
+                // Block external URLs in question text (defense-in-depth SSRF protection).
+                // Catches: http(s), ftp, file protocol handlers, IP literals, localhost, encoded variants.
+                if (/https?:\/\//i.test(question) || /file:\/\//i.test(question) || /ftp:\/\//i.test(question) ||
+                    /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/.test(question) ||
+                    /localhost/i.test(question) || /\[::1\]/i.test(question)) {
+                    jsonResponse(res, 400, { error: 'external URLs are not allowed in questions' });
+                    return true;
+                }
+                // Delegate to A2A SendMessage with referenceTaskIds
+                const payload = {
+                    jsonrpc: '2.0',
+                    id: 2,
+                    method: 'SendMessage',
+                    params: {
+                        message: {
+                            messageId: `mob-ask-${Date.now()}`,
+                            role: 1,
+                            parts: [{ text: question }],
+                            referenceTaskIds: [taskId],
+                        },
+                    },
+                };
+                const result = await agent.handleJsonRpc(payload, { 'a2a-version': '1.0' });
+                const parsed = JSON.parse(result.body);
+                if (parsed?.error) {
+                    jsonResponse(res, result.status || 502, { error: parsed.error });
+                    return true;
+                }
+                const task = parsed?.result?.task;
+                const answer = task?.status?.message?.parts?.[0]?.text || '';
+                jsonResponse(res, 200, { answer, taskId: task?.id });
+                return true;
+            }
+            catch (err) {
+                jsonResponse(res, 500, { error: err?.message || String(err) });
+                return true;
+            }
+        }
+        return false; // Not handled
+    };
+}

package/gateway/dist/mobile/pairing.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairingService = void 0;
+const crypto = __importStar(require("crypto"));
+function hashNonce(nonce) {
+    return crypto.createHash('sha256').update(nonce).digest('hex');
+}
+class PairingService {
+    nonces = new Map();
+    rateLimits = new Map();
+    apiToken;
+    tailscaleUrl;
+    ttlMs;
+    rateLimit;
+    cleanupTimer = null;
+    constructor(config) {
+        this.apiToken = config.apiToken;
+        this.tailscaleUrl = config.tailscaleUrl;
+        this.ttlMs = config.ttlMs ?? 5 * 60 * 1000;
+        this.rateLimit = config.rateLimit ?? 5;
+        // Periodic cleanup every 60s — unref so it doesn't pin the process exit
+        this.cleanupTimer = setInterval(() => this.cleanup(), 60_000);
+        // allow process to exit gracefully when this is the last handle
+        if (this.cleanupTimer.unref)
+            this.cleanupTimer.unref();
+    }
+    /**
+     * Generate a one-time pairing URL. Rate-limit applies to non-loopback only;
+     * loopback is exempt because the operator is local and trusted (spec §6.1
+     * allows local generation without throttling). Documented here for audit.
+     */
+    generatePairingCode(ip) {
+        const isLoopback = ip === '127.0.0.1' || ip.startsWith('127.') || ip === '::1' || ip === '::ffff:127.0.0.1';
+        if (!isLoopback) {
+            this.checkRateLimit(ip);
+        }
+        const nonce = crypto.randomBytes(16).toString('hex');
+        const exp = Date.now() + this.ttlMs;
+        this.nonces.set(hashNonce(nonce), { hash: hashNonce(nonce), expiresAt: exp });
+        const params = new URLSearchParams({
+            url: this.tailscaleUrl,
+            token: this.apiToken,
+            v: '1',
+            exp: String(exp),
+            nonce,
+        });
+        return { url: `mafw://pair?${params.toString()}` };
+    }
+    /**
+     * Consume a nonce: check TTL validity and delete (single-use by deletion).
+     * Returns true if the nonce was valid and consumed.
+     */
+    consumeNonce(nonce) {
+        const h = hashNonce(nonce);
+        const entry = this.nonces.get(h);
+        if (!entry)
+            return false;
+        if (Date.now() > entry.expiresAt) {
+            this.nonces.delete(h);
+            return false;
+        }
+        this.nonces.delete(h);
+        return true;
+    }
+    checkRateLimit(ip) {
+        const now = Date.now();
+        const bucket = this.rateLimits.get(ip);
+        if (!bucket || now - bucket.windowStart > 60_000) {
+            this.rateLimits.set(ip, { count: 1, windowStart: now });
+            return;
+        }
+        bucket.count++;
+        if (bucket.count > this.rateLimit) {
+            throw new Error(`Rate limit exceeded for ${ip}: max ${this.rateLimit} codes per minute`);
+        }
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [nonce, entry] of this.nonces) {
+            if (now > entry.expiresAt) {
+                this.nonces.delete(nonce);
+            }
+        }
+        for (const [ip, bucket] of this.rateLimits) {
+            if (now - bucket.windowStart > 60_000) {
+                this.rateLimits.delete(ip);
+            }
+        }
+    }
+    /** Hot-update credentials after config token tailnet url change (no restart). */
+    updateConfig(opts) {
+        if (opts.apiToken !== undefined)
+            this.apiToken = opts.apiToken;
+        if (opts.tailscaleUrl !== undefined)
+            this.tailscaleUrl = opts.tailscaleUrl;
+    }
+    destroy() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        this.nonces.clear();
+        this.rateLimits.clear();
+    }
+}
+exports.PairingService = PairingService;