@blunking/codexlink 0.1.0 → 0.1.2

package/telegram-plugin/lib/bridge.js

@@ -22,6 +22,52 @@ function pendingReplyKey(entry) {
   return entry.turnId || `${entry.threadId || ""}:${entry.chatId}:${entry.messageId}`;
 }
 
+function containsToken(text, token) {
+  const value = String(token || "").trim();
+  if (!value) {
+    return false;
+  }
+  const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(^|[^a-z0-9_])${escaped}([^a-z0-9_]|$)`, "i").test(String(text || ""));
+}
+
+function looksLikeEscalation(text) {
+  const value = String(text || "");
+  return [
+    "eskalation",
+    "escalation",
+    "urgent",
+    "emergency",
+    "sofort",
+    "prio 0",
+    "p0",
+    "blocker"
+  ].some((token) => containsToken(value, token));
+}
+
+function classifyInboundRelevance(config, inbound) {
+  if (looksLikeEscalation(inbound.text)) {
+    return "escalation";
+  }
+
+  if (String(inbound.chatType || "") === "private") {
+    return "direct";
+  }
+
+  const text = String(inbound.text || "");
+  const agentName = String(config.agentName || "").trim();
+  if (agentName && agentName.toLowerCase() !== "default" && containsToken(text, agentName)) {
+    return "direct";
+  }
+
+  const lane = String(config.lane || "").trim();
+  if (lane && lane.toLowerCase() !== "general" && containsToken(text, lane)) {
+    return "lane";
+  }
+
+  return "ambient";
+}
+
 function statusWeight(status) {
   switch (status) {
     case "delivered":
@@ -96,7 +142,7 @@ function mergeQueueEntry(current, incoming) {
   merged.deliveredAt = pickIsoLater(current.deliveredAt, incoming.deliveredAt);
   merged.ts = pickIsoLater(current.ts, incoming.ts);
 
-  for (const field of ["threadId", "responsePreview", "stderr", "stdout", "chatType", "conversationKey", "groupTitle", "telegramThreadId", "senderIsBot"]) {
+  for (const field of ["threadId", "responsePreview", "stderr", "stdout", "chatType", "conversationKey", "groupTitle", "telegramThreadId", "senderIsBot", "relevance"]) {
     if (!merged[field]) {
       merged[field] = current[field] || incoming[field] || null;
     }
@@ -300,6 +346,7 @@ function normalizeInbound(message) {
     userId: message.from?.id ? String(message.from.id) : "",
     text,
     ts: nowIso(),
+    relevance: "ambient",
     status: "queued",
     attempts: 0,
     lastAttemptAt: null
@@ -310,6 +357,14 @@ function normalizeTelegramThreadId(value) {
   return String(value || "").trim();
 }
 
+function isAllowedChat(config, chatId) {
+  const allowed = Array.isArray(config.allowedChatIds) ? config.allowedChatIds : [];
+  if (allowed.length === 0) {
+    return true;
+  }
+  return allowed.includes(String(chatId || "").trim());
+}
+
 function splitTelegramText(text, maxLength = 3500) {
   const value = String(text || "").trim();
   if (!value) {
@@ -401,6 +456,28 @@ async function resolveThreadSessionPath(config, threadId) {
   return findRolloutFile(config.paths.sessionsDir, threadId) || "";
 }
 
+function countOpenPendingReplies(state) {
+  return (state.pendingReplies || []).filter((entry) => !entry.sentAt && !["error", "ignored_bot", "superseded"].includes(String(entry.status || ""))).length;
+}
+
+async function resolveSessionActivity(config, threadId) {
+  const sessionPath = await resolveThreadSessionPath(config, threadId);
+  if (!sessionPath || !existsSync(sessionPath)) {
+    return {
+      sessionPath,
+      quietMs: Number.POSITIVE_INFINITY,
+      active: false
+    };
+  }
+
+  const quietMs = Math.max(0, Date.now() - statSync(sessionPath).mtimeMs);
+  return {
+    sessionPath,
+    quietMs,
+    active: quietMs < Number(config.idleCooldownMs || 0)
+  };
+}
+
 function buildPendingReplyEntry(message, threadId, turnId, sessionPath, sessionOffset) {
   return {
     turnId: String(turnId || "").trim(),
@@ -526,7 +603,7 @@ function promoteVisibleQueuedEntry(config, state, threadId, message) {
 }
 
 async function resolveActiveThreadId(config, state, preferredThreadId) {
-  const fallbackThreadId = String(preferredThreadId || state.currentThreadId || config.currentThreadId || "").trim();
+  const fallbackThreadId = String(preferredThreadId || config.currentThreadId || state.currentThreadId || "").trim();
   if (!config.appServerWsUrl) {
     return fallbackThreadId;
   }
@@ -584,12 +661,16 @@ export function bridgeStatus() {
   const state = loadState(config);
   const queued = state.queue.filter((item) => item.status === "queued");
   const submitted = state.queue.filter((item) => item.status === "submitted");
+  const ambient = queued.filter((item) => item.relevance === "ambient");
   const pendingReplies = (state.pendingReplies || []).filter((item) => !item.sentAt && item.status !== "error");
   return {
     agent: config.agentName,
     allowedChatId: config.allowedChatId || null,
-    boundThreadId: state.currentThreadId || config.currentThreadId || null,
+    boundThreadId: config.currentThreadId || state.currentThreadId || null,
+    dispatchMode: config.dispatchMode,
+    idleCooldownMs: config.idleCooldownMs,
     queueDepth: queued.length,
+    ambientQueueDepth: ambient.length,
     submittedDepth: submitted.length,
     pendingReplyDepth: pendingReplies.length,
     lastInbound: state.lastInbound,
@@ -597,7 +678,7 @@ export function bridgeStatus() {
     lastPollAt: state.lastPollAt,
     lastInjectAt: state.lastInjectAt,
     stateDir: config.paths.root,
-    note: "No autonomous shadow bot. Telegram is queued here and only injected into a real Codex thread on demand."
+    note: "Telegram first lands in queue. Automatic delivery waits for an idle session, skips ambient group noise, and still lets escalations through."
   };
 }
 
@@ -682,7 +763,7 @@ export async function pollOnce() {
       continue;
     }
     const inbound = normalizeInbound(update.message);
-    if (config.allowedChatId && inbound.chatId !== config.allowedChatId) {
+    if (!isAllowedChat(config, inbound.chatId)) {
       ignored += 1;
       appendLog(config.paths.activityFile, `IGNORED chat=${inbound.chatId} message=${inbound.messageId}`);
       continue;
@@ -692,10 +773,11 @@ export async function pollOnce() {
       appendLog(config.paths.activityFile, `IGNORED_EMPTY chat=${inbound.chatId} message=${inbound.messageId}`);
       continue;
     }
+    inbound.relevance = classifyInboundRelevance(config, inbound);
     state.queue.push(inbound);
     state.lastInbound = inbound;
     appendJsonl(config.paths.inboxFile, inbound);
-    appendLog(config.paths.activityFile, `IN chat=${inbound.chatId} message=${inbound.messageId} user=${inbound.user}: ${inbound.text.replace(/\s+/g, " ").slice(0, 180)}`);
+    appendLog(config.paths.activityFile, `IN chat=${inbound.chatId} message=${inbound.messageId} relevance=${inbound.relevance} user=${inbound.user}: ${inbound.text.replace(/\s+/g, " ").slice(0, 180)}`);
     captured += 1;
   }
 
@@ -717,9 +799,10 @@ export function listQueue(limit = 10) {
   return state.queue.slice(-Math.max(1, limit));
 }
 
-export async function injectNext(threadId) {
+export async function injectNext(threadId, options = {}) {
   const config = loadConfig();
   const state = loadState(config);
+  const auto = Boolean(options.auto);
   const useAppServer = Boolean(config.appServerWsUrl);
   const preferredThreadId = (
     threadId
@@ -732,6 +815,53 @@ export async function injectNext(threadId) {
     throw new Error("No bound thread id. Use bridge_bind_current_thread first.");
   }
 
+  let next = null;
+  if (auto && String(config.dispatchMode || "deferred").toLowerCase() !== "legacy") {
+    next = state.queue.find((item) => {
+      if (item.status !== "queued") {
+        return false;
+      }
+      if (String(item.chatType || "") === "private") {
+        return true;
+      }
+      return ["direct", "lane", "escalation"].includes(String(item.relevance || ""));
+    });
+  } else {
+    next = state.queue.find((item) => item.status === "queued");
+  }
+
+  if (!next) {
+    return {
+      ok: true,
+      status: auto ? "deferred" : "empty",
+      reason: auto ? "no_eligible_message" : undefined
+    };
+  }
+
+  const bypassDeferredGate = auto && next.relevance === "escalation";
+  if (auto && !bypassDeferredGate && String(config.dispatchMode || "deferred").toLowerCase() !== "legacy") {
+    const openPendingReplies = countOpenPendingReplies(state);
+    if (openPendingReplies > 0) {
+      return {
+        ok: false,
+        status: "deferred",
+        reason: "pending_reply",
+        pendingReplies: openPendingReplies
+      };
+    }
+
+    const sessionActivity = await resolveSessionActivity(config, resolvedThreadId);
+    if (sessionActivity.active) {
+      return {
+        ok: false,
+        status: "deferred",
+        reason: "session_active",
+        quietMs: sessionActivity.quietMs,
+        readyInMs: Math.max(0, Number(config.idleCooldownMs || 0) - Number(sessionActivity.quietMs || 0))
+      };
+    }
+  }
+
   let promoted = 0;
   if (!useAppServer) {
     for (const entry of state.queue) {
@@ -744,14 +874,6 @@ export async function injectNext(threadId) {
     saveStateForConfig(config, state);
   }
 
-  const next = state.queue.find((item) => item.status === "queued");
-  if (!next) {
-    return {
-      ok: true,
-      status: promoted > 0 ? "submitted" : "empty"
-    };
-  }
-
   next.attempts = Number(next.attempts || 0) + 1;
   next.lastAttemptAt = nowIso();
   let sessionPath = "";
@@ -803,6 +925,7 @@ export async function injectNext(threadId) {
     }
   }
   state.lastInjectAt = nowIso();
+  state.lastAutoDispatchAt = auto ? state.lastInjectAt : state.lastAutoDispatchAt;
   const latestState = loadState(config);
   saveStateForConfig(config, mergeStateSnapshots(latestState, state));
   appendLog(config.paths.activityFile, `INJECT_${result.ok ? "OK" : "ERROR"} thread=${resolvedThreadId} message=${next.messageId}`);

package/telegram-plugin/lib/env.js

@@ -18,6 +18,13 @@ function readDotEnvFile(path) {
   return values;
 }
 
+function parseAllowedChatIds(rawValue) {
+  return String(rawValue || "")
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
 export function loadConfig() {
   ensureStateLayout();
   const paths = getPaths();
@@ -27,17 +34,21 @@ export function loadConfig() {
   delete fallbackEnv.BLUN_TELEGRAM_AGENT_NAME;
   delete fallbackEnv.BLUN_TELEGRAM_STATE_DIR;
   delete fallbackEnv.BLUN_TELEGRAM_THREAD_ID;
-  const env = { ...fallbackEnv, ...fileEnv, ...process.env };
+  const env = { ...fallbackEnv, ...process.env, ...fileEnv };
+  const allowedChatIds = parseAllowedChatIds(env.BLUN_TELEGRAM_ALLOWED_CHAT_ID || env.TELEGRAM_ALLOWED_CHAT_ID || "");
   return {
     paths,
-    agentName: env.BLUN_TELEGRAM_AGENT_NAME?.trim() || "default",
+    agentName: env.BLUN_TELEGRAM_AGENT_NAME?.trim() || env.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() || "",
+    botToken: env.BLUN_TELEGRAM_BOT_TOKEN?.trim() || env.TELEGRAM_BOT_TOKEN?.trim() || "",
+    allowedChatId: allowedChatIds[0] || "",
+    allowedChatIds,
     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,
+    dispatchMode: env.BLUN_TELEGRAM_DISPATCH_MODE?.trim() || "deferred",
     pluginMode: env.BLUN_TELEGRAM_PLUGIN_MODE?.trim() || "inherit",
     model: env.BLUN_CODEX_MODEL?.trim() || "",
     reasoningEffort: env.BLUN_CODEX_REASONING_EFFORT?.trim() || "",

package/telegram-plugin/lib/sidecars.js

@@ -59,10 +59,12 @@ function ensureSidecar(scriptName, pidFile, stdoutFile, stderrFile, config, opti
     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_ALLOWED_CHAT_ID: Array.isArray(config.allowedChatIds) ? config.allowedChatIds.join(",") : (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_IDLE_COOLDOWN_MS: String(config.idleCooldownMs || 15000),
+    BLUN_TELEGRAM_DISPATCH_MODE: config.dispatchMode || "deferred",
     BLUN_TELEGRAM_PLUGIN_MODE: config.pluginMode || "plugin",
     BLUN_CODEX_MODEL: config.model || "",
     BLUN_CODEX_REASONING_EFFORT: config.reasoningEffort || "",

package/telegram-plugin/lib/storage.js

@@ -1,49 +1,50 @@
-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
-  };
-}
+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,
+    lastAutoDispatchAt: null
+  };
+}

package/telegram-setup.ps1

@@ -0,0 +1,245 @@
+param(
+  [string]$Profile = "default",
+  [switch]$EnsureConfigured,
+  [switch]$Json
+)
+
+$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 Ensure-Dir {
+  param([string]$Path)
+  if (-not (Test-Path $Path)) {
+    New-Item -ItemType Directory -Path $Path -Force | Out-Null
+  }
+}
+
+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 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 Write-DotEnvFile {
+  param(
+    [string]$Path,
+    [hashtable]$Values
+  )
+
+  $lines = foreach ($key in ($Values.Keys | Sort-Object)) {
+    "$key=$($Values[$key])"
+  }
+  Set-Content -Path $Path -Value $lines -Encoding UTF8
+}
+
+function Test-TelegramTokenFormat {
+  param([string]$Value)
+  if (-not $Value) { return $false }
+  return $Value -match '^\d{6,}:[A-Za-z0-9_-]{20,}$'
+}
+
+function Test-AllowedChatIdsFormat {
+  param([string]$Value)
+  if (-not $Value) { return $false }
+  $parts = @($Value -split "," | ForEach-Object { $_.Trim() } | Where-Object { $_ })
+  if ($parts.Count -eq 0) { return $false }
+  foreach ($part in $parts) {
+    if ($part -notmatch '^-?\d+$') {
+      return $false
+    }
+  }
+  return $true
+}
+
+function Prompt-RequiredValue {
+  param(
+    [string]$Prompt,
+    [string]$CurrentValue,
+    [scriptblock]$Validator,
+    [string]$ErrorMessage
+  )
+
+  while ($true) {
+    $fullPrompt = if ($CurrentValue) { "$Prompt [$CurrentValue]" } else { $Prompt }
+    $inputValue = Read-Host -Prompt $fullPrompt
+    if (-not $inputValue -and $CurrentValue) {
+      $inputValue = $CurrentValue
+    }
+    $inputValue = [string]$inputValue
+    if (& $Validator $inputValue) {
+      return $inputValue
+    }
+    Write-Host $ErrorMessage -ForegroundColor Yellow
+  }
+}
+
+function Get-ProfilePath {
+  param(
+    [string]$RuntimeRoot,
+    [string]$ProfileName
+  )
+
+  $normalized = [string]$ProfileName
+  if (-not $normalized) { $normalized = "" }
+  $normalized = $normalized.ToLower()
+  $candidates = @()
+  if ($env:BLUN_CODEX_PROFILE_ROOT) {
+    $candidates += (Join-Path $env:BLUN_CODEX_PROFILE_ROOT ($normalized + ".json"))
+  }
+  $candidates += (Join-Path $env:USERPROFILE (".codex\\profiles\\codexlink\\" + $normalized + ".json"))
+  $candidates += (Join-Path $RuntimeRoot ("profiles\\" + $normalized + ".json"))
+
+  foreach ($candidate in $candidates) {
+    if ($candidate -and (Test-Path $candidate)) {
+      return $candidate
+    }
+  }
+
+  return $candidates[-1]
+}
+
+$runtimeRoot = Split-Path -Parent $MyInvocation.MyCommand.Path
+$profilePath = Get-ProfilePath -RuntimeRoot $runtimeRoot -ProfileName $Profile
+$profileJson = Try-ReadJson -Path $profilePath
+
+if (-not $profileJson) {
+  throw "Profile not found or invalid: $profilePath"
+}
+
+$profileAgent = if ($profileJson.agent_name) { [string]$profileJson.agent_name } else { $Profile.ToLower() }
+$stateDir = if ($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)
+}
+
+Ensure-Dir -Path $stateDir
+$envPath = Join-Path $stateDir ".env"
+$envValues = Read-DotEnvFile -Path $envPath
+
+$currentToken = [string]$envValues["BLUN_TELEGRAM_BOT_TOKEN"]
+if (-not (Test-TelegramTokenFormat -Value $currentToken)) {
+  $currentToken = [string]$envValues["TELEGRAM_BOT_TOKEN"]
+}
+
+$currentAllowedChatIds = [string]$envValues["BLUN_TELEGRAM_ALLOWED_CHAT_ID"]
+if (-not (Test-AllowedChatIdsFormat -Value $currentAllowedChatIds)) {
+  $currentAllowedChatIds = [string]$envValues["TELEGRAM_ALLOWED_CHAT_ID"]
+}
+
+$needsToken = -not (Test-TelegramTokenFormat -Value $currentToken)
+$needsChatIds = -not (Test-AllowedChatIdsFormat -Value $currentAllowedChatIds)
+$changed = $false
+
+if ($EnsureConfigured -and -not $needsToken -and -not $needsChatIds) {
+  $result = [ordered]@{
+    ok = $true
+    changed = $false
+    profile = $profileAgent
+    state_dir = $stateDir
+    env_path = $envPath
+    missing = @()
+  }
+  if ($Json) {
+    $result | ConvertTo-Json -Depth 6
+  } else {
+    Write-Host "Telegram ist bereits eingerichtet fuer Profil '$profileAgent'." -ForegroundColor Green
+    Write-Host "State-Ordner: $stateDir"
+  }
+  exit 0
+}
+
+if ($EnsureConfigured -and $Json -and ($needsToken -or $needsChatIds)) {
+  $missing = @()
+  if ($needsToken) { $missing += "bot_token" }
+  if ($needsChatIds) { $missing += "allowed_chat_ids" }
+  [ordered]@{
+    ok = $false
+    changed = $false
+    profile = $profileAgent
+    state_dir = $stateDir
+    env_path = $envPath
+    missing = $missing
+  } | ConvertTo-Json -Depth 6
+  exit 2
+}
+
+if (-not $Json) {
+  Write-Host ""
+  Write-Host "CodexLink Telegram Setup" -ForegroundColor Cyan
+  Write-Host "Profil: $profileAgent"
+  Write-Host "Lokaler State-Ordner: $stateDir"
+  Write-Host ""
+  Write-Host "Ich speichere die Telegram-Werte automatisch an die richtige lokale Stelle." -ForegroundColor DarkGray
+  Write-Host "Du musst keine .env-Datei selbst suchen." -ForegroundColor DarkGray
+  Write-Host ""
+}
+
+if ($needsToken) {
+  $currentToken = Prompt-RequiredValue `
+    -Prompt "Telegram Bot Token" `
+    -CurrentValue $currentToken `
+    -Validator { param($v) Test-TelegramTokenFormat -Value $v } `
+    -ErrorMessage "Bitte einen gueltigen Telegram Bot Token eingeben. Beispiel: 123456789:ABC..."
+  $envValues["BLUN_TELEGRAM_BOT_TOKEN"] = $currentToken
+  $changed = $true
+}
+
+if ($needsChatIds) {
+  $currentAllowedChatIds = Prompt-RequiredValue `
+    -Prompt "Erlaubte Chat ID(s), komma-getrennt" `
+    -CurrentValue $currentAllowedChatIds `
+    -Validator { param($v) Test-AllowedChatIdsFormat -Value $v } `
+    -ErrorMessage "Bitte mindestens eine numerische Chat-ID eingeben. Mehrere IDs mit Komma trennen."
+  $envValues["BLUN_TELEGRAM_ALLOWED_CHAT_ID"] = (($currentAllowedChatIds -split "," | ForEach-Object { $_.Trim() } | Where-Object { $_ }) -join ",")
+  $changed = $true
+}
+
+$envValues["BLUN_TELEGRAM_AGENT_NAME"] = $profileAgent
+$envValues["BLUN_TELEGRAM_STATE_DIR"] = $stateDir
+Write-DotEnvFile -Path $envPath -Values $envValues
+
+$result = [ordered]@{
+  ok = $true
+  changed = $changed
+  profile = $profileAgent
+  state_dir = $stateDir
+  env_path = $envPath
+  missing = @()
+}
+
+if ($Json) {
+  $result | ConvertTo-Json -Depth 6
+  exit 0
+}
+
+Write-Host ""
+Write-Host "Telegram ist jetzt eingerichtet." -ForegroundColor Green
+Write-Host "Gespeichert unter: $envPath"
+Write-Host ""
+Write-Host "Naechster Schritt:" -ForegroundColor Cyan
+Write-Host "  blun-codex --profile $profileAgent telegram-plugin"
+Write-Host ""
+Write-Host "Pruefen kannst du spaeter mit:" -ForegroundColor Cyan
+Write-Host "  blun-codex --profile $profileAgent telegram-doctor"