@blunking/codexlink 0.1.0

package/telegram-plugin/lib/codex.js

@@ -0,0 +1,185 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { startTextTurnOverWs } from "./app-server-client.js";
+
+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");
+}
+
+export async function injectIntoThread(config, message, threadId) {
+  if (config.appServerWsUrl) {
+    const result = await startTextTurnOverWs({
+      wsUrl: config.appServerWsUrl,
+      threadId,
+      text: buildPrompt(config, message),
+      model: config.model || null,
+      effort: config.reasoningEffort || null,
+      personality: config.personality || null,
+      timeoutMs: config.resumeTimeoutMs
+    });
+
+    return {
+      ok: result.ok,
+      busy: result.busy,
+      turnId: result.turnId || "",
+      code: result.ok ? 0 : null,
+      signal: null,
+      responseText: result.ok ? `turn_started thread=${threadId}` : "",
+      stdout: "",
+      stderr: result.error ? String(result.error.message || result.error) : ""
+    };
+  }
+
+  const safeKey = `${message.chatId}_${message.messageId}`.replace(/[^0-9A-Za-z_-]/g, "_");
+  const promptFile = `${config.paths.promptsDir}\\${safeKey}.md`;
+  const responseFile = `${config.paths.responsesDir}\\${safeKey}.txt`;
+  writeFileSync(promptFile, buildPrompt(config, message), "utf8");
+
+  return await new Promise((resolve) => {
+    let timedOut = false;
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const command = resolveCodexCommand(config.codexBin);
+    const child = spawn(
+      command.file,
+      command.args.concat([
+        "exec",
+        "resume",
+        "--skip-git-repo-check",
+        "-o",
+        responseFile,
+        threadId,
+        "-"
+      ]),
+      command.options
+    );
+
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(value);
+    };
+
+    child.on("error", (error) => {
+      finish({
+        ok: false,
+        busy: false,
+        code: null,
+        signal: null,
+        responseText: "",
+        stdout: stdout.trim(),
+        stderr: `${stderr}\n${error}`.trim()
+      });
+    });
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      const hardKill = setTimeout(() => {
+        child.kill("SIGKILL");
+      }, 3000);
+      hardKill.unref?.();
+    }, config.resumeTimeoutMs);
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.stdin.write(readFileSync(promptFile, "utf8"));
+    child.stdin.end();
+
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      const responseText = existsSync(responseFile) ? readFileSync(responseFile, "utf8").trim() : "";
+      if (timedOut) {
+        finish({
+          ok: false,
+          busy: true,
+          code,
+          signal,
+          responseText,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+        return;
+      }
+      finish({
+        ok: code === 0,
+        busy: false,
+        code,
+        signal,
+        responseText,
+        stdout: stdout.trim(),
+        stderr: stderr.trim()
+      });
+    });
+  });
+}
+
+function resolveCodexCommand(rawCodexBin) {
+  const requested = (rawCodexBin || "codex").trim();
+  if (process.platform !== "win32") {
+    return {
+      file: requested,
+      args: [],
+      options: {}
+    };
+  }
+
+  const appData = process.env.APPDATA || "";
+  const preferredCandidates = [
+    requested,
+    requested.endsWith(".cmd") ? requested : `${requested}.cmd`,
+    appData ? join(appData, "npm", "codex.cmd") : "",
+    appData ? join(appData, "npm", "codex") : ""
+  ].filter(Boolean);
+
+  for (const candidate of preferredCandidates) {
+    if (candidate === requested || existsSync(candidate)) {
+      if (candidate.toLowerCase().endsWith(".cmd")) {
+        return {
+          file: process.env.ComSpec || "cmd.exe",
+          args: ["/d", "/s", "/c", candidate],
+          options: { windowsHide: true }
+        };
+      }
+      return {
+        file: candidate,
+        args: [],
+        options: { windowsHide: true }
+      };
+    }
+  }
+
+  return {
+    file: process.env.ComSpec || "cmd.exe",
+    args: ["/d", "/s", "/c", requested],
+    options: { windowsHide: true }
+  };
+}

