claude-slack-channel-bots 0.18.3 → 0.18.4

package/docs/bots.md

@@ -141,6 +141,8 @@ A message from Slack carries these tag attributes:
 | `thread_ts` | The thread's timestamp, for a thread reply. |
 | `attachment_count`, `attachments` | The number of attached files and each file's name, type and size, when files are attached. |
 
+A long `attachments` or `user` value can be cut short, ending in `…`; on a macOS host this happens sooner, and a long `channel_name` can be cut too. `chat_id` and `attachment_count` are always whole.
+
 Each way a message reaches a persona:
 
 | Kind | How it reaches the persona | Tag attributes | `via` | Reminder |

package/docs/troubleshooting.md

@@ -74,6 +74,9 @@ Each start logs one `[slack] startupSessionManager: complete — …` line count
 **Delivery notices or delivery diagnostic lines**
 For *Message not saved*, check the server disk; for *Delivery stuck* or *Message not taken in*, follow the notice's remedy; for *Messages waiting*, resolve the persona's state; for *Queue record unreadable*, preserve its file and ask the senders to resend. Accepted messages stay queued in order, including when [`message-partial-receipt`](../skills/debug-slack-channel-bots/SKILL.md#message-partial-receipt) reports cut-off text. [Full entry](../skills/debug-slack-channel-bots/SKILL.md#symptom-delivery-notices-or-delivery-diagnostic-lines).
 
+**A persona on a Mac keeps retyping a long message**
+On a macOS host CSCB types a long message in parts of at most about 880 bytes each. A message queued before an upgrade can keep larger parts, and a restart does not split it again: CSCB keeps offering it until the bot takes it in, while later messages wait. [Full entry](../skills/debug-slack-channel-bots/SKILL.md#symptom-a-persona-on-a-mac-keeps-retyping-a-long-message).
+
 **A persona posts a *Waiting on a prompt* or *Not connected* notice**
 The session runs but is disconnected; accepted messages are kept until it reconnects. A human attaches with `tmux attach -t =slack_bot_<key>`, deals with anything on screen and, if it stays disconnected, types `/mcp reconnect slack-channel-router`, or restarts the server. [Full entry](../skills/debug-slack-channel-bots/SKILL.md#symptom-a-persona-posts-a-waiting-on-a-prompt-or-not-connected-notice).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-slack-channel-bots",
-  "version": "0.18.3",
+  "version": "0.18.4",
   "description": "Run several Claude Code personas, each its own Slack app, from one server via Socket Mode",
   "type": "module",
   "bin": {

package/skills/debug-slack-channel-bots/SKILL.md

@@ -498,7 +498,7 @@ no recovery outcome. See [Message saved after retry](#message-saved-after-retry)
 - **Line:** `[slack] message-retyped: persona="<name>" (key=<key>) source=<source> chat_id="<chat>" ts="<ts>" sender_id="<sender>" retype_count=<n>`
 - **Meaning:** CSCB offered the queued message again; it may reach the bot more than once.
 - **Cause:** The transcript has not confirmed the earlier copy.
-- **Fix:** Check **Message not taken in** and **Delivery stuck** below if it persists. Retries continue indefinitely; later messages wait behind it.
+- **Fix:** Check **Message not taken in** and **Delivery stuck** below if it persists. Retries continue indefinitely; later messages wait behind it. For a long message on a Mac host, see [A persona on a Mac keeps retyping a long message](#symptom-a-persona-on-a-mac-keeps-retyping-a-long-message).
 
 ### `message-not-taken-in`
 
@@ -7250,6 +7250,12 @@ and [Persona diagnostic classes](#persona-diagnostic-classes). Storage failures
 a disk check; stuck delivery needs the notice's remedy; waiting messages need the
 persona's hold or down state resolved. Accepted items remain queued in order.
 
+### Symptom: A persona on a Mac keeps retyping a long message
+
+Claude Code on macOS loses typed input sent as one large burst, so on a macOS host CSCB types a long message as several parts of at most about 880 bytes each, tag included; on other hosts a part can reach about 1,900 bytes. On a Mac, long attachment lists, sender names and channel names in the tag are shortened sooner, each ending in `…`; the channel ID and the attachment count are kept whole.
+
+CSCB sets a message's parts once, shortly after it is queued, and never changes them; restarting the bot or the server does not split it again. A message queued before an upgrade can therefore keep its larger parts, go on logging `message-retyped` and raise a *Message not taken in* or *Delivery stuck* notice while later messages wait behind it. CSCB keeps offering it until the bot takes it in. [Delivery notices](#delivery-notices) explains each notice and how to attach to the bot's terminal to see what it received.
+
 ### Symptom: A persona posts a *Waiting on a prompt* or *Not connected* notice
 
 The persona's session runs but is disconnected. Messages sent to it are kept and delivered once it reconnects. What each notice means and what to do: the notice table under [A persona's instance runs but isn't connected](#a-personas-instance-runs-but-isnt-connected).

package/src/delivery-intake.ts

@@ -1,7 +1,7 @@
 /** Post-accept immutable fixation shared by fresh and recovered work. */
 import type { WebClient } from '@slack/web-api'
 import type { DeliveryQueue, QueueAccept, QueueItem, QueueEvent } from './delivery-queue.ts'
-import { buildTagParts, NAME_LOOKUP_TIMEOUT_MS, type TagMessage } from './tag-wrapper.ts'
+import { buildTagParts, NAME_LOOKUP_TIMEOUT_MS, TAG_MAX_BYTES, type TagMessage } from './tag-wrapper.ts'
 import { sanitizeFilename } from './lib.ts'
 import { RETYPE_BACKOFF_MS } from './delivery-constants.ts'
 export interface DeliveryPreparationClock {
@@ -20,6 +20,8 @@ export interface DeliveryPreparationDeps {
   /** Called only from post-ack/answer preparation or startup recovery. */
   onReceived?(key: string, item: QueueItem): void
   lookupTimeoutMs?: number
+  /** Byte limit for each fixed part; production binds the host's `tagMaxBytesFor`. */
+  tagMaxBytes?: number
   clock?: DeliveryPreparationClock
   retryBackoffMs?: readonly number[]
 }
@@ -40,6 +42,7 @@ export function createDeliveryPreparation(deps: DeliveryPreparationDeps): Delive
   const fixedParts = new Map<string, string[]>()
   let stopped = false
   const timeout = deps.lookupTimeoutMs ?? NAME_LOOKUP_TIMEOUT_MS
+  const tagMaxBytes = deps.tagMaxBytes ?? TAG_MAX_BYTES
   const clock: DeliveryPreparationClock = deps.clock ?? {
     setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
     clearTimeout: handle => globalThis.clearTimeout(handle as ReturnType<typeof globalThis.setTimeout>),
@@ -91,7 +94,7 @@ export function createDeliveryPreparation(deps: DeliveryPreparationDeps): Delive
             message.attachments = a.files.map(f => `${sanitizeFilename(f.name || 'unnamed')} (${f.mimetype || 'unknown'}, ${f.size || '?'} bytes)`).join('; ')
           }
         }
-        parts = buildTagParts(message)
+        parts = buildTagParts(message, tagMaxBytes)
         fixedParts.set(id, parts)
       }
       await deps.queue.append(key, { v: 1, kind: 'fixed', seq: a.seq, parts })

package/src/server.ts

@@ -208,6 +208,7 @@ import { createPersonaRouting } from './persona-routing.ts'
 import { createDeliveryQueue, type ReplyReminderQueue, type QueueEvent } from './delivery-queue.ts'
 import { createReplyReminders, type ReplyReminders } from './reply-reminder.ts'
 import { createDeliveryPreparation, type DeliveryPreparation } from './delivery-intake.ts'
+import { tagMaxBytesFor } from './tag-wrapper.ts'
 import {
   createPersonaConnectionManager,
   SYSTEM_PERSONA_CONNECTION_CLOCK,
@@ -2717,6 +2718,7 @@ export async function main(): Promise<void> {
     clientFor,
     wake: key => deliveryQueueWake.wake(key),
     onPending: key => deliveryEngines?.wake(key),
+    tagMaxBytes: tagMaxBytesFor(process.platform),
   })
 
   // the retired-key record (retired-keys.json in the

package/src/tag-wrapper.ts

@@ -1,5 +1,7 @@
 /** Deterministic typed tags, with no I/O or module state. */
 export const TAG_MAX_BYTES = 1900
+/** Claude Code on macOS loses a typed burst over about 900 bytes, wrapper included. */
+export const TAG_MAX_BYTES_MACOS = 880
 export const TAG_MIN_BODY_BYTES = 400
 export const NAME_LOOKUP_TIMEOUT_MS = 2000
 export const TAG_SOURCE = 'slack-channel-router'
@@ -44,6 +46,8 @@ export function escapeBody(value: string): string {
   return out.replace(/[\u0301\u0308\u2028]/g, c => `&#${c.codePointAt(0)};`)
 }
 export function tagByteLength(value: string): number { return new TextEncoder().encode(value).byteLength }
+/** The typed part limit for the host the agent runs on, which is the server's own host. */
+export function tagMaxBytesFor(platform: string): number { return platform === 'darwin' ? TAG_MAX_BYTES_MACOS : TAG_MAX_BYTES }
 function render(attrs: TagAttributes, body: string, part?: string): string {
   const values = { ...attrs, part }
   const attributes = TAG_ATTRIBUTE_ORDER.flatMap(key => values[key] === undefined || values[key] === '' ? [] : [`${key}="${escapeAttr(values[key])}"`])
@@ -51,10 +55,11 @@ function render(attrs: TagAttributes, body: string, part?: string): string {
 }
 /** Unsized reference formatter, useful for wrapper.py parity. */
 export function buildWrapper(message: TagMessage): string { return render(message, escapeBody(message.text ?? ''), message.part) }
-function boundedAttrs(input: TagAttributes, part?: string): TagAttributes {
+function boundedAttrs(input: TagAttributes, maxBytes: number, part?: string): TagAttributes {
   const attrs = { ...input }
-  for (const key of ['attachments', 'user'] as const) {
-    if (tagByteLength(render(attrs, '', part)) <= TAG_MAX_BYTES - TAG_MIN_BODY_BYTES) break
+  const allowance = maxBytes - TAG_MIN_BODY_BYTES
+  for (const key of ['attachments', 'user', 'channel_name'] as const) {
+    if (tagByteLength(render(attrs, '', part)) <= allowance) break
     const original = attrs[key]
     if (original === undefined || original === '') continue
     const chars = Array.from(replaceLoneSurrogates(original))
@@ -62,12 +67,12 @@ function boundedAttrs(input: TagAttributes, part?: string): TagAttributes {
     while (low < high) {
       const mid = Math.ceil((low + high) / 2)
       attrs[key] = chars.slice(0, mid).join('') + '…'
-      if (tagByteLength(render(attrs, '', part)) <= TAG_MAX_BYTES - TAG_MIN_BODY_BYTES) low = mid
+      if (tagByteLength(render(attrs, '', part)) <= allowance) low = mid
       else high = mid - 1
     }
     attrs[key] = chars.slice(0, low).join('') + '…'
   }
-  if (tagByteLength(render(attrs, '', part)) > TAG_MAX_BYTES - TAG_MIN_BODY_BYTES) throw new Error('Tag attributes exceed the minimum body allowance')
+  if (tagByteLength(render(attrs, '', part)) > allowance) throw new Error('Tag attributes exceed the minimum body allowance')
   return attrs
 }
 function cutBody(body: string, budget: number): [string, string] {
@@ -82,15 +87,15 @@ function cutBody(body: string, budget: number): [string, string] {
   return [body.slice(0, cut), body.slice(cut)]
 }
 /** Escape once, then split losslessly, accounting for the widest part index. */
-export function buildTagParts(message: TagMessage): string[] {
+export function buildTagParts(message: TagMessage, maxBytes: number = TAG_MAX_BYTES): string[] {
   const body = escapeBody(message.text ?? '')
-  const singleAttrs = boundedAttrs(message)
-  if (tagByteLength(render(singleAttrs, body)) <= TAG_MAX_BYTES) return [render(singleAttrs, body)]
+  const singleAttrs = boundedAttrs(message, maxBytes)
+  if (tagByteLength(render(singleAttrs, body)) <= maxBytes) return [render(singleAttrs, body)]
   let count = 2
   for (;;) {
     const widest = `${count}/${count}`
-    const attrs = boundedAttrs(message, widest)
-    const budget = TAG_MAX_BYTES - tagByteLength(render(attrs, '', widest))
+    const attrs = boundedAttrs(message, maxBytes, widest)
+    const budget = maxBytes - tagByteLength(render(attrs, '', widest))
     const bodies: string[] = []
     let remaining = body
     do { const [part, rest] = cutBody(remaining, budget); bodies.push(part); remaining = rest } while (remaining !== '')