daemora 1.0.1 → 1.0.3

package/src/channels/LineChannel.js

@@ -3,22 +3,22 @@ import taskQueue from "../core/TaskQueue.js";
 import crypto from "crypto";
 
 /**
- * LINE Channel — receives messages via LINE Messaging API webhook.
+ * LINE Channel - receives messages via LINE Messaging API webhook.
  *
  * Setup:
  * 1. Go to https://developers.line.biz → Create a provider → Create a Messaging API channel
  * 2. Under "Messaging API" → Issue a channel access token (long-lived) → LINE_CHANNEL_ACCESS_TOKEN
  * 3. Under "Basic settings" → Channel secret → LINE_CHANNEL_SECRET
  * 4. Set webhook URL to: https://your-server/webhooks/line
- *    (requires a public HTTPS URL — use ngrok or deploy to a server)
+ *    (requires a public HTTPS URL - use ngrok or deploy to a server)
  * 5. Enable "Use webhook" → Verify
  * 6. Set env: LINE_CHANNEL_SECRET, LINE_CHANNEL_ACCESS_TOKEN
  *
  * Config:
- *   accessToken   — Channel access token
- *   channelSecret — Channel secret for HMAC signature validation
- *   allowlist     — Optional array of LINE user IDs (Uxxxxxxxx) allowed to use the bot
- *   model         — Optional model override
+ *   accessToken   - Channel access token
+ *   channelSecret - Channel secret for HMAC signature validation
+ *   allowlist     - Optional array of LINE user IDs (Uxxxxxxxx) allowed to use the bot
+ *   model         - Optional model override
  *
  * The bot responds to all direct messages sent to the LINE Official Account.
  */