package/telegram-plugin/lib/env.js

@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+import { ensureStateLayout, getPaths } from "./paths.js";
+
+function readDotEnvFile(path) {
+  const values = {};
+  try {
+    const text = readFileSync(path, "utf8");
+    for (const line of text.split(/\r?\n/)) {
+      if (!line || line.trim().startsWith("#") || !line.includes("=")) {
+        continue;
+      }
+      const [rawKey, ...rest] = line.split("=");
+      values[rawKey.trim()] = rest.join("=").trim();
+    }
+  } catch {
+    return values;
+  }
+  return values;
+}
+
+export function loadConfig() {
+  ensureStateLayout();
+  const paths = getPaths();
+  const fileEnv = readDotEnvFile(paths.envFile);
+  const legacyEnv = readDotEnvFile(`${paths.legacyRoot}\\.env`);
+  const fallbackEnv = { ...legacyEnv };
+  delete fallbackEnv.BLUN_TELEGRAM_AGENT_NAME;
+  delete fallbackEnv.BLUN_TELEGRAM_STATE_DIR;
+  delete fallbackEnv.BLUN_TELEGRAM_THREAD_ID;
+  const env = { ...fallbackEnv, ...fileEnv, ...process.env };
+  return {
+    paths,
+    agentName: env.BLUN_TELEGRAM_AGENT_NAME?.trim() || "default",
+    lane: env.BLUN_CODEX_LANE?.trim() || "",
+    botToken: env.BLUN_TELEGRAM_BOT_TOKEN?.trim() || "",
+    allowedChatId: env.BLUN_TELEGRAM_ALLOWED_CHAT_ID?.trim() || "",
+    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,
+    pluginMode: env.BLUN_TELEGRAM_PLUGIN_MODE?.trim() || "inherit",
+    model: env.BLUN_CODEX_MODEL?.trim() || "",
+    reasoningEffort: env.BLUN_CODEX_REASONING_EFFORT?.trim() || "",
+    personality: env.BLUN_CODEX_PERSONALITY?.trim() || ""
+  };
+}

package/telegram-plugin/lib/paths.js

