@blunking/codexlink 0.1.16 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blunking/codexlink",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "BLUN CLI launcher with Telegram channel support for one visible session.",
   "license": "MIT",
   "private": false,
@@ -21,9 +21,10 @@
     "telegram-title-embed.ps1",
     "telegram-status.ps1",
     "telegram-doctor.ps1",
-    "telegram-setup.ps1",
-    "telegram-title-watcher.ps1"
-  ],
+    "telegram-setup.ps1",
+    "telegram-console-input.ps1",
+    "telegram-title-watcher.ps1"
+  ],
   "keywords": [
     "blun",
     "codexlink",

package/start-codex-agent.ps1

@@ -469,12 +469,17 @@ if ($telegramEnvOverride) {
   $commonOverrides += $telegramEnvOverride
 }
 
-$codexArgs = @()
-
-if ($profile.reasoning_effort) {
-  $codexArgs += "-c"
-  $codexArgs += ("model_reasoning_effort=""" + $profile.reasoning_effort + """")
-}
+$codexArgs = @()
+
+if ($profile.model) {
+  $codexArgs += "--model"
+  $codexArgs += $profile.model
+}
+
+if ($profile.reasoning_effort) {
+  $codexArgs += "-c"
+  $codexArgs += ("model_reasoning_effort=""" + $profile.reasoning_effort + """")
+}
 
 if ($profile.personality) {
   $codexArgs += "-c"
@@ -749,20 +754,28 @@ if ($useRemoteAppServer) {
       if ($loadedIds.Count -gt 0) {
         $activeThreadId = [string]$loadedIds[$loadedIds.Count - 1]
         $bestThreadScore = [double]::NegativeInfinity
+        $runtimeStartedAtMs = 0
+        try {
+          $runtimeStartedAtMs = [DateTimeOffset]::Parse([string]$currentRuntime.started_at).ToUnixTimeMilliseconds()
+        } catch {
+          $runtimeStartedAtMs = 0
+        }
         foreach ($candidate in $loadedIds) {
           $candidateThreadId = [string]$candidate
           if ([string]::IsNullOrWhiteSpace($candidateThreadId)) {
             continue
           }
           $threadScore = 0.0
+          $threadCreatedAtMs = 0.0
           try {
             $candidateInfo = Invoke-NodeJsonWithRetry -NodeArgs @($bootstrapScript, "read-thread", "--ws-url", $telegramAppServerWsUrl, "--thread-id", $candidateThreadId) -Attempts 1 -DelayMs 0
             $thread = $candidateInfo.response.result.thread
             if ($null -ne $thread -and $null -ne $thread.createdAt) {
-              $threadScore = [double]$thread.createdAt
-              if ($threadScore -gt 0 -and $threadScore -lt 1000000000000) {
-                $threadScore = $threadScore * 1000
+              $threadCreatedAtMs = [double]$thread.createdAt
+              if ($threadCreatedAtMs -gt 0 -and $threadCreatedAtMs -lt 1000000000000) {
+                $threadCreatedAtMs = $threadCreatedAtMs * 1000
               }
+              $threadScore = $threadCreatedAtMs
             }
             $threadSource = ""
             $threadStatusType = ""
@@ -773,11 +786,14 @@ if ($useRemoteAppServer) {
               $threadStatusType = ([string]$thread.status.type).ToLowerInvariant()
             }
             if ($threadSource -eq "cli" -and $threadStatusType -eq "active") {
-              $threadScore += 1000000000000000
+              $threadScore += 4000000000000000
             } elseif ($threadStatusType -eq "active") {
-              $threadScore += 900000000000000
+              $threadScore += 3000000000000000
             } elseif ($threadSource -eq "cli") {
-              $threadScore += 800000000000000
+              $threadScore += 2000000000000000
+            }
+            if ($runtimeStartedAtMs -gt 0 -and $threadCreatedAtMs -ge ($runtimeStartedAtMs - 120000)) {
+              $threadScore += 1000000000000000
             }
           } catch {
             $threadScore = 0.0

package/telegram-console-input.ps1

@@ -0,0 +1,151 @@
+param(
+  [Parameter(Mandatory = $true)]
+  [int]$TargetPid,
+
+  [string]$Text = "",
+
+  [switch]$ClearBefore,
+
+  [switch]$Submit
+)
+
+$ErrorActionPreference = "Stop"
+
+$typeName = "ConsoleInputWriter"
+$assemblyDir = Join-Path $env:TEMP "blun-codexlink"
+$assemblyPath = Join-Path $assemblyDir "console-input-writer-v4.dll"
+
+$source = @"
+using System;
+using System.Runtime.InteropServices;
+
+public static class ConsoleInputWriter {
+  private const int STD_INPUT_HANDLE = -10;
+  private const short KEY_EVENT = 0x0001;
+  private const ushort VK_RETURN = 0x0D;
+  private const ushort VK_BACK = 0x08;
+  private const ushort VK_U = 0x55;
+  private const ushort SCAN_RETURN = 0x1C;
+  private const ushort SCAN_U = 0x16;
+  private const uint LEFT_CTRL_PRESSED = 0x0008;
+  private const uint GENERIC_READ = 0x80000000;
+  private const uint GENERIC_WRITE = 0x40000000;
+  private const uint FILE_SHARE_READ = 0x00000001;
+  private const uint FILE_SHARE_WRITE = 0x00000002;
+  private const uint OPEN_EXISTING = 3;
+
+  [StructLayout(LayoutKind.Sequential)]
+  public struct KEY_EVENT_RECORD {
+    [MarshalAs(UnmanagedType.Bool)]
+    public bool bKeyDown;
+    public ushort wRepeatCount;
+    public ushort wVirtualKeyCode;
+    public ushort wVirtualScanCode;
+    public char UnicodeChar;
+    public uint dwControlKeyState;
+  }
+
+  [StructLayout(LayoutKind.Explicit)]
+  public struct INPUT_RECORD {
+    [FieldOffset(0)]
+    public short EventType;
+    [FieldOffset(4)]
+    public KEY_EVENT_RECORD KeyEvent;
+  }
+
+  [DllImport("kernel32.dll", SetLastError=true)]
+  private static extern bool AttachConsole(uint dwProcessId);
+
+  [DllImport("kernel32.dll", SetLastError=true)]
+  private static extern bool FreeConsole();
+
+  [DllImport("kernel32.dll", SetLastError=true)]
+  private static extern IntPtr GetStdHandle(int nStdHandle);
+
+  [DllImport("kernel32.dll", SetLastError=true, CharSet=CharSet.Unicode)]
+  private static extern IntPtr CreateFileW(string lpFileName, uint dwDesiredAccess, uint dwShareMode, IntPtr lpSecurityAttributes, uint dwCreationDisposition, uint dwFlagsAndAttributes, IntPtr hTemplateFile);
+
+  [DllImport("kernel32.dll", SetLastError=true)]
+  private static extern bool CloseHandle(IntPtr hObject);
+
+  [DllImport("kernel32.dll", SetLastError=true, CharSet=CharSet.Unicode)]
+  private static extern bool WriteConsoleInputW(IntPtr hConsoleInput, INPUT_RECORD[] lpBuffer, uint nLength, out uint lpNumberOfEventsWritten);
+
+  public static void WriteText(int targetPid, string text, bool clearBefore, bool submit) {
+    FreeConsole();
+    if (!AttachConsole((uint)targetPid)) {
+      throw new InvalidOperationException("AttachConsole failed: " + Marshal.GetLastWin32Error());
+    }
+
+    IntPtr input = CreateFileW("CONIN$", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
+    if (input == IntPtr.Zero || input == new IntPtr(-1)) {
+      input = GetStdHandle(STD_INPUT_HANDLE);
+    }
+    if (input == IntPtr.Zero || input == new IntPtr(-1)) {
+      throw new InvalidOperationException("Open console input failed: " + Marshal.GetLastWin32Error());
+    }
+
+    try {
+      if (clearBefore) {
+        WriteKey(input, (char)21, VK_U, SCAN_U, LEFT_CTRL_PRESSED);
+      }
+
+      foreach (char ch in text) {
+        WriteKey(input, ch, 0);
+      }
+
+      if (submit) {
+        WriteKey(input, '\r', VK_RETURN, SCAN_RETURN);
+      }
+    } finally {
+      CloseHandle(input);
+      FreeConsole();
+    }
+  }
+
+  private static void WriteKey(IntPtr input, char ch, ushort virtualKey) {
+    WriteKey(input, ch, virtualKey, 0);
+  }
+
+  private static void WriteKey(IntPtr input, char ch, ushort virtualKey, ushort virtualScanCode) {
+    WriteKey(input, ch, virtualKey, virtualScanCode, 0);
+  }
+
+  private static void WriteKey(IntPtr input, char ch, ushort virtualKey, ushort virtualScanCode, uint controlKeyState) {
+    INPUT_RECORD[] records = new INPUT_RECORD[2];
+    records[0].EventType = KEY_EVENT;
+    records[0].KeyEvent.bKeyDown = true;
+    records[0].KeyEvent.wRepeatCount = 1;
+    records[0].KeyEvent.wVirtualKeyCode = virtualKey;
+    records[0].KeyEvent.wVirtualScanCode = virtualScanCode;
+    records[0].KeyEvent.UnicodeChar = ch;
+    records[0].KeyEvent.dwControlKeyState = controlKeyState;
+
+    records[1].EventType = KEY_EVENT;
+    records[1].KeyEvent.bKeyDown = false;
+    records[1].KeyEvent.wRepeatCount = 1;
+    records[1].KeyEvent.wVirtualKeyCode = virtualKey;
+    records[1].KeyEvent.wVirtualScanCode = virtualScanCode;
+    records[1].KeyEvent.UnicodeChar = ch;
+    records[1].KeyEvent.dwControlKeyState = controlKeyState;
+
+    uint written;
+    if (!WriteConsoleInputW(input, records, (uint)records.Length, out written) || written != records.Length) {
+      throw new InvalidOperationException("WriteConsoleInputW failed: " + Marshal.GetLastWin32Error());
+    }
+  }
+}
+"@
+
+if (-not ($typeName -as [type])) {
+  if (Test-Path $assemblyPath) {
+    Add-Type -Path $assemblyPath
+  } else {
+    New-Item -ItemType Directory -Path $assemblyDir -Force | Out-Null
+    Add-Type -TypeDefinition $source -OutputAssembly $assemblyPath -OutputType Library
+    Add-Type -Path $assemblyPath
+  }
+}
+
+$normalizedText = $Text -replace "`r`n", " " -replace "`n", " " -replace "`r", " "
+[ConsoleInputWriter]::WriteText($TargetPid, $normalizedText, [bool]$ClearBefore, [bool]$Submit)

package/telegram-plugin/README.md

@@ -10,8 +10,9 @@ It is intentionally **not** an autonomous answer bot.
 - stores inbound and outbound history under a local state directory
 - keeps private chats and group threads separated
 - binds a live thread id
-- injects the next queued Telegram message into that exact live thread only after the session is idle
-- keeps injected Telegram messages visible as pending until the matching answer is sent
+- injects direct/private/lane Telegram messages into the active app-server thread
+- steers active turns when the app-server supports it
+- keeps queued Telegram messages visible when they are waiting instead of ready to deliver
 - sends explicit manual replies from the visible operator session
 - keeps ambient group noise queued unless it is relevant to that operator
 - lets escalation-style messages bypass the normal idle queue
@@ -47,7 +48,7 @@ Copy `.env.example` to `.env` in the state directory or export env vars:
 
 - `BLUN_TELEGRAM_AGENT_NAME`
 - `BLUN_TELEGRAM_BOT_TOKEN`
-- `BLUN_TELEGRAM_ALLOWED_CHAT_ID` (`chatId` or comma-separated list like `1605241602,-1003927574737`)
+- `BLUN_TELEGRAM_ALLOWED_CHAT_ID` (`chatId` or comma-separated list like `123456789,-1001234567890`)
 - `BLUN_TELEGRAM_CODEX_BIN`
 - `BLUN_TELEGRAM_THREAD_ID`
 - `BLUN_TELEGRAM_RESUME_TIMEOUT_MS`

package/telegram-plugin/lib/app-server-client.js

@@ -55,12 +55,44 @@ function extractTurnId(response) {
     || "";
 }
 
+function extractActiveTurnId(turnsResponse) {
+  const turns = Array.isArray(turnsResponse?.result?.data) ? turnsResponse.result.data : [];
+  const active = turns.find((turn) => String(turn?.status || "").trim() === "inProgress");
+  return String(active?.id || "").trim();
+}
+
 function extractThreadPath(response) {
   return response?.result?.thread?.path
     || response?.result?.path
     || "";
 }
 
+function normalizeUserInput(input) {
+  const items = Array.isArray(input) ? input : [];
+  return items.map((item) => {
+    if (!item || typeof item !== "object") {
+      return item;
+    }
+    if (item.type === "text" && !Array.isArray(item.text_elements)) {
+      return {
+        ...item,
+        text_elements: []
+      };
+    }
+    return item;
+  });
+}
+
+function buildTextInput(text) {
+  return [
+    {
+      type: "text",
+      text,
+      text_elements: []
+    }
+  ];
+}
+
 export class AppServerClient {
   constructor(wsUrl, options = {}) {
     this.wsUrl = normalizeWsUrl(wsUrl);
@@ -220,14 +252,12 @@ export async function startThreadOverWs(options) {
 export async function startTextTurnOverWs(options) {
   const client = new AppServerClient(options.wsUrl, { timeoutMs: options.timeoutMs || 20000 });
   try {
+    const input = Array.isArray(options.input) && options.input.length > 0
+      ? normalizeUserInput(options.input)
+      : buildTextInput(options.text);
     const response = await client.request("turn/start", {
       threadId: options.threadId,
-      input: [
-        {
-          type: "text",
-          text: options.text
-        }
-      ],
+      input,
       model: options.model || null,
       effort: options.effort || null,
       personality: options.personality || null
@@ -256,11 +286,115 @@ export async function startTextTurnOverWs(options) {
   }
 }
 
+export async function startOrSteerTextTurnOverWs(options) {
+  const client = new AppServerClient(options.wsUrl, { timeoutMs: options.timeoutMs || 20000 });
+  try {
+    const input = Array.isArray(options.input) && options.input.length > 0
+      ? normalizeUserInput(options.input)
+      : buildTextInput(options.text);
+
+    let activeTurnId = "";
+    try {
+      const turnsResponse = await client.request("thread/turns/list", {
+        threadId: options.threadId,
+        limit: 8,
+        itemsView: "notLoaded"
+      }, { timeoutMs: Math.min(options.timeoutMs || 20000, 5000) });
+      activeTurnId = extractActiveTurnId(turnsResponse);
+    } catch {
+      activeTurnId = "";
+    }
+
+    if (activeTurnId) {
+      try {
+        const steerResponse = await client.request("turn/steer", {
+          threadId: options.threadId,
+          expectedTurnId: activeTurnId,
+          input,
+          responsesapiClientMetadata: {
+            source: "telegram"
+          }
+        }, { timeoutMs: options.timeoutMs || 20000 });
+
+        return {
+          ok: true,
+          busy: false,
+          steered: true,
+          turnId: extractTurnId(steerResponse) || activeTurnId,
+          response: steerResponse
+        };
+      } catch (error) {
+        const details = `${error?.message || error}`.toLowerCase();
+        const notSteerable = details.includes("activeturnnotsteerable")
+          || details.includes("not steerable")
+          || details.includes("cannot accept same-turn steering");
+        const staleTurn = details.includes("expectedturnid")
+          || details.includes("precondition")
+          || details.includes("does not match")
+          || details.includes("no active turn");
+        if (notSteerable) {
+          return {
+            ok: false,
+            busy: true,
+            steered: true,
+            turnId: activeTurnId,
+            error
+          };
+        }
+        if (!staleTurn) {
+          return {
+            ok: false,
+            busy: true,
+            steered: true,
+            turnId: activeTurnId,
+            error
+          };
+        }
+      }
+    }
+
+    const response = await client.request("turn/start", {
+      threadId: options.threadId,
+      input,
+      model: options.model || null,
+      effort: options.effort || null,
+      personality: options.personality || null,
+      responsesapiClientMetadata: {
+        source: "telegram"
+      }
+    }, { timeoutMs: options.timeoutMs || 20000 });
+
+    return {
+      ok: true,
+      busy: false,
+      steered: false,
+      turnId: extractTurnId(response),
+      response
+    };
+  } catch (error) {
+    const details = `${error?.message || error}`.toLowerCase();
+    const busy = details.includes("active turn")
+      || details.includes("cannot accept")
+      || details.includes("already running")
+      || details.includes("busy");
+
+    return {
+      ok: false,
+      busy,
+      steered: false,
+      error
+    };
+  } finally {
+    await client.close();
+  }
+}
+
 export async function readThreadOverWs(options) {
   const client = new AppServerClient(options.wsUrl, { timeoutMs: options.timeoutMs || 10000 });
   try {
     const response = await client.request("thread/read", {
-      threadId: options.threadId
+      threadId: options.threadId,
+      includeTurns: Boolean(options.includeTurns)
     }, { timeoutMs: options.timeoutMs || 10000 });
     const threadId = extractThreadId(response);
     return {