@objectstack/connector-slack 7.4.0

package/dist/index.mjs

@@ -0,0 +1,166 @@
+// src/slack-connector.ts
+function createSlackConnector(opts) {
+  const name = opts.name ?? "slack";
+  const baseUrl = (opts.baseUrl ?? "https://slack.com/api").replace(/\/+$/, "");
+  const doFetch = opts.fetchImpl ?? fetch;
+  const def = {
+    name,
+    label: opts.label ?? "Slack",
+    type: "api",
+    description: "Slack Web API connector (static bot-token auth). Post and update messages, or call any Web API method.",
+    icon: "slack",
+    authentication: { type: "bearer", token: opts.token },
+    // Defaulted by ConnectorSchema; set explicitly so the literal satisfies
+    // the (post-parse) Connector output type.
+    status: "active",
+    enabled: true,
+    connectionTimeoutMs: 3e4,
+    requestTimeoutMs: 3e4,
+    actions: [
+      {
+        key: "chat.postMessage",
+        label: "Post Message",
+        description: "Post a message to a channel, DM, or thread (Slack chat.postMessage).",
+        inputSchema: {
+          type: "object",
+          required: ["channel"],
+          properties: {
+            channel: { type: "string", description: "Channel id, user id, or #name" },
+            text: { type: "string", description: "Message text" },
+            thread_ts: { type: "string", description: "Thread root ts to reply into" },
+            blocks: { type: "array", description: "Block Kit blocks" }
+          }
+        },
+        outputSchema: slackOutputSchema()
+      },
+      {
+        key: "chat.update",
+        label: "Update Message",
+        description: "Edit an existing message (Slack chat.update).",
+        inputSchema: {
+          type: "object",
+          required: ["channel", "ts"],
+          properties: {
+            channel: { type: "string", description: "Channel id" },
+            ts: { type: "string", description: "Timestamp of the message to update" },
+            text: { type: "string", description: "New message text" },
+            blocks: { type: "array", description: "New Block Kit blocks" }
+          }
+        },
+        outputSchema: slackOutputSchema()
+      },
+      {
+        key: "call",
+        label: "Call Web API Method",
+        description: "Escape hatch \u2014 call any Slack Web API method with arbitrary params.",
+        inputSchema: {
+          type: "object",
+          required: ["method"],
+          properties: {
+            method: { type: "string", description: "Web API method, e.g. conversations.list" },
+            params: { type: "object", description: "Method parameters (JSON body)" }
+          }
+        },
+        outputSchema: slackOutputSchema()
+      }
+    ]
+  };
+  async function callSlack(method, params) {
+    const headers = {
+      "Content-Type": "application/json; charset=utf-8",
+      ...opts.defaultHeaders,
+      Authorization: `Bearer ${opts.token}`
+    };
+    const response = await doFetch(`${baseUrl}/${method}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(params)
+    });
+    const body = await response.json();
+    const ok = body.ok === true;
+    return {
+      ok,
+      status: response.status,
+      body,
+      error: ok ? void 0 : body.error
+    };
+  }
+  async function postMessage(input) {
+    return toRecord(await callSlack("chat.postMessage", input));
+  }
+  async function update(input) {
+    return toRecord(await callSlack("chat.update", input));
+  }
+  async function call(input) {
+    const method = String(input.method ?? "");
+    if (!method) throw new Error("slack 'call' action: 'method' is required");
+    const params = input.params ?? {};
+    return toRecord(await callSlack(method, params));
+  }
+  return {
+    def,
+    handlers: {
+      "chat.postMessage": postMessage,
+      "chat.update": update,
+      call
+    }
+  };
+}
+function toRecord(r) {
+  return { ok: r.ok, status: r.status, body: r.body, error: r.error };
+}
+function slackOutputSchema() {
+  return {
+    type: "object",
+    properties: {
+      ok: { type: "boolean", description: "Slack's logical success flag" },
+      status: { type: "number", description: "HTTP status" },
+      body: { type: "object", description: "Full Slack response payload" },
+      error: { type: "string", description: "Slack error code when ok is false" }
+    }
+  };
+}
+
+// src/connector-slack-plugin.ts
+var ConnectorSlackPlugin = class {
+  constructor(options) {
+    this.name = "com.objectstack.connector.slack";
+    this.version = "1.0.0";
+    this.type = "standard";
+    // Ensure the automation engine (and its connector registry) is started first.
+    this.dependencies = ["com.objectstack.service-automation"];
+    this.options = options;
+  }
+  async init(_ctx) {
+  }
+  async start(ctx) {
+    let automation;
+    try {
+      automation = ctx.getService("automation");
+    } catch {
+      automation = void 0;
+    }
+    if (!automation || typeof automation.registerConnector !== "function") {
+      ctx.logger.info("ConnectorSlackPlugin: no automation engine \u2014 Slack connector not registered");
+      return;
+    }
+    const { def, handlers } = createSlackConnector(this.options);
+    automation.registerConnector(def, handlers);
+    this.automation = automation;
+    this.connectorName = def.name;
+    ctx.logger.info(`ConnectorSlackPlugin: Slack connector '${def.name}' registered`);
+  }
+  async stop(_ctx) {
+    if (this.automation && this.connectorName) {
+      try {
+        this.automation.unregisterConnector(this.connectorName);
+      } catch {
+      }
+    }
+  }
+};
+export {
+  ConnectorSlackPlugin,
+  createSlackConnector
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/slack-connector.ts","../src/connector-slack-plugin.ts"],"sourcesContent":["// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Connector } from '@objectstack/spec/integration';\n\n/**\n * Slack connector — a *concrete* connector (ADR-0018 §Addendum) and the second\n * reference implementation after `@objectstack/connector-rest`. It produces a\n * {@link Connector} definition plus handlers for a small set of Slack Web API\n * actions, which the baseline `connector_action` node dispatches to.\n *\n * Scope (ADR-0022 \"raw API call\" path): this is the *integration mechanism*\n * for talking to Slack's API — \"post this exact text to this channel\". It is\n * deliberately **not** the human-notification layer: there is no preference\n * matrix, inbox, outbox, or thread/session semantics here. Those belong to a\n * `MessagingChannel` (ADR-0012/0013), which may itself delegate its transport\n * to this connector.\n *\n * Open-source scope: **static** auth only — a Slack **bot token** (`xoxb-…`),\n * supplied by the caller and sent as a bearer credential. OAuth2 install/refresh,\n * credential vaulting, and multi-tenant connection lifecycle are the enterprise\n * tier (see `../cloud/docs/design/connector-tiering.md`) and are out of scope.\n *\n * Slack quirk: the Web API returns HTTP `200` even on logical failure, with the\n * real outcome in the JSON body's `ok` field (and `error` on failure). Handlers\n * therefore surface `ok` from the payload, not from the HTTP status, and never\n * throw on a logical failure — the flow author branches on `${node.ok}`.\n */\n\nexport interface SlackConnectorOptions {\n    /** Connector machine name (snake_case). Defaults to `slack`. */\n    name?: string;\n    /** Human-readable label. Defaults to `Slack`. */\n    label?: string;\n    /** Slack bot token (`xoxb-…`), sent as `Authorization: Bearer <token>`. */\n    token: string;\n    /** Web API base URL. Defaults to `https://slack.com/api`. */\n    baseUrl?: string;\n    /** Headers merged into every request (request-level headers win). */\n    defaultHeaders?: Record<string, string>;\n    /** Injected for tests; defaults to the global `fetch`. */\n    fetchImpl?: typeof fetch;\n}\n\n/** Input accepted by `chat.postMessage`. */\nexport interface SlackPostMessageInput {\n    /** Channel id (`C…`), user id (`U…`), or channel name (`#general`). */\n    channel: string;\n    /** Message text (fallback when `blocks` are present). */\n    text?: string;\n    /** Thread root `ts` to reply into an existing thread. */\n    thread_ts?: string;\n    /** Block Kit blocks. */\n    blocks?: unknown[];\n    [key: string]: unknown;\n}\n\n/** Generic Slack Web API result envelope. */\nexport interface SlackResult {\n    /** Slack's logical success flag (from the JSON body, not the HTTP status). */\n    ok: boolean;\n    /** HTTP status (almost always 200 for the Slack Web API). */\n    status: number;\n    /** Full parsed Slack payload. */\n    body: Record<string, unknown>;\n    /** Slack error code when `ok` is false (e.g. `channel_not_found`). */\n    error?: string;\n}\n\n/** A connector definition paired with its action handlers, ready for registerConnector(). */\nexport interface SlackConnectorBundle {\n    def: Connector;\n    handlers: Record<\n        string,\n        (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>\n    >;\n}\n\nexport function createSlackConnector(opts: SlackConnectorOptions): SlackConnectorBundle {\n    const name = opts.name ?? 'slack';\n    const baseUrl = (opts.baseUrl ?? 'https://slack.com/api').replace(/\\/+$/, '');\n    const doFetch = opts.fetchImpl ?? fetch;\n\n    const def: Connector = {\n        name,\n        label: opts.label ?? 'Slack',\n        type: 'api',\n        description: 'Slack Web API connector (static bot-token auth). Post and update messages, or call any Web API method.',\n        icon: 'slack',\n        authentication: { type: 'bearer', token: opts.token },\n        // Defaulted by ConnectorSchema; set explicitly so the literal satisfies\n        // the (post-parse) Connector output type.\n        status: 'active',\n        enabled: true,\n        connectionTimeoutMs: 30000,\n        requestTimeoutMs: 30000,\n        actions: [\n            {\n                key: 'chat.postMessage',\n                label: 'Post Message',\n                description: 'Post a message to a channel, DM, or thread (Slack chat.postMessage).',\n                inputSchema: {\n                    type: 'object',\n                    required: ['channel'],\n                    properties: {\n                        channel: { type: 'string', description: 'Channel id, user id, or #name' },\n                        text: { type: 'string', description: 'Message text' },\n                        thread_ts: { type: 'string', description: 'Thread root ts to reply into' },\n                        blocks: { type: 'array', description: 'Block Kit blocks' },\n                    },\n                },\n                outputSchema: slackOutputSchema(),\n            },\n            {\n                key: 'chat.update',\n                label: 'Update Message',\n                description: 'Edit an existing message (Slack chat.update).',\n                inputSchema: {\n                    type: 'object',\n                    required: ['channel', 'ts'],\n                    properties: {\n                        channel: { type: 'string', description: 'Channel id' },\n                        ts: { type: 'string', description: 'Timestamp of the message to update' },\n                        text: { type: 'string', description: 'New message text' },\n                        blocks: { type: 'array', description: 'New Block Kit blocks' },\n                    },\n                },\n                outputSchema: slackOutputSchema(),\n            },\n            {\n                key: 'call',\n                label: 'Call Web API Method',\n                description: 'Escape hatch — call any Slack Web API method with arbitrary params.',\n                inputSchema: {\n                    type: 'object',\n                    required: ['method'],\n                    properties: {\n                        method: { type: 'string', description: 'Web API method, e.g. conversations.list' },\n                        params: { type: 'object', description: 'Method parameters (JSON body)' },\n                    },\n                },\n                outputSchema: slackOutputSchema(),\n            },\n        ],\n    };\n\n    /** POST a JSON body to a Slack Web API method and normalise the result. */\n    async function callSlack(method: string, params: Record<string, unknown>): Promise<SlackResult> {\n        const headers: Record<string, string> = {\n            'Content-Type': 'application/json; charset=utf-8',\n            ...opts.defaultHeaders,\n            Authorization: `Bearer ${opts.token}`,\n        };\n\n        const response = await doFetch(`${baseUrl}/${method}`, {\n            method: 'POST',\n            headers,\n            body: JSON.stringify(params),\n        });\n\n        // The Slack Web API always answers with JSON; `ok` is the real outcome.\n        const body = (await response.json()) as Record<string, unknown>;\n        const ok = body.ok === true;\n        return {\n            ok,\n            status: response.status,\n            body,\n            error: ok ? undefined : (body.error as string | undefined),\n        };\n    }\n\n    async function postMessage(input: Record<string, unknown>): Promise<Record<string, unknown>> {\n        return toRecord(await callSlack('chat.postMessage', input));\n    }\n\n    async function update(input: Record<string, unknown>): Promise<Record<string, unknown>> {\n        return toRecord(await callSlack('chat.update', input));\n    }\n\n    async function call(input: Record<string, unknown>): Promise<Record<string, unknown>> {\n        const method = String(input.method ?? '');\n        if (!method) throw new Error(\"slack 'call' action: 'method' is required\");\n        const params = (input.params as Record<string, unknown>) ?? {};\n        return toRecord(await callSlack(method, params));\n    }\n\n    return {\n        def,\n        handlers: {\n            'chat.postMessage': postMessage,\n            'chat.update': update,\n            call,\n        },\n    };\n}\n\nfunction toRecord(r: SlackResult): Record<string, unknown> {\n    return { ok: r.ok, status: r.status, body: r.body, error: r.error };\n}\n\nfunction slackOutputSchema(): Record<string, unknown> {\n    return {\n        type: 'object',\n        properties: {\n            ok: { type: 'boolean', description: \"Slack's logical success flag\" },\n            status: { type: 'number', description: 'HTTP status' },\n            body: { type: 'object', description: 'Full Slack response payload' },\n            error: { type: 'string', description: 'Slack error code when ok is false' },\n        },\n    };\n}\n","// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\nimport type { Plugin, PluginContext } from '@objectstack/core';\nimport type { Connector } from '@objectstack/spec/integration';\nimport { createSlackConnector, type SlackConnectorOptions } from './slack-connector.js';\n\n/**\n * Minimal surface of the automation engine this plugin depends on — the\n * connector registry from ADR-0018 §Addendum. Kept structural so the plugin\n * needs no runtime dependency on `@objectstack/service-automation`.\n */\nexport interface ConnectorRegistrySurface {\n    registerConnector(\n        def: Connector,\n        handlers: Record<\n            string,\n            (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>\n        >,\n    ): void;\n    unregisterConnector(name: string): void;\n}\n\nexport interface ConnectorSlackPluginOptions extends SlackConnectorOptions {}\n\n/**\n * ConnectorSlackPlugin — registers a Slack Web API connector on the automation\n * engine. The second reference concrete connector (ADR-0018 §Addendum); it\n * enables the ADR-0022 \"raw API call\" path — a flow's `connector_action` step\n * can dispatch to `slack.chat.postMessage` without the messaging stack.\n *\n * If no automation engine is present the plugin logs and skips — the connector\n * has nowhere to register, which is not an error.\n */\nexport class ConnectorSlackPlugin implements Plugin {\n    name = 'com.objectstack.connector.slack';\n    version = '1.0.0';\n    type = 'standard' as const;\n    // Ensure the automation engine (and its connector registry) is started first.\n    dependencies = ['com.objectstack.service-automation'];\n\n    private readonly options: ConnectorSlackPluginOptions;\n    private connectorName?: string;\n    private automation?: ConnectorRegistrySurface;\n\n    constructor(options: ConnectorSlackPluginOptions) {\n        this.options = options;\n    }\n\n    async init(_ctx: PluginContext): Promise<void> {\n        // No services to register; the connector is registered in start() once\n        // the automation engine is available.\n    }\n\n    async start(ctx: PluginContext): Promise<void> {\n        let automation: ConnectorRegistrySurface | undefined;\n        try {\n            automation = ctx.getService<ConnectorRegistrySurface>('automation');\n        } catch {\n            automation = undefined;\n        }\n\n        if (!automation || typeof automation.registerConnector !== 'function') {\n            ctx.logger.info('ConnectorSlackPlugin: no automation engine — Slack connector not registered');\n            return;\n        }\n\n        const { def, handlers } = createSlackConnector(this.options);\n        automation.registerConnector(def, handlers);\n        this.automation = automation;\n        this.connectorName = def.name;\n        ctx.logger.info(`ConnectorSlackPlugin: Slack connector '${def.name}' registered`);\n    }\n\n    async stop(_ctx: PluginContext): Promise<void> {\n        if (this.automation && this.connectorName) {\n            try { this.automation.unregisterConnector(this.connectorName); } catch { /* ignore */ }\n        }\n    }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@objectstack/connector-slack",
+  "version": "7.4.0",
+  "license": "Apache-2.0",
+  "description": "Slack Web API connector for ObjectStack — registers `chat.postMessage` / `chat.update` / `call` actions on the automation engine's connector registry (ADR-0018 §Addendum, ADR-0022).",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@objectstack/core": "7.4.0",
+    "@objectstack/spec": "7.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7",
+    "@objectstack/service-automation": "7.4.0"
+  },
+  "keywords": [
+    "objectstack",
+    "connector",
+    "slack",
+    "integration",
+    "messaging"
+  ],
+  "scripts": {
+    "build": "tsup --config ../../../tsup.config.ts",
+    "test": "vitest run --passWithNoTests"
+  }
+}

package/src/connector-slack-plugin.test.ts

@@ -0,0 +1,78 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect } from 'vitest';
+import { LiteKernel } from '@objectstack/core';
+import { AutomationServicePlugin, type AutomationEngine } from '@objectstack/service-automation';
+import { ConnectorSlackPlugin } from './connector-slack-plugin.js';
+
+/** A fetch stub mimicking the Slack Web API (HTTP 200 + ok in the body). */
+function stubSlack() {
+    const calls: Array<{ url: string; init: RequestInit }> = [];
+    const impl = (async (url: string, init: RequestInit) => {
+        calls.push({ url, init });
+        return {
+            status: 200,
+            ok: true,
+            headers: { get: () => 'application/json' },
+            json: async () => ({ ok: true, ts: '1700000000.000200', channel: 'C42' }),
+            text: async () => '{"ok":true}',
+        };
+    }) as unknown as typeof fetch;
+    return { impl, calls };
+}
+
+describe('ConnectorSlackPlugin — end to end with the automation engine', () => {
+    it('registers the Slack connector so a connector_action flow can post a message', async () => {
+        const { impl, calls } = stubSlack();
+
+        const kernel = new LiteKernel();
+        kernel.use(new AutomationServicePlugin());
+        kernel.use(new ConnectorSlackPlugin({ token: 'xoxb-secret-token', fetchImpl: impl }));
+        await kernel.bootstrap();
+
+        const engine = kernel.getService<AutomationEngine>('automation');
+
+        // The baseline dispatch node and the plugin-contributed connector are both present.
+        expect(engine.getRegisteredNodeTypes()).toContain('connector_action');
+        expect(engine.getRegisteredConnectors()).toContain('slack');
+
+        engine.registerFlow('notify_channel', {
+            name: 'notify_channel',
+            label: 'Post to Slack',
+            type: 'autolaunched',
+            variables: [{ name: 'post.ok', type: 'boolean', isOutput: true }],
+            nodes: [
+                { id: 'start', type: 'start', label: 'Start' },
+                {
+                    id: 'post',
+                    type: 'connector_action',
+                    label: 'Post to #sales',
+                    connectorConfig: {
+                        connectorId: 'slack',
+                        actionId: 'chat.postMessage',
+                        input: { channel: 'C42', text: 'Deal closed 🎉' },
+                    },
+                },
+                { id: 'end', type: 'end', label: 'End' },
+            ],
+            edges: [
+                { id: 'e1', source: 'start', target: 'post' },
+                { id: 'e2', source: 'post', target: 'end' },
+            ],
+        });
+
+        const result = await engine.execute('notify_channel');
+
+        expect(result.success).toBe(true);
+        // The Slack connector handled the dispatch: one POST with bearer auth + JSON body.
+        expect(calls).toHaveLength(1);
+        expect(calls[0].url).toBe('https://slack.com/api/chat.postMessage');
+        expect(calls[0].init.method).toBe('POST');
+        expect((calls[0].init.headers as Record<string, string>).Authorization).toBe('Bearer xoxb-secret-token');
+        expect(calls[0].init.body).toBe('{"channel":"C42","text":"Deal closed 🎉"}');
+        // Slack's logical `ok` propagated back into the flow output.
+        expect(result.output).toEqual({ 'post.ok': true });
+
+        await kernel.shutdown();
+    });
+});

