@kamilio/wire 0.1.12 → 0.1.14

package/node_modules/provider-slack/src/index.ts

@@ -1,6 +1,6 @@
 import { slackService } from "./slack.js";
 
-export { slackService, markdownToSlackBlocks, slackBlocksToMarkdown, sendSlackMessage, type SlackSentMessage } from "./slack.js";
+export { slackService, markdownToSlackBlocks, slackBlocksToMarkdown, sendSlackMessage, editSlackMessage, lookupSlackUsers, type SlackSentMessage } from "./slack.js";
 export const slackProvider = Object.freeze({
   services: [slackService] as const,
 });

package/node_modules/provider-slack/src/slack.ts

@@ -42,6 +42,7 @@ function inlinePlain(nodes: readonly MdNode[]): string {
     if ("children" in node) return inlinePlain(node.children);
     if (node.type === "image") return node.alt;
     if (node.type === "break") return "\n";
+    if (node.type === "thematicBreak") return "──────────";
     if (node.type === "footnoteReference") return `[${node.label}]`;
     throw new Error(`Unsupported Slack inline node: ${node.type}`);
   }).join("");
@@ -263,14 +264,90 @@ async function slackSession(runtime: RuntimeCapabilities) {
   return { origin: metadata["origin"]!, token: metadata["token"]!, cookie: cookies.map((value) => `${value.name}=${value.value}`).join("; ") };
 }
 
-export type SlackSentMessage = Readonly<{ channel: string; ts: string; url: string; thread_ts?: string }>;
+export async function lookupSlackUsers(runtime: RuntimeCapabilities, query: string): Promise<readonly JsonObject[]> {
+  query = query.trim();
+  if (query === "") throw new Error("Slack user lookup requires an email or name");
+  const session = await slackSession(runtime);
+  const request = (method: string, parameters: Readonly<Record<string, string>>) => api(runtime, session.origin, session.token, session.cookie, method, parameters);
+  const email = /^[^@\s]+@[^@\s]+$/.test(query);
+  const found: JsonObject[] = [];
+  let cursor: string | undefined;
+  do {
+    const response = await request("users.list", { limit: "200", ...(cursor === undefined ? {} : { cursor }) });
+    for (const member of response["members"] as readonly JsonObject[]) {
+      if (member["deleted"] === true) continue;
+      const profile = member["profile"] as JsonObject | undefined;
+      const names = [member["name"], member["real_name"], profile?.["display_name"], profile?.["real_name"], profile?.["email"]].filter((value): value is string => typeof value === "string");
+      if (email ? (profile?.["email"] as string | undefined)?.toLowerCase() === query.toLowerCase() : query.startsWith("@") ? member["name"] === query.slice(1) : query.toLowerCase().split(/\s+/).every((word) => names.some((name) => name.toLowerCase().includes(word)))) found.push(member);
+    }
+    cursor = (response["response_metadata"] as JsonObject | undefined)?.["next_cursor"] as string | undefined;
+  } while (cursor !== undefined && cursor !== "");
+  return found;
+}
+
+function slackMessageParts(markdown: string): string[] {
+  const ast = parse(markdown).ast;
+  if (ast.type !== "root") throw new Error("Expected Markdown document");
+  const bytes = Buffer.from(markdown);
+  const parts: string[] = [];
+  let start = 0;
+  for (const node of ast.children) {
+    if (node.type !== "thematicBreak" || bytes.subarray(node.range!.start, node.range!.end).toString().trim() !== "---") continue;
+    parts.push(bytes.subarray(start, node.range!.start).toString().trim());
+    start = node.range!.end;
+  }
+  parts.push(bytes.subarray(start).toString().trim());
+  if (parts.some((part) => part === "")) throw new Error("Slack thread sections must not be empty");
+  return parts;
+}
+
+async function resolveSlackEmailMentions(runtime: RuntimeCapabilities, blocks: readonly JsonObject[], users: Map<string, string>): Promise<readonly JsonObject[]> {
+  const resolve = async (element: JsonObject): Promise<JsonObject> => {
+    if (element["type"] === "link" && typeof element["text"] === "string" && element["text"].startsWith("@") && typeof element["url"] === "string" && element["url"].startsWith("mailto:")) {
+      const email = decodeURIComponent(element["url"].slice(7));
+      if (!/^[^@\s?]+@[^@\s?]+$/.test(email)) throw new Error(`Invalid mention email: ${email}`);
+      const key = email.toLowerCase();
+      if (!users.has(key)) {
+        const matches = await lookupSlackUsers(runtime, email);
+        if (matches.length !== 1) throw new Error(`Expected one Slack user for ${email}, found ${matches.length}`);
+        users.set(key, matches[0]!["id"] as string);
+      }
+      return { type: "user", user_id: users.get(key)!, ...(element["style"] === undefined ? {} : { style: element["style"] }) };
+    }
+    if (Array.isArray(element["elements"])) {
+      const elements: JsonObject[] = [];
+      for (const child of element["elements"] as readonly JsonObject[]) elements.push(await resolve(child));
+      return { ...element, elements };
+    }
+    return element;
+  };
+  const result: JsonObject[] = [];
+  for (const block of blocks) result.push(await resolve(block));
+  return result;
+}
+
+export type SlackSentMessage = Readonly<{ channel: string; ts: string; url: string; thread_ts?: string; replies?: readonly SlackSentMessage[] }>;
+
+export function sendSlackMessage(runtime: RuntimeCapabilities, destination: string, markdown: string): Promise<SlackSentMessage> {
+  return writeSlackMessage(runtime, destination, markdown, false);
+}
+
+export function editSlackMessage(runtime: RuntimeCapabilities, url: string, markdown: string): Promise<SlackSentMessage> {
+  return writeSlackMessage(runtime, url, markdown, true);
+}
 
