@ebowwa/glm-daemon 0.4.5 → 0.4.6

package/dist/bin/discord-cli.js

@@ -98838,6 +98838,50 @@ function registerAllCommands(bot, memory, tools) {
   registerInnerthoughtsCommand(bot, memory, tools);
   register(bot, tools);
 }
+// ../channel-telegram/dist/utils/normalize.js
+function normalizeTelegramMessagingTarget(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return;
+  let normalized = trimmed;
+  if (normalized.startsWith("telegram:")) {
+    normalized = normalized.slice("telegram:".length).trim();
+  } else if (normalized.startsWith("tg:")) {
+    normalized = normalized.slice("tg:".length).trim();
+  }
+  if (!normalized)
+    return;
+  const tmeMatch = /^https?:\/\/t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized) ?? /^t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized);
+  if (tmeMatch?.[1]) {
+    normalized = `@${tmeMatch[1]}`;
+  }
+  if (!normalized)
+    return;
+  return `telegram:${normalized}`.toLowerCase();
+}
+function looksLikeTelegramTargetId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return false;
+  if (/^(telegram|tg):/i.test(trimmed))
+    return true;
+  if (trimmed.startsWith("@"))
+    return true;
+  return /^-?\d{6,}$/.test(trimmed);
+}
+function extractRawTarget(normalized) {
+  const trimmed = normalized.trim();
+  if (!trimmed.startsWith("telegram:"))
+    return;
+  const raw = trimmed.slice("telegram:".length);
+  return raw || undefined;
+}
+function isNumericIdTarget(normalized) {
+  const raw = extractRawTarget(normalized);
+  if (!raw)
+    return false;
+  return /^-?\d+$/.test(raw);
+}
 // ../channel-telegram/dist/index.js
 class TelegramChannel {
   id;
@@ -99202,6 +99246,41 @@ class GLMTelegramChannel extends BaseChannel {
   isAllowed(userId, chatId) {
     return this.protocolAdapter.isAllowed(userId, chatId);
   }
+  normalizeTarget(raw) {
+    return normalizeTelegramMessagingTarget(raw);
+  }
+  isValidTarget(raw) {
+    return looksLikeTelegramTargetId(raw);
+  }
+  parseTargetFromInput(input) {
+    const words = input.split(/\s+/);
+    for (const word of words) {
+      if (looksLikeTelegramTargetId(word)) {
+        const normalized = normalizeTelegramMessagingTarget(word);
+        if (normalized) {
+          return extractRawTarget(normalized);
+        }
+      }
+    }
+    return;
+  }
+  async sendToTarget(target, text) {
+    const normalized = normalizeTelegramMessagingTarget(target);
+    if (!normalized) {
+      throw new Error(`Invalid Telegram target: ${target}`);
+    }
+    const rawTarget = extractRawTarget(normalized);
+    if (!rawTarget) {
+      throw new Error(`Failed to extract target from: ${normalized}`);
+    }
+    let chatId;
+    if (isNumericIdTarget(normalized)) {
+      chatId = parseInt(rawTarget, 10);
+    } else {
+      throw new Error(`Username targets require resolution. Use numeric chat ID instead, or implement username resolution. Target: ${rawTarget}`);
+    }
+    await this.sendMessage(chatId, text);
+  }
 }
 // src/channels/discord.ts
 var import_discord = __toESM(require_src2(), 1);

package/dist/bin/telegram-cli.js

@@ -98838,6 +98838,50 @@ function registerAllCommands(bot, memory, tools) {
   registerInnerthoughtsCommand(bot, memory, tools);
   register(bot, tools);
 }
+// ../channel-telegram/dist/utils/normalize.js
+function normalizeTelegramMessagingTarget(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return;
+  let normalized = trimmed;
+  if (normalized.startsWith("telegram:")) {
+    normalized = normalized.slice("telegram:".length).trim();
+  } else if (normalized.startsWith("tg:")) {
+    normalized = normalized.slice("tg:".length).trim();
+  }
+  if (!normalized)
+    return;
+  const tmeMatch = /^https?:\/\/t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized) ?? /^t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized);
+  if (tmeMatch?.[1]) {
+    normalized = `@${tmeMatch[1]}`;
+  }
+  if (!normalized)
+    return;
+  return `telegram:${normalized}`.toLowerCase();
+}
+function looksLikeTelegramTargetId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return false;
+  if (/^(telegram|tg):/i.test(trimmed))
+    return true;
+  if (trimmed.startsWith("@"))
+    return true;
+  return /^-?\d{6,}$/.test(trimmed);
+}
+function extractRawTarget(normalized) {
+  const trimmed = normalized.trim();
+  if (!trimmed.startsWith("telegram:"))
+    return;
+  const raw = trimmed.slice("telegram:".length);
+  return raw || undefined;
+}
+function isNumericIdTarget(normalized) {
+  const raw = extractRawTarget(normalized);
+  if (!raw)
+    return false;
+  return /^-?\d+$/.test(raw);
+}
 // ../channel-telegram/dist/index.js
 class TelegramChannel {
   id;
@@ -99202,6 +99246,41 @@ class GLMTelegramChannel extends BaseChannel {
   isAllowed(userId, chatId) {
     return this.protocolAdapter.isAllowed(userId, chatId);
   }
+  normalizeTarget(raw) {
+    return normalizeTelegramMessagingTarget(raw);
+  }
+  isValidTarget(raw) {
+    return looksLikeTelegramTargetId(raw);
+  }
+  parseTargetFromInput(input) {
+    const words = input.split(/\s+/);
+    for (const word of words) {
+      if (looksLikeTelegramTargetId(word)) {
+        const normalized = normalizeTelegramMessagingTarget(word);
+        if (normalized) {
+          return extractRawTarget(normalized);
+        }
+      }
+    }
+    return;
+  }
+  async sendToTarget(target, text) {
+    const normalized = normalizeTelegramMessagingTarget(target);
+    if (!normalized) {
+      throw new Error(`Invalid Telegram target: ${target}`);
+    }
+    const rawTarget = extractRawTarget(normalized);
+    if (!rawTarget) {
+      throw new Error(`Failed to extract target from: ${normalized}`);
+    }
+    let chatId;
+    if (isNumericIdTarget(normalized)) {
+      chatId = parseInt(rawTarget, 10);
+    } else {
+      throw new Error(`Username targets require resolution. Use numeric chat ID instead, or implement username resolution. Target: ${rawTarget}`);
+    }
+    await this.sendMessage(chatId, text);
+  }
 }
 // src/channels/discord.ts
 var import_discord = __toESM(require_src2(), 1);

package/dist/index.js

@@ -99032,6 +99032,50 @@ function registerAllCommands(bot, memory, tools) {
   registerInnerthoughtsCommand(bot, memory, tools);
   register(bot, tools);
 }
+// ../channel-telegram/dist/utils/normalize.js
+function normalizeTelegramMessagingTarget(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return;
+  let normalized = trimmed;
+  if (normalized.startsWith("telegram:")) {
+    normalized = normalized.slice("telegram:".length).trim();
+  } else if (normalized.startsWith("tg:")) {
+    normalized = normalized.slice("tg:".length).trim();
+  }
+  if (!normalized)
+    return;
+  const tmeMatch = /^https?:\/\/t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized) ?? /^t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized);
+  if (tmeMatch?.[1]) {
+    normalized = `@${tmeMatch[1]}`;
+  }
+  if (!normalized)
+    return;
+  return `telegram:${normalized}`.toLowerCase();
+}
+function looksLikeTelegramTargetId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return false;
+  if (/^(telegram|tg):/i.test(trimmed))
+    return true;
+  if (trimmed.startsWith("@"))
+    return true;
+  return /^-?\d{6,}$/.test(trimmed);
+}
+function extractRawTarget(normalized) {
+  const trimmed = normalized.trim();
+  if (!trimmed.startsWith("telegram:"))
+    return;
+  const raw = trimmed.slice("telegram:".length);
+  return raw || undefined;
+}
+function isNumericIdTarget(normalized) {
+  const raw = extractRawTarget(normalized);
+  if (!raw)
+    return false;
+  return /^-?\d+$/.test(raw);
+}
 // ../channel-telegram/dist/index.js
 class TelegramChannel {
   id;
@@ -99396,6 +99440,41 @@ class GLMTelegramChannel extends BaseChannel {
   isAllowed(userId, chatId) {
     return this.protocolAdapter.isAllowed(userId, chatId);
   }
+  normalizeTarget(raw) {
+    return normalizeTelegramMessagingTarget(raw);
+  }
+  isValidTarget(raw) {
+    return looksLikeTelegramTargetId(raw);
+  }
+  parseTargetFromInput(input) {
+    const words = input.split(/\s+/);
+    for (const word of words) {
+      if (looksLikeTelegramTargetId(word)) {
+        const normalized = normalizeTelegramMessagingTarget(word);
+        if (normalized) {
+          return extractRawTarget(normalized);
+        }
+      }
+    }
+    return;
+  }
+  async sendToTarget(target, text) {
+    const normalized = normalizeTelegramMessagingTarget(target);
+    if (!normalized) {
+      throw new Error(`Invalid Telegram target: ${target}`);
+    }
+    const rawTarget = extractRawTarget(normalized);
+    if (!rawTarget) {
+      throw new Error(`Failed to extract target from: ${normalized}`);
+    }
+    let chatId;
+    if (isNumericIdTarget(normalized)) {
+      chatId = parseInt(rawTarget, 10);
+    } else {
+      throw new Error(`Username targets require resolution. Use numeric chat ID instead, or implement username resolution. Target: ${rawTarget}`);
+    }
+    await this.sendMessage(chatId, text);
+  }
 }
 // src/channels/discord.ts
 var import_discord = __toESM(require_src2(), 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/glm-daemon",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Autonomous GLM 4.7 daemon with hooks, tools, teammates, and communication channels (Telegram, Discord)",
   "type": "module",
   "main": "./dist/index.js",

package/src/channels/telegram.ts

@@ -12,12 +12,27 @@ import {
 import {
   TelegramChannel as TelegramProtocolAdapter,
   type TelegramConfig as ProtocolConfig,
+  // Telegram target normalization utilities
+  normalizeTelegramMessagingTarget,
+  looksLikeTelegramTargetId,
+  extractRawTarget,
+  isUsernameTarget,
+  isNumericIdTarget,
 } from "@ebowwa/channel-telegram";
 import {
   BaseChannel,
   type GLMChannelConfig,
 } from "./base.js";
 
+// Re-export normalization utilities for consumers
+export {
+  normalizeTelegramMessagingTarget,
+  looksLikeTelegramTargetId,
+  extractRawTarget,
+  isUsernameTarget,
+  isNumericIdTarget,
+};
+
 // ============================================================
 // TELEGRAM CHANNEL CONFIG
 // ============================================================
@@ -163,6 +178,96 @@ export class GLMTelegramChannel extends BaseChannel {
   isAllowed(userId?: number, chatId?: number): boolean {
     return this.protocolAdapter.isAllowed(userId, chatId);
   }
+
+  // ============================================================
+  // Target Normalization Helpers
+  // ============================================================
+
+  /**
+   * Normalize a Telegram target (username, URL, or ID) to standard format.
+   *
+   * @param raw - Raw input (@username, t.me/user, 123456, etc.)
+   * @returns Normalized target or undefined if invalid
+   *
+   * @example
+   * channel.normalizeTarget("@durov")      // "telegram:@durov"
+   * channel.normalizeTarget("t.me/durov")  // "telegram:@durov"
+   * channel.normalizeTarget("123456")      // "telegram:123456"
+   */
+  normalizeTarget(raw: string): string | undefined {
+    return normalizeTelegramMessagingTarget(raw);
+  }
+
+  /**
+   * Check if a string looks like a Telegram target.
+   *
+   * @param raw - Raw input string
+   * @returns true if it looks like a Telegram target
+   */
+  isValidTarget(raw: string): boolean {
+    return looksLikeTelegramTargetId(raw);
+  }
+
+  /**
+   * Parse a target from user input and extract the usable form.
+   *
+   * @param input - User input like "send to @user" or "dm t.me/user"
+   * @returns Extracted raw target (@username or numeric ID) or undefined
+   *
+   * @example
+   * channel.parseTargetFromInput("send to @durov")  // "@durov"
+   * channel.parseTargetFromInput("dm 123456")       // "123456"
+   */
+  parseTargetFromInput(input: string): string | undefined {
+    const words = input.split(/\s+/);
+    for (const word of words) {
+      if (looksLikeTelegramTargetId(word)) {
+        const normalized = normalizeTelegramMessagingTarget(word);
+        if (normalized) {
+          return extractRawTarget(normalized);
+        }
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Send a message to a target (username or chat ID).
+   *
+   * @param target - Telegram target (@username, numeric ID, or normalized format)
+   * @param text - Message text
+   *
+   * @example
+   * await channel.sendToTarget("@durov", "Hello!")
+   * await channel.sendToTarget("123456", "Hello!")
+   */
+  async sendToTarget(target: string, text: string): Promise<void> {
+    const normalized = normalizeTelegramMessagingTarget(target);
+    if (!normalized) {
+      throw new Error(`Invalid Telegram target: ${target}`);
+    }
+
+    const rawTarget = extractRawTarget(normalized);
+    if (!rawTarget) {
+      throw new Error(`Failed to extract target from: ${normalized}`);
+    }
+
+    // Parse chat ID (numeric or resolve username)
+    let chatId: number;
+
+    if (isNumericIdTarget(normalized)) {
+      chatId = parseInt(rawTarget, 10);
+    } else {
+      // Username target - need to resolve via bot API
+      // Note: This requires the bot to have seen the user/channel before
+      // For now, we'll try direct message with username (may fail if not cached)
+      throw new Error(
+        `Username targets require resolution. Use numeric chat ID instead, or implement username resolution. Target: ${rawTarget}`
+      );
+    }
+
+    await this.sendMessage(chatId, text);
+  }
 }
 
 // ============================================================