@meetquinn/animactl 0.1.1-canary.21.1.cd63d38

package/dist/server/tools/message-history-cli.js

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { messageServiceForAgent } from '../messages/message.service.js';
+import { resolveToolAgentId } from './tool-context.js';
+const MessageHistorySchema = z.object({
+    before: z.string().optional(),
+    limit: z.coerce.number().int().positive().optional(),
+    since: z.string().optional(),
+});
+export function registerMessageHistoryCommands(program) {
+    program
+        .command('inbox')
+        .description('Show recent messages and wakes received by this agent.')
+        .option('--limit <n>', 'max entries to return (default: 20; hard cap: 500)')
+        .option('--before <iso>', 'page older than this ISO timestamp')
+        .option('--since <iso>', 'only include entries at or after this ISO timestamp')
+        .action(async (_, command) => {
+        const opts = MessageHistorySchema.parse(command.optsWithGlobals());
+        await runMessageHistory('in', opts);
+    });
+    program
+        .command('outbox')
+        .description('Show recent Slack messages, files, and reactions sent by this agent.')
+        .option('--limit <n>', 'max entries to return (default: 20; hard cap: 500)')
+        .option('--before <iso>', 'page older than this ISO timestamp')
+        .option('--since <iso>', 'only include entries at or after this ISO timestamp')
+        .action(async (_, command) => {
+        const opts = MessageHistorySchema.parse(command.optsWithGlobals());
+        await runMessageHistory('out', opts);
+    });
+}
+async function runMessageHistory(direction, opts) {
+    const agentId = resolveToolAgentId({});
+    if (!agentId)
+        throw new Error(`${direction === 'in' ? 'inbox' : 'outbox'} requires current agent context`);
+    const page = await messageServiceForAgent(agentId).list({
+        direction,
+        ...normalizeTimeWindow(opts),
+        limit: opts.limit ?? 20,
+    });
+    const title = direction === 'in' ? 'Inbox' : 'Outbox';
+    if (page.entries.length === 0) {
+        console.log(`${title} is empty.`);
+        return;
+    }
+    console.log(`${title} (${page.entries.length} entr${page.entries.length === 1 ? 'y' : 'ies'}, newest first)`);
+    for (const entry of page.entries)
+        console.log(formatHistoryEntry(entry));
+    console.log(`[page has_more=${Boolean(page.nextCursor)} next_cursor=${page.nextCursor ?? '-'}]`);
+}
+function normalizeTimeWindow(opts) {
+    return {
+        ...(opts.before ? { before: normalizeIsoCursor(opts.before, '--before') } : {}),
+        ...(opts.since ? { since: normalizeIsoCursor(opts.since, '--since') } : {}),
+    };
+}
+function normalizeIsoCursor(value, flag) {
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()))
+        throw new Error(`${flag} must be an ISO timestamp`);
+    return date.toISOString();
+}
+function formatHistoryEntry(entry) {
+    const attrs = [`time=${entry.timestamp}`];
+    const surface = surfaceLabel(entry);
+    if (surface)
+        attrs.push(`channel=${surface}`);
+    if (entry.channelId && entry.channelId !== surface)
+        attrs.push(`channel_id=${entry.channelId}`);
+    if (entry.threadTs)
+        attrs.push(`thread_ts=${entry.threadTs}`);
+    if (entry.messageTs)
+        attrs.push(`message_ts=${entry.messageTs}`);
+    const lead = entry.direction === 'in' ? `${entry.actor ?? 'Unknown'}:` : `${outboxVerb(entry)}:`;
+    return `[${attrs.join(' ')}] ${lead} ${oneLineText(entry.text)}`;
+}
+function outboxVerb(entry) {
+    if (entry.kind === 'file')
+        return 'sent file';
+    if (entry.kind === 'reaction') {
+        const reaction = entry.reaction;
+        if (!reaction)
+            return 'reacted';
+        return `${reaction.action === 'removed' ? 'removed reaction' : 'reacted'} :${reaction.name}:`;
+    }
+    if (entry.kind === 'message' && entry.threadTs)
+        return 'replied';
+    return 'sent';
+}
+function surfaceLabel(entry) {
+    if (entry.dmHandle)
+        return `@${entry.dmHandle.replace(/^@/, '')}`;
+    if (entry.channelKind === 'dm') {
+        const raw = entry.channelDisplayName?.replace(/^DM with /i, '');
+        if (raw && raw !== entry.channelDisplayName)
+            return raw.startsWith('@') ? raw : `@${raw}`;
+        return entry.dmUserId ?? 'DM';
+    }
+    if (entry.channelName)
+        return `#${entry.channelName.replace(/^#/, '')}`;
+    if (entry.channelDisplayName)
+        return entry.channelDisplayName.startsWith('#')
+            ? entry.channelDisplayName
+            : `#${entry.channelDisplayName.replace(/^#/, '')}`;
+    return entry.channelId;
+}
+function oneLineText(text) {
+    const normalized = text.replace(/\r?\n/g, '\\n').trim();
+    if (normalized.length <= 1000)
+        return normalized;
+    return `${normalized.slice(0, 997)}...`;
+}