@@ -31,14 +31,14 @@ export class LineChannel extends BaseChannel {
 
   async start() {
     if (!this.accessToken || !this.channelSecret) {
-      console.log(`[Channel:LINE] Skipped — need LINE_CHANNEL_ACCESS_TOKEN and LINE_CHANNEL_SECRET`);
+      console.log(`[Channel:LINE] Skipped - need LINE_CHANNEL_ACCESS_TOKEN and LINE_CHANNEL_SECRET`);
       return;
     }
 
     this.running = true;
     console.log(`[Channel:LINE] Ready (webhook: POST /webhooks/line)`);
     if (this.config.allowlist?.length) {
-      console.log(`[Channel:LINE] Allowlist active — ${this.config.allowlist.length} authorized user(s)`);
+      console.log(`[Channel:LINE] Allowlist active - ${this.config.allowlist.length} authorized user(s)`);
     }
   }
 
@@ -61,12 +61,12 @@ export class LineChannel extends BaseChannel {
 
   /**
    * Handle incoming webhook from LINE.
-   * Called from Express route in index.js — passed the validated request body.
+   * Called from Express route in index.js - passed the validated request body.
    */
   async handleWebhook(rawBody, signature, body) {
-    // Signature validation — reject unsigned requests
+    // Signature validation - reject unsigned requests
     if (!this.validateSignature(rawBody, signature)) {
-      console.log(`[Channel:LINE] Invalid signature — request rejected`);
+      console.log(`[Channel:LINE] Invalid signature - request rejected`);
       return { error: "Invalid signature" };
     }
 
@@ -98,7 +98,7 @@ export class LineChannel extends BaseChannel {
         model: this.getModel(),
       });
 
-      // LINE reply tokens expire quickly — process in background and use push message
+      // LINE reply tokens expire quickly - process in background and use push message
       taskQueue.waitForCompletion(task.id).then(async (completedTask) => {
         if (this.isTaskMerged(completedTask)) return; // absorbed into concurrent session
         const response = completedTask.status === "failed"
@@ -117,7 +117,7 @@ export class LineChannel extends BaseChannel {
 
   /**
    * Send a message to a LINE user via push message API.
-   * Push messages work without a reply token — needed for long-running tasks.
+   * Push messages work without a reply token - needed for long-running tasks.
    */
   async sendReply(channelMeta, text) {
     if (!this.accessToken || !channelMeta.userId) return;

package/src/channels/MatrixChannel.js

@@ -0,0 +1,97 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+
+/**
+ * Matrix Channel - receives messages via Matrix (matrix.org / Element protocol).
+ *
+ * Setup:
+ * 1. Register a Matrix bot account (e.g. @mybot:matrix.org)
+ * 2. Generate an access token via /_matrix/client/v3/login
+ * 3. Set env: MATRIX_HOMESERVER_URL, MATRIX_ACCESS_TOKEN, MATRIX_BOT_USER_ID
+ *
+ * Config:
+ *   homeserverUrl  - e.g. https://matrix.org
+ *   accessToken    - Matrix access token
+ *   botUserId      - e.g. @mybot:matrix.org
+ *   allowlist      - Optional array of Matrix user IDs
+ *   model          - Optional model override
+ */
+export class MatrixChannel extends BaseChannel {
+  constructor(config) {
+    super("matrix", config);
+    this.client = null;
+    this.syncToken = null;
+  }
+
+  async start() {
+    if (!this.config.homeserverUrl || !this.config.accessToken) {
+      console.log("[Channel:Matrix] Skipped - missing MATRIX_HOMESERVER_URL or MATRIX_ACCESS_TOKEN");
+      return;
+    }
+
+    try {
+      const sdk = await import("matrix-js-sdk");
+      this.client = sdk.createClient({
+        baseUrl: this.config.homeserverUrl,
+        accessToken: this.config.accessToken,
+        userId: this.config.botUserId,
+      });
+
+      this.client.on("Room.timeline", async (event, room) => {
+        if (event.getType() !== "m.room.message") return;
+        if (event.getSender() === this.config.botUserId) return;
+
+        const userId = event.getSender();
+        if (!this.isAllowed(userId)) return;
+
+        const content = event.getContent();
+        if (content.msgtype !== "m.text") return;
+
+        const input = content.body?.trim();
+        if (!input) return;
+
+        const roomId = room.roomId;
+        const channelMeta = { roomId, userId, eventId: event.getId() };
+
+        const task = await taskQueue.enqueue({
+          input,
+          channel: "matrix",
+          sessionId: this.getSessionId(userId),
+          channelMeta,
+          model: this.getModel(),
+        });
+
+        const result = await taskQueue.waitForResult(task.id);
+        if (!this.isTaskMerged(result)) {
+          await this.sendReply(channelMeta, result.result || "(no response)");
+        }
+      });
+
+      await this.client.startClient({ initialSyncLimit: 0 });
+      this.running = true;
+      console.log(`[Channel:Matrix] Connected as ${this.config.botUserId}`);
+    } catch (err) {
+      console.log(`[Channel:Matrix] Failed to start: ${err.message}`);
+    }
+  }
+
+  async stop() {
+    if (this.client) {
+      this.client.stopClient();
+      this.running = false;
+    }
+    console.log("[Channel:Matrix] Stopped");
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!this.client || !channelMeta?.roomId) return;
+    // Split long messages (Matrix limit ~60KB but we keep replies readable)
+    const chunks = text.match(/[\s\S]{1,4000}/g) || [text];
+    for (const chunk of chunks) {
+      await this.client.sendMessage(channelMeta.roomId, {
+        msgtype: "m.text",
+        body: chunk,
+      });
+    }
+  }
+}

package/src/channels/MattermostChannel.js

@@ -0,0 +1,119 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+
+/**
+ * Mattermost Channel - receives messages via Mattermost WebSocket API.
+ *
+ * Setup:
+ * 1. Create a bot account in Mattermost (System Console → Integrations → Bot Accounts)
+ * 2. Copy the bot access token
+ * 3. Set env: MATTERMOST_URL, MATTERMOST_TOKEN, MATTERMOST_BOT_USER_ID
+ *
+ * Config:
+ *   url        - Mattermost server URL (e.g. https://mattermost.example.com)
+ *   token      - Bot access token
+ *   botUserId  - Bot user ID
+ *   allowlist  - Optional array of Mattermost user IDs
+ *   model      - Optional model override
+ */
+export class MattermostChannel extends BaseChannel {
+  constructor(config) {
+    super("mattermost", config);
+    this.ws = null;
+    this.seq = 1;
+  }
+
+  async start() {
+    if (!this.config.url || !this.config.token) {
+      console.log("[Channel:Mattermost] Skipped - missing MATTERMOST_URL or MATTERMOST_TOKEN");
+      return;
+    }
+
+    try {
+      const { WebSocket } = await import("ws");
+      const wsUrl = this.config.url.replace(/^http/, "ws") + "/api/v4/websocket";
+
+      this.ws = new WebSocket(wsUrl);
+
+      this.ws.on("open", () => {
+        // Authenticate
+        this.ws.send(JSON.stringify({
+          seq: this.seq++,
+          action: "authentication_challenge",
+          data: { token: this.config.token },
+        }));
+        this.running = true;
+        console.log("[Channel:Mattermost] WebSocket connected");
+      });
+
+      this.ws.on("message", async (raw) => {
+        let msg;
+        try { msg = JSON.parse(raw); } catch { return; }
+
+        if (msg.event !== "posted") return;
+        const post = JSON.parse(msg.data?.post || "{}");
+        if (!post.message?.trim()) return;
+        if (post.user_id === this.config.botUserId) return;
+        if (!this.isAllowed(post.user_id)) return;
+
+        // Only respond to DMs or @mentions
+        const isDM = msg.data?.channel_type === "D";
+        const isMentioned = post.message.includes(`@${this.config.botUsername || "bot"}`);
+        if (!isDM && !isMentioned) return;
+
+        const input = post.message.replace(/@\S+/g, "").trim() || post.message;
+        const channelMeta = { channelId: post.channel_id, userId: post.user_id, postId: post.id };
+
+        const task = await taskQueue.enqueue({
+          input,
+          channel: "mattermost",
+          sessionId: this.getSessionId(post.user_id),
+          channelMeta,
+          model: this.getModel(),
+        });
+
+        const result = await taskQueue.waitForResult(task.id);
+        if (!this.isTaskMerged(result)) {
+          await this.sendReply(channelMeta, result.result || "(no response)");
+        }
+      });
+
+      this.ws.on("error", (err) => console.log(`[Channel:Mattermost] WS error: ${err.message}`));
+      this.ws.on("close", () => {
+        this.running = false;
+        console.log("[Channel:Mattermost] WebSocket closed");
+      });
+    } catch (err) {
+      console.log(`[Channel:Mattermost] Failed to start: ${err.message}`);
+    }
+  }
+
+  async stop() {
+    if (this.ws) {
+      this.ws.close();
+      this.running = false;
+    }
+    console.log("[Channel:Mattermost] Stopped");
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!this.config.url || !this.config.token || !channelMeta?.channelId) return;
+    const fetchFn = globalThis.fetch || (await import("node-fetch")).default;
+    // Split if needed (Mattermost limit 16383 chars per post)
+    const chunks = text.match(/[\s\S]{1,4000}/g) || [text];
+    for (const chunk of chunks) {
+      await fetchFn(`${this.config.url}/api/v4/posts`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.config.token}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          channel_id: channelMeta.channelId,
+          message: chunk,
+          ...(channelMeta.postId ? { root_id: channelMeta.postId } : {}),
+        }),
+      });
+    }
+  }
+}

