pipane 0.1.6 → 0.1.7

package/dist/server/server/server.js

@@ -20,8 +20,10 @@ import path from "node:path";
 import { hostname } from "node:os";
 import { randomBytes } from "node:crypto";
 import { existsSync, readFileSync, watch } from "node:fs";
-import { WebSocketServer, WebSocket } from "ws";
+import { WebSocketServer } from "ws";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { WS_PROTOCOL_VERSION } from "../shared/ws-protocol.js";
+import { BACKEND_PROTOCOL_VERSION } from "../shared/backend-protocol.js";
 import { resolvePiLaunch } from "./pi-launch.js";
 import { checkCommandAvailable, makePiNotFoundMessage } from "./pi-runtime.js";
 import { registerRestApi } from "./rest-api.js";
@@ -29,8 +31,21 @@ import { SessionRegistry } from "./session-registry.js";
 import { ProcessPool } from "./process-pool.js";
 import { WsHandler } from "./ws-handler.js";
 import { LocalSettingsStore } from "./local-settings.js";
-import { fetchLatestVersion, compareSemver } from "./update-check.js";
 import { resolveUsageExtensionPath } from "./bundled-extensions.js";
+import { UpdateManager } from "./update-manager.js";
+import { registerUpdateApi } from "./update-api.js";
+import { SessionPathGuard } from "./session-path.js";
+import { AuthGuard } from "./auth-guard.js";
+import { loadOrCreateBackendIdentity } from "./backend-identity.js";
+import { BackendRendezvousClient } from "./rendezvous-client.js";
+import { BackendWebRtcManager } from "./backend-webrtc.js";
+import { BackendTrustStore } from "./backend-trust-store.js";
+import { BackendConnectionAuthorizer } from "./backend-connection-authorizer.js";
+import { DataChannelFrameConnection } from "./frame-connection.js";
+import { routeFrameConnection } from "./frame-router.js";
+import { BackendProtocolHandler } from "./backend-protocol-handler.js";
+import { LocalBackendApi } from "./local-backend-api.js";
+import qrcode from "qrcode-terminal";
 const DEFAULT_PORT = process.env.NODE_ENV === "production" ? "8222" : "18111";
 const REQUESTED_PORT = parseInt(process.env.PORT || DEFAULT_PORT, 10);
 const INSTANCE_ID = process.env.PIPANE_INSTANCE_ID || null;
@@ -58,6 +73,9 @@ const PI_AVAILABLE = checkCommandAvailable(PI_LAUNCH.command);
 const PI_MAX_PROCESSES = parseInt(process.env.PI_MAX_PROCESSES || "24", 10);
 const PI_PREWARM_COUNT = parseInt(process.env.PI_PREWARM_COUNT || "2", 10);
 const USAGE_EXTENSION_ENABLED = process.env.PIPANE_USAGE_EXTENSION !== "0";
+const RENDEZVOUS_URL = process.env.PIPANE_RENDEZVOUS_URL;
+let rendezvousPairingRuntime;
+let registeredBackendId;
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Read own version from package.json
 const PKG_JSON_PATH = path.resolve(__dirname, "../../../package.json");
@@ -70,44 +88,79 @@ const PKG_VERSION = (() => {
     }
 })();
 const PKG_NAME = "pipane";
