@lightupai/polaris 0.0.4 → 0.0.6

package/src/slack/bridge.ts

@@ -0,0 +1,399 @@
+// --- Slack Bridge ---
+// Connects a project's event stream to a Slack channel.
+// Runs server-side, one bridge per org.
+//
+// Project → Slack: session events → formatted Slack posts
+// Slack → Project: advisor messages → injected into target session
+
+import { SocketModeClient } from "@slack/socket-mode";
+import { WebClient } from "@slack/web-api";
+import { createDb, getOrg, listProjects, getProjectEvents, getOrgEventsSince, getSession, createSession, pushEvent, setProjectSlackChannel, type Sql, type Org } from "../service/db";
+import { formatEventForSlack, toMrkdwn, THREAD_THRESHOLD } from "./format";
+import type { PolarisEvent } from "../types";
+
+// --- Channel management ---
+
+// In-memory cache: project name → Slack channel ID
+const channelCache = new Map<string, string>();
+
+async function getOrCreateChannel(web: WebClient, sql: Sql, orgId: string, projectName: string): Promise<string> {
+  // 1. Check in-memory cache
+  const cached = channelCache.get(projectName);
+  if (cached) return cached;
+
+  // 2. Check DB for stored channel ID (survives renames and restarts)
+  const projects = await listProjects(sql, orgId);
+  const project = projects.find((p) => p.name === projectName);
+  if (project?.slack_channel_id) {
+    channelCache.set(projectName, project.slack_channel_id);
+    // Ensure bot is in the channel (might have been removed)
+    try { await web.conversations.join({ channel: project.slack_channel_id }); } catch {}
+    return project.slack_channel_id;
+  }
+
+  // 3. Create or find channel by name
+  const channelName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-").slice(0, 80);
+  let channelId: string | undefined;
+
+  try {
+    const result = await web.conversations.create({ name: channelName, is_private: false });
+    if (result.ok && result.channel?.id) {
+      channelId = result.channel.id;
+      await web.conversations.setTopic({
+        channel: channelId,
+        topic: `Polaris project: ${projectName}`,
+      });
+    }
+  } catch {
+    // name_taken — find and join
+  }
+
+  if (!channelId) {
+    let cursor: string | undefined;
+    do {
+      const list = await web.conversations.list({
+        types: "public_channel",
+        limit: 200,
+        exclude_archived: true,
+        cursor,
+      });
+      const found = list.channels?.find((c) => c.name === channelName);
+      if (found?.id) {
+        channelId = found.id;
+        await web.conversations.join({ channel: channelId });
+        break;
+      }
+      cursor = list.response_metadata?.next_cursor || undefined;
+    } while (cursor);
+  }
+
+  if (!channelId) {
+    throw new Error(`Could not create or find channel for project: ${projectName}`);
+  }
+
+  // 4. Persist the channel ID in DB (resilient to renames)
+  channelCache.set(projectName, channelId);
+  // Resolve and store channel name (for status line display)
+  let resolvedName: string | undefined;
+  try {
+    const info = await web.conversations.info({ channel: channelId });
+    resolvedName = info.channel?.name ?? undefined;
+  } catch {}
+  await setProjectSlackChannel(sql, orgId, projectName, channelId, resolvedName);
+  return channelId;
+}
+
+// --- Event → Slack posting ---
+
+async function postEventToSlack(web: WebClient, sql: Sql, orgId: string, event: PolarisEvent): Promise<void> {
+  // Skip _system events (handled separately)
+  if (event.project === "_system") return;
+
+  // Skip events that originated from Slack (avoid re-posting)
+  if (event.sender.startsWith("slack:")) return;
+
+  const msg = formatEventForSlack(event);
+  if (!msg) return;
+
+  try {
+    const channelId = await getOrCreateChannel(web, sql, orgId, event.project);
+    const isLong = msg.text.length > THREAD_THRESHOLD;
+    // POLARIS_LONG_MSG controls how messages longer than THREAD_THRESHOLD are posted:
+    //   "snippet" (default) — 500-char preview + full content as expandable text snippet
+    //   "thread"  — 500-char preview in channel, full content in a thread reply
+    //   "inline"  — post the full message directly in the channel (may be very long)
+    const longMode = process.env.POLARIS_LONG_MSG ?? "snippet";
+
+    if (!isLong || longMode === "inline") {
+      await web.chat.postMessage({
+        channel: channelId,
+        text: msg.text,
+        ...(msg.blocks ? { blocks: msg.blocks } : {}),
+        ...(msg.username ? { username: msg.username } : {}),
+        ...(msg.icon_emoji ? { icon_emoji: msg.icon_emoji } : {}),
+      });
+    } else if (longMode === "thread") {
+      const preview = msg.text.slice(0, 500).trimEnd();
+      const summaryText = `${preview}...\n\n_Full response in thread_ :thread:`;
+      const summary = await web.chat.postMessage({
+        channel: channelId,
+        text: summaryText,
+        blocks: [{ type: "section", text: { type: "mrkdwn", text: summaryText } }],
+        ...(msg.username ? { username: msg.username } : {}),
+        ...(msg.icon_emoji ? { icon_emoji: msg.icon_emoji } : {}),
+      });
+      if (summary.ok && summary.ts) {
+        await web.chat.postMessage({
+          channel: channelId,
+          thread_ts: summary.ts,
+          text: msg.text,
+          ...(msg.username ? { username: msg.username } : {}),
+          ...(msg.icon_emoji ? { icon_emoji: msg.icon_emoji } : {}),
+        });
+      }
+    } else {
+      // snippet mode — preview + expandable file attachment
+      // Requires files:write scope on the Slack bot token
+      const preview = msg.text.slice(0, 500).trimEnd();
+      const summaryText = `${preview}...`;
+      await web.chat.postMessage({
+        channel: channelId,
+        text: summaryText,
+        blocks: [{ type: "section", text: { type: "mrkdwn", text: summaryText } }],
+        ...(msg.username ? { username: msg.username } : {}),
+        ...(msg.icon_emoji ? { icon_emoji: msg.icon_emoji } : {}),
+      });
+      const sender = msg.username ?? "agent";
+      await web.filesUploadV2({
+        channel_id: channelId,
+        content: msg.text,
+        filename: `${sender.toLowerCase().replace(/[^a-z0-9-]/g, "-")}-${event.session}-${Date.now()}.md`,
+        title: `${sender} — full response`,
+        initial_comment: `_Expand to read the full response from ${sender}_`,
+      });
+    }
+  } catch (e) {
+    console.error(`[bridge] Failed to post to Slack for project ${event.project}:`, e);
+  }
+}
+
+// --- Slack → Project injection ---
+
+async function handleSlackMessage(
+  web: WebClient,
+  sql: Sql,
+  orgId: string,
+  botUserId: string,
+  event: {
+    text: string;
+    user: string;
+    channel: string;
+    ts: string;
+  }
+): Promise<void> {
+  // Ignore bot's own messages
+  if (event.user === botUserId) return;
+
+  // Find which project this channel belongs to
+  let projectName: string | undefined;
+
+  // Check in-memory cache
+  for (const [proj, chanId] of channelCache) {
+    if (chanId === event.channel) {
+      projectName = proj;
+      break;
+    }
+  }
+
+  // Check DB
+  if (!projectName) {
+    const projects = await listProjects(sql, orgId);
+    for (const proj of projects) {
+      if (proj.slack_channel_id === event.channel) {
+        projectName = proj.name;
+        channelCache.set(proj.name, event.channel);
+        break;
+      }
+    }
+  }
+
+  // Fall back to channel name lookup
+  if (!projectName) {
+    try {
+      const info = await web.conversations.info({ channel: event.channel });
+      const chanName = info.channel?.name;
+      if (chanName) {
+        projectName = chanName;
+        channelCache.set(chanName, event.channel);
+      }
+    } catch {
+      return;
+    }
+  }
+
+  if (!projectName) {
+    return;
+  }
+
+  // Parse target session from message: @session-name or first word
+  // Format: "@session message" or "session: message"
+  const match = event.text.match(/^@(\S+)\s+(.+)$/s) || event.text.match(/^(\S+):\s+(.+)$/s);
+  if (!match) {
+    // No target specified — post a hint
+    try {
+      await web.chat.postMessage({
+        channel: event.channel,
+        thread_ts: event.ts,
+        text: `To send a message to a session, use: \`@session-name your message\``,
+      });
+    } catch { /* ignore */ }
+    return;
+  }
+
+  const targetSession = match[1];
+  const content = match[2];
+
+  // Look up Slack user to get display name
+  let senderName = `slack:${event.user}`;
+  try {
+    const userInfo = await web.users.info({ user: event.user });
+    if (userInfo.user?.profile?.display_name || userInfo.user?.real_name) {
+      const name = (userInfo.user.profile?.display_name || userInfo.user.real_name || "")
+        .toLowerCase().replace(/\s+/g, ".");
+      senderName = `slack:${name}`;
+    }
+  } catch { /* use ID */ }
+
+  // Inject directly into DB (bridge runs server-side with DB access)
+  try {
+    // Ensure session exists
+    let session = await getSession(sql, orgId, projectName, targetSession);
+    if (!session) {
+      try { session = await createSession(sql, orgId, projectName, targetSession, null); } catch { /* exists */ }
+      session = await getSession(sql, orgId, projectName, targetSession);
+    }
+    if (!session) {
+      console.error(`[bridge] Session ${projectName}/${targetSession} not found`);
+      await web.chat.postMessage({
+        channel: event.channel,
+        thread_ts: event.ts,
+        text: `Session \`${targetSession}\` not found in project \`${projectName}\`.`,
+      });
+      return;
+    }
+    const injectEvent = {
+      id: crypto.randomUUID(),
+      project: projectName,
+      session: targetSession,
+      timestamp: new Date().toISOString(),
+      source: "inject" as const,
+      sender: senderName as `${"user" | "agent" | "slack"}:${string}`,
+      payload: {
+        type: "inject" as const,
+        content,
+        sender: senderName as `${"user" | "agent" | "slack"}:${string}`,
+        target: targetSession,
+      },
+    };
+    await pushEvent(sql, orgId, injectEvent);
+    console.error(`[bridge] Injected into ${projectName}/${targetSession}: ${content.slice(0, 50)}`);
+  } catch (e) {
+    console.error(`[bridge] Failed to inject:`, e);
+  }
+}
+
+// --- Bridge startup ---
+
+export async function startBridge(opts: {
+  databaseUrl?: string;
+  orgId: string;
+  apiBaseUrl?: string;
+}): Promise<{ stop: () => void }> {
+  const sql = await createDb(opts.databaseUrl);
+  const org = await getOrg(sql, opts.orgId);
+  if (!org) throw new Error(`Org not found: ${opts.orgId}`);
+  if (!org.slack_bot_token) throw new Error(`Org ${opts.orgId} has no Slack bot token`);
+
+  const appToken = process.env.SLACK_APP_TOKEN;
+  if (!appToken) throw new Error("SLACK_APP_TOKEN required for Socket Mode");
+
+  const apiBaseUrl = opts.apiBaseUrl ?? process.env.POLARIS_API_URL ?? "http://localhost:4321";
+
+  const web = new WebClient(org.slack_bot_token);
+  const socketMode = new SocketModeClient({ appToken });
+
+  // Get bot user ID to filter own messages
+  let botUserId = "";
+  try {
+    const auth = await web.auth.test();
+    botUserId = auth.user_id as string;
+    console.error(`[bridge] Bot user ID: ${botUserId}`);
+  } catch (e) {
+    console.error("[bridge] Failed to get bot user ID:", e);
+  }
+
+  // Listen for Slack messages
+  socketMode.on("message", async ({ event, ack }: { event: Record<string, unknown>; ack: () => Promise<void> }) => {
+    try {
+      await ack();
+      const msg = event as { text?: string; user?: string; channel?: string; ts?: string; subtype?: string; name?: string };
+      console.error(`[bridge] message: user=${msg.user} channel=${msg.channel} subtype=${msg.subtype} text=${msg.text?.slice(0, 80)}`);
+
+      // Handle channel rename system messages
+      if (msg.subtype === "channel_name" && msg.channel && msg.name) {
+        console.error(`[bridge] channel renamed: ${msg.channel} → ${msg.name}`);
+        const projects = await listProjects(sql, opts.orgId);
+        for (const proj of projects) {
+          if (proj.slack_channel_id === msg.channel) {
+            channelCache.set(proj.name, msg.channel);
+            await setProjectSlackChannel(sql, opts.orgId, proj.name, msg.channel, msg.name);
+            // Notify local daemon so status line updates immediately
+            try {
+              await fetch(`http://127.0.0.1:${process.env.POLARIS_DAEMON_PORT ?? 4322}/channel-update`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ project: proj.name, slackChannel: msg.name }),
+              });
+            } catch { /* daemon may not be running */ }
+            console.error(`[bridge] Updated channel name for project ${proj.name}: ${msg.name}`);
+          }
+        }
+        return;
+      }
+
+      if (msg.subtype || !msg.channel || !msg.text || !msg.user) return;
+      if (msg.user === botUserId) return;
+      await handleSlackMessage(web, sql, opts.orgId, botUserId, msg as { text: string; user: string; channel: string; ts: string });
+    } catch (e) {
+      console.error(`[bridge] message handler error:`, e);
+    }
+  });
+
+  // Poll for new events directly from DB (bridge runs server-side)
+  const postedEventIds = new Set<string>();
+  let lastPollTime = new Date().toISOString();
+
+  async function pollEvents() {
+    try {
+      const since = lastPollTime;
+      const events = await getOrgEventsSince(sql, opts.orgId, since);
+      const now = new Date().toISOString();
+
+      for (const event of events) {
+        if (event.project === "_system") continue;
+        if (postedEventIds.has(event.id)) continue;
+        postedEventIds.add(event.id);
+        await postEventToSlack(web, sql, opts.orgId, event);
+      }
+
+      lastPollTime = now;
+    } catch (e) {
+      console.error("[bridge] Poll error:", e);
+    }
+  }
+
+  const pollInterval = setInterval(pollEvents, 5000);
+
+  // Start Socket Mode
+  await socketMode.start();
+  console.error(`[bridge] Slack bridge started for org: ${org.name}`);
+  console.error(`[bridge] Watching for messages in project channels`);
+
+  return {
+    stop: () => {
+      clearInterval(pollInterval);
+      socketMode.disconnect();
+      sql.end();
+    },
+  };
+}
+
+// --- Run if executed directly ---
+if (import.meta.main) {
+  const orgId = process.argv[2];
+  if (!orgId) {
+    console.error("Usage: bun run src/slack/bridge.ts <org-id>");
+    process.exit(1);
+  }
+  await startBridge({ orgId });
+}