package/src/channels/NextcloudChannel.js

@@ -0,0 +1,133 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+
+/**
+ * Nextcloud Talk Channel - polls Nextcloud Talk for new messages.
+ *
+ * Setup:
+ * 1. Create a bot user in Nextcloud
+ * 2. Generate an app password: Profile → Security → Devices & Sessions
+ * 3. Set env: NEXTCLOUD_URL, NEXTCLOUD_USER, NEXTCLOUD_PASSWORD
+ *    Optional: NEXTCLOUD_ROOM_TOKEN (specific room token to monitor)
+ *
+ * Config:
+ *   url               - Nextcloud instance URL (e.g. https://cloud.example.com)
+ *   user              - Nextcloud username
+ *   password          - Nextcloud app password
+ *   roomToken         - Optional: specific room token to monitor (monitors all DMs if omitted)
+ *   pollIntervalMs    - Polling interval in ms (default 5000)
+ *   allowlist         - Optional array of Nextcloud usernames
+ *   model             - Optional model override
+ */
+export class NextcloudChannel extends BaseChannel {
+  constructor(config) {
+    super("nextcloud", config);
+    this.pollInterval = null;
+    this.pollMs = config.pollIntervalMs || 5000;
+    this.lastMessageIds = {};
+  }
+
+  get _headers() {
+    const creds = Buffer.from(`${this.config.user}:${this.config.password}`).toString("base64");
+    return {
+      "Authorization": `Basic ${creds}`,
+      "OCS-APIRequest": "true",
+      "Accept": "application/json",
+    };
+  }
+
+  async start() {
+    if (!this.config.url || !this.config.user || !this.config.password) {
+      console.log("[Channel:Nextcloud] Skipped - missing NEXTCLOUD_URL, NEXTCLOUD_USER, or NEXTCLOUD_PASSWORD");
+      return;
+    }
+
+    this.running = true;
+    this.pollInterval = setInterval(() => this._poll(), this.pollMs);
+    console.log(`[Channel:Nextcloud] Polling ${this.config.url} every ${this.pollMs}ms`);
+  }
+
+  async _poll() {
+    const fetchFn = globalThis.fetch || (await import("node-fetch")).default;
+    try {
+      // Get list of conversations
+      const convsRes = await fetchFn(
+        `${this.config.url}/ocs/v2.php/apps/spreed/api/v4/room`,
+        { headers: this._headers }
+      );
+      const convsData = await convsRes.json();
+      const rooms = convsData?.ocs?.data || [];
+
+      for (const room of rooms) {
+        const token = room.token;
+        if (this.config.roomToken && token !== this.config.roomToken) continue;
+        if (room.type !== 1 && room.type !== 3) continue; // 1=DM, 3=group
+
+        const lastKnown = this.lastMessageIds[token] || 0;
+
+        const msgsRes = await fetchFn(
+          `${this.config.url}/ocs/v2.php/apps/spreed/api/v1/chat/${token}?lookIntoFuture=0&limit=10&lastKnownMessageId=${lastKnown}`,
+          { headers: this._headers }
+        );
+        const msgsData = await msgsRes.json();
+        const messages = msgsData?.ocs?.data || [];
+
+        for (const msg of messages) {
+          if (msg.actorId === this.config.user) continue;
+          if (msg.messageType !== "comment") continue;
+          if (msg.id <= lastKnown) continue;
+
+          this.lastMessageIds[token] = Math.max(this.lastMessageIds[token] || 0, msg.id);
+
+          if (!this.isAllowed(msg.actorId)) continue;
+
+          const input = msg.message?.trim();
+          if (!input) continue;
+
+          const channelMeta = { token, actorId: msg.actorId, messageId: msg.id };
+          const task = await taskQueue.enqueue({
+            input,
+            channel: "nextcloud",
+            sessionId: this.getSessionId(msg.actorId),
+            channelMeta,
+            model: this.getModel(),
+          });
+
+          taskQueue.waitForResult(task.id).then(result => {
+            if (!this.isTaskMerged(result)) {
+              this.sendReply(channelMeta, result.result || "(no response)");
+            }
+          }).catch(() => {});
+        }
+      }
+    } catch (err) {
+      // Silent polling errors
+    }
+  }
+
+  async stop() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+    this.running = false;
+    console.log("[Channel:Nextcloud] Stopped");
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!channelMeta?.token) return;
+    const fetchFn = globalThis.fetch || (await import("node-fetch")).default;
+    const chunks = text.match(/[\s\S]{1,32000}/g) || [text];
+    for (const chunk of chunks) {
+      const body = new URLSearchParams({ message: chunk });
+      await fetchFn(
+        `${this.config.url}/ocs/v2.php/apps/spreed/api/v1/chat/${channelMeta.token}`,
+        {
+          method: "POST",
+          headers: { ...this._headers, "Content-Type": "application/x-www-form-urlencoded" },
+          body: body.toString(),
+        }
+      );
+    }
+  }
+}

