@lightupai/polaris 0.0.1

package/src/daemon/daemon.ts

@@ -0,0 +1,275 @@
+import type { Server, ServerWebSocket } from "bun";
+
+// --- Session registry ---
+
+interface SessionMapping {
+  ccSessionId: string;
+  project: string;
+  session: string;
+  user: string;
+  ws: WebSocket | null;
+}
+
+const sessions = new Map<string, SessionMapping>(); // keyed by ccSessionId
+
+// IPC callbacks for MCP servers to receive advisor messages
+const mcpCallbacks = new Map<string, (event: unknown) => void>(); // keyed by ccSessionId
+
+function getServiceUrl(): string {
+  return process.env.POLARIS_SERVICE_URL ?? "http://localhost:4321";
+}
+
+// --- Cloud WebSocket management ---
+
+function connectCloudWs(mapping: SessionMapping) {
+  const serviceUrl = getServiceUrl();
+  const wsUrl = serviceUrl.replace(/^http/, "ws");
+  const ws = new WebSocket(`${wsUrl}/projects/${mapping.project}/sessions/${mapping.session}/ws`);
+
+  ws.onmessage = (event) => {
+    try {
+      const data = JSON.parse(event.data as string);
+      // Forward inject events to the registered MCP callback
+      if (data.source === "inject") {
+        const callback = mcpCallbacks.get(mapping.ccSessionId);
+        if (callback) callback(data);
+      }
+    } catch {
+      // Ignore malformed messages
+    }
+  };
+
+  ws.onclose = () => {
+    // Reconnect if still registered
+    if (sessions.has(mapping.ccSessionId) && sessions.get(mapping.ccSessionId)!.project === mapping.project) {
+      setTimeout(() => {
+        if (sessions.has(mapping.ccSessionId)) {
+          connectCloudWs(sessions.get(mapping.ccSessionId)!);
+        }
+      }, 3000);
+    }
+  };
+
+  ws.onerror = () => {
+    // Will trigger onclose
+  };
+
+  mapping.ws = ws;
+}
+
+function disconnectCloudWs(ccSessionId: string) {
+  const mapping = sessions.get(ccSessionId);
+  if (mapping?.ws) {
+    mapping.ws.close();
+    mapping.ws = null;
+  }
+}
+
+// --- HTTP Server ---
+
+function json(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+function error(message: string, status: number): Response {
+  return json({ error: message }, status);
+}
+
+export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 4321)): {
+  server: Server;
+  sessions: Map<string, SessionMapping>;
+  mcpCallbacks: Map<string, (event: unknown) => void>;
+  stop: () => void;
+} {
+  const server = Bun.serve({
+    port,
+    hostname: "127.0.0.1",
+
+    async fetch(req) {
+      const url = new URL(req.url);
+      const { pathname } = url;
+      const method = req.method;
+
+      // POST /register — MCP server registers its CC session
+      if (method === "POST" && pathname === "/register") {
+        try {
+          const body = (await req.json()) as { ccSessionId: string };
+          if (!body.ccSessionId) return error("ccSessionId required", 400);
+          // Register without a session mapping yet — that comes from /connect
+          if (!sessions.has(body.ccSessionId)) {
+            sessions.set(body.ccSessionId, {
+              ccSessionId: body.ccSessionId,
+              project: "",
+              session: "",
+              user: "",
+              ws: null,
+            });
+          }
+          return json({ status: "registered", ccSessionId: body.ccSessionId });
+        } catch {
+          return error("Invalid JSON", 400);
+        }
+      }
+
+      // POST /connect — bind a CC session to a polaris project/session
+      if (method === "POST" && pathname === "/connect") {
+        try {
+          const body = (await req.json()) as {
+            ccSessionId: string;
+            project: string;
+            session: string;
+            user: string;
+          };
+          if (!body.ccSessionId || !body.project || !body.session || !body.user) {
+            return error("ccSessionId, project, session, and user are required", 400);
+          }
+
+          // Disconnect existing cloud WS if switching sessions
+          disconnectCloudWs(body.ccSessionId);
+
+          const mapping: SessionMapping = {
+            ccSessionId: body.ccSessionId,
+            project: body.project,
+            session: body.session,
+            user: body.user,
+            ws: null,
+          };
+          sessions.set(body.ccSessionId, mapping);
+
+          // Ensure the project exists on the cloud service (create if not)
+          const serviceUrl = getServiceUrl();
+          await fetch(`${serviceUrl}/projects`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: body.project }),
+          }); // Ignore 409 (already exists)
+
+          // Ensure the session exists (create if not, claim driver)
+          const sessionRes = await fetch(`${serviceUrl}/projects/${body.project}/sessions`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: body.session, driver: body.user }),
+          });
+          if (!sessionRes.ok && sessionRes.status !== 409) {
+            const err = await sessionRes.text();
+            return error(`Failed to create session: ${err}`, 500);
+          }
+
+          // If session already existed, try to claim driver
+          if (sessionRes.status === 409) {
+            await fetch(`${serviceUrl}/projects/${body.project}/sessions/${body.session}/driver`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ driver: body.user }),
+            }); // Ignore errors (might already be driver)
+          }
+
+          // Connect to cloud WebSocket
+          connectCloudWs(mapping);
+
+          return json({
+            status: "connected",
+            project: body.project,
+            session: body.session,
+            user: body.user,
+          });
+        } catch {
+          return error("Invalid JSON", 400);
+        }
+      }
+
+      // POST /disconnect — unbind a CC session
+      if (method === "POST" && pathname === "/disconnect") {
+        try {
+          const body = (await req.json()) as { ccSessionId: string };
+          if (!body.ccSessionId) return error("ccSessionId required", 400);
+          disconnectCloudWs(body.ccSessionId);
+          const mapping = sessions.get(body.ccSessionId);
+          if (mapping) {
+            mapping.project = "";
+            mapping.session = "";
+            mapping.user = "";
+          }
+          return json({ status: "disconnected" });
+        } catch {
+          return error("Invalid JSON", 400);
+        }
+      }
+
+      // POST /events — hook events arrive here, routed by session_id in the payload
+      if (method === "POST" && pathname === "/events") {
+        try {
+          const body = (await req.json()) as { session_id?: string; [key: string]: unknown };
+          const ccSessionId = body.session_id;
+          if (!ccSessionId) return error("session_id required in hook payload", 400);
+
+          const mapping = sessions.get(ccSessionId);
+          if (!mapping || !mapping.project) {
+            // Session not connected to polaris — silently discard
+            return json({ status: "not_connected" });
+          }
+
+          // Relay to cloud service
+          const serviceUrl = getServiceUrl();
+          const res = await fetch(
+            `${serviceUrl}/projects/${mapping.project}/sessions/${mapping.session}/events`,
+            {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ sender: mapping.user, payload: body }),
+            }
+          );
+
+          if (!res.ok) {
+            const err = await res.text();
+            return new Response(err, { status: res.status });
+          }
+          return json({ status: "relayed" });
+        } catch {
+          return error("Invalid JSON", 400);
+        }
+      }
+
+      // GET /status/:ccSessionId — status line queries this
+      if (method === "GET" && pathname.startsWith("/status/")) {
+        const ccSessionId = pathname.slice("/status/".length);
+        const mapping = sessions.get(ccSessionId);
+        if (!mapping || !mapping.project) {
+          return json({ connected: false });
+        }
+        return json({
+          connected: true,
+          project: mapping.project,
+          session: mapping.session,
+          user: mapping.user,
+        });
+      }
+
+      // GET /status — daemon health + all active sessions
+      if (method === "GET" && pathname === "/status") {
+        const active = Array.from(sessions.values())
+          .filter((m) => m.project)
+          .map((m) => ({
+            ccSessionId: m.ccSessionId,
+            project: m.project,
+            session: m.session,
+            user: m.user,
+          }));
+        return json({ ok: true, version: "0.0.1", sessions: active });
+      }
+
+      return error("Not found", 404);
+    },
+  });
+
+  return { server, sessions, mcpCallbacks, stop: () => server.stop(true) };
+}
+
+// --- Run if executed directly ---
+if (import.meta.main) {
+  const { server } = startDaemon();
+  console.error(`Polaris daemon listening on http://127.0.0.1:${server.port}`);
+}

