@rootly/wizard 0.1.0

package/src/mcp.js

@@ -0,0 +1,254 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+
+const HOSTED_MCP_URL = 'https://mcp.rootly.com/mcp';
+
+function stringifyConfig(config) {
+  return `${JSON.stringify(config, null, 2)}\n`;
+}
+
+function mergeMcpServers(existing, incoming) {
+  return {
+    ...existing,
+    ...incoming,
+    mcpServers: {
+      ...(existing?.mcpServers || {}),
+      ...(incoming?.mcpServers || {})
+    }
+  };
+}
+
+function hostedJsonConfig(token) {
+  return {
+    mcpServers: {
+      rootly: {
+        url: HOSTED_MCP_URL,
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      }
+    }
+  };
+}
+
+function claudeDesktopConfig(token) {
+  return {
+    mcpServers: {
+      rootly: {
+        command: 'npx',
+        args: ['-y', 'mcp-remote', 'https://mcp.rootly.com/sse', '--header', `Authorization: Bearer ${token}`]
+      }
+    }
+  };
+}
+
+function claudeCodeConfig(token) {
+  return {
+    mcpServers: {
+      rootly: {
+        type: 'http',
+        url: HOSTED_MCP_URL,
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      }
+    }
+  };
+}
+
+function windsurfConfig(token) {
+  return {
+    mcpServers: {
+      rootly: {
+        serverUrl: HOSTED_MCP_URL,
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      }
+    }
+  };
+}
+
+function codexConfig() {
+  return [
+    '[mcp_servers.rootly]',
+    `url = "${HOSTED_MCP_URL}"`,
+    'bearer_token_env_var = "ROOTLY_API_TOKEN"'
+  ].join('\n');
+}
+
+function configForClient(client, token) {
+  switch (client) {
+    case 'Cursor':
+      return stringifyConfig(hostedJsonConfig(token));
+    case 'Claude Desktop':
+      return stringifyConfig(claudeDesktopConfig(token));
+    case 'Claude Code':
+      return stringifyConfig(claudeCodeConfig(token));
+    case 'Windsurf':
+      return stringifyConfig(windsurfConfig(token));
+    case 'Codex':
+      return `${codexConfig()}\n`;
+    default:
+      throw new Error(`Unsupported MCP client: ${client}`);
+  }
+}
+
+function configFileForClient(client) {
+  const home = os.homedir();
+  const appData = process.env.APPDATA;
+  const platform = process.platform;
+
+  switch (client) {
+    case 'Cursor':
+      return path.join(home, '.cursor', 'mcp.json');
+    case 'Claude Desktop':
+      if (platform === 'win32') {
+        return path.join(appData || home, 'Claude', 'claude_desktop_config.json');
+      }
+      if (platform === 'darwin') {
+        return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+      }
+      return path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+    case 'Windsurf':
+      if (platform === 'win32') {
+        return path.join(appData || home, 'Codeium', 'Windsurf', 'mcp_config.json');
+      }
+      return path.join(home, '.codeium', 'windsurf', 'mcp_config.json');
+    case 'Claude Code':
+      return path.join(process.cwd(), '.mcp.json');
+    case 'Codex':
+      return path.join(home, '.codex', 'config.toml');
+    default:
+      throw new Error(`Unsupported MCP client: ${client}`);
+  }
+}
+
+async function ensureParentDir(filePath) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+}
+
+async function maybeBackupFile(filePath) {
+  try {
+    await fs.access(filePath);
+  } catch {
+    return null;
+  }
+
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${filePath}.bak.${stamp}`;
+  await fs.copyFile(filePath, backupPath);
+  return backupPath;
+}
+
+async function readExistingJson(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export function buildHostedMcpPreview(client, tokenType) {
+  return [
+    `Client: ${client}`,
+    `Auth: ${tokenType}`,
+    'Connection: hosted Rootly MCP server',
+    '',
+    configForClient(client, '<YOUR_ROOTLY_API_TOKEN>')
+  ].join('\n');
+}
+
+export async function writeHostedMcpConfig(client, token) {
+  const targetPath = configFileForClient(client);
+  await ensureParentDir(targetPath);
+  const backupPath = await maybeBackupFile(targetPath);
+
+  if (client === 'Codex') {
+    // Codex config references the token via env var, so it holds no secret —
+    // but write it owner-only for consistency with the token-bearing configs.
+    await fs.writeFile(targetPath, codexConfig(), { encoding: 'utf8', mode: 0o600 });
+    return { targetPath, backupPath };
+  }
+
+  const existing = await readExistingJson(targetPath);
+  const merged = mergeMcpServers(existing, JSON.parse(configForClient(client, token)));
+  // These configs embed the bearer token inline, so restrict to owner read/write
+  // (0600) rather than leaving the default world-readable perms. writeFile's mode
+  // only applies on create, so chmod afterward to also tighten a pre-existing file.
+  await fs.writeFile(targetPath, stringifyConfig(merged), { encoding: 'utf8', mode: 0o600 });
+  await fs.chmod(targetPath, 0o600).catch(() => {});
+  return { targetPath, backupPath };
+}
+
+export function getMcpConfigPath(client) {
+  return configFileForClient(client);
+}
+
+// Claude Code stores user-scoped (global) MCP servers in ~/.claude.json. The
+// supported way to register one is the `claude` CLI, which manages that file
+// correctly, rather than hand-editing it.
+export function buildClaudeCodeUserCommandArgs(token) {
+  return ['mcp', 'add', '--scope', 'user', '--transport', 'http', 'rootly', HOSTED_MCP_URL, '--header', `Authorization: Bearer ${token}`];
+}
+
+export function claudeCodeUserCommandDisplay() {
+  return `claude mcp add --scope user --transport http rootly ${HOSTED_MCP_URL} --header "Authorization: Bearer <YOUR_ROOTLY_API_TOKEN>"`;
+}
+
+function claudeCliAvailable() {
+  try {
+    const result = spawnSync('claude', ['--version'], { stdio: 'ignore' });
+    return !result.error && result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+export function addClaudeCodeUserScope(token) {
+  const display = claudeCodeUserCommandDisplay();
+
+  if (!claudeCliAvailable()) {
+    return { ran: false, target: 'user scope (~/.claude.json)', command: display };
+  }
+
+  const result = spawnSync('claude', buildClaudeCodeUserCommandArgs(token), { stdio: 'ignore' });
+  return { ran: !result.error && result.status === 0, target: 'user scope (~/.claude.json)', command: display };
+}
+
+export async function verifyHostedMcpConfig(client) {
+  const targetPath = configFileForClient(client);
+
+  if (client === 'Codex') {
+    const raw = await fs.readFile(targetPath, 'utf8');
+    if (!raw.includes('[mcp_servers.rootly]')) {
+      throw new Error(`Rootly MCP config not found in ${targetPath}`);
+    }
+    if (!raw.includes(HOSTED_MCP_URL)) {
+      throw new Error(`Rootly MCP config in ${targetPath} is missing the hosted Rootly endpoint`);
+    }
+    if (!raw.includes('bearer_token_env_var')) {
+      throw new Error(`Rootly MCP config in ${targetPath} is missing bearer_token_env_var`);
+    }
+    return targetPath;
+  }
+
+  const config = await readExistingJson(targetPath);
+  const rootly = config?.mcpServers?.rootly || config?.rootly;
+
+  if (!rootly) {
+    throw new Error(`Rootly MCP config not found in ${targetPath}`);
+  }
+
+  const isHostedHttp = rootly.url === HOSTED_MCP_URL || rootly.serverUrl === HOSTED_MCP_URL;
+  const isClaudeDesktop = rootly.command === 'npx' && Array.isArray(rootly.args) && rootly.args.includes('mcp-remote');
+
+  if (!isHostedHttp && !isClaudeDesktop) {
+    throw new Error(`Rootly MCP config in ${targetPath} does not point at the hosted Rootly server`);
+  }
+
+  return targetPath;
+}

package/src/rootly-api.js

@@ -0,0 +1,325 @@
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+
+export class RootlyApiClient {
+  constructor(token, baseUrl = 'https://api.rootly.com') {
+    this.token = token;
+    this.baseUrl = baseUrl;
+  }
+
+  async request(path, options = {}) {
+    const response = await fetch(new URL(path, this.baseUrl), {
+      method: options.method || 'GET',
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        Accept: 'application/vnd.api+json',
+        ...(options.body ? { 'Content-Type': 'application/vnd.api+json' } : {}),
+        ...(options.headers || {})
+      },
+      signal: options.signal || AbortSignal.timeout(DEFAULT_REQUEST_TIMEOUT_MS),
+      ...(options.body ? { body: JSON.stringify(options.body) } : {})
+    });
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => '');
+      throw new Error(`Rootly API request failed for ${path}: ${response.status}${text ? ` - ${text}` : ''}`);
+    }
+
+    return response.json();
+  }
+
+  async getCurrentUser() {
+    return this.request('/v1/users/me');
+  }
+
+  async listTeams() {
+    return this.request('/v1/teams?include=users,schedules,escalation_policies');
+  }
+
+  async getTeam(id) {
+    return this.request(`/v1/teams/${id}?include=users`);
+  }
+
+  async listUsers() {
+    return this.request('/v1/users');
+  }
+
+  async listAllUsers() {
+    const users = [];
+    let next = '/v1/users';
+    let pagesScanned = 0;
+
+    while (next && pagesScanned < 100) {
+      pagesScanned += 1;
+      const payload = await this.request(next);
+      if (Array.isArray(payload?.data)) {
+        users.push(...payload.data);
+      }
+      next = payload?.links?.next || null;
+    }
+
+    return users;
+  }
+
+  async listSchedules() {
+    return this.request('/v1/schedules');
+  }
+
+  async listEscalationPolicies() {
+    return this.request('/v1/escalation_policies');
+  }
+
+  async listAlertSources() {
+    return this.request('/v1/alert_sources');
+  }
+
+  async listSeverities() {
+    return this.request('/v1/severities');
+  }
+
+  async listServices() {
+    return this.request('/v1/services');
+  }
+
+  async listFunctionalities() {
+    return this.request('/v1/functionalities');
+  }
+
+  async createFunctionality(attributes) {
+    return this.request('/v1/functionalities', {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'functionalities',
+          attributes
+        }
+      }
+    });
+  }
+
+  async createService(attributes) {
+    return this.request('/v1/services', {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'services',
+          attributes
+        }
+      }
+    });
+  }
+
+  async listEnvironments() {
+    return this.request('/v1/environments');
+  }
+
+  async listIncidentTypes() {
+    return this.request('/v1/incident_types');
+  }
+
+  async createTeam(attributes) {
+    return this.request('/v1/teams', {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'groups',
+          attributes
+        }
+      }
+    });
+  }
+
+  async updateTeam(id, attributes) {
+    return this.request(`/v1/teams/${id}`, {
+      method: 'PUT',
+      body: {
+        data: {
+          type: 'groups',
+          attributes
+        }
+      }
+    });
+  }
+
+  async createSchedule(attributes) {
+    return this.request('/v1/schedules', {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'schedules',
+          attributes
+        }
+      }
+    });
+  }
+
+  async createScheduleRotation(scheduleId, attributes) {
+    return this.request(`/v1/schedules/${scheduleId}/schedule_rotations`, {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'schedule_rotations',
+          attributes
+        }
+      }
+    });
+  }
+
+  async createEscalationPolicy(attributes) {
+    return this.request('/v1/escalation_policies', {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'escalation_policies',
+          attributes
+        }
+      }
+    });
+  }
+
+  async createEscalationPath(escalationPolicyId, attributes) {
+    return this.request(`/v1/escalation_policies/${escalationPolicyId}/escalation_paths`, {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'escalation_paths',
+          attributes
+        }
+      }
+    });
+  }
+
+  async createEscalationLevel(escalationPolicyId, attributes) {
+    return this.request(`/v1/escalation_policies/${escalationPolicyId}/escalation_levels`, {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'escalation_levels',
+          attributes
+        }
+      }
+    });
+  }
+
+  async listAlertUrgencies() {
+    return this.request('/v1/alert_urgencies');
+  }
+
+  async listStatusPages() {
+    return this.request('/v1/status-pages');
+  }
+
+  async createStatusPage(attributes) {
+    return this.request('/v1/status-pages', {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'status_pages',
+          attributes
+        }
+      }
+    });
+  }
+
+  async updateStatusPage(id, attributes) {
+    return this.request(`/v1/status-pages/${id}`, {
+      method: 'PATCH',
+      body: {
+        data: {
+          type: 'status_pages',
+          attributes
+        }
+      }
+    });
+  }
+
+  async createAlertSource(attributes) {
+    return this.request('/v1/alert_sources', {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'alert_sources',
+          attributes
+        }
+      }
+    });
+  }
+
+  async createAlert(attributes) {
+    return this.request('/v1/alerts', {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'alerts',
+          attributes
+        }
+      }
+    });
+  }
+
+  async createIncident(attributes) {
+    return this.request('/v1/incidents', {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'incidents',
+          attributes
+        }
+      }
+    });
+  }
+
+  async getUserPhoneNumbers(userId) {
+    return this.request(`/v1/users/${userId}/phone_numbers`);
+  }
+
+  async createUserPhoneNumber(userId, phone) {
+    return this.request(`/v1/users/${userId}/phone_numbers`, {
+      method: 'POST',
+      body: {
+        data: {
+          type: 'user_phone_numbers',
+          attributes: { phone }
+        }
+      }
+    });
+  }
+
+  // Triggers a Twilio SMS with a verification code (member route is shallow).
+  async sendPhoneVerification(phoneNumberId) {
+    return this.request(`/v1/phone_numbers/${phoneNumberId}/verify`, { method: 'POST' });
+  }
+
+  async submitPhoneVerificationCode(phoneNumberId, code) {
+    return this.request(`/v1/phone_numbers/${phoneNumberId}/verify_code`, {
+      method: 'PATCH',
+      body: { code }
+    });
+  }
+
+  async resendPhoneVerification(phoneNumberId) {
+    return this.request(`/v1/phone_numbers/${phoneNumberId}/resend_verification`, { method: 'POST' });
+  }
+
+  async deleteUserPhoneNumber(phoneNumberId) {
+    return this.request(`/v1/phone_numbers/${phoneNumberId}`, { method: 'DELETE' });
+  }
+
+  async findUserByEmail(email) {
+    const target = String(email).toLowerCase();
+    let next = '/v1/users';
+    let pagesScanned = 0;
+
+    while (next && pagesScanned < 100) {
+      pagesScanned += 1;
+      const payload = await this.request(next);
+      const match = payload?.data?.find((user) => user?.attributes?.email?.toLowerCase() === target);
+      if (match) {
+        return match;
+      }
+
+      next = payload?.links?.next || null;
+    }
+
+    return null;
+  }
+}

package/src/runtime.js

@@ -0,0 +1,55 @@
+import { getStoredToken } from './auth.js';
+import { RootlyApiClient } from './rootly-api.js';
+import { detectOnboardingState } from './detect-state.js';
+
+export async function getActiveToken() {
+  return process.env.ROOTLY_TOKEN?.trim() || (await getStoredToken()) || null;
+}
+
+export async function loadApiClient() {
+  const token = await getActiveToken();
+  if (!token) {
+    throw new Error('Rootly auth is required first.');
+  }
+
+  return new RootlyApiClient(token);
+}
+
+export async function loadOnboardingState() {
+  const token = await getActiveToken();
+  if (!token) {
+    return null;
+  }
+
+  const api = new RootlyApiClient(token);
+  const [userPayload, teamsPayload, schedulesPayload, escalationPoliciesPayload] = await Promise.all([
+    api.getCurrentUser(),
+    api.listTeams(),
+    api.listSchedules(),
+    api.listEscalationPolicies()
+  ]);
+
+  return detectOnboardingState({
+    userPayload,
+    teamsPayload,
+    schedulesPayload,
+    escalationPoliciesPayload,
+    authMode: process.env.ROOTLY_TOKEN?.trim() ? 'env-token' : 'stored-token'
+  });
+}
+
+export function extractTeamId(group) {
+  return group?.data?.id || group?.id || null;
+}
+
+export function extractUserId(user) {
+  return user?.id || user?.data?.id || null;
+}
+
+// API keys authenticate as a synthetic service user whose email looks like
+// `bot+apikey-<uuid>@rootly.com`. Such an identity should not be seeded as a
+// team member or on-call participant.
+export function isServiceAccount(user) {
+  const email = user?.data?.attributes?.email || user?.attributes?.email || '';
+  return /^bot\+apikey-/i.test(email);
+}

package/src/tui/components/AppShell.js

@@ -0,0 +1,68 @@
+import { createElement as h } from 'react';
+import { Box, Text, useWindowSize } from 'ink';
+import { palette, glyphs, HINTS } from '../theme.js';
+
+function KeyHints({ items, keyColor = palette.brand }) {
+  if (!items?.length) {
+    return h(Text, { color: palette.border }, ' ');
+  }
+  const parts = [];
+  items.forEach((item, index) => {
+    if (index > 0) {
+      parts.push(h(Text, { key: `sep-${index}`, color: palette.border }, '    '));
+    }
+    parts.push(h(Text, { key: `key-${index}`, color: keyColor }, item.key));
+    parts.push(h(Text, { key: `lbl-${index}`, color: palette.muted }, ` ${item.label}`));
+  });
+  return h(Box, null, ...parts);
+}
+
+export function AppShell({ title, context = 'rootly.com', hints = HINTS.nav, keyColor = palette.brand, children }) {
+  const { columns } = useWindowSize();
+  const cols = columns || 80;
+  // Fit the terminal: shrink on narrow screens, cap on wide ones.
+  const width = Math.min(82, Math.max(24, cols - 4));
+  const ruleWidth = Math.max(4, Math.min(title ? title.length : 0, width - 8));
+
+  return h(
+    Box,
+    // Full-width column, centered — so on a wide/enlarged terminal everything
+    // stays centered rather than pinned to the left.
+    { flexDirection: 'column', alignItems: 'center', width: cols, paddingTop: 1 },
+    // Brand header
+    h(
+      Box,
+      { width, justifyContent: 'space-between', marginBottom: 1 },
+      h(
+        Box,
+        null,
+        h(Text, { color: keyColor, bold: true }, `${glyphs.logo} `),
+        h(Text, { bold: true, color: palette.text }, 'Rootly Wizard')
+      ),
+      h(Text, { color: palette.accent, bold: true }, context)
+    ),
+    // Content card
+    h(
+      Box,
+      {
+        width,
+        flexDirection: 'column',
+        borderStyle: 'round',
+        borderColor: palette.border,
+        paddingX: 2,
+        paddingY: 1
+      },
+      title
+        ? h(
+            Box,
+            { flexDirection: 'column', marginBottom: 1 },
+            h(Text, { bold: true, color: palette.text }, title),
+            h(Text, { color: palette.brand }, '─'.repeat(ruleWidth))
+          )
+        : null,
+      ...(Array.isArray(children) ? children : [children]).filter(Boolean)
+    ),
+    // Footer hints
+    h(Box, { width, marginTop: 1, justifyContent: 'center' }, h(KeyHints, { items: hints, keyColor }))
+  );
+}