npm - @rubytech/taskmaster - Versions diffs - 1.0.94 → 1.0.96 - Mend

@rubytech/taskmaster 1.0.94 → 1.0.96

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

package/dist/agents/taskmaster-tools.js +4 -4
package/dist/agents/tool-policy.js +2 -2
package/dist/agents/tools/contact-lookup-tool.js +45 -0
package/dist/agents/tools/contact-update-tool.js +68 -0
package/dist/agents/tools/memory-tool.js +10 -3
package/dist/build-info.json +3 -3
package/dist/cli/provision-seed.js +2 -2
package/dist/control-ui/assets/index-6WdtDXJj.css +1 -0
package/dist/control-ui/assets/index-lbNnMWBM.js +3508 -0
package/dist/control-ui/assets/index-lbNnMWBM.js.map +1 -0
package/dist/control-ui/index.html +2 -2
package/dist/gateway/chat-sanitize.js +121 -5
package/dist/gateway/media-http.js +120 -0
package/dist/gateway/protocol/schema/logs-chat.js +4 -0
package/dist/gateway/public-chat-api.js +5 -3
package/dist/gateway/server-http.js +3 -0
package/dist/gateway/server-methods/chat.js +12 -5
package/dist/gateway/server-methods/wifi.js +202 -0
package/dist/gateway/server-methods.js +2 -0
package/dist/infra/heartbeat-infra-alert.js +143 -0
package/dist/infra/heartbeat-runner.js +13 -0
package/dist/memory/manager.js +15 -8
package/extensions/diagnostics-otel/node_modules/.bin/acorn +0 -0
package/extensions/googlechat/node_modules/.bin/taskmaster +0 -0
package/extensions/line/node_modules/.bin/taskmaster +0 -0
package/extensions/matrix/node_modules/.bin/markdown-it +0 -0
package/extensions/matrix/node_modules/.bin/taskmaster +0 -0
package/extensions/memory-lancedb/node_modules/.bin/arrow2csv +0 -0
package/extensions/memory-lancedb/node_modules/.bin/openai +0 -0
package/extensions/msteams/node_modules/.bin/taskmaster +0 -0
package/extensions/nostr/node_modules/.bin/taskmaster +0 -0
package/extensions/nostr/node_modules/.bin/tsc +0 -0
package/extensions/nostr/node_modules/.bin/tsserver +0 -0
package/extensions/zalo/node_modules/.bin/taskmaster +0 -0
package/extensions/zalouser/node_modules/.bin/taskmaster +0 -0
package/package.json +64 -54
package/scripts/install.sh +0 -0
package/taskmaster-docs/USER-GUIDE.md +1 -1
package/dist/control-ui/assets/index-B7exVNNa.css +0 -1
package/dist/control-ui/assets/index-DfQL37PU.js +0 -3379
package/dist/control-ui/assets/index-DfQL37PU.js.map +0 -1
package/templates/.DS_Store +0 -0
package/templates/customer/.DS_Store +0 -0
package/templates/customer/agents/.DS_Store +0 -0
package/templates/taskmaster/.gitignore +0 -1

package/dist/control-ui/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <title>Taskmaster Control</title>
     <meta name="color-scheme" content="dark light" />
     <link rel="icon" type="image/png" href="./favicon.png" />
-    <script type="module" crossorigin src="./assets/index-DfQL37PU.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-B7exVNNa.css">
+    <script type="module" crossorigin src="./assets/index-lbNnMWBM.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-6WdtDXJj.css">
   </head>
   <body>
     <taskmaster-app></taskmaster-app>

package/dist/gateway/chat-sanitize.js CHANGED Viewed

@@ -119,13 +119,18 @@ export function stripEnvelopeFromMessages(messages) {
     return changed ? next : messages;
 }
 // ---------------------------------------------------------------------------
-// Base64 image stripping
+// Base64 image stripping & media URL references
 // ---------------------------------------------------------------------------
