switchroom 0.16.15 → 0.16.20

package/dist/cli/switchroom.js

@@ -51692,8 +51692,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.16.15";
-var COMMIT_SHA = "a9c59169";
+var VERSION = "0.16.20";
+var COMMIT_SHA = "6ea6e873";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {
@@ -77519,11 +77519,23 @@ function agentLiveness(config, agentName) {
   return "offline";
 }
 function toHermesSession(agent, liveness) {
+  const nowSec = Math.floor(Date.now() / 1000);
   return {
     id: agent.name,
     name: agent.name,
+    title: agent.name,
     status: liveness,
     model: "claude",
+    is_active: liveness === "active",
+    started_at: nowSec,
+    last_active: nowSec,
+    ended_at: null,
+    input_tokens: 0,
+    output_tokens: 0,
+    message_count: 0,
+    tool_call_count: 0,
+    preview: null,
+    source: "switchroom",
     created_at: null,
     updated_at: null,
     quota: agent.primaryAccount ? { used_pct: null, slot: agent.primaryAccount } : null
@@ -77596,11 +77608,19 @@ async function injectInbound(agentsDir, agentName, chatId, threadId, text, promp
   });
 }
 async function handleHermesRest(method, pathname, config) {
-  if (method === "GET" && pathname === "/api/sessions") {
+  if (method === "GET" && (pathname === "/api/sessions" || pathname === "/api/profiles/sessions")) {
     const agents = await handleGetAgents(config);
-    const agentsDir = resolveAgentsDir(config);
     const sessions = agents.map((a) => toHermesSession(a, agentLiveness(config, a.name)));
-    return { status: 200, body: { sessions } };
+    return {
+      status: 200,
+      body: {
+        sessions,
+        total: sessions.length,
+        limit: sessions.length,
+        offset: 0,
+        profile_totals: { default: sessions.length }
+      }
+    };
   }
   const sessionMatch = pathname.match(/^\/api\/sessions\/([^/]+)$/);
   if (method === "GET" && sessionMatch) {
@@ -77624,30 +77644,81 @@ async function handleHermesRest(method, pathname, config) {
     return { status: 200, body: { history: result.turns ?? [] } };
   }
   if (method === "GET" && pathname === "/api/status") {
-    const agents = await handleGetAgents(config);
-    const fleet = agents.map((a) => ({
-      name: a.name,
-      status: agentLiveness(config, a.name)
-    }));
     return {
       status: 200,
       body: {
-        status: "ok",
-        provider: "switchroom",
-        agents: fleet
+        version: "switchroom",
+        gateway_running: true,
+        gateway_platforms: {},
+        gateway_state: "ready",
+        config_version: 0,
+        latest_config_version: 0,
+        hermes_home: "switchroom",
+        release_date: null,
+        active_sessions: 0,
+        config_path: null,
+        env_path: null,
+        gateway_exit_reason: null,
+        gateway_health_url: null,
+        gateway_pid: null,
+        gateway_updated_at: null
       }
     };
   }
   if (method === "GET" && pathname === "/api/config") {
-    const agentNames = Object.keys(config.agents ?? {});
     return {
       status: 200,
       body: {
         provider: "switchroom",
-        agents: agentNames
+        model: null,
+        context_length: null,
+        system_prompt: null
+      }
+    };
+  }
+  if (method === "GET" && (pathname === "/api/config/defaults" || pathname === "/api/config/schema")) {
+    return { status: 200, body: {} };
+  }
+  if (method === "GET" && pathname === "/api/model/info") {
+    return {
+      status: 200,
+      body: {
+        model: "claude",
+        provider: "switchroom",
+        capabilities: {}
       }
     };
   }
+  if (method === "GET" && pathname.startsWith("/api/logs")) {
+    return { status: 200, body: { file: "gateway.log", lines: [] } };
+  }
+  if (method === "GET" && pathname.startsWith("/api/cron")) {
+    if (pathname === "/api/cron/jobs")
+      return { status: 200, body: [] };
+    if (pathname.includes("/runs"))
+      return { status: 200, body: { runs: [] } };
+    if (pathname.includes("sessions")) {
+      return { status: 200, body: { sessions: [], total: 0, limit: 0, offset: 0 } };
+    }
+    return { status: 200, body: {} };
+  }
+  if (method === "GET" && pathname.startsWith("/api/messaging")) {
+    if (pathname === "/api/messaging/platforms")
+      return { status: 200, body: { platforms: [] } };
+    return { status: 200, body: {} };
+  }
+  if (method === "GET" && pathname.startsWith("/api/profiles")) {
+    if (pathname.includes("sessions")) {
+      return { status: 200, body: { sessions: [], total: 0, limit: 0, offset: 0 } };
+    }
+    return { status: 200, body: {} };
+  }
+  if (method === "GET" && pathname === "/api/memory/providers") {
+    return { status: 200, body: {} };
+  }
+  if (method === "GET" && pathname === "/api/fs/default-cwd") {
+    return { status: 200, body: { cwd: null, branch: null } };
+  }
   return null;
 }
 function sendEvent(ctx, type, sessionId, payload) {
@@ -77806,9 +77877,13 @@ async function onHermesMessage(ctx, raw) {
         sendResponse(ctx, rpcErr(id, -32603, result.error ?? "inject failed"));
         break;
       }
+      sendEvent(ctx, "message.delta", sessionId, {
+        text: `*(Prompt sent to ${sessionId} \u2014 response will appear in Telegram)*`,
+        prompt_key: promptKey
+      });
       sendEvent(ctx, "message.complete", sessionId, {
-        prompt_key: promptKey,
-        note: "reply delivered to Telegram thread"
+        text: `*(Prompt sent to ${sessionId} \u2014 response will appear in Telegram)*`,
+        prompt_key: promptKey
       });
       sendResponse(ctx, rpcOk(id, { ok: true, prompt_key: promptKey }));
       break;
@@ -77834,6 +77909,14 @@ async function onHermesMessage(ctx, raw) {
       sendResponse(ctx, rpcOk(id, { ok: true }));
       break;
     }
+    case "setup.status": {
+      sendResponse(ctx, rpcOk(id, { provider_configured: true }));
+      break;
+    }
+    case "setup.runtime_check": {
+      sendResponse(ctx, rpcOk(id, { ok: true }));
+      break;
+    }
     case "approval.request":
     case "approval.respond":
     case "sudo.request":

package/dist/host-control/main.js

@@ -22587,7 +22587,7 @@ import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:f
 import { dirname as dirname4, join as join2 } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.16.15";
+var VERSION = "0.16.20";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.16.15",
+  "version": "0.16.20",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/answer-stream.ts

@@ -93,6 +93,24 @@ export interface AnswerStreamConfig {
   ) => Promise<unknown>
   deleteMessage?: (chatId: string, messageId: number) => Promise<unknown>
 
+  /**
+   * Render the raw assistant transcript text into the wire format used for
+   * `parse_mode: 'HTML'` sends/edits. Every OTHER outbound lane in the gateway
+   * (handleStreamReply, the reply handler, the turn-flush backstop, the PTY
+   * partial handler) converts markdown → Telegram HTML via
+   * `sanitizeTelegramHtml(markdownToHtml(...))` before sending. The
+   * answer-stream lane historically shipped the RAW transcript under
+   * `parse_mode: 'HTML'`, so `**bold**` reached the user as literal asterisks
+   * and agent narration read as unformatted text.
+   *
+   * Injected as a dependency (mirroring `renderText` on the PTY partial
+   * handler) rather than hard-importing `format`/`html-sanitize` here, so this
+   * module stays free of a grammy/format dependency and remains fully
+   * testable. When absent, text is sent verbatim — preserving the old
+   * behaviour for callers (and tests) that don't wire it.
+   */
+  renderText?: (text: string) => string
+
   /** Called when a late edit/send resolves but this stream has been superseded. */
   onSuperseded?: OnSupersededCallback
   log?: (msg: string) => void
@@ -179,6 +197,7 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
     replyToMessageId,
     sendMessage,
     editMessageText,
+    renderText,
     onSuperseded,
     log,
     warn,
@@ -188,6 +207,13 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
     recordOutbound,
   } = config
 
+  /**
+   * Convert raw transcript text to the wire format before any
+   * `parse_mode: 'HTML'` send/edit. Falls back to the verbatim text when no
+   * renderer is injected (old behaviour / unwired tests).
+   */
+  const render = (text: string): string => (renderText != null ? renderText(text) : text)
+
   const effectiveThrottle = Math.max(250, throttleMs)
 
   // Stream state
@@ -229,6 +255,10 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
   }
 
   async function sendOrEditViaMessage(trimmed: string, gen: number, prevText: string): Promise<void> {
+    // Convert raw transcript markdown → Telegram HTML before sending under
+    // parse_mode: 'HTML'. Without this, `**bold**` ships as literal asterisks
+    // (the answer-stream-raw-markdown bug). Mirrors every other outbound lane.
+    const rendered = render(trimmed)
     if (typeof streamMsgId === 'number') {
       // Edit existing message
       const editParams: Parameters<typeof editMessageText>[3] = {
@@ -237,7 +267,7 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
       }
       if (threadId != null) editParams.message_thread_id = threadId
       try {
-        await editMessageText(chatId, streamMsgId, trimmed, editParams)
+        await editMessageText(chatId, streamMsgId, rendered, editParams)
         onMetric?.({ kind: 'answer_lane_update', chatId, messageId: streamMsgId, charCount: trimmed.length, transport: 'edit' })
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err)
@@ -266,7 +296,7 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
       }
       if (threadId != null) sendParams.message_thread_id = threadId
       if (replyToMessageId != null) sendParams.reply_parameters = { message_id: replyToMessageId }
-      const sent = await sendMessage(chatId, trimmed, sendParams)
+      const sent = await sendMessage(chatId, rendered, sendParams)
       const sentId = sent?.message_id
       if (typeof sentId !== 'number' || !Number.isFinite(sentId)) {
         warn?.('answer-stream: sendMessage returned no message_id')
@@ -424,7 +454,11 @@ export function createAnswerStream(config: AnswerStreamConfig): AnswerStreamHand
       // nested quote that looks wrong.
 
       try {
-        const sent = await sendMessage(chatId, textToSend, sendParams)
+        // Render markdown → Telegram HTML for the wire send. The dedup /
+        // silent-marker / history checks above all run on the raw textToSend
+        // (so they match the comparisons the other lanes make on raw text);
+        // only the actual outbound payload is converted.
+        const sent = await sendMessage(chatId, render(textToSend), sendParams)
         const sentId = sent?.message_id
         if (typeof sentId === 'number' && Number.isFinite(sentId)) {
           streamMsgId = sentId