clawdbot 2026.1.4-1

package/dist/gateway/server-methods/sessions.js

@@ -0,0 +1,305 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../../agents/defaults.js";
+import { buildAllowedModelSet, buildModelAliasIndex, modelKey, resolveConfiguredModelRef, resolveModelRefFromString, } from "../../agents/model-selection.js";
+import { abortEmbeddedPiRun, isEmbeddedPiRunActive, resolveEmbeddedSessionLane, waitForEmbeddedPiRunEnd, } from "../../agents/pi-embedded.js";
+import { normalizeGroupActivation } from "../../auto-reply/group-activation.js";
+import { normalizeThinkLevel, normalizeVerboseLevel, } from "../../auto-reply/thinking.js";
+import { loadConfig } from "../../config/config.js";
+import { loadSessionStore, resolveMainSessionKey, resolveStorePath, saveSessionStore, } from "../../config/sessions.js";
+import { clearCommandLane } from "../../process/command-queue.js";
+import { normalizeSendPolicy } from "../../sessions/send-policy.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateSessionsCompactParams, validateSessionsDeleteParams, validateSessionsListParams, validateSessionsPatchParams, validateSessionsResetParams, } from "../protocol/index.js";
+import { archiveFileOnDisk, listSessionsFromStore, loadSessionEntry, resolveSessionTranscriptCandidates, } from "../session-utils.js";
+export const sessionsHandlers = {
+    "sessions.list": ({ params, respond }) => {
+        if (!validateSessionsListParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.list params: ${formatValidationErrors(validateSessionsListParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const cfg = loadConfig();
+        const storePath = resolveStorePath(cfg.session?.store);
+        const store = loadSessionStore(storePath);
+        const result = listSessionsFromStore({
+            cfg,
+            storePath,
+            store,
+            opts: p,
+        });
+        respond(true, result, undefined);
+    },
+    "sessions.patch": async ({ params, respond, context }) => {
+        if (!validateSessionsPatchParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.patch params: ${formatValidationErrors(validateSessionsPatchParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const key = String(p.key ?? "").trim();
+        if (!key) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "key required"));
+            return;
+        }
+        const cfg = loadConfig();
+        const storePath = resolveStorePath(cfg.session?.store);
+        const store = loadSessionStore(storePath);
+        const now = Date.now();
+        const existing = store[key];
+        const next = existing
+            ? {
+                ...existing,
+                updatedAt: Math.max(existing.updatedAt ?? 0, now),
+            }
+            : { sessionId: randomUUID(), updatedAt: now };
+        if ("thinkingLevel" in p) {
+            const raw = p.thinkingLevel;
+            if (raw === null) {
+                delete next.thinkingLevel;
+            }
+            else if (raw !== undefined) {
+                const normalized = normalizeThinkLevel(String(raw));
+                if (!normalized) {
+                    respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "invalid thinkingLevel (use off|minimal|low|medium|high)"));
+                    return;
+                }
+                if (normalized === "off")
+                    delete next.thinkingLevel;
+                else
+                    next.thinkingLevel = normalized;
+            }
+        }
+        if ("verboseLevel" in p) {
+            const raw = p.verboseLevel;
+            if (raw === null) {
+                delete next.verboseLevel;
+            }
+            else if (raw !== undefined) {
+                const normalized = normalizeVerboseLevel(String(raw));
+                if (!normalized) {
+                    respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, 'invalid verboseLevel (use "on"|"off")'));
+                    return;
+                }
+                if (normalized === "off")
+                    delete next.verboseLevel;
+                else
+                    next.verboseLevel = normalized;
+            }
+        }
+        if ("model" in p) {
+            const raw = p.model;
+            if (raw === null) {
+                delete next.providerOverride;
+                delete next.modelOverride;
+            }
+            else if (raw !== undefined) {
+                const trimmed = String(raw).trim();
+                if (!trimmed) {
+                    respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "invalid model: empty"));
+                    return;
+                }
+                const resolvedDefault = resolveConfiguredModelRef({
+                    cfg,
+                    defaultProvider: DEFAULT_PROVIDER,
+                    defaultModel: DEFAULT_MODEL,
+                });
+                const aliasIndex = buildModelAliasIndex({
+                    cfg,
+                    defaultProvider: resolvedDefault.provider,
+                });
+                const resolved = resolveModelRefFromString({
+                    raw: trimmed,
+                    defaultProvider: resolvedDefault.provider,
+                    aliasIndex,
+                });
+                if (!resolved) {
+                    respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid model: ${trimmed}`));
+                    return;
+                }
+                const catalog = await context.loadGatewayModelCatalog();
+                const allowed = buildAllowedModelSet({
+                    cfg,
+                    catalog,
+                    defaultProvider: resolvedDefault.provider,
+                });
+                const key = modelKey(resolved.ref.provider, resolved.ref.model);
+                if (!allowed.allowAny && !allowed.allowedKeys.has(key)) {
+                    respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `model not allowed: ${key}`));
+                    return;
+                }
+                if (resolved.ref.provider === resolvedDefault.provider &&
+                    resolved.ref.model === resolvedDefault.model) {
+                    delete next.providerOverride;
+                    delete next.modelOverride;
+                }
+                else {
+                    next.providerOverride = resolved.ref.provider;
+                    next.modelOverride = resolved.ref.model;
+                }
+            }
+        }
+        if ("sendPolicy" in p) {
+            const raw = p.sendPolicy;
+            if (raw === null) {
+                delete next.sendPolicy;
+            }
+            else if (raw !== undefined) {
+                const normalized = normalizeSendPolicy(String(raw));
+                if (!normalized) {
+                    respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, 'invalid sendPolicy (use "allow"|"deny")'));
+                    return;
+                }
+                next.sendPolicy = normalized;
+            }
+        }
+        if ("groupActivation" in p) {
+            const raw = p.groupActivation;
+            if (raw === null) {
+                delete next.groupActivation;
+            }
+            else if (raw !== undefined) {
+                const normalized = normalizeGroupActivation(String(raw));
+                if (!normalized) {
+                    respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, 'invalid groupActivation (use "mention"|"always")'));
+                    return;
+                }
+                next.groupActivation = normalized;
+            }
+        }
+        store[key] = next;
+        await saveSessionStore(storePath, store);
+        const result = {
+            ok: true,
+            path: storePath,
+            key,
+            entry: next,
+        };
+        respond(true, result, undefined);
+    },
+    "sessions.reset": async ({ params, respond }) => {
+        if (!validateSessionsResetParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.reset params: ${formatValidationErrors(validateSessionsResetParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const key = String(p.key ?? "").trim();
+        if (!key) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "key required"));
+            return;
+        }
+        const { storePath, store, entry } = loadSessionEntry(key);
+        const now = Date.now();
+        const next = {
+            sessionId: randomUUID(),
+            updatedAt: now,
+            systemSent: false,
+            abortedLastRun: false,
+            thinkingLevel: entry?.thinkingLevel,
+            verboseLevel: entry?.verboseLevel,
+            model: entry?.model,
+            contextTokens: entry?.contextTokens,
+            sendPolicy: entry?.sendPolicy,
+            lastChannel: entry?.lastChannel,
+            lastTo: entry?.lastTo,
+            skillsSnapshot: entry?.skillsSnapshot,
+        };
+        store[key] = next;
+        await saveSessionStore(storePath, store);
+        respond(true, { ok: true, key, entry: next }, undefined);
+    },
+    "sessions.delete": async ({ params, respond }) => {
+        if (!validateSessionsDeleteParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.delete params: ${formatValidationErrors(validateSessionsDeleteParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const key = String(p.key ?? "").trim();
+        if (!key) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "key required"));
+            return;
+        }
+        const mainKey = resolveMainSessionKey(loadConfig());
+        if (key === mainKey) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `Cannot delete the main session (${mainKey}).`));
+            return;
+        }
+        const deleteTranscript = typeof p.deleteTranscript === "boolean" ? p.deleteTranscript : true;
+        const { storePath, store, entry } = loadSessionEntry(key);
+        const sessionId = entry?.sessionId;
+        const existed = Boolean(store[key]);
+        clearCommandLane(resolveEmbeddedSessionLane(key));
+        if (sessionId && isEmbeddedPiRunActive(sessionId)) {
+            abortEmbeddedPiRun(sessionId);
+            const ended = await waitForEmbeddedPiRunEnd(sessionId, 15_000);
+            if (!ended) {
+                respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, `Session ${key} is still active; try again in a moment.`));
+                return;
+            }
+        }
+        if (existed)
+            delete store[key];
+        await saveSessionStore(storePath, store);
+        const archived = [];
+        if (deleteTranscript && sessionId) {
+            for (const candidate of resolveSessionTranscriptCandidates(sessionId, storePath)) {
+                if (!fs.existsSync(candidate))
+                    continue;
+                try {
+                    archived.push(archiveFileOnDisk(candidate, "deleted"));
+                }
+                catch {
+                    // Best-effort.
+                }
+            }
+        }
+        respond(true, { ok: true, key, deleted: existed, archived }, undefined);
+    },
+    "sessions.compact": async ({ params, respond }) => {
+        if (!validateSessionsCompactParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.compact params: ${formatValidationErrors(validateSessionsCompactParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const key = String(p.key ?? "").trim();
+        if (!key) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "key required"));
+            return;
+        }
+        const maxLines = typeof p.maxLines === "number" && Number.isFinite(p.maxLines)
+            ? Math.max(1, Math.floor(p.maxLines))
+            : 400;
+        const { storePath, store, entry } = loadSessionEntry(key);
+        const sessionId = entry?.sessionId;
+        if (!sessionId) {
+            respond(true, { ok: true, key, compacted: false, reason: "no sessionId" }, undefined);
+            return;
+        }
+        const filePath = resolveSessionTranscriptCandidates(sessionId, storePath).find((candidate) => fs.existsSync(candidate));
+        if (!filePath) {
+            respond(true, { ok: true, key, compacted: false, reason: "no transcript" }, undefined);
+            return;
+        }
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const lines = raw.split(/\r?\n/).filter((l) => l.trim().length > 0);
+        if (lines.length <= maxLines) {
+            respond(true, { ok: true, key, compacted: false, kept: lines.length }, undefined);
+            return;
+        }
+        const archived = archiveFileOnDisk(filePath, "bak");
+        const keptLines = lines.slice(-maxLines);
+        fs.writeFileSync(filePath, `${keptLines.join("\n")}\n`, "utf-8");
+        if (store[key]) {
+            delete store[key].inputTokens;
+            delete store[key].outputTokens;
+            delete store[key].totalTokens;
+            store[key].updatedAt = Date.now();
+            await saveSessionStore(storePath, store);
+        }
+        respond(true, {
+            ok: true,
+            key,
+            compacted: true,
+            archived,
+            kept: keptLines.length,
+        }, undefined);
+    },
+};

package/dist/gateway/server-methods/skills.js

@@ -0,0 +1,83 @@
+import { installSkill } from "../../agents/skills-install.js";
+import { buildWorkspaceSkillStatus } from "../../agents/skills-status.js";
+import { DEFAULT_AGENT_WORKSPACE_DIR } from "../../agents/workspace.js";
+import { loadConfig, writeConfigFile } from "../../config/config.js";
+import { resolveUserPath } from "../../utils.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateSkillsInstallParams, validateSkillsStatusParams, validateSkillsUpdateParams, } from "../protocol/index.js";
+export const skillsHandlers = {
+    "skills.status": ({ params, respond }) => {
+        if (!validateSkillsStatusParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.status params: ${formatValidationErrors(validateSkillsStatusParams.errors)}`));
+            return;
+        }
+        const cfg = loadConfig();
+        const workspaceDirRaw = cfg.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR;
+        const workspaceDir = resolveUserPath(workspaceDirRaw);
+        const report = buildWorkspaceSkillStatus(workspaceDir, {
+            config: cfg,
+        });
+        respond(true, report, undefined);
+    },
+    "skills.install": async ({ params, respond }) => {
+        if (!validateSkillsInstallParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.install params: ${formatValidationErrors(validateSkillsInstallParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const cfg = loadConfig();
+        const workspaceDirRaw = cfg.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR;
+        const result = await installSkill({
+            workspaceDir: workspaceDirRaw,
+            skillName: p.name,
+            installId: p.installId,
+            timeoutMs: p.timeoutMs,
+            config: cfg,
+        });
+        respond(result.ok, result, result.ok
+            ? undefined
+            : errorShape(ErrorCodes.UNAVAILABLE, result.message));
+    },
+    "skills.update": async ({ params, respond }) => {
+        if (!validateSkillsUpdateParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.update params: ${formatValidationErrors(validateSkillsUpdateParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const cfg = loadConfig();
+        const skills = cfg.skills ? { ...cfg.skills } : {};
+        const entries = skills.entries ? { ...skills.entries } : {};
+        const current = entries[p.skillKey] ? { ...entries[p.skillKey] } : {};
+        if (typeof p.enabled === "boolean") {
+            current.enabled = p.enabled;
+        }
+        if (typeof p.apiKey === "string") {
+            const trimmed = p.apiKey.trim();
+            if (trimmed)
+                current.apiKey = trimmed;
+            else
+                delete current.apiKey;
+        }
+        if (p.env && typeof p.env === "object") {
+            const nextEnv = current.env ? { ...current.env } : {};
+            for (const [key, value] of Object.entries(p.env)) {
+                const trimmedKey = key.trim();
+                if (!trimmedKey)
+                    continue;
+                const trimmedVal = value.trim();
+                if (!trimmedVal)
+                    delete nextEnv[trimmedKey];
+                else
+                    nextEnv[trimmedKey] = trimmedVal;
+            }
+            current.env = nextEnv;
+        }
+        entries[p.skillKey] = current;
+        skills.entries = entries;
+        const nextConfig = {
+            ...cfg,
+            skills,
+        };
+        await writeConfigFile(nextConfig);
+        respond(true, { ok: true, skillKey: p.skillKey, config: current }, undefined);
+    },
+};

package/dist/gateway/server-methods/system.js

@@ -0,0 +1,118 @@
+import { getLastHeartbeatEvent } from "../../infra/heartbeat-events.js";
+import { setHeartbeatsEnabled } from "../../infra/heartbeat-runner.js";
+import { enqueueSystemEvent, isSystemEventContextChanged, } from "../../infra/system-events.js";
+import { listSystemPresence, updateSystemPresence, } from "../../infra/system-presence.js";
+import { ErrorCodes, errorShape } from "../protocol/index.js";
+export const systemHandlers = {
+    "last-heartbeat": ({ respond }) => {
+        respond(true, getLastHeartbeatEvent(), undefined);
+    },
+    "set-heartbeats": ({ params, respond }) => {
+        const enabled = params.enabled;
+        if (typeof enabled !== "boolean") {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "invalid set-heartbeats params: enabled (boolean) required"));
+            return;
+        }
+        setHeartbeatsEnabled(enabled);
+        respond(true, { ok: true, enabled }, undefined);
+    },
+    "system-presence": ({ respond }) => {
+        const presence = listSystemPresence();
+        respond(true, presence, undefined);
+    },
+    "system-event": ({ params, respond, context }) => {
+        const text = typeof params.text === "string" ? params.text.trim() : "";
+        if (!text) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "text required"));
+            return;
+        }
+        const instanceId = typeof params.instanceId === "string" ? params.instanceId : undefined;
+        const host = typeof params.host === "string" ? params.host : undefined;
+        const ip = typeof params.ip === "string" ? params.ip : undefined;
+        const mode = typeof params.mode === "string" ? params.mode : undefined;
+        const version = typeof params.version === "string" ? params.version : undefined;
+        const platform = typeof params.platform === "string" ? params.platform : undefined;
+        const deviceFamily = typeof params.deviceFamily === "string" ? params.deviceFamily : undefined;
+        const modelIdentifier = typeof params.modelIdentifier === "string"
+            ? params.modelIdentifier
+            : undefined;
+        const lastInputSeconds = typeof params.lastInputSeconds === "number" &&
+            Number.isFinite(params.lastInputSeconds)
+            ? params.lastInputSeconds
+            : undefined;
+        const reason = typeof params.reason === "string" ? params.reason : undefined;
+        const tags = Array.isArray(params.tags) &&
+            params.tags.every((t) => typeof t === "string")
+            ? params.tags
+            : undefined;
+        const presenceUpdate = updateSystemPresence({
+            text,
+            instanceId,
+            host,
+            ip,
+            mode,
+            version,
+            platform,
+            deviceFamily,
+            modelIdentifier,
+            lastInputSeconds,
+            reason,
+            tags,
+        });
+        const isNodePresenceLine = text.startsWith("Node:");
+        if (isNodePresenceLine) {
+            const next = presenceUpdate.next;
+            const changed = new Set(presenceUpdate.changedKeys);
+            const reasonValue = next.reason ?? reason;
+            const normalizedReason = (reasonValue ?? "").toLowerCase();
+            const ignoreReason = normalizedReason.startsWith("periodic") ||
+                normalizedReason === "heartbeat";
+            const hostChanged = changed.has("host");
+            const ipChanged = changed.has("ip");
+            const versionChanged = changed.has("version");
+            const modeChanged = changed.has("mode");
+            const reasonChanged = changed.has("reason") && !ignoreReason;
+            const hasChanges = hostChanged ||
+                ipChanged ||
+                versionChanged ||
+                modeChanged ||
+                reasonChanged;
+            if (hasChanges) {
+                const contextChanged = isSystemEventContextChanged(presenceUpdate.key);
+                const parts = [];
+                if (contextChanged || hostChanged || ipChanged) {
+                    const hostLabel = next.host?.trim() || "Unknown";
+                    const ipLabel = next.ip?.trim();
+                    parts.push(`Node: ${hostLabel}${ipLabel ? ` (${ipLabel})` : ""}`);
+                }
+                if (versionChanged) {
+                    parts.push(`app ${next.version?.trim() || "unknown"}`);
+                }
+                if (modeChanged) {
+                    parts.push(`mode ${next.mode?.trim() || "unknown"}`);
+                }
+                if (reasonChanged) {
+                    parts.push(`reason ${reasonValue?.trim() || "event"}`);
+                }
+                const deltaText = parts.join(" · ");
+                if (deltaText) {
+                    enqueueSystemEvent(deltaText, {
+                        contextKey: presenceUpdate.key,
+                    });
+                }
+            }
+        }
+        else {
+            enqueueSystemEvent(text);
+        }
+        const nextPresenceVersion = context.incrementPresenceVersion();
+        context.broadcast("presence", { presence: listSystemPresence() }, {
+            dropIfSlow: true,
+            stateVersion: {
+                presence: nextPresenceVersion,
+                health: context.getHealthVersion(),
+            },
+        });
+        respond(true, { ok: true }, undefined);
+    },
+};

package/dist/gateway/server-methods/talk.js

@@ -0,0 +1,22 @@
+import { ErrorCodes, errorShape, formatValidationErrors, validateTalkModeParams, } from "../protocol/index.js";
+export const talkHandlers = {
+    "talk.mode": ({ params, respond, context, client, isWebchatConnect }) => {
+        if (client &&
+            isWebchatConnect(client.connect) &&
+            !context.hasConnectedMobileNode()) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "talk disabled: no connected iOS/Android nodes"));
+            return;
+        }
+        if (!validateTalkModeParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.mode params: ${formatValidationErrors(validateTalkModeParams.errors)}`));
+            return;
+        }
+        const payload = {
+            enabled: params.enabled,
+            phase: params.phase ?? null,
+            ts: Date.now(),
+        };
+        context.broadcast("talk.mode", payload, { dropIfSlow: true });
+        respond(true, payload, undefined);
+    },
+};

package/dist/gateway/server-methods/types.js

@@ -0,0 +1 @@
+export {};

package/dist/gateway/server-methods/voicewake.js

@@ -0,0 +1,30 @@
+import { loadVoiceWakeConfig, setVoiceWakeTriggers, } from "../../infra/voicewake.js";
+import { ErrorCodes, errorShape } from "../protocol/index.js";
+import { normalizeVoiceWakeTriggers } from "../server-utils.js";
+import { formatForLog } from "../ws-log.js";
+export const voicewakeHandlers = {
+    "voicewake.get": async ({ respond }) => {
+        try {
+            const cfg = await loadVoiceWakeConfig();
+            respond(true, { triggers: cfg.triggers });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "voicewake.set": async ({ params, respond, context }) => {
+        if (!Array.isArray(params.triggers)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "voicewake.set requires triggers: string[]"));
+            return;
+        }
+        try {
+            const triggers = normalizeVoiceWakeTriggers(params.triggers);
+            const cfg = await setVoiceWakeTriggers(triggers);
+            context.broadcastVoiceWakeChanged(cfg.triggers);
+            respond(true, { triggers: cfg.triggers });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+};

package/dist/gateway/server-methods/web.js

@@ -0,0 +1,58 @@
+import { defaultRuntime } from "../../runtime.js";
+import { startWebLoginWithQr, waitForWebLogin } from "../../web/login-qr.js";
+import { logoutWeb } from "../../web/session.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateWebLoginStartParams, validateWebLoginWaitParams, } from "../protocol/index.js";
+import { formatForLog } from "../ws-log.js";
+export const webHandlers = {
+    "web.login.start": async ({ params, respond, context }) => {
+        if (!validateWebLoginStartParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid web.login.start params: ${formatValidationErrors(validateWebLoginStartParams.errors)}`));
+            return;
+        }
+        try {
+            await context.stopWhatsAppProvider();
+            const result = await startWebLoginWithQr({
+                force: Boolean(params.force),
+                timeoutMs: typeof params.timeoutMs === "number"
+                    ? params.timeoutMs
+                    : undefined,
+                verbose: Boolean(params.verbose),
+            });
+            respond(true, result, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "web.login.wait": async ({ params, respond, context }) => {
+        if (!validateWebLoginWaitParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid web.login.wait params: ${formatValidationErrors(validateWebLoginWaitParams.errors)}`));
+            return;
+        }
+        try {
+            const result = await waitForWebLogin({
+                timeoutMs: typeof params.timeoutMs === "number"
+                    ? params.timeoutMs
+                    : undefined,
+            });
+            if (result.connected) {
+                await context.startWhatsAppProvider();
+            }
+            respond(true, result, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "web.logout": async ({ respond, context }) => {
+        try {
+            await context.stopWhatsAppProvider();
+            const cleared = await logoutWeb(defaultRuntime);
+            context.markWhatsAppLoggedOut(cleared);
+            respond(true, { cleared }, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+};