-// Images must be stored as physical files on disk and referenced by path —
-// never as inline base64 in transcripts or chat history responses.
-// These functions remove base64 data from image content blocks wherever
-// they appear (user, assistant, tool messages).
+// Images are stored as physical files on disk and referenced by path.
+// When sending chat history to the UI, base64 image data is replaced with
+// URL references to the /api/media endpoint. The UI renders these as <img>.
+//
+// Flow:
+// 1. Extract file paths from [media attached: /path (type)] text annotations
+// 2. Remove base64 image blocks from content
+// 3. Add { type: "image", url: "/api/media?path=..." } blocks
 // ---------------------------------------------------------------------------
+import nodePath from "node:path";
 function isBase64ImageBlock(block) {
     if (!block || typeof block !== "object")
         return false;
@@ -148,6 +153,33 @@ function isBase64ImageBlock(block) {
     }
     return false;
 }
+// Pattern: [media attached: /path (mime/type)] or [media attached 1/2: /path (mime/type) | url]
+const MEDIA_PATH_PATTERN = /\[media attached(?:\s+\d+\/\d+)?:\s*(.+?)\s*\(([^)]+)\)(?:\s*\|[^\]]+)?\]/gi;
+/**
+ * Parse [media attached: ...] annotations from text to extract file paths.
+ */
+function extractMediaRefs(text) {
+    if (!text.includes("[media attached"))
+        return [];
+    const refs = [];
+    let match;
+    MEDIA_PATH_PATTERN.lastIndex = 0;
+    while ((match = MEDIA_PATH_PATTERN.exec(text)) !== null) {
+        const absPath = match[1]?.trim();
+        const mimeType = match[2]?.trim();
+        if (absPath && mimeType) {
+            refs.push({ absPath, mimeType });
+        }
+    }
+    return refs;
+}
+function mediaRefToUrl(ref, workspaceRoot) {
+    const relPath = nodePath.relative(workspaceRoot, ref.absPath);
+    // Must stay within workspace (no ../ escapes)
+    if (relPath.startsWith("..") || nodePath.isAbsolute(relPath))
+        return null;
+    return `/api/media?path=${encodeURIComponent(relPath)}`;
+}
 function stripBase64FromContentBlocks(content) {
     let changed = false;
     const next = content.map((block) => {
@@ -193,3 +225,87 @@ export function stripBase64ImagesFromMessages(messages) {
     });
     return changed ? next : messages;
 }
+// ---------------------------------------------------------------------------
+// Combined media sanitization for chat display
+// ---------------------------------------------------------------------------
+/**
+ * Sanitize media in chat messages for UI display.
+ * - Extracts file paths from [media attached: ...] text annotations
+ * - Removes base64 image blocks
+ * - Creates URL-based image references for the /api/media endpoint
+ *
+ * Must be called BEFORE stripEnvelopeFromMessages (which strips annotations).
+ */
+export function sanitizeMediaForChat(messages, workspaceRoot) {
+    if (messages.length === 0 || !workspaceRoot) {
+        // No workspace context — fall back to plain base64 stripping
+        return stripBase64ImagesFromMessages(messages);
+    }
+    let changed = false;
+    const next = messages.map((message) => {
+        const result = sanitizeMessageMedia(message, workspaceRoot);
+        if (result !== message)
+            changed = true;
+        return result;
+    });
+    return changed ? next : messages;
+}
+function sanitizeMessageMedia(message, workspaceRoot) {
+    if (!message || typeof message !== "object")
+        return message;
+    const entry = message;
+    // Collect media refs from text content (works for both string and array content)
+    const mediaRefs = extractMediaRefsFromMessage(entry);
+    // Build URL-based image blocks from annotations
+    const imageBlocks = [];
+    for (const ref of mediaRefs) {
+        const url = mediaRefToUrl(ref, workspaceRoot);
+        if (url) {
+            imageBlocks.push({ type: "image", url });
+        }
+    }
+    if (!Array.isArray(entry.content)) {
+        // String content — no base64 blocks to strip, just add image blocks if found
+        if (imageBlocks.length === 0)
+            return message;
+        const textContent = typeof entry.content === "string" ? entry.content : "";
+        return {
+            ...entry,
+            content: [{ type: "text", text: textContent }, ...imageBlocks],
+        };
+    }
+    // Array content — remove base64 image blocks, add URL-based ones
+    let didChange = false;
+    const filtered = entry.content.filter((block) => {
+        if (isBase64ImageBlock(block)) {
+            didChange = true;
+            return false;
+        }
+        return true;
+    });
+    if (imageBlocks.length > 0) {
+        didChange = true;
+        filtered.push(...imageBlocks);
+    }
+    if (!didChange)
+        return message;
+    return { ...entry, content: filtered };
+}
+function extractMediaRefsFromMessage(entry) {
+    if (typeof entry.content === "string") {
+        return extractMediaRefs(entry.content);
+    }
+    if (Array.isArray(entry.content)) {
+        const refs = [];
+        for (const block of entry.content) {
+            if (!block || typeof block !== "object")
+                continue;
+            const b = block;
+            if (b.type === "text" && typeof b.text === "string") {
+                refs.push(...extractMediaRefs(b.text));
+            }
+        }
+        return refs;
+    }
+    return [];
+}

package/dist/gateway/media-http.js ADDED Viewed

@@ -0,0 +1,120 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveAgentWorkspaceRoot } from "../agents/agent-scope.js";
+// ---------------------------------------------------------------------------
+// Workspace media file endpoint
+// ---------------------------------------------------------------------------
+// Serves image files from the workspace root so that chat history can display
+// inline images by URL instead of embedding base64 data in WebSocket messages.
+//
+// Route:  GET /api/media?path=<workspace-relative-path>
+// ---------------------------------------------------------------------------
+const ALLOWED_IMAGE_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".heic",
+    ".heif",
+    ".bmp",
+    ".tiff",
+    ".tif",
+    ".pdf",
+]);
+function contentType(ext) {
+    switch (ext) {
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        case ".heic":
+            return "image/heic";
+        case ".heif":
+            return "image/heif";
+        case ".bmp":
+            return "image/bmp";
+        case ".tiff":
+        case ".tif":
+            return "image/tiff";
+        case ".pdf":
+            return "application/pdf";
+        default:
+            return "application/octet-stream";
+    }
+}
+function isSafeRelativePath(relPath) {
+    if (!relPath)
+        return false;
+    const normalized = path.posix.normalize(relPath);
+    if (normalized.startsWith("../") || normalized === "..")
+        return false;
+    if (normalized.includes("\0"))
+        return false;
+    return true;
+}
+export function resolveWorkspaceRoot(config) {
+    return resolveAgentWorkspaceRoot(config, "admin");
+}
+export function handleMediaRequest(req, res, opts) {
+    const urlObj = new URL(req.url ?? "/", "http://localhost");
+    if (urlObj.pathname !== "/api/media")
+        return false;
+    if (req.method !== "GET" && req.method !== "HEAD") {
+        res.statusCode = 405;
+        res.setHeader("Allow", "GET, HEAD");
+        res.end();
+        return true;
+    }
+    const relPath = urlObj.searchParams.get("path") ?? "";
+    if (!relPath || !isSafeRelativePath(relPath)) {
+        res.statusCode = 404;
+        res.end("Not Found");
+        return true;
+    }
+    const ext = path.extname(relPath).toLowerCase();
+    if (!ALLOWED_IMAGE_EXTENSIONS.has(ext)) {
+        res.statusCode = 403;
+        res.end("Forbidden");
+        return true;
+    }
+    const workspaceRoot = resolveWorkspaceRoot(opts.config);
+    const filePath = path.resolve(workspaceRoot, relPath);
+    // Boundary check: must stay within workspace
+    if (!filePath.startsWith(workspaceRoot + path.sep) && filePath !== workspaceRoot) {
+        res.statusCode = 403;
+        res.end("Forbidden");
+        return true;
+    }
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+    }
+    catch {
+        res.statusCode = 404;
+        res.end("Not Found");
+        return true;
+    }
+    if (!stat.isFile()) {
+        res.statusCode = 404;
+        res.end("Not Found");
+        return true;
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", contentType(ext));
+    res.setHeader("Content-Length", stat.size);
+    res.setHeader("Cache-Control", "private, max-age=86400");
+    if (req.method === "HEAD") {
+        res.end();
+    }
+    else {
+        const stream = fs.createReadStream(filePath);
+        stream.pipe(res);
+    }
+    return true;
+}