package/src/service/auth.ts

@@ -0,0 +1,45 @@
+import * as jose from "jose";
+
+const JWT_SECRET = new TextEncoder().encode(process.env.POLARIS_JWT_SECRET ?? "polaris-dev-secret-change-in-prod");
+const JWT_ISSUER = "polaris";
+const JWT_EXPIRY = "30d";
+
+export interface TokenPayload {
+  sub: string; // user ID
+  email: string;
+  name: string;
+  org_id: string;
+  participant_id: string;
+}
+
+export async function createToken(payload: TokenPayload): Promise<string> {
+  return new jose.SignJWT({
+    email: payload.email,
+    name: payload.name,
+    org_id: payload.org_id,
+    participant_id: payload.participant_id,
+  })
+    .setProtectedHeader({ alg: "HS256" })
+    .setIssuedAt()
+    .setIssuer(JWT_ISSUER)
+    .setSubject(payload.sub)
+    .setExpirationTime(JWT_EXPIRY)
+    .sign(JWT_SECRET);
+}
+
+export async function verifyToken(token: string): Promise<TokenPayload | null> {
+  try {
+    const { payload } = await jose.jwtVerify(token, JWT_SECRET, {
+      issuer: JWT_ISSUER,
+    });
+    return {
+      sub: payload.sub!,
+      email: payload.email as string,
+      name: payload.name as string,
+      org_id: payload.org_id as string,
+      participant_id: payload.participant_id as string,
+    };
+  } catch {
+    return null;
+  }
+}