package/src/channels/NostrChannel.js

@@ -0,0 +1,175 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+
+/**
+ * Nostr Channel - receives and responds to Nostr direct messages (NIP-04 encrypted DMs).
+ * Connects to one or more Nostr relays via WebSocket.
+ *
+ * Setup:
+ * 1. Generate a Nostr keypair: `node -e "const {generateSecretKey,getPublicKey}=require('@noble/secp256k1');const sk=generateSecretKey();console.log('SK:',Buffer.from(sk).toString('hex'));console.log('PK:',getPublicKey(sk))"`
+ * 2. Set env: NOSTR_PRIVATE_KEY (hex), NOSTR_RELAYS (comma-separated relay URLs)
+ *
+ * Config:
+ *   privateKey - Bot's Nostr private key (hex string)
+ *   relays     - Array of relay URLs (wss://relay.damus.io, etc.)
+ *   allowlist  - Optional array of allowed public keys (npub or hex)
+ *   model      - Optional model override
+ *
+ * Implements NIP-04 encrypted DMs (kind 4).
+ */
+export class NostrChannel extends BaseChannel {
+  constructor(config) {
+    super("nostr", config);
+    this.relayConnections = [];
+    this.privateKey = null;
+    this.publicKey = null;
+  }
+
+  async start() {
+    if (!this.config.privateKey) {
+      console.log("[Channel:Nostr] Skipped - missing NOSTR_PRIVATE_KEY");
+      return;
+    }
+
+    const relays = this.config.relays || ["wss://relay.damus.io", "wss://nos.lol"];
+
+    try {
+      // Use @noble/curves for crypto (NIP-04 requires secp256k1)
+      const { secp256k1, schnorr } = await import("@noble/curves/secp256k1").catch(async () => {
+        throw new Error("@noble/curves package not found. Run: npm install @noble/curves");
+      });
+
+      const skBytes = Buffer.from(this.config.privateKey, "hex");
+      this.privateKey = skBytes;
+      this.publicKey = Buffer.from(secp256k1.getPublicKey(skBytes, true)).toString("hex").slice(2); // remove 02/03 prefix
+
+      const { WebSocket } = await import("ws");
+
+      for (const relayUrl of relays) {
+        this._connectRelay(relayUrl, WebSocket, secp256k1);
+      }
+
+      this.running = true;
+      console.log(`[Channel:Nostr] Listening on ${relays.length} relay(s). pubkey: ${this.publicKey.slice(0, 16)}...`);
+    } catch (err) {
+      console.log(`[Channel:Nostr] Failed to start: ${err.message}`);
+    }
+  }
+
+  _connectRelay(relayUrl, WebSocket, secp256k1) {
+    const ws = new WebSocket(relayUrl);
+
+    ws.on("open", () => {
+      // Subscribe to DMs (kind 4) where we are the recipient (#p tag)
+      const subId = "dm-sub-" + Date.now();
+      ws.send(JSON.stringify([
+        "REQ",
+        subId,
+        { kinds: [4], "#p": [this.publicKey], since: Math.floor(Date.now() / 1000) - 60 },
+      ]));
+      console.log(`[Channel:Nostr] Subscribed on ${relayUrl}`);
+    });
+
+    ws.on("message", async (raw) => {
+      let msg;
+      try { msg = JSON.parse(raw); } catch { return; }
+      if (msg[0] !== "EVENT") return;
+
+      const event = msg[2];
+      if (event.kind !== 4) return;
+      if (event.pubkey === this.publicKey) return; // ignore our own
+
+      const senderPubkey = event.pubkey;
+      if (!this.isAllowed(senderPubkey)) return;
+
+      // Decrypt NIP-04 DM
+      let input;
+      try {
+        const { nip04Decrypt } = this._nip04(secp256k1);
+        input = await nip04Decrypt(this.privateKey, senderPubkey, event.content);
+      } catch { return; }
+
+      if (!input?.trim()) return;
+
+      const channelMeta = { senderPubkey, relayUrl, eventId: event.id };
+
+      const task = await taskQueue.enqueue({
+        input: input.trim(),
+        channel: "nostr",
+        sessionId: this.getSessionId(senderPubkey),
+        channelMeta,
+        model: this.getModel(),
+      });
+
+      const result = await taskQueue.waitForResult(task.id);
+      if (!this.isTaskMerged(result)) {
+        await this.sendReply(channelMeta, result.result || "(no response)");
+      }
+    });
+
+    ws.on("error", (err) => console.log(`[Channel:Nostr] ${relayUrl} error: ${err.message}`));
+    this.relayConnections.push(ws);
+  }
+
+  _nip04(secp256k1) {
+    const nip04Decrypt = async (privKey, pubKeyHex, encryptedContent) => {
+      const [ciphertext, ivB64] = encryptedContent.split("?iv=");
+      const sharedPoint = secp256k1.getSharedSecret(privKey, "02" + pubKeyHex);
+      const sharedX = sharedPoint.slice(1, 33);
+      const { subtle } = globalThis.crypto;
+      const key = await subtle.importKey("raw", sharedX, { name: "AES-CBC" }, false, ["decrypt"]);
+      const iv = Buffer.from(ivB64, "base64");
+      const data = Buffer.from(ciphertext, "base64");
+      const decrypted = await subtle.decrypt({ name: "AES-CBC", iv }, key, data);
+      return new TextDecoder().decode(decrypted);
+    };
+
+    const nip04Encrypt = async (privKey, pubKeyHex, plaintext) => {
+      const sharedPoint = secp256k1.getSharedSecret(privKey, "02" + pubKeyHex);
+      const sharedX = sharedPoint.slice(1, 33);
+      const { subtle } = globalThis.crypto;
+      const key = await subtle.importKey("raw", sharedX, { name: "AES-CBC" }, false, ["encrypt"]);
+      const iv = globalThis.crypto.getRandomValues(new Uint8Array(16));
+      const data = new TextEncoder().encode(plaintext);
+      const encrypted = await subtle.encrypt({ name: "AES-CBC", iv }, key, data);
+      return Buffer.from(encrypted).toString("base64") + "?iv=" + Buffer.from(iv).toString("base64");
+    };
+
+    return { nip04Decrypt, nip04Encrypt };
+  }
+
+  async stop() {
+    for (const ws of this.relayConnections) {
+      ws.close();
+    }
+    this.relayConnections = [];
+    this.running = false;
+    console.log("[Channel:Nostr] Stopped");
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!channelMeta?.senderPubkey || !this.relayConnections.length) return;
+
+    const { secp256k1 } = await import("@noble/curves/secp256k1").catch(() => null);
+    if (!secp256k1) return;
+
+    const { nip04Encrypt } = this._nip04(secp256k1);
+    const { schnorr } = await import("@noble/curves/secp256k1");
+
+    const content = await nip04Encrypt(this.privateKey, channelMeta.senderPubkey, text);
+    const now = Math.floor(Date.now() / 1000);
+
+    const eventData = [0, this.publicKey, now, 4, [["p", channelMeta.senderPubkey]], content];
+    const hash = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(eventData)));
+    const id = Buffer.from(hash).toString("hex");
+    const sig = Buffer.from(schnorr.sign(Buffer.from(id, "hex"), this.privateKey)).toString("hex");
+
+    const signedEvent = { id, pubkey: this.publicKey, created_at: now, kind: 4, tags: [["p", channelMeta.senderPubkey]], content, sig };
+
+    for (const ws of this.relayConnections) {
+      if (ws.readyState === 1) {
+        ws.send(JSON.stringify(["EVENT", signedEvent]));
+      }
+    }
+  }
+}

