@lightupai/polaris 0.0.1

package/scripts/setup-slack-app.sh

@@ -0,0 +1,115 @@
+#!/bin/sh
+# scripts/setup-slack-app.sh
+# Creates a Slack app for Polaris and outputs credentials.
+# Requires a Slack workspace admin token or manual steps.
+#
+# Unfortunately, Slack does not provide a CLI or API to create apps
+# programmatically. This script automates what it can and opens the
+# browser for the manual steps.
+
+set -e
+
+REDIRECT_URI="http://localhost:3000/slack/callback"
+ENV_FILE=".env"
+
+echo "=== Setting up Slack App for Polaris ==="
+echo ""
+echo "This script will open your browser to create a Slack app."
+echo "Follow the steps, then paste the credentials here."
+echo ""
+
+# Step 1: Create the app
+echo "Step 1: Create the Slack app"
+echo "---"
+echo "  1. Click 'Create New App' → 'From scratch'"
+echo "  2. App Name: Polaris"
+echo "  3. Workspace: your development workspace"
+echo "  4. Click 'Create App'"
+echo ""
+open "https://api.slack.com/apps" 2>/dev/null || xdg-open "https://api.slack.com/apps" 2>/dev/null || echo "Open https://api.slack.com/apps in your browser"
+echo "Press Enter when the app is created..."
+read -r
+
+# Step 2: OAuth redirect
+echo ""
+echo "Step 2: Set up OAuth"
+echo "---"
+echo "  1. In the left sidebar, go to 'OAuth & Permissions'"
+echo "  2. Under 'Redirect URLs', click 'Add New Redirect URL'"
+echo "  3. Add: ${REDIRECT_URI}"
+echo "  4. Click 'Save URLs'"
+echo ""
+echo "  5. Scroll to 'Bot Token Scopes' and add these scopes:"
+echo "     - channels:manage"
+echo "     - channels:join"
+echo "     - channels:read"
+echo "     - chat:write"
+echo "     - users:read"
+echo "     - users:read.email"
+echo ""
+echo "Press Enter when done..."
+read -r
+
+# Step 3: Enable Socket Mode
+echo ""
+echo "Step 3: Enable Socket Mode"
+echo "---"
+echo "  1. In the left sidebar, go to 'Socket Mode'"
+echo "  2. Toggle 'Enable Socket Mode' on"
+echo "  3. Name the token: polaris-socket"
+echo "  4. Scope: connections:write (should be pre-selected)"
+echo "  5. Click 'Generate'"
+echo "  6. Copy the token (starts with xapp-)"
+echo ""
+echo "Press Enter when done..."
+read -r
+
+# Step 4: Enable Events (required for Socket Mode)
+echo ""
+echo "Step 4: Enable Events"
+echo "---"
+echo "  1. In the left sidebar, go to 'Event Subscriptions'"
+echo "  2. Toggle 'Enable Events' on"
+echo "  3. Under 'Subscribe to bot events', add:"
+echo "     - message.channels"
+echo "  4. Click 'Save Changes'"
+echo ""
+echo "Press Enter when done..."
+read -r
+
+# Step 5: Collect credentials
+echo ""
+echo "Step 5: Collect credentials"
+echo "---"
+echo "  Go to 'Basic Information' in the left sidebar."
+echo ""
+
+printf "Paste your Client ID: "
+read -r SLACK_CLIENT_ID
+
+printf "Paste your Client Secret: "
+read -r SLACK_CLIENT_SECRET
+
+printf "Paste your Socket Mode token (xapp-...): "
+read -r SLACK_APP_TOKEN
+
+if [ -z "$SLACK_CLIENT_ID" ] || [ -z "$SLACK_CLIENT_SECRET" ] || [ -z "$SLACK_APP_TOKEN" ]; then
+  echo ""
+  echo "ERROR: All three values are required."
+  exit 1
+fi
+
+# Append to .env (preserve existing content)
+echo "" >> "$ENV_FILE"
+echo "# Slack" >> "$ENV_FILE"
+echo "SLACK_CLIENT_ID=${SLACK_CLIENT_ID}" >> "$ENV_FILE"
+echo "SLACK_CLIENT_SECRET=${SLACK_CLIENT_SECRET}" >> "$ENV_FILE"
+echo "SLACK_APP_TOKEN=${SLACK_APP_TOKEN}" >> "$ENV_FILE"
+echo "SLACK_REDIRECT_URI=${REDIRECT_URI}" >> "$ENV_FILE"
+
+echo ""
+echo "=== Done! ==="
+echo "Credentials appended to ${ENV_FILE}"
+echo ""
+echo "Restart the dev server: make clean && make dev"
+echo "Then click 'Connect Slack' on the dashboard."

package/skills/polaris/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: polaris
+description: Connect to a Polaris multiplayer collaboration session
+allowed-tools: polaris_connect polaris_disconnect polaris_status polaris_reply polaris_context
+argument-hint: [join <project> <session> | disconnect | (no args for status)]
+---
+
+## Polaris — Multiplayer Collaboration
+
+Manage your connection to a Polaris collaboration session.
+
+### Commands
+
+Based on the arguments provided, do ONE of the following:
+
+**`/polaris join <project> <session>`** — Connect to a session:
+1. Call `polaris_connect` with the given project, session, and user identity
+2. If `.polaris.json` exists in the repo root, read the `user` field from it. Otherwise ask the user for their participant ID (e.g., `user:manu`).
+3. Report the connection status
+
+**`/polaris disconnect`** — Disconnect:
+1. Call `polaris_disconnect`
+2. Confirm disconnection
+
+**`/polaris`** (no arguments) — Show status:
+1. Call `polaris_status`
+2. Display the current connection state
+
+### Arguments: $ARGUMENTS

package/src/cli/cli.ts

@@ -0,0 +1,294 @@
+#!/usr/bin/env bun
+// --- Polaris CLI ---
+// Usage:
+//   polaris login    — authenticate via Google SSO, install local components
+//   polaris daemon   — start the local daemon
+//   polaris status   — show daemon health and active sessions
+//   polaris logout   — remove credentials and local config
+
+import { mkdir, writeFile, readFile, rm, exists } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const POLARIS_DIR = join(homedir(), ".polaris");
+const CREDENTIALS_FILE = join(POLARIS_DIR, "credentials.json");
+const CLAUDE_DIR = join(homedir(), ".claude");
+const CLAUDE_SETTINGS_DIR = join(CLAUDE_DIR);
+
+const SERVICE_URL = process.env.POLARIS_SERVICE_URL ?? "http://localhost:3000";
+
+// --- Login ---
+
+async function login() {
+  console.log("Polaris — setting up your machine\n");
+
+  // 1. Start a local HTTP server to receive the token callback
+  let resolveToken: (token: string) => void;
+  const tokenPromise = new Promise<string>((resolve) => { resolveToken = resolve; });
+
+  const callbackServer = Bun.serve({
+    port: 0,
+    hostname: "127.0.0.1",
+    fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        if (token) {
+          resolveToken!(token);
+          return new Response(
+            `<!DOCTYPE html><html><head><title>Polaris</title><style>body{font-family:-apple-system,sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;color:#1a1a1a;}</style></head><body><div style="text-align:center"><h2>Authenticated!</h2><p>You can close this tab and return to the terminal.</p></div></body></html>`,
+            { headers: { "Content-Type": "text/html" } }
+          );
+        }
+      }
+      return new Response("Not found", { status: 404 });
+    },
+  });
+
+  const callbackPort = callbackServer.port;
+  const authUrl = `${SERVICE_URL}/auth/cli?port=${callbackPort}`;
+
+  console.log("Opening browser for Google sign-in...");
+  console.log(`If the browser doesn't open, visit: ${authUrl}\n`);
+
+  // Open browser
+  const proc = Bun.spawn(
+    process.platform === "darwin" ? ["open", authUrl] :
+    process.platform === "win32" ? ["cmd", "/c", "start", authUrl] :
+    ["xdg-open", authUrl],
+    { stdout: "ignore", stderr: "ignore" }
+  );
+  await proc.exited;
+
+  // 2. Wait for the token
+  console.log("Waiting for authentication...");
+  const token = await tokenPromise;
+  callbackServer.stop(true);
+
+  // 3. Validate the token and get user info
+  const res = await fetch(`${SERVICE_URL}/auth/token?token=${token}`);
+  if (!res.ok) {
+    console.error("Failed to validate token. Please try again.");
+    process.exit(1);
+  }
+  const userInfo = (await res.json()) as {
+    sub: string;
+    email: string;
+    name: string;
+    org_id: string;
+    participant_id: string;
+  };
+
+  console.log(`\nAuthenticated as ${userInfo.name} (${userInfo.email})`);
+  console.log(`Organization: ${userInfo.org_id}`);
+  console.log(`Participant ID: ${userInfo.participant_id}\n`);
+
+  // 4. Store credentials
+  await mkdir(POLARIS_DIR, { recursive: true });
+  await writeFile(CREDENTIALS_FILE, JSON.stringify({
+    token,
+    ...userInfo,
+    service_url: SERVICE_URL,
+  }, null, 2));
+  console.log(`Credentials saved to ${CREDENTIALS_FILE}`);
+
+  // 5. Install MCP server config
+  await mkdir(CLAUDE_DIR, { recursive: true });
+
+  // Find the path to the client.ts relative to this CLI
+  const clientPath = join(import.meta.dir, "..", "client", "client.ts");
+
+  const mcpConfig = {
+    mcpServers: {
+      polaris: {
+        command: "bun",
+        args: [clientPath],
+        env: {
+          POLARIS_DAEMON_URL: "http://127.0.0.1:4321",
+          POLARIS_SERVICE_URL: SERVICE_URL.replace(":3000", ":4321"), // API port
+        },
+      },
+    },
+  };
+
+  const mcpConfigPath = join(CLAUDE_DIR, ".mcp.json");
+  // Merge with existing config if present
+  let existingMcp: Record<string, unknown> = {};
+  try {
+    const existing = await readFile(mcpConfigPath, "utf-8");
+    existingMcp = JSON.parse(existing);
+  } catch { /* doesn't exist yet */ }
+
+  const mergedMcp = {
+    ...existingMcp,
+    mcpServers: {
+      ...(existingMcp as { mcpServers?: Record<string, unknown> }).mcpServers,
+      ...mcpConfig.mcpServers,
+    },
+  };
+  await writeFile(mcpConfigPath, JSON.stringify(mergedMcp, null, 2));
+  console.log(`MCP server config written to ${mcpConfigPath}`);
+
+  // 6. Install hooks
+  const captureShPath = join(import.meta.dir, "..", "..", "hooks", "capture.sh");
+  const hooksConfig = {
+    UserPromptSubmit: [{ hooks: [{ type: "command", command: captureShPath }] }],
+    Stop: [{ hooks: [{ type: "command", command: captureShPath }] }],
+    PreToolUse: [{ hooks: [{ type: "command", command: captureShPath }] }],
+    PostToolUse: [{ hooks: [{ type: "command", command: captureShPath }] }],
+  };
+
+  const settingsPath = join(CLAUDE_DIR, "settings.json");
+  let existingSettings: Record<string, unknown> = {};
+  try {
+    const existing = await readFile(settingsPath, "utf-8");
+    existingSettings = JSON.parse(existing);
+  } catch { /* doesn't exist yet */ }
+
+  const mergedSettings = {
+    ...existingSettings,
+    hooks: {
+      ...(existingSettings as { hooks?: Record<string, unknown> }).hooks,
+      ...hooksConfig,
+    },
+  };
+  await writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
+  console.log(`Hooks config written to ${settingsPath}`);
+
+  // 7. Install /polaris skill
+  const skillDir = join(CLAUDE_DIR, "skills", "polaris");
+  await mkdir(skillDir, { recursive: true });
+  const skillContent = `---
+name: polaris
+description: Connect to a Polaris multiplayer collaboration session
+allowed-tools: polaris_connect polaris_disconnect polaris_status polaris_reply polaris_context
+argument-hint: [join <project> <session> | disconnect | (no args for status)]
+---
+
+## Polaris — Multiplayer Collaboration
+
+Manage your connection to a Polaris collaboration session.
+
+### Commands
+
+Based on the arguments provided, do ONE of the following:
+
+**\`/polaris join <project> <session>\`** — Connect to a session:
+1. Call \`polaris_connect\` with the given project, session, and user identity \`${userInfo.participant_id}\`
+2. Report the connection status
+
+**\`/polaris disconnect\`** — Disconnect:
+1. Call \`polaris_disconnect\`
+2. Confirm disconnection
+
+**\`/polaris\`** (no arguments) — Show status:
+1. Call \`polaris_status\`
+2. Display the current connection state
+
+### Arguments: $ARGUMENTS
+`;
+  await writeFile(join(skillDir, "SKILL.md"), skillContent);
+  console.log(`/polaris skill written to ${skillDir}/SKILL.md`);
+
+  // 8. Install status line
+  const statusLinePath = join(import.meta.dir, "..", "..", "hooks", "statusline.sh");
+  const mergedSettingsWithStatusLine = {
+    ...mergedSettings,
+    statusLine: {
+      type: "command",
+      command: statusLinePath,
+    },
+  };
+  await writeFile(settingsPath, JSON.stringify(mergedSettingsWithStatusLine, null, 2));
+  console.log(`Status line config written to ${settingsPath}`);
+
+  console.log("\n✓ Polaris is set up on this machine!");
+  console.log("\nNext steps:");
+  console.log("  1. Start the daemon:  bun run src/daemon/daemon.ts");
+  console.log("  2. Open your AI agent and run:  /polaris join <project> <session>");
+}
+
+// --- Daemon ---
+
+async function daemon() {
+  const daemonPath = join(import.meta.dir, "..", "daemon", "daemon.ts");
+  console.log("Starting Polaris daemon...");
+  const proc = Bun.spawn(["bun", "run", daemonPath], {
+    stdout: "inherit",
+    stderr: "inherit",
+    env: {
+      ...process.env,
+      POLARIS_SERVICE_URL: SERVICE_URL.replace(":3000", ":4321"),
+    },
+  });
+  await proc.exited;
+}
+
+// --- Status ---
+
+async function status() {
+  try {
+    const res = await fetch("http://127.0.0.1:4321/status");
+    const data = (await res.json()) as { ok: boolean; sessions?: Array<{ ccSessionId: string; project: string; session: string; user: string }> };
+    if (data.ok) {
+      console.log("Daemon: running");
+      if (data.sessions && data.sessions.length > 0) {
+        console.log(`Active sessions (${data.sessions.length}):`);
+        for (const s of data.sessions) {
+          console.log(`  ${s.project}/${s.session} as ${s.user} (cc: ${s.ccSessionId})`);
+        }
+      } else {
+        console.log("No active sessions");
+      }
+    }
+  } catch {
+    console.log("Daemon: not running");
+  }
+
+  // Check credentials
+  try {
+    const creds = JSON.parse(await readFile(CREDENTIALS_FILE, "utf-8"));
+    console.log(`\nLogged in as: ${creds.name} (${creds.email})`);
+    console.log(`Org: ${creds.org_id}`);
+    console.log(`Service: ${creds.service_url}`);
+  } catch {
+    console.log("\nNot logged in. Run: polaris login");
+  }
+}
+
+// --- Logout ---
+
+async function logout() {
+  try {
+    await rm(POLARIS_DIR, { recursive: true });
+    console.log("Credentials removed.");
+  } catch { /* already gone */ }
+  console.log("Logged out. MCP config and hooks are still installed — remove them manually if needed.");
+}
+
+// --- Main ---
+
+const command = process.argv[2];
+
+switch (command) {
+  case "login":
+    await login();
+    break;
+  case "daemon":
+    await daemon();
+    break;
+  case "status":
+    await status();
+    break;
+  case "logout":
+    await logout();
+    break;
+  default:
+    console.log("Polaris CLI");
+    console.log("");
+    console.log("Usage:");
+    console.log("  polaris login    — authenticate and set up this machine");
+    console.log("  polaris daemon   — start the local daemon");
+    console.log("  polaris status   — show connection status");
+    console.log("  polaris logout   — remove credentials");
+}

