kern0-cli 0.1.0

package/lib/cli/config.ts

@@ -0,0 +1,257 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+export interface Auth {
+  device_token: string;
+  expires_at: number;
+  token_type: "device" | "pat";
+}
+
+export interface User {
+  id: string;
+  email: string;
+}
+
+export interface Organization {
+  id: string;
+  name: string;
+}
+
+export interface Config {
+  api_url: string;
+  current_org_id?: string;
+  current_customer_id?: string;
+  current_env_id?: string;
+  user?: User;
+  auth?: Auth;
+  organizations?: Organization[];
+}
+
+const CONFIG_DIR = path.join(os.homedir(), ".kern0");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials");
+
+export function ensureConfigDir(): void {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+export function loadConfig(): Config {
+  ensureConfigDir();
+
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return { api_url: process.env.KERN0_API_URL || "http://localhost:3000" };
+  }
+
+  try {
+    const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error("Failed to load config:", error);
+    return { api_url: process.env.KERN0_API_URL || "http://localhost:3000" };
+  }
+}
+
+export function saveConfig(config: Config): void {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), {
+    mode: 0o600,
+  });
+}
+
+export function loadToken(): string | null {
+  ensureConfigDir();
+
+  if (!fs.existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+
+  try {
+    const token = fs.readFileSync(CREDENTIALS_FILE, "utf-8").trim();
+    return token || null;
+  } catch (error) {
+    return null;
+  }
+}
+
+export function saveToken(token: string): void {
+  ensureConfigDir();
+  fs.writeFileSync(CREDENTIALS_FILE, token, { mode: 0o600 });
+}
+
+export function deleteToken(): void {
+  ensureConfigDir();
+  if (fs.existsSync(CREDENTIALS_FILE)) {
+    fs.unlinkSync(CREDENTIALS_FILE);
+  }
+}
+
+export function getCurrentOrg(): string | null {
+  const config = loadConfig();
+  return config.current_org_id || null;
+}
+
+export function setCurrentOrg(orgId: string): void {
+  const config = loadConfig();
+  config.current_org_id = orgId;
+  config.current_customer_id = undefined; // Clear customer when switching org
+  saveConfig(config);
+}
+
+export function getCurrentCustomer(): string | null {
+  const config = loadConfig();
+  return config.current_customer_id || null;
+}
+
+export function setCurrentCustomer(customerId: string): void {
+  const config = loadConfig();
+  config.current_customer_id = customerId;
+  saveConfig(config);
+}
+
+export function getCurrentEnv(): string | null {
+  const config = loadConfig();
+  return config.current_env_id || null;
+}
+
+export function setCurrentEnv(envId: string): void {
+  const config = loadConfig();
+  config.current_env_id = envId;
+  saveConfig(config);
+}
+
+export function getUser(): User | null {
+  const config = loadConfig();
+  return config.user || null;
+}
+
+export function setUser(user: User): void {
+  const config = loadConfig();
+  config.user = user;
+  saveConfig(config);
+}
+
+export function getOrganizations(): Organization[] {
+  const config = loadConfig();
+  return config.organizations || [];
+}
+
+export function setOrganizations(orgs: Organization[]): void {
+  const config = loadConfig();
+  config.organizations = orgs;
+  saveConfig(config);
+}
+
+export function addOrganization(org: Organization): void {
+  const config = loadConfig();
+  const orgs = config.organizations || [];
+
+  // Don't add duplicate
+  if (!orgs.find(o => o.id === org.id)) {
+    orgs.push(org);
+    config.organizations = orgs;
+    saveConfig(config);
+  }
+}
+
+export function getAuth(): Auth | null {
+  const config = loadConfig();
+  return config.auth || null;
+}
+
+export function setAuth(auth: Auth): void {
+  const config = loadConfig();
+  config.auth = auth;
+  saveConfig(config);
+}
+
+export function isAuthenticated(): boolean {
+  const token = loadToken();
+  const auth = getAuth();
+
+  if (!token || !auth) {
+    return false;
+  }
+
+  // Check if token expired
+  if (auth.expires_at && auth.expires_at < Date.now()) {
+    return false;
+  }
+
+  return true;
+}
+
+export function requireAuthentication(): string {
+  if (!isAuthenticated()) {
+    throw new Error(
+      "Not authenticated. Run `kern0 login` to authenticate."
+    );
+  }
+
+  const token = loadToken();
+  if (!token) {
+    throw new Error("Token not found. Run `kern0 login` to authenticate.");
+  }
+
+  return token;
+}
+
+export function requireOrganization(): string {
+  const orgId = getCurrentOrg();
+  if (!orgId) {
+    throw new Error(
+      "No organization selected. Run `kern0 org select <orgId>` to select one."
+    );
+  }
+  return orgId;
+}
+
+export function requireCustomer(): string {
+  const customerId = getCurrentCustomer();
+  if (!customerId) {
+    throw new Error(
+      "No customer selected. Run `kern0 switch-customer <id>` to select one."
+    );
+  }
+  return customerId;
+}
+
+export function printContext(): void {
+  const config = loadConfig();
+  const auth = getAuth();
+  const user = getUser();
+  const org = config.current_org_id
+    ? getOrganizations().find(o => o.id === config.current_org_id)
+    : null;
+
+  console.log("\n📋 Current Context:");
+
+  if (user) {
+    console.log(`  User: ${user.email} (${user.id})`);
+  } else {
+    console.log(`  User: Not authenticated`);
+  }
+
+  if (org) {
+    console.log(`  Organization: ${org.name} (${org.id})`);
+  } else {
+    console.log(`  Organization: None selected`);
+  }
+
+  if (config.current_customer_id) {
+    console.log(`  Customer: ${config.current_customer_id}`);
+  }
+
+  if (config.current_env_id) {
+    console.log(`  Environment: ${config.current_env_id}`);
+  }
+
+  if (auth?.expires_at) {
+    const expiresIn = Math.floor((auth.expires_at - Date.now()) / 1000 / 60 / 60);
+    console.log(`  Token expires: ${expiresIn} hours from now`);
+  }
+
+  console.log("");
+}

package/lib/cli/index.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+import { login, logout } from "./commands/auth";
+import {
+  listOrgs,
+  selectOrg,
+  getOrgInfo,
+  createOrg,
+} from "./commands/org";
+import {
+  listTokensCmd,
+  createTokenCmd,
+  revokeTokenCmd,
+} from "./commands/tokens";
+import {
+  listCustomersCmd,
+  switchCustomerCmd,
+} from "./commands/customers";
+import {
+  listEnvironments,
+  getEnvironmentInfo,
+} from "./commands/environments";
+import { printContext } from "./config";
+
+const args = process.argv.slice(2);
+const command = args[0];
+const subcommand = args[1];
+const arg1 = args[2];
+const arg2 = args[3];
+
+async function main() {
+  try {
+    switch (command) {
+      // Auth commands
+      case "login":
+        await login();
+        break;
+
+      case "logout":
+        await logout();
+        break;
+
+      // Organization commands
+      case "org":
+        switch (subcommand) {
+          case "list":
+            await listOrgs();
+            break;
+          case "select":
+            if (!arg1) {
+              console.error("Usage: kern0 org select <orgId>");
+              process.exit(1);
+            }
+            await selectOrg(arg1);
+            break;
+          case "info":
+            await getOrgInfo();
+            break;
+          case "create":
+            if (!arg1) {
+              console.error("Usage: kern0 org create <name> [type]");
+              process.exit(1);
+            }
+            const type = (arg2 as "direct" | "msp") || "direct";
+            await createOrg(arg1, type);
+            break;
+          default:
+            console.error("Usage: kern0 org [list|select|info|create]");
+            process.exit(1);
+        }
+        break;
+
+      // Customer commands
+      case "customers":
+        switch (subcommand) {
+          case "list":
+            await listCustomersCmd();
+            break;
+          default:
+            console.error("Usage: kern0 customers list");
+            process.exit(1);
+        }
+        break;
+
+      case "switch-customer":
+        if (!arg1) {
+          console.error("Usage: kern0 switch-customer <customerId>");
+          process.exit(1);
+        }
+        await switchCustomerCmd(arg1);
+        break;
+
+      // Token commands
+      case "tokens":
+        switch (subcommand) {
+          case "list":
+            await listTokensCmd();
+            break;
+          case "create":
+            if (!arg1) {
+              console.error("Usage: kern0 tokens create <name>");
+              process.exit(1);
+            }
+            await createTokenCmd(arg1);
+            break;
+          case "delete":
+          case "revoke":
+            if (!arg1) {
+              console.error("Usage: kern0 tokens revoke <tokenId>");
+              process.exit(1);
+            }
+            await revokeTokenCmd(arg1);
+            break;
+          default:
+            console.error("Usage: kern0 tokens [list|create|revoke]");
+            process.exit(1);
+        }
+        break;
+
+      // Environment commands
+      case "environments":
+      case "envs":
+      case "env":
+        switch (subcommand) {
+          case "list":
+            await listEnvironments();
+            break;
+          case "info":
+            if (!arg1) {
+              console.error("Usage: kern0 environments info <envId>");
+              process.exit(1);
+            }
+            await getEnvironmentInfo(arg1);
+            break;
+          default:
+            console.error("Usage: kern0 environments [list|info <envId>]");
+            process.exit(1);
+        }
+        break;
+
+      // Status commands
+      case "whoami":
+        printContext();
+        break;
+
+      case "--version":
+      case "-v":
+        console.log("Kern0 CLI v0.1.0");
+        break;
+
+      case "--help":
+      case "-h":
+      case undefined:
+        showHelp();
+        break;
+
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.error("Run 'kern0 --help' for usage information");
+        process.exit(1);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`\n❌ Error: ${error.message}\n`);
+    }
+    process.exit(1);
+  }
+}
+
+function showHelp() {
+  console.log(`
+Kern0 CLI - Recovery Readiness Assessment Tool
+
+USAGE:
+  kern0 <command> [options]
+
+AUTHENTICATION:
+  login              Authenticate with OAuth device flow
+  logout             Clear credentials and log out
+  whoami             Show current user, organization, and customer
+
+ORGANIZATIONS:
+  org list           List your organizations
+  org select <id>    Switch to an organization
+  org info           Show current organization details
+  org create <name>  Create a new organization
+
+CUSTOMERS:
+  customers list           List customers in current organization
+  switch-customer <id>     Switch to a customer
+
+TOKENS:
+  tokens list              List API tokens
+  tokens create <name>     Create a new API token
+  tokens revoke <id>       Revoke an API token
+
+CONFIG:
+  config get <key>        Get a configuration value
+  config set <key> <val>  Set a configuration value
+
+OPTIONS:
+  -h, --help              Show this help message
+  -v, --version           Show version
+
+EXAMPLES:
+  kern0 login
+  kern0 org list
+  kern0 org select acme-corp
+  kern0 customers list
+  kern0 switch-customer acme-prod
+  kern0 tokens create "GitHub Actions"
+  kern0 whoami
+
+For more information, visit: https://kern0.dev/docs/cli
+`);
+}
+
+// Run CLI
+main().catch(error => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/lib/mcp/api-client.ts

@@ -0,0 +1,76 @@
+/**
+ * API client for MCP server to communicate with KernZero backend
+ */
+
+export async function fetchAPI(
+  endpoint: string,
+  token: string,
+  apiUrl: string
+): Promise<any> {
+  const url = new URL(endpoint, apiUrl).href;
+
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `API request failed: ${response.status} ${response.statusText}\n${errorText}`
+    );
+  }
+
+  const data = await response.json();
+
+  // Handle wrapped API responses
+  if (data.success && data.data) {
+    return data.data;
+  }
+
+  // Handle direct responses (auth/me endpoint)
+  if (data.authenticated !== undefined) {
+    return data;
+  }
+
+  // Return as-is for other responses
+  return data;
+}
+
+export async function callAPI(
+  method: "GET" | "POST" | "PUT" | "DELETE",
+  endpoint: string,
+  token: string,
+  apiUrl: string,
+  body?: any
+): Promise<any> {
+  const url = new URL(endpoint, apiUrl).href;
+
+  const response = await fetch(url, {
+    method,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `API request failed: ${response.status} ${response.statusText}\n${errorText}`
+    );
+  }
+
+  const data = await response.json();
+
+  // Handle wrapped API responses
+  if (data.success && data.data) {
+    return data.data;
+  }
+
+  return data;
+}