-export async function sendSlackMessage(runtime: RuntimeCapabilities, destination: string, markdown: string): Promise<SlackSentMessage> {
-  const blocks = markdownToSlackBlocks(markdown);
+async function writeSlackMessage(runtime: RuntimeCapabilities, destination: string, markdown: string, edit: boolean): Promise<SlackSentMessage> {
+  markdown = markdown.replace(/\r\n?/g, "\n");
+  const parts = slackMessageParts(markdown);
+  const blocks = parts.map(markdownToSlackBlocks);
+  const users = new Map<string, string>();
+  for (const [index, value] of blocks.entries()) blocks[index] = await resolveSlackEmailMentions(runtime, value, users);
+  if (edit && (!destination.startsWith("https://") || messageParts(new URL(destination)) === undefined)) throw new Error("Slack edit requires a message URL");
   const session = await slackSession(runtime);
   const request = (method: string, parameters: Readonly<Record<string, string>>) => api(runtime, session.origin, session.token, session.cookie, method, parameters);
   let channel: string;
   let thread: string | undefined;
+  let editTimestamp: string | undefined;
   if (destination.startsWith("https://")) {
     const url = new URL(destination);
     const message = messageParts(url);
@@ -278,25 +355,19 @@ export async function sendSlackMessage(runtime: RuntimeCapabilities, destination
     if (message === undefined && channelId === undefined) throw new Error(`Unsupported Slack destination: ${destination}`);
     if (message !== undefined) {
       channel = message.channel;
+      if (edit) editTimestamp = slackTimestamp(message.rawTimestamp);
       thread = url.searchParams.has("thread_ts") ? url.searchParams.get("thread_ts")! : slackTimestamp(message.rawTimestamp);
       const response = await request("conversations.replies", { channel, ts: thread, limit: "1" });
       const selected = (response["messages"] as readonly JsonObject[])[0]!;
       if (selected["thread_ts"] !== undefined) thread = selected["thread_ts"] as string;
     } else channel = channelId!;
   } else if (/^[CDG][A-Z0-9]+$/.test(destination)) channel = destination;
-  else if (/^[UW][A-Z0-9]+$/.test(destination) || destination.startsWith("@")) {
+  else if (/^[UW][A-Z0-9]+$/.test(destination) || destination.startsWith("@") || /^[^@\s]+@[^@\s]+$/.test(destination)) {
     let user = destination;
-    if (destination.startsWith("@")) {
-      const name = destination.slice(1);
-      const found: string[] = [];
-      let cursor: string | undefined;
-      do {
-        const response = await request("users.list", { limit: "200", ...(cursor === undefined ? {} : { cursor }) });
-        for (const member of response["members"] as readonly JsonObject[]) if (member["name"] === name && member["deleted"] !== true) found.push(member["id"] as string);
-        cursor = (response["response_metadata"] as JsonObject | undefined)?.["next_cursor"] as string | undefined;
-      } while (cursor !== undefined && cursor !== "");
-      if (found.length !== 1) throw new Error(`Expected one Slack user named @${name}, found ${found.length}; use a user ID`);
-      user = found[0]!;
+    if (!/^[UW][A-Z0-9]+$/.test(destination)) {
+      const found = await lookupSlackUsers(runtime, destination);
+      if (found.length !== 1) throw new Error(`Expected one Slack user for ${destination}, found ${found.length}; use an email or user ID`);
+      user = found[0]!["id"] as string;
     }
     const opened = await request("conversations.open", { users: user });
     channel = (opened["channel"] as JsonObject)["id"] as string;
@@ -314,10 +385,21 @@ export async function sendSlackMessage(runtime: RuntimeCapabilities, destination
     if (found.length !== 1) throw new Error(`Expected one Slack channel named #${name}, found ${found.length}; use a channel ID or URL`);
     channel = found[0]!;
   }
-  const posted = await request("chat.postMessage", { channel, text: markdown, blocks: JSON.stringify(blocks), unfurl_links: "false", unfurl_media: "false", parse: "none", mrkdwn: "false", ...(thread === undefined ? {} : { thread_ts: thread }) });
-  const ts = posted["ts"] as string;
-  const url = `${session.origin}/archives/${posted["channel"]}/p${ts.replace(".", "")}${thread === undefined ? "" : `?thread_ts=${thread}`}`;
-  return { channel: posted["channel"] as string, ts, url, ...(thread === undefined ? {} : { thread_ts: thread }) };
+  const sent: SlackSentMessage[] = [];
+  for (const [index, part] of parts.entries()) {
+    try {
+      const updating = index === 0 && edit;
+      const posted = await request(updating ? "chat.update" : "chat.postMessage", { channel, text: part, blocks: JSON.stringify(blocks[index]), unfurl_links: "false", unfurl_media: "false", parse: "none", mrkdwn: "false", ...(updating ? { ts: editTimestamp! } : thread === undefined ? {} : { thread_ts: thread }) });
+      const ts = posted["ts"] as string;
+      const url = `${session.origin}/archives/${posted["channel"]}/p${ts.replace(".", "")}${thread === undefined ? "" : `?thread_ts=${thread}`}`;
+      sent.push({ channel: posted["channel"] as string, ts, url, ...(thread === undefined ? {} : { thread_ts: thread }) });
+      thread ??= ts;
+    } catch (error) {
+      if (sent.length === 0) throw error;
+      throw new Error(`Slack thread stopped after ${sent.length} message(s): ${sent.map((message) => message.url).join(", ")}. ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { ...sent[0]!, ...(sent.length === 1 ? {} : { replies: sent.slice(1) }) };
 }
 
 export const slackService = defineService<RuntimeCapabilities>({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kamilio/wire",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Attach Notion, Google Docs, Slack, Gmail, Asana, ChatGPT, and Zoom resources as local Markdown you can sync.",
   "keywords": [
     "markdown",

package/src/adapters/root.ts

@@ -1,6 +1,6 @@
 import { UserError, defineCommand, defineGroup, S, type Group } from "toolcraft";
 
-import { defaultWireBackend, registryPathForBackend, type FetchedDocument, type InitializedWire, type Resource, type SwitchedWireBackend, type Wire, type WireBackend, type WireResult, type WireWatchSession } from "wire-core";
+import { defaultWireBackend, registryPathForBackend, type JsonObject, type FetchedDocument, type InitializedWire, type Resource, type SwitchedWireBackend, type Wire, type WireBackend, type WireResult, type WireWatchSession } from "wire-core";
 import type { SlackSentMessage } from "provider-slack";
 import type { Auth, AuthResult, AuthService } from "../auth.js";
 
@@ -415,7 +415,7 @@ function authGroup(service: AuthService, description: string, loginDescription:
   ] });
 }
 
-export function createRoot(wire: Wire, currentDirectory: string, auth?: Auth, readInput?: TextInputReader, options: WireRootOptions = { allowPaste: true }, sendSlack?: (destination: string, markdown: string) => Promise<SlackSentMessage>): WireRoot {
+export function createRoot(wire: Wire, currentDirectory: string, auth?: Auth, readInput?: TextInputReader, options: WireRootOptions = { allowPaste: true }, sendSlack?: (destination: string, markdown: string) => Promise<SlackSentMessage>, lookupSlack?: (query: string) => Promise<readonly JsonObject[]>, editSlack?: (url: string, markdown: string) => Promise<SlackSentMessage>, lookupNotion?: (query: string) => Promise<readonly JsonObject[]>): WireRoot {
   const attachFromCliUrl = (url: string) => {
     const removedCommand = removedCliCommandNames[url as keyof typeof removedCliCommandNames];
     if (removedCommand !== undefined) throw new UserError(`Unknown command: ${url}. ${removedCommand}`);
@@ -449,14 +449,33 @@ export function createRoot(wire: Wire, currentDirectory: string, auth?: Auth, re
   const authCommand = (service: (typeof authServices)[number]) => {
     const title = serviceTitle(service);
     const group = authGroup(service, `Manage ${title} login.`, "Capture cookies once; normal commands reuse saved cookies.", auth!, readInput, options);
-    if (service !== "slack") return group;
-    return defineGroup({ name: "slack", description: "Read Slack channels, DMs, and threads, send Markdown, and manage login.", children: [preview, defaultAttach, sync, ...group.children, ...(sendSlack === undefined ? [] : [defineCommand({
+    const lookup = service === "slack" ? lookupSlack : service === "notion" ? lookupNotion : undefined;
+    const users = lookup === undefined ? [] : [defineGroup({ name: "users", description: "Find people by email or name.", children: [defineCommand({
+      name: "lookup",
+      description: "Look up active users by exact email or name. Email lookup avoids ambiguous names.",
+      positional: ["query"],
+      params: S.Object({ query: S.String({ description: "Email address or name to look up." }) }),
+      handler: ({ params }) => userFacing(() => lookup(params.query)),
+      render: render<readonly JsonObject[]>((results) => results.length === 0 ? "No matching users" : results.map((user) => {
+        const profile = user["profile"] as JsonObject | undefined;
+        return service === "slack" ? `${user["id"]}  ${user["real_name"] ?? user["name"]}  ${profile?.["email"] ?? ""}` : `${user["userId"]}  ${user["name"] ?? ""}  ${(user["aliases"] as readonly string[] | undefined ?? []).join(", ")}`;
+      }).join("\n")),
+    })] })];
+    if (service !== "slack") return users.length === 0 ? group : defineGroup({ ...group, children: [...group.children, ...users] });
+    return defineGroup({ name: "slack", description: "Read Slack channels, DMs, and threads, send Markdown, and manage login.", children: [preview, defaultAttach, sync, ...group.children, ...users, ...(sendSlack === undefined ? [] : [defineCommand({
       name: "send",
-      description: "Send Markdown to a channel, @username, user ID, DM URL, or thread URL. Use a thread URL to reply. Tables and frontmatter are sent as code blocks.",
+      description: "Send Markdown to a channel, email, @username, user ID, or URL. Top-level --- separators split it into a parent and thread replies; a thread URL replies there.",
       positional: ["destination", "markdown"],
-      params: S.Object({ destination: S.String({ description: "Slack channel name (with #), @username, user ID, conversation ID or URL, or thread URL to reply to." }), markdown: S.String({ description: "Message in Markdown. Supports formatting, nested lists, code, quotes, links, and explicit Slack mentions such as <@U123>." }) }),
+      params: S.Object({ destination: S.String({ description: "Slack channel name (with #), email, @username, user ID, conversation ID or URL, or thread URL to reply to." }), markdown: S.String({ description: "Message in Markdown. Mention by email with [@Name](mailto:email), or use <@U123>. Separate thread messages with blank lines around ---." }) }),
       handler: ({ params }) => userFacing(() => sendSlack!(params.destination, params.markdown)),
-      render: render<SlackSentMessage>((result) => `Sent: ${result.url}`),
+      render: render<SlackSentMessage>((result) => `Sent: ${[result, ...result.replies ?? []].map((message) => message.url).join("\n")}`),
+    })]), ...(editSlack === undefined ? [] : [defineCommand({
+      name: "edit",
+      description: "Edit a message by URL. Sections after --- are appended as thread replies.",
+      positional: ["url", "markdown"],
+      params: S.Object({ url: S.String({ description: "URL of your Slack message to edit." }), markdown: S.String({ description: "Replacement Markdown, with email mentions and optional --- thread separators." }) }),
+      handler: ({ params }) => userFacing(() => editSlack(params.url, params.markdown)),
+      render: render<SlackSentMessage>((result) => `Updated: ${[result, ...result.replies ?? []].map((message) => message.url).join("\n")}`),
     })])] });
   };
   return defineGroup({

package/src/cli.ts

@@ -240,7 +240,8 @@ function excessPositionals(argv: readonly string[]): Readonly<{ commandPath: str
   const command = words[0]!;
   if (command in fixedCommandPositionals) return Object.freeze({ commandPath: command, expected: fixedCommandPositionals[command as keyof typeof fixedCommandPositionals].expected, received: words.length - 1 });
   if (command === "slack" && slackResourceCommands.has(words[1]!)) return { commandPath: `slack ${words[1]}`, expected: 1, received: words.length - 2 };
-  if (command === "slack" && words[1] === "send") return Object.freeze({ commandPath: "slack send", expected: 2, received: words.length - 2 });
+  if ((command === "slack" || command === "notion") && words[1] === "users" && words[2] === "lookup") return { commandPath: `${command} users lookup`, expected: 1, received: words.length - 3 };
+  if (command === "slack" && (words[1] === "send" || words[1] === "edit")) return { commandPath: `slack ${words[1]}`, expected: 2, received: words.length - 2 };
   if (authServices.has(command)) {
     const authCommand = words[1];
     if (authCommand === undefined || !authCommands.has(authCommand)) return null;
@@ -256,7 +257,8 @@ function missingPositionals(argv: readonly string[]): Readonly<{ commandPath: st
   if (words === null || words.length === 0) return null;
   const command = words[0]!;
   if (command === "slack" && slackResourceCommands.has(words[1]!) && words.length < 3) return { commandPath: `slack ${words[1]}`, name: words[1] === "sync" ? "resource" : "url" };
-  if (command === "slack" && words[1] === "send" && words.length < 4) return { commandPath: "slack send", name: words.length === 2 ? "destination" : "markdown" };
+  if ((command === "slack" || command === "notion") && words[1] === "users" && words[2] === "lookup" && words.length < 4) return { commandPath: `${command} users lookup`, name: "query" };
+  if (command === "slack" && (words[1] === "send" || words[1] === "edit") && words.length < 4) return { commandPath: `slack ${words[1]}`, name: words.length === 2 ? words[1] === "send" ? "destination" : "url" : "markdown" };
   if (!(command in fixedCommandPositionals)) return null;
   const positional = fixedCommandPositionals[command as keyof typeof fixedCommandPositionals];
   if (words.length - 1 >= positional.expected || positional.expected === 0) return null;
@@ -292,7 +294,7 @@ function renderRemovedCommand(argv: readonly string[]): boolean {
 function renderUnknownAuthCommand(argv: readonly string[]): boolean {
   if (hasRootSeparator(argv)) return false;
   const words = positionalWords(argv);
-  if (words === null || words.length < 2 || !authServices.has(words[0]!) || authCommands.has(words[1]!) || words[0] === "slack" && (words[1] === "send" || slackResourceCommands.has(words[1]!))) return false;
+  if (words === null || words.length < 2 || !authServices.has(words[0]!) || authCommands.has(words[1]!) || (words[0] === "slack" || words[0] === "notion") && words[1] === "users" || words[0] === "slack" && (words[1] === "send" || words[1] === "edit" || slackResourceCommands.has(words[1]!))) return false;
   renderCliError(argv, `Unknown command: ${words[1]}`, `wire ${words[0]} --help`, `Unknown command: ${cliValue(words[1]!)}`);
   return true;
 }

package/src/executable.ts

@@ -2,7 +2,9 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 
-import { sendSlackMessage } from "provider-slack";
+import { sendSlackMessage, editSlackMessage, lookupSlackUsers } from "provider-slack";
+
+import { lookupNotionUsers } from "provider-notion";
 
 import { createRoot } from "./adapters/root.js";
 import { composeAuth } from "./auth.js";
@@ -127,5 +129,5 @@ export function createExecutableRoot(environment: NodeEnvironment, currentDirect
     switchBackend: baseWire.switchBackend,
   });
   const wire = withWireHooks(configuredWire, { currentDirectory, home, environment: configuredEnvironment() });
-  return createRoot(wire, currentDirectory, auth, readStandardInput, options, (destination, markdown) => sendSlackMessage(runtime, destination, markdown));
+  return createRoot(wire, currentDirectory, auth, readStandardInput, options, (destination, markdown) => sendSlackMessage(runtime, destination, markdown), (query) => lookupSlackUsers(runtime, query), (url, markdown) => editSlackMessage(runtime, url, markdown), (query) => lookupNotionUsers(runtime, query));
 }