@everruns/channelkit 0.0.0-stage → 0.1.0-alpha.1

package/index.cjs

@@ -0,0 +1,71 @@
+'use strict';
+const {join} = require('node:path');
+const {platform, arch} = process;
+const target = platform === 'linux' && arch === 'x64' && process.report.getReport().header.glibcVersionRuntime
+  ? 'linux-x64-gnu' : platform === 'darwin' && ['arm64', 'x64'].includes(arch)
+  ? `darwin-${arch}` : platform === 'win32' && arch === 'x64' ? 'win32-x64-msvc' : null;
+if (!target) throw new Error('Channelkit supports Linux x64 glibc, macOS arm64/x64, and Windows x64. No platform fallback is used.');
+const native = require(join(__dirname, `channelkit.${target}.node`));
+
+class ChannelkitError extends Error {
+  constructor(details) {
+    super(details.message);
+    this.name = 'ChannelkitError';
+    this.code = details.code;
+    this.details = details;
+    this.confirmed = details.confirmed || [];
+    this.retryAfterMs = details.retry_after_ms;
+  }
+}
+function unwrap(result) {
+  const value = JSON.parse(result);
+  if (!value.ok) throw new ChannelkitError(value.error);
+  return value.value;
+}
+function utility(name, value) { return unwrap(native.utility(name, JSON.stringify(value))); }
+function conversation(provider, installation, channel, thread = null) {
+  return utility('conversation', {provider, installation, channel, thread});
+}
+function text(value) { return utility('content', {Text: value}); }
+function markdown(value) { return utility('content', {Markdown: value}); }
+function card(title, body, actions) { return utility('content', {Card: {title, body, actions}}); }
+function splitText(value, maxChars) { return utility('split_text', {text: value, max_chars: maxChars}); }
+class Adapter {
+  #adapter;
+  #metadata;
+  constructor(config) {
+    try { this.#adapter = new native.NativeAdapter(JSON.stringify(config)); }
+    catch (error) { throw new ChannelkitError(JSON.parse(error.message)); }
+    this.#metadata = unwrap(this.#adapter.metadata());
+  }
+  get providerCapabilities() { return {...this.#metadata.capabilities}; }
+  conversation(channel, thread = null) {
+    return conversation(this.#metadata.provider, this.#metadata.installation, channel, thread);
+  }
+  receive(body, headers = {}, {method = 'POST', query = {}} = {}) {
+    if (!Buffer.isBuffer(body)) throw new TypeError('webhook body must be the original Buffer');
+    const result = unwrap(this.#adapter.receive(body, JSON.stringify({method, headers, query})));
+    result.response.body = Buffer.from(result.response.body);
+    return result;
+  }
+  async _call(operation, args) { return unwrap(await this.#adapter.call(JSON.stringify({operation, ...args}))); }
+  async post(target, content) { return this._call('post', {target, content: typeof content === 'string' ? text(content) : content}); }
+  async reply(source, content) { return this._call('reply', {source, content: typeof content === 'string' ? text(content) : content}); }
+  react(target, emoji = null) { return this._call('react', {target, emoji}); }
+  async edit(target, content) { return this._call('edit', {target, content: typeof content === 'string' ? text(content) : content}); }
+  delete(target) { return this._call('delete', {target}); }
+  history(target, {cursor = null, limit = 100} = {}) { return this._call('history', {target, cursor, limit}); }
+  typing(target) { return this._call('typing', {target}); }
+}
+class Slack extends Adapter {
+  constructor({installation, teamId, token, signingSecret, apiOrigin = null}) {
+    super({provider: 'slack', installation, team_id: teamId, token, signing_secret: signingSecret, api_origin: apiOrigin});
+  }
+}
+class WhatsApp extends Adapter {
+  constructor({installation, phoneNumberId, token, appSecret, verifyToken, apiOrigin = null}) {
+    super({provider: 'whatsapp', installation, phone_number_id: phoneNumberId, token, app_secret: appSecret, verify_token: verifyToken, api_origin: apiOrigin});
+  }
+  sendTemplate(target, name, language, components = []) { return this._call('template', {target, name, language, components}); }
+}
+module.exports = {Slack, WhatsApp, ChannelkitError, conversation, text, markdown, card, splitText, version: native.version()};

package/index.d.ts

@@ -0,0 +1,34 @@
+/// Native direct-adapter bindings. HTTP acceptance, authorization and agents remain host-owned.
+import type {Buffer} from 'node:buffer';
+export type Provider = 'slack' | 'whatsapp';
+export interface Conversation { provider: Provider; installation: string; channel: string; thread: string | null }
+export interface MessageRef { conversation: Conversation; id: string }
+export interface User { id: string; display_name: string | null; is_bot: boolean }
+export interface Message { reference: MessageRef; author: User; text: string; attachments: Array<{id: string; name: string | null; media_type: string | null; size: number | null}>; direct: boolean; mentioned: boolean; reply_to: string | null; timestamp: number | null }
+export type Content = {Text: string} | {Markdown: string} | {Card: {title: string; body: string; actions: Array<{id: string; label: string}>}};
+export interface Receipt { messages: MessageRef[]; status: 'accepted' | 'sent' | 'delivered' | 'read' | 'failed' }
+export interface Ingress { response: {status: number; content_type: string; body: Buffer}; events: Array<{id: string; kind: Record<string, unknown>}> }
+export class ChannelkitError extends Error { code: string; details: Record<string, unknown>; confirmed: MessageRef[]; retryAfterMs?: number }
+declare class Adapter {
+  readonly providerCapabilities: Record<string, 'Native' | 'Emulated' | 'Conditional' | 'Unsupported'>;
+  conversation(channel: string, thread?: string | null): Conversation;
+  receive(body: Buffer, headers?: Record<string, string>, options?: {method?: string; query?: Record<string, string>}): Ingress;
+  post(target: Conversation, content: string | Content): Promise<Receipt>;
+  reply(source: Message, content: string | Content): Promise<Receipt>;
+  react(target: MessageRef, emoji?: string | null): Promise<null>;
+  edit(target: MessageRef, content: string | Content): Promise<null>;
+  delete(target: MessageRef): Promise<null>;
+  history(target: Conversation, options?: {cursor?: string | null; limit?: number}): Promise<{messages: Message[]; next_cursor: string | null; complete: boolean; native: boolean}>;
+  typing(target: MessageRef): Promise<null>;
+}
+export class Slack extends Adapter { constructor(config: {installation: string; teamId: string; token: string; signingSecret: string; apiOrigin?: string | null}) }
+export class WhatsApp extends Adapter {
+  constructor(config: {installation: string; phoneNumberId: string; token: string; appSecret: string; verifyToken: string; apiOrigin?: string | null});
+  sendTemplate(target: Conversation, name: string, language: string, components?: unknown[]): Promise<Receipt>;
+}
+export function conversation(provider: Provider, installation: string, channel: string, thread?: string | null): Conversation;
+export function text(value: string): Content;
+export function markdown(value: string): Content;
+export function card(title: string, body: string, actions: Array<{id: string; label: string}>): Content;
+export function splitText(value: string, maxChars: number): string[];
+export const version: string;

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@everruns/channelkit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.1",
+  "description": "Rust-backed Slack and WhatsApp messaging adapters for application-owned agents",
+  "main": "index.cjs",
+  "types": "index.d.ts",
+  "files": [
+    "index.cjs",
+    "index.d.ts",
+    "channelkit.*.node",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.txt"
+  ],
+  "license": "MIT",
+  "author": "Mykhailo Chalyi <mike@chaliy.name>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/everruns/channelkit.git",
+    "directory": "bindings/node"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "agents",
+    "slack",
+    "whatsapp",
+    "messaging",
+    "rust"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "scripts": {
+    "test": "node --test tests/*.test.cjs"
+  }
+}