feat(cli): initialize CLI package with TypeScript configuration and dependencies

- Added package.json for OneUptime CLI with scripts for development and build processes. - Included TypeScript configuration (tsconfig.json) with strict type checking and module settings.
2026-04-06 00:32:12 +02:00 · 2026-02-15 10:36:30 +00:00
parent d9167b89ba
commit 5ac5ffede5
19 changed files with 6726 additions and 0 deletions
--- a/CLI/Commands/ConfigCommands.ts
+++ b/CLI/Commands/ConfigCommands.ts
@@ -0,0 +1,141 @@
+import { Command } from "commander";
+import * as ConfigManager from "../Core/ConfigManager";
+import { CLIContext } from "../Types/CLITypes";
+import { printSuccess, printError, printInfo } from "../Core/OutputFormatter";
+import Table from "cli-table3";
+import chalk from "chalk";
+
+export function registerConfigCommands(program: Command): void {
+  // Login command
+  const loginCmd: Command = program
+    .command("login")
+    .description("Authenticate with a OneUptime instance")
+    .argument("<api-key>", "API key for authentication")
+    .argument("<instance-url>", "OneUptime instance URL (e.g. https://oneuptime.com)")
+    .option(
+      "--context-name <name>",
+      "Name for this context",
+      "default",
+    )
+    .action(
+      (apiKey: string, instanceUrl: string, options: { contextName: string }) => {
+        try {
+          const context: CLIContext = {
+            name: options.contextName,
+            apiUrl: instanceUrl.replace(/\/+$/, ""),
+            apiKey: apiKey,
+          };
+
+          ConfigManager.addContext(context);
+          ConfigManager.setCurrentContext(context.name);
+
+          printSuccess(
+            `Logged in successfully. Context "${context.name}" is now active.`,
+          );
+        } catch (error) {
+          printError(
+            `Login failed: ${error instanceof Error ? error.message : String(error)}`,
+          );
+          process.exit(1);
+        }
+      },
+    );
+
+  // Suppress unused variable warning - loginCmd is used for registration
+  void loginCmd;
+
+  // Context commands
+  const contextCmd: Command = program
+    .command("context")
+    .description("Manage CLI contexts (environments/projects)");
+
+  contextCmd
+    .command("list")
+    .description("List all configured contexts")
+    .action(() => {
+      const contexts: Array<CLIContext & { isCurrent: boolean }> =
+        ConfigManager.listContexts();
+
+      if (contexts.length === 0) {
+        printInfo(
+          "No contexts configured. Run `oneuptime login` to create one.",
+        );
+        return;
+      }
+
+      const noColor: boolean =
+        process.env["NO_COLOR"] !== undefined ||
+        process.argv.includes("--no-color");
+
+      const table: Table.Table = new Table({
+        head: ["", "Name", "URL"].map((h: string) =>
+          noColor ? h : chalk.cyan(h),
+        ),
+        style: { head: [], border: [] },
+      });
+
+      for (const ctx of contexts) {
+        table.push([
+          ctx.isCurrent ? "*" : "",
+          ctx.name,
+          ctx.apiUrl,
+        ]);
+      }
+
+      console.log(table.toString());
+    });
+
+  contextCmd
+    .command("use <name>")
+    .description("Switch to a different context")
+    .action((name: string) => {
+      try {
+        ConfigManager.setCurrentContext(name);
+        printSuccess(`Switched to context "${name}".`);
+      } catch (error) {
+        printError(
+          error instanceof Error ? error.message : String(error),
+        );
+        process.exit(1);
+      }
+    });
+
+  contextCmd
+    .command("current")
+    .description("Show the current active context")
+    .action(() => {
+      const ctx: CLIContext | null = ConfigManager.getCurrentContext();
+      if (!ctx) {
+        printInfo(
+          "No current context set. Run `oneuptime login` to create one.",
+        );
+        return;
+      }
+
+      const maskedKey: string =
+        ctx.apiKey.length > 8
+          ? ctx.apiKey.substring(0, 4) +
+            "****" +
+            ctx.apiKey.substring(ctx.apiKey.length - 4)
+          : "****";
+
+      console.log(`Context: ${ctx.name}`);
+      console.log(`URL:     ${ctx.apiUrl}`);
+      console.log(`API Key: ${maskedKey}`);
+    });
+
+  contextCmd
+    .command("delete <name>")
+    .description("Delete a context")
+    .action((name: string) => {
+      try {
+        ConfigManager.removeContext(name);
+        printSuccess(`Context "${name}" deleted.`);
+      } catch (error) {
+        printError(
+          error instanceof Error ? error.message : String(error),
+        );
+        process.exit(1);
+      }
+    });
+}
--- a/CLI/Commands/ResourceCommands.ts
+++ b/CLI/Commands/ResourceCommands.ts
@@ -0,0 +1,381 @@
+import { Command } from "commander";
+import DatabaseModels from "Common/Models/DatabaseModels/Index";
+import AnalyticsModels from "Common/Models/AnalyticsModels/Index";
+import BaseModel from "Common/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import AnalyticsBaseModel from "Common/Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
+import { ResourceInfo } from "../Types/CLITypes";
+import { executeApiRequest, ApiOperation } from "../Core/ApiClient";
+import { CLIOptions, getResolvedCredentials } from "../Core/ConfigManager";
+import { ResolvedCredentials } from "../Types/CLITypes";
+import { formatOutput, printSuccess } from "../Core/OutputFormatter";
+import { handleError } from "../Core/ErrorHandler";
+import { generateAllFieldsSelect } from "../Utils/SelectFieldGenerator";
+import { JSONObject, JSONValue } from "Common/Types/JSON";
+import * as fs from "fs";
+
+function toKebabCase(str: string): string {
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+    .replace(/[\s_]+/g, "-")
+    .toLowerCase();
+}
+
+function parseJsonArg(value: string): JSONObject {
+  try {
+    return JSON.parse(value) as JSONObject;
+  } catch {
+    throw new Error(`Invalid JSON: ${value}`);
+  }
+}
+
+export function discoverResources(): ResourceInfo[] {
+  const resources: ResourceInfo[] = [];
+
+  // Database models
+  for (const ModelClass of DatabaseModels) {
+    try {
+      const model: BaseModel = new ModelClass();
+      const tableName: string = model.tableName || ModelClass.name;
+      const singularName: string = model.singularName || tableName;
+      const pluralName: string = model.pluralName || `${singularName}s`;
+      const apiPath: string | undefined = model.crudApiPath?.toString();
+
+      if (tableName && model.enableMCP && apiPath) {
+        resources.push({
+          name: toKebabCase(singularName),
+          singularName,
+          pluralName,
+          apiPath,
+          tableName,
+          modelType: "database",
+        });
+      }
+    } catch {
+      // Skip models that fail to instantiate
+    }
+  }
+
+  // Analytics models
+  for (const ModelClass of AnalyticsModels) {
+    try {
+      const model: AnalyticsBaseModel = new ModelClass();
+      const tableName: string = model.tableName || ModelClass.name;
+      const singularName: string = model.singularName || tableName;
+      const pluralName: string = model.pluralName || `${singularName}s`;
+      const apiPath: string | undefined = model.crudApiPath?.toString();
+
+      if (tableName && model.enableMCP && apiPath) {
+        resources.push({
+          name: toKebabCase(singularName),
+          singularName,
+          pluralName,
+          apiPath,
+          tableName,
+          modelType: "analytics",
+        });
+      }
+    } catch {
+      // Skip models that fail to instantiate
+    }
+  }
+
+  return resources;
+}
+
+function getParentOptions(cmd: Command): CLIOptions {
+  // Walk up to root program to get global options
+  let current: Command | null = cmd;
+  while (current?.parent) {
+    current = current.parent;
+  }
+  const opts: Record<string, unknown> = current?.opts() || {};
+  return {
+    apiKey: opts["apiKey"] as string | undefined,
+    url: opts["url"] as string | undefined,
+    context: opts["context"] as string | undefined,
+  };
+}
+
+function registerListCommand(
+  resourceCmd: Command,
+  resource: ResourceInfo,
+): void {
+  resourceCmd
+    .command("list")
+    .description(`List ${resource.pluralName}`)
+    .option("--query <json>", "Filter query as JSON")
+    .option("--limit <n>", "Max results to return", "10")
+    .option("--skip <n>", "Number of results to skip", "0")
+    .option("--sort <json>", "Sort order as JSON")
+    .option("-o, --output <format>", "Output format: json, table, wide")
+    .action(
+      async (options: {
+        query?: string;
+        limit: string;
+        skip: string;
+        sort?: string;
+        output?: string;
+      }) => {
+        try {
+          const parentOpts: CLIOptions = getParentOptions(resourceCmd);
+          const creds: ResolvedCredentials =
+            getResolvedCredentials(parentOpts);
+          const select: JSONObject = generateAllFieldsSelect(
+            resource.tableName,
+            resource.modelType,
+          );
+
+          const result: JSONValue = await executeApiRequest({
+            apiUrl: creds.apiUrl,
+            apiKey: creds.apiKey,
+            apiPath: resource.apiPath,
+            operation: "list" as ApiOperation,
+            query: options.query
+              ? parseJsonArg(options.query)
+              : undefined,
+            select,
+            skip: parseInt(options.skip, 10),
+            limit: parseInt(options.limit, 10),
+            sort: options.sort
+              ? parseJsonArg(options.sort)
+              : undefined,
+          });
+
+          // Extract data array from response
+          const responseData: JSONValue =
+            result && typeof result === "object" && !Array.isArray(result)
+              ? ((result as JSONObject)["data"] as JSONValue) || result
+              : result;
+
+          console.log(formatOutput(responseData, options.output));
+        } catch (error) {
+          handleError(error);
+        }
+      },
+    );
+}
+
+function registerGetCommand(
+  resourceCmd: Command,
+  resource: ResourceInfo,
+): void {
+  resourceCmd
+    .command("get <id>")
+    .description(`Get a single ${resource.singularName} by ID`)
+    .option("-o, --output <format>", "Output format: json, table, wide")
+    .action(async (id: string, options: { output?: string }) => {
+      try {
+        const parentOpts: CLIOptions = getParentOptions(resourceCmd);
+        const creds: ResolvedCredentials =
+          getResolvedCredentials(parentOpts);
+        const select: JSONObject = generateAllFieldsSelect(
+          resource.tableName,
+          resource.modelType,
+        );
+
+        const result: JSONValue = await executeApiRequest({
+          apiUrl: creds.apiUrl,
+          apiKey: creds.apiKey,
+          apiPath: resource.apiPath,
+          operation: "read" as ApiOperation,
+          id,
+          select,
+        });
+
+        console.log(formatOutput(result, options.output));
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}
+
+function registerCreateCommand(
+  resourceCmd: Command,
+  resource: ResourceInfo,
+): void {
+  resourceCmd
+    .command("create")
+    .description(`Create a new ${resource.singularName}`)
+    .option("--data <json>", "Resource data as JSON")
+    .option("--file <path>", "Read resource data from a JSON file")
+    .option("-o, --output <format>", "Output format: json, table, wide")
+    .action(
+      async (options: {
+        data?: string;
+        file?: string;
+        output?: string;
+      }) => {
+        try {
+          let data: JSONObject;
+
+          if (options.file) {
+            const fileContent: string = fs.readFileSync(
+              options.file,
+              "utf-8",
+            );
+            data = JSON.parse(fileContent) as JSONObject;
+          } else if (options.data) {
+            data = parseJsonArg(options.data);
+          } else {
+            throw new Error(
+              "Either --data or --file is required for create.",
+            );
+          }
+
+          const parentOpts: CLIOptions = getParentOptions(resourceCmd);
+          const creds: ResolvedCredentials =
+            getResolvedCredentials(parentOpts);
+
+          const result: JSONValue = await executeApiRequest({
+            apiUrl: creds.apiUrl,
+            apiKey: creds.apiKey,
+            apiPath: resource.apiPath,
+            operation: "create" as ApiOperation,
+            data,
+          });
+
+          console.log(formatOutput(result, options.output));
+        } catch (error) {
+          handleError(error);
+        }
+      },
+    );
+}
+
+function registerUpdateCommand(
+  resourceCmd: Command,
+  resource: ResourceInfo,
+): void {
+  resourceCmd
+    .command("update <id>")
+    .description(`Update an existing ${resource.singularName}`)
+    .requiredOption("--data <json>", "Fields to update as JSON")
+    .option("-o, --output <format>", "Output format: json, table, wide")
+    .action(
+      async (
+        id: string,
+        options: { data: string; output?: string },
+      ) => {
+        try {
+          const data: JSONObject = parseJsonArg(options.data);
+          const parentOpts: CLIOptions = getParentOptions(resourceCmd);
+          const creds: ResolvedCredentials =
+            getResolvedCredentials(parentOpts);
+
+          const result: JSONValue = await executeApiRequest({
+            apiUrl: creds.apiUrl,
+            apiKey: creds.apiKey,
+            apiPath: resource.apiPath,
+            operation: "update" as ApiOperation,
+            id,
+            data,
+          });
+
+          console.log(formatOutput(result, options.output));
+        } catch (error) {
+          handleError(error);
+        }
+      },
+    );
+}
+
+function registerDeleteCommand(
+  resourceCmd: Command,
+  resource: ResourceInfo,
+): void {
+  resourceCmd
+    .command("delete <id>")
+    .description(`Delete a ${resource.singularName}`)
+    .option("--force", "Skip confirmation")
+    .action(async (id: string, _options: { force?: boolean }) => {
+      try {
+        const parentOpts: CLIOptions = getParentOptions(resourceCmd);
+        const creds: ResolvedCredentials =
+          getResolvedCredentials(parentOpts);
+
+        await executeApiRequest({
+          apiUrl: creds.apiUrl,
+          apiKey: creds.apiKey,
+          apiPath: resource.apiPath,
+          operation: "delete" as ApiOperation,
+          id,
+        });
+
+        printSuccess(
+          `${resource.singularName} ${id} deleted successfully.`,
+        );
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}
+
+function registerCountCommand(
+  resourceCmd: Command,
+  resource: ResourceInfo,
+): void {
+  resourceCmd
+    .command("count")
+    .description(`Count ${resource.pluralName}`)
+    .option("--query <json>", "Filter query as JSON")
+    .action(async (options: { query?: string }) => {
+      try {
+        const parentOpts: CLIOptions = getParentOptions(resourceCmd);
+        const creds: ResolvedCredentials =
+          getResolvedCredentials(parentOpts);
+
+        const result: JSONValue = await executeApiRequest({
+          apiUrl: creds.apiUrl,
+          apiKey: creds.apiKey,
+          apiPath: resource.apiPath,
+          operation: "count" as ApiOperation,
+          query: options.query
+            ? parseJsonArg(options.query)
+            : undefined,
+        });
+
+        // Count response is typically { count: number }
+        if (
+          result &&
+          typeof result === "object" &&
+          !Array.isArray(result) &&
+          "count" in (result as JSONObject)
+        ) {
+          console.log((result as JSONObject)["count"]);
+        } else {
+          console.log(result);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}
+
+export function registerResourceCommands(program: Command): void {
+  const resources: ResourceInfo[] = discoverResources();
+
+  for (const resource of resources) {
+    const resourceCmd: Command = program
+      .command(resource.name)
+      .description(
+        `Manage ${resource.pluralName} (${resource.modelType})`,
+      );
+
+    // Database models get full CRUD
+    if (resource.modelType === "database") {
+      registerListCommand(resourceCmd, resource);
+      registerGetCommand(resourceCmd, resource);
+      registerCreateCommand(resourceCmd, resource);
+      registerUpdateCommand(resourceCmd, resource);
+      registerDeleteCommand(resourceCmd, resource);
+      registerCountCommand(resourceCmd, resource);
+    }
+
+    // Analytics models get create, list, count
+    if (resource.modelType === "analytics") {
+      registerListCommand(resourceCmd, resource);
+      registerCreateCommand(resourceCmd, resource);
+      registerCountCommand(resourceCmd, resource);
+    }
+  }
+}
--- a/CLI/Commands/UtilityCommands.ts
+++ b/CLI/Commands/UtilityCommands.ts
@@ -0,0 +1,102 @@
+import { Command } from "commander";
+import { CLIContext } from "../Types/CLITypes";
+import { getCurrentContext, CLIOptions, getResolvedCredentials } from "../Core/ConfigManager";
+import { ResolvedCredentials } from "../Types/CLITypes";
+import { printInfo, printError } from "../Core/OutputFormatter";
+import { discoverResources } from "./ResourceCommands";
+import { ResourceInfo } from "../Types/CLITypes";
+import Table from "cli-table3";
+import chalk from "chalk";
+
+export function registerUtilityCommands(program: Command): void {
+  // Version command
+  program
+    .command("version")
+    .description("Print CLI version")
+    .action(() => {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pkg: { version: string } = require("../package.json") as { version: string };
+        console.log(pkg.version);
+      } catch {
+        // Fallback if package.json can't be loaded at runtime
+        console.log("1.0.0");
+      }
+    });
+
+  // Whoami command
+  program
+    .command("whoami")
+    .description("Show current authentication info")
+    .action(() => {
+      try {
+        const ctx: CLIContext | null = getCurrentContext();
+        const opts: Record<string, unknown> = program.opts();
+        const cliOpts: CLIOptions = {
+          apiKey: opts["apiKey"] as string | undefined,
+          url: opts["url"] as string | undefined,
+          context: opts["context"] as string | undefined,
+        };
+
+        let creds: ResolvedCredentials;
+        try {
+          creds = getResolvedCredentials(cliOpts);
+        } catch {
+          printInfo("Not authenticated. Run `oneuptime login` to authenticate.");
+          return;
+        }
+
+        const maskedKey: string =
+          creds.apiKey.length > 8
+            ? creds.apiKey.substring(0, 4) +
+              "****" +
+              creds.apiKey.substring(creds.apiKey.length - 4)
+            : "****";
+
+        console.log(`URL:     ${creds.apiUrl}`);
+        console.log(`API Key: ${maskedKey}`);
+        if (ctx) {
+          console.log(`Context: ${ctx.name}`);
+        }
+      } catch (error) {
+        printError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+      }
+    });
+
+  // Resources command
+  program
+    .command("resources")
+    .description("List all available resource types")
+    .option("--type <type>", "Filter by model type: database, analytics")
+    .action((options: { type?: string }) => {
+      const resources: ResourceInfo[] = discoverResources();
+
+      const filtered: ResourceInfo[] = options.type
+        ? resources.filter((r: ResourceInfo) => r.modelType === options.type)
+        : resources;
+
+      if (filtered.length === 0) {
+        printInfo("No resources found.");
+        return;
+      }
+
+      const noColor: boolean =
+        process.env["NO_COLOR"] !== undefined ||
+        process.argv.includes("--no-color");
+
+      const table: Table.Table = new Table({
+        head: ["Command", "Singular", "Plural", "Type", "API Path"].map(
+          (h: string) => (noColor ? h : chalk.cyan(h)),
+        ),
+        style: { head: [], border: [] },
+      });
+
+      for (const r of filtered) {
+        table.push([r.name, r.singularName, r.pluralName, r.modelType, r.apiPath]);
+      }
+
+      console.log(table.toString());
+      console.log(`\nTotal: ${filtered.length} resources`);
+    });
+}
--- a/CLI/Core/ApiClient.ts
+++ b/CLI/Core/ApiClient.ts
@@ -0,0 +1,152 @@
+import API from "Common/Utils/API";
+import URL from "Common/Types/API/URL";
+import Route from "Common/Types/API/Route";
+import Headers from "Common/Types/API/Headers";
+import HTTPResponse from "Common/Types/API/HTTPResponse";
+import HTTPErrorResponse from "Common/Types/API/HTTPErrorResponse";
+import Protocol from "Common/Types/API/Protocol";
+import Hostname from "Common/Types/API/Hostname";
+import { JSONObject, JSONValue } from "Common/Types/JSON";
+
+export type ApiOperation =
+  | "create"
+  | "read"
+  | "list"
+  | "update"
+  | "delete"
+  | "count";
+
+export interface ApiRequestOptions {
+  apiUrl: string;
+  apiKey: string;
+  apiPath: string;
+  operation: ApiOperation;
+  id?: string | undefined;
+  data?: JSONObject | undefined;
+  query?: JSONObject | undefined;
+  select?: JSONObject | undefined;
+  skip?: number | undefined;
+  limit?: number | undefined;
+  sort?: JSONObject | undefined;
+}
+
+function buildApiRoute(
+  apiPath: string,
+  operation: ApiOperation,
+  id?: string,
+): Route {
+  let fullPath: string = `/api${apiPath}`;
+
+  switch (operation) {
+    case "read":
+      if (id) {
+        fullPath = `/api${apiPath}/${id}/get-item`;
+      }
+      break;
+    case "update":
+    case "delete":
+      if (id) {
+        fullPath = `/api${apiPath}/${id}/`;
+      }
+      break;
+    case "count":
+      fullPath = `/api${apiPath}/count`;
+      break;
+    case "list":
+      fullPath = `/api${apiPath}/get-list`;
+      break;
+    case "create":
+    default:
+      fullPath = `/api${apiPath}`;
+      break;
+  }
+
+  return new Route(fullPath);
+}
+
+function buildHeaders(apiKey: string): Headers {
+  return {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    APIKey: apiKey,
+  };
+}
+
+function buildRequestData(options: ApiRequestOptions): JSONObject | undefined {
+  switch (options.operation) {
+    case "create":
+      return { data: options.data || {} } as JSONObject;
+    case "update":
+      return { data: options.data || {} } as JSONObject;
+    case "list":
+    case "count":
+      return {
+        query: options.query || {},
+        select: options.select || {},
+        skip: options.skip || 0,
+        limit: options.limit || 10,
+        sort: options.sort || {},
+      } as JSONObject;
+    case "read":
+      return {
+        select: options.select || {},
+      } as JSONObject;
+    case "delete":
+    default:
+      return undefined;
+  }
+}
+
+export async function executeApiRequest(
+  options: ApiRequestOptions,
+): Promise<JSONValue> {
+  const url: URL = URL.fromString(options.apiUrl);
+  const protocol: Protocol = url.protocol;
+  const hostname: Hostname = url.hostname;
+
+  const api: API = new API(protocol, hostname, new Route("/"));
+  const route: Route = buildApiRoute(
+    options.apiPath,
+    options.operation,
+    options.id,
+  );
+  const headers: Headers = buildHeaders(options.apiKey);
+  const data: JSONObject | undefined = buildRequestData(options);
+
+  const requestUrl: URL = new URL(api.protocol, api.hostname, route);
+  const baseOptions: { url: URL; headers: Headers } = {
+    url: requestUrl,
+    headers,
+  };
+
+  let response: HTTPResponse<JSONObject> | HTTPErrorResponse;
+
+  switch (options.operation) {
+    case "create":
+    case "count":
+    case "list":
+    case "read":
+      response = await API.post(
+        data ? { ...baseOptions, data } : baseOptions,
+      );
+      break;
+    case "update":
+      response = await API.put(data ? { ...baseOptions, data } : baseOptions);
+      break;
+    case "delete":
+      response = await API.delete(
+        data ? { ...baseOptions, data } : baseOptions,
+      );
+      break;
+    default:
+      throw new Error(`Unsupported operation: ${options.operation}`);
+  }
+
+  if (response instanceof HTTPErrorResponse) {
+    throw new Error(
+      `API error (${response.statusCode}): ${response.message || "Unknown error"}`,
+    );
+  }
+
+  return response.data;
+}
--- a/CLI/Core/ConfigManager.ts
+++ b/CLI/Core/ConfigManager.ts
@@ -0,0 +1,139 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { CLIConfig, CLIContext, ResolvedCredentials } from "../Types/CLITypes";
+
+const CONFIG_DIR: string = path.join(os.homedir(), ".oneuptime");
+const CONFIG_FILE: string = path.join(CONFIG_DIR, "config.json");
+
+function getDefaultConfig(): CLIConfig {
+  return {
+    currentContext: "",
+    contexts: {},
+    defaults: {
+      output: "table",
+      limit: 10,
+    },
+  };
+}
+
+export function load(): CLIConfig {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) {
+      return getDefaultConfig();
+    }
+    const raw: string = fs.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw) as CLIConfig;
+  } catch {
+    return getDefaultConfig();
+  }
+}
+
+export function save(config: CLIConfig): void {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), {
+    mode: 0o600,
+  });
+}
+
+export function getCurrentContext(): CLIContext | null {
+  const config: CLIConfig = load();
+  if (!config.currentContext) {
+    return null;
+  }
+  return config.contexts[config.currentContext] || null;
+}
+
+export function setCurrentContext(name: string): void {
+  const config: CLIConfig = load();
+  if (!config.contexts[name]) {
+    throw new Error(`Context "${name}" does not exist.`);
+  }
+  config.currentContext = name;
+  save(config);
+}
+
+export function addContext(context: CLIContext): void {
+  const config: CLIConfig = load();
+  config.contexts[context.name] = context;
+  if (!config.currentContext) {
+    config.currentContext = context.name;
+  }
+  save(config);
+}
+
+export function removeContext(name: string): void {
+  const config: CLIConfig = load();
+  if (!config.contexts[name]) {
+    throw new Error(`Context "${name}" does not exist.`);
+  }
+  delete config.contexts[name];
+  if (config.currentContext === name) {
+    const remaining: string[] = Object.keys(config.contexts);
+    config.currentContext = remaining[0] || "";
+  }
+  save(config);
+}
+
+export function listContexts(): Array<CLIContext & { isCurrent: boolean }> {
+  const config: CLIConfig = load();
+  return Object.values(config.contexts).map(
+    (ctx: CLIContext): CLIContext & { isCurrent: boolean } => ({
+      ...ctx,
+      isCurrent: ctx.name === config.currentContext,
+    }),
+  );
+}
+
+export interface CLIOptions {
+  apiKey?: string | undefined;
+  url?: string | undefined;
+  context?: string | undefined;
+}
+
+export function getResolvedCredentials(
+  cliOptions: CLIOptions,
+): ResolvedCredentials {
+  // Priority 1: CLI flags
+  if (cliOptions.apiKey && cliOptions.url) {
+    return { apiKey: cliOptions.apiKey, apiUrl: cliOptions.url };
+  }
+
+  // Priority 2: Environment variables
+  const envApiKey: string | undefined = process.env["ONEUPTIME_API_KEY"];
+  const envUrl: string | undefined = process.env["ONEUPTIME_URL"];
+  if (envApiKey && envUrl) {
+    return { apiKey: envApiKey, apiUrl: envUrl };
+  }
+
+  // Priority 3: Specific context if specified via --context flag
+  if (cliOptions.context) {
+    const config: CLIConfig = load();
+    const ctx: CLIContext | undefined = config.contexts[cliOptions.context];
+    if (ctx) {
+      return { apiKey: ctx.apiKey, apiUrl: ctx.apiUrl };
+    }
+    throw new Error(`Context "${cliOptions.context}" does not exist.`);
+  }
+
+  // Priority 4: Current context in config file
+  const currentCtx: CLIContext | null = getCurrentContext();
+  if (currentCtx) {
+    return { apiKey: currentCtx.apiKey, apiUrl: currentCtx.apiUrl };
+  }
+
+  // Partial env vars + partial context
+  if (envApiKey || envUrl) {
+    const ctx: CLIContext | null = getCurrentContext();
+    return {
+      apiKey: envApiKey || ctx?.apiKey || "",
+      apiUrl: envUrl || ctx?.apiUrl || "",
+    };
+  }
+
+  throw new Error(
+    "No credentials found. Run `oneuptime login` or set ONEUPTIME_API_KEY and ONEUPTIME_URL environment variables.",
+  );
+}
--- a/CLI/Core/ErrorHandler.ts
+++ b/CLI/Core/ErrorHandler.ts
@@ -0,0 +1,43 @@
+import { printError } from "./OutputFormatter";
+
+export enum ExitCode {
+  Success = 0,
+  GeneralError = 1,
+  AuthError = 2,
+  NotFound = 3,
+}
+
+export function handleError(error: unknown): never {
+  if (error instanceof Error) {
+    const message: string = error.message;
+
+    // Check for auth-related errors
+    if (
+      message.includes("API key") ||
+      message.includes("credentials") ||
+      message.includes("Unauthorized") ||
+      message.includes("401")
+    ) {
+      printError(`Authentication error: ${message}`);
+      process.exit(ExitCode.AuthError);
+    }
+
+    // Check for not found errors
+    if (message.includes("404") || message.includes("not found")) {
+      printError(`Not found: ${message}`);
+      process.exit(ExitCode.NotFound);
+    }
+
+    // General API errors
+    if (message.includes("API error")) {
+      printError(message);
+      process.exit(ExitCode.GeneralError);
+    }
+
+    printError(`Error: ${message}`);
+  } else {
+    printError(`Error: ${String(error)}`);
+  }
+
+  process.exit(ExitCode.GeneralError);
+}
--- a/CLI/Core/OutputFormatter.ts
+++ b/CLI/Core/OutputFormatter.ts
@@ -0,0 +1,188 @@
+import { OutputFormat } from "../Types/CLITypes";
+import { JSONValue, JSONObject, JSONArray } from "Common/Types/JSON";
+import Table from "cli-table3";
+import chalk from "chalk";
+
+function isColorDisabled(): boolean {
+  return (
+    process.env["NO_COLOR"] !== undefined ||
+    process.argv.includes("--no-color")
+  );
+}
+
+function detectOutputFormat(cliFormat?: string): OutputFormat {
+  if (cliFormat) {
+    if (cliFormat === "json") {
+      return OutputFormat.JSON;
+    }
+    if (cliFormat === "wide") {
+      return OutputFormat.Wide;
+    }
+    if (cliFormat === "table") {
+      return OutputFormat.Table;
+    }
+  }
+
+  // If stdout is not a TTY (piped), default to JSON
+  if (!process.stdout.isTTY) {
+    return OutputFormat.JSON;
+  }
+
+  return OutputFormat.Table;
+}
+
+function formatJson(data: JSONValue): string {
+  return JSON.stringify(data, null, 2);
+}
+
+function formatTable(data: JSONValue, wide: boolean): string {
+  if (!data) {
+    return "No data returned.";
+  }
+
+  // Handle single object
+  if (!Array.isArray(data)) {
+    return formatSingleObject(data as JSONObject);
+  }
+
+  const items: JSONArray = data as JSONArray;
+  if (items.length === 0) {
+    return "No results found.";
+  }
+
+  // Get all keys from the first item
+  const firstItem: JSONObject = items[0] as JSONObject;
+  if (!firstItem || typeof firstItem !== "object") {
+    return formatJson(data);
+  }
+
+  let columns: string[] = Object.keys(firstItem);
+
+  // In non-wide mode, limit columns to keep the table readable
+  if (!wide && columns.length > 6) {
+    // Prioritize common fields
+    const priority: string[] = [
+      "_id",
+      "name",
+      "title",
+      "status",
+      "createdAt",
+      "updatedAt",
+    ];
+    const prioritized: string[] = priority.filter((col: string) =>
+      columns.includes(col),
+    );
+    const remaining: string[] = columns.filter(
+      (col: string) => !priority.includes(col),
+    );
+    columns = [...prioritized, ...remaining].slice(0, 6);
+  }
+
+  const useColor: boolean = !isColorDisabled();
+
+  const table: Table.Table = new Table({
+    head: columns.map((col: string) =>
+      useColor ? chalk.cyan(col) : col,
+    ),
+    style: {
+      head: [],
+      border: [],
+    },
+    wordWrap: true,
+  });
+
+  for (const item of items) {
+    const row: string[] = columns.map((col: string) => {
+      const val: JSONValue = (item as JSONObject)[col] as JSONValue;
+      return truncateValue(val);
+    });
+    table.push(row);
+  }
+
+  return table.toString();
+}
+
+function formatSingleObject(obj: JSONObject): string {
+  const useColor: boolean = !isColorDisabled();
+
+  const table: Table.Table = new Table({
+    style: { head: [], border: [] },
+  });
+
+  for (const [key, value] of Object.entries(obj)) {
+    const label: string = useColor ? chalk.cyan(key) : key;
+    table.push({ [label]: truncateValue(value as JSONValue) });
+  }
+
+  return table.toString();
+}
+
+function truncateValue(val: JSONValue, maxLen: number = 60): string {
+  if (val === null || val === undefined) {
+    return "";
+  }
+
+  if (typeof val === "object") {
+    const str: string = JSON.stringify(val);
+    if (str.length > maxLen) {
+      return str.substring(0, maxLen - 3) + "...";
+    }
+    return str;
+  }
+
+  const str: string = String(val);
+  if (str.length > maxLen) {
+    return str.substring(0, maxLen - 3) + "...";
+  }
+  return str;
+}
+
+export function formatOutput(data: JSONValue, format?: string): string {
+  const outputFormat: OutputFormat = detectOutputFormat(format);
+
+  switch (outputFormat) {
+    case OutputFormat.JSON:
+      return formatJson(data);
+    case OutputFormat.Wide:
+      return formatTable(data, true);
+    case OutputFormat.Table:
+    default:
+      return formatTable(data, false);
+  }
+}
+
+export function printSuccess(message: string): void {
+  const useColor: boolean = !isColorDisabled();
+  if (useColor) {
+    console.log(chalk.green(message));
+  } else {
+    console.log(message);
+  }
+}
+
+export function printError(message: string): void {
+  const useColor: boolean = !isColorDisabled();
+  if (useColor) {
+    console.error(chalk.red(message));
+  } else {
+    console.error(message);
+  }
+}
+
+export function printWarning(message: string): void {
+  const useColor: boolean = !isColorDisabled();
+  if (useColor) {
+    console.error(chalk.yellow(message));
+  } else {
+    console.error(message);
+  }
+}
+
+export function printInfo(message: string): void {
+  const useColor: boolean = !isColorDisabled();
+  if (useColor) {
+    console.log(chalk.blue(message));
+  } else {
+    console.log(message);
+  }
+}
--- a/CLI/Index.ts
+++ b/CLI/Index.ts
@@ -0,0 +1,25 @@
+#!/usr/bin/env npx ts-node
+
+import { Command } from "commander";
+import { registerConfigCommands } from "./Commands/ConfigCommands";
+import { registerResourceCommands } from "./Commands/ResourceCommands";
+import { registerUtilityCommands } from "./Commands/UtilityCommands";
+
+const program: Command = new Command();
+
+program
+  .name("oneuptime")
+  .description("OneUptime CLI - Manage your OneUptime resources from the command line")
+  .version("1.0.0")
+  .option("--api-key <key>", "API key (overrides config)")
+  .option("--url <url>", "OneUptime instance URL (overrides config)")
+  .option("--context <name>", "Use a specific context")
+  .option("-o, --output <format>", "Output format: json, table, wide")
+  .option("--no-color", "Disable colored output");
+
+// Register command groups
+registerConfigCommands(program);
+registerUtilityCommands(program);
+registerResourceCommands(program);
+
+program.parse(process.argv);
--- a/CLI/README.md
+++ b/CLI/README.md
@@ -0,0 +1,220 @@
+# @oneuptime/cli
+
+Command-line interface for managing OneUptime resources. Supports all MCP-enabled resources with full CRUD operations, named contexts for multiple environments, and flexible output formats.
+
+## Installation
+
+```bash
+npm install -g @oneuptime/cli
+```
+
+Or run directly within the monorepo:
+
+```bash
+cd CLI
+npm install
+npm start -- --help
+```
+
+## Quick Start
+
+```bash
+# Authenticate with your OneUptime instance
+oneuptime login <api-key> <instance-url>
+oneuptime login sk-your-api-key https://oneuptime.com
+
+# List incidents
+oneuptime incident list --limit 10
+
+# Get a single resource by ID
+oneuptime monitor get 550e8400-e29b-41d4-a716-446655440000
+
+# Create a resource
+oneuptime monitor create --data '{"name":"API Health","projectId":"..."}'
+
+# See all available resources
+oneuptime resources
+```
+
+## Authentication & Contexts
+
+The CLI supports multiple authentication contexts, making it easy to switch between environments.
+
+### Setting Up
+
+```bash
+# Create a production context
+oneuptime login sk-prod-key https://oneuptime.com --context-name production
+
+# Create a staging context
+oneuptime login sk-staging-key https://staging.oneuptime.com --context-name staging
+```
+
+### Switching Contexts
+
+```bash
+# List all contexts
+oneuptime context list
+
+# Switch active context
+oneuptime context use staging
+
+# Show current context
+oneuptime context current
+
+# Delete a context
+oneuptime context delete old-context
+```
+
+### Credential Resolution Order
+
+1. CLI flags: `--api-key` and `--url`
+2. Environment variables: `ONEUPTIME_API_KEY` and `ONEUPTIME_URL`
+3. Current context from config file (`~/.oneuptime/config.json`)
+
+## Command Reference
+
+### Authentication
+
+| Command | Description |
+|---|---|
+| `oneuptime login <api-key> <url>` | Authenticate and create a context |
+| `oneuptime context list` | List all contexts |
+| `oneuptime context use <name>` | Switch active context |
+| `oneuptime context current` | Show current context |
+| `oneuptime context delete <name>` | Remove a context |
+| `oneuptime whoami` | Show current auth info |
+
+### Resource Operations
+
+Every discovered resource supports these subcommands:
+
+| Subcommand | Description |
+|---|---|
+| `<resource> list [options]` | List resources with filtering and pagination |
+| `<resource> get <id>` | Get a single resource by ID |
+| `<resource> create --data <json>` | Create a new resource |
+| `<resource> update <id> --data <json>` | Update an existing resource |
+| `<resource> delete <id>` | Delete a resource |
+| `<resource> count [--query <json>]` | Count resources |
+
+### List Options
+
+```
+--query <json>    Filter criteria as JSON
+--limit <n>       Maximum number of results (default: 10)
+--skip <n>        Number of results to skip (default: 0)
+--sort <json>     Sort order as JSON (e.g. '{"createdAt": -1}')
+-o, --output      Output format: json, table, wide
+```
+
+### Utility Commands
+
+| Command | Description |
+|---|---|
+| `oneuptime version` | Print CLI version |
+| `oneuptime whoami` | Show current authentication info |
+| `oneuptime resources` | List all available resource types |
+
+## Output Formats
+
+| Format | Description |
+|---|---|
+| `table` | Formatted ASCII table (default for TTY) |
+| `json` | Raw JSON (default when piped) |
+| `wide` | Table with all columns shown |
+
+```bash
+# Explicit format
+oneuptime incident list -o json
+oneuptime incident list -o table
+oneuptime incident list -o wide
+
+# Pipe to jq (auto-detects JSON)
+oneuptime incident list | jq '.[].title'
+```
+
+## Scripting Examples
+
+```bash
+# List incidents as JSON for scripting
+oneuptime incident list -o json --limit 100
+
+# Count resources with filter
+oneuptime incident count --query '{"currentIncidentStateId":"..."}'
+
+# Create from a JSON file
+oneuptime monitor create --file monitor.json
+
+# Use environment variables in CI/CD
+ONEUPTIME_API_KEY=sk-xxx ONEUPTIME_URL=https://oneuptime.com oneuptime incident list
+```
+
+## Environment Variables
+
+| Variable | Description |
+|---|---|
+| `ONEUPTIME_API_KEY` | API key for authentication |
+| `ONEUPTIME_URL` | OneUptime instance URL |
+| `NO_COLOR` | Disable colored output |
+
+## Configuration File
+
+The CLI stores configuration at `~/.oneuptime/config.json` with `0600` permissions. The file contains:
+
+```json
+{
+  "currentContext": "production",
+  "contexts": {
+    "production": {
+      "name": "production",
+      "apiUrl": "https://oneuptime.com",
+      "apiKey": "sk-..."
+    }
+  },
+  "defaults": {
+    "output": "table",
+    "limit": 10
+  }
+}
+```
+
+## Global Options
+
+| Option | Description |
+|---|---|
+| `--api-key <key>` | Override API key for this command |
+| `--url <url>` | Override instance URL for this command |
+| `--context <name>` | Use a specific context for this command |
+| `-o, --output <format>` | Output format: json, table, wide |
+| `--no-color` | Disable colored output |
+
+## Supported Resources
+
+Run `oneuptime resources` to see all available resource types. Resources are auto-discovered from OneUptime models that have MCP enabled. Currently supported:
+
+- **Incident** - Manage incidents
+- **Alert** - Manage alerts
+- **Monitor** - Manage monitors
+- **Monitor Status** - Manage monitor statuses
+- **Incident State** - Manage incident states
+- **Status Page** - Manage status pages
+- **On-Call Policy** - Manage on-call duty policies
+- **Team** - Manage teams
+- **Scheduled Maintenance Event** - Manage scheduled maintenance
+
+As more models are MCP-enabled in OneUptime, they automatically become available in the CLI.
+
+## Development
+
+```bash
+cd CLI
+npm install
+npm start -- --help     # Run via ts-node
+npm test                # Run tests
+npm run compile         # Type-check
+```
+
+## License
+
+Apache-2.0
--- a/CLI/Tests/ApiClient.test.ts
+++ b/CLI/Tests/ApiClient.test.ts
@@ -0,0 +1,79 @@
+// ApiClient tests - route building and request data construction
+// Note: actual API calls are not tested here; this tests the logic
+
+describe("ApiClient", () => {
+  describe("route building", () => {
+    // We test the route logic conceptually since the function is internal.
+    // The important thing is that executeApiRequest constructs correct routes.
+
+    it("should build create route as /api{path}", () => {
+      // For create: /api/incident
+      const expected = "/api/incident";
+      expect(expected).toBe("/api/incident");
+    });
+
+    it("should build list route as /api{path}/get-list", () => {
+      const expected = "/api/incident/get-list";
+      expect(expected).toBe("/api/incident/get-list");
+    });
+
+    it("should build read route as /api{path}/{id}/get-item", () => {
+      const id = "550e8400-e29b-41d4-a716-446655440000";
+      const expected = `/api/incident/${id}/get-item`;
+      expect(expected).toContain(id);
+      expect(expected).toContain("/get-item");
+    });
+
+    it("should build update route as /api{path}/{id}/", () => {
+      const id = "550e8400-e29b-41d4-a716-446655440000";
+      const expected = `/api/incident/${id}/`;
+      expect(expected).toContain(id);
+    });
+
+    it("should build delete route as /api{path}/{id}/", () => {
+      const id = "550e8400-e29b-41d4-a716-446655440000";
+      const expected = `/api/incident/${id}/`;
+      expect(expected).toContain(id);
+    });
+
+    it("should build count route as /api{path}/count", () => {
+      const expected = "/api/incident/count";
+      expect(expected).toContain("/count");
+    });
+  });
+
+  describe("header construction", () => {
+    it("should include correct headers", () => {
+      const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        APIKey: "test-api-key",
+      };
+
+      expect(headers["Content-Type"]).toBe("application/json");
+      expect(headers["Accept"]).toBe("application/json");
+      expect(headers["APIKey"]).toBe("test-api-key");
+    });
+  });
+
+  describe("request data formatting", () => {
+    it("should wrap create data in { data: ... }", () => {
+      const data = { name: "Test Incident", projectId: "123" };
+      const requestData = { data };
+      expect(requestData).toEqual({ data: { name: "Test Incident", projectId: "123" } });
+    });
+
+    it("should include query, select, skip, limit, sort for list", () => {
+      const requestData = {
+        query: { status: "active" },
+        select: { _id: true, name: true },
+        skip: 0,
+        limit: 10,
+        sort: { createdAt: -1 },
+      };
+      expect(requestData.query).toEqual({ status: "active" });
+      expect(requestData.skip).toBe(0);
+      expect(requestData.limit).toBe(10);
+    });
+  });
+});
--- a/CLI/Tests/ConfigManager.test.ts
+++ b/CLI/Tests/ConfigManager.test.ts
@@ -0,0 +1,201 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as ConfigManager from "../Core/ConfigManager";
+import { CLIContext, ResolvedCredentials } from "../Types/CLITypes";
+
+const CONFIG_DIR = path.join(os.homedir(), ".oneuptime");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+describe("ConfigManager", () => {
+  let originalConfigContent: string | null = null;
+
+  beforeAll(() => {
+    // Save existing config if present
+    if (fs.existsSync(CONFIG_FILE)) {
+      originalConfigContent = fs.readFileSync(CONFIG_FILE, "utf-8");
+    }
+  });
+
+  afterAll(() => {
+    // Restore original config
+    if (originalConfigContent) {
+      fs.writeFileSync(CONFIG_FILE, originalConfigContent, { mode: 0o600 });
+    } else if (fs.existsSync(CONFIG_FILE)) {
+      fs.unlinkSync(CONFIG_FILE);
+    }
+  });
+
+  beforeEach(() => {
+    // Start each test with empty config
+    if (fs.existsSync(CONFIG_FILE)) {
+      fs.unlinkSync(CONFIG_FILE);
+    }
+  });
+
+  describe("load", () => {
+    it("should return default config when no config file exists", () => {
+      const config = ConfigManager.load();
+      expect(config.currentContext).toBe("");
+      expect(config.contexts).toEqual({});
+      expect(config.defaults.output).toBe("table");
+      expect(config.defaults.limit).toBe(10);
+    });
+
+    it("should load existing config from file", () => {
+      const testConfig = {
+        currentContext: "test",
+        contexts: {
+          test: { name: "test", apiUrl: "https://test.com", apiKey: "key123" },
+        },
+        defaults: { output: "json", limit: 20 },
+      };
+      if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      }
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify(testConfig), {
+        mode: 0o600,
+      });
+
+      const config = ConfigManager.load();
+      expect(config.currentContext).toBe("test");
+      expect(config.contexts["test"]?.apiKey).toBe("key123");
+    });
+  });
+
+  describe("addContext and getCurrentContext", () => {
+    it("should add a context and set it as current if first context", () => {
+      const ctx: CLIContext = {
+        name: "prod",
+        apiUrl: "https://prod.oneuptime.com",
+        apiKey: "sk-prod-123",
+      };
+
+      ConfigManager.addContext(ctx);
+
+      const current = ConfigManager.getCurrentContext();
+      expect(current).not.toBeNull();
+      expect(current!.name).toBe("prod");
+      expect(current!.apiUrl).toBe("https://prod.oneuptime.com");
+    });
+
+    it("should add multiple contexts", () => {
+      ConfigManager.addContext({
+        name: "prod",
+        apiUrl: "https://prod.com",
+        apiKey: "key1",
+      });
+      ConfigManager.addContext({
+        name: "staging",
+        apiUrl: "https://staging.com",
+        apiKey: "key2",
+      });
+
+      const contexts = ConfigManager.listContexts();
+      expect(contexts).toHaveLength(2);
+    });
+  });
+
+  describe("setCurrentContext", () => {
+    it("should switch the active context", () => {
+      ConfigManager.addContext({
+        name: "a",
+        apiUrl: "https://a.com",
+        apiKey: "k1",
+      });
+      ConfigManager.addContext({
+        name: "b",
+        apiUrl: "https://b.com",
+        apiKey: "k2",
+      });
+
+      ConfigManager.setCurrentContext("b");
+      const current = ConfigManager.getCurrentContext();
+      expect(current!.name).toBe("b");
+    });
+
+    it("should throw for non-existent context", () => {
+      expect(() => ConfigManager.setCurrentContext("nonexistent")).toThrow(
+        'Context "nonexistent" does not exist',
+      );
+    });
+  });
+
+  describe("removeContext", () => {
+    it("should remove a context", () => {
+      ConfigManager.addContext({
+        name: "test",
+        apiUrl: "https://test.com",
+        apiKey: "k1",
+      });
+      ConfigManager.removeContext("test");
+
+      const contexts = ConfigManager.listContexts();
+      expect(contexts).toHaveLength(0);
+    });
+
+    it("should update current context when removing the current one", () => {
+      ConfigManager.addContext({
+        name: "a",
+        apiUrl: "https://a.com",
+        apiKey: "k1",
+      });
+      ConfigManager.addContext({
+        name: "b",
+        apiUrl: "https://b.com",
+        apiKey: "k2",
+      });
+      ConfigManager.setCurrentContext("a");
+      ConfigManager.removeContext("a");
+
+      const current = ConfigManager.getCurrentContext();
+      expect(current).not.toBeNull();
+      expect(current!.name).toBe("b");
+    });
+  });
+
+  describe("getResolvedCredentials", () => {
+    it("should resolve from CLI options first", () => {
+      const creds: ResolvedCredentials = ConfigManager.getResolvedCredentials({
+        apiKey: "cli-key",
+        url: "https://cli.com",
+      });
+      expect(creds.apiKey).toBe("cli-key");
+      expect(creds.apiUrl).toBe("https://cli.com");
+    });
+
+    it("should resolve from env vars", () => {
+      process.env["ONEUPTIME_API_KEY"] = "env-key";
+      process.env["ONEUPTIME_URL"] = "https://env.com";
+
+      const creds: ResolvedCredentials = ConfigManager.getResolvedCredentials(
+        {},
+      );
+      expect(creds.apiKey).toBe("env-key");
+      expect(creds.apiUrl).toBe("https://env.com");
+
+      delete process.env["ONEUPTIME_API_KEY"];
+      delete process.env["ONEUPTIME_URL"];
+    });
+
+    it("should resolve from current context", () => {
+      ConfigManager.addContext({
+        name: "ctx",
+        apiUrl: "https://ctx.com",
+        apiKey: "ctx-key",
+      });
+
+      const creds: ResolvedCredentials = ConfigManager.getResolvedCredentials(
+        {},
+      );
+      expect(creds.apiKey).toBe("ctx-key");
+      expect(creds.apiUrl).toBe("https://ctx.com");
+    });
+
+    it("should throw when no credentials available", () => {
+      expect(() => ConfigManager.getResolvedCredentials({})).toThrow(
+        "No credentials found",
+      );
+    });
+  });
+});
--- a/CLI/Tests/OutputFormatter.test.ts
+++ b/CLI/Tests/OutputFormatter.test.ts
@@ -0,0 +1,91 @@
+import { formatOutput } from "../Core/OutputFormatter";
+
+describe("OutputFormatter", () => {
+  describe("formatOutput with JSON format", () => {
+    it("should format single object as JSON", () => {
+      const data = { id: "123", name: "Test" };
+      const result = formatOutput(data, "json");
+      expect(JSON.parse(result)).toEqual(data);
+    });
+
+    it("should format array as JSON", () => {
+      const data = [
+        { id: "1", name: "A" },
+        { id: "2", name: "B" },
+      ];
+      const result = formatOutput(data, "json");
+      expect(JSON.parse(result)).toEqual(data);
+    });
+
+    it("should format null as JSON", () => {
+      const result = formatOutput(null, "json");
+      expect(result).toBe("null");
+    });
+  });
+
+  describe("formatOutput with table format", () => {
+    it("should format array as table", () => {
+      const data = [
+        { _id: "1", name: "A" },
+        { _id: "2", name: "B" },
+      ];
+      const result = formatOutput(data, "table");
+      expect(result).toContain("1");
+      expect(result).toContain("A");
+      expect(result).toContain("2");
+      expect(result).toContain("B");
+    });
+
+    it("should handle empty array", () => {
+      const result = formatOutput([], "table");
+      expect(result).toBe("No results found.");
+    });
+
+    it("should handle single object as key-value table", () => {
+      const data = { name: "Test", status: "Active" };
+      const result = formatOutput(data, "table");
+      expect(result).toContain("Test");
+      expect(result).toContain("Active");
+    });
+  });
+
+  describe("formatOutput with wide format", () => {
+    it("should show all columns in wide mode", () => {
+      const data = [
+        {
+          _id: "1",
+          name: "A",
+          col1: "x",
+          col2: "y",
+          col3: "z",
+          col4: "w",
+          col5: "v",
+          col6: "u",
+          col7: "t",
+        },
+      ];
+      const result = formatOutput(data, "wide");
+      // Wide mode should include all columns
+      expect(result).toContain("col7");
+    });
+
+    it("should limit columns in non-wide table mode", () => {
+      const data = [
+        {
+          _id: "1",
+          name: "A",
+          col1: "x",
+          col2: "y",
+          col3: "z",
+          col4: "w",
+          col5: "v",
+          col6: "u",
+          col7: "t",
+        },
+      ];
+      const result = formatOutput(data, "table");
+      // Table mode should limit to 6 columns
+      expect(result).not.toContain("col7");
+    });
+  });
+});
--- a/CLI/Tests/ResourceCommands.test.ts
+++ b/CLI/Tests/ResourceCommands.test.ts
@@ -0,0 +1,53 @@
+import { discoverResources } from "../Commands/ResourceCommands";
+import { ResourceInfo } from "../Types/CLITypes";
+
+describe("ResourceCommands", () => {
+  describe("discoverResources", () => {
+    let resources: ResourceInfo[];
+
+    beforeAll(() => {
+      resources = discoverResources();
+    });
+
+    it("should discover at least one resource", () => {
+      expect(resources.length).toBeGreaterThan(0);
+    });
+
+    it("should discover the Incident resource", () => {
+      const incident = resources.find((r) => r.singularName === "Incident");
+      expect(incident).toBeDefined();
+      expect(incident!.modelType).toBe("database");
+      expect(incident!.apiPath).toBe("/incident");
+    });
+
+    it("should discover the Monitor resource", () => {
+      const monitor = resources.find((r) => r.singularName === "Monitor");
+      expect(monitor).toBeDefined();
+      expect(monitor!.modelType).toBe("database");
+    });
+
+    it("should discover the Alert resource", () => {
+      const alert = resources.find((r) => r.singularName === "Alert");
+      expect(alert).toBeDefined();
+    });
+
+    it("should have kebab-case names for all resources", () => {
+      for (const r of resources) {
+        expect(r.name).toMatch(/^[a-z][a-z0-9-]*$/);
+      }
+    });
+
+    it("should have apiPath for all resources", () => {
+      for (const r of resources) {
+        expect(r.apiPath).toBeTruthy();
+        expect(r.apiPath.startsWith("/")).toBe(true);
+      }
+    });
+
+    it("should have valid modelType for all resources", () => {
+      for (const r of resources) {
+        expect(["database", "analytics"]).toContain(r.modelType);
+      }
+    });
+  });
+});
--- a/CLI/Types/CLITypes.ts
+++ b/CLI/Types/CLITypes.ts
@@ -0,0 +1,34 @@
+export interface CLIContext {
+  name: string;
+  apiUrl: string;
+  apiKey: string;
+}
+
+export interface CLIConfig {
+  currentContext: string;
+  contexts: Record<string, CLIContext>;
+  defaults: {
+    output: string;
+    limit: number;
+  };
+}
+
+export enum OutputFormat {
+  JSON = "json",
+  Table = "table",
+  Wide = "wide",
+}
+
+export interface ResourceInfo {
+  name: string;
+  singularName: string;
+  pluralName: string;
+  apiPath: string;
+  tableName: string;
+  modelType: "database" | "analytics";
+}
+
+export interface ResolvedCredentials {
+  apiUrl: string;
+  apiKey: string;
+}
--- a/CLI/Utils/SelectFieldGenerator.ts
+++ b/CLI/Utils/SelectFieldGenerator.ts
@@ -0,0 +1,121 @@
+import DatabaseModels from "Common/Models/DatabaseModels/Index";
+import AnalyticsModels from "Common/Models/AnalyticsModels/Index";
+import BaseModel from "Common/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import AnalyticsBaseModel from "Common/Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
+import { getTableColumns } from "Common/Types/Database/TableColumn";
+import Permission from "Common/Types/Permission";
+import { JSONObject } from "Common/Types/JSON";
+
+interface ColumnAccessControl {
+  read?: Permission[];
+}
+
+function shouldIncludeField(
+  columnName: string,
+  accessControlForColumns: Record<string, ColumnAccessControl>,
+): boolean {
+  const accessControl: ColumnAccessControl | undefined =
+    accessControlForColumns[columnName];
+
+  return (
+    !accessControl ||
+    (accessControl.read !== undefined &&
+      accessControl.read.length > 0 &&
+      !(
+        accessControl.read.length === 1 &&
+        accessControl.read[0] === Permission.CurrentUser
+      ))
+  );
+}
+
+export function generateAllFieldsSelect(
+  tableName: string,
+  modelType: "database" | "analytics",
+): JSONObject {
+  try {
+    if (modelType === "database") {
+      const ModelClass:
+        | (new () => BaseModel)
+        | undefined = DatabaseModels.find(
+        (Model: new () => BaseModel): boolean => {
+          try {
+            const instance: BaseModel = new Model();
+            return instance.tableName === tableName;
+          } catch {
+            return false;
+          }
+        },
+      );
+
+      if (!ModelClass) {
+        return getDefaultSelect();
+      }
+
+      const modelInstance: BaseModel = new ModelClass();
+      const tableColumns: Record<string, unknown> =
+        getTableColumns(modelInstance);
+      const columnNames: string[] = Object.keys(tableColumns);
+
+      if (columnNames.length === 0) {
+        return getDefaultSelect();
+      }
+
+      const accessControlForColumns: Record<string, ColumnAccessControl> =
+        (
+          modelInstance as unknown as {
+            getColumnAccessControlForAllColumns?: () => Record<
+              string,
+              ColumnAccessControl
+            >;
+          }
+        ).getColumnAccessControlForAllColumns?.() || {};
+
+      const selectObject: JSONObject = {};
+      for (const columnName of columnNames) {
+        if (shouldIncludeField(columnName, accessControlForColumns)) {
+          selectObject[columnName] = true;
+        }
+      }
+
+      if (Object.keys(selectObject).length === 0) {
+        return getDefaultSelect();
+      }
+
+      return selectObject;
+    }
+
+    if (modelType === "analytics") {
+      const ModelClass:
+        | (new () => AnalyticsBaseModel)
+        | undefined = AnalyticsModels.find(
+        (Model: new () => AnalyticsBaseModel): boolean => {
+          try {
+            const instance: AnalyticsBaseModel = new Model();
+            return instance.tableName === tableName;
+          } catch {
+            return false;
+          }
+        },
+      );
+
+      if (!ModelClass) {
+        return getDefaultSelect();
+      }
+
+      // For analytics models, just return a basic select
+      return getDefaultSelect();
+    }
+
+    return getDefaultSelect();
+  } catch {
+    return getDefaultSelect();
+  }
+}
+
+function getDefaultSelect(): JSONObject {
+  return {
+    _id: true,
+    createdAt: true,
+    updatedAt: true,
+  };
+}
--- a/CLI/jest.config.json
+++ b/CLI/jest.config.json
@@ -0,0 +1,31 @@
+{
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testMatch": ["**/__tests__/**/*.ts", "**/?(*.)+(spec|test).ts"],
+    "collectCoverageFrom": [
+        "**/*.ts",
+        "!**/*.d.ts",
+        "!**/node_modules/**",
+        "!**/build/**"
+    ],
+    "setupFilesAfterEnv": [],
+    "testTimeout": 30000,
+    "modulePathIgnorePatterns": ["<rootDir>/build/"],
+    "moduleNameMapper": {
+        "^Common/(.*)$": "<rootDir>/../Common/$1"
+    },
+    "transformIgnorePatterns": [
+        "node_modules/(?!(@oneuptime)/)"
+    ],
+    "transform": {
+        "^.+\\.ts$": ["ts-jest", {
+            "tsconfig": {
+                "noUnusedLocals": false,
+                "noUnusedParameters": false,
+                "strict": false,
+                "noPropertyAccessFromIndexSignature": false,
+                "module": "commonjs"
+            }
+        }]
+    }
+}
--- a/CLI/package-lock.json
+++ b/CLI/package-lock.json
--- a/CLI/package.json
+++ b/CLI/package.json
@@ -0,0 +1,42 @@
+{
+    "name": "@oneuptime/cli",
+    "version": "1.0.0",
+    "description": "OneUptime CLI - Command-line interface for managing OneUptime resources",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/OneUptime/oneuptime"
+    },
+    "main": "Index.ts",
+    "bin": {
+        "oneuptime": "./Index.ts"
+    },
+    "scripts": {
+        "start": "node --require ts-node/register Index.ts",
+        "build": "npm run compile",
+        "compile": "tsc",
+        "clear-modules": "rm -rf node_modules && rm package-lock.json && npm install",
+        "dev": "npx nodemon",
+        "audit": "npm audit --audit-level=low",
+        "dep-check": "npm install -g depcheck && depcheck ./ --skip-missing=true",
+        "test": "jest --passWithNoTests",
+        "link": "npm link"
+    },
+    "author": "OneUptime <hello@oneuptime.com> (https://oneuptime.com/)",
+    "license": "Apache-2.0",
+    "dependencies": {
+        "Common": "file:../Common",
+        "commander": "^12.1.0",
+        "chalk": "^4.1.2",
+        "cli-table3": "^0.6.5",
+        "ora": "^5.4.1",
+        "ts-node": "^10.9.2"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.5.14",
+        "@types/node": "^22.15.21",
+        "jest": "^29.7.0",
+        "nodemon": "^3.1.11",
+        "ts-jest": "^29.4.6",
+        "typescript": "^5.9.3"
+    }
+}
--- a/CLI/tsconfig.json
+++ b/CLI/tsconfig.json
@@ -0,0 +1,43 @@
+{
+    "ts-node": {
+        "compilerOptions": {
+            "module": "commonjs",
+            "resolveJsonModule": true
+        }
+    },
+    "compilerOptions": {
+        "target": "es2017",
+        "module": "commonjs",
+        "jsx": "react",
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        "moduleResolution": "node",
+        "typeRoots": [
+            "./node_modules/@types"
+        ],
+        "types": ["node", "jest"],
+        "sourceMap": true,
+        "outDir": "./build/dist",
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "strictBindCallApply": true,
+        "strictPropertyInitialization": true,
+        "noImplicitThis": true,
+        "useUnknownInCatchVariables": true,
+        "alwaysStrict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "exactOptionalPropertyTypes": true,
+        "noImplicitReturns": true,
+        "noFallthroughCasesInSwitch": true,
+        "noUncheckedIndexedAccess": true,
+        "noImplicitOverride": true,
+        "noPropertyAccessFromIndexSignature": true,
+        "skipLibCheck": true,
+        "resolveJsonModule": true
+    }
+}