Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

8.1 KB
Raw Blame
import { WebClient } from "@slack/web-api";
import type { LoopItem, LoopSourcePayload } from "../../types.ts";
import { normalizeSlackApiUrl } from "../../slack/config.ts";
import { SLACK_POST_SPLIT_LIMIT } from "../../slack/delivery.ts";
import { neutralizeMentions, wireMentionKeys } from "../../slack/mrkdwn.ts";
import { agentDraftsOf } from "../item-ledger.ts";
import { safeChunks } from "../../slack/safe-cut.ts";
import { applyReactions, normalizeReaction } from "../../slack/reactions.ts";
import { slackErrorCode } from "../../slack/payloads.ts";
import { errMessage } from "../../util/errors.ts";
import {
  clip,
  clipOpt,
  draftOf,
  isObj,
  parseCommonFields,
  parseReplyDraft,
  tokenFor,
  type LoopSourceAdapter,
  type ParsedEntry,
  type ReplyDraft,
  type SlackUserClient,
  type SourceActionDeps,
  type SourceActionResult,
} from "./adapter.ts";

const SLACK_HOST = "slack.com";

interface SlackMeta {
  channelId: string;
  channelLabel?: string;
  ts: string;
  threadTs?: string;
  isDirectMessage?: boolean;
  userId?: string;
}

function parseSlackMeta(v: unknown): SlackMeta | undefined {
  if (!isObj(v)) return undefined;
  const channelId = clip(v.channelId, 60);
  const ts = clip(v.ts, 40);
  if (!channelId || !ts) return undefined;
  const channelLabel = clipOpt(v.channelLabel, 120);
  const threadTs = clipOpt(v.threadTs, 40);
  const userId = clipOpt(v.userId, 40);
  return {
    channelId,
    ts,
    ...(channelLabel ? { channelLabel } : {}),
    ...(threadTs ? { threadTs } : {}),
    ...(userId ? { userId } : {}),
    ...(typeof v.isDirectMessage === "boolean" ? { isDirectMessage: v.isDirectMessage } : {}),
  };
}

function metaOf(item: LoopItem): SlackMeta | undefined {
  return parseSlackMeta(item.sourcePayload?.slack);
}

export function slackConversationRef(
  channelId: string,
  ts: string,
  threadTs: string | undefined,
  isDirectMessage: boolean,
): string {
  return isDirectMessage && !threadTs ? channelId : `${channelId}:${threadTs ?? ts}`;
}

export function slackReplyThreadTs(item: LoopItem): string | undefined {
  const slack = metaOf(item);
  if (!slack) return undefined;
  return slack.threadTs ?? (slack.isDirectMessage ? undefined : slack.ts);
}

function itemReactions(item: LoopItem): string[] {
  const raw = item.sourcePayload?.reactions;
  return Array.isArray(raw) ? raw.filter((name): name is string => typeof name === "string") : [];
}

export function slackUserClientFactory(apiUrl?: string): (token: string) => SlackUserClient {
  const options = {
    attachOriginalToWebAPIRequestError: false,
    ...(apiUrl ? { slackApiUrl: normalizeSlackApiUrl(apiUrl) } : {}),
  };
  return (token) => new WebClient(token, options);
}

const defaultSlackClient = slackUserClientFactory();

async function clientAsUser(deps: SourceActionDeps): Promise<SlackUserClient | null> {
  const token = await tokenFor(deps.tokens, SLACK_HOST, deps.owner);
  if (!token) return null;
  return (deps.slackClient ?? defaultSlackClient)(token);
}

const notConnected: SourceActionResult = {
  ok: false,
  reason: "not_connected",
  message: "Slack is not connected for this account",
};

function agentDraftBodies(item: LoopItem): string[] {
  return agentDraftsOf(item).flatMap((d) => {
    const body = parseReplyDraft(d.data)?.body;
    return body === undefined ? [] : [body.trim()];
  });
}

function provenanceUnknown(item: LoopItem): boolean {
  return item.agentDrafts === undefined && item.proposal?.by === "human";
}

export function renderSlackSendText(item: LoopItem, body: string, actor: "human" | "agent" = "human"): string {
  const agentBodies = agentDraftBodies(item);
  if (actor === "agent" || provenanceUnknown(item) || agentBodies.includes(body.trim()))
    return neutralizeMentions(body);
  const everWritten = new Set([
    ...(item.agentMentionKeys ?? []),
    ...agentBodies.flatMap((b) => [...wireMentionKeys(b)]),
  ]);
  return everWritten.size ? neutralizeMentions(body, everWritten) : body;
}