package/dist/server/tools/message-read.d.ts

@@ -0,0 +1,20 @@
+interface MessageGlobalInput {
+    agent?: string;
+    item?: string;
+}
+export interface MessageReadInput extends MessageGlobalInput {
+    after?: string;
+    around?: string;
+    before?: string;
+    channel?: string;
+    cursor?: string;
+    inclusive?: boolean;
+    json?: boolean;
+    latest?: string;
+    limit?: number;
+    oldest?: string;
+    threadTs?: string;
+}
+export declare function runMessageRead(opts: MessageReadInput): Promise<void>;
+export {};
+//# sourceMappingURL=message-read.d.ts.map

package/dist/server/tools/message-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-read.d.ts","sourceRoot":"","sources":["../../../server/tools/message-read.ts"],"names":[],"mappings":"AAyBA,UAAU,kBAAkB;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAiB,SAAQ,kBAAkB;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA4BD,wBAAsB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6B1E"}

package/dist/server/tools/message-read.js

@@ -0,0 +1,138 @@
+import { resolveSlackChannelArgument } from './slack-channel-resolver.js';
+import { slackTargetSummary, slackThreadSummary, } from './slack-target.js';
+import { resolveToolAgentId, slackWebClientForOpts, withToolActivity, } from './tool-context.js';
+import { slackTranscriptOutput, slackTranscriptUserLabels, } from './slack-transcript.js';
+export async function runMessageRead(opts) {
+    const threadTs = opts.threadTs;
+    const mode = threadTs ? 'replies' : 'history';
+    const request = await slackReadRequest({ ...opts, threadTs }, mode);
+    if (mode === 'replies' && !request.threadTs)
+        throw new Error('Missing --thread-ts');
+    await runSlackReadTool({
+        opts,
+        request,
+        tool: 'anima.message.read',
+        execute: () => mode === 'replies'
+            ? request.client.conversations.replies({
+                channel: request.channel,
+                ...(request.cursor ? { cursor: request.cursor } : {}),
+                ...(request.inclusive !== undefined ? { inclusive: request.inclusive } : {}),
+                ...(request.latest ? { latest: request.latest } : {}),
+                limit: request.limit,
+                ...(request.oldest ? { oldest: request.oldest } : {}),
+                ts: request.threadTs,
+            })
+            : request.client.conversations.history({
+                channel: request.channel,
+                ...(request.cursor ? { cursor: request.cursor } : {}),
+                ...(request.inclusive !== undefined ? { inclusive: request.inclusive } : {}),
+                ...(request.latest ? { latest: request.latest } : {}),
+                limit: request.limit,
+                ...(request.oldest ? { oldest: request.oldest } : {}),
+            }),
+    });
+}
+async function slackReadRequest(opts, mode) {
+    const { agent, client } = await slackWebClientForOpts(opts);
+    const teamId = agent.slack.teamId || undefined;
+    if (!opts.channel)
+        throw new Error('Missing --channel');
+    const channel = await resolveSlackChannelArgument({
+        channel: opts.channel,
+        client,
+        teamId,
+    });
+    const agentRangeSelectors = [opts.around, opts.before, opts.after].filter(Boolean);
+    if (agentRangeSelectors.length > 1) {
+        throw new Error('Pass only one of --around, --before, or --after');
+    }
+    if (agentRangeSelectors.length > 0 && (opts.latest || opts.oldest || opts.cursor)) {
+        throw new Error('Do not combine --around, --before, or --after with --oldest, --latest, or --cursor');
+    }
+    const latest = opts.latest ?? opts.around ?? opts.before;
+    const oldest = opts.oldest ?? opts.after;
+    const inclusive = opts.inclusive ?? (opts.around ? true : undefined);
+    const threadTs = opts.threadTs;
+    const limitDefault = mode === 'replies' ? 50 : 20;
+    const limit = Math.min(opts.limit ?? limitDefault, 200);
+    return {
+        ...(opts.after ? { after: opts.after } : {}),
+        ...(opts.around ? { around: opts.around } : {}),
+        ...(opts.before ? { before: opts.before } : {}),
+        channel: channel.id,
+        client,
+        ...(channel.name ? { channelName: channel.name } : {}),
+        ...('dmHandle' in channel && channel.dmHandle ? { dmHandle: channel.dmHandle } : {}),
+        ...('dmUserId' in channel && channel.dmUserId ? { dmUserId: channel.dmUserId } : {}),
+        ...(opts.cursor ? { cursor: opts.cursor } : {}),
+        ...(inclusive ? { inclusive } : {}),
+        ...(latest ? { latest } : {}),
+        limit,
+        ...(oldest ? { oldest } : {}),
+        ...(teamId ? { teamId } : {}),
+        ...(threadTs ? { threadTs } : {}),
+        ...(await slackTargetSummary({ channel, client, teamId })),
+    };
+}
+async function runSlackReadTool(input) {
+    const agentId = resolveToolAgentId(input.opts);
+    if (!agentId)
+        throw new Error('message read requires current agent context for audit');
+    const basePayload = slackReadActivityPayload(input.tool, input.request);
+    await withToolActivity({
+        audit: { agentId },
+        basePayload,
+        op: async () => {
+            const response = await input.execute();
+            const messages = slackMessagesWithTimestamps(response.messages);
+            const auth = await input.request.client.auth.test().catch(() => undefined);
+            const cacheTeamId = auth?.team_id ?? input.request.teamId;
+            const cacheContext = { ...(cacheTeamId ? { teamId: cacheTeamId } : {}) };
+            const userLabels = await slackTranscriptUserLabels(messages, input.request.client, cacheTeamId);
+            console.log(slackTranscriptOutput(messages, input.request, userLabels, {
+                hasMore: response.has_more ?? false,
+                nextCursor: response.response_metadata?.next_cursor ?? '',
+            }, cacheContext));
+            return {
+                result: undefined,
+                completedPayload: {
+                    hasMore: response.has_more ?? false,
+                    messageCount: messages.length,
+                    nextCursor: response.response_metadata?.next_cursor ?? '',
+                },
+            };
+        },
+    });
+}
+function slackReadActivityPayload(tool, request) {
+    return {
+        ...(request.after ? { after: request.after } : {}),
+        ...(request.around ? { around: request.around } : {}),
+        ...(request.before ? { before: request.before } : {}),
+        channel: request.channel,
+        ...slackReadOutputTarget(request),
+        ...(request.channelName ? { channelName: request.channelName } : {}),
+        ...(request.cursor ? { cursor: request.cursor } : {}),
+        ...(request.dmHandle ? { dmHandle: request.dmHandle } : {}),
+        ...(request.dmUserId ? { dmUserId: request.dmUserId } : {}),
+        ...(request.latest ? { latest: request.latest } : {}),
+        limit: request.limit,
+        ...(request.oldest ? { oldest: request.oldest } : {}),
+        ...(request.threadTs ? { threadTs: request.threadTs } : {}),
+        tool,
+    };
+}
+function slackReadOutputTarget(request) {
+    const target = {
+        channelDisplayName: request.channelDisplayName,
+        channelKind: request.channelKind,
+    };
+    return request.threadTs
+        ? { ...target, ...slackThreadSummary(target, request.threadTs) }
+        : target;
+}
+function slackMessagesWithTimestamps(messages) {
+    return (messages ?? [])
+        .filter((message) => typeof message.ts === 'string')
+        .map((message) => message);
+}