package/src/channels/SignalChannel.js

@@ -2,7 +2,7 @@ import { BaseChannel } from "./BaseChannel.js";
 import taskQueue from "../core/TaskQueue.js";
 
 /**
- * Signal Channel — receives messages via signal-cli REST API.
+ * Signal Channel - receives messages via signal-cli REST API.
  *
  * signal-cli is an open-source CLI tool that acts as a Signal client.
  * It must be running separately as a daemon before Daemora starts.
@@ -19,10 +19,10 @@ import taskQueue from "../core/TaskQueue.js";
  *      SIGNAL_PHONE_NUMBER=+1234567890         (your registered number)
  *
  * Config:
- *   cliUrl      — signal-cli REST URL
- *   phoneNumber — your registered Signal number
- *   allowlist   — Optional array of phone numbers (+1234567890) allowed to send tasks
- *   model       — Optional model override
+ *   cliUrl      - signal-cli REST URL
+ *   phoneNumber - your registered Signal number
+ *   allowlist   - Optional array of phone numbers (+1234567890) allowed to send tasks
+ *   model       - Optional model override
  *
  * Daemora polls signal-cli every 2 seconds for new messages.
  * All replies are sent back through signal-cli.
@@ -38,7 +38,7 @@ export class SignalChannel extends BaseChannel {
 
   async start() {
     if (!this.cliUrl || !this.phoneNumber) {
-      console.log(`[Channel:Signal] Skipped — need SIGNAL_CLI_URL and SIGNAL_PHONE_NUMBER`);
+      console.log(`[Channel:Signal] Skipped - need SIGNAL_CLI_URL and SIGNAL_PHONE_NUMBER`);
       return;
     }
 
@@ -53,9 +53,9 @@ export class SignalChannel extends BaseChannel {
     }
 
     this.running = true;
-    console.log(`[Channel:Signal] Started — polling ${this.cliUrl} for ${this.phoneNumber}`);
+    console.log(`[Channel:Signal] Started - polling ${this.cliUrl} for ${this.phoneNumber}`);
     if (this.config.allowlist?.length) {
-      console.log(`[Channel:Signal] Allowlist active — ${this.config.allowlist.length} authorized number(s)`);
+      console.log(`[Channel:Signal] Allowlist active - ${this.config.allowlist.length} authorized number(s)`);
     }
 
     // Poll for new messages every 2 seconds
@@ -78,7 +78,7 @@ export class SignalChannel extends BaseChannel {
         await this._handleEnvelope(envelope);
       }
     } catch (_) {
-      // Silent — network errors during polling are expected if signal-cli restarts
+      // Silent - network errors during polling are expected if signal-cli restarts
     }
   }