relay-ide 0.1.0

package/dist/server/pty-handler.js

@@ -0,0 +1,586 @@
+import pty from 'node-pty';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { AGENT_COMMANDS, AGENT_CONTINUE_ARGS, resolveFramework, } from './types.js';
+import { readMeta, writeMeta } from './config.js';
+import { cleanEnv } from './utils.js';
+import { outputParsers } from './output-parsers/index.js';
+import { installOpencodeRelayPlugin } from './opencode-relay.js';
+import { writeCodexHooksAdapter } from './codex-hooks-adapter.js';
+import { createLogger } from './logger.js';
+const IDLE_TIMEOUT_MS = 5000;
+const MAX_SCROLLBACK = 256 * 1024; // 256KB max
+const logger = createLogger('pty');
+export function getTmuxPrefix() {
+    return process.env.NO_PIN === '1' ? 'crcd-' : 'crc-';
+}
+export function generateTmuxSessionName(displayName, id) {
+    const sanitized = displayName
+        .replace(/[^a-zA-Z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .slice(0, 30);
+    return `${getTmuxPrefix()}${sanitized}-${id.slice(0, 8)}`;
+}
+export function resolveTmuxSpawn(command, args, tmuxSessionName) {
+    return {
+        command: 'tmux',
+        args: [
+            '-u',
+            'new-session',
+            '-s',
+            tmuxSessionName,
+            '--',
+            command,
+            ...args,
+            ';',
+            'set',
+            'set-clipboard',
+            'on',
+            ';',
+            'set',
+            'allow-passthrough',
+            'on',
+            ';',
+            'set',
+            'mode-keys',
+            'vi',
+        ],
+    };
+}
+function shellQuote(value) {
+    return "'" + value.replace(/'/g, "'\"'\"'") + "'";
+}
+function readGlobalStatusLineCommand() {
+    try {
+        const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+        const raw = fs.readFileSync(settingsPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed.statusLine?.command === 'string'
+            ? parsed.statusLine.command
+            : '';
+    }
+    catch {
+        return '';
+    }
+}
+export function buildStatusLineRelayScript(sessionId, configDir, globalCmd) {
+    const telemetryDir = path.join(configDir, 'telemetry');
+    const telemetryPath = path.join(telemetryDir, `${sessionId}.json`);
+    const tempPattern = `${telemetryPath}.tmp.XXXXXX`;
+    return `#!/usr/bin/env bash
+set -u
+mkdir -p ${shellQuote(telemetryDir)}
+tmp_file=$(mktemp ${shellQuote(tempPattern)})
+cleanup() {
+  rm -f "$tmp_file"
+}
+trap cleanup EXIT
+GLOBAL_CMD=${shellQuote(globalCmd)}
+if [ -n "$GLOBAL_CMD" ] && [ -x "$GLOBAL_CMD" ]; then
+  tee "$tmp_file" | "$GLOBAL_CMD"
+  pipeline_statuses=("\${PIPESTATUS[@]}")
+else
+  tee "$tmp_file" | node -e 'let raw="";process.stdin.setEncoding("utf8");process.stdin.on("data", (chunk) => raw += chunk);process.stdin.on("end", () => { try { const data = JSON.parse(raw); const model = data?.model?.display_name ?? "Claude"; const remaining = data?.context_window?.remaining_percentage ?? "?"; process.stdout.write(model + " | " + remaining + "% ctx\n"); } catch { process.stdout.write("Claude | ?% ctx\n"); } });'
+  pipeline_statuses=("\${PIPESTATUS[@]}")
+fi
+
+pipeline_status=0
+for status in "\${pipeline_statuses[@]}"; do
+  if [ "$status" -ne 0 ]; then
+    pipeline_status=$status
+  fi
+done
+
+if [ "\${pipeline_statuses[0]}" -eq 0 ]; then
+  mv "$tmp_file" ${shellQuote(telemetryPath)}
+  trap - EXIT
+fi
+
+exit "$pipeline_status"
+`;
+}
+function writeStatusLineScript(sessionId, dir, configDir) {
+    const scriptPath = path.join(dir, 'relay-statusline.sh');
+    const script = buildStatusLineRelayScript(sessionId, configDir, readGlobalStatusLineCommand());
+    fs.writeFileSync(scriptPath, script, 'utf-8');
+    fs.chmodSync(scriptPath, 0o755);
+    return scriptPath;
+}
+/**
+ * Upgrade an existing hooks-settings.json to include statusLine if missing.
+ * Called on session restore to ensure sessions created before telemetry support
+ * get the relay script written to disk. The running Claude process will pick this
+ * up on its next statusLine poll cycle (Claude re-reads the settings file).
+ */
+export function upgradeHooksSettings(sessionId, configDir) {
+    const dir = path.join(os.tmpdir(), 'relay-ide', sessionId);
+    const filePath = path.join(dir, 'hooks-settings.json');
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const settings = JSON.parse(raw);
+        if (settings.statusLine)
+            return false; // already has statusLine
+    }
+    catch {
+        return false; // file doesn't exist or is malformed
+    }
+    // Write the relay script and patch the settings file
+    try {
+        const statusLinePath = writeStatusLineScript(sessionId, dir, configDir);
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const settings = JSON.parse(raw);
+        settings.statusLine = { type: 'command', command: statusLinePath };
+        fs.writeFileSync(filePath, JSON.stringify(settings, null, 2), 'utf-8');
+        return true;
+    }
+    catch (err) {
+        logger.warn(`Failed to upgrade hooks settings for session ${sessionId}:`, err);
+        return false;
+    }
+}
+function writeHooksSettingsFile(sessionId, port, token, configDir) {
+    const dir = path.join(os.tmpdir(), 'relay-ide', sessionId);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const filePath = path.join(dir, 'hooks-settings.json');
+    const statusLinePath = writeStatusLineScript(sessionId, dir, configDir);
+    const base = `http://127.0.0.1:${port}`;
+    const q = `sessionId=${sessionId}&token=${token}`;
+    const settings = {
+        hooks: {
+            Stop: [
+                {
+                    hooks: [{ type: 'http', url: `${base}/hooks/stop?${q}`, timeout: 5 }],
+                },
+            ],
+            Notification: [
+                {
+                    matcher: 'permission_prompt',
+                    hooks: [
+                        {
+                            type: 'http',
+                            url: `${base}/hooks/notification?${q}&type=permission_prompt`,
+                            timeout: 5,
+                        },
+                    ],
+                },
+                {
+                    matcher: 'idle_prompt',
+                    hooks: [
+                        {
+                            type: 'http',
+                            url: `${base}/hooks/notification?${q}&type=idle_prompt`,
+                            timeout: 5,
+                        },
+                    ],
+                },
+            ],
+            UserPromptSubmit: [
+                {
+                    hooks: [
+                        {
+                            type: 'http',
+                            url: `${base}/hooks/prompt-submit?${q}`,
+                            timeout: 5,
+                        },
+                    ],
+                },
+            ],
+            SessionEnd: [
+                {
+                    hooks: [
+                        { type: 'http', url: `${base}/hooks/session-end?${q}`, timeout: 5 },
+                    ],
+                },
+            ],
+            PreToolUse: [
+                {
+                    hooks: [
+                        { type: 'http', url: `${base}/hooks/tool-use?${q}`, timeout: 5 },
+                    ],
+                },
+            ],
+            PostToolUse: [
+                {
+                    hooks: [
+                        { type: 'http', url: `${base}/hooks/tool-result?${q}`, timeout: 5 },
+                    ],
+                },
+            ],
+        },
+        statusLine: {
+            type: 'command',
+            command: statusLinePath,
+        },
+    };
+    fs.writeFileSync(filePath, JSON.stringify(settings, null, 2), 'utf-8');
+    fs.chmodSync(filePath, 0o600);
+    return filePath;
+}
+export function createPtySession(params, sessionsMap, stateChangeCallbacks = [], sessionEndCallbacks = [], fireBackendStateIfChanged) {
+    const { id, type, agent = 'claude', repoName, repoPath, worktreePath = null, cwd, branchName, displayName, command, args: rawArgs = [], cols = 80, rows = 24, configPath, configDir, useTmux: paramUseTmux, tmuxSessionName: paramTmuxSessionName, initialScrollback, restored: paramRestored, port, forceOutputParser, yolo: paramYolo, claudeArgs: paramClaudeArgs, hookToken: paramHookToken, hooksActive: paramHooksActive, frameworks, } = params;
+    let args = rawArgs;
+    const createdAt = new Date().toISOString();
+    // Resolve the agent framework (builtin or future config-driven custom)
+    // Falls back to a minimal stub using deprecated aliases when agent is not a known framework.
+    let framework;
+    try {
+        framework = resolveFramework(frameworks ? { frameworks } : {}, agent);
+    }
+    catch {
+        // Unknown agent — synthesize a minimal framework from deprecated aliases for backward compat
+        framework = {
+            id: agent,
+            displayName: agent,
+            command: AGENT_COMMANDS[agent] ?? agent,
+            continueArgs: AGENT_CONTINUE_ARGS[agent] ?? [],
+            yoloArgs: [],
+            parserType: 'none',
+            eventSource: 'parser',
+            capabilities: {
+                supportsHooks: false,
+                supportsContinue: false,
+                supportsYolo: false,
+                supportsTelemetry: false,
+            },
+        };
+    }
+    const resolvedCommand = command || framework.commandOverride || framework.command;
+    const env = cleanEnv();
+    // Inject Claude --settings hooks file for frameworks that use HTTP hook callbacks.
+    // This is the Claude-specific hook mechanism; codex uses hooks.json (Task 7) and
+    // opencode uses a TS relay plugin (Task 6) — each with its own injection path.
+    // For restored sessions whose tmux died, reuse the preserved token but re-create the settings
+    // file on disk — the new Claude process needs --settings even though the token is the same.
+    // For surviving tmux sessions (command='tmux'), shouldInjectHooks is false — the old Claude
+    // instance already has its settings file, and we just need the token for server-side validation.
+    let hookToken = paramHookToken ?? '';
+    let hooksActive = paramHooksActive ?? false;
+    let settingsPath = '';
+    const effectiveEventSource = forceOutputParser
+        ? 'parser'
+        : framework.eventSource;
+    if (paramYolo && framework.yoloEnv) {
+        Object.assign(env, framework.yoloEnv);
+    }
+    if (effectiveEventSource === 'plugin' && port !== undefined) {
+        if (!hookToken) {
+            hookToken = crypto.randomBytes(32).toString('hex');
+        }
+        try {
+            installOpencodeRelayPlugin();
+            env.CRC_RELAY_URL = `http://127.0.0.1:${port}`;
+            env.CRC_SESSION_ID = id;
+            env.CRC_RELAY_TOKEN = hookToken;
+            hooksActive = true;
+        }
+        catch (err) {
+            logger.warn(`Failed to install opencode relay plugin for session ${id}:`, err);
+        }
+    }
+    if (framework.id === 'codex' && port !== undefined) {
+        if (!hookToken) {
+            hookToken = crypto.randomBytes(32).toString('hex');
+        }
+        try {
+            const codexConfigDir = writeCodexHooksAdapter(id, port, hookToken, configDir ?? process.cwd());
+            env.CODEX_CONFIG_DIR = codexConfigDir;
+            hooksActive = true;
+        }
+        catch (err) {
+            logger.warn(`Failed to write codex hooks adapter for session ${id}:`, err);
+        }
+    }
+    // Only inject --settings for claude; codex and opencode have their own hook injection paths
+    const shouldInjectHooks = framework.id === 'claude' &&
+        framework.capabilities.supportsHooks &&
+        effectiveEventSource === 'hooks' &&
+        !command &&
+        port !== undefined;
+    if (shouldInjectHooks) {
+        if (!hookToken) {
+            hookToken = crypto.randomBytes(32).toString('hex');
+        }
+        try {
+            settingsPath = writeHooksSettingsFile(id, port, hookToken, configDir ?? process.cwd());
+            args = ['--settings', settingsPath, ...args];
+            hooksActive = true;
+        }
+        catch (err) {
+            logger.warn(`Failed to generate hooks settings for session ${id}:`, err);
+            hooksActive = false;
+            hookToken = '';
+        }
+    }
+    const useTmux = !command && !!paramUseTmux;
+    let spawnCommand = resolvedCommand;
+    let spawnArgs = args;
+    const tmuxSessionName = paramTmuxSessionName ||
+        (useTmux
+            ? generateTmuxSessionName(params.tmuxDisplayName ||
+                displayName ||
+                repoName ||
+                path.basename(cwd) ||
+                'session', id)
+            : '');
+    if (useTmux) {
+        const tmux = resolveTmuxSpawn(resolvedCommand, args, tmuxSessionName);
+        spawnCommand = tmux.command;
+        spawnArgs = tmux.args;
+    }
+    const ptyProcess = pty.spawn(spawnCommand, spawnArgs, {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd,
+        env,
+    });
+    // Scrollback buffer: stores all PTY output so we can replay on WebSocket (re)connect
+    const scrollback = initialScrollback ? [...initialScrollback] : [];
+    let scrollbackBytes = initialScrollback
+        ? initialScrollback.reduce((sum, s) => sum + s.length, 0)
+        : 0;
+    // Instantiate vendor-specific output parser dispatched by framework.parserType
+    // Falls back to 'none' parser for unknown parserType values
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const parserFactory = outputParsers[framework.parserType] ?? outputParsers['none'];
+    const parser = parserFactory();
+    const session = {
+        id,
+        type: type || 'agent',
+        agent,
+        mode: 'pty',
+        repoPath: repoPath || '',
+        worktreePath: worktreePath ?? null,
+        repoName: repoName || '',
+        branchName: branchName || '',
+        displayName: displayName || repoName || path.basename(cwd) || '',
+        pty: ptyProcess,
+        createdAt,
+        lastActivity: createdAt,
+        scrollback,
+        idle: false,
+        cwd,
+        customCommand: command || null,
+        useTmux,
+        tmuxSessionName,
+        onPtyReplacedCallbacks: [],
+        status: 'active',
+        restored: paramRestored || false,
+        needsBranchRename: false,
+        agentState: 'initializing',
+        outputParser: parser,
+        hookToken,
+        hooksActive,
+        cleanedUp: false,
+        yolo: paramYolo ?? false,
+        sessionArgs: paramClaudeArgs ?? [],
+        claudeArgs: paramClaudeArgs ?? [], // keep for backward compat
+        continuePolicy: params.continuePolicy ?? 'never',
+        // Derive dataQuality from what actually got enabled, not just the configured framework eventSource.
+        // If hook/plugin injection failed, hooksActive is false → downgrade to 'parser' for accuracy.
+        dataQuality: hooksActive ? effectiveEventSource : 'parser',
+        _lastHookTime: undefined,
+    };
+    sessionsMap.set(id, session);
+    // Load existing metadata to preserve a previously-set displayName
+    if (configPath && worktreePath) {
+        const existing = readMeta(configPath, worktreePath);
+        if (existing && existing.displayName) {
+            session.displayName = existing.displayName;
+        }
+        writeMeta(configPath, {
+            worktreePath,
+            displayName: session.displayName,
+            lastActivity: createdAt,
+        });
+    }
+    let metaFlushTimer = null;
+    let idleTimer = null;
+    function resetIdleTimer() {
+        if (session.idle) {
+            session.idle = false;
+            fireBackendStateIfChanged?.(session);
+        }
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+            if (!session.idle) {
+                session.idle = true;
+                fireBackendStateIfChanged?.(session);
+            }
+        }, IDLE_TIMEOUT_MS);
+    }
+    const continueArgs = framework.continueArgs;
+    function attachHandlers(proc, canRetry) {
+        const spawnTime = Date.now();
+        // Clear restored flag after 3s of running — means the PTY is healthy
+        const restoredClearTimer = session.restored
+            ? setTimeout(() => {
+                session.restored = false;
+            }, 3000)
+            : null;
+        proc.onData((data) => {
+            session.lastActivity = new Date().toISOString();
+            resetIdleTimer();
+            scrollback.push(data);
+            scrollbackBytes += data.length;
+            // Trim oldest entries if over limit
+            while (scrollbackBytes > MAX_SCROLLBACK && scrollback.length > 1) {
+                scrollbackBytes -= scrollback.shift().length;
+            }
+            if (configPath && worktreePath && !metaFlushTimer) {
+                metaFlushTimer = setTimeout(() => {
+                    metaFlushTimer = null;
+                    writeMeta(configPath, {
+                        worktreePath,
+                        displayName: session.displayName,
+                        lastActivity: session.lastActivity,
+                    });
+                }, 5000);
+            }
+            // Vendor-specific output parsing for semantic state detection
+            const parseResult = session.outputParser.onData(data, scrollback.slice(-20));
+            if (parseResult && parseResult.state !== session.agentState) {
+                if (session.hooksActive) {
+                    // Hooks are authoritative — check 30s reconciliation timeout
+                    const lastHook = session._lastHookTime;
+                    const sessionAge = Date.now() - new Date(session.createdAt).getTime();
+                    if (lastHook && Date.now() - lastHook > 30000) {
+                        // No hook for 30s and parser disagrees — parser overrides
+                        session.agentState = parseResult.state;
+                        for (const cb of stateChangeCallbacks)
+                            cb(session.id, parseResult.state);
+                        fireBackendStateIfChanged?.(session);
+                    }
+                    else if (!lastHook && sessionAge > 30000) {
+                        // Hooks active but never fired in 30s — allow parser to override to prevent permanent suppression
+                        session.agentState = parseResult.state;
+                        for (const cb of stateChangeCallbacks)
+                            cb(session.id, parseResult.state);
+                        fireBackendStateIfChanged?.(session);
+                    }
+                    // else: suppress parser — hooks are still fresh
+                }
+                else {
+                    // No hooks — parser is primary (current behavior)
+                    session.agentState = parseResult.state;
+                    for (const cb of stateChangeCallbacks)
+                        cb(session.id, parseResult.state);
+                    fireBackendStateIfChanged?.(session);
+                }
+            }
+        });
+        proc.onExit(() => {
+            if (canRetry && Date.now() - spawnTime < 3000) {
+                let retryArgs = rawArgs.filter((a) => !continueArgs.includes(a));
+                // Re-inject hooks settings if active (settingsPath captured from outer scope)
+                if (session.hooksActive && settingsPath) {
+                    retryArgs = ['--settings', settingsPath, ...retryArgs];
+                }
+                const retryNotice = '\r\n[relay-ide] --continue not available; starting new session...\r\n';
+                scrollback.length = 0;
+                scrollbackBytes = 0;
+                scrollback.push(retryNotice);
+                scrollbackBytes = retryNotice.length;
+                let retryCommand = resolvedCommand;
+                let retrySpawnArgs = retryArgs;
+                if (useTmux && tmuxSessionName) {
+                    const retryTmuxName = tmuxSessionName + '-retry';
+                    session.tmuxSessionName = retryTmuxName;
+                    const tmux = resolveTmuxSpawn(resolvedCommand, retryArgs, retryTmuxName);
+                    retryCommand = tmux.command;
+                    retrySpawnArgs = tmux.args;
+                }
+                let retryPty;
+                try {
+                    retryPty = pty.spawn(retryCommand, retrySpawnArgs, {
+                        name: 'xterm-256color',
+                        cols,
+                        rows,
+                        cwd,
+                        env,
+                    });
+                }
+                catch {
+                    // Retry spawn failed — fall through to normal exit cleanup
+                    if (restoredClearTimer)
+                        clearTimeout(restoredClearTimer);
+                    if (idleTimer)
+                        clearTimeout(idleTimer);
+                    if (metaFlushTimer)
+                        clearTimeout(metaFlushTimer);
+                    sessionsMap.delete(id);
+                    return;
+                }
+                session.pty = retryPty;
+                for (const cb of session.onPtyReplacedCallbacks)
+                    cb(retryPty);
+                attachHandlers(retryPty, false);
+                return;
+            }
+            if (session.cleanedUp)
+                return; // Dedup: SessionEnd hook already cleaned up
+            session.cleanedUp = true;
+            if (restoredClearTimer)
+                clearTimeout(restoredClearTimer);
+            // If PTY exited and this is a restored session, mark disconnected rather than delete
+            if (session.restored) {
+                session.status = 'disconnected';
+                session.restored = false; // clear so user-initiated kills can delete normally
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                if (metaFlushTimer)
+                    clearTimeout(metaFlushTimer);
+                return;
+            }
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            if (metaFlushTimer)
+                clearTimeout(metaFlushTimer);
+            if (configPath && worktreePath) {
+                writeMeta(configPath, {
+                    worktreePath,
+                    displayName: session.displayName,
+                    lastActivity: session.lastActivity,
+                });
+            }
+            for (const cb of sessionEndCallbacks) {
+                try {
+                    cb(id, cwd, session.branchName);
+                }
+                catch (err) {
+                    logger.error('sessionEnd callback error:', err);
+                }
+            }
+            sessionsMap.delete(id);
+            const tmpDir = path.join(os.tmpdir(), 'relay-ide', id);
+            fs.rm(tmpDir, { recursive: true, force: true }, () => { });
+        });
+    }
+    attachHandlers(ptyProcess, continueArgs.some((a) => args.includes(a)));
+    const result = {
+        id,
+        type: session.type,
+        agent: session.agent,
+        mode: 'pty',
+        repoPath: session.repoPath,
+        worktreePath: session.worktreePath,
+        repoName: session.repoName,
+        branchName: session.branchName,
+        displayName: session.displayName,
+        pid: ptyProcess.pid,
+        createdAt,
+        lastActivity: createdAt,
+        idle: false,
+        cwd,
+        customCommand: command || null,
+        useTmux,
+        tmuxSessionName,
+        status: 'active',
+        needsBranchRename: false,
+        agentState: 'initializing',
+    };
+    return { session, result };
+}

