@letta-ai/letta-code 0.22.0 → 0.22.1

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.22.0",
+    version: "0.22.1",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -48585,13 +48585,22 @@ function createTelegramAdapter(config) {
       await bot.init();
       const info = bot.botInfo;
       console.log(`[Telegram] Bot started as @${info.username} (dm_policy: ${config.dmPolicy})`);
-      bot.start({
-        onStart: () => {
-          running = true;
-        }
-      }).catch((error) => {
-        running = false;
-        console.error("[Telegram] Long-polling stopped unexpectedly:", error);
+      await new Promise((resolve2, reject) => {
+        let started = false;
+        bot.start({
+          onStart: () => {
+            running = true;
+            started = true;
+            resolve2();
+          }
+        }).catch((error) => {
+          running = false;
+          if (!started) {
+            reject(error);
+            return;
+          }
+          console.error("[Telegram] Long-polling stopped unexpectedly:", error);
+        });
       });
     },
     async stop() {
@@ -48635,12 +48644,16 @@ __export(exports_registry, {
   initializeChannels: () => initializeChannels,
   getChannelRegistry: () => getChannelRegistry,
   getActiveChannelIds: () => getActiveChannelIds,
+  ensureChannelRegistry: () => ensureChannelRegistry,
   completePairing: () => completePairing,
   ChannelRegistry: () => ChannelRegistry
 });
 function getChannelRegistry() {
   return instance;
 }
+function ensureChannelRegistry() {
+  return instance ?? new ChannelRegistry;
+}
 function getActiveChannelIds() {
   if (!instance)
     return [];
@@ -48651,6 +48664,7 @@ class ChannelRegistry {
   adapters = new Map;
   ready = false;
   messageHandler = null;
+  eventHandler = null;
   buffer = [];
   constructor() {
     if (instance) {
@@ -48673,6 +48687,9 @@ class ChannelRegistry {
   setMessageHandler(handler) {
     this.messageHandler = handler;
   }
+  setEventHandler(handler) {
+    this.eventHandler = handler;
+  }
   setReady() {
     this.ready = true;
     this.flushBuffer();
@@ -48683,6 +48700,39 @@ class ChannelRegistry {
   getRoute(channel, chatId) {
     return getRoute(channel, chatId);
   }
+  async startChannel(channelId) {
+    const config = readChannelConfig(channelId);
+    if (!config) {
+      return false;
+    }
+    loadRoutes(channelId);
+    loadPairingStore(channelId);
+    const existing = this.adapters.get(channelId);
+    if (existing?.isRunning()) {
+      await existing.stop();
+    }
+    this.adapters.delete(channelId);
+    if (channelId === "telegram") {
+      const { createTelegramAdapter: createTelegramAdapter2 } = await Promise.resolve().then(() => (init_adapter(), exports_adapter));
+      const adapter = createTelegramAdapter2(config);
+      this.registerAdapter(adapter);
+      await adapter.start();
+      return true;
+    }
+    console.error(`Unknown channel "${channelId}". Supported: telegram`);
+    return false;
+  }
+  async stopChannel(channelId) {
+    const adapter = this.adapters.get(channelId);
+    if (!adapter) {
+      return false;
+    }
+    if (adapter.isRunning()) {
+      await adapter.stop();
+    }
+    this.adapters.delete(channelId);
+    return true;
+  }
   async startAll() {
     for (const adapter of Array.from(this.adapters.values())) {
       if (!adapter.isRunning()) {
@@ -48693,6 +48743,7 @@ class ChannelRegistry {
   pause() {
     this.ready = false;
     this.messageHandler = null;
+    this.eventHandler = null;
   }
   async stopAll() {
     for (const adapter of Array.from(this.adapters.values())) {
@@ -48702,6 +48753,7 @@ class ChannelRegistry {
     }
     this.ready = false;
     this.messageHandler = null;
+    this.eventHandler = null;
     instance = null;
   }
   async handleInboundMessage(msg) {
@@ -48722,11 +48774,15 @@ class ChannelRegistry {
       }
       if (!isUserApproved(msg.channel, msg.senderId)) {
         const code = createPairingCode(msg.channel, msg.senderId, msg.chatId, msg.senderName);
+        this.eventHandler?.({
+          type: "pairings_updated",
+          channelId: msg.channel
+        });
         await adapter.sendDirectReply(msg.chatId, `To connect this chat to a Letta Code agent, run:
 
-` + `/channels telegram pair ${code}
+/channels telegram pair ${code}
 
-` + `This code expires in 15 minutes.`);
+This code expires in 15 minutes.`);
         return;
       }
     }
@@ -48736,7 +48792,7 @@ class ChannelRegistry {
       route = getRoute(msg.channel, msg.chatId);
     }
     if (!route) {
-      await adapter.sendDirectReply(msg.chatId, `This chat isn't bound to an agent. ` + `Run \`/channels telegram enable --chat-id ${msg.chatId}\` ` + `on your Letta Code agent to connect.`);
+      await adapter.sendDirectReply(msg.chatId, `This chat isn't bound to an agent. Run \`/channels telegram enable --chat-id ${msg.chatId}\` on your Letta Code agent to connect.`);
       return;
     }
     const xmlContent = formatChannelNotification(msg);
@@ -48758,7 +48814,7 @@ class ChannelRegistry {
   }
 }
 async function initializeChannels(channelNames) {
-  const registry = new ChannelRegistry;
+  const registry = ensureChannelRegistry();
   for (const channelId of channelNames) {
     const config = readChannelConfig(channelId);
     if (!config) {
@@ -48769,17 +48825,8 @@ async function initializeChannels(channelNames) {
       console.log(`Channel "${channelId}" is disabled in config, skipping.`);
       continue;
     }
-    loadRoutes(channelId);
-    loadPairingStore(channelId);
-    if (channelId === "telegram") {
-      const { createTelegramAdapter: createTelegramAdapter2 } = await Promise.resolve().then(() => (init_adapter(), exports_adapter));
-      const adapter = createTelegramAdapter2(config);
-      registry.registerAdapter(adapter);
-    } else {
-      console.error(`Unknown channel: "${channelId}". Supported: telegram`);
-    }
+    await registry.startChannel(channelId);
   }
-  await registry.startAll();
   return registry;
 }
 function completePairing(channelId, code, agentId, conversationId) {
@@ -94145,6 +94192,67 @@ function isSetReflectionSettingsCommand(value) {
   const settings = c.settings;
   return (settings.trigger === "off" || settings.trigger === "step-count" || settings.trigger === "compaction-event") && typeof settings.step_count === "number" && Number.isInteger(settings.step_count) && settings.step_count > 0 && (c.scope === undefined || c.scope === "local_project" || c.scope === "global" || c.scope === "both");
 }
+function isChannelId(value) {
+  return value === "telegram";
+}
+function isChannelsListCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "channels_list" && typeof c.request_id === "string";
+}
+function isChannelGetConfigCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "channel_get_config" && typeof c.request_id === "string" && isChannelId(c.channel_id);
+}
+function isChannelSetConfigCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  if (c.type !== "channel_set_config" || typeof c.request_id !== "string" || !isChannelId(c.channel_id) || !c.config || typeof c.config !== "object") {
+    return false;
+  }
+  const config = c.config;
+  return (config.token === undefined || typeof config.token === "string") && (config.dm_policy === undefined || config.dm_policy === "pairing" || config.dm_policy === "allowlist" || config.dm_policy === "open") && (config.allowed_users === undefined || Array.isArray(config.allowed_users) && config.allowed_users.every((entry) => typeof entry === "string"));
+}
+function isChannelStartCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "channel_start" && typeof c.request_id === "string" && isChannelId(c.channel_id);
+}
+function isChannelStopCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "channel_stop" && typeof c.request_id === "string" && isChannelId(c.channel_id);
+}
+function isChannelPairingsListCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "channel_pairings_list" && typeof c.request_id === "string" && isChannelId(c.channel_id);
+}
+function isChannelPairingBindCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "channel_pairing_bind" && typeof c.request_id === "string" && isChannelId(c.channel_id) && isRuntimeScope(c.runtime) && typeof c.code === "string" && c.code.length > 0;
+}
+function isChannelRoutesListCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "channel_routes_list" && typeof c.request_id === "string" && (c.channel_id === undefined || isChannelId(c.channel_id)) && (c.agent_id === undefined || typeof c.agent_id === "string") && (c.conversation_id === undefined || typeof c.conversation_id === "string");
+}
+function isChannelRouteRemoveCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "channel_route_remove" && typeof c.request_id === "string" && isChannelId(c.channel_id) && typeof c.chat_id === "string" && c.chat_id.length > 0;
+}
 function isSearchBranchesCommand(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -94168,7 +94276,7 @@ function parseServerMessage(data) {
   try {
     const raw = typeof data === "string" ? data : data.toString();
     const parsed = JSON.parse(raw);
-    if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed) || isSearchFilesCommand(parsed) || isListInDirectoryCommand(parsed) || isReadFileCommand(parsed) || isWriteFileCommand(parsed) || isWatchFileCommand(parsed) || isUnwatchFileCommand(parsed) || isEditFileCommand(parsed) || isListMemoryCommand(parsed) || isMemoryHistoryCommand(parsed) || isMemoryFileAtRefCommand(parsed) || isEnableMemfsCommand(parsed) || isListModelsCommand(parsed) || isUpdateModelCommand(parsed) || isCronListCommand(parsed) || isCronAddCommand(parsed) || isCronGetCommand(parsed) || isCronDeleteCommand(parsed) || isCronDeleteAllCommand(parsed) || isSkillEnableCommand(parsed) || isSkillDisableCommand(parsed) || isCreateAgentCommand(parsed) || isGetReflectionSettingsCommand(parsed) || isSetReflectionSettingsCommand(parsed) || isExecuteCommandCommand(parsed) || isSearchBranchesCommand(parsed) || isCheckoutBranchCommand(parsed)) {
+    if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed) || isSearchFilesCommand(parsed) || isListInDirectoryCommand(parsed) || isReadFileCommand(parsed) || isWriteFileCommand(parsed) || isWatchFileCommand(parsed) || isUnwatchFileCommand(parsed) || isEditFileCommand(parsed) || isListMemoryCommand(parsed) || isMemoryHistoryCommand(parsed) || isMemoryFileAtRefCommand(parsed) || isEnableMemfsCommand(parsed) || isListModelsCommand(parsed) || isUpdateModelCommand(parsed) || isCronListCommand(parsed) || isCronAddCommand(parsed) || isCronGetCommand(parsed) || isCronDeleteCommand(parsed) || isCronDeleteAllCommand(parsed) || isSkillEnableCommand(parsed) || isSkillDisableCommand(parsed) || isCreateAgentCommand(parsed) || isGetReflectionSettingsCommand(parsed) || isSetReflectionSettingsCommand(parsed) || isChannelsListCommand(parsed) || isChannelGetConfigCommand(parsed) || isChannelSetConfigCommand(parsed) || isChannelStartCommand(parsed) || isChannelStopCommand(parsed) || isChannelPairingsListCommand(parsed) || isChannelPairingBindCommand(parsed) || isChannelRoutesListCommand(parsed) || isChannelRouteRemoveCommand(parsed) || isExecuteCommandCommand(parsed) || isSearchBranchesCommand(parsed) || isCheckoutBranchCommand(parsed)) {
       return parsed;
     }
     const invalidInput = getInvalidInputReason(parsed);
@@ -94189,6 +94297,201 @@ var init_protocol_inbound = __esm(async () => {
   await init_approval();
 });
 
+// src/channels/service.ts
+var exports_service = {};
+__export(exports_service, {
+  stopChannelLive: () => stopChannelLive,
+  startChannelLive: () => startChannelLive,
+  setChannelConfigLive: () => setChannelConfigLive,
+  removeChannelRouteLive: () => removeChannelRouteLive,
+  listPendingPairingSnapshots: () => listPendingPairingSnapshots,
+  listChannelSummaries: () => listChannelSummaries,
+  listChannelRouteSnapshots: () => listChannelRouteSnapshots,
+  getChannelConfigSnapshot: () => getChannelConfigSnapshot,
+  bindChannelPairing: () => bindChannelPairing,
+  CHANNEL_DISPLAY_NAMES: () => CHANNEL_DISPLAY_NAMES
+});
+function assertSupportedChannelId(channelId) {
+  if (channelId !== "telegram") {
+    throw new Error(`Unsupported channel: ${channelId}`);
+  }
+}
+function toConfigSnapshot(channelId, config) {
+  return {
+    channelId,
+    enabled: config.enabled,
+    dmPolicy: config.dmPolicy,
+    allowedUsers: [...config.allowedUsers],
+    hasToken: config.token.trim().length > 0
+  };
+}
+function toPendingPairingSnapshot(pending) {
+  return {
+    code: pending.code,
+    senderId: pending.telegramUserId,
+    senderName: pending.telegramUsername,
+    chatId: pending.chatId,
+    createdAt: pending.createdAt,
+    expiresAt: pending.expiresAt
+  };
+}
+function toRouteSnapshot(channelId, route) {
+  return {
+    channelId,
+    chatId: route.chatId,
+    agentId: route.agentId,
+    conversationId: route.conversationId,
+    enabled: route.enabled,
+    createdAt: route.createdAt
+  };
+}
+function listChannelSummaries() {
+  const registry = getChannelRegistry();
+  const channelId = "telegram";
+  const config = readChannelConfig(channelId);
+  if (!config) {
+    return [
+      {
+        channelId,
+        displayName: CHANNEL_DISPLAY_NAMES[channelId],
+        configured: false,
+        enabled: false,
+        running: false,
+        dmPolicy: null,
+        pendingPairingsCount: 0,
+        approvedUsersCount: 0,
+        routesCount: 0
+      }
+    ];
+  }
+  loadRoutes(channelId);
+  loadPairingStore(channelId);
+  return [
+    {
+      channelId,
+      displayName: CHANNEL_DISPLAY_NAMES[channelId],
+      configured: true,
+      enabled: config.enabled,
+      running: registry?.getAdapter(channelId)?.isRunning() ?? false,
+      dmPolicy: config.dmPolicy,
+      pendingPairingsCount: getPendingPairings(channelId).length,
+      approvedUsersCount: getApprovedUsers(channelId).length,
+      routesCount: getRoutesForChannel(channelId).length
+    }
+  ];
+}
+function getChannelConfigSnapshot(channelId) {
+  assertSupportedChannelId(channelId);
+  const config = readChannelConfig(channelId);
+  if (!config) {
+    return null;
+  }
+  return toConfigSnapshot(channelId, config);
+}
+async function setChannelConfigLive(channelId, patch) {
+  assertSupportedChannelId(channelId);
+  const existing = readChannelConfig(channelId);
+  const merged = {
+    channel: "telegram",
+    enabled: existing?.enabled ?? false,
+    token: patch.token ?? existing?.token ?? "",
+    dmPolicy: patch.dmPolicy ?? existing?.dmPolicy ?? "pairing",
+    allowedUsers: patch.allowedUsers ?? existing?.allowedUsers ?? []
+  };
+  writeChannelConfig(channelId, merged);
+  if (merged.enabled) {
+    const registry = ensureChannelRegistry();
+    await registry.startChannel(channelId);
+  }
+  return toConfigSnapshot(channelId, merged);
+}
+async function startChannelLive(channelId) {
+  assertSupportedChannelId(channelId);
+  const existing = readChannelConfig(channelId);
+  if (!existing) {
+    throw new Error(`Channel "${channelId}" is not configured. Configure it first.`);
+  }
+  if (!existing.token.trim()) {
+    throw new Error(`Channel "${channelId}" is missing a token. Configure it first.`);
+  }
+  if (!existing.enabled) {
+    writeChannelConfig(channelId, {
+      ...existing,
+      enabled: true
+    });
+  }
+  if (!getChannelRegistry()) {
+    await initializeChannels([channelId]);
+  } else {
+    await ensureChannelRegistry().startChannel(channelId);
+  }
+  const summary = listChannelSummaries().find((entry) => entry.channelId === channelId);
+  if (!summary) {
+    throw new Error(`Channel "${channelId}" summary not found after start`);
+  }
+  return summary;
+}
+async function stopChannelLive(channelId) {
+  assertSupportedChannelId(channelId);
+  const existing = readChannelConfig(channelId);
+  if (!existing) {
+    throw new Error(`Channel "${channelId}" is not configured. Configure it first.`);
+  }
+  writeChannelConfig(channelId, {
+    ...existing,
+    enabled: false
+  });
+  await getChannelRegistry()?.stopChannel(channelId);
+  const summary = listChannelSummaries().find((entry) => entry.channelId === channelId);
+  if (!summary) {
+    throw new Error(`Channel "${channelId}" summary not found after stop`);
+  }
+  return summary;
+}
+function listPendingPairingSnapshots(channelId) {
+  assertSupportedChannelId(channelId);
+  loadPairingStore(channelId);
+  return getPendingPairings(channelId).map(toPendingPairingSnapshot);
+}
+function bindChannelPairing(channelId, code, agentId, conversationId) {
+  assertSupportedChannelId(channelId);
+  loadRoutes(channelId);
+  loadPairingStore(channelId);
+  const result = completePairing(channelId, code, agentId, conversationId);
+  if (!result.success || !result.chatId) {
+    throw new Error(result.error ?? "Failed to bind pairing");
+  }
+  const route = getRoute(channelId, result.chatId);
+  if (!route) {
+    throw new Error("Pairing succeeded but route was not found");
+  }
+  return {
+    chatId: result.chatId,
+    route: toRouteSnapshot(channelId, route)
+  };
+}
+function listChannelRouteSnapshots(params) {
+  const channelId = params?.channelId ?? "telegram";
+  assertSupportedChannelId(channelId);
+  loadRoutes(channelId);
+  return getRoutesForChannel(channelId).filter((route) => params?.agentId ? route.agentId === params.agentId : true).filter((route) => params?.conversationId ? route.conversationId === params.conversationId : true).map((route) => toRouteSnapshot(channelId, route));
+}
+function removeChannelRouteLive(channelId, chatId) {
+  assertSupportedChannelId(channelId);
+  loadRoutes(channelId);
+  return removeRoute(channelId, chatId);
+}
+var CHANNEL_DISPLAY_NAMES;
+var init_service = __esm(() => {
+  init_config();
+  init_pairing();
+  init_registry();
+  init_routing();
+  CHANNEL_DISPLAY_NAMES = {
+    telegram: "Telegram"
+  };
+});
+
 // src/agent/memoryScanner.ts
 var exports_memoryScanner = {};
 __export(exports_memoryScanner, {
@@ -94562,6 +94865,29 @@ function emitCronsUpdated(socket, scope) {
     ...scope?.conversation_id !== undefined ? { conversation_id: scope.conversation_id } : {}
   }, "listener_cron_send_failed", "listener_cron_command");
 }
+function emitChannelsUpdated(socket, channelId) {
+  safeSocketSend(socket, {
+    type: "channels_updated",
+    timestamp: Date.now(),
+    ...channelId ? { channel_id: channelId } : {}
+  }, "listener_channels_send_failed", "listener_channels_command");
+}
+function emitChannelPairingsUpdated(socket, channelId) {
+  safeSocketSend(socket, {
+    type: "channel_pairings_updated",
+    timestamp: Date.now(),
+    channel_id: channelId
+  }, "listener_channels_send_failed", "listener_channels_command");
+}
+function emitChannelRoutesUpdated(socket, params) {
+  safeSocketSend(socket, {
+    type: "channel_routes_updated",
+    timestamp: Date.now(),
+    channel_id: params.channelId,
+    ...params.agentId ? { agent_id: params.agentId } : {},
+    ...params.conversationId !== undefined ? { conversation_id: params.conversationId } : {}
+  }, "listener_channels_send_failed", "listener_channels_command");
+}
 async function handleCronCommand(parsed, socket) {
   if (parsed.type === "cron_list") {
     try {
@@ -94699,6 +95025,299 @@ async function handleCronCommand(parsed, socket) {
   }
   return true;
 }
+async function handleChannelsProtocolCommand(parsed, socket, runtime, opts, processQueuedTurn) {
+  const {
+    bindChannelPairing: bindChannelPairing2,
+    getChannelConfigSnapshot: getChannelConfigSnapshot2,
+    listChannelRouteSnapshots: listChannelRouteSnapshots2,
+    listChannelSummaries: listChannelSummaries2,
+    listPendingPairingSnapshots: listPendingPairingSnapshots2,
+    removeChannelRouteLive: removeChannelRouteLive2,
+    setChannelConfigLive: setChannelConfigLive2,
+    startChannelLive: startChannelLive2,
+    stopChannelLive: stopChannelLive2
+  } = await Promise.resolve().then(() => (init_service(), exports_service));
+  if (parsed.type === "channels_list") {
+    try {
+      safeSocketSend(socket, {
+        type: "channels_list_response",
+        request_id: parsed.request_id,
+        success: true,
+        channels: listChannelSummaries2().map((summary) => ({
+          channel_id: summary.channelId,
+          display_name: summary.displayName,
+          configured: summary.configured,
+          enabled: summary.enabled,
+          running: summary.running,
+          dm_policy: summary.dmPolicy,
+          pending_pairings_count: summary.pendingPairingsCount,
+          approved_users_count: summary.approvedUsersCount,
+          routes_count: summary.routesCount
+        }))
+      }, "listener_channels_send_failed", "listener_channels_command");
+    } catch (err) {
+      safeSocketSend(socket, {
+        type: "channels_list_response",
+        request_id: parsed.request_id,
+        success: false,
+        channels: [],
+        error: err instanceof Error ? err.message : "Failed to list channels"
+      }, "listener_channels_send_failed", "listener_channels_command");
+    }
+    return true;
+  }
+  if (parsed.type === "channel_get_config") {
+    try {
+      safeSocketSend(socket, {
+        type: "channel_get_config_response",
+        request_id: parsed.request_id,
+        success: true,
+        config: (() => {
+          const snapshot = getChannelConfigSnapshot2(parsed.channel_id);
+          return snapshot ? {
+            channel_id: snapshot.channelId,
+            enabled: snapshot.enabled,
+            dm_policy: snapshot.dmPolicy,
+            allowed_users: snapshot.allowedUsers,
+            has_token: snapshot.hasToken
+          } : null;
+        })()
+      }, "listener_channels_send_failed", "listener_channels_command");
+    } catch (err) {
+      safeSocketSend(socket, {
+        type: "channel_get_config_response",
+        request_id: parsed.request_id,
+        success: false,
+        config: null,
+        error: err instanceof Error ? err.message : "Failed to read channel config"
+      }, "listener_channels_send_failed", "listener_channels_command");
+    }
+    return true;
+  }
+  if (parsed.type === "channel_set_config") {
+    try {
+      const snapshot = await setChannelConfigLive2(parsed.channel_id, {
+        token: parsed.config.token,
+        dmPolicy: parsed.config.dm_policy,
+        allowedUsers: parsed.config.allowed_users
+      });
+      if (snapshot.enabled) {
+        wireChannelIngress(runtime, socket, opts, processQueuedTurn);
+      }
+      safeSocketSend(socket, {
+        type: "channel_set_config_response",
+        request_id: parsed.request_id,
+        success: true,
+        config: {
+          channel_id: snapshot.channelId,
+          enabled: snapshot.enabled,
+          dm_policy: snapshot.dmPolicy,
+          allowed_users: snapshot.allowedUsers,
+          has_token: snapshot.hasToken
+        }
+      }, "listener_channels_send_failed", "listener_channels_command");
+      emitChannelsUpdated(socket, parsed.channel_id);
+    } catch (err) {
+      safeSocketSend(socket, {
+        type: "channel_set_config_response",
+        request_id: parsed.request_id,
+        success: false,
+        config: null,
+        error: err instanceof Error ? err.message : "Failed to update channel config"
+      }, "listener_channels_send_failed", "listener_channels_command");
+    }
+    return true;
+  }
+  if (parsed.type === "channel_start") {
+    try {
+      const summary = await startChannelLive2(parsed.channel_id);
+      wireChannelIngress(runtime, socket, opts, processQueuedTurn);
+      safeSocketSend(socket, {
+        type: "channel_start_response",
+        request_id: parsed.request_id,
+        success: true,
+        channel: {
+          channel_id: summary.channelId,
+          display_name: summary.displayName,
+          configured: summary.configured,
+          enabled: summary.enabled,
+          running: summary.running,
+          dm_policy: summary.dmPolicy,
+          pending_pairings_count: summary.pendingPairingsCount,
+          approved_users_count: summary.approvedUsersCount,
+          routes_count: summary.routesCount
+        }
+      }, "listener_channels_send_failed", "listener_channels_command");
+      emitChannelsUpdated(socket, parsed.channel_id);
+    } catch (err) {
+      safeSocketSend(socket, {
+        type: "channel_start_response",
+        request_id: parsed.request_id,
+        success: false,
+        channel: null,
+        error: err instanceof Error ? err.message : "Failed to start channel"
+      }, "listener_channels_send_failed", "listener_channels_command");
+    }
+    return true;
+  }
+  if (parsed.type === "channel_stop") {
+    try {
+      const summary = await stopChannelLive2(parsed.channel_id);
+      safeSocketSend(socket, {
+        type: "channel_stop_response",
+        request_id: parsed.request_id,
+        success: true,
+        channel: {
+          channel_id: summary.channelId,
+          display_name: summary.displayName,
+          configured: summary.configured,
+          enabled: summary.enabled,
+          running: summary.running,
+          dm_policy: summary.dmPolicy,
+          pending_pairings_count: summary.pendingPairingsCount,
+          approved_users_count: summary.approvedUsersCount,
+          routes_count: summary.routesCount
+        }
+      }, "listener_channels_send_failed", "listener_channels_command");
+      emitChannelsUpdated(socket, parsed.channel_id);
+    } catch (err) {
+      safeSocketSend(socket, {
+        type: "channel_stop_response",
+        request_id: parsed.request_id,
+        success: false,
+        channel: null,
+        error: err instanceof Error ? err.message : "Failed to stop channel"
+      }, "listener_channels_send_failed", "listener_channels_command");
+    }
+    return true;
+  }
+  if (parsed.type === "channel_pairings_list") {
+    try {
+      safeSocketSend(socket, {
+        type: "channel_pairings_list_response",
+        request_id: parsed.request_id,
+        success: true,
+        channel_id: parsed.channel_id,
+        pending: listPendingPairingSnapshots2(parsed.channel_id).map((pending) => ({
+          code: pending.code,
+          sender_id: pending.senderId,
+          sender_name: pending.senderName,
+          chat_id: pending.chatId,
+          created_at: pending.createdAt,
+          expires_at: pending.expiresAt
+        }))
+      }, "listener_channels_send_failed", "listener_channels_command");
+    } catch (err) {
+      safeSocketSend(socket, {
+        type: "channel_pairings_list_response",
+        request_id: parsed.request_id,
+        success: false,
+        channel_id: parsed.channel_id,
+        pending: [],
+        error: err instanceof Error ? err.message : "Failed to list pending pairings"
+      }, "listener_channels_send_failed", "listener_channels_command");
+    }
+    return true;
+  }
+  if (parsed.type === "channel_pairing_bind") {
+    try {
+      const result = bindChannelPairing2(parsed.channel_id, parsed.code, parsed.runtime.agent_id, parsed.runtime.conversation_id);
+      safeSocketSend(socket, {
+        type: "channel_pairing_bind_response",
+        request_id: parsed.request_id,
+        success: true,
+        channel_id: parsed.channel_id,
+        chat_id: result.chatId,
+        route: {
+          channel_id: result.route.channelId,
+          chat_id: result.route.chatId,
+          agent_id: result.route.agentId,
+          conversation_id: result.route.conversationId,
+          enabled: result.route.enabled,
+          created_at: result.route.createdAt
+        }
+      }, "listener_channels_send_failed", "listener_channels_command");
+      emitChannelPairingsUpdated(socket, parsed.channel_id);
+      emitChannelRoutesUpdated(socket, {
+        channelId: parsed.channel_id,
+        agentId: parsed.runtime.agent_id,
+        conversationId: parsed.runtime.conversation_id
+      });
+      emitChannelsUpdated(socket, parsed.channel_id);
+    } catch (err) {
+      safeSocketSend(socket, {
+        type: "channel_pairing_bind_response",
+        request_id: parsed.request_id,
+        success: false,
+        channel_id: parsed.channel_id,
+        route: null,
+        error: err instanceof Error ? err.message : "Failed to bind pairing"
+      }, "listener_channels_send_failed", "listener_channels_command");
+    }
+    return true;
+  }
+  if (parsed.type === "channel_routes_list") {
+    try {
+      const channelId = parsed.channel_id ?? "telegram";
+      safeSocketSend(socket, {
+        type: "channel_routes_list_response",
+        request_id: parsed.request_id,
+        success: true,
+        channel_id: channelId,
+        routes: listChannelRouteSnapshots2({
+          channelId,
+          agentId: parsed.agent_id,
+          conversationId: parsed.conversation_id
+        }).map((route) => ({
+          channel_id: route.channelId,
+          chat_id: route.chatId,
+          agent_id: route.agentId,
+          conversation_id: route.conversationId,
+          enabled: route.enabled,
+          created_at: route.createdAt
+        }))
+      }, "listener_channels_send_failed", "listener_channels_command");
+    } catch (err) {
+      safeSocketSend(socket, {
+        type: "channel_routes_list_response",
+        request_id: parsed.request_id,
+        success: false,
+        channel_id: parsed.channel_id,
+        routes: [],
+        error: err instanceof Error ? err.message : "Failed to list routes"
+      }, "listener_channels_send_failed", "listener_channels_command");
+    }
+    return true;
+  }
+  try {
+    const found = removeChannelRouteLive2(parsed.channel_id, parsed.chat_id);
+    safeSocketSend(socket, {
+      type: "channel_route_remove_response",
+      request_id: parsed.request_id,
+      success: true,
+      channel_id: parsed.channel_id,
+      chat_id: parsed.chat_id,
+      found
+    }, "listener_channels_send_failed", "listener_channels_command");
+    if (found) {
+      emitChannelRoutesUpdated(socket, {
+        channelId: parsed.channel_id
+      });
+      emitChannelsUpdated(socket, parsed.channel_id);
+    }
+  } catch (err) {
+    safeSocketSend(socket, {
+      type: "channel_route_remove_response",
+      request_id: parsed.request_id,
+      success: false,
+      channel_id: parsed.channel_id,
+      chat_id: parsed.chat_id,
+      found: false,
+      error: err instanceof Error ? err.message : "Failed to remove route"
+    }, "listener_channels_send_failed", "listener_channels_command");
+  }
+  return true;
+}
 function emitSkillsUpdated(socket) {
   safeSocketSend(socket, {
     type: "skills_updated",
@@ -94958,6 +95577,12 @@ function wireChannelIngress(listener, socket, opts, processQueuedTurn) {
     enqueueChannelTurn(conversationRuntime, route, xmlContent);
     scheduleQueuePump(conversationRuntime, socket, opts, processQueuedTurn);
   });
+  registry.setEventHandler((event) => {
+    if (event.type === "pairings_updated") {
+      emitChannelPairingsUpdated(socket, event.channelId);
+      emitChannelsUpdated(socket, event.channelId);
+    }
+  });
   registry.setReady();
 }
 function enqueueChannelTurn(runtime, route, xmlContent) {
@@ -96196,6 +96821,12 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         });
         return;
       }
+      if (isChannelsListCommand(parsed) || isChannelGetConfigCommand(parsed) || isChannelSetConfigCommand(parsed) || isChannelStartCommand(parsed) || isChannelStopCommand(parsed) || isChannelPairingsListCommand(parsed) || isChannelPairingBindCommand(parsed) || isChannelRoutesListCommand(parsed) || isChannelRouteRemoveCommand(parsed)) {
+        runDetachedListenerTask("channels_command", async () => {
+          await handleChannelsProtocolCommand(parsed, socket, runtime, opts, processQueuedTurn);
+        });
+        return;
+      }
       if (isSkillEnableCommand(parsed) || isSkillDisableCommand(parsed)) {
         runDetachedListenerTask("skill_command", async () => {
           await handleSkillCommand(parsed, socket);
@@ -96696,6 +97327,7 @@ var init_client4 = __esm(async () => {
     handleAbortMessageInput,
     handleChangeDeviceStateInput,
     handleCronCommand,
+    handleChannelsProtocolCommand,
     handleSkillCommand,
     handleCreateAgentCommand,
     handleReflectionSettingsCommand,
@@ -165182,4 +165814,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=CB456D0ECB3C77E564756E2164756E21
+//# debugId=25D3963E52DABC3164756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {