@lightupai/polaris 0.0.4 → 0.0.6

package/src/client/client.ts

@@ -7,8 +7,7 @@ import {
 
 // --- Configuration ---
 
-const DAEMON_URL = process.env.POLARIS_DAEMON_URL ?? "http://127.0.0.1:4321";
-const SERVICE_URL = process.env.POLARIS_SERVICE_URL ?? "http://localhost:4321";
+const DAEMON_URL = process.env.POLARIS_DAEMON_URL ?? "http://127.0.0.1:4322";
 
 // Generate a stable session ID for this MCP server instance
 const CC_SESSION_ID = process.env.POLARIS_CC_SESSION_ID ?? crypto.randomUUID();
@@ -27,12 +26,6 @@ async function daemonGet(path: string): Promise<Response> {
   return fetch(`${DAEMON_URL}${path}`);
 }
 
-// --- Cloud service (direct, for context queries) ---
-
-async function serviceGet(path: string): Promise<Response> {
-  return fetch(`${SERVICE_URL}${path}`);
-}
-
 // --- Current connection state ---
 
 let currentProject = "";
@@ -94,6 +87,17 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ["message"],
       },
     },
+    {
+      name: "polaris_rename",
+      description: "Rename the current project. Also renames the Slack channel.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          name: { type: "string", description: "New project name" },
+        },
+        required: ["name"],
+      },
+    },
     {
       name: "polaris_context",
       description: "Fetch activity from a sibling session in this project. Use this to see what other drivers have been doing.",
@@ -164,24 +168,33 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     }
     const message = (args as { message: string }).message;
     try {
-      const res = await fetch(`${SERVICE_URL}/projects/${currentProject}/sessions/${currentSession}/events`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          sender: currentUser,
-          payload: {
-            hook_event_name: "Stop",
-            session_id: CC_SESSION_ID,
-            stop_response: message,
-          },
-        }),
-      });
+      const res = await daemonPost("/reply", { ccSessionId: CC_SESSION_ID, message });
       if (res.ok) {
         return { content: [{ type: "text", text: "Reply sent to the floor." }] };
       }
-      return { content: [{ type: "text", text: `Failed to send reply: ${res.status}` }] };
+      const body = await res.json();
+      return { content: [{ type: "text", text: `Failed to send reply: ${(body as { error?: string }).error ?? res.status}` }] };
+    } catch {
+      return { content: [{ type: "text", text: "Failed to reach the daemon." }] };
+    }
+  }
+
+  if (name === "polaris_rename") {
+    if (!currentProject) {
+      return { content: [{ type: "text", text: "Not connected to a Polaris session. Use polaris_connect first." }] };
+    }
+    const newName = (args as { name: string }).name;
+    try {
+      const res = await daemonPost("/rename", { oldName: currentProject, newName });
+      const body = await res.json();
+      if (res.ok) {
+        const oldName = currentProject;
+        currentProject = newName;
+        return { content: [{ type: "text", text: `Renamed project "${oldName}" to "${newName}".` }] };
+      }
+      return { content: [{ type: "text", text: `Failed to rename: ${(body as { error?: string }).error ?? "unknown error"}` }] };
     } catch {
-      return { content: [{ type: "text", text: "Failed to reach the cloud service." }] };
+      return { content: [{ type: "text", text: "Failed to rename — is the Polaris daemon running?" }] };
     }
   }
 
@@ -191,7 +204,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     }
     const targetSession = (args as { session: string }).session;
     try {
-      const res = await serviceGet(`/projects/${currentProject}/sessions/${targetSession}/messages`);
+      const res = await daemonGet(`/context/${CC_SESSION_ID}/${targetSession}`);
       if (!res.ok) {
         return { content: [{ type: "text", text: `Could not fetch session "${targetSession}": ${res.status}` }] };
       }
@@ -208,7 +221,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         .join("\n");
       return { content: [{ type: "text", text: summary || "(no activity yet)" }] };
     } catch {
-      return { content: [{ type: "text", text: "Failed to reach the cloud service." }] };
+      return { content: [{ type: "text", text: "Failed to reach the daemon." }] };
     }
   }
 

package/src/daemon/daemon.ts

@@ -1,4 +1,7 @@
 import type { Server, ServerWebSocket } from "bun";
+import { readFile, appendFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
 
 // --- Session registry ---
 
@@ -7,6 +10,7 @@ interface SessionMapping {
   project: string;
   session: string;
   user: string;
+  slackChannel?: string;
   ws: WebSocket | null;
 }
 
@@ -15,8 +19,67 @@ 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
 
+// --- Config resolution (env var > config.json > legacy credentials.json > defaults) ---
+
+interface PolarisConfig {
+  active: string;
+  profiles: Record<string, { api: string; token: string; [key: string]: unknown }>;
+}
+
+let cachedConfig: PolarisConfig | null | undefined = undefined;
+async function loadConfig(): Promise<PolarisConfig | null> {
+  if (cachedConfig !== undefined) return cachedConfig;
+  try {
+    const configPath = join(homedir(), ".polaris", "config.json");
+    cachedConfig = JSON.parse(await readFile(configPath, "utf-8"));
+    return cachedConfig;
+  } catch {
+    cachedConfig = null;
+    return null;
+  }
+}
+
 function getServiceUrl(): string {
-  return process.env.POLARIS_SERVICE_URL ?? "http://localhost:4321";
+  // 1. Env var override (Makefile uses this for local dev)
+  if (process.env.POLARIS_SERVICE_URL) return process.env.POLARIS_SERVICE_URL;
+  // 2. Active profile (read synchronously from cache — loaded at startup)
+  if (cachedConfig?.active && cachedConfig.profiles[cachedConfig.active]) {
+    return cachedConfig.profiles[cachedConfig.active].api;
+  }
+  // 3. Fallback
+  return "https://api.polaris.lightup.ai";
+}
+
+let cachedToken: string | null | undefined = undefined;
+async function getAuthToken(): Promise<string | null> {
+  if (cachedToken !== undefined) return cachedToken;
+  // 1. Env var (for testing). Empty string means "no auth".
+  if (process.env.POLARIS_AUTH_TOKEN !== undefined) {
+    cachedToken = process.env.POLARIS_AUTH_TOKEN || null;
+    return cachedToken;
+  }
+  // 2. Active profile in config.json
+  const config = await loadConfig();
+  if (config?.active && config.profiles[config.active]?.token) {
+    cachedToken = config.profiles[config.active].token;
+    return cachedToken;
+  }
+  // 3. Legacy credentials.json
+  try {
+    const credsPath = join(homedir(), ".polaris", "credentials.json");
+    const creds = JSON.parse(await readFile(credsPath, "utf-8"));
+    cachedToken = creds.token ?? null;
+    return cachedToken;
+  } catch {
+    cachedToken = null;
+    return null;
+  }
+}
+
+async function authHeaders(): Promise<Record<string, string>> {
+  const token = await getAuthToken();
+  if (token) return { "Content-Type": "application/json", Authorization: `Bearer ${token}` };
+  return { "Content-Type": "application/json" };
 }
 
 // --- Cloud WebSocket management ---
@@ -65,6 +128,26 @@ function disconnectCloudWs(ccSessionId: string) {
   }
 }
 
+// --- Local event log (JSONL) for manual recovery ---
+
+const LOG_DIR = join(homedir(), ".polaris", "logs");
+let logReady: Promise<void> | null = null;
+
+function ensureLogDir(): Promise<void> {
+  if (!logReady) logReady = mkdir(LOG_DIR, { recursive: true }).then(() => {});
+  return logReady;
+}
+
+async function logEvent(endpoint: string, payload: unknown, response?: { status: number; body?: unknown }): Promise<void> {
+  try {
+    await ensureLogDir();
+    const entry: Record<string, unknown> = { t: new Date().toISOString(), endpoint, payload };
+    if (response) entry.response = response;
+    const file = join(LOG_DIR, `daemon-${new Date().toISOString().slice(0, 10)}.jsonl`);
+    await appendFile(file, JSON.stringify(entry) + "\n");
+  } catch { /* best-effort — don't break the request */ }
+}
+
 // --- HTTP Server ---
 
 function json(data: unknown, status = 200): Response {
@@ -123,6 +206,7 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
             session: string;
             user: string;
           };
+          await logEvent("/connect", body);
           if (!body.ccSessionId || !body.project || !body.session || !body.user) {
             return error("ccSessionId, project, session, and user are required", 400);
           }
