@blunking/codexlink 0.1.0

package/telegram-plugin/server.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { bindCurrentThread, bridgeStatus, injectNext, listQueue, pollOnce, relayRepliesOnce, reply, tailActivity } from "./lib/bridge.js";
+import { loadConfig } from "./lib/env.js";
+import { ensureStateLayout } from "./lib/paths.js";
+import { ensureBackgroundSidecars } from "./lib/sidecars.js";
+
+ensureStateLayout();
+ensureBackgroundSidecars(loadConfig());
+
+function textResult(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+      }
+    ]
+  };
+}
+
+const server = new Server(
+  {
+    name: "codexlink-telegram",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "bridge_status",
+      description: "Show BLUN Telegram bridge status, bound thread, queue depth, and recent activity pointers.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "bridge_bind_current_thread",
+      description: "Bind the real Codex thread id that queued Telegram messages should inject into. If omitted, CODEX_THREAD_ID is used.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          thread_id: { type: "string", description: "Explicit Codex thread UUID to bind." }
+        }
+      }
+    },
+    {
+      name: "bridge_poll_once",
+      description: "Poll Telegram one time and append any allowed inbound messages to the BLUN queue.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "bridge_list_queue",
+      description: "List the most recent queued or processed bridge messages.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: { type: "number", description: "How many queue items to return. Default 10." }
+        }
+      }
+    },
+    {
+      name: "bridge_inject_next",
+      description: "Inject the next queued Telegram message into the bound real Codex thread. If that thread is busy, the message remains queued.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          thread_id: { type: "string", description: "Optional explicit thread id override for this injection." }
+        }
+      }
+    },
+    {
+      name: "bridge_reply",
+      description: "Send an explicit manual Telegram reply from the real operator/CLI.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          text: { type: "string", description: "Reply text to send." },
+          chat_id: { type: "string", description: "Optional chat id override. Defaults to the latest inbound chat." },
+          reply_to_message_id: { type: "string", description: "Optional Telegram message id to reply under." },
+          telegram_thread_id: { type: "string", description: "Optional Telegram topic/thread id for forum-style group topics." }
+        },
+        required: ["text"]
+      }
+    },
+    {
+      name: "bridge_relay_once",
+      description: "Read the active Codex session file and relay any completed Telegram-originated final answers back to Telegram.",
+      inputSchema: { type: "object", properties: {} }
+    },
+    {
+      name: "bridge_tail_activity",
+      description: "Read the last lines from the local BLUN Telegram bridge activity log.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          lines: { type: "number", description: "Number of lines to read. Default 20." }
+        }
+      }
+    }
+  ]
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const args = request.params.arguments || {};
+  switch (request.params.name) {
+    case "bridge_status":
+      return textResult(bridgeStatus());
+    case "bridge_bind_current_thread":
+      return textResult(bindCurrentThread(args.thread_id || ""));
+    case "bridge_poll_once":
+      return textResult(await pollOnce());
+    case "bridge_list_queue":
+      return textResult(listQueue(Number(args.limit || 10)));
+    case "bridge_inject_next":
+      return textResult(await injectNext(args.thread_id || ""));
+    case "bridge_reply":
+      return textResult(
+        await reply(String(args.text || ""), {
+          chatId: args.chat_id || "",
+          replyToMessageId: args.reply_to_message_id || "",
+          telegramThreadId: args.telegram_thread_id || ""
+        })
+      );
+    case "bridge_relay_once":
+      return textResult(await relayRepliesOnce());
+    case "bridge_tail_activity":
+      return textResult(tailActivity(Number(args.lines || 20)));
+    default:
+      throw new Error(`Unknown tool: ${request.params.name}`);
+  }
+});
+
+await server.connect(new StdioServerTransport());

package/telegram-plugin/sidecar-manager.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { loadConfig } from "./lib/env.js";
+import { ensureStateLayout } from "./lib/paths.js";
+import { ensureBackgroundSidecars } from "./lib/sidecars.js";
+
+ensureStateLayout();
+const result = ensureBackgroundSidecars(loadConfig());
+process.stdout.write(`${JSON.stringify(result)}\n`);

package/telegram-status.ps1

@@ -0,0 +1,160 @@
+param(
+  [string]$Profile = "default"
+)
+
+$ErrorActionPreference = "Stop"
+
+function Try-ReadJson {
+  param([string]$Path)
+  if (-not (Test-Path $Path)) { return $null }
+  try { return Get-Content -Raw -Path $Path | ConvertFrom-Json } catch { return $null }
+}
+
+function Read-DotEnvFile {
+  param([string]$Path)
+  $values = @{}
+  if (-not (Test-Path $Path)) { return $values }
+  foreach ($line in (Get-Content -Path $Path)) {
+    if (-not $line) { continue }
+    if ($line.Trim().StartsWith("#")) { continue }
+    $parts = $line -split "=", 2
+    if ($parts.Count -ne 2) { continue }
+    $values[$parts[0].Trim()] = $parts[1]
+  }
+  return $values
+}
+
+function Test-PidAlive {
+  param([int]$ProcId)
+  if ($ProcId -le 0) { return $false }
+  return $null -ne (Get-Process -Id $ProcId -ErrorAction SilentlyContinue)
+}
+
+function Resolve-ConfiguredPath {
+  param([string]$Value, [string]$RuntimeRoot)
+  if (-not $Value) { return "" }
+  $expanded = [Environment]::ExpandEnvironmentVariables($Value)
+  if ([System.IO.Path]::IsPathRooted($expanded)) { return $expanded }
+  return [System.IO.Path]::GetFullPath((Join-Path $RuntimeRoot $expanded))
+}
+
+function Get-TelegramPluginRoot {
+  param([string]$RuntimeRoot)
+
+  $candidates = @()
+  if ($env:BLUN_CODEX_TELEGRAM_PLUGIN_ROOT) {
+    $candidates += $env:BLUN_CODEX_TELEGRAM_PLUGIN_ROOT
+  }
+  $candidates += (Join-Path $RuntimeRoot "telegram-plugin")
+
+  foreach ($candidate in $candidates) {
+    if (-not $candidate) { continue }
+    if ((Test-Path (Join-Path $candidate "app-server-cli.js")) -and (Test-Path (Join-Path $candidate "sidecar-manager.js"))) {
+      return $candidate
+    }
+  }
+
+  return $null
+}
+
+$runtimeRoot = Split-Path -Parent $MyInvocation.MyCommand.Path
+$profilePath = Join-Path $runtimeRoot ("profiles\" + $Profile.ToLower() + ".json")
+$profileJson = Try-ReadJson -Path $profilePath
+$profileAgent = if ($profileJson -and $profileJson.agent_name) { [string]$profileJson.agent_name } else { $Profile.ToLower() }
+$runtimeDir = Join-Path $env:USERPROFILE (".codex\\runtimes\\" + $profileAgent)
+$stateDir = if ($profileJson -and $profileJson.telegram -and $profileJson.telegram.state_dir) {
+  Resolve-ConfiguredPath -Value ([string]$profileJson.telegram.state_dir) -RuntimeRoot $runtimeRoot
+} else {
+  Join-Path $env:USERPROFILE (".codex\\channels\\telegram-" + $profileAgent)
+}
+$currentRuntime = Try-ReadJson -Path (Join-Path $runtimeDir "current-remote-runtime.json")
+$state = Try-ReadJson -Path (Join-Path $stateDir "state.json")
+$envFile = Read-DotEnvFile -Path (Join-Path $stateDir ".env")
+$loadedThreads = @()
+$queue = @($state.queue)
+$queued = @($queue | Where-Object { $_.status -eq "queued" })
+$submitted = @($queue | Where-Object { $_.status -eq "submitted" })
+$delivered = @($queue | Where-Object { $_.status -eq "delivered" })
+$errors = @($queue | Where-Object { $_.status -eq "error" })
+$pendingReplies = @($state.pendingReplies | Where-Object { -not $_.sentAt -and $_.status -ne "error" })
+$pollerPid = if (Test-Path (Join-Path $stateDir "poller.pid")) { (Get-Content -Raw (Join-Path $stateDir "poller.pid")).Trim() } else { $null }
+$dispatcherPid = if (Test-Path (Join-Path $stateDir "dispatcher.pid")) { (Get-Content -Raw (Join-Path $stateDir "dispatcher.pid")).Trim() } else { $null }
+$responderPid = if (Test-Path (Join-Path $stateDir "responder.pid")) { (Get-Content -Raw (Join-Path $stateDir "responder.pid")).Trim() } else { $null }
+$stateThreadId = if ($state.currentThreadId) { [string]$state.currentThreadId } else { "" }
+$telegramPluginRoot = Get-TelegramPluginRoot -RuntimeRoot $runtimeRoot
+
+if ($currentRuntime) {
+  if ($stateThreadId) {
+    if ($currentRuntime.PSObject.Properties.Name.Contains("thread_id")) {
+      $currentRuntime.thread_id = $stateThreadId
+    } else {
+      $currentRuntime | Add-Member -NotePropertyName "thread_id" -NotePropertyValue $stateThreadId
+    }
+  }
+  if ($pollerPid) {
+    if ($currentRuntime.PSObject.Properties.Name.Contains("poller_pid")) {
+      $currentRuntime.poller_pid = $pollerPid
+    } else {
+      $currentRuntime | Add-Member -NotePropertyName "poller_pid" -NotePropertyValue $pollerPid
+    }
+  }
+  if ($dispatcherPid) {
+    if ($currentRuntime.PSObject.Properties.Name.Contains("dispatcher_pid")) {
+      $currentRuntime.dispatcher_pid = $dispatcherPid
+    } else {
+      $currentRuntime | Add-Member -NotePropertyName "dispatcher_pid" -NotePropertyValue $dispatcherPid
+    }
+  }
+  if ($responderPid) {
+    if ($currentRuntime.PSObject.Properties.Name.Contains("responder_pid")) {
+      $currentRuntime.responder_pid = $responderPid
+    } else {
+      $currentRuntime | Add-Member -NotePropertyName "responder_pid" -NotePropertyValue $responderPid
+    }
+  }
+}
+
+if ($envFile["BLUN_TELEGRAM_APP_SERVER_WS_URL"] -and $telegramPluginRoot) {
+  try {
+    $bootstrapScript = Join-Path $telegramPluginRoot "app-server-cli.js"
+    $loaded = & node $bootstrapScript "list-loaded" "--ws-url" $envFile["BLUN_TELEGRAM_APP_SERVER_WS_URL"] | ConvertFrom-Json
+    $loadedThreads = @($loaded.data)
+  } catch {
+    $loadedThreads = @()
+  }
+}
+
+$result = [ordered]@{
+  profile = $profileAgent
+  state_dir = $stateDir
+  plugin_root = $telegramPluginRoot
+  active_ws = $envFile["BLUN_TELEGRAM_APP_SERVER_WS_URL"]
+  env_thread_id = $envFile["BLUN_TELEGRAM_THREAD_ID"]
+  state_thread_id = $stateThreadId
+  active_thread_id = if ($stateThreadId) { $stateThreadId } else { $envFile["BLUN_TELEGRAM_THREAD_ID"] }
+  current_runtime = $currentRuntime
+  loaded_threads = $loadedThreads
+  queue_depth = $queued.Count
+  submitted_depth = $submitted.Count
+  pending_reply_depth = $pendingReplies.Count
+  delivered_count = $delivered.Count
+  error_count = $errors.Count
+  history_count = $queue.Count
+  last_inbound = $state.lastInbound
+  last_outbound = $state.lastOutbound
+  poller_pid = $pollerPid
+  dispatcher_pid = $dispatcherPid
+  responder_pid = $responderPid
+}
+
+if ($result.poller_pid) {
+  $result["poller_alive"] = Test-PidAlive -ProcId ([int]$result.poller_pid)
+}
+if ($result.dispatcher_pid) {
+  $result["dispatcher_alive"] = Test-PidAlive -ProcId ([int]$result.dispatcher_pid)
+}
+if ($result.responder_pid) {
+  $result["responder_alive"] = Test-PidAlive -ProcId ([int]$result.responder_pid)
+}
+
+$result | ConvertTo-Json -Depth 8