package/src/connector-slack-plugin.ts

@@ -0,0 +1,79 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import type { Plugin, PluginContext } from '@objectstack/core';
+import type { Connector } from '@objectstack/spec/integration';
+import { createSlackConnector, type SlackConnectorOptions } from './slack-connector.js';
+
+/**
+ * Minimal surface of the automation engine this plugin depends on — the
+ * connector registry from ADR-0018 §Addendum. Kept structural so the plugin
+ * needs no runtime dependency on `@objectstack/service-automation`.
+ */
+export interface ConnectorRegistrySurface {
+    registerConnector(
+        def: Connector,
+        handlers: Record<
+            string,
+            (input: Record<string, unknown>, ctx: unknown) => Promise<Record<string, unknown>>
+        >,
+    ): void;
+    unregisterConnector(name: string): void;
+}
+
+export interface ConnectorSlackPluginOptions extends SlackConnectorOptions {}
+
+/**
+ * ConnectorSlackPlugin — registers a Slack Web API connector on the automation
+ * engine. The second reference concrete connector (ADR-0018 §Addendum); it
+ * enables the ADR-0022 "raw API call" path — a flow's `connector_action` step
+ * can dispatch to `slack.chat.postMessage` without the messaging stack.
+ *
+ * If no automation engine is present the plugin logs and skips — the connector
+ * has nowhere to register, which is not an error.
+ */
+export class ConnectorSlackPlugin implements Plugin {
+    name = 'com.objectstack.connector.slack';
+    version = '1.0.0';
+    type = 'standard' as const;
+    // Ensure the automation engine (and its connector registry) is started first.
+    dependencies = ['com.objectstack.service-automation'];
+
+    private readonly options: ConnectorSlackPluginOptions;
+    private connectorName?: string;
+    private automation?: ConnectorRegistrySurface;
+
+    constructor(options: ConnectorSlackPluginOptions) {
+        this.options = options;
+    }
+
+    async init(_ctx: PluginContext): Promise<void> {
+        // No services to register; the connector is registered in start() once
+        // the automation engine is available.
+    }
+
+    async start(ctx: PluginContext): Promise<void> {
+        let automation: ConnectorRegistrySurface | undefined;
+        try {
+            automation = ctx.getService<ConnectorRegistrySurface>('automation');
+        } catch {
+            automation = undefined;
+        }
+
+        if (!automation || typeof automation.registerConnector !== 'function') {
+            ctx.logger.info('ConnectorSlackPlugin: no automation engine — Slack connector not registered');
+            return;
+        }
+
+        const { def, handlers } = createSlackConnector(this.options);
+        automation.registerConnector(def, handlers);
+        this.automation = automation;
+        this.connectorName = def.name;
+        ctx.logger.info(`ConnectorSlackPlugin: Slack connector '${def.name}' registered`);
+    }
+
+    async stop(_ctx: PluginContext): Promise<void> {
+        if (this.automation && this.connectorName) {
+            try { this.automation.unregisterConnector(this.connectorName); } catch { /* ignore */ }
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * @objectstack/connector-slack
+ *
+ * Slack Web API connector — a concrete connector (ADR-0018 §Addendum) and the
+ * second reference implementation after `@objectstack/connector-rest`. The
+ * baseline automation engine ships the `connector_action` dispatch node + an
+ * empty connector registry; this plugin populates it with a `slack` connector
+ * exposing `chat.postMessage`, `chat.update`, and a generic `call` action.
+ *
+ * This is the integration mechanism (ADR-0022 "raw API call" path), not the
+ * human-notification layer. Static bot-token auth only; OAuth2 install/refresh,
+ * credential vaulting, and multi-tenant lifecycle are the enterprise tier.
+ */
+
+export {
+    createSlackConnector,
+    type SlackConnectorOptions,
+    type SlackConnectorBundle,
+    type SlackPostMessageInput,
+    type SlackResult,
+} from './slack-connector.js';
+export {
+    ConnectorSlackPlugin,
+    type ConnectorSlackPluginOptions,
+    type ConnectorRegistrySurface,
+} from './connector-slack-plugin.js';

package/src/slack-connector.test.ts

@@ -0,0 +1,132 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect } from 'vitest';
+import { createSlackConnector } from './slack-connector.js';
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+interface CapturedCall {
+    url: string;
+    init: RequestInit;
+}
+
+/**
+ * A fetch stub mimicking the Slack Web API: always HTTP 200, with the logical
+ * outcome carried in the JSON body's `ok` field.
+ */
+function stubSlack(responseBody: Record<string, unknown> = { ok: true }) {
+    const calls: CapturedCall[] = [];
+    const impl = (async (url: string, init: RequestInit) => {
+        calls.push({ url, init });
+        return {
+            status: 200,
+            ok: true,
+            headers: { get: () => 'application/json' },
+            json: async () => responseBody,
+            text: async () => JSON.stringify(responseBody),
+        };
+    }) as unknown as typeof fetch;
+    return { impl, calls };
+}
+
+function headersOf(call: CapturedCall): Record<string, string> {
+    return (call.init.headers ?? {}) as Record<string, string>;
+}
+
+// ─── definition ──────────────────────────────────────────────────────
+
+describe('createSlackConnector — definition', () => {
+    it('declares a slack connector with the expected actions and bearer auth', () => {
+        const { def, handlers } = createSlackConnector({ token: 'xoxb-1' });
+
+        expect(def.name).toBe('slack');
+        expect(def.type).toBe('api');
+        expect(def.authentication).toEqual({ type: 'bearer', token: 'xoxb-1' });
+
+        const keys = (def.actions ?? []).map((a) => a.key);
+        expect(keys).toEqual(['chat.postMessage', 'chat.update', 'call']);
+        // Every declared action has a handler (the registry enforces this too).
+        for (const k of keys) expect(typeof handlers[k]).toBe('function');
+    });
+});
+
+// ─── chat.postMessage ────────────────────────────────────────────────
+
+describe('createSlackConnector — chat.postMessage', () => {
+    it('POSTs JSON to the method URL with a bearer token and returns ok from the payload', async () => {
+        const { impl, calls } = stubSlack({ ok: true, ts: '1700000000.000100', channel: 'C123' });
+        const { handlers } = createSlackConnector({ token: 'xoxb-secret', fetchImpl: impl });
+
+        const out = await handlers['chat.postMessage'](
+            { channel: 'C123', text: 'hello', thread_ts: '1699999999.0001' },
+            {},
+        );
+
+        expect(calls).toHaveLength(1);
+        expect(calls[0].url).toBe('https://slack.com/api/chat.postMessage');
+        expect(calls[0].init.method).toBe('POST');
+        expect(headersOf(calls[0]).Authorization).toBe('Bearer xoxb-secret');
+        expect(calls[0].init.body).toBe('{"channel":"C123","text":"hello","thread_ts":"1699999999.0001"}');
+
+        expect(out.ok).toBe(true);
+        expect(out.status).toBe(200);
+        expect(out.body).toEqual({ ok: true, ts: '1700000000.000100', channel: 'C123' });
+        expect(out.error).toBeUndefined();
+    });
+
+    it('surfaces a Slack logical failure (HTTP 200, ok:false) without throwing', async () => {
+        const { impl } = stubSlack({ ok: false, error: 'channel_not_found' });
+        const { handlers } = createSlackConnector({ token: 'xoxb-1', fetchImpl: impl });
+
+        const out = await handlers['chat.postMessage']({ channel: 'nope', text: 'hi' }, {});
+
+        expect(out.ok).toBe(false);
+        expect(out.error).toBe('channel_not_found');
+        expect(out.status).toBe(200);
+    });
+});
+
+// ─── chat.update + call ───────────────────────────────────────────────
+
+describe('createSlackConnector — chat.update & generic call', () => {
+    it('chat.update hits the chat.update method', async () => {
+        const { impl, calls } = stubSlack({ ok: true });
+        const { handlers } = createSlackConnector({ token: 'xoxb-1', fetchImpl: impl });
+
+        await handlers['chat.update']({ channel: 'C1', ts: '170.1', text: 'edited' }, {});
+        expect(calls[0].url).toBe('https://slack.com/api/chat.update');
+        expect(calls[0].init.body).toBe('{"channel":"C1","ts":"170.1","text":"edited"}');
+    });
+
+    it('call dispatches to an arbitrary Web API method with params', async () => {
+        const { impl, calls } = stubSlack({ ok: true, channels: [] });
+        const { handlers } = createSlackConnector({ token: 'xoxb-1', fetchImpl: impl });
+
+        const out = await handlers.call({ method: 'conversations.list', params: { limit: 50 } }, {});
+        expect(calls[0].url).toBe('https://slack.com/api/conversations.list');
+        expect(calls[0].init.body).toBe('{"limit":50}');
+        expect(out.ok).toBe(true);
+    });
+
+    it('call throws when method is missing', async () => {
+        const { impl } = stubSlack();
+        const { handlers } = createSlackConnector({ token: 'xoxb-1', fetchImpl: impl });
+        await expect(handlers.call({ params: {} }, {})).rejects.toThrow(/method.*required/);
+    });
+
+    it('honours a custom baseUrl and merges defaultHeaders', async () => {
+        const { impl, calls } = stubSlack();
+        const { handlers } = createSlackConnector({
+            token: 'xoxb-1',
+            baseUrl: 'https://slack.example.test/api/',
+            defaultHeaders: { 'X-Trace': 'on' },
+            fetchImpl: impl,
+        });
+
+        await handlers['chat.postMessage']({ channel: 'C1', text: 'x' }, {});
+        expect(calls[0].url).toBe('https://slack.example.test/api/chat.postMessage');
+        expect(headersOf(calls[0])['X-Trace']).toBe('on');
+        // Auth still wins over defaultHeaders.
+        expect(headersOf(calls[0]).Authorization).toBe('Bearer xoxb-1');
+    });
+});