package/lib/mcp/resources.ts

@@ -0,0 +1,55 @@
+/**
+ * MCP resource definitions for KernZero
+ * Resources represent data that Claude can read and analyze
+ */
+
+export interface Resource {
+  uri: string;
+  name: string;
+  description: string;
+  mimeType: string;
+}
+
+export function getOrganizationResources(org: any): Resource[] {
+  return [
+    {
+      uri: `kernzero://organization/${org.id}`,
+      name: `Organization: ${org.name}`,
+      description: `Details for ${org.name} (${org.type} type) - Created ${new Date(org.createdAt).toLocaleDateString()}`,
+      mimeType: "application/json",
+    },
+  ];
+}
+
+export function getEnvironmentResources(orgId: string): Resource[] {
+  return [
+    {
+      uri: `kernzero://environments/${orgId}`,
+      name: `Environments in ${orgId}`,
+      description: `All monitored environments and forest DNS for organization ${orgId}`,
+      mimeType: "application/json",
+    },
+  ];
+}
+
+export function getTokenResources(orgId: string): Resource[] {
+  return [
+    {
+      uri: `kernzero://tokens/${orgId}`,
+      name: `API Tokens in ${orgId}`,
+      description: `Personal Access Tokens and their scopes for organization ${orgId}`,
+      mimeType: "application/json",
+    },
+  ];
+}
+
+export function getAuditLogResources(orgId: string): Resource[] {
+  return [
+    {
+      uri: `kernzero://audit-logs/${orgId}`,
+      name: `Audit Logs in ${orgId}`,
+      description: `Action history and who did what when in organization ${orgId}`,
+      mimeType: "application/json",
+    },
+  ];
+}