-const AUTH_COOKIE_NAME = "pipane_auth";
-const AUTH_TOKEN = process.env.PIPANE_AUTH_TOKEN || randomBytes(24).toString("base64url");
-const PUBLIC_HOSTNAME = process.env.PI_PUBLIC_HOSTNAME || hostname();
-function parseCookies(header) {
-    const out = {};
-    if (!header)
-        return out;
-    for (const part of header.split(";")) {
-        const idx = part.indexOf("=");
-        if (idx <= 0)
-            continue;
-        const k = part.slice(0, idx).trim();
-        const v = part.slice(idx + 1).trim();
-        out[k] = decodeURIComponent(v);
+async function startRendezvousRegistration() {
+    if (!RENDEZVOUS_URL)
+        return;
+    const identity = loadOrCreateBackendIdentity(process.env.PIPANE_BACKEND_IDENTITY_FILE);
+    const trustStore = new BackendTrustStore({ filePath: process.env.PIPANE_BACKEND_TRUST_FILE });
+    registeredBackendId = identity.backendId;
+    const client = new BackendRendezvousClient({
+        url: RENDEZVOUS_URL,
+        identity,
+        metadata: {
+            name: process.env.PIPANE_BACKEND_NAME || hostname(),
+            softwareVersion: PKG_VERSION,
+            protocolVersions: [WS_PROTOCOL_VERSION, BACKEND_PROTOCOL_VERSION],
+        },
+    });
+    client.onError((error) => {
+        console.warn("[rendezvous]", error instanceof Error ? error.message : error.message);
+    });
+    let peers;
+    client.onAuthorizationRevoked(({ accountId, deviceId }) => {
+        trustStore.applyRevocation(accountId, deviceId);
+        peers?.closeAuthorization(accountId, deviceId);
+    });
+    const backendId = await client.start();
+    const authorizer = new BackendConnectionAuthorizer(trustStore, client);
+    peers = new BackendWebRtcManager({
+        signaling: client,
+        identity,
+        ticketPublicKey: () => client.ticketPublicKey,
+        authorize: (context) => authorizer.authorize(context),
+        iceTransportPolicy: process.env.PIPANE_ICE_TRANSPORT_POLICY === "relay" ? "relay" : "all",
+    });
+    peers.onDataChannel(({ channel, deviceId }) => {
+        const routes = routeFrameConnection(new DataChannelFrameConnection(channel));
+        wsHandler.acceptAuthenticatedConnection(routes.application);
+        backendProtocolHandler.accept(routes.semantic, deviceId);
+    });
+    peers.onError((_connectionId, error) => console.warn("[webrtc]", error.message));
+    const appUrl = new URL(process.env.PIPANE_APP_URL || RENDEZVOUS_URL);
+    if (appUrl.protocol === "ws:")
+        appUrl.protocol = "http:";
+    if (appUrl.protocol === "wss:")
+        appUrl.protocol = "https:";
+    appUrl.pathname = `/backend/${backendId}`;
+    appUrl.search = "";
+    appUrl.hash = "";
+    log(`  Backend: ${backendId}`);
+    log(`  Web:     ${appUrl.toString()}`);
+    const createPairingUrl = async () => {
+        const pairing = trustStore.createPairing();
+        await client.openPairing(pairing.pairId, pairing.expiresAt);
+        const pairingUrl = new URL(appUrl);
+        pairingUrl.pathname = `/pair/${encodeURIComponent(pairing.pairId)}`;
+        pairingUrl.hash = new URLSearchParams({ backend: backendId, secret: pairing.secret }).toString();
+        return pairingUrl.toString();
+    };
+    rendezvousPairingRuntime = { createPairingUrl };
+    for (const pairing of trustStore.listActivePairings()) {
+        void client.openPairing(pairing.pairId, pairing.expiresAt).catch((error) => console.warn("[pairing]", error.message));
+    }
+    if (!trustStore.ownerAccountId || process.argv.includes("--pair")) {
+        const pairingUrl = await createPairingUrl();
+        log(`  Pair:    ${pairingUrl}`);
+        qrcode.generate(pairingUrl, { small: true }, (code) => log(code));
     }
-    return out;
-}
-function isLocalAddress(addr) {
-    if (!addr)
-        return false;
-    return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
-}
-function isLocalRequest(req) {
-    if (process.env.PIPANE_DISABLE_LOCAL_BYPASS === "1")
-        return false;
-    return isLocalAddress(req.socket.remoteAddress);
-}
-function setAuthCookie(res) {
-    const secure = process.env.PIPANE_SECURE_COOKIE === "1" ? "; Secure" : "";
-    const maxAgeSeconds = 60 * 60 * 24 * 30;
-    res.setHeader("Set-Cookie", `${AUTH_COOKIE_NAME}=${encodeURIComponent(AUTH_TOKEN)}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${maxAgeSeconds}${secure}`);
-}
-function isAuthorizedRequest(req) {
-    if (isLocalRequest(req))
-        return true;
-    const cookies = parseCookies(req.headers.cookie);
-    return cookies[AUTH_COOKIE_NAME] === AUTH_TOKEN;
 }
+const AUTH_TOKEN = process.env.PIPANE_AUTH_TOKEN || randomBytes(24).toString("base64url");
+const PUBLIC_HOSTNAME = process.env.PI_PUBLIC_HOSTNAME || hostname();
+const authGuard = new AuthGuard({
+    token: AUTH_TOKEN,
+    disableLocalBypass: process.env.PIPANE_DISABLE_LOCAL_BYPASS === "1",
+    secureCookie: process.env.PIPANE_SECURE_COOKIE === "1",
+});
 // ============================================================================
 // Express + HTTP server
 // ============================================================================
@@ -138,56 +191,32 @@ const pingInterval = setInterval(() => {
     }
 }, WS_PING_INTERVAL);
 wss.on("close", () => { clearInterval(pingInterval); });
-app.get("/auth", (req, res) => {
-    const token = typeof req.query.token === "string" ? req.query.token : undefined;
-    if (isLocalRequest(req) || token === AUTH_TOKEN) {
-        setAuthCookie(res);
-        res.redirect("/");
-        return;
-    }
-    res.status(401).type("html").send("<h3>Unauthorized</h3><p>Invalid auth token.</p>");
-});
-app.use((req, res, next) => {
-    if (isAuthorizedRequest(req)) {
-        if (isLocalRequest(req)) {
-            setAuthCookie(res);
-        }
-        next();
-        return;
-    }
-    res.status(401).type("html").send("<h3>Unauthorized</h3><p>Open the one-time auth URL shown in the pipane terminal.</p>");
-});
+authGuard.register(app);
 // A harness can provide a unique ID and verify that it reached the child it
 // launched, rather than an unrelated process that happened to acquire a port.
 app.get("/api/debug/health", (_req, res) => {
     res.json({ ok: true, instanceId: INSTANCE_ID, pid: process.pid });
 });
+app.post("/api/pairing", async (_req, res) => {
+    res.setHeader("Cache-Control", "no-store");
+    if (!rendezvousPairingRuntime) {
+        res.status(503).json({ error: "Backend is not registered with rendezvous" });
+        return;
+    }
+    try {
+        res.json({ url: await rendezvousPairingRuntime.createPairingUrl() });
+    }
+    catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+});
 const localSettingsStore = new LocalSettingsStore();
 const registry = new SessionRegistry();
+const SESSIONS_DIR = path.join(getAgentDir(), "sessions");
+const sessionPaths = new SessionPathGuard(SESSIONS_DIR);
 // Serve static files in production
 const clientDist = path.resolve(__dirname, "../../client");
 app.use(express.static(clientDist));
-// Register REST endpoints
-registerRestApi(app, {
-    localSettingsStore,
-    runSessionMutation: (sessionPath, operation, mutation) => {
-        const actor = registry.get(sessionPath);
-        return actor.enqueue(operation, async () => {
-            actor.assertAvailable(operation);
-            await mutation();
-        });
-    },
-    onLocalSettingsReloaded: () => {
-        wss.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(JSON.stringify({
-                    type: "sessions_changed",
-                    file: "__local_settings__",
-                }));
-            }
-        });
-    },
-});
 // ============================================================================
 // Core modules
 // ============================================================================