package/src/slack/format.ts

@@ -0,0 +1,115 @@
+// --- Event → Slack message formatting ---
+
+import type { PolarisEvent } from "../types";
+
+// Messages longer than this get a summary in the channel + full content in a thread
+export const THREAD_THRESHOLD = 700;
+
+export interface SlackMessage {
+  text: string;
+  blocks?: Array<Record<string, unknown>>;
+  username?: string;
+  icon_emoji?: string;
+}
+
+// Derive a display name from a participant ID
+function displayName(participantId: string): string {
+  const [type, name] = participantId.split(":", 2);
+  if (!name) return participantId;
+  const pretty = name.replace(/[._-]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  if (type === "agent") return `Agent: ${pretty}`;
+  return pretty;
+}
+
+function personaIcon(participantId: string): string {
+  if (participantId.startsWith("agent:")) return ":robot_face:";
+  if (participantId.startsWith("slack:")) return ":speech_balloon:";
+  return ":bust_in_silhouette:";
+}
+
+// Format a PolarisEvent into a Slack message.
+// Returns null if the event should be skipped (e.g., tool calls).
+export function formatEventForSlack(event: PolarisEvent): SlackMessage | null {
+  const payload = event.payload;
+
+  if ("hook_event_name" in payload) {
+    switch (payload.hook_event_name) {
+      case "UserPromptSubmit":
+        return formatUserPrompt(event.sender, event.session, payload.prompt);
+      case "Stop": {
+        const response = payload.stop_response || payload.last_assistant_message;
+        if (!response) return null;
+        return formatAgentResponse(event.session, response);
+      }
+      case "PreToolUse":
+      case "PostToolUse":
+        return null;
+    }
+  }
+
+  if ("type" in payload && payload.type === "inject") {
+    return formatAdvisorMessage(
+      event.sender,
+      (payload as { target: string }).target,
+      (payload as { content: string }).content,
+    );
+  }
+
+  if ("type" in payload && payload.type === "reply") {
+    const body = (payload as { content: string }).content;
+    if (!body) return null;
+    return {
+      text: toMrkdwn(body),
+      blocks: [{ type: "section", text: { type: "mrkdwn", text: toMrkdwn(body) } }],
+      username: displayName(event.sender),
+      icon_emoji: personaIcon(event.sender),
+    };
+  }
+
+  return null;
+}
+
+// --- User prompt ---
+
+function formatUserPrompt(sender: string, session: string, prompt: string): SlackMessage | null {
+  if (!prompt) return null;
+  return {
+    text: toMrkdwn(prompt),
+    blocks: [{ type: "section", text: { type: "mrkdwn", text: toMrkdwn(prompt) } }],
+    username: `${displayName(sender)} (${session})`,
+    icon_emoji: personaIcon(sender),
+  };
+}
+
+// --- Agent response ---
+
+function formatAgentResponse(session: string, response: string): SlackMessage | null {
+  if (!response) return null;
+  return {
+    text: toMrkdwn(response),
+    blocks: [{ type: "section", text: { type: "mrkdwn", text: toMrkdwn(response) } }],
+    username: `Agent (${session})`,
+    icon_emoji: ":robot_face:",
+  };
+}
+
+// --- Advisor message ---
+
+function formatAdvisorMessage(sender: string, target: string, content: string): SlackMessage | null {
+  if (!content) return null;
+  return {
+    text: toMrkdwn(content),
+    blocks: [{ type: "section", text: { type: "mrkdwn", text: toMrkdwn(`→ _${target}_:  ${content}`) } }],
+    username: displayName(sender),
+    icon_emoji: personaIcon(sender),
+  };
+}
+
+// --- Markdown → Slack mrkdwn ---
+
+export function toMrkdwn(text: string): string {
+  return text
+    .replace(/```(\w*)\n([\s\S]*?)```/g, "```$2```")
+    .replace(/\*\*(.*?)\*\*/g, "*$1*")
+    .replace(/__(.*?)__/g, "*$1*");
+}

package/src/types.ts

@@ -27,7 +27,10 @@ export const UserPromptSubmitPayload = HookCommon.extend({
 
 export const StopPayload = HookCommon.extend({
   hook_event_name: z.literal("Stop"),
-  stop_response: z.string(),
+  stop_response: z.string().optional(),
+  last_assistant_message: z.string().optional(),
+  stop_hook_active: z.boolean().optional(),
+  raw_turn: z.array(z.unknown()).optional(),
 });
 
 export const PreToolUsePayload = HookCommon.extend({
@@ -92,7 +95,10 @@ export type PolarisEvent = z.infer<typeof PolarisEvent>;
 // --- Project & Session Models ---
 
 export const Project = z.object({
+  id: z.string().uuid(),
   name: z.string().min(1),
+  slack_channel_id: z.string().nullable().optional(),
+  slack_channel_name: z.string().nullable().optional(),
   created_at: z.string().datetime(),
 });
 

package/src/web/app.ts

@@ -10,6 +10,10 @@ import {
   upsertUser,
   setOrgSlack,
   getSessionEvents,
+  listProjects,
+  listSessions,
+  getSessionPromptCounts,
+  getProjectEvents,
   type Sql,
 } from "../service/db";
 import { layout, nav } from "./layout";
@@ -175,6 +179,34 @@ export function createApp(sql: Sql) {
       }
     } catch { /* _system project may not exist yet */ }
 
+    // Query real projects, sessions, and prompt counts
+    const projects = (await listProjects(sql, payload.org_id)).filter((p) => p.name !== "_system");
+    const allSessions = (await listSessions(sql, payload.org_id)).filter((s) => s.project !== "_system");
+    const promptCounts = await getSessionPromptCounts(sql, payload.org_id);
+
+    function buildSessionFixture(s: typeof allSessions[0]): import("./fixtures").SessionFixture {
+      return {
+        name: s.name,
+        project: s.project,
+        driver: s.driver ?? "",
+        role: (s.driver === payload.participant_id ? "driver" : "advisor") as "driver" | "advisor",
+        description: "",
+        participants: s.driver ? [{ id: s.driver, role: "driver" as const }] : [],
+        eventCount: promptCounts.get(`${s.project}/${s.name}`) ?? 0,
+        connectedSince: s.created_at,
+      };
+    }
+
+    const sessionFixtures = allSessions.map(buildSessionFixture);
+
+    const projectFixtures: import("./fixtures").ProjectFixture[] = projects.map((p) => ({
+      name: p.name,
+      slackChannel: p.slack_channel_name ? `#${p.slack_channel_name}` : "",
+      sessions: allSessions.filter((s) => s.project === p.name).map(buildSessionFixture),
+    }));
+
+    const hasConnectedSession = allSessions.length > 0;
+
     const ctx = {
       token,
       userName: payload.name,
@@ -183,14 +215,12 @@ export function createApp(sql: Sql) {
       email: payload.email,
       slackConnected: !!org.slack_team_id,
       cliInstalled,
-      hasConnectedSession: false,
+      hasConnectedSession,
+      totalPrompts: Array.from(promptCounts.values()).reduce((a, b) => a + b, 0),
     };
 
-    // TODO: query cloud service for active sessions for this user
-    const activeSessions: unknown[] = [];
-
-    if (activeSessions.length > 0) {
-      return layout(renderActiveView(ctx, [], [], devices), "Polaris");
+    if (hasConnectedSession) {
+      return layout(renderActiveView(ctx, sessionFixtures, projectFixtures, devices), "Polaris");
     }
     return layout(renderSetupView(ctx, devices), "Polaris");
   });
@@ -227,10 +257,10 @@ export function createApp(sql: Sql) {
     const mockToken = "preview-token";
     const base = { token: mockToken, userName: mockUser.name, orgName: mockOrg.name, orgSlug: "lightup-data" as string | null, email: mockUser.email };
 
-    const fresh       = { ...base, orgSlug: null, slackConnected: false, cliInstalled: false, hasConnectedSession: false };
-    const slackDone   = { ...base, slackConnected: true,  cliInstalled: false, hasConnectedSession: false };
-    const cliDone     = { ...base, slackConnected: true,  cliInstalled: true,  hasConnectedSession: false };
-    const allDone     = { ...base, slackConnected: true,  cliInstalled: true,  hasConnectedSession: true };
+    const fresh       = { ...base, orgSlug: null, slackConnected: false, cliInstalled: false, hasConnectedSession: false, totalPrompts: 0 };
+    const slackDone   = { ...base, slackConnected: true,  cliInstalled: false, hasConnectedSession: false, totalPrompts: 0 };
+    const cliDone     = { ...base, slackConnected: true,  cliInstalled: true,  hasConnectedSession: false, totalPrompts: 0 };
+    const allDone     = { ...base, slackConnected: true,  cliInstalled: true,  hasConnectedSession: true,  totalPrompts: 127 };
 
     return layout(`
       <div class="max-w-5xl mx-auto px-6 py-12">

package/src/web/layout.ts

@@ -27,8 +27,22 @@ tailwind.config = {
 }
 </script>
 </head>
-<body class="bg-gray-50 text-gray-900 antialiased">${body}</body></html>`,
-    { headers: { "Content-Type": "text/html" } }
+<body class="bg-gray-50 text-gray-900 antialiased">${body}
+<script>
+document.addEventListener('click', function(e) {
+  const btn = e.target.closest('.polaris-copy');
+  if (!btn) return;
+  const id = btn.dataset.copy;
+  const el = document.getElementById(id);
+  if (!el) return;
+  navigator.clipboard.writeText(el.textContent);
+  const orig = btn.innerHTML;
+  btn.innerHTML = '<svg class="w-3.5 h-3.5 text-green-500" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg>';
+  setTimeout(function() { btn.innerHTML = orig; }, 1500);
+});
+</script>
+</body></html>`,
+    { headers: { "Content-Type": "text/html", "Cache-Control": "no-store" } }
   );
 }