@@ -143,18 +227,19 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
           const serviceUrl = getServiceUrl();
           await fetch(`${serviceUrl}/projects`, {
             method: "POST",
-            headers: { "Content-Type": "application/json" },
+            headers: await authHeaders(),
             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" },
+            headers: await authHeaders(),
             body: JSON.stringify({ name: body.session, driver: body.user }),
           });
           if (!sessionRes.ok && sessionRes.status !== 409) {
             const err = await sessionRes.text();
+            await logEvent("/connect", body, { status: sessionRes.status, body: err });
             return error(`Failed to create session: ${err}`, 500);
           }
 
@@ -162,11 +247,22 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
           if (sessionRes.status === 409) {
             await fetch(`${serviceUrl}/projects/${body.project}/sessions/${body.session}/driver`, {
               method: "POST",
-              headers: { "Content-Type": "application/json" },
+              headers: await authHeaders(),
               body: JSON.stringify({ driver: body.user }),
             }); // Ignore errors (might already be driver)
           }
 
+          // Fetch Slack channel name for status display
+          try {
+            const projRes = await fetch(`${serviceUrl}/projects/${body.project}`, {
+              headers: await authHeaders(),
+            });
+            if (projRes.ok) {
+              const projData = await projRes.json() as { slack_channel_name?: string };
+              mapping.slackChannel = projData.slack_channel_name ?? undefined;
+            }
+          } catch {}
+
           // Connect to cloud WebSocket
           connectCloudWs(mapping);
 
@@ -199,17 +295,42 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
         }
       }
 
+      // POST /disconnect-all — disconnect all sessions (for testing)
+      if (method === "POST" && pathname === "/disconnect-all") {
+        for (const [id, mapping] of sessions) {
+          disconnectCloudWs(id);
+          mapping.project = "";
+          mapping.session = "";
+          mapping.user = "";
+        }
+        sessions.clear();
+        return json({ status: "all_disconnected" });
+      }
+
       // 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 };
+          await logEvent("/events", body);
           const ccSessionId = body.session_id;
           if (!ccSessionId) return error("session_id required in hook payload", 400);
 
-          const mapping = sessions.get(ccSessionId);
+          let mapping = sessions.get(ccSessionId);
           if (!mapping || !mapping.project) {
-            // Session not connected to polaris — silently discard
-            return json({ status: "not_connected" });
+            // CC session_id doesn't match any registered MCP client.
+            // Try to find a connected session to route to (the MCP client
+            // generates its own UUID, which differs from CC's session_id).
+            const connectedSessions = Array.from(sessions.values()).filter((m) => m.project);
+            if (connectedSessions.length === 1) {
+              // Only one active session — route to it and remember the mapping
+              mapping = connectedSessions[0];
+              sessions.set(ccSessionId, { ...mapping, ccSessionId, slackChannel: undefined });
+            } else if (connectedSessions.length > 1) {
+              // Multiple sessions — can't determine which one. Discard.
+              return json({ status: "ambiguous" });
+            } else {
+              return json({ status: "not_connected" });
+            }
           }
 
           // Relay to cloud service
@@ -218,13 +339,14 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
             `${serviceUrl}/projects/${mapping.project}/sessions/${mapping.session}/events`,
             {
               method: "POST",
-              headers: { "Content-Type": "application/json" },
+              headers: await authHeaders(),
               body: JSON.stringify({ sender: mapping.user, payload: body }),
             }
           );
 
           if (!res.ok) {
             const err = await res.text();
+            await logEvent("/events", body, { status: res.status, body: err });
             return new Response(err, { status: res.status });
           }
           return json({ status: "relayed" });
@@ -233,6 +355,55 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
         }
       }
 
