@coffer-org/plugin-http 1.2.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@coffer-org/sdk/plugin").PluginManifest;
+export default _default;

package/dist/index.js

@@ -0,0 +1,15 @@
+import { definePlugin } from '@coffer-org/sdk/plugin';
+import { defineSettings } from '@coffer-org/sdk/settings';
+import { field } from '@coffer-org/sdk/fields';
+export default definePlugin({
+    id: 'http',
+    version: '1.0.0',
+    dependsOn: ['orchestrator'],
+    settings: defineSettings({
+        label: 'http.settings.label',
+        fields: [
+            field.int({ key: 'port', label: 'http.settings.port' }),
+            field.password({ key: 'access_password', label: 'http.settings.access_password' }),
+        ],
+    }),
+});

package/dist/runtime/config.d.ts

@@ -0,0 +1,11 @@
+import type { GatePolicy } from '@coffer-org/plugin-orchestrator/runtime';
+export interface HttpConfig {
+    port: number;
+    accessPassword: string;
+}
+export interface LoadOpts {
+    env?: Record<string, string | undefined>;
+    dbSettings?: Record<string, unknown>;
+}
+export declare function loadHttpConfig(opts?: LoadOpts): HttpConfig;
+export declare function policy(cfg: HttpConfig): GatePolicy;

package/dist/runtime/config.js

@@ -0,0 +1,15 @@
+export function loadHttpConfig(opts = {}) {
+    const env = opts.env ?? process.env;
+    const db = (opts.dbSettings ?? {});
+    return {
+        port: Number(env['HTTP_CONNECTOR_PORT'] ?? db['port'] ?? 7025) || 7025,
+        accessPassword: env['HTTP_CONNECTOR_PASSWORD'] ?? db['access_password'] ?? '',
+    };
+}
+export function policy(cfg) {
+    return {
+        accessPassword: cfg.accessPassword,
+        triggerPrefix: '',
+        replyWindow: 1800,
+    };
+}

package/dist/runtime/connector.d.ts

@@ -0,0 +1,6 @@
+import type { Connector } from '@coffer-org/plugin-orchestrator/runtime';
+export interface BufferedConnector {
+    connector: Connector;
+    drain(): string[];
+}
+export declare function makeBufferedConnector(): BufferedConnector;

package/dist/runtime/connector.js

@@ -0,0 +1,23 @@
+export function makeBufferedConnector() {
+    const buffer = [];
+    let counter = 0;
+    const capabilities = {
+        streaming: false,
+        typing: false,
+        maxMessageLength: 100_000,
+    };
+    const connector = {
+        id: 'http',
+        capabilities,
+        async sendMessage(_chatId, text) {
+            buffer.push(text);
+            return { msgId: String(counter++) };
+        },
+    };
+    return {
+        connector,
+        drain() {
+            return buffer.splice(0);
+        },
+    };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,6 @@
+import type { PluginHooks } from '@coffer-org/server/plugin-hooks';
+export type { HttpConfig, LoadOpts } from './config.ts';
+export { loadHttpConfig, policy } from './config.ts';
+export { makeBufferedConnector } from './connector.ts';
+export { startServer, stopServer } from './server.ts';
+export declare const serverHooks: PluginHooks;

package/dist/runtime/index.js

@@ -0,0 +1,16 @@
+import { getPluginSettings } from '@coffer-org/server/plugin-runtime';
+import { startServer, stopServer } from "./server.js";
+export { loadHttpConfig, policy } from "./config.js";
+export { makeBufferedConnector } from "./connector.js";
+export { startServer, stopServer } from "./server.js";
+export const serverHooks = {
+    init: async () => {
+        const { loadHttpConfig } = await import("./config.js");
+        const dbSettings = await getPluginSettings('http');
+        const cfg = loadHttpConfig({ dbSettings });
+        void startServer(cfg).catch((e) => console.warn(`[http] failed to start: ${e.message}`));
+    },
+    teardown: async () => {
+        await stopServer();
+    },
+};

package/dist/runtime/server.d.ts

@@ -0,0 +1,7 @@
+import { handleIncoming } from '@coffer-org/plugin-orchestrator/runtime';
+import type { HttpConfig } from './config.ts';
+export interface ServerDeps {
+    handleIncoming?: typeof handleIncoming;
+}
+export declare function startServer(cfg: HttpConfig, deps?: ServerDeps): Promise<void>;
+export declare function stopServer(): Promise<void>;

package/dist/runtime/server.js

@@ -0,0 +1,83 @@
+import { createServer } from 'node:http';
+import { handleIncoming } from '@coffer-org/plugin-orchestrator/runtime';
+import { policy } from "./config.js";
+import { makeBufferedConnector } from "./connector.js";
+const BIND_HOST = '127.0.0.1';
+let server;
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        req.on('error', reject);
+    });
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+    });
+    res.end(payload);
+}
+async function handleRequest(req, res, cfg, deps) {
+    const doHandle = deps.handleIncoming ?? handleIncoming;
+    if (req.method !== 'POST' || req.url !== '/message') {
+        sendJson(res, 404, { error: 'Not found' });
+        return;
+    }
+    let body;
+    try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+    }
+    catch {
+        sendJson(res, 400, { error: 'Invalid JSON body' });
+        return;
+    }
+    if (typeof body !== 'object' || body === null) {
+        sendJson(res, 400, { error: 'Body must be a JSON object' });
+        return;
+    }
+    const { chatId, userId, text } = body;
+    if (typeof text !== 'string' || !text.trim()) {
+        sendJson(res, 400, { error: 'Missing required field: text' });
+        return;
+    }
+    const { connector, drain } = makeBufferedConnector();
+    await doHandle(connector, {
+        chatId: typeof chatId === 'string' ? chatId : 'http',
+        userId: typeof userId === 'string' ? userId : 'http',
+        text,
+        replyToId: null,
+    }, { policy: policy(cfg) });
+    sendJson(res, 200, { reply: drain().join('\n\n') });
+}
+export async function startServer(cfg, deps = {}) {
+    if (server)
+        return;
+    server = createServer((req, res) => {
+        handleRequest(req, res, cfg, deps).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[http-connector] request handling error: ${msg}`);
+            if (!res.headersSent) {
+                sendJson(res, 500, { error: 'Internal server error' });
+            }
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.listen(cfg.port, BIND_HOST, () => resolve());
+        server.once('error', reject);
+    });
+    console.log(`[http-connector] listening on http://${BIND_HOST}:${cfg.port}/message`);
+}
+export async function stopServer() {
+    if (!server)
+        return;
+    const s = server;
+    server = undefined;
+    await new Promise((resolve, reject) => {
+        s.close((err) => (err ? reject(err) : resolve()));
+    });
+    console.log('[http-connector] stopped');
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@coffer-org/plugin-http",
+  "version": "1.2.0",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "default": "./dist/runtime/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "prepack": "npm run build && node ../../scripts/swap-exports.mjs dist",
+    "postpack": "node ../../scripts/swap-exports.mjs src",
+    "test": "node --import tsx --test \"src/runtime/*.test.ts\""
+  },
+  "dependencies": {
+    "@coffer-org/plugin-orchestrator": "^1.2.0",
+    "@coffer-org/sdk": "^1.2.0",
+    "@coffer-org/server": "^1.2.0"
+  },
+  "devDependencies": {}
+}