@@ -221,6 +250,7 @@ const pool = new ProcessPool({
 const wsHandler = new WsHandler({
     registry,
     pool,
+    sessionPaths,
     defaultCwd: PI_CWD,
     piLaunch: PI_LAUNCH,
     ensurePool: () => {
@@ -228,10 +258,38 @@ const wsHandler = new WsHandler({
             pool.prewarm(PI_CWD);
         }
     },
-    isRequestAuthorized: (req) => isAuthorizedRequest(req),
+    isRequestAuthorized: (req) => authGuard.isAuthorizedRequest(req),
 });
 // Register WS handler
 wsHandler.register(wss);
+const updateManager = new UpdateManager({
+    pipaneVersion: PKG_VERSION,
+    pipanePackageName: PKG_NAME,
+    piLaunch: PI_LAUNCH,
+    cwd: PI_CWD,
+    onPiRuntimeChanged: async () => {
+        pool.decommissionAll();
+        if (wsHandler.isPiAvailable)
+            await pool.prewarm(PI_CWD);
+    },
+});
+registerUpdateApi(app, updateManager);
+const backendApi = new LocalBackendApi({
+    localSettingsStore,
+    sessionPaths,
+    backendId: () => registeredBackendId,
+    updateManager,
+    runSessionMutation: (sessionPath, operation, mutation) => {
+        const actor = registry.get(sessionPath);
+        return actor.enqueue(operation, async () => {
+            actor.assertAvailable(operation);
+            await mutation();
+        });
+    },
+    onLocalSettingsReloaded: () => wsHandler.notifySessionsChanged("__local_settings__"),
+});
+registerRestApi(app, { api: backendApi });
+const backendProtocolHandler = new BackendProtocolHandler(backendApi);
 // ============================================================================
 // Debug endpoints
 // ============================================================================
@@ -290,7 +348,6 @@ setInterval(tick, 1000); tick();
 // ============================================================================
 // Sessions Directory Watcher
 // ============================================================================
-const SESSIONS_DIR = path.join(getAgentDir(), "sessions");
 function startSessionsWatcher() {
     if (!existsSync(SESSIONS_DIR)) {
         console.log(`Sessions dir does not exist yet: ${SESSIONS_DIR}`);
@@ -308,15 +365,8 @@ function startSessionsWatcher() {
             const fullPath = path.join(SESSIONS_DIR, lastChangedFile);
             // Re-read detached session state and push it to active subscribers.
             wsHandler.notifySessionFileChanged(fullPath);
-            // Also notify all WS clients about the file change (for sidebar refresh)
-            wss.clients.forEach((client) => {
-                if (client.readyState === WebSocket.OPEN) {
-                    client.send(JSON.stringify({
-                        type: "sessions_changed",
-                        file: fullPath,
-                    }));
-                }
-            });
+            // Notify every local WebSocket and authenticated DataChannel client.
+            wsHandler.notifySessionsChanged(fullPath);
         }, 300);
     });
     console.log(`Watching sessions directory: ${SESSIONS_DIR}`);
@@ -333,7 +383,10 @@ if (PI_AVAILABLE) {
 else {
     console.log(`[pi] ${makePiNotFoundMessage(PI_LAUNCH.command)}`);
 }
-server.listen(REQUESTED_PORT, async () => {
+server.listen(REQUESTED_PORT, () => {
+    void startRendezvousRegistration().catch((error) => {
+        console.warn("[rendezvous] registration stopped:", error);
+    });
     const address = server.address();
     const port = address && typeof address !== "string" ? address.port : REQUESTED_PORT;
     const authUrl = `http://${PUBLIC_HOSTNAME}:${port}/auth?token=${encodeURIComponent(AUTH_TOKEN)}`;
@@ -353,11 +406,24 @@ server.listen(REQUESTED_PORT, async () => {
         log(`  Set PIPANE_AUTH_TOKEN to use a fixed token.`);
     }
     log("");
-    // Non-blocking update check
-    const latest = await fetchLatestVersion(PKG_NAME);
-    if (latest && compareSemver(PKG_VERSION, latest) < 0) {
-        log(`  Update available: v${PKG_VERSION} → v${latest}`);
-        log(`  Run \`npm install -g ${PKG_NAME}\` to upgrade.`);
-        log("");
-    }
+    // The same asynchronous check feeds the web UI and preserves terminal hints.
+    void updateManager.check().then(({ notices }) => {
+        for (const notice of notices) {
+            if (notice.target === "pipane") {
+                log(`  Update available: v${notice.currentVersion} → v${notice.latestVersion}`);
+                log(`  Open pipane in the browser to install it, or run \`npm install -g ${PKG_NAME}\`.`);
+            }
+            else if (notice.target === "pi") {
+                log(`  Pi update available: v${notice.currentVersion} → v${notice.latestVersion}`);
+                log("  Open pipane in the browser to install it, or run `pi update --self`.");
+            }
+            else if (notice.packages?.length) {
+                log(`  Pi package updates available: ${notice.packages.join(", ")}`);
+                log("  Open pipane in the browser to install them, or run `pi update --extensions`.");
+            }
+            log("");
+        }
+    }).catch((error) => {
+        console.warn("[updates] Update check failed:", error);
+    });
 });

package/dist/server/server/session-index.js

@@ -1,9 +1,19 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { getAgentDir, parseSessionEntries } from "@earendil-works/pi-coding-agent";
-import { resolveWorktreeName } from "./worktree-name.js";
+import { createWorktreeNameResolver, } from "./worktree-name.js";
 const CACHE_FORMAT_VERSION = 1;
-const DEFAULT_EXTRACTOR_VERSION = "2";
+const DEFAULT_EXTRACTOR_VERSION = "3";
+const MAX_RECENT_TOOL_PATHS = 16;
+const PATH_ACTIVITY_TOOLS = new Set([
+    "edit",
+    "hypa_find",
+    "hypa_grep",
+    "hypa_ls",
+    "hypa_read",
+    "read",
+    "write",
+]);
 export class SessionIndex {
     agentDir;
     extractorVersion;
@@ -16,7 +26,7 @@ export class SessionIndex {
         this.extractorVersion = opts?.extractorVersion ?? DEFAULT_EXTRACTOR_VERSION;
         this.cacheFilePath = path.join(this.agentDir, "cache", "pipane-session-index-v1.json");
         this.cwdDisplayFormatter = opts?.cwdDisplayFormatter;
-        this.worktreeNameResolver = opts?.worktreeNameResolver ?? resolveWorktreeName;
+        this.worktreeNameResolver = opts?.worktreeNameResolver;
     }
     async listSessions() {
         const files = this.listSessionFiles();
@@ -41,17 +51,18 @@ export class SessionIndex {
                 sessions.push(cached.meta);
                 continue;
             }
-            const meta = this.extractSessionMeta(sessionPath, stat.mtimeMs);
-            if (!meta) {
+            const extracted = this.extractSessionMeta(sessionPath, stat.mtimeMs);
+            if (!extracted) {
                 mutated = true;
                 continue;
             }
             nextEntries[sessionPath] = {
                 fileMtimeMs: stat.mtimeMs,
                 fileSize: stat.size,
-                meta,
+                meta: extracted.meta,
+                recentToolPaths: extracted.recentToolPaths,
             };
-            sessions.push(meta);
+            sessions.push(extracted.meta);
             mutated = true;
         }
         if (!mutated) {
@@ -83,17 +94,17 @@ export class SessionIndex {
                 // on read-only agent dirs or transient filesystem errors.
             }
         }
-        const worktreeNames = new Map();
+        // A default resolver is scoped to one listing: its filesystem lookups are
+        // shared by every session, but discarded before the next request so newly
+        // created or removed worktrees are reflected immediately.
+        const worktreeNameResolver = this.worktreeNameResolver ?? createWorktreeNameResolver();
         return sessions.map((session) => {
-            let worktreeName = worktreeNames.get(session.cwd);
-            if (!worktreeName) {
-                try {
-                    worktreeName = this.worktreeNameResolver(session.cwd) || "root";
-                }
-                catch {
-                    worktreeName = "root";
-                }
-                worktreeNames.set(session.cwd, worktreeName);
+            let worktreeName = "root";
+            try {
+                worktreeName = worktreeNameResolver(session.cwd, nextEntries[session.path]?.recentToolPaths ?? []) || "root";
+            }
+            catch {
+                worktreeName = "root";
             }
             return { ...session, worktreeName };
         });
@@ -141,11 +152,14 @@ export class SessionIndex {
             const header = entries[0];
             if (header?.type !== "session" || typeof header.id !== "string")
                 return null;
+            const cwd = typeof header.cwd === "string" ? header.cwd : "";
             let name;
             let messageCount = 0;
             let firstMessage = "";
             let lastActivityTime;
             let lastUserPromptTimeMs = 0;
+            const pendingToolPaths = new Map();
+            const recentToolPaths = [];
             for (const entry of entries) {
                 if (entry?.type === "session_info" && typeof entry.name === "string") {
                     const trimmed = entry.name.trim();
@@ -158,6 +172,19 @@ export class SessionIndex {
                 const msg = entry.message;
                 if (!msg || typeof msg.role !== "string" || !Object.prototype.hasOwnProperty.call(msg, "content"))
                     continue;
+                if (msg.role === "assistant") {
+                    this.rememberPendingToolPaths(msg.content, cwd, pendingToolPaths);
+                }
+                else if (msg.role === "toolResult" && typeof msg.toolCallId === "string") {
+                    const completedPaths = pendingToolPaths.get(msg.toolCallId);
+                    pendingToolPaths.delete(msg.toolCallId);
+                    if (msg.isError !== true && completedPaths) {
+                        recentToolPaths.push(...completedPaths);
+                        if (recentToolPaths.length > MAX_RECENT_TOOL_PATHS) {
+                            recentToolPaths.splice(0, recentToolPaths.length - MAX_RECENT_TOOL_PATHS);
+                        }
+                    }
+                }
                 if (msg.role !== "user" && msg.role !== "assistant")
                     continue;
                 const messageTs = typeof msg.timestamp === "number" ? msg.timestamp : undefined;
@@ -186,24 +213,74 @@ export class SessionIndex {
                     return new Date(createdMs);
                 return new Date(statMtimeMs);
             })();
-            const cwd = typeof header.cwd === "string" ? header.cwd : "";
             return {
-                id: header.id,
-                path: sessionPath,
-                cwd,
-                cwdDisplay: cwd && this.cwdDisplayFormatter ? this.cwdDisplayFormatter(cwd) : cwd,
-                name,
-                created: created.toISOString(),
-                modified: modified.toISOString(),
-                lastUserPromptTime: lastUserPromptTimeMs > 0 ? new Date(lastUserPromptTimeMs).toISOString() : undefined,
-                messageCount,
-                firstMessage: firstMessage || "(no messages)",
+                meta: {
+                    id: header.id,
+                    path: sessionPath,
+                    cwd,
+                    cwdDisplay: cwd && this.cwdDisplayFormatter ? this.cwdDisplayFormatter(cwd) : cwd,
+                    name,
+                    created: created.toISOString(),
+                    modified: modified.toISOString(),
+                    lastUserPromptTime: lastUserPromptTimeMs > 0 ? new Date(lastUserPromptTimeMs).toISOString() : undefined,
+                    messageCount,
+                    firstMessage: firstMessage || "(no messages)",
+                },
+                recentToolPaths,
             };
         }
         catch {
             return null;
         }
     }
+    rememberPendingToolPaths(content, cwd, pendingToolPaths) {
+        if (!Array.isArray(content))
+            return;
+        for (const chunk of content) {
+            if (chunk?.type !== "toolCall" || typeof chunk.id !== "string")
+                continue;
+            pendingToolPaths.set(chunk.id, this.extractToolPaths(chunk.name, chunk.arguments, cwd));
+        }
+    }
+    extractToolPaths(toolName, rawArguments, cwd) {
+        if (typeof toolName !== "string")
+            return [];
+        const args = this.parseToolArguments(rawArguments);
+        if (!args)
+            return [];
+        if (Array.isArray(args.tool_uses)) {
+            return args.tool_uses.flatMap((toolUse) => this.extractToolPaths(toolUse?.recipient_name, toolUse?.parameters, cwd));
+        }
+        const shortName = toolName.toLowerCase().split(".").pop() ?? "";
+        if (!PATH_ACTIVITY_TOOLS.has(shortName))
+            return [];
+        const candidate = typeof args.path === "string"
+            ? args.path
+            : typeof args.file_path === "string"
+                ? args.file_path
+                : "";
+        if (!candidate || candidate.includes("\0"))
+            return [];
+        if (!path.isAbsolute(candidate) && !cwd)
+            return [];
+        return [path.resolve(cwd || path.parse(candidate).root, candidate)];
+    }
+    parseToolArguments(rawArguments) {
+        if (rawArguments && typeof rawArguments === "object" && !Array.isArray(rawArguments)) {
+            return rawArguments;
+        }
+        if (typeof rawArguments !== "string")
+            return null;
+        try {
+            const parsed = JSON.parse(rawArguments);
+            return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
     extractTextContent(content) {
         if (typeof content === "string")
             return content;