package/dist/gateway/protocol/schema/logs-chat.js CHANGED Viewed

@@ -17,6 +17,10 @@ export const LogsTailResultSchema = Type.Object({
 export const ChatHistoryParamsSchema = Type.Object({
     sessionKey: NonEmptyString,
     limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 10_000 })),
+    /** Number of messages to skip from the end (newest) before applying limit.
+     *  offset=0 (default) returns the most recent `limit` messages.
+     *  offset=50 with limit=50 returns messages 51–100 from the end. */
+    offset: Type.Optional(Type.Integer({ minimum: 0 })),
     /** When set, read from this specific session transcript instead of the current one. */
     sessionId: Type.Optional(NonEmptyString),
     /** When true, preserve envelope headers (channel, timestamp, sender metadata) on user messages.

package/dist/gateway/public-chat-api.js CHANGED Viewed

@@ -36,7 +36,8 @@ import { requestOtp, verifyOtp } from "./public-chat/otp.js";
 import { deliverOtp } from "./public-chat/deliver-otp.js";
 import { buildPublicSessionKey, resolvePublicAgentId } from "./public-chat/session.js";
 import { loadSessionEntry, readSessionMessages } from "./session-utils.js";
-import { stripBase64ImagesFromMessages, stripEnvelopeFromMessages } from "./chat-sanitize.js";
+import { sanitizeMediaForChat, stripEnvelopeFromMessages } from "./chat-sanitize.js";
+import { resolveWorkspaceRoot } from "./media-http.js";
 import { readJsonBodyOrError, sendInvalidRequest, sendJson, sendMethodNotAllowed, setSseHeaders, writeDone, } from "./http-common.js";
 // ---------------------------------------------------------------------------
 // Helpers
@@ -597,7 +598,7 @@ async function handleChatHistory(req, res) {
         sendInvalidRequest(res, "X-Session-Key header required");
         return;
     }
-    const { storePath, entry } = loadSessionEntry(sessionKey);
+    const { cfg, storePath, entry } = loadSessionEntry(sessionKey);
     const sessionId = entry?.sessionId;
     let rawMessages = [];
     if (entry && storePath) {
@@ -620,7 +621,8 @@ async function handleChatHistory(req, res) {
     const limitParam = url.searchParams.get("limit");
     const requested = limitParam ? Math.min(10_000, Math.max(1, Number(limitParam) || 5000)) : 5000;
     const messages = rawMessages.length > requested ? rawMessages.slice(-requested) : rawMessages;
-    const sanitized = stripEnvelopeFromMessages(stripBase64ImagesFromMessages(messages));
+    const workspaceRoot = resolveWorkspaceRoot(cfg);
+    const sanitized = stripEnvelopeFromMessages(sanitizeMediaForChat(messages, workspaceRoot));
     sendJson(res, 200, {
         session_key: sessionKey,
         messages: sanitized,

package/dist/gateway/server-http.js CHANGED Viewed

@@ -13,6 +13,7 @@ import { extractHookToken, getHookChannelError, normalizeAgentPayload, normalize
 import { applyHookMappings } from "./hooks-mapping.js";
 import { handleOpenAiHttpRequest } from "./openai-http.js";
 import { handleOpenResponsesHttpRequest } from "./openresponses-http.js";
+import { handleMediaRequest } from "./media-http.js";
 import { handleToolsInvokeHttpRequest } from "./tools-invoke-http.js";
 function sendJson(res, status, body) {
     res.statusCode = status;
@@ -226,6 +227,8 @@ export function createGatewayHttpServer(opts) {
                 }))
                     return;
             }
+            if (handleMediaRequest(req, res, { config: configSnapshot }))
+                return;
             if (canvasHost) {
                 if (await handleA2uiHttpRequest(req, res))
                     return;

package/dist/gateway/server-methods/chat.js CHANGED Viewed

@@ -15,7 +15,8 @@ import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel.js";
 import { abortChatRunById, abortChatRunsForSessionKey, isChatStopCommandText, resolveChatRunExpiresAtMs, } from "../chat-abort.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateChatAbortParams, validateChatHistoryParams, validateChatInjectParams, validateChatSendParams, } from "../protocol/index.js";
 import { loadSessionEntry, readSessionMessages, resolveSessionModelRef } from "../session-utils.js";
-import { stripBase64ImagesFromMessages, stripEnvelopeFromMessages } from "../chat-sanitize.js";
+import { sanitizeMediaForChat, stripEnvelopeFromMessages } from "../chat-sanitize.js";
+import { resolveWorkspaceRoot } from "../media-http.js";
 import { formatForLog } from "../ws-log.js";
 function resolveTranscriptPath(params) {
     const { sessionId, storePath, sessionFile } = params;
@@ -138,7 +139,7 @@ export const chatHandlers = {
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid chat.history params: ${formatValidationErrors(validateChatHistoryParams.errors)}`));
             return;
         }
-        const { sessionKey, limit, sessionId: requestedSessionId, preserveEnvelopes, } = params;
+        const { sessionKey, limit, offset, sessionId: requestedSessionId, preserveEnvelopes, } = params;
         const publicError = validatePublicSessionAccess(client?.connect?.role, sessionKey);
         if (publicError) {
             respond(false, undefined, publicError);
@@ -184,13 +185,18 @@ export const chatHandlers = {
                 rawMessages.push(...current);
             }
         }
+        const totalMessages = rawMessages.length;
         const hardMax = 10_000;
         const defaultLimit = 5000;
         const requested = typeof limit === "number" ? limit : defaultLimit;
         const max = Math.min(hardMax, requested);
-        const messages = rawMessages.length > max ? rawMessages.slice(-max) : rawMessages;
-        const withoutBase64 = stripBase64ImagesFromMessages(messages);
-        const sanitized = preserveEnvelopes ? withoutBase64 : stripEnvelopeFromMessages(withoutBase64);
+        const skip = typeof offset === "number" ? Math.min(offset, totalMessages) : 0;
+        const end = totalMessages - skip;
+        const start = Math.max(0, end - max);
+        const messages = start === 0 && end === totalMessages ? rawMessages : rawMessages.slice(start, end);
+        const workspaceRoot = resolveWorkspaceRoot(cfg);
+        const withMediaUrls = sanitizeMediaForChat(messages, workspaceRoot);
+        const sanitized = preserveEnvelopes ? withMediaUrls : stripEnvelopeFromMessages(withMediaUrls);
         // Diagnostic: log resolution details so we can trace "lost history" reports.
         const prevCount = entry?.previousSessions?.length ?? 0;
         context.logGateway.info(`chat.history: sessionKey=${sessionKey} resolvedSessionId=${sessionId ?? "none"} storePath=${storePath ?? "none"} entryExists=${!!entry} previousSessions=${prevCount} rawMessages=${rawMessages.length} sent=${sanitized.length}`);
@@ -219,6 +225,7 @@ export const chatHandlers = {
             sessionKey,
             sessionId,
             messages: sanitized,
+            totalMessages,
             thinkingLevel,
             modelProvider,
             model: modelId,

package/dist/gateway/server-methods/wifi.js ADDED Viewed

@@ -0,0 +1,202 @@
+/**
+ * RPC handlers for WiFi network management on Linux (Raspberry Pi).
+ * Uses nmcli (NetworkManager CLI) which ships with Raspberry Pi OS Bookworm.
+ * All methods require operator.admin scope (enforced by the catch-all in server-methods.ts).
+ */
+import os from "node:os";
+import { runExec } from "../../process/exec.js";
+import { ErrorCodes, errorShape } from "../protocol/index.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function requireLinux(respond) {
+    if (os.platform() !== "linux") {
+        respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "WiFi management is only available on Linux"));
+        return false;
+    }
+    return true;
+}
+async function nmcliAvailable() {
+    try {
+        await runExec("nmcli", ["--version"], { timeoutMs: 3_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse nmcli terse output for wifi list.
+ * Fields: IN-USE, SSID, SIGNAL, SECURITY
+ * Terse format uses `:` as separator; SSIDs containing `:` are escaped by nmcli
+ * with `\:`, so we split carefully.
+ */
+function parseWifiList(stdout) {
+    const seen = new Set();
+    const networks = [];
+    for (const line of stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        // nmcli terse output escapes colons in SSIDs as \:
+        // Split on unescaped colons by replacing \: with a placeholder first
+        const placeholder = "\x00";
+        const safe = line.replace(/\\:/g, placeholder);
+        const parts = safe.split(":");
+        if (parts.length < 4)
+            continue;
+        const inUse = parts[0].replace(new RegExp(placeholder, "g"), ":").trim() === "*";
+        const ssid = parts[1].replace(new RegExp(placeholder, "g"), ":").trim();
+        const signal = parseInt(parts[2], 10);
+        const security = parts.slice(3).join(":").replace(new RegExp(placeholder, "g"), ":").trim();
+        if (!ssid)
+            continue; // Skip hidden/empty SSIDs
+        if (seen.has(ssid))
+            continue; // Deduplicate
+        seen.add(ssid);
+        networks.push({
+            ssid,
+            signal: isNaN(signal) ? 0 : signal,
+            security: security || "Open",
+            active: inUse,
+        });
+    }
+    // Sort by signal strength descending (strongest first)
+    networks.sort((a, b) => b.signal - a.signal);
+    return networks;
+}
+/**
+ * Get the IPv4 address of the active WiFi interface.
+ */
+async function getWifiIp() {
+    try {
+        const { stdout } = await runExec("nmcli", ["-t", "-f", "IP4.ADDRESS", "dev", "show", "wlan0"], {
+            timeoutMs: 5_000,
+        });
+        // Output like: IP4.ADDRESS[1]:192.168.1.100/24
+        for (const line of stdout.split("\n")) {
+            if (line.startsWith("IP4.ADDRESS")) {
+                const addr = line.split(":")[1]?.split("/")[0]?.trim();
+                if (addr)
+                    return addr;
+            }
+        }
+    }
+    catch {
+        // Fallback: not critical
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+export const wifiHandlers = {
+    /**
+     * Return current WiFi connection status.
+     */
+    "wifi.status": async ({ respond, context }) => {
+        if (!requireLinux(respond))
+            return;
+        try {
+            if (!(await nmcliAvailable())) {
+                respond(true, {
+                    available: false,
+                    connected: false,
+                    ssid: null,
+                    signal: null,
+                    ip: null,
+                });
+                return;
+            }
+            // Check active WiFi connection
+            const { stdout } = await runExec("nmcli", ["-t", "-f", "IN-USE,SSID,SIGNAL,SECURITY", "dev", "wifi", "list"], { timeoutMs: 10_000 });
+            const networks = parseWifiList(stdout);
+            const active = networks.find((n) => n.active);
+            const ip = active ? await getWifiIp() : null;
+            respond(true, {
+                available: true,
+                connected: !!active,
+                ssid: active?.ssid ?? null,
+                signal: active?.signal ?? null,
+                ip,
+            });
+        }
+        catch (err) {
+            context.logGateway.warn(`wifi.status failed: ${err instanceof Error ? err.message : String(err)}`);
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "Failed to check WiFi status"));
+        }
+    },
+    /**
+     * Scan for available WiFi networks. Triggers a rescan.
+     */
+    "wifi.scan": async ({ respond, context }) => {
+        if (!requireLinux(respond))
+            return;
+        try {
+            if (!(await nmcliAvailable())) {
+                respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "NetworkManager (nmcli) is not installed"));
+                return;
+            }
+            const { stdout } = await runExec("nmcli", ["-t", "-f", "IN-USE,SSID,SIGNAL,SECURITY", "dev", "wifi", "list", "--rescan", "yes"], { timeoutMs: 15_000 });
+            const networks = parseWifiList(stdout);
+            respond(true, { networks });
+        }
+        catch (err) {
+            context.logGateway.warn(`wifi.scan failed: ${err instanceof Error ? err.message : String(err)}`);
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "Failed to scan WiFi networks"));
+        }
+    },
+    /**
+     * Connect to a WiFi network.
+     * Params: { ssid: string, password?: string }
+     */
+    "wifi.connect": async ({ params, respond, context }) => {
+        if (!requireLinux(respond))
+            return;
+        const ssid = typeof params.ssid === "string" ? params.ssid.trim() : "";
+        const password = typeof params.password === "string" ? params.password : "";
+        if (!ssid) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "Missing required parameter: ssid"));
+            return;
+        }
+        try {
+            if (!(await nmcliAvailable())) {
+                respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "NetworkManager (nmcli) is not installed"));
+                return;
+            }
+            const args = ["dev", "wifi", "connect", ssid];
+            if (password) {
+                args.push("password", password);
+            }
+            const { stdout, stderr } = await runExec("nmcli", args, { timeoutMs: 30_000 });
+            // nmcli prints "Device 'wlan0' successfully activated..." on success
+            const combined = `${stdout}\n${stderr}`;
+            const success = combined.includes("successfully activated") || combined.includes("successfully added");
+            if (success) {
+                const ip = await getWifiIp();
+                respond(true, { connected: true, ssid, ip });
+            }
+            else {
+                // nmcli returned 0 but no success message — treat as unexpected
+                context.logGateway.warn(`wifi.connect: unexpected output: ${combined.slice(0, 300)}`);
+                respond(true, { connected: true, ssid, ip: null });
+            }
+        }
+        catch (err) {
+            const errObj = err;
+            const detail = errObj.stderr?.trim() || errObj.message || "Connection failed";
+            context.logGateway.warn(`wifi.connect failed for "${ssid}": ${detail}`);
+            // Surface user-friendly error from nmcli stderr
+            let message = "Failed to connect to WiFi network";
+            if (detail.includes("Secrets were required")) {
+                message = "Incorrect password";
+            }
+            else if (detail.includes("No network with SSID")) {
+                message = "Network not found — try scanning again";
+            }
+            else if (detail.includes("not found")) {
+                message = "WiFi adapter not found";
+            }
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, message));
+        }
+    },
+};

package/dist/gateway/server-methods.js CHANGED Viewed

@@ -34,6 +34,7 @@ import { webHandlers } from "./server-methods/web.js";
 import { wizardHandlers } from "./server-methods/wizard.js";
 import { publicChatHandlers } from "./server-methods/public-chat.js";
 import { tailscaleHandlers } from "./server-methods/tailscale.js";
+import { wifiHandlers } from "./server-methods/wifi.js";
 import { workspacesHandlers } from "./server-methods/workspaces.js";
 const ADMIN_SCOPE = "operator.admin";
 const READ_SCOPE = "operator.read";
@@ -237,6 +238,7 @@ export const coreGatewayHandlers = {
     ...workspacesHandlers,
     ...publicChatHandlers,
     ...tailscaleHandlers,
+    ...wifiHandlers,
 };
 export async function handleGatewayRequest(opts) {
     const { req, respond, client, isWebchatConnect, context } = opts;