package/dist/server/tools/messages-cli.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function registerMessageCommands(program: Command): void;
+//# sourceMappingURL=messages-cli.d.ts.map

package/dist/server/tools/messages-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages-cli.d.ts","sourceRoot":"","sources":["../../../server/tools/messages-cli.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2CzC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA2E9D"}

package/dist/server/tools/messages-cli.js

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { runMessageRead } from './message-read.js';
+import { runMessageReact } from './reactions.js';
+import { runMessageSend, runMessageUpdate, } from './messages.js';
+const GlobalFlags = z.object({});
+const MessageReadSchema = GlobalFlags.extend({
+    after: z.string().optional(),
+    around: z.string().optional(),
+    before: z.string().optional(),
+    channel: z.string().optional(),
+    cursor: z.string().optional(),
+    inclusive: z.boolean().optional(),
+    latest: z.string().optional(),
+    limit: z.coerce.number().int().positive().optional(),
+    oldest: z.string().optional(),
+    threadTs: z.string().optional(),
+});
+const MessageSendSchema = GlobalFlags.extend({
+    channel: z.string().optional(),
+    threadTs: z.string().optional(),
+});
+const MessageUpdateSchema = GlobalFlags.extend({
+    channel: z.string().optional(),
+    messageTs: z.string().optional(),
+});
+const MessageReactSchema = GlobalFlags.extend({
+    channel: z.string().optional(),
+    emoji: z.string().optional(),
+    messageTs: z.string().optional(),
+    name: z.string().optional(),
+    remove: z.boolean().optional(),
+});
+export function registerMessageCommands(program) {
+    const message = program
+        .command('message')
+        .description('Read Slack messages and record Slack outputs');
+    // Input:   anima message read --channel <id> [--thread-ts <ts>] [--limit <n>]
+    //          [--around <ts> | --before <ts> | --after <ts>] [--oldest <ts>] [--latest <ts>]
+    //          [--cursor <c>] [--inclusive]
+    // Output:  multi-line transcript, oldest → newest, one line per Slack message:
+    //            [channel=<display> [channel_id=<id>] [thread_ts=<ts>] message_ts=<ts>
+    //             time=<iso> [user_id=<id>] [user_local_time=<local> user_tz=<tz>]] <actor>: <text>
+    //          File attachments append a trailing line:
+    //            attached: id=<id> name=<name> mimetype=<m> size_bytes=<n> (path=<local> | use anima file fetch <id>)
+    //          Pagination: [page has_more=<bool> next_cursor=<cursor|-}]
+    // Failure: human-readable error to stderr; exit 1.
+    message
+        .command('read')
+        .description('Read messages from a Slack channel or thread.')
+        .option('--channel <channel>', 'channel ID (e.g. C123ABC) or name (e.g. prod)\nDM: D-prefixed channel ID (e.g. D123ABC)')
+        .option('--thread-ts <ts>', 'read a thread; omit for the top-level channel')
+        .option('--limit <n>', 'max messages to return (default: 20 for channel, 50 for thread; hard cap: 200)')
+        .option('--around <ts>', 'window centered on ts (inclusive); cannot combine with --oldest/--latest/--cursor')
+        .option('--before <ts>', 'messages before ts (exclusive); cannot combine with --oldest/--latest/--cursor')
+        .option('--after <ts>', 'messages after ts (exclusive); cannot combine with --oldest/--latest/--cursor')
+        .option('--oldest <ts>', 'lower bound; cannot combine with --around/--before/--after')
+        .option('--latest <ts>', 'upper bound; cannot combine with --around/--before/--after')
+        .option('--inclusive', 'include messages at the --oldest/--latest boundaries')
+        .option('--cursor <cursor>', 'pagination: next_cursor value from a prior response\'s [page ...] line')
+        .action(async (_, command) => {
+        const opts = MessageReadSchema.parse(command.optsWithGlobals());
+        await runMessageRead(opts);
+    });
+    // Input:   anima message send --channel <id> [--thread-ts <ts>] < body (stdin)
+    // Output:  sent successfully. (channel=#<name> | dm=<handle>)[, thread_ts=<ts>], message_ts=<ts>.
+    // Failure: human-readable error to stderr; exit 1.
+    message
+        .command('send')
+        .description('Post a Slack message (top-level or in a thread).\nMessage body is read from stdin.')
+        .option('--channel <channel>', 'channel ID (e.g. C123ABC) or name (e.g. prod)\nDM: D-prefixed channel ID (e.g. D123ABC)')
+        .option('--thread-ts <ts>', 'reply inside this thread; omit to post top-level')
+        .action(async (_, command) => {
+        const opts = MessageSendSchema.parse(command.optsWithGlobals());
+        await runMessageSend(opts);
+    });
+    // Input:   anima message update --channel <id> --message-ts <ts> < body (stdin)
+    // Output:  updated successfully. (channel=#<name> | dm=<handle>), message_ts=<ts>.
+    // Failure: human-readable error to stderr; exit 1.
+    message
+        .command('update')
+        .description('Edit a previously sent message in place.\nNew message body is read from stdin.')
+        .option('--channel <channel>', 'channel ID (e.g. C123ABC) or name (e.g. prod)\nDM: D-prefixed channel ID (e.g. D123ABC)')
+        .option('--message-ts <ts>', 'timestamp of the message to update (from the send output)')
+        .action(async (_, command) => {
+        const opts = MessageUpdateSchema.parse(command.optsWithGlobals());
+        await runMessageUpdate(opts);
+    });
+    message
+        .command('react')
+        .description('Add a reaction emoji to a Slack message.')
+        .option('--channel <channel>', 'channel ID (e.g. C123ABC) or name (e.g. prod)\nDM: D-prefixed channel ID (e.g. D123ABC)')
+        .option('--message-ts <ts>', 'timestamp of the message to react to')
+        .option('--name <emoji>', 'emoji name without colons (e.g. white_check_mark, eyes)')
+        .option('--emoji <emoji>', 'alias for --name')
+        .option('--remove', 'remove the reaction instead of adding it')
+        .action(async (_, command) => {
+        const opts = MessageReactSchema.parse(command.optsWithGlobals());
+        await runMessageReact({
+            ...opts,
+            name: opts.name ?? opts.emoji,
+            remove: Boolean(opts.remove),
+        });
+    });
+}