package/dist/server/push.js

@@ -0,0 +1,84 @@
+import webpush from 'web-push';
+let vapidPublicKey = null;
+const subscriptions = new Map();
+const MAX_PAYLOAD_SIZE = 4 * 1024; // 4KB
+export function ensureVapidKeys(config, configPath, save) {
+    if (config.vapidPublicKey && config.vapidPrivateKey) {
+        vapidPublicKey = config.vapidPublicKey;
+        webpush.setVapidDetails('mailto:noreply@relay-ide.local', config.vapidPublicKey, config.vapidPrivateKey);
+        return;
+    }
+    try {
+        const keys = webpush.generateVAPIDKeys();
+        config.vapidPublicKey = keys.publicKey;
+        config.vapidPrivateKey = keys.privateKey;
+        save(configPath, config);
+        vapidPublicKey = keys.publicKey;
+        webpush.setVapidDetails('mailto:noreply@relay-ide.local', keys.publicKey, keys.privateKey);
+    }
+    catch {
+        // VAPID key generation failed — push will be unavailable
+        vapidPublicKey = null;
+    }
+}
+export function getVapidPublicKey() {
+    return vapidPublicKey;
+}
+export function subscribe(subscription, sessionIds) {
+    // Replace the full session list for this endpoint — the client sends
+    // the complete set of sessions it wants notifications for.
+    subscriptions.set(subscription.endpoint, {
+        subscription,
+        sessionIds: new Set(sessionIds),
+    });
+}
+export function unsubscribe(endpoint) {
+    subscriptions.delete(endpoint);
+}
+export function removeSession(sessionId) {
+    for (const entry of subscriptions.values()) {
+        entry.sessionIds.delete(sessionId);
+    }
+}
+function truncatePayload(payload) {
+    if (payload.length <= MAX_PAYLOAD_SIZE)
+        return payload;
+    // Try to parse, truncate text fields, and re-serialize
+    try {
+        const obj = JSON.parse(payload);
+        if (typeof obj.enrichedMessage === 'string' &&
+            obj.enrichedMessage.length > 100) {
+            obj.enrichedMessage =
+                obj.enrichedMessage.slice(0, 100) + '...';
+        }
+        const truncated = JSON.stringify(obj);
+        if (truncated.length <= MAX_PAYLOAD_SIZE)
+            return truncated;
+    }
+    catch {
+        // fall through
+    }
+    return payload.slice(0, MAX_PAYLOAD_SIZE);
+}
+export function notifySessionAttention(sessionId, session) {
+    if (!vapidPublicKey)
+        return;
+    const payloadObj = {
+        type: 'session-attention',
+        sessionId,
+        displayName: session.displayName,
+        sessionType: session.type,
+    };
+    const payload = truncatePayload(JSON.stringify(payloadObj));
+    for (const [endpoint, entry] of subscriptions) {
+        if (!entry.sessionIds.has(sessionId))
+            continue;
+        webpush
+            .sendNotification(entry.subscription, payload)
+            .catch((err) => {
+            if (err.statusCode === 410 || err.statusCode === 404) {
+                subscriptions.delete(endpoint);
+            }
+        });
+    }
+}