@@ -0,0 +1,45 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export function getStateDir() {
+  return process.env.BLUN_TELEGRAM_STATE_DIR?.trim() || join(homedir(), ".codex", "channels", "codexlink-telegram");
+}
+
+export function getPaths() {
+  const root = getStateDir();
+  const codexHome = join(homedir(), ".codex");
+  return {
+    root,
+    legacyRoot: join(codexHome, "channels", "codexlink-telegram"),
+    codexHome,
+    sessionsDir: join(codexHome, "sessions"),
+    envFile: join(root, ".env"),
+    stateFile: join(root, "state.json"),
+    inboxFile: join(root, "inbox.jsonl"),
+    outboxFile: join(root, "outbox.jsonl"),
+    activityFile: join(root, "activity.log"),
+    pollerPidFile: join(root, "poller.pid"),
+    dispatcherPidFile: join(root, "dispatcher.pid"),
+    responderPidFile: join(root, "responder.pid"),
+    pollerStdoutFile: join(root, "poller.stdout.log"),
+    pollerStderrFile: join(root, "poller.stderr.log"),
+    dispatcherStdoutFile: join(root, "dispatcher.stdout.log"),
+    dispatcherStderrFile: join(root, "dispatcher.stderr.log"),
+    responderStdoutFile: join(root, "responder.stdout.log"),
+    responderStderrFile: join(root, "responder.stderr.log"),
+    historyFile: join(codexHome, "history.jsonl"),
+    promptsDir: join(root, "prompts"),
+    responsesDir: join(root, "responses")
+  };
+}
+
+export function ensureStateLayout() {
+  const paths = getPaths();
+  for (const dir of [paths.root, paths.promptsDir, paths.responsesDir]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  return paths;
+}

package/telegram-plugin/lib/sidecars.js

@@ -0,0 +1,142 @@
+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 { appendLog } from "./storage.js";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const pluginRoot = join(here, "..");
+
+function readPid(path) {
+  try {
+    return Number.parseInt(readFileSync(path, "utf8").trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function isPidAlive(pid) {
+  if (!pid || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function stopPid(pid) {
+  if (!isPidAlive(pid)) {
+    return false;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    // Process may already be gone.
+  }
+  return true;
+}
+
+function ensureSidecar(scriptName, pidFile, stdoutFile, stderrFile, config, options = {}) {
+  const forceRestart = Boolean(options.forceRestart);
+  const existingPid = readPid(pidFile);
+  if (isPidAlive(existingPid)) {
+    if (!forceRestart) {
+      return { started: false, pid: existingPid, reason: "already_running" };
+    }
+    stopPid(existingPid);
+  }
+
+  const env = {
+    ...process.env,
+    BLUN_TELEGRAM_AGENT_NAME: config.agentName || "default",
+    BLUN_TELEGRAM_STATE_DIR: config.paths.root,
+    BLUN_TELEGRAM_BOT_TOKEN: config.botToken || "",
+    BLUN_TELEGRAM_ALLOWED_CHAT_ID: config.allowedChatId || "",
+    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_PLUGIN_MODE: config.pluginMode || "plugin",
+    BLUN_CODEX_MODEL: config.model || "",
+    BLUN_CODEX_REASONING_EFFORT: config.reasoningEffort || "",
+    BLUN_CODEX_PERSONALITY: config.personality || ""
+  };
+
+  if (config.currentThreadId) {
+    env.BLUN_TELEGRAM_THREAD_ID = config.currentThreadId;
+  }
+
+  const child = spawn(
+    process.execPath,
+    [join(pluginRoot, scriptName)],
+    {
+      cwd: pluginRoot,
+      env,
+      detached: true,
+      windowsHide: true,
+      stdio: [
+        "ignore",
+        openSync(stdoutFile, "a"),
+        openSync(stderrFile, "a")
+      ]
+    }
+  );
+  child.unref();
+  writeFileSync(pidFile, `${child.pid}\n`, "utf8");
+  return { started: true, pid: child.pid, reason: "spawned" };
+}
+
+export function ensureBackgroundSidecars(config) {
+  if (config.pluginMode !== "plugin") {
+    return { ok: true, enabled: false, reason: "plugin_mode_not_enabled" };
+  }
+  if (!config.botToken) {
+    appendLog(config.paths.activityFile, "PLUGIN_AUTOSTART_SKIPPED missing_bot_token");
+    return { ok: false, enabled: false, reason: "missing_bot_token" };
+  }
+
+  const poller = ensureSidecar(
+    "poller.js",
+    config.paths.pollerPidFile,
+    config.paths.pollerStdoutFile,
+    config.paths.pollerStderrFile,
+    config,
+    { forceRestart: true }
+  );
+  const dispatcher = ensureSidecar(
+    "dispatcher.js",
+    config.paths.dispatcherPidFile,
+    config.paths.dispatcherStdoutFile,
+    config.paths.dispatcherStderrFile,
+    config,
+    { forceRestart: true }
+  );
+  const responder = ensureSidecar(
+    "responder.js",
+    config.paths.responderPidFile,
+    config.paths.responderStdoutFile,
+    config.paths.responderStderrFile,
+    config,
+    { forceRestart: true }
+  );
+
+  appendLog(
+    config.paths.activityFile,
+    `PLUGIN_AUTOSTART poller=${poller.pid || 0}:${poller.reason} dispatcher=${dispatcher.pid || 0}:${dispatcher.reason} responder=${responder.pid || 0}:${responder.reason}`
+  );
+
+  return {
+    ok: true,
+    enabled: true,
+    poller,
+    dispatcher,
+    responder
+  };
+}

package/telegram-plugin/lib/storage.js

@@ -0,0 +1,49 @@
+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");
+}
+
+export function appendJsonl(path, value) {
+  appendFileSync(path, `${JSON.stringify(value)}\n`, "utf8");
+}
+
+export function appendLog(path, message) {
+  appendFileSync(path, `${nowIso()} ${message}\n`, "utf8");
+}
+
+export function readTail(path, lines = 20) {
+  if (!existsSync(path)) {
+    return [];
+  }
+  const text = readFileSync(path, "utf8");
+  return text.split(/\r?\n/).filter(Boolean).slice(-lines);
+}
+
+export function defaultState() {
+  return {
+    offset: 0,
+    currentThreadId: "",
+    queue: [],
+    pendingReplies: [],
+    replyOffsets: {},
+    replyBuffers: {},
+    lastInbound: null,
+    lastOutbound: null,
+    lastPollAt: null,
+    lastInjectAt: null
+  };
+}

package/telegram-plugin/lib/telegram.js

@@ -0,0 +1,37 @@
+function requireToken(config) {
+  if (!config.botToken) {
+    throw new Error(`BLUN_TELEGRAM_BOT_TOKEN is missing in ${config.paths.envFile}`);
+  }
+}
+
+async function telegramRequest(config, method, body) {
+  requireToken(config);
+  const response = await fetch(`https://api.telegram.org/bot${config.botToken}/${method}`, {
+    method: body ? "POST" : "GET",
+    headers: body ? { "Content-Type": "application/json; charset=utf-8" } : undefined,
+    body: body ? JSON.stringify(body) : undefined
+  });
+  const json = await response.json();
+  if (!json.ok) {
+    throw new Error(`Telegram ${method} failed: ${json.description || response.status}`);
+  }
+  return json.result;
+}
+
+export async function getUpdates(config, offset) {
+  return telegramRequest(config, "getUpdates", {
+    offset,
+    timeout: 1,
+    allowed_updates: ["message"]
+  });
+}
+
+export async function sendMessage(config, { chatId, text, replyToMessageId, telegramThreadId }) {
+  return telegramRequest(config, "sendMessage", {
+    chat_id: chatId,
+    text,
+    disable_web_page_preview: true,
+    ...(replyToMessageId ? { reply_to_message_id: Number(replyToMessageId), allow_sending_without_reply: true } : {}),
+    ...(telegramThreadId ? { message_thread_id: Number(telegramThreadId) } : {})
+  });
+}

package/telegram-plugin/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "codexlink-telegram-plugin",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": "./server.js",
+  "scripts": {
+    "start": "node server.js"
+  },
+  "dependencies": {}
+}

package/telegram-plugin/poller.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { pollOnce } from "./lib/bridge.js";
+
+const intervalMs = Number.parseInt(process.env.BLUN_TELEGRAM_POLL_INTERVAL_MS || "1500", 10) || 1500;
+let stopping = false;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+process.on("SIGINT", () => {
+  stopping = true;
+});
+
+process.on("SIGTERM", () => {
+  stopping = true;
+});
+
+async function main() {
+  while (!stopping) {
+    try {
+      const result = await pollOnce();
+      if (result.captured > 0 || result.ignored > 0) {
+        console.log(JSON.stringify({ ts: new Date().toISOString(), kind: "poll", result }));
+      }
+    } catch (error) {
+      console.error(JSON.stringify({
+        ts: new Date().toISOString(),
+        kind: "error",
+        error: `${error}`
+      }));
+    }
+    await sleep(intervalMs);
+  }
+}
+
+await main();

package/telegram-plugin/responder.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { relayRepliesOnce } from "./lib/bridge.js";
+
+const intervalMs = Number.parseInt(process.env.BLUN_TELEGRAM_REPLY_INTERVAL_MS || "1500", 10) || 1500;
+let stopping = false;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+process.on("SIGINT", () => {
+  stopping = true;
+});
+
+process.on("SIGTERM", () => {
+  stopping = true;
+});
+
+async function main() {
+  while (!stopping) {
+    try {
+      const result = await relayRepliesOnce();
+      if (result.status !== "empty" && result.delivered > 0) {
+        console.log(JSON.stringify({ ts: new Date().toISOString(), kind: "reply", result }));
+      }
+    } catch (error) {
+      console.error(JSON.stringify({
+        ts: new Date().toISOString(),
+        kind: "error",
+        error: `${error}`
+      }));
+    }
+    await sleep(intervalMs);
+  }
+}
+
+await main();