package/dist/server/tools/messages.d.ts

@@ -0,0 +1,18 @@
+interface MessageGlobalInput {
+    agent?: string;
+    item?: string;
+}
+interface MessageSendInput extends MessageGlobalInput {
+    channel?: string;
+    text?: string;
+    threadTs?: string;
+}
+interface MessageUpdateInput extends MessageGlobalInput {
+    channel?: string;
+    messageTs?: string;
+    text?: string;
+}
+export declare function runMessageSend(opts: MessageSendInput): Promise<void>;
+export declare function runMessageUpdate(opts: MessageUpdateInput): Promise<void>;
+export {};
+//# sourceMappingURL=messages.d.ts.map

package/dist/server/tools/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../server/tools/messages.ts"],"names":[],"mappings":"AA4BA,UAAU,kBAAkB;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,UAAU,gBAAiB,SAAQ,kBAAkB;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,kBAAmB,SAAQ,kBAAkB;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAKD,wBAAsB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiF1E;AAED,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoE9E"}

package/dist/server/tools/messages.js

@@ -0,0 +1,188 @@
+import { ensureThreadSubscriptionForSentMessage, recordChannelPost, } from '../inbox/slack-subscription.service.js';
+import { resolveSlackChannelArgument } from './slack-channel-resolver.js';
+import { slackMessageContentForText } from './slack-message-format.js';
+import { mentionWarningsForTarget, slackTextForPostMessage, } from './slack-message-mentions.js';
+import { slackOutputTarget, slackTargetPayload, slackTargetSummary, slackThreadSummary, } from './slack-target.js';
+import { resolveToolAgentId, slackWebClientForOpts, withToolActivity, readStdin, } from './tool-context.js';
+export async function runMessageSend(opts) {
+    const text = await readStdin();
+    const agentId = resolveToolAgentId(opts);
+    if (!agentId)
+        throw new Error('message send requires current agent context for audit');
+    if (!opts.channel)
+        throw new Error('message send requires --channel');
+    const { agent, client } = await slackWebClientForOpts(opts);
+    const teamId = agent.slack.teamId || undefined;
+    const channel = await resolveSlackChannelArgument({
+        channel: opts.channel,
+        client,
+        teamId,
+    });
+    const threadTs = opts.threadTs;
+    const target = await slackTargetSummary({ channel, client, teamId });
+    const thread = threadTs ? slackThreadSummary(target, threadTs) : undefined;
+    const basePayload = {
+        ...slackTargetPayload(channel),
+        ...target,
+        ...(thread ? thread : {}),
+        ...(threadTs ? { threadTs } : {}),
+        tool: 'anima.message.send',
+    };
+    await withToolActivity({
+        audit: { agentId },
+        basePayload,
+        effectType: 'slack.message.send',
+        op: async () => {
+            const slackText = await slackTextForPostMessage({ client, teamId, text });
+            const content = slackMessageContentForText(slackText.text);
+            const warnings = await mentionWarningsForTarget({
+                channelId: channel.id,
+                client,
+                slackText,
+                target,
+                teamId,
+            });
+            const payload = {
+                ...(content.blocks ? { blocks: content.blocks } : {}),
+                channel: channel.id,
+                text: content.text,
+                ...(threadTs ? { thread_ts: threadTs } : {}),
+            };
+            const response = await client.chat.postMessage(payload);
+            const channelId = response.channel ?? channel.id;
+            const permalink = slackMessageRedirectLink({ channelId, messageTs: response.ts });
+            if (!channel.dmUserId && !threadTs) {
+                await recordChannelPost({ agentId, channelId });
+            }
+            const threadSubscription = channel.dmUserId || !response.ts
+                ? undefined
+                : await ensureThreadSubscriptionForSentMessage({
+                    agentId,
+                    channelId,
+                    messageTs: response.ts,
+                    ...(threadTs ? { threadTs } : {}),
+                });
+            console.log(slackOutputLine({
+                messageTs: response.ts,
+                status: 'sent',
+                target,
+                ...(thread ? { thread } : {}),
+                warnings,
+            }));
+            return {
+                result: undefined,
+                completedPayload: {
+                    payload,
+                    ...slackTextPayload(slackText, text),
+                    messageFormat: content.format,
+                    ...(content.blockCount ? { blockCount: content.blockCount } : {}),
+                    ...(permalink ? { permalink } : {}),
+                    ...(warnings.length ? { warnings } : {}),
+                    ...(threadSubscription ? { threadSubscription: subscriptionPayload(threadSubscription) } : {}),
+                    status: 'sent',
+                    text,
+                    ...(response.ts ? { ts: response.ts } : {}),
+                },
+            };
+        },
+    });
+}
+export async function runMessageUpdate(opts) {
+    const text = await readStdin();
+    const agentId = resolveToolAgentId(opts);
+    if (!agentId)
+        throw new Error('message update requires current agent context for audit');
+    if (!opts.channel)
+        throw new Error('message update requires --channel');
+    const targetTs = opts.messageTs;
+    if (!targetTs)
+        throw new Error('message update requires --message-ts');
+    const { agent, client } = await slackWebClientForOpts(opts);
+    const teamId = agent.slack.teamId || undefined;
+    const channel = await resolveSlackChannelArgument({
+        channel: opts.channel,
+        client,
+        teamId,
+    });
+    const target = await slackTargetSummary({ channel, client, teamId });
+    const basePayload = {
+        ...slackTargetPayload(channel),
+        ...target,
+        targetTs,
+        tool: 'anima.message.update',
+    };
+    await withToolActivity({
+        audit: { agentId },
+        basePayload,
+        effectType: 'slack.message.update',
+        op: async () => {
+            const slackText = await slackTextForPostMessage({ client, teamId, text });
+            const content = slackMessageContentForText(slackText.text);
+            const warnings = await mentionWarningsForTarget({
+                channelId: channel.id,
+                client,
+                slackText,
+                target,
+                teamId,
+            });
+            const payload = {
+                ...(content.blocks ? { blocks: content.blocks } : {}),
+                channel: channel.id,
+                text: content.text,
+                ts: targetTs,
+            };
+            const response = await client.chat.update(payload);
+            const responseTs = response.ts ?? targetTs;
+            const permalink = slackMessageRedirectLink({ channelId: channel.id, messageTs: responseTs });
+            console.log(slackOutputLine({
+                messageTs: responseTs,
+                status: 'updated',
+                target,
+                warnings,
+            }));
+            return {
+                result: undefined,
+                completedPayload: {
+                    payload,
+                    ...slackTextPayload(slackText, text),
+                    messageFormat: content.format,
+                    ...(content.blockCount ? { blockCount: content.blockCount } : {}),
+                    ...(permalink ? { permalink } : {}),
+                    ...(warnings.length ? { warnings } : {}),
+                    status: 'updated',
+                    text,
+                    ts: responseTs,
+                },
+            };
+        },
+    });
+}
+function subscriptionPayload(subscription) {
+    return {
+        subscriptionId: subscription.subscriptionId,
+        kind: subscription.kind,
+        ...(subscription.mutedAt ? { mutedAt: subscription.mutedAt } : {}),
+        ...(subscription.threadTs ? { threadTs: subscription.threadTs } : {}),
+    };
+}
+function slackTextPayload(slackText, originalText) {
+    return {
+        ...(slackText.resolved.length > 0 ? { resolvedMentions: slackText.resolved } : {}),
+        ...(slackText.text !== originalText ? { slackText: slackText.text } : {}),
+        ...(slackText.unresolved.length > 0 ? { unresolvedMentions: slackText.unresolved } : {}),
+    };
+}
+function slackMessageRedirectLink(input) {
+    if (!input.messageTs)
+        return undefined;
+    return `https://slack.com/app_redirect?channel=${encodeURIComponent(input.channelId)}&message_ts=${encodeURIComponent(input.messageTs)}`;
+}
+function slackOutputLine(input) {
+    const parts = [slackOutputTarget(input.target)];
+    if (input.thread)
+        parts.push(`thread_ts=${input.thread.threadTs}`);
+    if (input.messageTs)
+        parts.push(`message_ts=${input.messageTs}`);
+    const warning = input.warnings?.length ? ` Warning: ${input.warnings.join(' ')}` : '';
+    return `${input.status} successfully. ${parts.join(', ')}.${warning}`;
+}

package/dist/server/tools/reactions-cli.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function registerReactionCommands(program: Command): void;
+//# sourceMappingURL=reactions-cli.d.ts.map

package/dist/server/tools/reactions-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactions-cli.d.ts","sourceRoot":"","sources":["../../../server/tools/reactions-cli.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAezC,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiD/D"}