async function sendSlack(deps: SourceActionDeps, item: LoopItem, draft: ReplyDraft): Promise<SourceActionResult> {
  const slack = metaOf(item);
  if (!slack?.channelId) return { ok: false, reason: "bad_item", message: "item carries no Slack channel" };
  const client = await clientAsUser(deps);
  if (!client) return notConnected;
  const threadTs = slackReplyThreadTs(item);
  const parts = safeChunks(renderSlackSendText(item, draft.body, deps.actor ?? "human"), SLACK_POST_SPLIT_LIMIT);
  const posted: string[] = [];
  for (const text of parts) {
    try {
      await client.chat.postMessage({
        channel: slack.channelId,
        text,
        parse: "none",
        ...(threadTs ? { thread_ts: threadTs } : {}),
      });
    } catch (err) {
      if (!posted.length) throw err;
      const code = slackErrorCode(err);
      return {
        ok: false,
        reason: "upstream",
        partial: true,
        message: `Slack posted ${posted.length} of ${parts.length} parts, then refused the next${code ? `: ${code}` : ""}. The reply is incomplete in Slack.`,
      };
    }
    posted.push(text);
  }
  return { ok: true, result: posted.join("\n") };
}

async function reactInSlack(deps: SourceActionDeps, item: LoopItem, raw: unknown): Promise<SourceActionResult> {
  const slack = metaOf(item);
  if (!slack?.channelId) return { ok: false, reason: "bad_item", message: "item carries no Slack channel" };
  const name = typeof raw === "string" ? normalizeReaction(raw) : null;
  if (!name) return { ok: false, reason: "bad_item", message: "name (an emoji short name) required" };
  const client = await clientAsUser(deps);
  if (!client) return notConnected;
  const { added } = await applyReactions(client, slack.channelId, slack.ts, [name]);
  if (!added.includes(name)) {
    return { ok: false, reason: "upstream", message: `Slack refused the reaction :${name}:` };
  }
  return {
    ok: true,
    result: `:${name}:`,
    resolves: false,
    payloadPatch: { reactions: [...new Set([...itemReactions(item), name])] } as LoopSourcePayload,
  };
}

export const slackAdapter: LoopSourceAdapter = {
  id: "slack",
  actions: ["send", "react"],
  parse(raw) {
    const common = parseCommonFields(raw);
    if ("error" in common) return common;
    const rawKey = clip(raw.sourceKey ?? raw.dedupeKey, 300);
    if (!rawKey) return { error: "sourceKey required" };
    const slack = parseSlackMeta(raw.slack);
    if (!slack || slack.isDirectMessage === undefined)
      return { error: "slack items need slack.channelId, slack.ts and slack.isDirectMessage" };
    const dedupeKey = slackConversationRef(slack.channelId, slack.ts, slack.threadTs, slack.isDirectMessage);
    const draft = raw.draft === undefined ? undefined : parseReplyDraft(raw.draft);
    if (draft === null) return { error: "draft needs a string body" };
    const entry: ParsedEntry = {
      dedupeKey,
      summary: common.snippet,
      sourceAt: common.receivedAt,
      sourcePayload: { source: "slack", ...common, slack } as LoopSourcePayload,
      ...(draft ? { proposal: { data: draft as unknown as LoopSourcePayload } } : {}),
    };
    return entry;
  },
  matchesEvent(item, conversationRef) {
    const slack = metaOf(item);
    if (!slack) return false;
    return (slack.isDirectMessage ? [true, false] : [false]).some(
      (dm) => slackConversationRef(slack.channelId, slack.ts, slack.threadTs, dm) === conversationRef,
    );
  },
  parseProposal(raw) {
    const draft = parseReplyDraft(raw);
    return draft ? (draft as unknown as LoopSourcePayload) : null;
  },
  async act(deps, item, kind, args) {
    if (kind !== "send" && kind !== "react") {
      return { ok: false, reason: "bad_item", message: `slack items do not support "${kind}"` };
    }
    try {
      if (kind === "react") return await reactInSlack(deps, item, args.name);
      const draft = args.body !== undefined ? parseReplyDraft(args) : draftOf(item);
      if (!draft || !draft.body.trim()) return { ok: false, reason: "bad_item", message: "the draft is empty" };
      return await sendSlack(deps, item, { ...draft, body: draft.body.trim() });
    } catch (err) {
      const code = slackErrorCode(err);
      return { ok: false, reason: "upstream", message: code ? `Slack refused the ${kind}: ${code}` : errMessage(err) };
    }
  },
};