package/src/client/client.ts

@@ -0,0 +1,245 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+// --- 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";
+
+// Generate a stable session ID for this MCP server instance
+const CC_SESSION_ID = process.env.POLARIS_CC_SESSION_ID ?? crypto.randomUUID();
+
+// --- Daemon communication ---
+
+async function daemonPost(path: string, body: unknown): Promise<Response> {
+  return fetch(`${DAEMON_URL}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+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 = "";
+let currentSession = "";
+let currentUser = "";
+
+// --- MCP Server ---
+
+const mcp = new Server(
+  { name: "polaris", version: "0.0.1" },
+  {
+    capabilities: {
+      experimental: { "claude/channel": {} },
+      tools: {},
+    },
+    instructions: `You are connected to Polaris — a multiplayer collaboration system. Messages from advisors and teammates may arrive as <channel source="polaris" from="..."> tags. Use /polaris commands to manage your session, or call the polaris tools directly.`,
+  }
+);
+
+mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "polaris_connect",
+      description: "Connect this session to a Polaris project and session. Creates the session if it doesn't exist.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          project: { type: "string", description: "Project name" },
+          session: { type: "string", description: "Session name" },
+          user: { type: "string", description: "Your participant ID (e.g., user:manu)" },
+        },
+        required: ["project", "session", "user"],
+      },
+    },
+    {
+      name: "polaris_disconnect",
+      description: "Disconnect from the current Polaris session.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {},
+      },
+    },
+    {
+      name: "polaris_status",
+      description: "Show current Polaris connection status.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {},
+      },
+    },
+    {
+      name: "polaris_reply",
+      description: "Send a message to the project floor (visible to all advisors and the Slack/WhatsApp channel).",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          message: { type: "string", description: "Message to send" },
+        },
+        required: ["message"],
+      },
+    },
+    {
+      name: "polaris_context",
+      description: "Fetch activity from a sibling session in this project. Use this to see what other drivers have been doing.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          session: { type: "string", description: "Name of the sibling session to fetch context from" },
+        },
+        required: ["session"],
+      },
+    },
+  ],
+}));
+
+mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name, arguments: args } = req.params;
+
+  if (name === "polaris_connect") {
+    const { project, session, user } = args as { project: string; session: string; user: string };
+    try {
+      const res = await daemonPost("/connect", {
+        ccSessionId: CC_SESSION_ID,
+        project,
+        session,
+        user,
+      });
+      const body = await res.json();
+      if (res.ok) {
+        currentProject = project;
+        currentSession = session;
+        currentUser = user;
+        return { content: [{ type: "text", text: `Connected to ${project}/${session} as ${user}.` }] };
+      }
+      return { content: [{ type: "text", text: `Failed to connect: ${(body as { error?: string }).error ?? "unknown error"}` }] };
+    } catch {
+      return { content: [{ type: "text", text: "Failed to connect — is the Polaris daemon running? Start it with `polaris daemon` or `bun run src/daemon/daemon.ts`." }] };
+    }
+  }
+
+  if (name === "polaris_disconnect") {
+    try {
+      await daemonPost("/disconnect", { ccSessionId: CC_SESSION_ID });
+      currentProject = "";
+      currentSession = "";
+      currentUser = "";
+      return { content: [{ type: "text", text: "Disconnected from Polaris." }] };
+    } catch {
+      return { content: [{ type: "text", text: "Failed to disconnect — daemon may not be running." }] };
+    }
+  }
+
+  if (name === "polaris_status") {
+    try {
+      const res = await daemonGet(`/status/${CC_SESSION_ID}`);
+      const body = (await res.json()) as { connected: boolean; project?: string; session?: string; user?: string };
+      if (body.connected) {
+        return { content: [{ type: "text", text: `Connected: ${body.project}/${body.session} as ${body.user}` }] };
+      }
+      return { content: [{ type: "text", text: "Not connected to any Polaris session." }] };
+    } catch {
+      return { content: [{ type: "text", text: "Polaris daemon not reachable." }] };
+    }
+  }
+
+  if (name === "polaris_reply") {
+    if (!currentProject) {
+      return { content: [{ type: "text", text: "Not connected to a Polaris session. Use polaris_connect first." }] };
+    }
+    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,
+          },
+        }),
+      });
+      if (res.ok) {
+        return { content: [{ type: "text", text: "Reply sent to the floor." }] };
+      }
+      return { content: [{ type: "text", text: `Failed to send reply: ${res.status}` }] };
+    } catch {
+      return { content: [{ type: "text", text: "Failed to reach the cloud service." }] };
+    }
+  }
+
+  if (name === "polaris_context") {
+    if (!currentProject) {
+      return { content: [{ type: "text", text: "Not connected to a Polaris session. Use polaris_connect first." }] };
+    }
+    const targetSession = (args as { session: string }).session;
+    try {
+      const res = await serviceGet(`/projects/${currentProject}/sessions/${targetSession}/messages`);
+      if (!res.ok) {
+        return { content: [{ type: "text", text: `Could not fetch session "${targetSession}": ${res.status}` }] };
+      }
+      const events = (await res.json()) as Array<{
+        sender: string;
+        payload: { prompt?: string; stop_response?: string; content?: string };
+      }>;
+      const summary = events
+        .map((e) => {
+          const p = e.payload;
+          const text = p.prompt ?? p.stop_response ?? p.content ?? JSON.stringify(p);
+          return `[${e.sender}] ${text}`;
+        })
+        .join("\n");
+      return { content: [{ type: "text", text: summary || "(no activity yet)" }] };
+    } catch {
+      return { content: [{ type: "text", text: "Failed to reach the cloud service." }] };
+    }
+  }
+
+  throw new Error(`Unknown tool: ${name}`);
+});
+
+// --- Register with daemon and connect stdio ---
+
+async function main() {
+  // Register with daemon (best-effort — daemon might not be running yet)
+  try {
+    await daemonPost("/register", { ccSessionId: CC_SESSION_ID });
+  } catch {
+    console.error("Warning: Polaris daemon not reachable. Start it with `bun run src/daemon/daemon.ts`.");
+  }
+
+  // Poll daemon for advisor messages and inject into MCP session
+  setInterval(async () => {
+    if (!currentProject) return;
+    // The daemon's cloud WS forwards inject events to the mcpCallbacks map,
+    // but since we're in a separate process, we use HTTP polling as a fallback.
+    // In production, this would use IPC (Unix socket or named pipe).
+  }, 5000);
+
+  const transport = new StdioServerTransport();
+  await mcp.connect(transport);
+  console.error(`Polaris MCP client started (session: ${CC_SESSION_ID})`);
+}
+
+if (import.meta.main) {
+  await main();
+}
+
+export { mcp, CC_SESSION_ID, main as startClient };