opencode-dingtalk 0.2.0

package/dist/registry.js

@@ -0,0 +1,77 @@
+/**
+ * Instance registry — manages all BotInstance objects in the process.
+ *
+ * Provides a central place to create, look up, and destroy instances
+ * so that both plugin mode and standalone mode share the same bookkeeping.
+ */
+import { BotInstance } from "./instance.js";
+const instances = new Map();
+// DEBUG: Track instance creation
+function debugLog(...args) {
+    const fs = require("fs");
+    const logFile = "/tmp/opencode-dingtalk-debug.log";
+    const timestamp = new Date().toISOString();
+    const message = args
+        .map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a)))
+        .join(" ");
+    const line = `[${timestamp}] [REGISTRY] ${message}\n`;
+    try {
+        fs.appendFileSync(logFile, line);
+    }
+    catch { }
+}
+/**
+ * Create (and register) a new BotInstance.
+ * Throws if an instance with the same id already exists.
+ */
+export function createInstance(options) {
+    debugLog("Creating NEW instance:", options.instanceId, "botConfig:", !!options.botConfig);
+    if (instances.has(options.instanceId)) {
+        throw new Error(`Instance "${options.instanceId}" already exists`);
+    }
+    const instance = new BotInstance(options);
+    instances.set(options.instanceId, instance);
+    debugLog("Instance created, total instances:", instances.size);
+    return instance;
+}
+/**
+ * Create or return an existing instance with the given id.
+ * If the instance already exists, updates its client / serverUrl if provided.
+ */
+export function getOrCreateInstance(options) {
+    const existing = instances.get(options.instanceId);
+    if (existing) {
+        debugLog("Found EXISTING instance:", options.instanceId, "update botConfig:", !!options.botConfig);
+        if (options.client)
+            existing.state.client = options.client;
+        if (options.serverUrl)
+            existing.state.serverUrl = options.serverUrl;
+        if (options.botConfig)
+            existing.state.botConfig = options.botConfig;
+        debugLog("After update, existing.state.botConfig:", !!existing.state.botConfig);
+        return existing;
+    }
+    debugLog("Instance NOT found, will create new one");
+    return createInstance(options);
+}
+export function getInstance(id) {
+    return instances.get(id);
+}
+export function removeInstance(id) {
+    return instances.delete(id);
+}
+export function getAllInstances() {
+    return Array.from(instances.values());
+}
+/** Stop all running instances and clear the registry. */
+export async function shutdownAll() {
+    const all = getAllInstances();
+    for (const inst of all) {
+        try {
+            if (inst.isRunning)
+                await inst.stop();
+        }
+        catch { }
+    }
+    instances.clear();
+}

package/dist/standalone.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import { createOpencodeClient } from "@opencode-ai/sdk";
+import { resolveInstances, getDefaultConfigPath, getConfigFilePath, } from "./config.js";
+import { createInstance, shutdownAll } from "./registry.js";
+import { logger } from "./logger.js";
+// ============ Event Subscription ============
+async function subscribeToEvents(label, client, instance) {
+    logger.log(`[opencode-dingtalk][${label}] Subscribing to OpenCode events...`);
+    try {
+        const result = await client.global.event({});
+        const stream = result.stream;
+        logger.log(`[opencode-dingtalk][${label}] Event subscription active`);
+        for await (const globalEvent of stream) {
+            if (globalEvent) {
+                try {
+                    const payload = globalEvent.payload;
+                    await instance.handleEvent(payload);
+                }
+                catch (err) {
+                    logger.error(`[opencode-dingtalk][${label}] Error handling event:`, err);
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger.error(`[opencode-dingtalk][${label}] Event subscription error:`, err);
+        setTimeout(() => subscribeToEvents(label, client, instance), 5000);
+    }
+}
+// ============ Main ============
+async function main() {
+    const configs = resolveInstances();
+    // Filter out configs without credentials
+    const valid = configs.filter((c) => c.clientId && c.clientSecret);
+    if (valid.length === 0) {
+        const configPath = getDefaultConfigPath();
+        logger.error(`[opencode-dingtalk] Missing credentials. Configure in one of:\n` +
+            `  1. Config file: ${configPath}\n` +
+            `  2. Env vars: DINGTALK_CLIENT_ID / DINGTALK_CLIENT_SECRET`);
+        process.exit(1);
+    }
+    logger.log(`[opencode-dingtalk] Starting ${valid.length} instance(s) in standalone mode...`);
+    if (getConfigFilePath()) {
+        logger.log(`[opencode-dingtalk] Config loaded from ${getConfigFilePath()}`);
+    }
+    for (const config of valid) {
+        const label = config.name || config.clientId;
+        const instanceId = config.clientId;
+        logger.log(`[opencode-dingtalk][${label}] Connecting to OpenCode at ${config.opencodeUrl}`);
+        logger.log(`[opencode-dingtalk][${label}] Message type: ${config.messageType}, notify: ${config.notifyLevel}`);
+        try {
+            const client = createOpencodeClient({
+                baseUrl: config.opencodeUrl,
+            });
+            const instance = createInstance({
+                instanceId,
+                client,
+                serverUrl: config.opencodeUrl,
+                botConfig: {
+                    clientId: config.clientId,
+                    clientSecret: config.clientSecret,
+                    robotCode: config.robotCode,
+                    messageType: config.messageType,
+                    cardTemplateId: config.cardTemplateId,
+                    notifyLevel: config.notifyLevel,
+                },
+            });
+            // Resolve initial session
+            const sessionsRes = await client.session.list({});
+            if (sessionsRes.data && sessionsRes.data.length > 0) {
+                instance.state.activeSessionId = sessionsRes.data[0].id;
+                logger.log(`[opencode-dingtalk][${label}] Using session: ${instance.state.activeSessionId}`);
+            }
+            else {
+                const newSession = await client.session.create({});
+                if (newSession.data) {
+                    instance.state.activeSessionId = newSession.data.id;
+                    logger.log(`[opencode-dingtalk][${label}] Created new session: ${instance.state.activeSessionId}`);
+                }
+            }
+            subscribeToEvents(label, client, instance);
+            await instance.startWithConfig({
+                clientId: config.clientId,
+                clientSecret: config.clientSecret,
+                robotCode: config.robotCode,
+                messageType: config.messageType,
+                cardTemplateId: config.cardTemplateId,
+                notifyLevel: config.notifyLevel,
+            });
+            logger.log(`[opencode-dingtalk][${label}] Bot is running.`);
+        }
+        catch (err) {
+            logger.error(`[opencode-dingtalk][${label}] Failed to start:`, err);
+        }
+    }
+    logger.log("[opencode-dingtalk] All instances started. Press Ctrl+C to stop.");
+    // Keep the process alive
+    await new Promise(() => { });
+}
+main();
+async function shutdown() {
+    logger.log("\n[opencode-dingtalk] Shutting down all instances...");
+    try {
+        await shutdownAll();
+    }
+    catch { }
+    process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);