typeclaw 0.22.0 → 0.24.0

package/src/channels/adapters/slack-bot.ts

@@ -18,6 +18,7 @@ import type { ChannelRouter } from '@/channels/router'
 import type { ChannelAdapterConfig } from '@/channels/schema'
 import type {
   ChannelHistoryMessage,
+  ChannelSelfIdentityResolver,
   FetchAttachmentCallback,
   FetchHistoryArgs,
   FetchHistoryResult,
@@ -42,6 +43,7 @@ import {
   type SlackInboundMessageEvent,
 } from './slack-bot-classify'
 import { createSlackDedupe } from './slack-bot-dedupe'
+import { enrichSlackReferenceContext } from './slack-bot-reference'
 import {
   buildSlashAckPayload,
   commandResultReply,
@@ -260,6 +262,7 @@ export type SlackBotAdapterOptions = {
   // classifier behaves as before (no alias-driven thread anchoring), so
   // tests and ad-hoc adapter constructions stay backwards-compatible.
   selfAliasesRef?: () => readonly string[]
+  fetchImpl?: typeof fetch
 }
 
 export type SlackBotAdapter = {
@@ -350,18 +353,23 @@ export function createTypingCallback(deps: {
   const { typingTracker, logger, formatChannelTag } = deps
   return async (target: TypingTarget): Promise<void> => {
     if (target.adapter !== 'slack-bot') return
+    // DMs are flat (thread null) but setStatus still needs a real message ts;
+    // `typingThread` carries the inbound ts for exactly that case. Real channel
+    // threads keep using `thread`. Either way the status is keyed on one ts.
+    const statusThread =
+      target.typingThread !== undefined && target.typingThread !== '' ? target.typingThread : target.thread
     const tag = formatChannelTag
-      ? await formatChannelTag(target.workspace, target.thread ?? target.chat)
-      : `channel=${target.thread ?? target.chat}`
-    if (target.thread === undefined || target.thread === null || target.thread === '') {
+      ? await formatChannelTag(target.workspace, statusThread ?? target.chat)
+      : `channel=${statusThread ?? target.chat}`
+    if (statusThread === undefined || statusThread === null || statusThread === '') {
       if (target.phase === 'tick') logger.info(`[slack-bot] typing (no-op, top-level chat) ${tag}`)
       return
     }
     if (target.phase === 'stop') {
-      await typingTracker.clearAfterSend(target.chat, target.thread)
+      await typingTracker.clearAfterSend(target.chat, statusThread)
       return
     }
-    await typingTracker.setStatus(target.chat, target.thread, 'is typing...')
+    await typingTracker.setStatus(target.chat, statusThread, 'is typing...')
   }
 }
 
@@ -822,7 +830,7 @@ export function createOutboundCallback(deps: {
           // top-level posts.
           if (threadTs === null && chunks.length > 1) threadTs = sent.ts
         }
-        if (typingTracker) await typingTracker.clearAfterSend(msg.chat, msg.thread)
+        if (typingTracker) await typingTracker.clearAfterSend(msg.chat, msg.typingThread ?? msg.thread)
         return { ok: true }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err)
@@ -855,7 +863,7 @@ export function createOutboundCallback(deps: {
         return { ok: false, error: `uploadFile failed: ${message}` }
       }
     }
-    if (typingTracker) await typingTracker.clearAfterSend(msg.chat, msg.thread)
+    if (typingTracker) await typingTracker.clearAfterSend(msg.chat, msg.typingThread ?? msg.thread)
     return { ok: true }
   }
 }
@@ -896,9 +904,46 @@ export function createFetchAttachmentCallback(deps: {
   }
 }
 
+function createSlackReferenceFetch(deps: { token: string; fetchImpl: typeof fetch }) {
+  return async (channelId: string, messageTs: string) => {
+    const url = new URL('https://slack.com/api/conversations.replies')
+    url.searchParams.set('channel', channelId)
+    url.searchParams.set('ts', messageTs)
+    url.searchParams.set('limit', '1')
+    const response = await deps.fetchImpl(url, { headers: { Authorization: `Bearer ${deps.token}` } })
+    if (!response.ok) return null
+    const body = recordValue(await response.json())
+    if (body === null || body.ok !== true) return null
+    const messages = arrayField(body, 'messages')
+    const first = recordValue(messages[0])
+    if (first === null) return null
+    const authorId = stringField(first, 'user') ?? stringField(first, 'bot_id')
+    const text = stringField(first, 'text')
+    if (authorId === null || text === null) return null
+    return { authorId, authorName: authorId, text }
+  }
+}
+
+function recordValue(value: unknown): Record<string, unknown> | null {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null
+}
+
+function arrayField(record: Record<string, unknown>, key: string): readonly unknown[] {
+  const value = record[key]
+  return Array.isArray(value) ? value : []
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key]
+  return typeof value === 'string' && value.length > 0 ? value : null
+}
+
 export function createSlackBotAdapter(options: SlackBotAdapterOptions): SlackBotAdapter {
   const logger = options.logger ?? consoleLogger
   const client = new SlackBotClient()
+  const fetchImpl = options.fetchImpl ?? fetch
   let listener: SlackBotListener | null = null
   let botUserId: string | null = null
   let teamId: string | null = null
@@ -909,6 +954,11 @@ export function createSlackBotAdapter(options: SlackBotAdapterOptions): SlackBot
   const authorResolver = createSlackAuthorResolver({ token: options.token })
   const channelResolver = createSlackChannelResolver({ token: options.token })
 
+  // Slack mentions by id (`<@U…>`), so no username form. Read live off the
+  // closure so a reconnect re-running auth.test stays reflected; one team
+  // per token in practice, so `workspace` is ignored.
+  const selfIdentityResolver: ChannelSelfIdentityResolver = () => (botUserId !== null ? { id: botUserId } : null)
+
   const formatChannelTag = async (workspace: string, chat: string): Promise<string> => {
     const names = await channelResolver({ adapter: 'slack-bot', workspace, chat, thread: null }).catch(
       () => ({}) as ResolvedChannelNames,
@@ -1047,7 +1097,22 @@ export function createSlackBotAdapter(options: SlackBotAdapterOptions): SlackBot
       }
 
       dedupe.mark(event)
-      const enriched = { ...verdict.payload, authorName: resolvedUserName }
+      const slackAttachments = Array.isArray(event.attachments) ? event.attachments : undefined
+      const referenceResult = await enrichSlackReferenceContext({
+        text: verdict.payload.text,
+        channelId: event.channel,
+        ...(event.thread_ts !== undefined ? { threadTs: event.thread_ts } : {}),
+        messageTs: event.ts,
+        ...(slackAttachments !== undefined ? { attachments: slackAttachments } : {}),
+        fetchMessage: createSlackReferenceFetch({ token: options.token, fetchImpl }),
+      })
+      const enriched = {
+        ...verdict.payload,
+        authorName: resolvedUserName,
+        ...(referenceResult.referenceContext !== undefined
+          ? { referenceContext: referenceResult.referenceContext }
+          : {}),
+      }
       const routedTag = await formatChannelTag(enriched.workspace, enriched.chat)
       logger.info(
         `[slack-bot] routed ts=${event.ts} ${routedTag} mention=${enriched.isBotMention} reply=${enriched.replyToBotMessageId !== null}`,
@@ -1143,6 +1208,7 @@ export function createSlackBotAdapter(options: SlackBotAdapterOptions): SlackBot
       options.router.registerOutbound('slack-bot', outboundCallback)
       options.router.registerTyping('slack-bot', typingCallback)
       options.router.registerChannelNameResolver('slack-bot', channelResolver)
+      options.router.registerSelfIdentity('slack-bot', selfIdentityResolver)
       options.router.registerHistory('slack-bot', historyCallback)
       options.router.registerFetchAttachment('slack-bot', fetchAttachmentCallback)
       options.router.registerMembership('slack-bot', membershipResolver)
@@ -1162,6 +1228,7 @@ export function createSlackBotAdapter(options: SlackBotAdapterOptions): SlackBot
       options.router.unregisterOutbound('slack-bot', outboundCallback)
       options.router.unregisterTyping('slack-bot', typingCallback)
       options.router.unregisterChannelNameResolver('slack-bot', channelResolver)
+      options.router.unregisterSelfIdentity('slack-bot', selfIdentityResolver)
       options.router.unregisterHistory('slack-bot', historyCallback)
       options.router.unregisterFetchAttachment('slack-bot', fetchAttachmentCallback)
       options.router.unregisterMembership('slack-bot', membershipResolver)

package/src/channels/adapters/telegram-bot.ts

@@ -6,6 +6,7 @@ import type { ChannelRouter } from '@/channels/router'
 import type { ChannelAdapterConfig } from '@/channels/schema'
 import type {
   ChannelNameResolver,
+  ChannelSelfIdentityResolver,
   FetchAttachmentCallback,
   OutboundCallback,
   OutboundMessage,
@@ -384,6 +385,13 @@ export function createTelegramBotAdapter(options: TelegramBotAdapterOptions): Te
 
   const channelResolver = createChannelNameResolver({ client })
 
+  // Telegram addresses by `@username`, not by the numeric id, so surface
+  // `username` when the bot has one; the id is kept for completeness.
+  const selfIdentityResolver: ChannelSelfIdentityResolver = () =>
+    botUser !== null
+      ? { id: String(botUser.id), ...(botUser.username !== undefined ? { username: botUser.username } : {}) }
+      : null
+
   const formatChannelTag = async (chat: string): Promise<string> => {
     const names = await channelResolver({
       adapter: 'telegram-bot',
@@ -522,6 +530,7 @@ export function createTelegramBotAdapter(options: TelegramBotAdapterOptions): Te
       options.router.registerOutbound('telegram-bot', outboundCallback)
       options.router.registerTyping('telegram-bot', typingCallback)
       options.router.registerChannelNameResolver('telegram-bot', channelResolver)
+      options.router.registerSelfIdentity('telegram-bot', selfIdentityResolver)
       options.router.registerFetchAttachment('telegram-bot', fetchAttachmentCallback)
       options.router.registerMembership('telegram-bot', membershipResolver)
 
@@ -529,6 +538,7 @@ export function createTelegramBotAdapter(options: TelegramBotAdapterOptions): Te
         options.router.unregisterOutbound('telegram-bot', outboundCallback)
         options.router.unregisterTyping('telegram-bot', typingCallback)
         options.router.unregisterChannelNameResolver('telegram-bot', channelResolver)
+        options.router.unregisterSelfIdentity('telegram-bot', selfIdentityResolver)
         options.router.unregisterFetchAttachment('telegram-bot', fetchAttachmentCallback)
         options.router.unregisterMembership('telegram-bot', membershipResolver)
         listener?.stop()
@@ -556,6 +566,7 @@ export function createTelegramBotAdapter(options: TelegramBotAdapterOptions): Te
       options.router.unregisterOutbound('telegram-bot', outboundCallback)
       options.router.unregisterTyping('telegram-bot', typingCallback)
       options.router.unregisterChannelNameResolver('telegram-bot', channelResolver)
+      options.router.unregisterSelfIdentity('telegram-bot', selfIdentityResolver)
       options.router.unregisterFetchAttachment('telegram-bot', fetchAttachmentCallback)
       options.router.unregisterMembership('telegram-bot', membershipResolver)
       // Stop the listener BEFORE waiting for inflight handlers. The SDK's

package/src/channels/manager.ts

@@ -13,7 +13,13 @@ import { createKakaotalkAdapter, type KakaotalkAdapter } from './adapters/kakaot
 import { createSlackBotAdapter, type SlackBotAdapter } from './adapters/slack-bot'
 import { createTelegramBotAdapter, type TelegramBotAdapter } from './adapters/telegram-bot'
 import type { GithubTokenBridge } from './github-token-bridge'
-import { createChannelRouter, type ChannelRouter, type ClaimHandler, type CreateSessionForChannel } from './router'
+import {
+  createChannelRouter,
+  type ChannelRouter,
+  type ClaimHandler,
+  type CreateSessionForChannel,
+  type RestartCommandContext,
+} from './router'
 import {
   ADAPTER_IDS,
   type AdapterId,
@@ -94,7 +100,7 @@ export type ChannelManagerOptions = {
   // container-restart bindings; tests omit them so the commands stay
   // unregistered. See CreateChannelRouterOptions.onReload/onRestart.
   onReload?: () => Promise<string>
-  onRestart?: () => Promise<string>
+  onRestart?: (ctx?: RestartCommandContext) => Promise<string>
 }
 
 export type ChannelManager = {