@nuvlore/extension-access-okta-slack 0.1.1

package/src/slackSyncExport.mjs

@@ -0,0 +1,346 @@
+import { mkdir, writeFile, access } from "node:fs/promises";
+import { join } from "node:path";
+import { getSlackConfig } from "./slackConfig.mjs";
+import {
+  channelExportPaths,
+  listRootMessages,
+  threadTsToFilename
+} from "./slackSyncPaths.mjs";
+import { loadSyncState, saveSyncState, updateChannelSyncCursor } from "./slackSyncState.mjs";
+import {
+  createSlackApiClient,
+  fetchAllHistory,
+  fetchAllReplies,
+  listChannelsFromBoot,
+  loadSlackSession,
+  slackUserBoot
+} from "./slackSessionRead.mjs";
+
+function compactMessage(message) {
+  return {
+    ts: message.ts,
+    user: message.user,
+    botId: message.bot_id,
+    subtype: message.subtype,
+    text: message.text,
+    threadTs: message.thread_ts,
+    replyCount: message.reply_count,
+    files: message.files,
+    attachments: message.attachments,
+    reactions: message.reactions
+  };
+}
+
+function newestTs(messages) {
+  if (!messages.length) return null;
+  return messages.reduce((max, message) => (message.ts > max ? message.ts : max), messages[0].ts);
+}
+
+function matchesChannelName(channelName, pattern) {
+  const name = String(channelName || "").toLowerCase();
+  const p = String(pattern || "").toLowerCase();
+  if (!p) return false;
+  if (p.endsWith("*") && p.startsWith("*")) {
+    const inner = p.slice(1, -1);
+    return name.includes(inner);
+  }
+  if (p.endsWith("*")) return name.startsWith(p.slice(0, -1));
+  if (p.startsWith("*")) return name.endsWith(p.slice(1));
+  return name === p;
+}
+
+export const SLACK_SYNC_PRESETS = {
+  /** All private channels plus BDS + issue-tracking public channels. */
+  priority: {
+    includePrivate: true,
+    channelNames: ["bds-public", "bds-notifications*", "jira-public", "*-issues"]
+  }
+};
+
+function dedupeChannelsById(channels) {
+  const seen = new Set();
+  return channels.filter((channel) => {
+    if (!channel?.id || seen.has(channel.id)) return false;
+    seen.add(channel.id);
+    return true;
+  });
+}
+
+function filterPrivateChannels(channels) {
+  return channels.filter((c) => c.is_private && !c.is_im && !c.is_mpim);
+}
+
+function filterChannelsByKind(channels, kind) {
+  if (kind === "private") return filterPrivateChannels(channels);
+  if (kind === "public") return channels.filter((c) => !c.is_private && !c.is_im && !c.is_mpim);
+  if (kind === "dm") return channels.filter((c) => c.is_im);
+  if (kind === "mpim") return channels.filter((c) => c.is_mpim);
+  return channels;
+}
+
+function filterChannelsByNames(channels, channelNames) {
+  return channels.filter((channel) =>
+    channelNames.some((pattern) => matchesChannelName(channel.name, pattern))
+  );
+}
+
+/** Pick channels for sync — kind/name filters, presets, and explicit channelIds. */
+export function selectChannelsForSync(channels, options = {}) {
+  const preset = options.preset ? SLACK_SYNC_PRESETS[options.preset] : undefined;
+  const includePrivate = options.includePrivate === true || preset?.includePrivate === true;
+  const channelNames = options.channelNames ?? preset?.channelNames;
+
+  if (includePrivate && channelNames?.length) {
+    const selected = dedupeChannelsById([
+      ...filterPrivateChannels(channels),
+      ...filterChannelsByNames(channels, channelNames)
+    ]);
+    const limit = options.channelLimit ?? selected.length;
+    return applyChannelIdFilter(selected, options).slice(0, limit);
+  }
+
+  let filtered = filterChannelsByKind(channels, options.channelKind);
+  if (channelNames?.length) {
+    filtered = filterChannelsByNames(filtered, channelNames);
+  }
+  filtered = applyChannelIdFilter(filtered, options);
+  const limit = options.channelLimit ?? filtered.length;
+  return filtered.slice(0, limit);
+}
+
+function applyChannelIdFilter(channels, options) {
+  if (!options.channelIds?.length) return channels;
+  const ids = new Set(options.channelIds);
+  return channels.filter((channel) => ids.has(channel.id));
+}
+
+async function filterCompletedChannels(channels, exportDir) {
+  const pending = [];
+  for (const channel of channels) {
+    const paths = channelExportPaths(exportDir, channel);
+    try {
+      await access(paths.channelMetaPath);
+    } catch {
+      pending.push(channel);
+    }
+  }
+  return pending;
+}
+
+async function threadFileExists(threadsDir, threadTs) {
+  try {
+    await access(join(threadsDir, threadTsToFilename(threadTs)));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function writeThreadFile(threadsDir, threadTs, payload) {
+  await mkdir(threadsDir, { recursive: true });
+  const path = join(threadsDir, threadTsToFilename(threadTs));
+  await writeFile(path, `${JSON.stringify(payload, null, 2)}\n`);
+  return path;
+}
+
+export async function syncSlackChannel(channel, context, options = {}) {
+  const { slackApi, exportDir, config, state } = context;
+  const paths = channelExportPaths(exportDir, channel);
+  await mkdir(paths.channelDir, { recursive: true });
+
+  const cursor = state.channels?.[channel.id];
+  const history = await fetchAllHistory(slackApi, channel.id, {
+    oldest: options.incremental && cursor?.newestTs ? cursor.newestTs : undefined
+  });
+
+  const roots = listRootMessages(history);
+  let threadCount = 0;
+  let messageCount = 0;
+  const threadFiles = [];
+
+  for (const root of roots) {
+    if (options.skipExistingThreads && (await threadFileExists(paths.threadsDir, root.threadTs))) {
+      threadCount += 1;
+      continue;
+    }
+
+    let threadMessages = [root];
+    if ((root.reply_count ?? 0) > 0) {
+      try {
+        threadMessages = await fetchAllReplies(slackApi, channel.id, root.threadTs);
+      } catch (error) {
+        if (!String(error.message).includes("ratelimited")) throw error;
+        await new Promise((resolve) => setTimeout(resolve, 30_000));
+        threadMessages = await fetchAllReplies(slackApi, channel.id, root.threadTs);
+      }
+    }
+    const compacted = threadMessages.map(compactMessage);
+    messageCount += compacted.length;
+    threadCount += 1;
+
+    const filePath = await writeThreadFile(paths.threadsDir, root.threadTs, {
+      readOnly: true,
+      channelId: channel.id,
+      channelName: channel.name,
+      channelKind: channel.is_im ? "im" : channel.is_mpim ? "mpim" : channel.is_private ? "private" : "public",
+      threadTs: root.threadTs,
+      syncedAt: new Date().toISOString(),
+      messageCount: compacted.length,
+      root: compacted[0] ?? null,
+      messages: compacted
+    });
+    threadFiles.push(filePath);
+    options.onProgress?.({
+      phase: "thread",
+      channelId: channel.id,
+      channelName: channel.name,
+      threadTs: root.threadTs,
+      messageCount: compacted.length
+    });
+  }
+
+  await writeFile(
+    paths.channelMetaPath,
+    `${JSON.stringify(
+      {
+        readOnly: true,
+        channelId: channel.id,
+        name: channel.name,
+        isPrivate: Boolean(channel.is_private),
+        isIm: Boolean(channel.is_im),
+        isMpim: Boolean(channel.is_mpim),
+        syncedAt: new Date().toISOString(),
+        threadCount,
+        messageCount,
+        incremental: Boolean(options.incremental && cursor?.newestTs),
+        threadsDir: "threads"
+      },
+      null,
+      2
+    )}\n`
+  );
+
+  const allMessages = history;
+  updateChannelSyncCursor(state, channel.id, {
+    newestTs: newestTs(allMessages) ?? cursor?.newestTs ?? null,
+    threadCount: (cursor?.threadCount ?? 0) + threadCount,
+    messageCount: (cursor?.messageCount ?? 0) + messageCount
+  });
+
+  return { channelId: channel.id, threadCount, messageCount, threadFiles };
+}
+
+/**
+ * Export all accessible Slack channels to disk:
+ *   {exportDir}/channels/{channelId}__{kind}__{name}/channel.json
+ *   {exportDir}/channels/.../threads/{threadTs}.json
+ */
+export async function syncAllSlackData(options = {}) {
+  const config = options.config ?? getSlackConfig();
+  const exportDir = options.exportDir ?? config.exportDir;
+  await mkdir(join(exportDir, "channels"), { recursive: true });
+
+  const session = await loadSlackSession(options);
+  const slackApi = createSlackApiClient(session, options);
+  const boot = await slackUserBoot(session, options);
+  const channels = listChannelsFromBoot(boot);
+  let selected = selectChannelsForSync(channels, options);
+  const skippedCompleted = options.skipCompleted
+    ? selected.length - (await filterCompletedChannels(selected, exportDir)).length
+    : 0;
+  if (options.skipCompleted) {
+    selected = await filterCompletedChannels(selected, exportDir);
+  }
+
+  const state = await loadSyncState(config);
+  const context = { slackApi, exportDir, config, state, boot };
+  const results = [];
+  let totalThreads = 0;
+  let totalMessages = 0;
+
+  for (const channel of selected) {
+    options.onProgress?.({
+      phase: "channel_start",
+      channelId: channel.id,
+      channelName: channel.name,
+      index: results.length + 1,
+      total: selected.length
+    });
+    try {
+      const result = await syncSlackChannel(channel, context, options);
+      totalThreads += result.threadCount;
+      totalMessages += result.messageCount;
+      results.push({ ...result, ok: true, channelName: channel.name });
+    } catch (error) {
+      results.push({
+        ok: false,
+        channelId: channel.id,
+        channelName: channel.name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    options.onProgress?.({
+      phase: "channel_done",
+      channelId: channel.id,
+      channelName: channel.name,
+      index: results.length,
+      total: selected.length
+    });
+  }
+
+  state.lastSyncAt = new Date().toISOString();
+  state.workspace = session.baseUrl;
+  state.user = boot.self?.name;
+  await saveSyncState(state, config);
+
+  const preset = options.preset ? SLACK_SYNC_PRESETS[options.preset] : undefined;
+  const resolvedChannelNames = options.channelNames ?? preset?.channelNames;
+
+  const manifest = {
+    readOnly: true,
+    workspace: session.baseUrl,
+    user: boot.self?.name,
+    syncedAt: state.lastSyncAt,
+    incremental: Boolean(options.incremental),
+    skipCompleted: Boolean(options.skipCompleted),
+    skipExistingThreads: Boolean(options.skipExistingThreads),
+    skippedCompleted,
+    channelKind: options.channelKind ?? (options.preset ? undefined : "all"),
+    preset: options.preset,
+    includePrivate: options.includePrivate ?? preset?.includePrivate,
+    channelNames: resolvedChannelNames,
+    selectedChannelCount: selected.length,
+    channelCount: results.filter((r) => r.ok).length,
+    failedChannels: results.filter((r) => !r.ok).length,
+    threadCount: totalThreads,
+    messageCount: totalMessages,
+    exportDir,
+    layout: {
+      channels: "channels/{channelId}__{kind}__{name}/channel.json",
+      threads: "channels/{channelId}__{kind}__{name}/threads/{threadTs}.json"
+    },
+    results: results.map((r) => ({
+      ok: r.ok,
+      channelId: r.channelId,
+      channelName: r.channelName,
+      threadCount: r.threadCount,
+      messageCount: r.messageCount,
+      error: r.error
+    }))
+  };
+  await writeFile(config.manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+
+  return manifest;
+}
+
+export async function getSlackSyncStatus(config = getSlackConfig()) {
+  const state = await loadSyncState(config);
+  let manifest = null;
+  try {
+    const { readFile } = await import("node:fs/promises");
+    manifest = JSON.parse(await readFile(config.manifestPath, "utf8"));
+  } catch {
+    // no manifest yet
+  }
+  return { state, manifest, exportDir: config.exportDir };
+}

package/src/slackSyncPaths.mjs

@@ -0,0 +1,47 @@
+import { join } from "node:path";
+
+export function sanitizePathSegment(value, fallback = "unnamed") {
+  const raw = String(value || fallback)
+    .trim()
+    .replace(/[\\/:*?"<>|]/g, "_")
+    .replace(/\s+/g, "-")
+    .replace(/[^a-zA-Z0-9._-]+/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^-|-$/g, "");
+  return (raw || fallback).slice(0, 80);
+}
+
+export function channelDirName(channel) {
+  const label = channel.name || channel.id;
+  const kind = channel.is_im ? "dm" : channel.is_mpim ? "mpim" : channel.is_private ? "private" : "public";
+  return `${channel.id}__${kind}__${sanitizePathSegment(label, channel.id)}`;
+}
+
+export function threadTsToFilename(threadTs) {
+  return `${String(threadTs).replace(/\./g, "_")}.json`;
+}
+
+export function channelExportPaths(exportDir, channel) {
+  const dirName = channelDirName(channel);
+  const channelDir = join(exportDir, "channels", dirName);
+  return {
+    dirName,
+    channelDir,
+    channelMetaPath: join(channelDir, "channel.json"),
+    threadsDir: join(channelDir, "threads")
+  };
+}
+
+export function listRootMessages(messages) {
+  const roots = [];
+  const seen = new Set();
+  for (const message of messages) {
+    if (message.subtype === "channel_join" || message.subtype === "channel_leave") continue;
+    const threadTs = message.thread_ts && message.thread_ts !== message.ts ? message.thread_ts : message.ts;
+    if (message.thread_ts && message.thread_ts !== message.ts) continue;
+    if (seen.has(threadTs)) continue;
+    seen.add(threadTs);
+    roots.push({ ...message, threadTs });
+  }
+  return roots;
+}

package/src/slackSyncState.mjs

@@ -0,0 +1,35 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { getSlackConfig } from "./slackConfig.mjs";
+
+export async function loadSyncState(config = getSlackConfig()) {
+  try {
+    const text = await readFile(config.syncStatePath, "utf8");
+    return JSON.parse(text);
+  } catch {
+    return {
+      version: 1,
+      lastSyncAt: null,
+      channels: {}
+    };
+  }
+}
+
+export async function saveSyncState(state, config = getSlackConfig()) {
+  await mkdir(dirname(config.syncStatePath), { recursive: true });
+  await writeFile(config.syncStatePath, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+export function getChannelSyncCursor(state, channelId) {
+  return state.channels?.[channelId] ?? { newestTs: null, threadCount: 0, messageCount: 0 };
+}
+
+export function updateChannelSyncCursor(state, channelId, update) {
+  state.channels ??= {};
+  state.channels[channelId] = {
+    ...getChannelSyncCursor(state, channelId),
+    ...update,
+    syncedAt: new Date().toISOString()
+  };
+  return state;
+}

package/tools/okta_slack_okta_read.mjs

@@ -0,0 +1,41 @@
+export const description = "Read-only GET for Okta app Slack using browser SSO cookies.";
+
+import { z } from "zod";
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+import { oktaAppReadGet } from "@nuvlore/extension-sso/okta-app-access";
+
+const inputSchema = {
+  restPath: z.string().trim().min(1).max(2048).optional(),
+  baseUrl: z.string().trim().url().max(2048).optional(),
+  query: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+  allowCookieFallback: z.boolean().optional()
+};
+
+const sharedTool = defineReadOnlyTool({
+  name: "okta_slack_okta_read",
+  description: "Read-only GET for Okta app \"Slack\" using browser SSO cookies.",
+  inputSchema,
+  meta: { permissions: { rule: "ask" } },
+  annotations: { openWorldHint: true },
+  async handler(input) {
+    try {
+      return ok(
+        JSON.stringify(
+          await oktaAppReadGet("Slack", { ...input, useDefault: input.useDefault ?? !input.restPath }),
+          null,
+          2
+        )
+      );
+    } catch (error) {
+      return fail(error);
+    }
+  }
+});
+
+export default {
+  description,
+  inputSchema: sharedTool.inputSchema,
+  meta: sharedTool.meta,
+  annotations: sharedTool.annotations,
+  handler: sharedTool.handler
+};

package/tools/okta_slack_okta_verify.mjs

@@ -0,0 +1,26 @@
+export const description = "Probe read-only SSO readiness for Okta app Slack.";
+
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+import { getOktaAppReadAccess } from "@nuvlore/extension-sso/okta-app-access";
+
+const sharedTool = defineReadOnlyTool({
+  name: "okta_slack_okta_verify",
+  description: "Probe read-only SSO readiness for Okta app \"Slack\".",
+  inputSchema: { type: "object", properties: {} },
+  meta: { permissions: { rule: "allow" } },
+  async handler() {
+    try {
+      return ok(JSON.stringify(await getOktaAppReadAccess("Slack"), null, 2));
+    } catch (error) {
+      return fail(error);
+    }
+  }
+});
+
+export default {
+  description,
+  inputSchema: sharedTool.inputSchema,
+  meta: sharedTool.meta,
+  annotations: sharedTool.annotations,
+  handler: sharedTool.handler
+};

package/tools/slack_okta_ai_capabilities.mjs

@@ -0,0 +1,26 @@
+export const description = "Report Slack search and Slack AI capabilities available with current browser SSO session.";
+
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+import { getSlackAiCapabilities } from "../src/slackSearch.mjs";
+
+const sharedTool = defineReadOnlyTool({
+  name: "slack_okta_ai_capabilities",
+  description: "Report Slack search and Slack AI capabilities available with current browser SSO session.",
+  inputSchema: { type: "object", properties: {} },
+  meta: { permissions: { rule: "allow" } },
+  async handler() {
+    try {
+      return ok(JSON.stringify(await getSlackAiCapabilities(), null, 2));
+    } catch (error) {
+      return fail(error);
+    }
+  }
+});
+
+export default {
+  description,
+  inputSchema: sharedTool.inputSchema,
+  meta: sharedTool.meta,
+  annotations: sharedTool.annotations,
+  handler: sharedTool.handler
+};

package/tools/slack_okta_bot_ask.mjs

@@ -0,0 +1,42 @@
+export const description = "Send a message to Slackbot via browser SSO and wait for its AI reply. Only works in your Slackbot DM — no other channels.";
+
+import { z } from "zod";
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+import { askSlackbot, followUpSlackbot } from "../src/slackBotChat.mjs";
+
+const inputSchema = {
+  question: z.string().trim().min(1).max(4000).describe("Message to send to @slackbot"),
+  threadTs: z
+    .string()
+    .trim()
+    .regex(/^\d+\.\d+$/)
+    .optional()
+    .describe("Optional thread timestamp to continue an existing Slackbot conversation"),
+  waitMs: z.number().int().min(5000).max(180000).optional().describe("How long to wait for Slackbot reply")
+};
+
+export default {
+  ...defineReadOnlyTool({
+    name: "slack_okta_bot_ask",
+    description:
+      "Send a message to Slackbot via browser SSO and wait for its AI reply. Only works in your Slackbot DM — no other channels.",
+    inputSchema,
+    meta: { permissions: { rule: "ask" } },
+    annotations: { openWorldHint: true, destructiveHint: false, readOnlyHint: false },
+    async handler(input) {
+      try {
+        const result = input.threadTs
+          ? await followUpSlackbot(input.threadTs, input.question, input)
+          : await askSlackbot(input.question, input);
+        return ok(JSON.stringify(result, null, 2));
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  }),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true
+  }
+};

package/tools/slack_okta_bot_history.mjs

@@ -0,0 +1,32 @@
+export const description = "Read Slackbot DM history and Q&A threads (read-only). Does not send new messages to Slackbot.";
+
+import { z } from "zod";
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+import { readSlackbotConversations } from "../src/slackBotRead.mjs";
+
+const inputSchema = {
+  limit: z.number().int().min(1).max(200).optional()
+};
+
+const sharedTool = defineReadOnlyTool({
+  name: "slack_okta_bot_history",
+  description:
+    "Read Slackbot DM history and Q&A threads (read-only). Does not send new messages to Slackbot.",
+  inputSchema,
+  meta: { permissions: { rule: "allow" } },
+  async handler(input) {
+    try {
+      return ok(JSON.stringify(await readSlackbotConversations(input), null, 2));
+    } catch (error) {
+      return fail(error);
+    }
+  }
+});
+
+export default {
+  description,
+  inputSchema: sharedTool.inputSchema,
+  meta: sharedTool.meta,
+  annotations: sharedTool.annotations,
+  handler: sharedTool.handler
+};

package/tools/slack_okta_create_canvas.mjs

@@ -0,0 +1,38 @@
+export const description = "Create a Slack canvas for a channel using the project Slack/Okta tooling. Requires an env Slack token with canvases:write; falls back to Chrome session to surface auth blockers.";
+
+import { z } from "zod";
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+import { createSlackCanvas } from "../src/slackCanvasCreate.mjs";
+
+const inputSchema = {
+  channelId: z.string().trim().min(1).describe("Slack channel conversation id, e.g. C0497KFSDNJ"),
+  title: z.string().trim().min(1).max(255).describe("Canvas title."),
+  content: z.string().trim().min(1).describe("Canvas markdown content."),
+  channelCanvas: z
+    .boolean()
+    .optional()
+    .describe("Create as the channel canvas via conversations.canvases.create. Defaults to true.")
+};
+
+export default {
+  ...defineReadOnlyTool({
+    name: "slack_okta_create_canvas",
+    description:
+      "Create a Slack canvas for a channel using the project Slack/Okta tooling. Requires an env Slack token with canvases:write; falls back to Chrome session to surface auth blockers.",
+    inputSchema,
+    meta: { permissions: { rule: "ask" } },
+    annotations: { openWorldHint: true, destructiveHint: false, readOnlyHint: false },
+    async handler(input) {
+      try {
+        return ok(JSON.stringify(await createSlackCanvas(input), null, 2));
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  }),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true
+  }
+};

package/tools/slack_okta_search_all.mjs

@@ -0,0 +1,33 @@
+export const description = "Search Slack messages, files, and posts (read-only search.all).";
+
+import { z } from "zod";
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+import { searchSlackAll } from "../src/slackSearch.mjs";
+
+const inputSchema = {
+  query: z.string().trim().min(1).max(2048),
+  count: z.number().int().min(1).max(100).optional()
+};
+
+const sharedTool = defineReadOnlyTool({
+  name: "slack_okta_search_all",
+  description: "Search Slack messages, files, and posts (read-only search.all).",
+  inputSchema,
+  meta: { permissions: { rule: "ask" } },
+  annotations: { openWorldHint: true },
+  async handler(input) {
+    try {
+      return ok(JSON.stringify(await searchSlackAll(input.query, input), null, 2));
+    } catch (error) {
+      return fail(error);
+    }
+  }
+});
+
+export default {
+  description,
+  inputSchema: sharedTool.inputSchema,
+  meta: sharedTool.meta,
+  annotations: sharedTool.annotations,
+  handler: sharedTool.handler
+};