@blunking/codexlink 0.1.2 → 0.1.10

package/telegram-plugin/lib/codex.js

@@ -3,28 +3,149 @@ import { spawn } from "node:child_process";
 import { join } from "node:path";
 import { startTextTurnOverWs } from "./app-server-client.js";
 
+function repairMojibake(value) {
+  const input = String(value || "");
+  if (!input || !/[ÃÂâð]/.test(input)) {
+    return input;
+  }
+  try {
+    const repaired = Buffer.from(input, "latin1").toString("utf8");
+    if (!repaired || repaired.includes("\uFFFD")) {
+      return input;
+    }
+    return repaired;
+  } catch {
+    return input;
+  }
+}
+
+function compactInboundLabel(message) {
+  const user = repairMojibake(String(message.user || "Unbekannt")).trim() || "Unbekannt";
+  const group = repairMojibake(String(message.groupTitle || "")).trim();
+  const chatType = String(message.chatType || "").trim();
+
+  if (group || chatType === "group" || chatType === "supergroup") {
+    return `${user} @ ${group || "Gruppe"} schrieb:`;
+  }
+
+  return `${user} schrieb:`;
+}
+
+function normalizeWhitespace(text) {
+  return repairMojibake(String(text || ""))
+    .replace(/\r/g, " ")
+    .replace(/\n/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function firstMeaningfulLine(lines) {
+  for (const raw of lines) {
+    const line = String(raw || "").trim();
+    if (!line) {
+      continue;
+    }
+    if (/^---\s*BRIEF/i.test(line) || /^---\s*BRIEF END/i.test(line)) {
+      continue;
+    }
+    if (/^##\s*(Title|Project|Request|Constraints|Acceptance|Report Back)\s*$/i.test(line)) {
+      continue;
+    }
+    return line;
+  }
+  return "";
+}
+
+function summarizeBrief(text) {
+  const raw = String(text || "");
+  const lines = raw.split(/\r?\n/);
+  const briefHeader = lines.find((line) => /^---\s*BRIEF\b/i.test(String(line || "").trim())) || "";
+  const idMatch = briefHeader.match(/\bid=(\d+)/i);
+  const fromMatch = briefHeader.match(/\bfrom=([^\s]+)/i);
+  const titleIndex = lines.findIndex((line) => /^##\s*Title\s*$/i.test(String(line || "").trim()));
+  const titleLine = titleIndex >= 0 ? firstMeaningfulLine(lines.slice(titleIndex + 1, titleIndex + 4)) : "";
+  const firstLine = firstMeaningfulLine(lines);
+  let detail = titleLine || firstLine || "Neuer Brief";
+  detail = detail.replace(/^\[IDLE-CYCLE\]\s*/i, "IDLE-CYCLE: ");
+  detail = normalizeWhitespace(detail);
+  const from = fromMatch ? fromMatch[1] : "Brief";
+  const idPart = idMatch ? ` #${idMatch[1]}` : "";
+  if (from === "mnemo-idle-loop") {
+    const compactIdle = detail
+      .replace(/^IDLE-CYCLE:\s*/i, "")
+      .replace(/^Pull project_state,\s*/i, "")
+      .replace(/generate proposals via mem_propose,\s*/i, "proposals, ")
+      .replace(/ship if ship_eligible\.?/i, "ship-check")
+      .replace(/Mode:\s*autonomous\.?/i, "auto")
+      .trim();
+    return `Mnemo Idle${idPart}: ${compactIdle || "IDLE-CYCLE"}`;
+  }
+  return `Brief von ${from}${idPart}: ${detail}`;
+}
+
+function compactInboundText(message) {
+  const text = String(message.text || "").trim();
+  if (!text) {
+    return "";
+  }
+  if (/^---\s*BRIEF\b/i.test(text)) {
+    return summarizeBrief(text);
+  }
+  return text;
+}
+
+function normalizeAddressText(value) {
+  return repairMojibake(String(value || ""))
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/^@+/, "")
+    .replace(/[^\p{L}\p{N}_-]+/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function isAddressOnlyPing(config, text) {
+  const normalizedText = normalizeAddressText(text);
+  if (!normalizedText || normalizedText.includes(" ")) {
+    return false;
+  }
+
+  const names = [
+    ...(Array.isArray(config.mentionNames) ? config.mentionNames : []),
+    config.agentName
+  ]
+    .map((value) => normalizeAddressText(value))
+    .filter((value) => value && value !== "default");
+
+  return names.includes(normalizedText);
+}
+
 function buildPrompt(config, message) {
-  return [
-    "[BLUN Telegram Inbound]",
-    `Agent: ${config.agentName}`,
-    ...(config.lane ? [`Lane: ${config.lane}`] : []),
-    `Chat ID: ${message.chatId}`,
-    `Message ID: ${message.messageId}`,
-    `User: ${message.user || "unknown"}`,
-    `Chat Type: ${message.chatType || "unknown"}`,
-    `Conversation Key: ${message.conversationKey || `${message.chatId}:dm`}`,
-    ...(message.groupTitle ? [`Group: ${message.groupTitle}`] : []),
-    ...(message.telegramThreadId ? [`Telegram Thread ID: ${message.telegramThreadId}`] : []),
-    `Timestamp: ${message.ts}`,
-    "",
-    "Treat the following as a real inbound user message for this exact existing thread.",
-    "Reply naturally in-thread. Do not mention bridge transport unless relevant.",
-    "If this came from a group or topic, keep the reply scoped to that exact conversation.",
-    ...(config.lane ? [`Stay strictly inside your assigned lane (${config.lane}). Do not claim ownership or make decisions for other lanes.`] : []),
-    "",
-    "Message:",
-    message.text
-  ].join("\n");
+  const compactText = compactInboundText(message);
+  const isBriefSummary = compactText.startsWith("Brief von ") || compactText.startsWith("Mnemo Idle");
+  const label = isBriefSummary ? "" : compactInboundLabel(message);
+  const header = [];
+
+  if (label) {
+    header.push(label);
+  }
+  header.push(compactText);
+
+  if (message.intent === "continue_nudge") {
+    header.push(
+      "",
+      "[Weiter-Signal: kein bloßes Ack senden. Nur antworten, wenn jetzt ein konkretes Ergebnis, Blocker oder eine Entscheidung sichtbar gemacht werden muss.]"
+    );
+  }
+
+  if (isAddressOnlyPing(config, compactText)) {
+    header.push(
+      "",
+      "[Ping: Der User prueft nur, ob du erreichbar bist. Antworte kurz, dass du da bist. Starte keine Suche und keinen Tool-Lauf.]"
+    );
+  }
+
+  return header.join("\n");
 }
 
 export async function injectIntoThread(config, message, threadId) {

package/telegram-plugin/lib/env.js

@@ -25,6 +25,15 @@ function parseAllowedChatIds(rawValue) {
     .filter(Boolean);
 }
 
+function parseMentionNames(rawValue) {
+  return Array.from(new Set(
+    String(rawValue || "")
+      .split(",")
+      .map((value) => value.trim().toLowerCase())
+      .filter(Boolean)
+  ));
+}
+
 export function loadConfig() {
   ensureStateLayout();
   const paths = getPaths();
@@ -36,6 +45,18 @@ export function loadConfig() {
   delete fallbackEnv.BLUN_TELEGRAM_THREAD_ID;
   const env = { ...fallbackEnv, ...process.env, ...fileEnv };
   const allowedChatIds = parseAllowedChatIds(env.BLUN_TELEGRAM_ALLOWED_CHAT_ID || env.TELEGRAM_ALLOWED_CHAT_ID || "");
+  const mentionNames = parseMentionNames(
+    env.BLUN_TELEGRAM_MENTION_NAMES
+    || env.BLUN_CODEX_AGENT
+    || env.TELEGRAM_AGENT_NAME
+    || env.BLUN_TELEGRAM_AGENT_NAME
+    || ""
+  );
+  const otherAgentNames = parseMentionNames(
+    env.BLUN_TELEGRAM_OTHER_AGENT_NAMES
+    || env.BLUN_CODEX_OTHER_AGENTS
+    || ""
+  );
   return {
     paths,
     agentName: env.BLUN_TELEGRAM_AGENT_NAME?.trim() || env.TELEGRAM_AGENT_NAME?.trim() || "default",
@@ -43,11 +64,18 @@ export function loadConfig() {
     botToken: env.BLUN_TELEGRAM_BOT_TOKEN?.trim() || env.TELEGRAM_BOT_TOKEN?.trim() || "",
     allowedChatId: allowedChatIds[0] || "",
     allowedChatIds,
+    mentionNames,
+    otherAgentNames,
     codexBin: env.BLUN_TELEGRAM_CODEX_BIN?.trim() || "codex",
     appServerWsUrl: env.BLUN_TELEGRAM_APP_SERVER_WS_URL?.trim() || "",
     currentThreadId: env.BLUN_TELEGRAM_THREAD_ID?.trim() || process.env.CODEX_THREAD_ID?.trim() || "",
     resumeTimeoutMs: Number.parseInt(env.BLUN_TELEGRAM_RESUME_TIMEOUT_MS || "15000", 10) || 15000,
-    idleCooldownMs: Number.parseInt(env.BLUN_TELEGRAM_IDLE_COOLDOWN_MS || "15000", 10) || 15000,
+    idleCooldownMs: Number.parseInt(env.BLUN_TELEGRAM_IDLE_COOLDOWN_MS || "3000", 10) || 3000,
+    ambientQueueTtlMs: Number.parseInt(env.BLUN_TELEGRAM_AMBIENT_QUEUE_TTL_MS || "600000", 10) || 600000,
+    pendingReplyTimeoutMs: Number.parseInt(env.BLUN_TELEGRAM_PENDING_REPLY_TIMEOUT_MS || "1800000", 10) || 1800000,
+    progressFallbackMs: Number.parseInt(env.BLUN_TELEGRAM_PROGRESS_FALLBACK_MS || "20000", 10) || 20000,
+    progressRelayMode: env.BLUN_TELEGRAM_PROGRESS_RELAY?.trim().toLowerCase() || "status",
+    queueNoticeEnabled: /^(1|true|yes|on)$/i.test(env.BLUN_TELEGRAM_QUEUE_NOTICE || ""),
     dispatchMode: env.BLUN_TELEGRAM_DISPATCH_MODE?.trim() || "deferred",
     pluginMode: env.BLUN_TELEGRAM_PLUGIN_MODE?.trim() || "inherit",
     model: env.BLUN_CODEX_MODEL?.trim() || "",

package/telegram-plugin/lib/paths.js

@@ -9,10 +9,16 @@ export function getStateDir() {
 export function getPaths() {
   const root = getStateDir();
   const codexHome = join(homedir(), ".codex");
+  const agentName = process.env.BLUN_TELEGRAM_AGENT_NAME?.trim()
+    || process.env.TELEGRAM_AGENT_NAME?.trim()
+    || "default";
+  const runtimeDir = join(codexHome, "runtimes", agentName);
   return {
     root,
     legacyRoot: join(codexHome, "channels", "codexlink-telegram"),
     codexHome,
+    runtimeDir,
+    currentRuntimeFile: join(runtimeDir, "current-remote-runtime.json"),
     sessionsDir: join(codexHome, "sessions"),
     envFile: join(root, ".env"),
     stateFile: join(root, "state.json"),
@@ -36,7 +42,7 @@ export function getPaths() {
 
 export function ensureStateLayout() {
   const paths = getPaths();
-  for (const dir of [paths.root, paths.promptsDir, paths.responsesDir]) {
+  for (const dir of [paths.root, paths.promptsDir, paths.responsesDir, paths.runtimeDir]) {
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
     }

package/telegram-plugin/lib/sidecars.js

@@ -1,7 +1,7 @@
 import { existsSync, openSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { appendLog } from "./storage.js";
 
 const here = dirname(fileURLToPath(import.meta.url));
@@ -31,6 +31,14 @@ function stopPid(pid) {
   if (!isPidAlive(pid)) {
     return false;
   }
+  if (process.platform === "win32") {
+    try {
+      execFileSync("taskkill.exe", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
   try {
     process.kill(pid, "SIGTERM");
   } catch {
@@ -60,10 +68,13 @@ function ensureSidecar(scriptName, pidFile, stdoutFile, stderrFile, config, opti
     BLUN_TELEGRAM_STATE_DIR: config.paths.root,
     BLUN_TELEGRAM_BOT_TOKEN: config.botToken || "",
     BLUN_TELEGRAM_ALLOWED_CHAT_ID: Array.isArray(config.allowedChatIds) ? config.allowedChatIds.join(",") : (config.allowedChatId || ""),
+    BLUN_TELEGRAM_OTHER_AGENT_NAMES: Array.isArray(config.otherAgentNames) ? config.otherAgentNames.join(",") : "",
     BLUN_TELEGRAM_APP_SERVER_WS_URL: config.appServerWsUrl || "",
     BLUN_TELEGRAM_CODEX_BIN: config.codexBin || "codex",
     BLUN_TELEGRAM_RESUME_TIMEOUT_MS: String(config.resumeTimeoutMs || 15000),
     BLUN_TELEGRAM_IDLE_COOLDOWN_MS: String(config.idleCooldownMs || 15000),
+    BLUN_TELEGRAM_PROGRESS_FALLBACK_MS: String(config.progressFallbackMs || 20000),
+    BLUN_TELEGRAM_QUEUE_NOTICE: config.queueNoticeEnabled ? "1" : "0",
     BLUN_TELEGRAM_DISPATCH_MODE: config.dispatchMode || "deferred",
     BLUN_TELEGRAM_PLUGIN_MODE: config.pluginMode || "plugin",
     BLUN_CODEX_MODEL: config.model || "",

package/telegram-plugin/lib/singleton.js

@@ -0,0 +1,66 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { getPaths } from "./paths.js";
+
+function readPid(path) {
+  try {
+    return Number.parseInt(readFileSync(path, "utf8").trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function writePid(path) {
+  try {
+    writeFileSync(path, `${process.pid}\n`, "utf8");
+  } catch {
+    // Best-effort self-heal only; the sidecar can still keep running.
+  }
+}
+
+function isPidAlive(pid) {
+  if (!pid || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isCurrentSidecarPid(kind) {
+  const paths = getPaths();
+  const pidFiles = {
+    poller: paths.pollerPidFile,
+    dispatcher: paths.dispatcherPidFile,
+    responder: paths.responderPidFile
+  };
+  const pidFile = pidFiles[kind];
+  if (!pidFile) {
+    return true;
+  }
+
+  const currentPid = readPid(pidFile);
+  if (!currentPid) {
+    writePid(pidFile);
+    return true;
+  }
+
+  if (currentPid === process.pid) {
+    return true;
+  }
+
+  // The parent writes the pid file just after spawn. Give a fresh child a
+  // short grace window so it does not exit before its pid has been recorded.
+  if (process.uptime() < 2) {
+    return true;
+  }
+
+  if (!isPidAlive(currentPid)) {
+    writePid(pidFile);
+    return true;
+  }
+
+  return false;
+}

package/telegram-plugin/lib/storage.js

@@ -1,21 +1,60 @@
-import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-
-export function nowIso() {
-  return new Date().toISOString();
-}
-
-export function loadJson(path, fallback) {
-  try {
-    const raw = readFileSync(path, "utf8").replace(/^\uFEFF/, "");
-    return JSON.parse(raw);
-  } catch {
-    return fallback;
-  }
-}
-
-export function saveJson(path, value) {
-  writeFileSync(path, JSON.stringify(value, null, 2), "utf8");
-}
+import { appendFileSync, existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+function sleepSync(ms) {
+  const buffer = new SharedArrayBuffer(4);
+  const view = new Int32Array(buffer);
+  Atomics.wait(view, 0, 0, ms);
+}
+
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+export function loadJson(path, fallback) {
+  for (let attempt = 0; attempt < 6; attempt += 1) {
+    try {
+      const raw = readFileSync(path, "utf8").replace(/^\uFEFF/, "");
+      if (!raw.trim()) {
+        throw new Error("empty json file");
+      }
+      return JSON.parse(raw);
+    } catch {
+      if (attempt < 5) {
+        sleepSync(20 * (attempt + 1));
+      }
+    }
+  }
+  return fallback;
+}
+
+export function saveJson(path, value) {
+  const text = JSON.stringify(value, null, 2);
+  const dir = dirname(path);
+  const base = basename(path);
+  let lastError = null;
+
+  for (let attempt = 0; attempt < 6; attempt += 1) {
+    const tempPath = join(dir, `.${base}.${process.pid}.${Date.now()}.${attempt}.tmp`);
+    try {
+      writeFileSync(tempPath, text, "utf8");
+      renameSync(tempPath, path);
+      return;
+    } catch (error) {
+      lastError = error;
+      try {
+        unlinkSync(tempPath);
+      } catch {
+        // Ignore cleanup failures for temp files.
+      }
+      if (attempt < 5) {
+        sleepSync(25 * (attempt + 1));
+      }
+    }
+  }
+
+  throw lastError || new Error(`Failed to save JSON file: ${path}`);
+}
 
 export function appendJsonl(path, value) {
   appendFileSync(path, `${JSON.stringify(value)}\n`, "utf8");
@@ -41,10 +80,12 @@ export function defaultState() {
     pendingReplies: [],
     replyOffsets: {},
     replyBuffers: {},
-    lastInbound: null,
-    lastOutbound: null,
-    lastPollAt: null,
-    lastInjectAt: null,
-    lastAutoDispatchAt: null
-  };
-}
+    lastInbound: null,
+    lastOutbound: null,
+    lastUiNotice: null,
+    lastPollAt: null,
+    lastInjectAt: null,
+    lastAutoDispatchAt: null,
+    lastQueueNoticeAt: null
+  };
+}

package/telegram-plugin/lib/telegram.js

@@ -35,3 +35,11 @@ export async function sendMessage(config, { chatId, text, replyToMessageId, tele
     ...(telegramThreadId ? { message_thread_id: Number(telegramThreadId) } : {})
   });
 }
+
+export async function sendChatAction(config, { chatId, telegramThreadId, action = "typing" }) {
+  return telegramRequest(config, "sendChatAction", {
+    chat_id: chatId,
+    action,
+    ...(telegramThreadId ? { message_thread_id: Number(telegramThreadId) } : {})
+  });
+}

package/telegram-plugin/poller.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { pollOnce } from "./lib/bridge.js";
+import { isCurrentSidecarPid } from "./lib/singleton.js";
 
 const intervalMs = Number.parseInt(process.env.BLUN_TELEGRAM_POLL_INTERVAL_MS || "1500", 10) || 1500;
 let stopping = false;
@@ -18,6 +19,9 @@ process.on("SIGTERM", () => {
 
 async function main() {
   while (!stopping) {
+    if (!isCurrentSidecarPid("poller")) {
+      break;
+    }
     try {
       const result = await pollOnce();
       if (result.captured > 0 || result.ignored > 0) {

package/telegram-plugin/responder.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { relayRepliesOnce } from "./lib/bridge.js";
+import { isCurrentSidecarPid } from "./lib/singleton.js";
 
 const intervalMs = Number.parseInt(process.env.BLUN_TELEGRAM_REPLY_INTERVAL_MS || "1500", 10) || 1500;
 let stopping = false;
@@ -18,6 +19,9 @@ process.on("SIGTERM", () => {
 
 async function main() {
   while (!stopping) {
+    if (!isCurrentSidecarPid("responder")) {
+      break;
+    }
     try {
       const result = await relayRepliesOnce();
       if (result.status !== "empty" && result.delivered > 0) {