+      // POST /rename — rename a project (proxies to cloud API, updates local state)
+      if (method === "POST" && pathname === "/rename") {
+        try {
+          const body = (await req.json()) as { oldName: string; newName: string };
+          if (!body.oldName || !body.newName) return error("oldName and newName required", 400);
+
+          // Call cloud API to rename in DB
+          const serviceUrl = getServiceUrl();
+          const res = await fetch(`${serviceUrl}/projects/${body.oldName}/rename`, {
+            method: "POST",
+            headers: await authHeaders(),
+            body: JSON.stringify({ name: body.newName }),
+          });
+          if (!res.ok) {
+            const err = await res.text();
+            return new Response(err, { status: res.status });
+          }
+
+          // Update in-memory sessions
+          for (const m of sessions.values()) {
+            if (m.project === body.oldName) {
+              m.project = body.newName;
+              m.slackChannel = body.newName;
+            }
+          }
+
+          return json({ status: "renamed", oldName: body.oldName, newName: body.newName });
+        } catch {
+          return error("Invalid JSON", 400);
+        }
+      }
+
+      // POST /channel-update — bridge pushes channel rename notifications
+      if (method === "POST" && pathname === "/channel-update") {
+        try {
+          const body = (await req.json()) as { project: string; slackChannel: string };
+          if (!body.project || !body.slackChannel) return error("project and slackChannel required", 400);
+          // Update all sessions for this project
+          for (const m of sessions.values()) {
+            if (m.project === body.project) {
+              m.slackChannel = body.slackChannel;
+            }
+          }
+          return json({ status: "updated" });
+        } 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);
@@ -240,11 +411,22 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
         if (!mapping || !mapping.project) {
           return json({ connected: false });
         }
+        // Resolve slackChannel from any session in the same project
+        let slackChannel = mapping.slackChannel ?? null;
+        if (!slackChannel) {
+          for (const m of sessions.values()) {
+            if (m.project === mapping.project && m.slackChannel) {
+              slackChannel = m.slackChannel;
+              break;
+            }
+          }
+        }
         return json({
           connected: true,
           project: mapping.project,
           session: mapping.session,
           user: mapping.user,
+          slackChannel,
         });
       }
 
@@ -261,6 +443,63 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
         return json({ ok: true, version: "0.0.1", sessions: active });
       }
 
+      // POST /reply — proxy a reply event to the cloud API
+      if (method === "POST" && pathname === "/reply") {
+        try {
+          const body = (await req.json()) as { ccSessionId: string; message: string };
+          await logEvent("/reply", body);
+          if (!body.ccSessionId || !body.message) return error("ccSessionId and message required", 400);
+          const mapping = sessions.get(body.ccSessionId);
+          if (!mapping || !mapping.project) return error("Not connected", 400);
+
+          const serviceUrl = getServiceUrl();
+          const res = await fetch(
+            `${serviceUrl}/projects/${mapping.project}/sessions/${mapping.session}/events`,
+            {
+              method: "POST",
+              headers: await authHeaders(),
+              body: JSON.stringify({
+                sender: mapping.user,
+                payload: {
+                  hook_event_name: "Stop",
+                  session_id: body.ccSessionId,
+                  stop_response: body.message,
+                },
+              }),
+            }
+          );
+          if (!res.ok) {
+            const err = await res.text();
+            await logEvent("/reply", body, { status: res.status, body: err });
+            return new Response(err, { status: res.status });
+          }
+          return json({ status: "sent" });
+        } catch {
+          return error("Invalid JSON", 400);
+        }
+      }
+
+      // GET /context/:ccSessionId/:session — proxy context fetch from cloud API
+      if (method === "GET" && pathname.match(/^\/context\/[^/]+\/[^/]+$/)) {
+        const parts = pathname.split("/");
+        const ccSessionId = parts[2];
+        const targetSession = parts[3];
+        const mapping = sessions.get(ccSessionId);
+        if (!mapping || !mapping.project) return error("Not connected", 400);
+
+        const serviceUrl = getServiceUrl();
+        const res = await fetch(
+          `${serviceUrl}/projects/${mapping.project}/sessions/${targetSession}/messages`,
+          { headers: await authHeaders() }
+        );
+        if (!res.ok) {
+          const err = await res.text();
+          return new Response(err, { status: res.status });
+        }
+        const data = await res.json();
+        return json(data);
+      }
+
       return error("Not found", 404);
     },
   });
@@ -270,6 +509,9 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
 
 // --- Run if executed directly ---
 if (import.meta.main) {
+  // Load config before starting so getServiceUrl() has the active profile
+  await loadConfig();
   const { server } = startDaemon();
   console.error(`Polaris daemon listening on http://127.0.0.1:${server.port}`);
+  console.error(`  API endpoint: ${getServiceUrl()}`);
 }