package/src/service/db.ts

@@ -0,0 +1,275 @@
+import postgres from "postgres";
+import type { PolarisEvent, Project, Session, ParticipantId } from "../types";
+
+export type Sql = postgres.Sql;
+
+// --- Types ---
+
+export interface Org {
+  id: string;
+  name: string;
+  domain: string | null;
+  slack_team_id: string | null;
+  slack_bot_token: string | null;
+  slack_system_channel_id: string | null;
+  created_at: string;
+}
+
+export interface User {
+  id: string;
+  email: string;
+  name: string;
+  org_id: string;
+  participant_id: string;
+  created_at: string;
+}
+
+// --- Schema ---
+
+export async function createDb(connectionString?: string): Promise<Sql> {
+  const sql = postgres(connectionString ?? process.env.DATABASE_URL ?? "postgres://polaris:polaris@localhost:5432/polaris");
+
+  await sql`
+    CREATE TABLE IF NOT EXISTS orgs (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      domain TEXT,
+      slack_team_id TEXT,
+      slack_bot_token TEXT,
+      slack_system_channel_id TEXT,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+    )
+  `;
+
+  await sql`
+    CREATE TABLE IF NOT EXISTS users (
+      id TEXT PRIMARY KEY,
+      email TEXT NOT NULL UNIQUE,
+      name TEXT NOT NULL,
+      org_id TEXT NOT NULL REFERENCES orgs(id),
+      participant_id TEXT NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+    )
+  `;
+
+  await sql`
+    CREATE TABLE IF NOT EXISTS projects (
+      name TEXT NOT NULL,
+      org_id TEXT NOT NULL REFERENCES orgs(id),
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      PRIMARY KEY (org_id, name)
+    )
+  `;
+
+  await sql`
+    CREATE TABLE IF NOT EXISTS sessions (
+      name TEXT NOT NULL,
+      project TEXT NOT NULL,
+      org_id TEXT NOT NULL,
+      driver TEXT,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      PRIMARY KEY (org_id, project, name),
+      FOREIGN KEY (org_id, project) REFERENCES projects(org_id, name)
+    )
+  `;
+
+  await sql`
+    CREATE TABLE IF NOT EXISTS events (
+      id UUID PRIMARY KEY,
+      org_id TEXT NOT NULL,
+      project TEXT NOT NULL,
+      session TEXT NOT NULL,
+      timestamp TIMESTAMPTZ NOT NULL,
+      source TEXT NOT NULL,
+      sender TEXT NOT NULL,
+      payload JSONB NOT NULL
+    )
+  `;
+
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_events_project ON events(org_id, project, timestamp)
+  `;
+
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_events_session ON events(org_id, project, session, timestamp)
+  `;
+
+  return sql;
+}
+
+// --- Orgs ---
+
+export async function createOrg(sql: Sql, id: string, name: string, domain?: string): Promise<Org> {
+  const [row] = await sql`
+    INSERT INTO orgs (id, name, domain) VALUES (${id}, ${name}, ${domain ?? null})
+    RETURNING *
+  `;
+  return { ...row, created_at: row.created_at.toISOString() } as Org;
+}
+
+export async function getOrg(sql: Sql, id: string): Promise<Org | null> {
+  const [row] = await sql`SELECT * FROM orgs WHERE id = ${id}`;
+  if (!row) return null;
+  return { ...row, created_at: row.created_at.toISOString() } as Org;
+}
+
+export async function getOrgByDomain(sql: Sql, domain: string): Promise<Org | null> {
+  const [row] = await sql`SELECT * FROM orgs WHERE domain = ${domain}`;
+  if (!row) return null;
+  return { ...row, created_at: row.created_at.toISOString() } as Org;
+}
+
+export async function setOrgSlack(sql: Sql, orgId: string, teamId: string, botToken: string, systemChannelId?: string): Promise<void> {
+  await sql`UPDATE orgs SET slack_team_id = ${teamId}, slack_bot_token = ${botToken}, slack_system_channel_id = ${systemChannelId ?? null} WHERE id = ${orgId}`;
+}
+
+// --- Users ---
+
+export async function createUser(sql: Sql, id: string, email: string, name: string, orgId: string, participantId: string): Promise<User> {
+  const [row] = await sql`
+    INSERT INTO users (id, email, name, org_id, participant_id) VALUES (${id}, ${email}, ${name}, ${orgId}, ${participantId})
+    RETURNING *
+  `;
+  return { ...row, created_at: row.created_at.toISOString() } as User;
+}
+
+export async function getUser(sql: Sql, id: string): Promise<User | null> {
+  const [row] = await sql`SELECT * FROM users WHERE id = ${id}`;
+  if (!row) return null;
+  return { ...row, created_at: row.created_at.toISOString() } as User;
+}
+
+export async function getUserByEmail(sql: Sql, email: string): Promise<User | null> {
+  const [row] = await sql`SELECT * FROM users WHERE email = ${email}`;
+  if (!row) return null;
+  return { ...row, created_at: row.created_at.toISOString() } as User;
+}
+
+export async function upsertUser(sql: Sql, id: string, email: string, name: string, orgId: string, participantId: string): Promise<User> {
+  const [row] = await sql`
+    INSERT INTO users (id, email, name, org_id, participant_id) VALUES (${id}, ${email}, ${name}, ${orgId}, ${participantId})
+    ON CONFLICT (email) DO UPDATE SET name = ${name}, org_id = ${orgId}, participant_id = ${participantId}
+    RETURNING *
+  `;
+  return { ...row, created_at: row.created_at.toISOString() } as User;
+}
+
+// --- Projects (org-scoped) ---
+
+export async function createProject(sql: Sql, orgId: string, name: string): Promise<Project> {
+  const [row] = await sql`
+    INSERT INTO projects (name, org_id) VALUES (${name}, ${orgId}) RETURNING name, created_at
+  `;
+  return { name: row.name, created_at: row.created_at.toISOString() };
+}
+
+export async function getProject(sql: Sql, orgId: string, name: string): Promise<Project | null> {
+  const [row] = await sql`
+    SELECT name, created_at FROM projects WHERE org_id = ${orgId} AND name = ${name}
+  `;
+  if (!row) return null;
+  return { name: row.name, created_at: row.created_at.toISOString() };
+}
+
+// --- Sessions (org-scoped) ---
+
+export async function createSession(
+  sql: Sql,
+  orgId: string,
+  project: string,
+  name: string,
+  driver: ParticipantId | null
+): Promise<Session> {
+  const [row] = await sql`
+    INSERT INTO sessions (name, project, org_id, driver)
+    VALUES (${name}, ${project}, ${orgId}, ${driver})
+    RETURNING name, project, driver, created_at
+  `;
+  return {
+    name: row.name,
+    project: row.project,
+    driver: row.driver,
+    created_at: row.created_at.toISOString(),
+  };
+}
+
+export async function getSession(sql: Sql, orgId: string, project: string, name: string): Promise<Session | null> {
+  const [row] = await sql`
+    SELECT name, project, driver, created_at FROM sessions
+    WHERE org_id = ${orgId} AND project = ${project} AND name = ${name}
+  `;
+  if (!row) return null;
+  return {
+    name: row.name,
+    project: row.project,
+    driver: row.driver,
+    created_at: row.created_at.toISOString(),
+  };
+}
+
+export async function setDriver(sql: Sql, orgId: string, project: string, session: string, driver: ParticipantId): Promise<void> {
+  await sql`
+    UPDATE sessions SET driver = ${driver}
+    WHERE org_id = ${orgId} AND project = ${project} AND name = ${session}
+  `;
+}
+
+export async function clearDriver(sql: Sql, orgId: string, project: string, session: string): Promise<void> {
+  await sql`
+    UPDATE sessions SET driver = NULL
+    WHERE org_id = ${orgId} AND project = ${project} AND name = ${session}
+  `;
+}
+
+// --- Events (org-scoped) ---
+
+export async function pushEvent(sql: Sql, orgId: string, event: PolarisEvent): Promise<void> {
+  await sql`
+    INSERT INTO events (id, org_id, project, session, timestamp, source, sender, payload)
+    VALUES (${event.id}, ${orgId}, ${event.project}, ${event.session}, ${event.timestamp}, ${event.source}, ${event.sender}, ${sql.json(event.payload)})
+  `;
+}
+
+function rowToEvent(row: {
+  id: string;
+  project: string;
+  session: string;
+  timestamp: Date;
+  source: string;
+  sender: string;
+  payload: unknown;
+}): PolarisEvent {
+  return {
+    id: row.id,
+    project: row.project,
+    session: row.session,
+    timestamp: row.timestamp.toISOString(),
+    source: row.source as PolarisEvent["source"],
+    sender: row.sender as ParticipantId,
+    payload: row.payload as PolarisEvent["payload"],
+  };
+}
+
+export async function getProjectEvents(sql: Sql, orgId: string, project: string): Promise<PolarisEvent[]> {
+  const rows = await sql`
+    SELECT id, project, session, timestamp, source, sender, payload
+    FROM events WHERE org_id = ${orgId} AND project = ${project} ORDER BY timestamp ASC
+  `;
+  return rows.map(rowToEvent);
+}
+
+export async function getSessionEvents(sql: Sql, orgId: string, project: string, session: string): Promise<PolarisEvent[]> {
+  const rows = await sql`
+    SELECT id, project, session, timestamp, source, sender, payload
+    FROM events WHERE org_id = ${orgId} AND project = ${project} AND session = ${session} ORDER BY timestamp ASC
+  `;
+  return rows.map(rowToEvent);
+}
+
+export async function getEventsSince(sql: Sql, orgId: string, project: string, since: string): Promise<PolarisEvent[]> {
+  const rows = await sql`
+    SELECT id, project, session, timestamp, source, sender, payload
+    FROM events WHERE org_id = ${orgId} AND project = ${project} AND timestamp > ${since} ORDER BY timestamp ASC
+  `;
+  return rows.map(rowToEvent);
+}