Files
waggle-os/packages/agent/src/connectors/slack-connector.ts
shumeiko.it 3528a242f6 refactor(agent): move the connector credential helpers out of VaultStore (P1.2)
getConnectorCredential, setConnectorCredential and setConnectorCredentialBundle
are now plain functions over a SecretStore in
packages/agent/src/connectors/connector-credentials.ts. The secret names,
metadata layout and the rule that tokens never go into plaintext metadata are
unchanged, so existing vault files keep working.

A bundle still lands as one update: SecretStore gains writeBatch, which
VaultStore applies with a single vault-file replacement.

Connector tests seed a Map-backed SecretStore instead of mocking VaultStore
methods; the helper tests from core and server moved to the agent package.
2026-10-24 17:35:36 +02:00

164 lines
5.8 KiB
TypeScript

/**
* Slack Connector — list channels, read messages, search, and send messages.
* Auth: Bearer (Bot User OAuth Token)
*/
import { BaseConnector, type ConnectorAction, type ConnectorResult } from '../connector-sdk.js';
import { getConnectorCredential } from './connector-credentials.js';
import type { VaultStore } from '@waggle/core';
import type { ConnectorHealth } from '@waggle/shared';
const API_BASE = 'https://slack.com/api';
export class SlackConnector extends BaseConnector {
readonly id = 'slack';
readonly name = 'Slack';
readonly description = "Send messages, search conversations, read channels, and manage Slack workspaces. Supports all standard Slack messaging operations including DMs and channel posts.";
readonly service = 'slack.com';
readonly authType = 'bearer' as const;
readonly substrate = 'waggle' as const;
readonly logoUrl = 'https://cdn.jsdelivr.net/npm/simple-icons@v11/icons/slack.svg';
readonly category = 'communication' as const;
readonly setupGuide = "Create a Slack App at api.slack.com, add Bot Token Scopes, install to workspace, copy Bot User OAuth Token.";
readonly actions: ConnectorAction[] = [
{
name: 'list_channels',
description: 'List Slack channels the bot has access to',
inputSchema: {
properties: {
limit: { type: 'number', description: 'Max channels to return (default 100)' },
types: { type: 'string', description: 'Channel types: public_channel,private_channel' },
},
},
riskLevel: 'low',
},
{
name: 'read_channel',
description: 'Read recent messages from a channel',
inputSchema: {
properties: {
channel: { type: 'string', description: 'Channel ID' },
limit: { type: 'number', description: 'Max messages to return (default 20)' },
},
required: ['channel'],
},
riskLevel: 'low',
},
{
name: 'search_messages',
description: 'Search Slack messages across all channels',
inputSchema: {
properties: {
query: { type: 'string', description: 'Search query' },
count: { type: 'number', description: 'Number of results (default 20)' },
},
required: ['query'],
},
riskLevel: 'low',
},
{
name: 'send_message',
description: 'Send a message to a Slack channel',
inputSchema: {
properties: {
channel: { type: 'string', description: 'Channel ID or name' },
text: { type: 'string', description: 'Message text (markdown supported)' },
},
required: ['channel', 'text'],
},
riskLevel: 'medium',
},
];
private token: string | null = null;
async connect(vault: VaultStore): Promise<void> {
const cred = getConnectorCredential(vault, this.id);
this.token = cred?.value ?? null;
}
async healthCheck(): Promise<ConnectorHealth> {
const health: ConnectorHealth = {
id: this.id,
name: this.name,
status: this.token ? 'connected' : 'disconnected',
lastChecked: new Date().toISOString(),
};
if (this.token) {
try {
const res = await fetch(`${API_BASE}/auth.test`, {
method: 'POST',
headers: this.headers(),
signal: AbortSignal.timeout(5000),
});
const data = await res.json() as { ok: boolean; error?: string };
if (!data.ok) {
health.status = 'error';
health.error = data.error ?? 'Auth test failed';
}
} catch (err: unknown) {
health.status = 'error';
health.error = err instanceof Error ? err.message : String(err);
}
}
return health;
}
async execute(action: string, params: Record<string, unknown>): Promise<ConnectorResult> {
if (!this.token) return { success: false, error: 'Not connected — add Slack bot token in vault' };
switch (action) {
case 'list_channels': return this.slackGet('conversations.list', params);
case 'read_channel': return this.slackGet('conversations.history', params);
case 'search_messages': return this.slackGet('search.messages', params);
case 'send_message': return this.slackPost('chat.postMessage', params);
default: return { success: false, error: `Unknown action: ${action}` };
}
}
private headers(): Record<string, string> {
return {
Authorization: `Bearer ${this.token}`,
'Content-Type': 'application/json; charset=utf-8',
};
}
private async slackGet(method: string, params: Record<string, unknown>): Promise<ConnectorResult> {
try {
const query = new URLSearchParams();
for (const [k, v] of Object.entries(params)) {
if (v !== undefined) query.set(k, String(v));
}
const qs = query.toString();
const res = await fetch(`${API_BASE}/${method}${qs ? `?${qs}` : ''}`, {
headers: this.headers(),
signal: AbortSignal.timeout(10000),
});
const data = await res.json() as { ok: boolean; error?: string };
if (!data.ok) return { success: false, error: data.error ?? `Slack API error: ${method}` };
return { success: true, data };
} catch (err: unknown) {
return { success: false, error: err instanceof Error ? err.message : String(err) };
}
}
private async slackPost(method: string, params: Record<string, unknown>): Promise<ConnectorResult> {
try {
const res = await fetch(`${API_BASE}/${method}`, {
method: 'POST',
headers: this.headers(),
body: JSON.stringify(params),
signal: AbortSignal.timeout(10000),
});
const data = await res.json() as { ok: boolean; error?: string };
if (!data.ok) return { success: false, error: data.error ?? `Slack API error: ${method}` };
return { success: true, data };
} catch (err: unknown) {
return { success: false, error: err instanceof Error ? err.message : String(err) };
}
}
}