Move provider to a plugin-architecture (#661)

* refactor: introduce provider plugin registry

* refactor: move provider CLI to plugins

* docs: add provider plugin implementation notes

* refactor: shift provider runtime logic into plugins

* refactor: add plugin defaults and summaries

* docs: update provider plugin notes

* feat(commands): add /commands slash list

* Auto-reply: tidy help message

* Auto-reply: fix status command lint

* Tests: align google shared expectations

* Auto-reply: tidy help message

* Auto-reply: fix status command lint

* refactor: move provider routing into plugins

* test: align agent routing expectations

* docs: update provider plugin notes

* refactor: route replies via provider plugins

* docs: note route-reply plugin hooks

* refactor: extend provider plugin contract

* refactor: derive provider status from plugins

* refactor: unify gateway provider control

* refactor: use plugin metadata in auto-reply

* fix: parenthesize cron target selection

* refactor: derive gateway methods from plugins

* refactor: generalize provider logout

* refactor: route provider logout through plugins

* refactor: move WhatsApp web login methods into plugin

* refactor: generalize provider log prefixes

* refactor: centralize default chat provider

* refactor: derive provider lists from registry

* refactor: move provider reload noops into plugins

* refactor: resolve web login provider via alias

* refactor: derive CLI provider options from plugins

* refactor: derive prompt provider list from plugins

* style: apply biome lint fixes

* fix: resolve provider routing edge cases

* docs: update provider plugin refactor notes

* fix(gateway): harden agent provider routing

* refactor: move provider routing into plugins

* refactor: move provider CLI to plugins

* refactor: derive provider lists from registry

* fix: restore slash command parsing

* refactor: align provider ids for schema

* refactor: unify outbound target resolution

* fix: keep outbound labels stable

* feat: add msteams to cron surfaces

* fix: clean up lint build issues

* refactor: localize chat provider alias normalization

* refactor: drive gateway provider lists from plugins

* docs: update provider plugin notes

* style: format message-provider

* fix: avoid provider registry init cycles

* style: sort message-provider imports

* fix: relax provider alias map typing

* refactor: move provider routing into plugins

* refactor: add plugin pairing/config adapters

* refactor: route pairing and provider removal via plugins

* refactor: align auto-reply provider typing

* test: stabilize telegram media mocks

* docs: update provider plugin refactor notes

* refactor: pluginize outbound targets

* refactor: pluginize provider selection

* refactor: generalize text chunk limits

* docs: update provider plugin notes

* refactor: generalize group session/config

* fix: normalize provider id for room detection

* fix: avoid provider init in system prompt

* style: formatting cleanup

* refactor: normalize agent delivery targets

* test: update outbound delivery labels

* chore: fix lint regressions

* refactor: extend provider plugin adapters

* refactor: move elevated/block streaming defaults to plugins

* refactor: defer outbound send deps to plugins

* docs: note plugin-driven streaming/elevated defaults

* refactor: centralize webchat provider constant

* refactor: add provider setup adapters

* refactor: delegate provider add config to plugins

* docs: document plugin-driven provider add

* refactor: add plugin state/binding metadata

* refactor: build agent provider status from plugins

* docs: note plugin-driven agent bindings

* refactor: centralize internal provider constant usage

* fix: normalize WhatsApp targets for groups and E.164 (#631) (thanks @imfing)

* refactor: centralize default chat provider

* refactor: centralize WhatsApp target normalization

* refactor: move provider routing into plugins

* refactor: normalize agent delivery targets

* chore: fix lint regressions

* fix: normalize WhatsApp targets for groups and E.164 (#631) (thanks @imfing)

* feat: expand provider plugin adapters

* refactor: route auto-reply via provider plugins

* fix: align WhatsApp target normalization

* fix: normalize WhatsApp targets for groups and E.164 (#631) (thanks @imfing)

* refactor: centralize WhatsApp target normalization

* feat: add /config chat config updates

* docs: add /config get alias

* feat(commands): add /commands slash list

* refactor: centralize default chat provider

* style: apply biome lint fixes

* chore: fix lint regressions

* fix: clean up whatsapp allowlist typing

* style: format config command helpers

* refactor: pluginize tool threading context

* refactor: normalize session announce targets

* docs: note new plugin threading and announce hooks

* refactor: pluginize message actions

* docs: update provider plugin actions notes

* fix: align provider action adapters

* refactor: centralize webchat checks

* style: format message provider helpers

* refactor: move provider onboarding into adapters

* docs: note onboarding provider adapters

* feat: add msteams onboarding adapter

* style: organize onboarding imports

* fix: normalize msteams allowFrom types

* feat: add plugin text chunk limits

* refactor: use plugin chunk limit fallbacks

* feat: add provider mention stripping hooks

* style: organize provider plugin type imports

* refactor: generalize health snapshots

* refactor: update macOS health snapshot handling

* docs: refresh health snapshot notes

* style: format health snapshot updates

* refactor: drive security warnings via plugins

* docs: note provider security adapter

* style: format provider security adapters

* refactor: centralize provider account defaults

* refactor: type gateway client identity constants

* chore: regen gateway protocol swift

* fix: degrade health on failed provider probe

* refactor: centralize pairing approve hint

* docs: add plugin CLI command references

* refactor: route auth and tool sends through plugins

* docs: expand provider plugin hooks

* refactor: document provider docking touchpoints

* refactor: normalize internal provider defaults

* refactor: streamline outbound delivery wiring

* refactor: make provider onboarding plugin-owned

* refactor: support provider-owned agent tools

* refactor: move telegram draft chunking into telegram module

* refactor: infer provider tool sends via extractToolSend

* fix: repair plugin onboarding imports

* refactor: de-dup outbound target normalization

* style: tidy plugin and agent imports

* refactor: data-drive provider selection line

* fix: satisfy lint after provider plugin rebase

* test: deflake gateway-cli coverage

* style: format gateway-cli coverage test

* refactor(provider-plugins): simplify provider ids

* test(pairing-cli): avoid provider-specific ternary

* style(macos): swiftformat HealthStore

* refactor(sandbox): derive provider tool denylist

* fix(sandbox): avoid plugin init in defaults

* refactor(provider-plugins): centralize provider aliases

* style(test): satisfy biome

* refactor(protocol): v3 providers.status maps

* refactor(ui): adapt to protocol v3

* refactor(macos): adapt to protocol v3

* test: update providers.status v3 fixtures

* refactor(gateway): map provider runtime snapshot

* test(gateway): update reload runtime snapshot

* refactor(whatsapp): normalize heartbeat provider id

* docs(refactor): update provider plugin notes

* style: satisfy biome after rebase

* fix: describe sandboxed elevated in prompt

* feat(gateway): add agent image attachments + live probe

* refactor: derive CLI provider options from plugins

* fix(gateway): harden agent provider routing

* fix(gateway): harden agent provider routing

* refactor: align provider ids for schema

* fix(protocol): keep agent provider string

* fix(gateway): harden agent provider routing

* fix(protocol): keep agent provider string

* refactor: normalize agent delivery targets

* refactor: support provider-owned agent tools

* refactor(config): provider-keyed elevated allowFrom

* style: satisfy biome

* fix(gateway): appease provider narrowing

* style: satisfy biome

* refactor(reply): move group intro hints into plugin

* fix(reply): avoid plugin registry init cycle

* refactor(providers): add lightweight provider dock

* refactor(gateway): use typed client id in connect

* refactor(providers): document docks and avoid init cycles

* refactor(providers): make media limit helper generic

* fix(providers): break plugin registry import cycles

* style: satisfy biome

* refactor(status-all): build providers table from plugins

* refactor(gateway): delegate web login to provider plugin

* refactor(provider): drop web alias

* refactor(provider): lazy-load monitors

* style: satisfy lint/format

* style: format status-all providers table

* style: swiftformat gateway discovery model

* test: make reload plan plugin-driven

* fix: avoid token stringification in status-all

* refactor: make provider IDs explicit in status

* feat: warn on signal/imessage provider runtime errors

* test: cover gateway provider runtime warnings in status

* fix: add runtime kind to provider status issues

* test: cover health degradation on probe failure

* fix: keep routeReply lightweight

* style: organize routeReply imports

* refactor(web): extract auth-store helpers

* refactor(whatsapp): lazy login imports

* refactor(outbound): route replies via plugin outbound

* docs: update provider plugin notes

* style: format provider status issues

* fix: make sandbox scope warning wrap-safe

* refactor: load outbound adapters from provider plugins

* docs: update provider plugin outbound notes

* style(macos): fix swiftformat lint

* docs: changelog for provider plugins

* fix(macos): satisfy swiftformat

* fix(macos): open settings via menu action

* style: format after rebase

* fix(macos): open Settings via menu action

---------

Co-authored-by: LK <luke@kyohere.com>
Co-authored-by: Luke K (pr-0f3t) <2609441+lc0rp@users.noreply.github.com>
Co-authored-by: Xin <xin@imfing.com>
This commit is contained in:
authored and GitHub committed 2026-01-11 11:45:25 +00:00
1 parent 23eec7d841
commit 7acd26a2fc
232 files changed
+13642 -10809

No files matched your search

+12 -4
View File
@@ -7,6 +7,12 @@ import {
resolveStateDir,
} from "../config/config.js";
import { pickPrimaryTailnetIPv4 } from "../infra/tailnet.js";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
type GatewayClientMode,
type GatewayClientName,
} from "../utils/message-provider.js";
import { GatewayClient } from "./client.js";
import { PROTOCOL_VERSION } from "./protocol/index.js";
@@ -18,10 +24,11 @@ export type CallGatewayOptions = {
params?: unknown;
expectFinal?: boolean;
timeoutMs?: number;
clientName?: string;
clientName?: GatewayClientName;
clientDisplayName?: string;
clientVersion?: string;
platform?: string;
mode?: string;
mode?: GatewayClientMode;
instanceId?: string;
minProtocol?: number;
maxProtocol?: number;
@@ -191,10 +198,11 @@ export async function callGateway<T = unknown>(
token,
password,
instanceId: opts.instanceId ?? randomUUID(),
clientName: opts.clientName ?? "cli",
clientName: opts.clientName ?? GATEWAY_CLIENT_NAMES.CLI,
clientDisplayName: opts.clientDisplayName,
clientVersion: opts.clientVersion ?? "dev",
platform: opts.platform,
mode: opts.mode ?? "cli",
mode: opts.mode ?? GATEWAY_CLIENT_MODES.CLI,
minProtocol: opts.minProtocol ?? PROTOCOL_VERSION,
maxProtocol: opts.maxProtocol ?? PROTOCOL_VERSION,
onHelloOk: async () => {
+13 -5
View File
@@ -2,6 +2,12 @@ import { randomUUID } from "node:crypto";
import { WebSocket } from "ws";
import { rawDataToString } from "../infra/ws.js";
import { logDebug, logError } from "../logger.js";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
type GatewayClientMode,
type GatewayClientName,
} from "../utils/message-provider.js";
import {
type ConnectParams,
type EventFrame,
@@ -24,10 +30,11 @@ export type GatewayClientOptions = {
token?: string;
password?: string;
instanceId?: string;
clientName?: string;
clientName?: GatewayClientName;
clientDisplayName?: string;
clientVersion?: string;
platform?: string;
mode?: string;
mode?: GatewayClientMode;
minProtocol?: number;
maxProtocol?: number;
onEvent?: (evt: EventFrame) => void;
@@ -109,10 +116,11 @@ export class GatewayClient {
minProtocol: this.opts.minProtocol ?? PROTOCOL_VERSION,
maxProtocol: this.opts.maxProtocol ?? PROTOCOL_VERSION,
client: {
name: this.opts.clientName ?? "gateway-client",
id: this.opts.clientName ?? GATEWAY_CLIENT_NAMES.GATEWAY_CLIENT,
displayName: this.opts.clientDisplayName,
version: this.opts.clientVersion ?? "dev",
platform: this.opts.platform ?? process.platform,
mode: this.opts.mode ?? "backend",
mode: this.opts.mode ?? GATEWAY_CLIENT_MODES.BACKEND,
instanceId: this.opts.instanceId,
},
caps: [],
@@ -135,7 +143,7 @@ export class GatewayClient {
err instanceof Error ? err : new Error(String(err)),
);
const msg = `gateway connect failed: ${String(err)}`;
if (this.opts.mode === "probe") logDebug(msg);
if (this.opts.mode === GATEWAY_CLIENT_MODES.PROBE) logDebug(msg);
else logError(msg);
this.ws?.close(1008, "connect failed");
});
+17 -4
View File
@@ -1,4 +1,5 @@
import { describe, expect, it } from "vitest";
import { listProviderPlugins } from "../providers/plugins/index.js";
import {
buildGatewayReloadPlan,
diffConfigPaths,
@@ -35,11 +36,23 @@ describe("buildGatewayReloadPlan", () => {
expect(plan.reloadHooks).toBe(true);
});
it("restarts providers for web/telegram changes", () => {
const plan = buildGatewayReloadPlan(["web.enabled", "telegram.botToken"]);
it("restarts providers when provider config prefixes change", () => {
const changedPaths = ["web.enabled", "telegram.botToken"];
const plan = buildGatewayReloadPlan(changedPaths);
expect(plan.restartGateway).toBe(false);
expect(plan.restartProviders.has("whatsapp")).toBe(true);
expect(plan.restartProviders.has("telegram")).toBe(true);
const expected = new Set(
listProviderPlugins()
.filter((plugin) =>
(plugin.reload?.configPrefixes ?? []).some((prefix) =>
changedPaths.some(
(path) => path === prefix || path.startsWith(`${prefix}.`),
),
),
)
.map((plugin) => plugin.id),
);
expect(expected.size).toBeGreaterThan(0);
expect(plan.restartProviders).toEqual(expected);
});
it("treats gateway.remote as no-op", () => {
+54 -49
View File
@@ -5,20 +5,17 @@ import type {
ConfigFileSnapshot,
GatewayReloadMode,
} from "../config/config.js";
import {
listProviderPlugins,
type ProviderId,
} from "../providers/plugins/index.js";
export type GatewayReloadSettings = {
mode: GatewayReloadMode;
debounceMs: number;
};
export type ProviderKind =
| "whatsapp"
| "telegram"
| "discord"
| "slack"
| "signal"
| "imessage"
| "msteams";
export type ProviderKind = ProviderId;
export type GatewayReloadPlan = {
changedPaths: string[];
@@ -46,20 +43,14 @@ type ReloadAction =
| "restart-browser-control"
| "restart-cron"
| "restart-heartbeat"
| "restart-provider:whatsapp"
| "restart-provider:telegram"
| "restart-provider:discord"
| "restart-provider:slack"
| "restart-provider:signal"
| "restart-provider:imessage"
| "restart-provider:msteams";
| `restart-provider:${ProviderId}`;
const DEFAULT_RELOAD_SETTINGS: GatewayReloadSettings = {
mode: "hybrid",
debounceMs: 300,
};
const RELOAD_RULES: ReloadRule[] = [
const BASE_RELOAD_RULES: ReloadRule[] = [
{ prefix: "gateway.remote", kind: "none" },
{ prefix: "gateway.reload", kind: "none" },
{ prefix: "hooks.gmail", kind: "hot", actions: ["restart-gmail-watcher"] },
@@ -69,29 +60,28 @@ const RELOAD_RULES: ReloadRule[] = [
kind: "hot",
actions: ["restart-heartbeat"],
},
{ prefix: "agent.heartbeat", kind: "hot", actions: ["restart-heartbeat"] },
{ prefix: "cron", kind: "hot", actions: ["restart-cron"] },
{
prefix: "browser",
kind: "hot",
actions: ["restart-browser-control"],
},
{ prefix: "web", kind: "hot", actions: ["restart-provider:whatsapp"] },
{ prefix: "telegram", kind: "hot", actions: ["restart-provider:telegram"] },
{ prefix: "discord", kind: "hot", actions: ["restart-provider:discord"] },
{ prefix: "slack", kind: "hot", actions: ["restart-provider:slack"] },
{ prefix: "signal", kind: "hot", actions: ["restart-provider:signal"] },
{ prefix: "imessage", kind: "hot", actions: ["restart-provider:imessage"] },
{ prefix: "msteams", kind: "hot", actions: ["restart-provider:msteams"] },
];
const BASE_RELOAD_RULES_TAIL: ReloadRule[] = [
{ prefix: "identity", kind: "none" },
{ prefix: "wizard", kind: "none" },
{ prefix: "logging", kind: "none" },
{ prefix: "models", kind: "none" },
{ prefix: "agents", kind: "none" },
{ prefix: "tools", kind: "none" },
{ prefix: "bindings", kind: "none" },
{ prefix: "audio", kind: "none" },
{ prefix: "wizard", kind: "none" },
{ prefix: "logging", kind: "none" },
{ prefix: "models", kind: "none" },
{ prefix: "agent", kind: "none" },
{ prefix: "routing", kind: "none" },
{ prefix: "messages", kind: "none" },
{ prefix: "session", kind: "none" },
{ prefix: "whatsapp", kind: "none" },
{ prefix: "talk", kind: "none" },
{ prefix: "skills", kind: "none" },
{ prefix: "ui", kind: "none" },
@@ -101,8 +91,39 @@ const RELOAD_RULES: ReloadRule[] = [
{ prefix: "canvasHost", kind: "restart" },
];
let cachedReloadRules: ReloadRule[] | null = null;
function listReloadRules(): ReloadRule[] {
if (cachedReloadRules) return cachedReloadRules;
// Provider docking: plugins contribute hot reload/no-op prefixes here.
const providerReloadRules: ReloadRule[] = listProviderPlugins().flatMap(
(plugin) => [
...(plugin.reload?.configPrefixes ?? []).map(
(prefix): ReloadRule => ({
prefix,
kind: "hot",
actions: [`restart-provider:${plugin.id}` as ReloadAction],
}),
),
...(plugin.reload?.noopPrefixes ?? []).map(
(prefix): ReloadRule => ({
prefix,
kind: "none",
}),
),
],
);
const rules = [
...BASE_RELOAD_RULES,
...providerReloadRules,
...BASE_RELOAD_RULES_TAIL,
];
cachedReloadRules = rules;
return rules;
}
function matchRule(path: string): ReloadRule | null {
for (const rule of RELOAD_RULES) {
for (const rule of listReloadRules()) {
if (path === rule.prefix || path.startsWith(`${rule.prefix}.`)) return rule;
}
return null;
@@ -186,6 +207,11 @@ export function buildGatewayReloadPlan(
};
const applyAction = (action: ReloadAction) => {
if (action.startsWith("restart-provider:")) {
const provider = action.slice("restart-provider:".length) as ProviderId;
plan.restartProviders.add(provider);
return;
}
switch (action) {
case "reload-hooks":
plan.reloadHooks = true;
@@ -202,27 +228,6 @@ export function buildGatewayReloadPlan(
case "restart-heartbeat":
plan.restartHeartbeat = true;
break;
case "restart-provider:whatsapp":
plan.restartProviders.add("whatsapp");
break;
case "restart-provider:telegram":
plan.restartProviders.add("telegram");
break;
case "restart-provider:discord":
plan.restartProviders.add("discord");
break;
case "restart-provider:slack":
plan.restartProviders.add("slack");
break;
case "restart-provider:signal":
plan.restartProviders.add("signal");
break;
case "restart-provider:imessage":
plan.restartProviders.add("imessage");
break;
case "restart-provider:msteams":
plan.restartProviders.add("msteams");
break;
default:
break;
}
@@ -14,6 +14,10 @@ import { resolveClawdbotAgentDir } from "../agents/agent-paths.js";
import { getApiKeyForModel } from "../agents/model-auth.js";
import { ensureClawdbotModelsJson } from "../agents/models-config.js";
import { loadConfig } from "../config/config.js";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
} from "../utils/message-provider.js";
import { resolveUserPath } from "../utils.js";
import { GatewayClient } from "./client.js";
import { renderCatNoncePngBase64 } from "./live-image-probe.js";
@@ -115,7 +119,6 @@ function editDistance(a: string, b: string): number {
return prev[bLen] ?? Number.POSITIVE_INFINITY;
}
async function getFreePort(): Promise<number> {
return await new Promise((resolve, reject) => {
const srv = createServer();
@@ -179,9 +182,10 @@ async function connectClient(params: { url: string; token: string }) {
const client = new GatewayClient({
url: params.url,
token: params.token,
clientName: "vitest-live",
clientName: GATEWAY_CLIENT_NAMES.TEST,
clientDisplayName: "vitest-live",
clientVersion: "dev",
mode: "test",
mode: GATEWAY_CLIENT_MODES.TEST,
onHelloOk: () => stop(undefined, client),
onConnectError: (err) => stop(err),
onClose: (code, reason) =>
@@ -491,7 +495,6 @@ describeLive("gateway live (dev agent, profile keys)", () => {
);
}
}
// Regression: tool-call-only turn followed by a user message (OpenAI responses bug class).
if (
(model.provider === "openai" &&
@@ -5,6 +5,10 @@ import os from "node:os";
import path from "node:path";
import { describe, expect, it } from "vitest";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
} from "../utils/message-provider.js";
import { GatewayClient } from "./client.js";
import { startGatewayServer } from "./server.js";
@@ -246,9 +250,10 @@ async function connectClient(params: { url: string; token: string }) {
const client = new GatewayClient({
url: params.url,
token: params.token,
clientName: "vitest-mock-openai",
clientName: GATEWAY_CLIENT_NAMES.TEST,
clientDisplayName: "vitest-mock-openai",
clientVersion: "dev",
mode: "test",
mode: GATEWAY_CLIENT_MODES.TEST,
onHelloOk: () => stop(undefined, client),
onConnectError: (err) => stop(err),
onClose: (code, reason) =>
+10 -4
View File
@@ -8,6 +8,10 @@ import { describe, expect, it } from "vitest";
import { WebSocket } from "ws";
import { rawDataToString } from "../infra/ws.js";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
} from "../utils/message-provider.js";
import { PROTOCOL_VERSION } from "./protocol/index.js";
async function getFreePort(): Promise<number> {
@@ -92,10 +96,11 @@ async function connectReq(params: { url: string; token?: string }) {
minProtocol: PROTOCOL_VERSION,
maxProtocol: PROTOCOL_VERSION,
client: {
name: "vitest",
id: GATEWAY_CLIENT_NAMES.TEST,
displayName: "vitest",
version: "dev",
platform: process.platform,
mode: "test",
mode: GATEWAY_CLIENT_MODES.TEST,
},
caps: [],
auth: params.token ? { token: params.token } : undefined,
@@ -133,9 +138,10 @@ async function connectClient(params: { url: string; token?: string }) {
const client = new GatewayClient({
url: params.url,
token: params.token,
clientName: "vitest-wizard",
clientName: GATEWAY_CLIENT_NAMES.TEST,
clientDisplayName: "vitest-wizard",
clientVersion: "dev",
mode: "test",
mode: GATEWAY_CLIENT_MODES.TEST,
onHelloOk: () => stop(undefined, client),
onConnectError: (err) => stop(err),
onClose: (code, reason) =>
+7 -9
View File
@@ -1,6 +1,10 @@
import { randomUUID } from "node:crypto";
import type { IncomingMessage } from "node:http";
import type { ClawdbotConfig } from "../config/config.js";
import {
listProviderPlugins,
type ProviderId,
} from "../providers/plugins/index.js";
import { normalizeMessageProvider } from "../utils/message-provider.js";
import {
type HookMappingResolved,
@@ -147,16 +151,10 @@ export type HookAgentPayload = {
const HOOK_PROVIDER_VALUES = [
"last",
"whatsapp",
"telegram",
"discord",
"slack",
"signal",
"imessage",
"msteams",
] as const;
...listProviderPlugins().map((plugin) => plugin.id),
];
export type HookMessageProvider = (typeof HOOK_PROVIDER_VALUES)[number];
export type HookMessageProvider = ProviderId | "last";
const hookProviderSet = new Set<string>(HOOK_PROVIDER_VALUES);
export const HOOK_PROVIDER_ERROR = `provider must be ${HOOK_PROVIDER_VALUES.join("|")}`;
+6 -2
View File
@@ -1,6 +1,10 @@
import { randomUUID } from "node:crypto";
import type { SystemPresence } from "../infra/system-presence.js";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
} from "../utils/message-provider.js";
import { GatewayClient } from "./client.js";
export type GatewayProbeAuth = {
@@ -56,9 +60,9 @@ export async function probeGateway(opts: {
url: opts.url,
token: opts.auth?.token,
password: opts.auth?.password,
clientName: "cli",
clientName: GATEWAY_CLIENT_NAMES.CLI,
clientVersion: "dev",
mode: "probe",
mode: GATEWAY_CLIENT_MODES.PROBE,
instanceId,
onConnectError: (err) => {
connectError = formatError(err);
+74
View File
@@ -0,0 +1,74 @@
export const GATEWAY_CLIENT_IDS = {
WEBCHAT_UI: "webchat-ui",
CONTROL_UI: "clawdbot-control-ui",
WEBCHAT: "webchat",
CLI: "cli",
GATEWAY_CLIENT: "gateway-client",
MACOS_APP: "clawdbot-macos",
TEST: "test",
FINGERPRINT: "fingerprint",
PROBE: "clawdbot-probe",
} as const;
export type GatewayClientId =
(typeof GATEWAY_CLIENT_IDS)[keyof typeof GATEWAY_CLIENT_IDS];
// Back-compat naming (internal): these values are IDs, not display names.
export const GATEWAY_CLIENT_NAMES = GATEWAY_CLIENT_IDS;
export type GatewayClientName = GatewayClientId;
export const GATEWAY_CLIENT_MODES = {
WEBCHAT: "webchat",
CLI: "cli",
UI: "ui",
BACKEND: "backend",
PROBE: "probe",
TEST: "test",
} as const;
export type GatewayClientMode =
(typeof GATEWAY_CLIENT_MODES)[keyof typeof GATEWAY_CLIENT_MODES];
export type GatewayClientInfo = {
id: GatewayClientId;
displayName?: string;
version: string;
platform: string;
deviceFamily?: string;
modelIdentifier?: string;
mode: GatewayClientMode;
instanceId?: string;
};
const GATEWAY_CLIENT_ID_SET = new Set<GatewayClientId>(
Object.values(GATEWAY_CLIENT_IDS),
);
const GATEWAY_CLIENT_MODE_SET = new Set<GatewayClientMode>(
Object.values(GATEWAY_CLIENT_MODES),
);
export function normalizeGatewayClientId(
raw?: string | null,
): GatewayClientId | undefined {
const normalized = raw?.trim().toLowerCase();
if (!normalized) return undefined;
return GATEWAY_CLIENT_ID_SET.has(normalized as GatewayClientId)
? (normalized as GatewayClientId)
: undefined;
}
export function normalizeGatewayClientName(
raw?: string | null,
): GatewayClientName | undefined {
return normalizeGatewayClientId(raw);
}
export function normalizeGatewayClientMode(
raw?: string | null,
): GatewayClientMode | undefined {
const normalized = raw?.trim().toLowerCase();
if (!normalized) return undefined;
return GATEWAY_CLIENT_MODE_SET.has(normalized as GatewayClientMode)
? (normalized as GatewayClientMode)
: undefined;
}
+11
View File
@@ -86,8 +86,12 @@ import {
type PresenceEntry,
PresenceEntrySchema,
ProtocolSchemas,
type ProvidersLogoutParams,
ProvidersLogoutParamsSchema,
type ProvidersStatusParams,
ProvidersStatusParamsSchema,
type ProvidersStatusResult,
ProvidersStatusResultSchema,
type RequestFrame,
RequestFrameSchema,
type ResponseFrame,
@@ -247,6 +251,9 @@ export const validateTalkModeParams =
export const validateProvidersStatusParams = ajv.compile<ProvidersStatusParams>(
ProvidersStatusParamsSchema,
);
export const validateProvidersLogoutParams = ajv.compile<ProvidersLogoutParams>(
ProvidersLogoutParamsSchema,
);
export const validateModelsListParams = ajv.compile<ModelsListParams>(
ModelsListParamsSchema,
);
@@ -344,6 +351,8 @@ export {
WizardStartResultSchema,
WizardStatusResultSchema,
ProvidersStatusParamsSchema,
ProvidersStatusResultSchema,
ProvidersLogoutParamsSchema,
WebLoginStartParamsSchema,
WebLoginWaitParamsSchema,
AgentSummarySchema,
@@ -409,6 +418,8 @@ export type {
WizardStatusResult,
TalkModeParams,
ProvidersStatusParams,
ProvidersStatusResult,
ProvidersLogoutParams,
WebLoginStartParams,
WebLoginWaitParams,
AgentSummary,
+79 -12
View File
@@ -1,5 +1,6 @@
import { type Static, type TSchema, Type } from "@sinclair/typebox";
import { SESSION_LABEL_MAX_LENGTH } from "../../sessions/session-label.js";
import { GATEWAY_CLIENT_IDS, GATEWAY_CLIENT_MODES } from "./client-info.js";
const NonEmptyString = Type.String({ minLength: 1 });
const SessionLabelString = Type.String({
@@ -7,6 +8,13 @@ const SessionLabelString = Type.String({
maxLength: SESSION_LABEL_MAX_LENGTH,
});
const GatewayClientIdSchema = Type.Union(
Object.values(GATEWAY_CLIENT_IDS).map((value) => Type.Literal(value)),
);
const GatewayClientModeSchema = Type.Union(
Object.values(GATEWAY_CLIENT_MODES).map((value) => Type.Literal(value)),
);
export const PresenceEntrySchema = Type.Object(
{
host: Type.Optional(NonEmptyString),
@@ -69,12 +77,13 @@ export const ConnectParamsSchema = Type.Object(
maxProtocol: Type.Integer({ minimum: 1 }),
client: Type.Object(
{
name: NonEmptyString,
id: GatewayClientIdSchema,
displayName: Type.Optional(NonEmptyString),
version: NonEmptyString,
platform: NonEmptyString,
deviceFamily: Type.Optional(NonEmptyString),
modelIdentifier: Type.Optional(NonEmptyString),
mode: NonEmptyString,
mode: GatewayClientModeSchema,
instanceId: Type.Optional(NonEmptyString),
},
{ additionalProperties: false },
@@ -587,6 +596,68 @@ export const ProvidersStatusParamsSchema = Type.Object(
{ additionalProperties: false },
);
// Provider docking: providers.status is intentionally schema-light so new
// providers can ship without protocol updates.
export const ProviderAccountSnapshotSchema = Type.Object(
{
accountId: NonEmptyString,
name: Type.Optional(Type.String()),
enabled: Type.Optional(Type.Boolean()),
configured: Type.Optional(Type.Boolean()),
linked: Type.Optional(Type.Boolean()),
running: Type.Optional(Type.Boolean()),
connected: Type.Optional(Type.Boolean()),
reconnectAttempts: Type.Optional(Type.Integer({ minimum: 0 })),
lastConnectedAt: Type.Optional(Type.Integer({ minimum: 0 })),
lastError: Type.Optional(Type.String()),
lastStartAt: Type.Optional(Type.Integer({ minimum: 0 })),
lastStopAt: Type.Optional(Type.Integer({ minimum: 0 })),
lastInboundAt: Type.Optional(Type.Integer({ minimum: 0 })),
lastOutboundAt: Type.Optional(Type.Integer({ minimum: 0 })),
lastProbeAt: Type.Optional(Type.Integer({ minimum: 0 })),
mode: Type.Optional(Type.String()),
dmPolicy: Type.Optional(Type.String()),
allowFrom: Type.Optional(Type.Array(Type.String())),
tokenSource: Type.Optional(Type.String()),
botTokenSource: Type.Optional(Type.String()),
appTokenSource: Type.Optional(Type.String()),
baseUrl: Type.Optional(Type.String()),
allowUnmentionedGroups: Type.Optional(Type.Boolean()),
cliPath: Type.Optional(Type.Union([Type.String(), Type.Null()])),
dbPath: Type.Optional(Type.Union([Type.String(), Type.Null()])),
port: Type.Optional(
Type.Union([Type.Integer({ minimum: 0 }), Type.Null()]),
),
probe: Type.Optional(Type.Unknown()),
audit: Type.Optional(Type.Unknown()),
application: Type.Optional(Type.Unknown()),
},
{ additionalProperties: true },
);
export const ProvidersStatusResultSchema = Type.Object(
{
ts: Type.Integer({ minimum: 0 }),
providerOrder: Type.Array(NonEmptyString),
providerLabels: Type.Record(NonEmptyString, NonEmptyString),
providers: Type.Record(NonEmptyString, Type.Unknown()),
providerAccounts: Type.Record(
NonEmptyString,
Type.Array(ProviderAccountSnapshotSchema),
),
providerDefaultAccountId: Type.Record(NonEmptyString, NonEmptyString),
},
{ additionalProperties: false },
);
export const ProvidersLogoutParamsSchema = Type.Object(
{
provider: NonEmptyString,
accountId: Type.Optional(Type.String()),
},
{ additionalProperties: false },
);
export const WebLoginStartParamsSchema = Type.Object(
{
force: Type.Optional(Type.Boolean()),
@@ -718,15 +789,7 @@ export const CronPayloadSchema = Type.Union([
timeoutSeconds: Type.Optional(Type.Integer({ minimum: 1 })),
deliver: Type.Optional(Type.Boolean()),
provider: Type.Optional(
Type.Union([
Type.Literal("last"),
Type.Literal("whatsapp"),
Type.Literal("telegram"),
Type.Literal("discord"),
Type.Literal("slack"),
Type.Literal("signal"),
Type.Literal("imessage"),
]),
Type.Union([Type.Literal("last"), NonEmptyString]),
),
to: Type.Optional(Type.String()),
bestEffortDeliver: Type.Optional(Type.Boolean()),
@@ -975,6 +1038,8 @@ export const ProtocolSchemas: Record<string, TSchema> = {
WizardStatusResult: WizardStatusResultSchema,
TalkModeParams: TalkModeParamsSchema,
ProvidersStatusParams: ProvidersStatusParamsSchema,
ProvidersStatusResult: ProvidersStatusResultSchema,
ProvidersLogoutParams: ProvidersLogoutParamsSchema,
WebLoginStartParams: WebLoginStartParamsSchema,
WebLoginWaitParams: WebLoginWaitParamsSchema,
AgentSummary: AgentSummarySchema,
@@ -1006,7 +1071,7 @@ export const ProtocolSchemas: Record<string, TSchema> = {
ShutdownEvent: ShutdownEventSchema,
};
export const PROTOCOL_VERSION = 2 as const;
export const PROTOCOL_VERSION = 3 as const;
export type ConnectParams = Static<typeof ConnectParamsSchema>;
export type HelloOk = Static<typeof HelloOkSchema>;
@@ -1052,6 +1117,8 @@ export type WizardStartResult = Static<typeof WizardStartResultSchema>;
export type WizardStatusResult = Static<typeof WizardStatusResultSchema>;
export type TalkModeParams = Static<typeof TalkModeParamsSchema>;
export type ProvidersStatusParams = Static<typeof ProvidersStatusParamsSchema>;
export type ProvidersStatusResult = Static<typeof ProvidersStatusResultSchema>;
export type ProvidersLogoutParams = Static<typeof ProvidersLogoutParamsSchema>;
export type WebLoginStartParams = Static<typeof WebLoginStartParamsSchema>;
export type WebLoginWaitParams = Static<typeof WebLoginWaitParamsSchema>;
export type AgentSummary = Static<typeof AgentSummarySchema>;
+2 -8
View File
@@ -34,6 +34,7 @@ import {
setVoiceWakeTriggers,
} from "../infra/voicewake.js";
import { clearCommandLane } from "../process/command-queue.js";
import { normalizeProviderId } from "../providers/plugins/index.js";
import { normalizeMainKey } from "../routing/session-key.js";
import { defaultRuntime } from "../runtime.js";
import {
@@ -1100,14 +1101,7 @@ export function createBridgeHandlers(ctx: BridgeHandlersContext) {
const channelRaw =
typeof link?.channel === "string" ? link.channel.trim() : "";
const channel = channelRaw.toLowerCase();
const provider =
channel === "whatsapp" ||
channel === "telegram" ||
channel === "signal" ||
channel === "imessage"
? channel
: undefined;
const provider = normalizeProviderId(channelRaw) ?? undefined;
const to =
typeof link?.to === "string" && link.to.trim()
? link.to.trim()
+32 -56
View File
@@ -9,6 +9,8 @@ import {
saveSessionStore,
} from "../../config/sessions.js";
import { registerAgentRunContext } from "../../infra/agent-events.js";
import { resolveOutboundTarget } from "../../infra/outbound/targets.js";
import { DEFAULT_CHAT_PROVIDER } from "../../providers/registry.js";
import { normalizeMainKey } from "../../routing/session-key.js";
import { defaultRuntime } from "../../runtime.js";
import { resolveSendPolicy } from "../../sessions/send-policy.js";
@@ -18,11 +20,6 @@ import {
isGatewayMessageProvider,
normalizeMessageProvider,
} from "../../utils/message-provider.js";
import { normalizeE164 } from "../../utils.js";
import {
isWhatsAppGroupJid,
normalizeWhatsAppTarget,
} from "../../whatsapp/normalize.js";
import { parseMessageWithAttachments } from "../chat-attachments.js";
import {
type AgentWaitParams,
@@ -238,7 +235,9 @@ export const agentHandlers: GatewayRequestHandlers = {
if (lastProvider && lastProvider !== INTERNAL_MESSAGE_PROVIDER) {
return lastProvider;
}
return wantsDelivery ? "whatsapp" : INTERNAL_MESSAGE_PROVIDER;
return wantsDelivery
? DEFAULT_CHAT_PROVIDER
: INTERNAL_MESSAGE_PROVIDER;
}
if (isGatewayMessageProvider(requestedProvider)) return requestedProvider;
@@ -246,59 +245,35 @@ export const agentHandlers: GatewayRequestHandlers = {
if (lastProvider && lastProvider !== INTERNAL_MESSAGE_PROVIDER) {
return lastProvider;
}
return wantsDelivery ? "whatsapp" : INTERNAL_MESSAGE_PROVIDER;
return wantsDelivery ? DEFAULT_CHAT_PROVIDER : INTERNAL_MESSAGE_PROVIDER;
})();
const resolvedTo = (() => {
const explicit =
typeof request.to === "string" && request.to.trim()
? request.to.trim()
: undefined;
if (explicit) return explicit;
if (isDeliverableMessageProvider(resolvedProvider)) {
return lastTo || undefined;
}
return undefined;
})();
const sanitizedTo = (() => {
// If we derived a WhatsApp recipient from session "lastTo", ensure it is still valid
// for the configured allowlist. Otherwise, fall back to the first allowed number so
// voice wake doesn't silently route to stale/test recipients.
if (resolvedProvider !== "whatsapp") return resolvedTo;
const explicit =
typeof request.to === "string" && request.to.trim()
? request.to.trim()
: undefined;
if (explicit) {
if (!resolvedTo) return resolvedTo;
return normalizeWhatsAppTarget(resolvedTo) ?? resolvedTo;
}
if (resolvedTo && isWhatsAppGroupJid(resolvedTo)) {
return normalizeWhatsAppTarget(resolvedTo) ?? resolvedTo;
}
const explicitTo =
typeof request.to === "string" && request.to.trim()
? request.to.trim()
: undefined;
const deliveryTargetMode = explicitTo
? "explicit"
: isDeliverableMessageProvider(resolvedProvider)
? "implicit"
: undefined;
let resolvedTo =
explicitTo ||
(isDeliverableMessageProvider(resolvedProvider)
? lastTo || undefined
: undefined);
if (!resolvedTo && isDeliverableMessageProvider(resolvedProvider)) {
const cfg = cfgForAgent ?? loadConfig();
const rawAllow = cfg.whatsapp?.allowFrom ?? [];
if (rawAllow.includes("*")) {
return resolvedTo
? (normalizeWhatsAppTarget(resolvedTo) ?? resolvedTo)
: resolvedTo;
const fallback = resolveOutboundTarget({
provider: resolvedProvider,
cfg,
accountId: sessionEntry?.lastAccountId ?? undefined,
mode: "implicit",
});
if (fallback.ok) {
resolvedTo = fallback.to;
}
const allowFrom = rawAllow
.map((val) => normalizeE164(val))
.filter((val) => val.length > 1);
if (allowFrom.length === 0) return resolvedTo;
const normalizedLast =
typeof resolvedTo === "string" && resolvedTo.trim()
? normalizeWhatsAppTarget(resolvedTo)
: undefined;
if (normalizedLast && allowFrom.includes(normalizedLast)) {
return normalizedLast;
}
return allowFrom[0];
})();
}
const deliver =
request.deliver === true &&
@@ -321,11 +296,12 @@ export const agentHandlers: GatewayRequestHandlers = {
{
message,
images,
to: sanitizedTo,
to: resolvedTo,
sessionId: resolvedSessionId,
sessionKey: requestedSessionKey,
thinking: request.thinking,
deliver,
deliveryTargetMode,
provider: resolvedProvider,
timeout: request.timeout?.toString(),
bestEffortDeliver,
+2 -1
View File
@@ -7,6 +7,7 @@ import { mergeSessionEntry, saveSessionStore } from "../../config/sessions.js";
import { registerAgentRunContext } from "../../infra/agent-events.js";
import { defaultRuntime } from "../../runtime.js";
import { resolveSendPolicy } from "../../sessions/send-policy.js";
import { INTERNAL_MESSAGE_PROVIDER } from "../../utils/message-provider.js";
import {
abortChatRunById,
abortChatRunsForSessionKey,
@@ -328,7 +329,7 @@ export const chatHandlers: GatewayRequestHandlers = {
thinking: p.thinking,
deliver: p.deliver,
timeout: Math.ceil(timeoutMs / 1000).toString(),
messageProvider: "webchat",
messageProvider: INTERNAL_MESSAGE_PROVIDER,
abortSignal: abortController.signal,
},
defaultRuntime,
+267 -488
View File
@@ -1,66 +1,80 @@
import type { ClawdbotConfig } from "../../config/config.js";
import {
loadConfig,
readConfigFileSnapshot,
writeConfigFile,
} from "../../config/config.js";
import type { TelegramGroupConfig } from "../../config/types.js";
import {
listDiscordAccountIds,
resolveDefaultDiscordAccountId,
resolveDiscordAccount,
} from "../../discord/accounts.js";
import {
auditDiscordChannelPermissions,
collectDiscordAuditChannelIds,
} from "../../discord/audit.js";
import { type DiscordProbe, probeDiscord } from "../../discord/probe.js";
import {
listIMessageAccountIds,
resolveDefaultIMessageAccountId,
resolveIMessageAccount,
} from "../../imessage/accounts.js";
import { type IMessageProbe, probeIMessage } from "../../imessage/probe.js";
import { loadConfig, readConfigFileSnapshot } from "../../config/config.js";
import { getProviderActivity } from "../../infra/provider-activity.js";
import { resolveProviderDefaultAccountId } from "../../providers/plugins/helpers.js";
import {
listSignalAccountIds,
resolveDefaultSignalAccountId,
resolveSignalAccount,
} from "../../signal/accounts.js";
import { probeSignal, type SignalProbe } from "../../signal/probe.js";
import {
listSlackAccountIds,
resolveDefaultSlackAccountId,
resolveSlackAccount,
} from "../../slack/accounts.js";
import { probeSlack, type SlackProbe } from "../../slack/probe.js";
import {
listTelegramAccountIds,
resolveDefaultTelegramAccountId,
resolveTelegramAccount,
} from "../../telegram/accounts.js";
import {
auditTelegramGroupMembership,
collectTelegramUnmentionedGroupIds,
} from "../../telegram/audit.js";
import { probeTelegram, type TelegramProbe } from "../../telegram/probe.js";
import {
listEnabledWhatsAppAccounts,
resolveDefaultWhatsAppAccountId,
} from "../../web/accounts.js";
import {
getWebAuthAgeMs,
readWebSelfId,
webAuthExists,
} from "../../web/session.js";
getProviderPlugin,
listProviderPlugins,
normalizeProviderId,
type ProviderId,
} from "../../providers/plugins/index.js";
import { buildProviderAccountSnapshot } from "../../providers/plugins/status.js";
import type {
ProviderAccountSnapshot,
ProviderPlugin,
} from "../../providers/plugins/types.js";
import { DEFAULT_ACCOUNT_ID } from "../../routing/session-key.js";
import { defaultRuntime } from "../../runtime.js";
import {
ErrorCodes,
errorShape,
formatValidationErrors,
validateProvidersLogoutParams,
validateProvidersStatusParams,
} from "../protocol/index.js";
import { formatForLog } from "../ws-log.js";
import type { GatewayRequestHandlers } from "./types.js";
import type { GatewayRequestContext, GatewayRequestHandlers } from "./types.js";
type ProviderLogoutPayload = {
provider: ProviderId;
accountId: string;
cleared: boolean;
[key: string]: unknown;
};
export async function logoutProviderAccount(params: {
providerId: ProviderId;
accountId?: string | null;
cfg: ClawdbotConfig;
context: GatewayRequestContext;
plugin: ProviderPlugin;
}): Promise<ProviderLogoutPayload> {
const resolvedAccountId =
params.accountId?.trim() ||
params.plugin.config.defaultAccountId?.(params.cfg) ||
params.plugin.config.listAccountIds(params.cfg)[0] ||
DEFAULT_ACCOUNT_ID;
const account = params.plugin.config.resolveAccount(
params.cfg,
resolvedAccountId,
);
await params.context.stopProvider(params.providerId, resolvedAccountId);
const result = await params.plugin.gateway?.logoutAccount?.({
cfg: params.cfg,
accountId: resolvedAccountId,
account,
runtime: defaultRuntime,
});
if (!result) {
throw new Error(`Provider ${params.providerId} does not support logout`);
}
const cleared = Boolean(result.cleared);
const loggedOut =
typeof result.loggedOut === "boolean" ? result.loggedOut : cleared;
if (loggedOut) {
params.context.markProviderLoggedOut(
params.providerId,
true,
resolvedAccountId,
);
}
return {
provider: params.providerId,
accountId: resolvedAccountId,
...result,
cleared,
};
}
export const providersHandlers: GatewayRequestHandlers = {
"providers.status": async ({ params, respond, context }) => {
@@ -81,457 +95,222 @@ export const providersHandlers: GatewayRequestHandlers = {
typeof timeoutMsRaw === "number" ? Math.max(1000, timeoutMsRaw) : 10_000;
const cfg = loadConfig();
const runtime = context.getRuntimeSnapshot();
const plugins = listProviderPlugins();
const pluginMap = new Map<ProviderId, ProviderPlugin>(
plugins.map((plugin) => [plugin.id, plugin]),
);
const defaultTelegramAccountId = resolveDefaultTelegramAccountId(cfg);
const defaultDiscordAccountId = resolveDefaultDiscordAccountId(cfg);
const defaultSlackAccountId = resolveDefaultSlackAccountId(cfg);
const defaultSignalAccountId = resolveDefaultSignalAccountId(cfg);
const defaultIMessageAccountId = resolveDefaultIMessageAccountId(cfg);
const resolveRuntimeSnapshot = (
providerId: ProviderId,
accountId: string,
defaultAccountId: string,
): ProviderAccountSnapshot | undefined => {
const accounts = runtime.providerAccounts[providerId];
const defaultRuntime = runtime.providers[providerId];
const raw =
accounts?.[accountId] ??
(accountId === defaultAccountId ? defaultRuntime : undefined);
if (!raw) return undefined;
return raw;
};
const telegramAccounts = await Promise.all(
listTelegramAccountIds(cfg).map(async (accountId) => {
const account = resolveTelegramAccount({ cfg, accountId });
const rt =
runtime.telegramAccounts?.[account.accountId] ??
(account.accountId === defaultTelegramAccountId
? runtime.telegram
: undefined);
const configured = Boolean(account.token);
let telegramProbe: TelegramProbe | undefined;
const isAccountEnabled = (plugin: ProviderPlugin, account: unknown) =>
plugin.config.isEnabled
? plugin.config.isEnabled(account, cfg)
: !account ||
typeof account !== "object" ||
(account as { enabled?: boolean }).enabled !== false;
const buildProviderAccounts = async (providerId: ProviderId) => {
const plugin = pluginMap.get(providerId);
if (!plugin) {
return {
accounts: [] as ProviderAccountSnapshot[],
defaultAccountId: DEFAULT_ACCOUNT_ID,
defaultAccount: undefined as ProviderAccountSnapshot | undefined,
resolvedAccounts: {} as Record<string, unknown>,
};
}
const accountIds = plugin.config.listAccountIds(cfg);
const defaultAccountId = resolveProviderDefaultAccountId({
plugin,
cfg,
accountIds,
});
const accounts: ProviderAccountSnapshot[] = [];
const resolvedAccounts: Record<string, unknown> = {};
for (const accountId of accountIds) {
const account = plugin.config.resolveAccount(cfg, accountId);
const enabled = isAccountEnabled(plugin, account);
resolvedAccounts[accountId] = account;
let probeResult: unknown;
let lastProbeAt: number | null = null;
const groups =
cfg.telegram?.accounts?.[account.accountId]?.groups ??
cfg.telegram?.groups;
const { groupIds, unresolvedGroups, hasWildcardUnmentionedGroups } =
collectTelegramUnmentionedGroupIds(
groups as Record<string, TelegramGroupConfig> | undefined,
);
let audit:
| Awaited<ReturnType<typeof auditTelegramGroupMembership>>
| undefined;
if (probe && configured && account.enabled) {
telegramProbe = await probeTelegram(
account.token,
timeoutMs,
account.config.proxy,
);
lastProbeAt = Date.now();
const botId =
telegramProbe.ok && telegramProbe.bot?.id != null
? telegramProbe.bot.id
: null;
if (botId && (groupIds.length > 0 || unresolvedGroups > 0)) {
const auditRes = await auditTelegramGroupMembership({
token: account.token,
botId,
groupIds,
proxyUrl: account.config.proxy,
if (probe && enabled && plugin.status?.probeAccount) {
let configured = true;
if (plugin.config.isConfigured) {
configured = await plugin.config.isConfigured(account, cfg);
}
if (configured) {
probeResult = await plugin.status.probeAccount({
account,
timeoutMs,
cfg,
});
audit = {
...auditRes,
unresolvedGroups,
hasWildcardUnmentionedGroups,
};
} else if (unresolvedGroups > 0 || hasWildcardUnmentionedGroups) {
audit = {
ok: unresolvedGroups === 0 && !hasWildcardUnmentionedGroups,
checkedGroups: 0,
unresolvedGroups,
hasWildcardUnmentionedGroups,
groups: [],
elapsedMs: 0,
};
lastProbeAt = Date.now();
}
}
const allowUnmentionedGroups =
Boolean(
groups?.["*"] &&
(groups["*"] as { requireMention?: boolean }).requireMention ===
false,
) ||
Object.entries(groups ?? {}).some(
([key, value]) =>
key !== "*" &&
Boolean(value) &&
typeof value === "object" &&
(value as { requireMention?: boolean }).requireMention === false,
);
return {
accountId: account.accountId,
name: account.name,
enabled: account.enabled,
configured,
tokenSource: account.tokenSource,
running: rt?.running ?? false,
mode: rt?.mode ?? (account.config.webhookUrl ? "webhook" : "polling"),
lastStartAt: rt?.lastStartAt ?? null,
lastStopAt: rt?.lastStopAt ?? null,
lastError: rt?.lastError ?? null,
probe: telegramProbe,
lastProbeAt,
audit,
allowUnmentionedGroups,
lastInboundAt: getProviderActivity({
provider: "telegram",
accountId: account.accountId,
}).inboundAt,
lastOutboundAt: getProviderActivity({
provider: "telegram",
accountId: account.accountId,
}).outboundAt,
};
}),
);
const defaultTelegramAccount =
telegramAccounts.find(
(account) => account.accountId === defaultTelegramAccountId,
) ?? telegramAccounts[0];
const discordAccounts = await Promise.all(
listDiscordAccountIds(cfg).map(async (accountId) => {
const account = resolveDiscordAccount({ cfg, accountId });
const rt =
runtime.discordAccounts?.[account.accountId] ??
(account.accountId === defaultDiscordAccountId
? runtime.discord
: undefined);
const configured = Boolean(account.token);
let discordProbe: DiscordProbe | undefined;
let lastProbeAt: number | null = null;
const { channelIds: auditChannelIds, unresolvedChannels } =
collectDiscordAuditChannelIds({ cfg, accountId: account.accountId });
let audit:
| Awaited<ReturnType<typeof auditDiscordChannelPermissions>>
| undefined;
if (probe && configured && account.enabled) {
discordProbe = await probeDiscord(account.token, timeoutMs, {
includeApplication: true,
});
lastProbeAt = Date.now();
if (auditChannelIds.length > 0 || unresolvedChannels > 0) {
const auditRes = await auditDiscordChannelPermissions({
token: account.token,
accountId: account.accountId,
channelIds: auditChannelIds,
let auditResult: unknown;
if (probe && enabled && plugin.status?.auditAccount) {
let configured = true;
if (plugin.config.isConfigured) {
configured = await plugin.config.isConfigured(account, cfg);
}
if (configured) {
auditResult = await plugin.status.auditAccount({
account,
timeoutMs,
cfg,
probe: probeResult,
});
audit = { ...auditRes, unresolvedChannels };
}
}
return {
accountId: account.accountId,
name: account.name,
enabled: account.enabled,
configured,
tokenSource: account.tokenSource,
bot: rt?.bot ?? null,
application: rt?.application ?? null,
running: rt?.running ?? false,
lastStartAt: rt?.lastStartAt ?? null,
lastStopAt: rt?.lastStopAt ?? null,
lastError: rt?.lastError ?? null,
probe: discordProbe,
lastProbeAt,
audit,
lastInboundAt: getProviderActivity({
provider: "discord",
accountId: account.accountId,
}).inboundAt,
lastOutboundAt: getProviderActivity({
provider: "discord",
accountId: account.accountId,
}).outboundAt,
};
}),
);
const defaultDiscordAccount =
discordAccounts.find(
(account) => account.accountId === defaultDiscordAccountId,
) ?? discordAccounts[0];
const slackAccounts = await Promise.all(
listSlackAccountIds(cfg).map(async (accountId) => {
const account = resolveSlackAccount({ cfg, accountId });
const rt =
runtime.slackAccounts?.[account.accountId] ??
(account.accountId === defaultSlackAccountId
? runtime.slack
: undefined);
const configured = Boolean(account.botToken && account.appToken);
let slackProbe: SlackProbe | undefined;
let lastProbeAt: number | null = null;
if (probe && configured && account.enabled && account.botToken) {
slackProbe = await probeSlack(account.botToken, timeoutMs);
lastProbeAt = Date.now();
}
return {
accountId: account.accountId,
name: account.name,
enabled: account.enabled,
configured,
botTokenSource: account.botTokenSource,
appTokenSource: account.appTokenSource,
running: rt?.running ?? false,
lastStartAt: rt?.lastStartAt ?? null,
lastStopAt: rt?.lastStopAt ?? null,
lastError: rt?.lastError ?? null,
probe: slackProbe,
lastProbeAt,
};
}),
);
const defaultSlackAccount =
slackAccounts.find(
(account) => account.accountId === defaultSlackAccountId,
) ?? slackAccounts[0];
const signalAccounts = await Promise.all(
listSignalAccountIds(cfg).map(async (accountId) => {
const account = resolveSignalAccount({ cfg, accountId });
const rt =
runtime.signalAccounts?.[account.accountId] ??
(account.accountId === defaultSignalAccountId
? runtime.signal
: undefined);
const configured = account.configured;
let signalProbe: SignalProbe | undefined;
let lastProbeAt: number | null = null;
if (probe && configured && account.enabled) {
signalProbe = await probeSignal(account.baseUrl, timeoutMs);
lastProbeAt = Date.now();
}
return {
accountId: account.accountId,
name: account.name,
enabled: account.enabled,
configured,
baseUrl: account.baseUrl,
running: rt?.running ?? false,
lastStartAt: rt?.lastStartAt ?? null,
lastStopAt: rt?.lastStopAt ?? null,
lastError: rt?.lastError ?? null,
probe: signalProbe,
lastProbeAt,
};
}),
);
const defaultSignalAccount =
signalAccounts.find(
(account) => account.accountId === defaultSignalAccountId,
) ?? signalAccounts[0];
const imessageBaseConfigured = Boolean(cfg.imessage);
let imessageProbe: IMessageProbe | undefined;
let imessageLastProbeAt: number | null = null;
if (probe && imessageBaseConfigured) {
imessageProbe = await probeIMessage(timeoutMs);
imessageLastProbeAt = Date.now();
}
const imessageAccounts = listIMessageAccountIds(cfg).map((accountId) => {
const account = resolveIMessageAccount({ cfg, accountId });
const rt =
runtime.imessageAccounts?.[account.accountId] ??
(account.accountId === defaultIMessageAccountId
? runtime.imessage
: undefined);
return {
accountId: account.accountId,
name: account.name,
enabled: account.enabled,
configured: imessageBaseConfigured,
running: rt?.running ?? false,
lastStartAt: rt?.lastStartAt ?? null,
lastStopAt: rt?.lastStopAt ?? null,
lastError: rt?.lastError ?? null,
cliPath: rt?.cliPath ?? account.config.cliPath ?? null,
dbPath: rt?.dbPath ?? account.config.dbPath ?? null,
probe: imessageProbe,
lastProbeAt: imessageLastProbeAt,
};
});
const defaultIMessageAccount =
imessageAccounts.find(
(account) => account.accountId === defaultIMessageAccountId,
) ?? imessageAccounts[0];
const defaultWhatsAppAccountId = resolveDefaultWhatsAppAccountId(cfg);
const enabledWhatsAppAccounts = listEnabledWhatsAppAccounts(cfg);
const defaultWhatsAppAccount =
enabledWhatsAppAccounts.find(
(account) => account.accountId === defaultWhatsAppAccountId,
) ?? enabledWhatsAppAccounts[0];
const linked = defaultWhatsAppAccount
? await webAuthExists(defaultWhatsAppAccount.authDir)
: false;
const authAgeMs = defaultWhatsAppAccount
? getWebAuthAgeMs(defaultWhatsAppAccount.authDir)
: null;
const self = defaultWhatsAppAccount
? readWebSelfId(defaultWhatsAppAccount.authDir)
: { e164: null, jid: null };
const defaultWhatsAppStatus = {
running: false,
connected: false,
reconnectAttempts: 0,
lastConnectedAt: null,
lastDisconnect: null,
lastMessageAt: null,
lastEventAt: null,
lastError: null,
} as const;
const whatsappAccounts = await Promise.all(
enabledWhatsAppAccounts.map(async (account) => {
const rt =
runtime.whatsappAccounts?.[account.accountId] ??
defaultWhatsAppStatus;
return {
accountId: account.accountId,
enabled: account.enabled,
linked: await webAuthExists(account.authDir),
authAgeMs: getWebAuthAgeMs(account.authDir),
self: readWebSelfId(account.authDir),
running: rt.running,
connected: rt.connected,
lastConnectedAt: rt.lastConnectedAt ?? null,
lastDisconnect: rt.lastDisconnect ?? null,
reconnectAttempts: rt.reconnectAttempts,
lastMessageAt: rt.lastMessageAt ?? null,
lastEventAt: rt.lastEventAt ?? null,
lastError: rt.lastError ?? null,
lastInboundAt: getProviderActivity({
provider: "whatsapp",
accountId: account.accountId,
}).inboundAt,
lastOutboundAt: getProviderActivity({
provider: "whatsapp",
accountId: account.accountId,
}).outboundAt,
};
}),
);
respond(
true,
{
ts: Date.now(),
whatsapp: {
configured: linked,
linked,
authAgeMs,
self,
running: runtime.whatsapp.running,
connected: runtime.whatsapp.connected,
lastConnectedAt: runtime.whatsapp.lastConnectedAt ?? null,
lastDisconnect: runtime.whatsapp.lastDisconnect ?? null,
reconnectAttempts: runtime.whatsapp.reconnectAttempts,
lastMessageAt: runtime.whatsapp.lastMessageAt ?? null,
lastEventAt: runtime.whatsapp.lastEventAt ?? null,
lastError: runtime.whatsapp.lastError ?? null,
},
whatsappAccounts,
whatsappDefaultAccountId: defaultWhatsAppAccountId,
telegram: {
configured: defaultTelegramAccount?.configured ?? false,
tokenSource: defaultTelegramAccount?.tokenSource ?? "none",
running: defaultTelegramAccount?.running ?? false,
mode: defaultTelegramAccount?.mode ?? null,
lastStartAt: defaultTelegramAccount?.lastStartAt ?? null,
lastStopAt: defaultTelegramAccount?.lastStopAt ?? null,
lastError: defaultTelegramAccount?.lastError ?? null,
probe: defaultTelegramAccount?.probe,
lastProbeAt: defaultTelegramAccount?.lastProbeAt ?? null,
},
telegramAccounts,
telegramDefaultAccountId: defaultTelegramAccountId,
discord: {
configured: defaultDiscordAccount?.configured ?? false,
tokenSource: defaultDiscordAccount?.tokenSource ?? "none",
running: defaultDiscordAccount?.running ?? false,
lastStartAt: defaultDiscordAccount?.lastStartAt ?? null,
lastStopAt: defaultDiscordAccount?.lastStopAt ?? null,
lastError: defaultDiscordAccount?.lastError ?? null,
probe: defaultDiscordAccount?.probe,
lastProbeAt: defaultDiscordAccount?.lastProbeAt ?? null,
},
discordAccounts,
discordDefaultAccountId: defaultDiscordAccountId,
slack: {
configured: defaultSlackAccount?.configured ?? false,
botTokenSource: defaultSlackAccount?.botTokenSource ?? "none",
appTokenSource: defaultSlackAccount?.appTokenSource ?? "none",
running: defaultSlackAccount?.running ?? false,
lastStartAt: defaultSlackAccount?.lastStartAt ?? null,
lastStopAt: defaultSlackAccount?.lastStopAt ?? null,
lastError: defaultSlackAccount?.lastError ?? null,
probe: defaultSlackAccount?.probe,
lastProbeAt: defaultSlackAccount?.lastProbeAt ?? null,
},
slackAccounts,
slackDefaultAccountId: defaultSlackAccountId,
signal: {
configured: defaultSignalAccount?.configured ?? false,
baseUrl: defaultSignalAccount?.baseUrl ?? null,
running: defaultSignalAccount?.running ?? false,
lastStartAt: defaultSignalAccount?.lastStartAt ?? null,
lastStopAt: defaultSignalAccount?.lastStopAt ?? null,
lastError: defaultSignalAccount?.lastError ?? null,
probe: defaultSignalAccount?.probe,
lastProbeAt: defaultSignalAccount?.lastProbeAt ?? null,
},
signalAccounts,
signalDefaultAccountId: defaultSignalAccountId,
imessage: {
configured: defaultIMessageAccount?.configured ?? false,
running: defaultIMessageAccount?.running ?? false,
lastStartAt: defaultIMessageAccount?.lastStartAt ?? null,
lastStopAt: defaultIMessageAccount?.lastStopAt ?? null,
lastError: defaultIMessageAccount?.lastError ?? null,
cliPath: defaultIMessageAccount?.cliPath ?? null,
dbPath: defaultIMessageAccount?.dbPath ?? null,
probe: defaultIMessageAccount?.probe,
lastProbeAt: defaultIMessageAccount?.lastProbeAt ?? null,
},
imessageAccounts,
imessageDefaultAccountId: defaultIMessageAccountId,
},
undefined,
);
},
"telegram.logout": async ({ respond, context }) => {
try {
await context.stopTelegramProvider();
const snapshot = await readConfigFileSnapshot();
if (!snapshot.valid) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
"config invalid; fix it before logging out",
),
const runtimeSnapshot = resolveRuntimeSnapshot(
providerId,
accountId,
defaultAccountId,
);
return;
const snapshot = await buildProviderAccountSnapshot({
plugin,
cfg,
accountId,
runtime: runtimeSnapshot,
probe: probeResult,
audit: auditResult,
});
if (lastProbeAt) snapshot.lastProbeAt = lastProbeAt;
const activity = getProviderActivity({
provider: providerId as never,
accountId,
});
if (snapshot.lastInboundAt == null) {
snapshot.lastInboundAt = activity.inboundAt;
}
if (snapshot.lastOutboundAt == null) {
snapshot.lastOutboundAt = activity.outboundAt;
}
accounts.push(snapshot);
}
const cfg = snapshot.config ?? {};
const envToken = process.env.TELEGRAM_BOT_TOKEN?.trim() ?? "";
const hadToken = Boolean(cfg.telegram?.botToken);
const nextTelegram = cfg.telegram ? { ...cfg.telegram } : undefined;
if (nextTelegram) {
delete nextTelegram.botToken;
}
const nextCfg = { ...cfg } as ClawdbotConfig;
if (nextTelegram && Object.keys(nextTelegram).length > 0) {
nextCfg.telegram = nextTelegram;
} else {
delete nextCfg.telegram;
}
await writeConfigFile(nextCfg);
const defaultAccount =
accounts.find((entry) => entry.accountId === defaultAccountId) ??
accounts[0];
return { accounts, defaultAccountId, defaultAccount, resolvedAccounts };
};
const payload: Record<string, unknown> = {
ts: Date.now(),
providerOrder: plugins.map((plugin) => plugin.id),
providerLabels: Object.fromEntries(
plugins.map((plugin) => [plugin.id, plugin.meta.label]),
),
providers: {} as Record<string, unknown>,
providerAccounts: {} as Record<string, unknown>,
providerDefaultAccountId: {} as Record<string, unknown>,
};
const providersMap = payload.providers as Record<string, unknown>;
const accountsMap = payload.providerAccounts as Record<string, unknown>;
const defaultAccountIdMap = payload.providerDefaultAccountId as Record<
string,
unknown
>;
for (const plugin of plugins) {
const { accounts, defaultAccountId, defaultAccount, resolvedAccounts } =
await buildProviderAccounts(plugin.id);
const fallbackAccount =
resolvedAccounts[defaultAccountId] ??
plugin.config.resolveAccount(cfg, defaultAccountId);
const summary = plugin.status?.buildProviderSummary
? await plugin.status.buildProviderSummary({
account: fallbackAccount,
cfg,
defaultAccountId,
snapshot:
defaultAccount ??
({
accountId: defaultAccountId,
} as ProviderAccountSnapshot),
})
: {
configured: defaultAccount?.configured ?? false,
};
providersMap[plugin.id] = summary;
accountsMap[plugin.id] = accounts;
defaultAccountIdMap[plugin.id] = defaultAccountId;
}
respond(true, payload, undefined);
},
"providers.logout": async ({ params, respond, context }) => {
if (!validateProvidersLogoutParams(params)) {
respond(
true,
{ cleared: hadToken, envToken: Boolean(envToken) },
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
`invalid providers.logout params: ${formatValidationErrors(validateProvidersLogoutParams.errors)}`,
),
);
return;
}
const rawProvider = (params as { provider?: unknown }).provider;
const providerId =
typeof rawProvider === "string" ? normalizeProviderId(rawProvider) : null;
if (!providerId) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
"invalid providers.logout provider",
),
);
return;
}
const plugin = getProviderPlugin(providerId);
if (!plugin?.gateway?.logoutAccount) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
`provider ${providerId} does not support logout`,
),
);
return;
}
const accountIdRaw = (params as { accountId?: unknown }).accountId;
const accountId =
typeof accountIdRaw === "string" ? accountIdRaw.trim() : undefined;
const snapshot = await readConfigFileSnapshot();
if (!snapshot.valid) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
"config invalid; fix it before logging out",
),
);
return;
}
try {
const payload = await logoutProviderAccount({
providerId,
accountId,
cfg: snapshot.config ?? {},
context,
plugin,
});
respond(true, payload, undefined);
} catch (err) {
respond(
false,
+143 -216
View File
@@ -1,16 +1,14 @@
import { loadConfig } from "../../config/config.js";
import { sendMessageDiscord, sendPollDiscord } from "../../discord/index.js";
import { shouldLogVerbose } from "../../globals.js";
import { sendMessageIMessage } from "../../imessage/index.js";
import { createMSTeamsPollStoreFs } from "../../msteams/polls.js";
import { sendMessageMSTeams, sendPollMSTeams } from "../../msteams/send.js";
import { deliverOutboundPayloads } from "../../infra/outbound/deliver.js";
import type { OutboundProvider } from "../../infra/outbound/targets.js";
import { resolveOutboundTarget } from "../../infra/outbound/targets.js";
import { normalizePollInput } from "../../polls.js";
import { sendMessageSignal } from "../../signal/index.js";
import { sendMessageSlack } from "../../slack/send.js";
import { sendMessageTelegram } from "../../telegram/send.js";
import { normalizeMessageProvider } from "../../utils/message-provider.js";
import { resolveDefaultWhatsAppAccountId } from "../../web/accounts.js";
import { sendMessageWhatsApp, sendPollWhatsApp } from "../../web/outbound.js";
import {
getProviderPlugin,
normalizeProviderId,
} from "../../providers/plugins/index.js";
import type { ProviderId } from "../../providers/plugins/types.js";
import { DEFAULT_CHAT_PROVIDER } from "../../providers/registry.js";
import {
ErrorCodes,
errorShape,
@@ -54,139 +52,86 @@ export const sendHandlers: GatewayRequestHandlers = {
}
const to = request.to.trim();
const message = request.message.trim();
const provider = normalizeMessageProvider(request.provider) ?? "whatsapp";
const providerInput =
typeof request.provider === "string" ? request.provider : undefined;
const normalizedProvider = providerInput
? normalizeProviderId(providerInput)
: null;
if (providerInput && !normalizedProvider) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
`unsupported provider: ${providerInput}`,
),
);
return;
}
const provider = normalizedProvider ?? DEFAULT_CHAT_PROVIDER;
const accountId =
typeof request.accountId === "string" && request.accountId.trim().length
? request.accountId.trim()
: undefined;
try {
if (provider === "telegram") {
const result = await sendMessageTelegram(to, message, {
mediaUrl: request.mediaUrl,
verbose: shouldLogVerbose(),
accountId,
});
const payload = {
runId: idem,
messageId: result.messageId,
chatId: result.chatId,
provider,
};
context.dedupe.set(`send:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
} else if (provider === "discord") {
const result = await sendMessageDiscord(to, message, {
mediaUrl: request.mediaUrl,
accountId,
});
const payload = {
runId: idem,
messageId: result.messageId,
channelId: result.channelId,
provider,
};
context.dedupe.set(`send:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
} else if (provider === "slack") {
const result = await sendMessageSlack(to, message, {
mediaUrl: request.mediaUrl,
accountId,
});
const payload = {
runId: idem,
messageId: result.messageId,
channelId: result.channelId,
provider,
};
context.dedupe.set(`send:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
} else if (provider === "signal") {
const result = await sendMessageSignal(to, message, {
mediaUrl: request.mediaUrl,
accountId,
});
const payload = {
runId: idem,
messageId: result.messageId,
provider,
};
context.dedupe.set(`send:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
} else if (provider === "imessage") {
const result = await sendMessageIMessage(to, message, {
mediaUrl: request.mediaUrl,
accountId,
});
const payload = {
runId: idem,
messageId: result.messageId,
provider,
};
context.dedupe.set(`send:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
} else if (provider === "msteams") {
const cfg = loadConfig();
const result = await sendMessageMSTeams({
cfg,
to,
text: message,
mediaUrl: request.mediaUrl,
});
const payload = {
runId: idem,
messageId: result.messageId,
conversationId: result.conversationId,
provider,
};
context.dedupe.set(`send:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
} else {
const cfg = loadConfig();
const targetAccountId =
accountId ?? resolveDefaultWhatsAppAccountId(cfg);
const result = await sendMessageWhatsApp(to, message, {
mediaUrl: request.mediaUrl,
verbose: shouldLogVerbose(),
gifPlayback: request.gifPlayback,
accountId: targetAccountId,
});
const payload = {
runId: idem,
messageId: result.messageId,
toJid: result.toJid ?? `${to}@s.whatsapp.net`,
provider,
};
context.dedupe.set(`send:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
const outboundProvider = provider as Exclude<OutboundProvider, "none">;
const plugin = getProviderPlugin(provider as ProviderId);
if (!plugin) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
`unsupported provider: ${provider}`,
),
);
return;
}
const cfg = loadConfig();
const resolved = resolveOutboundTarget({
provider: outboundProvider,
to,
cfg,
accountId,
mode: "explicit",
});
if (!resolved.ok) {
respond(
false,
undefined,
errorShape(ErrorCodes.INVALID_REQUEST, String(resolved.error)),
);
return;
}
const results = await deliverOutboundPayloads({
cfg,
provider: outboundProvider,
to: resolved.to,
accountId,
payloads: [{ text: message, mediaUrl: request.mediaUrl }],
gifPlayback: request.gifPlayback,
});
const result = results.at(-1);
if (!result) {
throw new Error("No delivery result");
}
const payload: Record<string, unknown> = {
runId: idem,
messageId: result.messageId,
provider,
};
if ("chatId" in result) payload.chatId = result.chatId;
if ("channelId" in result) payload.channelId = result.channelId;
if ("toJid" in result) payload.toJid = result.toJid;
if ("conversationId" in result) {
payload.conversationId = result.conversationId;
}
context.dedupe.set(`send:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
} catch (err) {
const error = errorShape(ErrorCodes.UNAVAILABLE, String(err));
context.dedupe.set(`send:${idem}`, {
@@ -232,22 +177,23 @@ export const sendHandlers: GatewayRequestHandlers = {
return;
}
const to = request.to.trim();
const provider = normalizeMessageProvider(request.provider) ?? "whatsapp";
if (
provider !== "whatsapp" &&
provider !== "discord" &&
provider !== "msteams"
) {
const providerInput =
typeof request.provider === "string" ? request.provider : undefined;
const normalizedProvider = providerInput
? normalizeProviderId(providerInput)
: null;
if (providerInput && !normalizedProvider) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
`unsupported poll provider: ${provider}`,
`unsupported poll provider: ${providerInput}`,
),
);
return;
}
const provider = normalizedProvider ?? DEFAULT_CHAT_PROVIDER;
const poll = {
question: request.question,
options: request.options,
@@ -259,78 +205,59 @@ export const sendHandlers: GatewayRequestHandlers = {
? request.accountId.trim()
: undefined;
try {
if (provider === "discord") {
const result = await sendPollDiscord(to, poll, { accountId });
const payload = {
runId: idem,
messageId: result.messageId,
channelId: result.channelId,
provider,
};
context.dedupe.set(`poll:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
} else if (provider === "msteams") {
const cfg = loadConfig();
const normalized = normalizePollInput(poll, { maxOptions: 12 });
const result = await sendPollMSTeams({
cfg,
to,
question: normalized.question,
options: normalized.options,
maxSelections: normalized.maxSelections,
});
const pollStore = createMSTeamsPollStoreFs();
await pollStore.createPoll({
id: result.pollId,
question: normalized.question,
options: normalized.options,
maxSelections: normalized.maxSelections,
createdAt: new Date().toISOString(),
conversationId: result.conversationId,
messageId: result.messageId,
votes: {},
});
const payload = {
runId: idem,
messageId: result.messageId,
conversationId: result.conversationId,
pollId: result.pollId,
provider,
};
context.dedupe.set(`poll:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
} else {
const cfg = loadConfig();
const accountId =
typeof request.accountId === "string" &&
request.accountId.trim().length > 0
? request.accountId.trim()
: resolveDefaultWhatsAppAccountId(cfg);
const result = await sendPollWhatsApp(to, poll, {
verbose: shouldLogVerbose(),
accountId,
});
const payload = {
runId: idem,
messageId: result.messageId,
toJid: result.toJid ?? `${to}@s.whatsapp.net`,
provider,
};
context.dedupe.set(`poll:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
const plugin = getProviderPlugin(provider as ProviderId);
const outbound = plugin?.outbound;
if (!outbound?.sendPoll) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
`unsupported poll provider: ${provider}`,
),
);
return;
}
const cfg = loadConfig();
const resolved = resolveOutboundTarget({
provider: provider as Exclude<OutboundProvider, "none">,
to,
cfg,
accountId,
mode: "explicit",
});
if (!resolved.ok) {
respond(
false,
undefined,
errorShape(ErrorCodes.INVALID_REQUEST, String(resolved.error)),
);
return;
}
const normalized = outbound.pollMaxOptions
? normalizePollInput(poll, { maxOptions: outbound.pollMaxOptions })
: normalizePollInput(poll);
const result = await outbound.sendPoll({
cfg,
to: resolved.to,
poll: normalized,
accountId,
});
const payload: Record<string, unknown> = {
runId: idem,
messageId: result.messageId,
provider,
};
if (result.toJid) payload.toJid = result.toJid;
if (result.channelId) payload.channelId = result.channelId;
if (result.conversationId) payload.conversationId = result.conversationId;
if (result.pollId) payload.pollId = result.pollId;
context.dedupe.set(`poll:${idem}`, {
ts: Date.now(),
ok: true,
payload,
});
respond(true, payload, undefined, { provider });
} catch (err) {
const error = errorShape(ErrorCodes.UNAVAILABLE, String(err));
context.dedupe.set(`poll:${idem}`, {
+13 -13
View File
@@ -69,19 +69,19 @@ export type GatewayRequestContext = {
findRunningWizard: () => string | null;
purgeWizardSession: (id: string) => void;
getRuntimeSnapshot: () => ProviderRuntimeSnapshot;
startWhatsAppProvider: (accountId?: string) => Promise<void>;
stopWhatsAppProvider: (accountId?: string) => Promise<void>;
startTelegramProvider: (accountId?: string) => Promise<void>;
stopTelegramProvider: (accountId?: string) => Promise<void>;
startDiscordProvider: (accountId?: string) => Promise<void>;
stopDiscordProvider: (accountId?: string) => Promise<void>;
startSlackProvider: (accountId?: string) => Promise<void>;
stopSlackProvider: (accountId?: string) => Promise<void>;
startSignalProvider: (accountId?: string) => Promise<void>;
stopSignalProvider: (accountId?: string) => Promise<void>;
startIMessageProvider: (accountId?: string) => Promise<void>;
stopIMessageProvider: (accountId?: string) => Promise<void>;
markWhatsAppLoggedOut: (cleared: boolean, accountId?: string) => void;
startProvider: (
provider: import("../../providers/plugins/types.js").ProviderId,
accountId?: string,
) => Promise<void>;
stopProvider: (
provider: import("../../providers/plugins/types.js").ProviderId,
accountId?: string,
) => Promise<void>;
markProviderLoggedOut: (
providerId: import("../../providers/plugins/types.js").ProviderId,
cleared: boolean,
accountId?: string,
) => void;
wizardRunner: (
opts: import("../../commands/onboard-types.js").OnboardOptions,
runtime: import("../../runtime.js").RuntimeEnv,
+60 -38
View File
@@ -1,8 +1,4 @@
import { loadConfig } from "../../config/config.js";
import { defaultRuntime } from "../../runtime.js";
import { resolveWhatsAppAccount } from "../../web/accounts.js";
import { startWebLoginWithQr, waitForWebLogin } from "../../web/login-qr.js";
import { logoutWeb } from "../../web/session.js";
import { listProviderPlugins } from "../../providers/plugins/index.js";
import {
ErrorCodes,
errorShape,
@@ -13,6 +9,15 @@ import {
import { formatForLog } from "../ws-log.js";
import type { GatewayRequestHandlers } from "./types.js";
const WEB_LOGIN_METHODS = new Set(["web.login.start", "web.login.wait"]);
const resolveWebLoginProvider = () =>
listProviderPlugins().find((plugin) =>
(plugin.gatewayMethods ?? []).some((method) =>
WEB_LOGIN_METHODS.has(method),
),
) ?? null;
export const webHandlers: GatewayRequestHandlers = {
"web.login.start": async ({ params, respond, context }) => {
if (!validateWebLoginStartParams(params)) {
@@ -31,8 +36,31 @@ export const webHandlers: GatewayRequestHandlers = {
typeof (params as { accountId?: unknown }).accountId === "string"
? (params as { accountId?: string }).accountId
: undefined;
await context.stopWhatsAppProvider(accountId);
const result = await startWebLoginWithQr({
const provider = resolveWebLoginProvider();
if (!provider) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
"web login provider is not available",
),
);
return;
}
await context.stopProvider(provider.id, accountId);
if (!provider.gateway?.loginWithQrStart) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
`web login is not supported by provider ${provider.id}`,
),
);
return;
}
const result = await provider.gateway.loginWithQrStart({
force: Boolean((params as { force?: boolean }).force),
timeoutMs:
typeof (params as { timeoutMs?: unknown }).timeoutMs === "number"
@@ -67,7 +95,30 @@ export const webHandlers: GatewayRequestHandlers = {
typeof (params as { accountId?: unknown }).accountId === "string"
? (params as { accountId?: string }).accountId
: undefined;
const result = await waitForWebLogin({
const provider = resolveWebLoginProvider();
if (!provider) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
"web login provider is not available",
),
);
return;
}
if (!provider.gateway?.loginWithQrWait) {
respond(
false,
undefined,
errorShape(
ErrorCodes.INVALID_REQUEST,
`web login is not supported by provider ${provider.id}`,
),
);
return;
}
const result = await provider.gateway.loginWithQrWait({
timeoutMs:
typeof (params as { timeoutMs?: unknown }).timeoutMs === "number"
? (params as { timeoutMs?: number }).timeoutMs
@@ -75,7 +126,7 @@ export const webHandlers: GatewayRequestHandlers = {
accountId,
});
if (result.connected) {
await context.startWhatsAppProvider(accountId);
await context.startProvider(provider.id, accountId);
}
respond(true, result, undefined);
} catch (err) {
@@ -86,33 +137,4 @@ export const webHandlers: GatewayRequestHandlers = {
);
}
},
"web.logout": async ({ params, respond, context }) => {
try {
const rawAccountId =
params && typeof params === "object" && "accountId" in params
? (params as { accountId?: unknown }).accountId
: undefined;
const accountId =
typeof rawAccountId === "string" ? rawAccountId.trim() : "";
const cfg = loadConfig();
const account = resolveWhatsAppAccount({
cfg,
accountId: accountId || undefined,
});
await context.stopWhatsAppProvider(account.accountId);
const cleared = await logoutWeb({
authDir: account.authDir,
isLegacyAuthDir: account.isLegacyAuthDir,
runtime: defaultRuntime,
});
context.markWhatsAppLoggedOut(cleared, account.accountId);
respond(true, { cleared }, undefined);
} catch (err) {
respond(
false,
undefined,
errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)),
);
}
},
};
File diff suppressed because it is too large. Load diff
+13 -8
View File
@@ -7,6 +7,10 @@ import {
emitAgentEvent,
registerAgentRunContext,
} from "../infra/agent-events.js";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
} from "../utils/message-provider.js";
import {
agentCommand,
connectOk,
@@ -30,7 +34,7 @@ function expectProviders(call: Record<string, unknown>, provider: string) {
}
describe("gateway server agent", () => {
test("agent falls back to allowFrom when lastTo is stale", async () => {
test("agent marks implicit delivery when lastTo is stale", async () => {
testState.allowFrom = ["+436769770569"];
const dir = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-gw-"));
testState.sessionStorePath = path.join(dir, "sessions.json");
@@ -66,7 +70,8 @@ describe("gateway server agent", () => {
const spy = vi.mocked(agentCommand);
const call = spy.mock.calls.at(-1)?.[0] as Record<string, unknown>;
expectProviders(call, "whatsapp");
expect(call.to).toBe("+436769770569");
expect(call.to).toBe("+1555");
expect(call.deliveryTargetMode).toBe("implicit");
expect(call.sessionId).toBe("sess-main-stale");
ws.close();
@@ -785,10 +790,10 @@ describe("gateway server agent", () => {
const { server, ws } = await startServerWithClient();
await connectOk(ws, {
client: {
name: "webchat",
id: GATEWAY_CLIENT_NAMES.WEBCHAT,
version: "1.0.0",
platform: "test",
mode: "webchat",
mode: GATEWAY_CLIENT_MODES.WEBCHAT,
},
});
@@ -833,10 +838,10 @@ describe("gateway server agent", () => {
const { server, ws } = await startServerWithClient();
await connectOk(ws, {
client: {
name: "webchat",
id: GATEWAY_CLIENT_NAMES.WEBCHAT,
version: "1.0.0",
platform: "test",
mode: "webchat",
mode: GATEWAY_CLIENT_MODES.WEBCHAT,
},
});
@@ -893,10 +898,10 @@ describe("gateway server agent", () => {
const { server, ws } = await startServerWithClient();
await connectOk(ws, {
client: {
name: "webchat",
id: GATEWAY_CLIENT_NAMES.WEBCHAT,
version: "1.0.0",
platform: "test",
mode: "webchat",
mode: GATEWAY_CLIENT_MODES.WEBCHAT,
},
});
+6 -2
View File
@@ -3,6 +3,10 @@ import os from "node:os";
import path from "node:path";
import { describe, expect, test, vi } from "vitest";
import { emitAgentEvent } from "../infra/agent-events.js";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
} from "../utils/message-provider.js";
import {
agentCommand,
connectOk,
@@ -31,10 +35,10 @@ describe("gateway server chat", () => {
const { server, ws } = await startServerWithClient();
await connectOk(ws, {
client: {
name: "clawdbot-control-ui",
id: GATEWAY_CLIENT_NAMES.CONTROL_UI,
version: "dev",
platform: "web",
mode: "webchat",
mode: GATEWAY_CLIENT_MODES.WEBCHAT,
},
});
+9 -5
View File
@@ -3,6 +3,10 @@ import { describe, expect, test } from "vitest";
import { WebSocket } from "ws";
import { emitAgentEvent } from "../infra/agent-events.js";
import { emitHeartbeatEvent } from "../infra/heartbeat-events.js";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
} from "../utils/message-provider.js";
import {
connectOk,
getFreePort,
@@ -238,12 +242,12 @@ describe("gateway server health/presence", () => {
const { server, ws } = await startServerWithClient();
await connectOk(ws, {
client: {
name: "fingerprint",
id: GATEWAY_CLIENT_NAMES.FINGERPRINT,
version: "9.9.9",
platform: "test",
deviceFamily: "iPad",
modelIdentifier: "iPad16,6",
mode: "ui",
mode: GATEWAY_CLIENT_MODES.UI,
instanceId: "abc",
},
});
@@ -264,7 +268,7 @@ describe("gateway server health/presence", () => {
const presenceRes = await presenceP;
const entries = presenceRes.payload as Array<Record<string, unknown>>;
const clientEntry = entries.find((e) => e.instanceId === "abc");
expect(clientEntry?.host).toBe("fingerprint");
expect(clientEntry?.host).toBe(GATEWAY_CLIENT_NAMES.FINGERPRINT);
expect(clientEntry?.version).toBe("9.9.9");
expect(clientEntry?.mode).toBe("ui");
expect(clientEntry?.deviceFamily).toBe("iPad");
@@ -279,10 +283,10 @@ describe("gateway server health/presence", () => {
const cliId = `cli-${randomUUID()}`;
await connectOk(ws, {
client: {
name: "cli",
id: GATEWAY_CLIENT_NAMES.CLI,
version: "dev",
platform: "test",
mode: "cli",
mode: GATEWAY_CLIENT_MODES.CLI,
instanceId: cliId,
},
});
+6 -2
View File
@@ -3,6 +3,10 @@ import os from "node:os";
import path from "node:path";
import { describe, expect, test, vi } from "vitest";
import { emitAgentEvent } from "../infra/agent-events.js";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
} from "../utils/message-provider.js";
import {
agentCommand,
bridgeInvoke,
@@ -870,10 +874,10 @@ describe("gateway server node/bridge", () => {
const { server, ws } = await startServerWithClient();
await connectOk(ws, {
client: {
name: "webchat",
id: GATEWAY_CLIENT_NAMES.WEBCHAT,
version: "1.0.0",
platform: "test",
mode: "webchat",
mode: GATEWAY_CLIENT_MODES.WEBCHAT,
},
});
+34 -27
View File
@@ -18,28 +18,28 @@ describe("gateway server providers", () => {
await connectOk(ws);
const res = await rpcReq<{
whatsapp?: { linked?: boolean };
telegram?: {
configured?: boolean;
tokenSource?: string;
probe?: unknown;
lastProbeAt?: unknown;
};
signal?: {
configured?: boolean;
probe?: unknown;
lastProbeAt?: unknown;
};
providers?: Record<
string,
| {
configured?: boolean;
tokenSource?: string;
probe?: unknown;
lastProbeAt?: unknown;
}
| { linked?: boolean }
>;
}>(ws, "providers.status", { probe: false, timeoutMs: 2000 });
expect(res.ok).toBe(true);
expect(res.payload?.whatsapp).toBeTruthy();
expect(res.payload?.telegram?.configured).toBe(false);
expect(res.payload?.telegram?.tokenSource).toBe("none");
expect(res.payload?.telegram?.probe).toBeUndefined();
expect(res.payload?.telegram?.lastProbeAt).toBeNull();
expect(res.payload?.signal?.configured).toBe(false);
expect(res.payload?.signal?.probe).toBeUndefined();
expect(res.payload?.signal?.lastProbeAt).toBeNull();
const telegram = res.payload?.providers?.telegram;
const signal = res.payload?.providers?.signal;
expect(res.payload?.providers?.whatsapp).toBeTruthy();
expect(telegram?.configured).toBe(false);
expect(telegram?.tokenSource).toBe("none");
expect(telegram?.probe).toBeUndefined();
expect(telegram?.lastProbeAt).toBeNull();
expect(signal?.configured).toBe(false);
expect(signal?.probe).toBeUndefined();
expect(signal?.lastProbeAt).toBeNull();
ws.close();
await server.close();
@@ -50,19 +50,24 @@ describe("gateway server providers", () => {
}
});
test("web.logout reports no session when missing", async () => {
test("providers.logout reports no session when missing", async () => {
const { server, ws } = await startServerWithClient();
await connectOk(ws);
const res = await rpcReq<{ cleared?: boolean }>(ws, "web.logout");
const res = await rpcReq<{ cleared?: boolean; provider?: string }>(
ws,
"providers.logout",
{ provider: "whatsapp" },
);
expect(res.ok).toBe(true);
expect(res.payload?.provider).toBe("whatsapp");
expect(res.payload?.cleared).toBe(false);
ws.close();
await server.close();
});
test("telegram.logout clears bot token from config", async () => {
test("providers.logout clears telegram bot token from config", async () => {
const prevToken = process.env.TELEGRAM_BOT_TOKEN;
delete process.env.TELEGRAM_BOT_TOKEN;
const { readConfigFileSnapshot, writeConfigFile } =
@@ -77,11 +82,13 @@ describe("gateway server providers", () => {
const { server, ws } = await startServerWithClient();
await connectOk(ws);
const res = await rpcReq<{ cleared?: boolean; envToken?: boolean }>(
ws,
"telegram.logout",
);
const res = await rpcReq<{
cleared?: boolean;
envToken?: boolean;
provider?: string;
}>(ws, "providers.logout", { provider: "telegram" });
expect(res.ok).toBe(true);
expect(res.payload?.provider).toBe("telegram");
expect(res.payload?.cleared).toBe(true);
expect(res.payload?.envToken).toBe(false);
+83 -88
View File
@@ -32,79 +32,72 @@ const hoisted = vi.hoisted(() => {
const providerManager = {
getRuntimeSnapshot: vi.fn(() => ({
whatsapp: {
running: false,
connected: false,
reconnectAttempts: 0,
lastConnectedAt: null,
lastDisconnect: null,
lastMessageAt: null,
lastEventAt: null,
lastError: null,
providers: {
whatsapp: {
running: false,
connected: false,
reconnectAttempts: 0,
lastConnectedAt: null,
lastDisconnect: null,
lastMessageAt: null,
lastEventAt: null,
lastError: null,
},
telegram: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
mode: null,
},
discord: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
},
slack: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
},
signal: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
baseUrl: null,
},
imessage: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
cliPath: null,
dbPath: null,
},
msteams: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
},
},
whatsappAccounts: {},
telegram: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
mode: null,
},
telegramAccounts: {},
discord: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
},
discordAccounts: {},
slack: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
},
slackAccounts: {},
signal: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
baseUrl: null,
},
signalAccounts: {},
imessage: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
cliPath: null,
dbPath: null,
},
imessageAccounts: {},
msteams: {
running: false,
lastStartAt: null,
lastStopAt: null,
lastError: null,
providerAccounts: {
whatsapp: {},
telegram: {},
discord: {},
slack: {},
signal: {},
imessage: {},
msteams: {},
},
})),
startProviders: vi.fn(async () => {}),
startWhatsAppProvider: vi.fn(async () => {}),
stopWhatsAppProvider: vi.fn(async () => {}),
startTelegramProvider: vi.fn(async () => {}),
stopTelegramProvider: vi.fn(async () => {}),
startDiscordProvider: vi.fn(async () => {}),
stopDiscordProvider: vi.fn(async () => {}),
startSlackProvider: vi.fn(async () => {}),
stopSlackProvider: vi.fn(async () => {}),
startSignalProvider: vi.fn(async () => {}),
stopSignalProvider: vi.fn(async () => {}),
startIMessageProvider: vi.fn(async () => {}),
stopIMessageProvider: vi.fn(async () => {}),
startMSTeamsProvider: vi.fn(async () => {}),
stopMSTeamsProvider: vi.fn(async () => {}),
markWhatsAppLoggedOut: vi.fn(),
startProvider: vi.fn(async () => {}),
stopProvider: vi.fn(async () => {}),
markProviderLoggedOut: vi.fn(),
};
const createProviderManager = vi.fn(() => providerManager);
@@ -265,33 +258,35 @@ describe("gateway hot reload", () => {
expect(hoisted.cronInstances[0].stop).toHaveBeenCalledTimes(1);
expect(hoisted.cronInstances[1].start).toHaveBeenCalledTimes(1);
expect(hoisted.providerManager.stopWhatsAppProvider).toHaveBeenCalledTimes(
1,
expect(hoisted.providerManager.stopProvider).toHaveBeenCalledTimes(5);
expect(hoisted.providerManager.startProvider).toHaveBeenCalledTimes(5);
expect(hoisted.providerManager.stopProvider).toHaveBeenCalledWith(
"whatsapp",
);
expect(hoisted.providerManager.startWhatsAppProvider).toHaveBeenCalledTimes(
1,
expect(hoisted.providerManager.startProvider).toHaveBeenCalledWith(
"whatsapp",
);
expect(hoisted.providerManager.stopTelegramProvider).toHaveBeenCalledTimes(
1,
expect(hoisted.providerManager.stopProvider).toHaveBeenCalledWith(
"telegram",
);
expect(hoisted.providerManager.startTelegramProvider).toHaveBeenCalledTimes(
1,
expect(hoisted.providerManager.startProvider).toHaveBeenCalledWith(
"telegram",
);
expect(hoisted.providerManager.stopDiscordProvider).toHaveBeenCalledTimes(
1,
expect(hoisted.providerManager.stopProvider).toHaveBeenCalledWith(
"discord",
);
expect(hoisted.providerManager.startDiscordProvider).toHaveBeenCalledTimes(
1,
expect(hoisted.providerManager.startProvider).toHaveBeenCalledWith(
"discord",
);
expect(hoisted.providerManager.stopSignalProvider).toHaveBeenCalledTimes(1);
expect(hoisted.providerManager.startSignalProvider).toHaveBeenCalledTimes(
1,
expect(hoisted.providerManager.stopProvider).toHaveBeenCalledWith("signal");
expect(hoisted.providerManager.startProvider).toHaveBeenCalledWith(
"signal",
);
expect(hoisted.providerManager.stopIMessageProvider).toHaveBeenCalledTimes(
1,
expect(hoisted.providerManager.stopProvider).toHaveBeenCalledWith(
"imessage",
);
expect(hoisted.providerManager.startIMessageProvider).toHaveBeenCalledTimes(
1,
expect(hoisted.providerManager.startProvider).toHaveBeenCalledWith(
"imessage",
);
await server.close();
+74 -148
View File
@@ -104,7 +104,16 @@ import {
runtimeForLogger,
} from "../logging.js";
import { setCommandLaneConcurrency } from "../process/command-queue.js";
import { defaultRuntime } from "../runtime.js";
import {
listProviderPlugins,
normalizeProviderId,
type ProviderId,
} from "../providers/plugins/index.js";
import { defaultRuntime, type RuntimeEnv } from "../runtime.js";
import {
isGatewayCliClient,
isWebchatClient,
} from "../utils/message-provider.js";
import { runOnboardingWizard } from "../wizard/onboarding.js";
import type { WizardSession } from "../wizard/session.js";
import {
@@ -189,21 +198,19 @@ const logCron = log.child("cron");
const logReload = log.child("reload");
const logHooks = log.child("hooks");
const logWsControl = log.child("ws");
const logWhatsApp = logProviders.child("whatsapp");
const logTelegram = logProviders.child("telegram");
const logDiscord = logProviders.child("discord");
const logSlack = logProviders.child("slack");
const logSignal = logProviders.child("signal");
const logIMessage = logProviders.child("imessage");
const logMSTeams = logProviders.child("msteams");
const canvasRuntime = runtimeForLogger(logCanvas);
const whatsappRuntimeEnv = runtimeForLogger(logWhatsApp);
const telegramRuntimeEnv = runtimeForLogger(logTelegram);
const discordRuntimeEnv = runtimeForLogger(logDiscord);
const slackRuntimeEnv = runtimeForLogger(logSlack);
const signalRuntimeEnv = runtimeForLogger(logSignal);
const imessageRuntimeEnv = runtimeForLogger(logIMessage);
const msteamsRuntimeEnv = runtimeForLogger(logMSTeams);
const providerLogs = Object.fromEntries(
listProviderPlugins().map((plugin) => [
plugin.id,
logProviders.child(plugin.id),
]),
) as Record<ProviderId, ReturnType<typeof createSubsystemLogger>>;
const providerRuntimeEnvs = Object.fromEntries(
Object.entries(providerLogs).map(([id, logger]) => [
id,
runtimeForLogger(logger),
]),
) as Record<ProviderId, RuntimeEnv>;
type GatewayModelChoice = ModelCatalogEntry;
@@ -225,10 +232,11 @@ type Client = {
presenceKey?: string;
};
const METHODS = [
const BASE_METHODS = [
"health",
"logs.tail",
"providers.status",
"providers.logout",
"status",
"usage.status",
"config.get",
@@ -277,16 +285,18 @@ const METHODS = [
"send",
"agent",
"agent.wait",
"web.login.start",
"web.login.wait",
"web.logout",
"telegram.logout",
// WebChat WebSocket-native chat methods
"chat.history",
"chat.abort",
"chat.send",
];
const PROVIDER_METHODS = listProviderPlugins().flatMap(
(plugin) => plugin.gatewayMethods ?? [],
);
const METHODS = Array.from(new Set([...BASE_METHODS, ...PROVIDER_METHODS]));
const EVENTS = [
"agent",
"chat",
@@ -377,10 +387,10 @@ function buildSnapshot(): Snapshot {
};
}
async function refreshHealthSnapshot(_opts?: { probe?: boolean }) {
async function refreshHealthSnapshot(opts?: { probe?: boolean }) {
if (!healthRefresh) {
healthRefresh = (async () => {
const snap = await getHealthSnapshot(undefined);
const snap = await getHealthSnapshot({ probe: opts?.probe });
healthCache = snap;
healthVersion += 1;
if (broadcastHealthUpdate) {
@@ -782,39 +792,15 @@ export async function startGatewayServer(
const providerManager = createProviderManager({
loadConfig,
logWhatsApp,
logTelegram,
logDiscord,
logSlack,
logSignal,
logIMessage,
logMSTeams,
whatsappRuntimeEnv,
telegramRuntimeEnv,
discordRuntimeEnv,
slackRuntimeEnv,
signalRuntimeEnv,
imessageRuntimeEnv,
msteamsRuntimeEnv,
providerLogs,
providerRuntimeEnvs,
});
const {
getRuntimeSnapshot,
startProviders,
startWhatsAppProvider,
startTelegramProvider,
startDiscordProvider,
startSlackProvider,
startSignalProvider,
startIMessageProvider,
startMSTeamsProvider,
stopWhatsAppProvider,
stopTelegramProvider,
stopDiscordProvider,
stopSlackProvider,
stopSignalProvider,
stopIMessageProvider,
stopMSTeamsProvider,
markWhatsAppLoggedOut,
startProvider,
stopProvider,
markProviderLoggedOut,
} = providerManager;
const broadcast = (
@@ -1293,8 +1279,7 @@ export async function startGatewayServer(
});
logWs("in", "open", { connId, remoteAddr });
const isWebchatConnect = (params: ConnectParams | null | undefined) =>
params?.client?.mode === "webchat" ||
params?.client?.name === "webchat-ui";
isWebchatClient(params?.client);
let handshakeState: "pending" | "connected" | "failed" = "pending";
let closeCause: string | undefined;
let closeMeta: Record<string, unknown> = {};
@@ -1476,6 +1461,8 @@ export async function startGatewayServer(
const frame = parsed as RequestFrame;
const connectParams = frame.params as ConnectParams;
const clientLabel =
connectParams.client.displayName ?? connectParams.client.id;
// protocol negotiation
const { minProtocol, maxProtocol } = connectParams;
@@ -1485,13 +1472,14 @@ export async function startGatewayServer(
) {
handshakeState = "failed";
logWsControl.warn(
`protocol mismatch conn=${connId} remote=${remoteAddr ?? "?"} client=${connectParams.client.name} ${connectParams.client.mode} v${connectParams.client.version}`,
`protocol mismatch conn=${connId} remote=${remoteAddr ?? "?"} client=${clientLabel} ${connectParams.client.mode} v${connectParams.client.version}`,
);
setCloseCause("protocol-mismatch", {
minProtocol,
maxProtocol,
expectedProtocol: PROTOCOL_VERSION,
client: connectParams.client.name,
client: connectParams.client.id,
clientDisplayName: connectParams.client.displayName,
mode: connectParams.client.mode,
version: connectParams.client.version,
});
@@ -1520,7 +1508,7 @@ export async function startGatewayServer(
if (!authResult.ok) {
handshakeState = "failed";
logWsControl.warn(
`unauthorized conn=${connId} remote=${remoteAddr ?? "?"} client=${connectParams.client.name} ${connectParams.client.mode} v${connectParams.client.version}`,
`unauthorized conn=${connId} remote=${remoteAddr ?? "?"} client=${clientLabel} ${connectParams.client.mode} v${connectParams.client.version}`,
);
const authProvided = connectParams.auth?.token
? "token"
@@ -1532,7 +1520,8 @@ export async function startGatewayServer(
authProvided,
authReason: authResult.reason,
allowTailscale: resolvedAuth.allowTailscale,
client: connectParams.client.name,
client: connectParams.client.id,
clientDisplayName: connectParams.client.displayName,
mode: connectParams.client.mode,
version: connectParams.client.version,
});
@@ -1548,14 +1537,15 @@ export async function startGatewayServer(
}
const authMethod = authResult.method ?? "none";
const shouldTrackPresence = connectParams.client.mode !== "cli";
const shouldTrackPresence = !isGatewayCliClient(connectParams.client);
const presenceKey = shouldTrackPresence
? connectParams.client.instanceId || connId
: undefined;
logWs("in", "connect", {
connId,
client: connectParams.client.name,
client: connectParams.client.id,
clientDisplayName: connectParams.client.displayName,
version: connectParams.client.version,
mode: connectParams.client.mode,
instanceId: connectParams.client.instanceId,
@@ -1565,13 +1555,16 @@ export async function startGatewayServer(
if (isWebchatConnect(connectParams)) {
logWsControl.info(
`webchat connected conn=${connId} remote=${remoteAddr ?? "?"} client=${connectParams.client.name} ${connectParams.client.mode} v${connectParams.client.version}`,
`webchat connected conn=${connId} remote=${remoteAddr ?? "?"} client=${clientLabel} ${connectParams.client.mode} v${connectParams.client.version}`,
);
}
if (presenceKey) {
upsertPresence(presenceKey, {
host: connectParams.client.name || os.hostname(),
host:
connectParams.client.displayName ??
connectParams.client.id ??
os.hostname(),
ip: isLoopbackAddress(remoteAddr) ? undefined : remoteAddr,
version: connectParams.client.version,
platform: connectParams.client.platform,
@@ -1707,19 +1700,9 @@ export async function startGatewayServer(
findRunningWizard,
purgeWizardSession,
getRuntimeSnapshot,
startWhatsAppProvider,
stopWhatsAppProvider,
startTelegramProvider,
stopTelegramProvider,
startDiscordProvider,
stopDiscordProvider,
startSlackProvider,
stopSlackProvider,
startSignalProvider,
stopSignalProvider,
startIMessageProvider,
stopIMessageProvider,
markWhatsAppLoggedOut,
startProvider,
stopProvider,
markProviderLoggedOut,
wizardRunner,
broadcastVoiceWakeChanged,
},
@@ -1859,8 +1842,8 @@ export async function startGatewayServer(
}
}
// Launch configured providers (WhatsApp Web, Discord, Slack, Telegram) so gateway replies via the
// surface the message came from. Tests can opt out via CLAWDBOT_SKIP_PROVIDERS.
// Launch configured providers so gateway replies via the surface the message came from.
// Tests can opt out via CLAWDBOT_SKIP_PROVIDERS.
if (process.env.CLAWDBOT_SKIP_PROVIDERS !== "1") {
try {
await startProviders();
@@ -1886,13 +1869,11 @@ export async function startGatewayServer(
}
const { cfg, entry } = loadSessionEntry(sessionKey);
const lastProvider =
entry?.lastProvider && entry.lastProvider !== "webchat"
? entry.lastProvider
: undefined;
const lastProvider = entry?.lastProvider;
const lastTo = entry?.lastTo?.trim();
const parsedTarget = resolveAnnounceTargetFromKey(sessionKey);
const provider = lastProvider ?? parsedTarget?.provider;
const providerRaw = lastProvider ?? parsedTarget?.provider;
const provider = providerRaw ? normalizeProviderId(providerRaw) : null;
const to = lastTo || parsedTarget?.to;
if (!provider || !to) {
enqueueSystemEvent(message, { sessionKey });
@@ -1900,16 +1881,11 @@ export async function startGatewayServer(
}
const resolved = resolveOutboundTarget({
provider: provider as
| "whatsapp"
| "telegram"
| "discord"
| "slack"
| "signal"
| "imessage"
| "webchat",
provider,
to,
allowFrom: cfg.whatsapp?.allowFrom ?? [],
cfg,
accountId: parsedTarget?.accountId ?? entry?.lastAccountId,
mode: "implicit",
});
if (!resolved.ok) {
enqueueSystemEvent(message, { sessionKey });
@@ -2011,59 +1987,13 @@ export async function startGatewayServer(
"skipping provider reload (CLAWDBOT_SKIP_PROVIDERS=1)",
);
} else {
const restartProvider = async (
name: ProviderKind,
stop: () => Promise<void>,
start: () => Promise<void>,
) => {
const restartProvider = async (name: ProviderKind) => {
logProviders.info(`restarting ${name} provider`);
await stop();
await start();
await stopProvider(name);
await startProvider(name);
};
if (plan.restartProviders.has("whatsapp")) {
await restartProvider(
"whatsapp",
stopWhatsAppProvider,
startWhatsAppProvider,
);
}
if (plan.restartProviders.has("telegram")) {
await restartProvider(
"telegram",
stopTelegramProvider,
startTelegramProvider,
);
}
if (plan.restartProviders.has("discord")) {
await restartProvider(
"discord",
stopDiscordProvider,
startDiscordProvider,
);
}
if (plan.restartProviders.has("slack")) {
await restartProvider("slack", stopSlackProvider, startSlackProvider);
}
if (plan.restartProviders.has("signal")) {
await restartProvider(
"signal",
stopSignalProvider,
startSignalProvider,
);
}
if (plan.restartProviders.has("imessage")) {
await restartProvider(
"imessage",
stopIMessageProvider,
startIMessageProvider,
);
}
if (plan.restartProviders.has("msteams")) {
await restartProvider(
"msteams",
stopMSTeamsProvider,
startMSTeamsProvider,
);
for (const provider of plan.restartProviders) {
await restartProvider(provider);
}
}
}
@@ -2158,13 +2088,9 @@ export async function startGatewayServer(
/* ignore */
}
}
await stopWhatsAppProvider();
await stopTelegramProvider();
await stopDiscordProvider();
await stopSlackProvider();
await stopSignalProvider();
await stopIMessageProvider();
await stopMSTeamsProvider();
for (const plugin of listProviderPlugins()) {
await stopProvider(plugin.id);
}
await stopGmailWatcher();
cron.stop();
heartbeatRunner.stop();
+8 -3
View File
@@ -8,6 +8,10 @@ import { resolveMainSessionKeyFromConfig } from "../config/sessions.js";
import { resetAgentRunContextForTest } from "../infra/agent-events.js";
import { drainSystemEvents, peekSystemEvents } from "../infra/system-events.js";
import { rawDataToString } from "../infra/ws.js";
import {
GATEWAY_CLIENT_MODES,
GATEWAY_CLIENT_NAMES,
} from "../utils/message-provider.js";
import { PROTOCOL_VERSION } from "./protocol/index.js";
import type { GatewayServerOptions } from "./server.js";
@@ -534,7 +538,8 @@ export async function connectReq(
minProtocol?: number;
maxProtocol?: number;
client?: {
name: string;
id: string;
displayName?: string;
version: string;
platform: string;
mode: string;
@@ -553,10 +558,10 @@ export async function connectReq(
minProtocol: opts?.minProtocol ?? PROTOCOL_VERSION,
maxProtocol: opts?.maxProtocol ?? PROTOCOL_VERSION,
client: opts?.client ?? {
name: "test",
id: GATEWAY_CLIENT_NAMES.TEST,
version: "1.0.0",
platform: "test",
mode: "test",
mode: GATEWAY_CLIENT_MODES.TEST,
},
caps: [],
auth: