eniac-slack 0.0.2

package/src/services/permissions.ts

@@ -0,0 +1,131 @@
+import type { WebClient } from "@slack/web-api";
+
+interface PendingPermission {
+  resolve: (granted: boolean) => void;
+  channel: string;
+  threadTs: string;
+  messageTs?: string;
+  authorUserId: string;
+}
+
+const pending = new Map<string, PendingPermission>();
+
+/**
+ * Register a pending permission request and post Slack buttons.
+ * Returns a Promise that resolves when the user clicks Approve or Deny.
+ */
+export async function requestPermission(
+  client: WebClient,
+  channel: string,
+  threadTs: string,
+  permissionId: string,
+  toolName: string,
+  description: string,
+  authorUserId?: string
+): Promise<boolean> {
+  console.log(`[perm] posting buttons: tool=${toolName}, permId=${permissionId}, author=${authorUserId}`);
+
+  const result = await client.chat.postMessage({
+    channel,
+    thread_ts: threadTs,
+    text: `Permission request: ${toolName}`,
+    blocks: [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `:lock: *Permission Required*\n\n*Tool:* \`${toolName}\`\n${description}`,
+        },
+      },
+      {
+        type: "actions",
+        block_id: `perm_${permissionId}`,
+        elements: [
+          {
+            type: "button",
+            text: { type: "plain_text", text: "Approve" },
+            style: "primary",
+            action_id: "approve_permission",
+            value: permissionId,
+          },
+          {
+            type: "button",
+            text: { type: "plain_text", text: "Deny" },
+            style: "danger",
+            action_id: "deny_permission",
+            value: permissionId,
+          },
+        ],
+      },
+    ],
+  });
+
+  console.log(`[perm] buttons posted: messageTs=${result.ts}`);
+
+  return new Promise<boolean>((resolve) => {
+    pending.set(permissionId, {
+      resolve,
+      channel,
+      threadTs,
+      messageTs: result.ts,
+      authorUserId: authorUserId ?? "",
+    });
+    console.log(`[perm] pending entry set: permId=${permissionId}, pending.size=${pending.size}`);
+  });
+}
+
+/**
+ * Resolve a pending permission (called from Slack action handler).
+ * Only the original thread author can approve/deny.
+ */
+export async function resolvePermission(
+  client: WebClient,
+  permissionId: string,
+  granted: boolean,
+  clickedUserId: string
+): Promise<void> {
+  console.log(`[perm] resolvePermission called: permId=${permissionId}, granted=${granted}, clickedBy=${clickedUserId}`);
+  console.log(`[perm] pending keys: [${[...pending.keys()].join(", ")}]`);
+
+  const entry = pending.get(permissionId);
+  if (!entry) {
+    console.log(`[perm] ERROR: no pending entry found for ${permissionId}`);
+    return;
+  }
+
+  console.log(`[perm] entry found: authorUserId=${entry.authorUserId}, clickedUserId=${clickedUserId}`);
+
+  // Only the thread author can approve/deny
+  if (entry.authorUserId && clickedUserId !== entry.authorUserId) {
+    console.log(`[perm] REJECTED: author mismatch! expected=${entry.authorUserId}, got=${clickedUserId}`);
+    return;
+  }
+
+  pending.delete(permissionId);
+
+  // Update the button message to show the decision
+  if (entry.messageTs) {
+    const status = granted
+      ? `:white_check_mark: *Approved* by <@${clickedUserId}>`
+      : `:no_entry_sign: *Denied* by <@${clickedUserId}>`;
+
+    try {
+      await client.chat.update({
+        channel: entry.channel,
+        ts: entry.messageTs,
+        text: status,
+        blocks: [
+          {
+            type: "section",
+            text: { type: "mrkdwn", text: status },
+          },
+        ],
+      });
+    } catch {
+      // best effort update
+    }
+  }
+
+  console.log(`[perm] resolving promise with granted=${granted}`);
+  entry.resolve(granted);
+}

package/src/services/slack-messenger.ts

@@ -0,0 +1,102 @@
+import type { WebClient } from "@slack/web-api";
+import type { ChatEvent } from "./claude.js";
+
+const THROTTLE_MS = 500;
+
+/**
+ * Post a streaming reply in a Slack thread, handling both text and tool events.
+ *
+ * - Text chunks are accumulated and the message is updated in real-time.
+ * - Tool use / tool result events are logged but don't affect the main message.
+ * - Permission requests are handled by claude.ts (via permissions.ts).
+ */
+export async function postStreamingReply(
+  client: WebClient,
+  channel: string,
+  threadTs: string,
+  eventStream: AsyncGenerator<ChatEvent, void, unknown>
+): Promise<string> {
+  const initial = await client.chat.postMessage({
+    channel,
+    thread_ts: threadTs,
+    text: ":hourglass_flowing_sand: Thinking...",
+  });
+
+  const messageTs = initial.ts;
+  if (!messageTs) {
+    throw new Error("Failed to post initial message — no ts returned");
+  }
+
+  let accumulated = "";
+  let lastUpdateTime = 0;
+  let pendingUpdate = false;
+
+  // Trim accumulated text to the last word boundary to avoid
+  // partial Korean characters being interpreted as punycode URLs by Slack
+  const safeSlice = (text: string): string => {
+    // Find last whitespace or newline
+    const lastBreak = Math.max(
+      text.lastIndexOf(" "),
+      text.lastIndexOf("\n"),
+      text.lastIndexOf("\t")
+    );
+    // If break is near the end (within 20 chars), use it; otherwise send everything
+    if (lastBreak > 0 && text.length - lastBreak <= 20) {
+      return text.slice(0, lastBreak + 1);
+    }
+    return text;
+  };
+
+  const doUpdate = async (text: string, isFinal: boolean) => {
+    const now = Date.now();
+    const elapsed = now - lastUpdateTime;
+
+    if (!isFinal && elapsed < THROTTLE_MS) {
+      pendingUpdate = true;
+      return;
+    }
+
+    pendingUpdate = false;
+    lastUpdateTime = Date.now();
+
+    // For intermediate updates, trim to word boundary to prevent garbled display
+    const displayText = isFinal ? text : safeSlice(text);
+
+    try {
+      await client.chat.update({
+        channel,
+        ts: messageTs,
+        text: displayText || ":hourglass_flowing_sand: Thinking...",
+      });
+    } catch (error) {
+      console.warn(
+        "[slack-messenger] Failed to update message:",
+        error instanceof Error ? error.message : error
+      );
+    }
+  };
+
+  for await (const event of eventStream) {
+    switch (event.type) {
+      case "text":
+        accumulated += event.content;
+        await doUpdate(accumulated, false);
+        break;
+
+      case "error":
+        accumulated += `\n\n:warning: ${event.message}`;
+        await doUpdate(accumulated, true);
+        break;
+    }
+  }
+
+  // Final flush
+  if (pendingUpdate || accumulated) {
+    await doUpdate(
+      accumulated || ":warning: No response generated.",
+      true
+    );
+  }
+
+  return messageTs;
+}

package/src/utils/parse.ts

@@ -0,0 +1,66 @@
+/**
+ * Remove the bot mention (`<@BOTID>`) from message text.
+ */
+export function removeMention(text: string): string {
+  return text.replace(/<@[A-Z0-9]+>/g, "").trim();
+}
+
+export interface GithubRepo {
+  owner: string;
+  repo: string;
+  url: string;
+}
+
+/**
+ * Extract a GitHub repository identifier from text.
+ *
+ * Supported formats:
+ * - `https://github.com/owner/repo`
+ * - `github.com/owner/repo`
+ * - `owner/repo` (only when it looks like a valid GitHub identifier)
+ *
+ * Returns `null` if no match is found.
+ */
+export function extractGithubRepo(text: string): GithubRepo | null {
+  // Full URL: https://github.com/owner/repo or github.com/owner/repo
+  const urlPattern =
+    /(?:https?:\/\/)?github\.com\/([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)/;
+  const urlMatch = text.match(urlPattern);
+
+  if (urlMatch) {
+    const owner = urlMatch[1]!;
+    const repo = urlMatch[2]!.replace(/\.git$/, "");
+    return {
+      owner,
+      repo,
+      url: `https://github.com/${owner}/${repo}.git`,
+    };
+  }
+
+  // Short form: owner/repo — must be a standalone token with valid GitHub naming
+  const shortPattern = /\b([a-zA-Z0-9](?:[a-zA-Z0-9_.-]*[a-zA-Z0-9])?)\/([a-zA-Z0-9](?:[a-zA-Z0-9_.-]*[a-zA-Z0-9])?)\b/;
+  const shortMatch = text.match(shortPattern);
+
+  if (shortMatch) {
+    const owner = shortMatch[1]!;
+    const repo = shortMatch[2]!;
+
+    // Reject things that look like file paths or generic patterns
+    if (
+      owner.includes("..") ||
+      repo.includes("..") ||
+      owner.startsWith(".") ||
+      repo.startsWith(".")
+    ) {
+      return null;
+    }
+
+    return {
+      owner,
+      repo,
+      url: `https://github.com/${owner}/${repo}.git`,
+    };
+  }
+
+  return null;
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}