@nebulaos/cli 0.1.0

package/dist/bin/nebulaos.js

@@ -0,0 +1,2629 @@
+#!/usr/bin/env node
+
+// src/bin/nebulaos.ts
+import { CommanderError } from "commander";
+
+// src/program.ts
+import { Command as Command67 } from "commander";
+
+// src/lib/flags.ts
+import { Option } from "commander";
+function addGlobalFlags(program) {
+  program.addOption(
+    new Option("-o, --output <format>", "Output format").choices(["table", "json", "yaml", "quiet"]).env("NEBULAOS_OUTPUT")
+  ).addOption(
+    new Option("--context <name>", "Use a specific context").env("NEBULAOS_CONTEXT")
+  ).addOption(
+    new Option("--api-url <url>", "Override API URL").env("NEBULAOS_API_URL")
+  ).addOption(
+    new Option("--token <token>", "Override authentication token").env("NEBULAOS_TOKEN")
+  ).addOption(
+    new Option("--org-id <id>", "Override organization ID").env("NEBULAOS_ORG_ID")
+  ).addOption(
+    new Option("--no-color", "Disable colored output")
+  ).addOption(
+    new Option("--verbose", "Enable verbose output")
+  );
+  return program;
+}
+function addPaginationFlags(command) {
+  command.addOption(
+    new Option("--page <number>", "Page number").argParser(parseInt)
+  ).addOption(
+    new Option("--page-size <number>", "Items per page").argParser(parseInt)
+  );
+  return command;
+}
+
+// src/lib/errors.ts
+var CLIError = class extends Error {
+  constructor(message, exitCode = 1 /* GeneralError */, hint) {
+    super(message);
+    this.exitCode = exitCode;
+    this.hint = hint;
+    this.name = "CLIError";
+  }
+};
+var AuthenticationError = class extends CLIError {
+  constructor(message = "Authentication required. Run `nebulaos auth login` first.") {
+    super(message, 3 /* AuthenticationError */);
+  }
+};
+var AuthorizationError = class extends CLIError {
+  constructor(message = "Insufficient permissions for this operation.") {
+    super(message, 4 /* AuthorizationError */);
+  }
+};
+var NotFoundError = class extends CLIError {
+  constructor(resource, identifier) {
+    super(`${resource} '${identifier}' not found.`, 5 /* NotFound */);
+  }
+};
+var NetworkError = class extends CLIError {
+  constructor(message = "Unable to connect to NebulaOS API. Check your network and API URL.") {
+    super(message, 8 /* NetworkError */);
+  }
+};
+var ConfigError = class extends CLIError {
+  constructor(message) {
+    super(message, 11 /* ConfigError */);
+  }
+};
+function handleError(error) {
+  if (error instanceof CLIError) {
+    console.error(`Error: ${error.message}`);
+    if (error.hint) {
+      console.error(`Hint: ${error.hint}`);
+    }
+    process.exit(error.exitCode);
+  }
+  if (error instanceof Error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1 /* GeneralError */);
+  }
+  console.error("An unexpected error occurred.");
+  process.exit(1 /* GeneralError */);
+}
+
+// src/commands/auth/index.ts
+import { Command as Command4 } from "commander";
+
+// src/commands/auth/login.ts
+import { Command } from "commander";
+import axios from "axios";
+import chalk from "chalk";
+import { password, input } from "@inquirer/prompts";
+
+// src/lib/config.ts
+import Conf from "conf";
+var schema = {
+  contexts: {
+    type: "object",
+    default: {}
+  },
+  currentContext: {
+    type: ["string", "null"],
+    default: null
+  },
+  defaults: {
+    type: "object",
+    default: {
+      output: "table",
+      pageSize: 20
+    },
+    properties: {
+      output: {
+        type: "string",
+        enum: ["table", "json", "yaml", "quiet"],
+        default: "table"
+      },
+      pageSize: {
+        type: "number",
+        default: 20,
+        minimum: 1,
+        maximum: 100
+      }
+    }
+  }
+};
+var config = new Conf({
+  projectName: "nebulaos",
+  schema
+});
+function getConfig() {
+  return {
+    contexts: config.get("contexts"),
+    currentContext: config.get("currentContext"),
+    defaults: config.get("defaults")
+  };
+}
+function getCurrentContext() {
+  const currentName = config.get("currentContext");
+  if (!currentName) {
+    throw new ConfigError(
+      "No active context. Run `nebulaos auth login` or `nebulaos config use-context <name>` first."
+    );
+  }
+  const contexts = config.get("contexts");
+  const ctx = contexts[currentName];
+  if (!ctx) {
+    throw new ConfigError(
+      `Context '${currentName}' not found. Run \`nebulaos config get-contexts\` to see available contexts.`
+    );
+  }
+  return ctx;
+}
+function setContext(name, context) {
+  const contexts = config.get("contexts");
+  contexts[name] = context;
+  config.set("contexts", contexts);
+}
+function removeContext(name) {
+  const contexts = config.get("contexts");
+  if (!contexts[name]) {
+    throw new ConfigError(`Context '${name}' not found.`);
+  }
+  delete contexts[name];
+  config.set("contexts", contexts);
+  if (config.get("currentContext") === name) {
+    config.set("currentContext", null);
+  }
+}
+function useContext(name) {
+  const contexts = config.get("contexts");
+  if (!contexts[name]) {
+    throw new ConfigError(
+      `Context '${name}' not found. Run \`nebulaos config get-contexts\` to see available contexts.`
+    );
+  }
+  config.set("currentContext", name);
+}
+function setDefault(key, value) {
+  const defaults = config.get("defaults");
+  defaults[key] = value;
+  config.set("defaults", defaults);
+}
+function getConfigPath() {
+  return config.path;
+}
+
+// src/commands/auth/login.ts
+async function verifyToken(apiUrl, token) {
+  try {
+    const response = await axios.post(
+      `${apiUrl}/auth/personal-tokens/verify`,
+      { token },
+      { timeout: 1e4 }
+    );
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      if (!error.response) {
+        throw new CLIError(
+          `Unable to connect to ${apiUrl}. Check the URL and your network.`,
+          8 /* NetworkError */
+        );
+      }
+      throw new CLIError(
+        `API returned ${error.response.status}: ${error.response.data?.message || "Unknown error"}`,
+        10 /* ServerError */
+      );
+    }
+    throw error;
+  }
+}
+function createLoginCommand() {
+  const cmd = new Command("login").description("Authenticate with NebulaOS using a Personal Access Token").option("-t, --token <token>", "Personal Access Token (PAT)").option("-u, --api-url <url>", "API URL (default: http://localhost:4100)").option("-n, --context-name <name>", "Name for this context").addHelpText("after", `
+Examples:
+  $ nebulaos auth login                                  Interactive login (prompts for token)
+  $ nebulaos auth login -t neb_pat_abc123                Login with a token directly
+  $ nebulaos auth login -u https://api.starya.com        Login to a custom API URL
+  $ nebulaos auth login -t neb_pat_abc123 -n production  Login and name the context "production"
+
+Note: Personal Access Tokens are tied to a specific workspace.
+      Create tokens in the NebulaOS dashboard for the workspace you want to access.
+`).action(async (options) => {
+    try {
+      console.log(chalk.bold("NebulaOS Login\n"));
+      let apiUrl = options.apiUrl || options.parent?.opts()?.apiUrl;
+      if (!apiUrl) {
+        apiUrl = await input({
+          message: "NebulaOS API URL:",
+          default: "http://localhost:4100",
+          validate: (value) => {
+            if (!value) return "API URL is required";
+            try {
+              new URL(value);
+              return true;
+            } catch {
+              return "Invalid URL format. Example: https://api.starya.com";
+            }
+          }
+        });
+      }
+      let token = options.token;
+      if (!token) {
+        console.log("\nGenerate a Personal Access Token at your NebulaOS dashboard.\n");
+        token = await password({
+          message: "Personal Access Token (PAT):",
+          mask: "*",
+          validate: (value) => {
+            if (!value) return "Token is required";
+            if (!value.startsWith("neb_pat_")) return "Invalid token format. Tokens start with 'neb_pat_'";
+            return true;
+          }
+        });
+      }
+      if (!token.startsWith("neb_pat_")) {
+        throw new CLIError(
+          "Invalid token format. Personal Access Tokens start with 'neb_pat_'.",
+          7 /* ValidationError */
+        );
+      }
+      console.log("\nVerifying token...");
+      const result = await verifyToken(apiUrl, token);
+      if (!result.valid) {
+        throw new CLIError(
+          `Token verification failed: ${result.error || "Unknown error"}`,
+          3 /* AuthenticationError */
+        );
+      }
+      const contextName = options.contextName || result.organization?.slug || "default";
+      setContext(contextName, {
+        name: contextName,
+        apiUrl,
+        token,
+        organizationId: result.organization?.id
+      });
+      useContext(contextName);
+      console.log(chalk.green("\nAuthenticated successfully!"));
+      console.log(`  Admin:        ${result.admin?.fullName} (${result.admin?.email})`);
+      console.log(`  Organization: ${result.organization?.name} (${result.organization?.slug})`);
+      if (result.workspaceId) {
+        console.log(`  Workspace:    ${result.workspaceId}`);
+      }
+      console.log(`  Context:      ${contextName}`);
+      if (result.scopes && result.scopes.length > 0) {
+        console.log(`  Scopes:       ${result.scopes.join(", ")}`);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/auth/logout.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import { confirm } from "@inquirer/prompts";
+function createLogoutCommand() {
+  const cmd = new Command2("logout").description("Remove authentication credentials for the current or specified context").option("-y, --yes", "Skip confirmation prompt").option("--context <name>", "Context to log out from (default: current)").addHelpText("after", `
+Examples:
+  $ nebulaos auth logout                   Log out from the current context
+  $ nebulaos auth logout -y                Log out without confirmation
+  $ nebulaos auth logout --context staging Log out from a specific context
+`).action(async (options) => {
+    try {
+      const config2 = getConfig();
+      const contextName = options.context || config2.currentContext;
+      if (!contextName) {
+        throw new CLIError("No active context. Nothing to log out from.", 11 /* ConfigError */);
+      }
+      if (!config2.contexts[contextName]) {
+        throw new CLIError(`Context '${contextName}' not found.`, 5 /* NotFound */);
+      }
+      if (!options.yes) {
+        const shouldProceed = await confirm({
+          message: `Remove credentials for context '${contextName}'?`,
+          default: false
+        });
+        if (!shouldProceed) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      removeContext(contextName);
+      console.log(chalk2.green(`Logged out from context '${contextName}'.`));
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/auth/status.ts
+import { Command as Command3 } from "commander";
+import chalk4 from "chalk";
+
+// src/lib/output.ts
+import Table from "cli-table3";
+import chalk3 from "chalk";
+import { stringify as yamlStringify } from "yaml";
+function resolveFormat(flagValue) {
+  if (flagValue) return flagValue;
+  return getConfig().defaults.output;
+}
+function printTable({ headers, rows }) {
+  const table = new Table({
+    head: headers.map((h) => chalk3.bold(h)),
+    style: { head: [], border: [] }
+  });
+  for (const row of rows) {
+    table.push(row);
+  }
+  console.log(table.toString());
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printYaml(data) {
+  console.log(yamlStringify(data));
+}
+function printQuiet(ids) {
+  for (const id of ids) {
+    console.log(id);
+  }
+}
+function output(format, outputData) {
+  switch (format) {
+    case "table":
+      printTable(outputData.table);
+      break;
+    case "json":
+      printJson(outputData.data);
+      break;
+    case "yaml":
+      printYaml(outputData.data);
+      break;
+    case "quiet":
+      printQuiet(outputData.ids);
+      break;
+  }
+}
+function printSuccess(message) {
+  console.log(chalk3.green(message));
+}
+function printDetail(label, value) {
+  console.log(`${chalk3.bold(label)}: ${value}`);
+}
+
+// src/commands/auth/status.ts
+function createStatusCommand() {
+  const cmd = new Command3("status").description("Show current authentication status and context information").addHelpText("after", `
+Examples:
+  $ nebulaos auth status              Show current auth status
+  $ nebulaos auth status -o json      Show auth status as JSON
+`).action(async (_options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const config2 = getConfig();
+      if (!config2.currentContext) {
+        if (format === "json") {
+          console.log(JSON.stringify({ authenticated: false }));
+        } else if (format === "yaml") {
+          console.log("authenticated: false");
+        } else {
+          console.log(chalk4.yellow("Not authenticated. Run `nebulaos auth login` to get started."));
+        }
+        return;
+      }
+      let context;
+      try {
+        context = getCurrentContext();
+      } catch (e) {
+        if (e instanceof ConfigError) {
+          console.log(chalk4.yellow(e.message));
+          return;
+        }
+        throw e;
+      }
+      const statusData = {
+        authenticated: true,
+        context: config2.currentContext,
+        apiUrl: context.apiUrl,
+        organizationId: context.organizationId || null,
+        hasToken: !!context.token
+      };
+      if (format === "table") {
+        console.log(chalk4.bold("Authentication Status\n"));
+        printDetail("Context", config2.currentContext);
+        printDetail("API URL", context.apiUrl);
+        printDetail("Authenticated", context.token ? chalk4.green("Yes") : chalk4.red("No"));
+        if (context.organizationId) {
+          printDetail("Organization ID", context.organizationId);
+        }
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: statusData,
+          ids: [config2.currentContext]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/auth/index.ts
+function createAuthCommand() {
+  const auth = new Command4("auth").description("Authenticate with NebulaOS and manage credentials");
+  auth.addCommand(createLoginCommand());
+  auth.addCommand(createLogoutCommand());
+  auth.addCommand(createStatusCommand());
+  return auth;
+}
+
+// src/commands/orgs/index.ts
+import { Command as Command8 } from "commander";
+
+// src/commands/orgs/list.ts
+import { Command as Command5 } from "commander";
+
+// src/lib/api.ts
+import axios2 from "axios";
+var client = null;
+function getApiClient() {
+  if (client) return client;
+  const context = getCurrentContext();
+  client = axios2.create({
+    baseURL: context.apiUrl,
+    timeout: 3e4,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  client.interceptors.request.use((config2) => {
+    const ctx = getCurrentContext();
+    if (ctx.token) {
+      config2.headers.Authorization = `Bearer ${ctx.token}`;
+    }
+    if (ctx.organizationId) {
+      config2.headers["X-Organization-Id"] = ctx.organizationId;
+    }
+    return config2;
+  });
+  client.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      if (!error.response) {
+        if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+          throw new NetworkError();
+        }
+        if (error.code === "ECONNABORTED" || error.code === "ETIMEDOUT") {
+          throw new CLIError(
+            "Request timed out. The server may be unavailable.",
+            9 /* TimeoutError */
+          );
+        }
+        throw new NetworkError(error.message);
+      }
+      const { status, data } = error.response;
+      const message = data?.message || error.message;
+      switch (status) {
+        case 401:
+          throw new AuthenticationError();
+        case 403:
+          throw new AuthorizationError();
+        case 404:
+          throw new NotFoundError("Resource", message);
+        case 409:
+          throw new CLIError(message, 6 /* ConflictError */);
+        case 422:
+          throw new CLIError(message, 7 /* ValidationError */);
+        default:
+          if (status >= 500) {
+            throw new CLIError(
+              `Server error (${status}): ${message}`,
+              10 /* ServerError */
+            );
+          }
+          throw new CLIError(message, 1 /* GeneralError */);
+      }
+    }
+  );
+  return client;
+}
+
+// src/commands/orgs/list.ts
+function createOrgsListCommand() {
+  const cmd = new Command5("list").description("List organizations accessible to the current admin").addHelpText("after", `
+Examples:
+  $ nebulaos orgs list                List all accessible organizations
+  $ nebulaos orgs list -o json        Output as JSON
+  $ nebulaos orgs list --page 2       Show page 2 of results
+`).action(async (_options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const params = {};
+      if (globalOpts.page) params.page = globalOpts.page;
+      if (globalOpts.pageSize) params.pageSize = globalOpts.pageSize;
+      const { data } = await api.get("/organizations", { params });
+      const orgs = Array.isArray(data) ? data : [];
+      output(format, {
+        table: {
+          headers: ["ID", "Name", "Slug", "Active", "Created At"],
+          rows: orgs.map((o) => [
+            o.id,
+            o.name,
+            o.slug,
+            o.isActive ? "Yes" : "No",
+            new Date(o.createdAt).toLocaleDateString()
+          ])
+        },
+        data: orgs,
+        ids: orgs.map((o) => o.id)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  addPaginationFlags(cmd);
+  return cmd;
+}
+
+// src/commands/orgs/get.ts
+import { Command as Command6 } from "commander";
+import chalk5 from "chalk";
+function createOrgsGetCommand() {
+  const cmd = new Command6("get").description("Get details of an organization by ID or slug").argument("<id>", "Organization ID or slug").addHelpText("after", `
+Examples:
+  $ nebulaos orgs get my-org                  Get organization by slug
+  $ nebulaos orgs get 550e8400-e29b-41d4...   Get organization by ID
+  $ nebulaos orgs get my-org -o json          Output as JSON
+`).action(async (id, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data: org } = await api.get(`/organizations/${id}`);
+      if (format === "table") {
+        console.log(chalk5.bold("Organization Details\n"));
+        printDetail("ID", org.id);
+        printDetail("Name", org.name);
+        printDetail("Slug", org.slug);
+        printDetail("Active", org.isActive ? chalk5.green("Yes") : chalk5.red("No"));
+        printDetail("Created", new Date(org.createdAt).toLocaleString());
+        printDetail("Updated", new Date(org.updatedAt).toLocaleString());
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: org,
+          ids: [org.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/orgs/switch.ts
+import { Command as Command7 } from "commander";
+import chalk6 from "chalk";
+function createOrgsSwitchCommand() {
+  const cmd = new Command7("switch").description("Switch the active organization context to a different organization").argument("<slug>", "Organization slug to switch to").addHelpText("after", `
+Examples:
+  $ nebulaos orgs switch my-org       Switch to the "my-org" organization
+  $ nebulaos orgs switch production   Switch to the "production" organization
+`).action(async (slug) => {
+    try {
+      const api = getApiClient();
+      const currentContext = getCurrentContext();
+      const { data: org } = await api.get(`/organizations/${slug}`);
+      const contextName = org.slug;
+      setContext(contextName, {
+        name: contextName,
+        apiUrl: currentContext.apiUrl,
+        token: currentContext.token,
+        organizationId: org.id
+      });
+      useContext(contextName);
+      console.log(chalk6.green(`Switched to organization '${org.name}' (${org.slug}).`));
+      console.log(`  Context:        ${contextName}`);
+      console.log(`  Organization ID: ${org.id}`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/orgs/index.ts
+function createOrgsCommand() {
+  const orgs = new Command8("orgs").description("List, inspect, and switch between organizations");
+  orgs.addCommand(createOrgsListCommand());
+  orgs.addCommand(createOrgsGetCommand());
+  orgs.addCommand(createOrgsSwitchCommand());
+  return orgs;
+}
+
+// src/commands/clients/index.ts
+import { Command as Command16 } from "commander";
+
+// src/commands/clients/list.ts
+import { Command as Command9 } from "commander";
+function createClientsListCommand() {
+  const cmd = new Command9("list").description("List registered clients in the current organization").addHelpText("after", `
+Examples:
+  $ nebulaos clients list                List all clients
+  $ nebulaos clients list -o json        Output as JSON
+  $ nebulaos clients list --page-size 5  Show 5 clients per page
+`).action(async (_options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const params = {};
+      if (globalOpts.page) params.page = globalOpts.page;
+      if (globalOpts.pageSize) params.pageSize = globalOpts.pageSize;
+      const { data } = await api.get("/clients", { params });
+      const clients = Array.isArray(data) ? data : [];
+      output(format, {
+        table: {
+          headers: ["ID", "Client ID", "Status", "Last Seen", "Registered At"],
+          rows: clients.map((c) => [
+            c.id,
+            c.clientId,
+            c.isOnline ? "Online" : "Offline",
+            c.lastSeenAt ? new Date(c.lastSeenAt).toLocaleString() : "-",
+            c.registeredAt ? new Date(c.registeredAt).toLocaleDateString() : "-"
+          ])
+        },
+        data: clients,
+        ids: clients.map((c) => c.id)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  addPaginationFlags(cmd);
+  return cmd;
+}
+
+// src/commands/clients/get.ts
+import { Command as Command10 } from "commander";
+import chalk7 from "chalk";
+function createClientsGetCommand() {
+  const cmd = new Command10("get").description("Get details of a client, including its registered agents and workflows").argument("<id>", "Client ID").addHelpText("after", `
+Examples:
+  $ nebulaos clients get 550e8400-e29b-41d4...   Get client details by ID
+  $ nebulaos clients get my-client -o json        Output as JSON
+`).action(async (id, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data: client2 } = await api.get(`/clients/${id}`);
+      if (format === "table") {
+        console.log(chalk7.bold("Client Details\n"));
+        printDetail("ID", client2.id);
+        printDetail("Client ID", client2.clientId);
+        printDetail("Status", client2.isOnline ? "Online" : "Offline");
+        printDetail("Last Seen", client2.lastSeenAt ? new Date(client2.lastSeenAt).toLocaleString() : "-");
+        printDetail("Registered", client2.registeredAt ? new Date(client2.registeredAt).toLocaleString() : "-");
+        printDetail("Updated", client2.updatedAt ? new Date(client2.updatedAt).toLocaleString() : "-");
+        if (client2.agents && client2.agents.length > 0) {
+          console.log(chalk7.bold("\nAgents:"));
+          for (const agent of client2.agents) {
+            console.log(`  - ${agent.name} (${agent.kind})`);
+          }
+        }
+        if (client2.workflows && client2.workflows.length > 0) {
+          console.log(chalk7.bold("\nWorkflows:"));
+          for (const wf of client2.workflows) {
+            console.log(`  - ${wf.name} (${wf.id})`);
+          }
+        }
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: client2,
+          ids: [client2.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/clients/create.ts
+import { Command as Command11 } from "commander";
+import chalk8 from "chalk";
+function createClientsCreateCommand() {
+  const cmd = new Command11("create").description("Register a new client in the current organization").requiredOption("--client-id <clientId>", "Unique client identifier").addHelpText("after", `
+Examples:
+  $ nebulaos clients create --client-id my-agent-server   Create a new client
+  $ nebulaos clients create --client-id worker-1 -o json  Create and output as JSON
+`).action(async (options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data: client2 } = await api.post("/clients", {
+        clientId: options.clientId
+      });
+      if (format === "table") {
+        console.log(chalk8.green("Client created successfully.\n"));
+        printDetail("ID", client2.id);
+        printDetail("Client ID", client2.clientId);
+        printDetail("Status", client2.isOnline ? "Online" : "Offline");
+        printDetail("Registered", client2.registeredAt ? new Date(client2.registeredAt).toLocaleString() : "-");
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: client2,
+          ids: [client2.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/clients/api-keys/index.ts
+import { Command as Command15 } from "commander";
+
+// src/commands/clients/api-keys/list.ts
+import { Command as Command12 } from "commander";
+function createApiKeysListCommand() {
+  const cmd = new Command12("list").description("List all API keys for a specific client").argument("<clientId>", "Client ID").addHelpText("after", `
+Examples:
+  $ nebulaos clients api-keys list 550e8400-e29b...   List keys for a client
+  $ nebulaos clients api-keys list my-client -o json  Output as JSON
+`).action(async (clientId, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data } = await api.get(`/clients/${clientId}/api-keys`);
+      const keys = Array.isArray(data) ? data : [];
+      output(format, {
+        table: {
+          headers: ["ID", "Key", "Active", "Expires At", "Last Used", "Created At"],
+          rows: keys.map((k) => [
+            k.id,
+            k.key,
+            k.isActive ? "Yes" : "No",
+            k.expiresAt ? new Date(k.expiresAt).toLocaleString() : "-",
+            k.lastUsedAt ? new Date(k.lastUsedAt).toLocaleString() : "-",
+            new Date(k.createdAt).toLocaleDateString()
+          ])
+        },
+        data: keys,
+        ids: keys.map((k) => k.id)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/clients/api-keys/create.ts
+import { Command as Command13 } from "commander";
+import chalk9 from "chalk";
+function createApiKeysCreateCommand() {
+  const cmd = new Command13("create").description("Generate a new API key for a client (shown only once)").argument("<clientId>", "Client ID").addHelpText("after", `
+Examples:
+  $ nebulaos clients api-keys create 550e8400-e29b...   Create a new API key
+  $ nebulaos clients api-keys create my-client -o json  Output as JSON
+
+Note: The API key is displayed only once after creation. Save it securely.
+`).action(async (clientId, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data: apiKey } = await api.post(`/clients/${clientId}/api-keys`);
+      if (format === "table") {
+        console.log(chalk9.green("API key created successfully.\n"));
+        printDetail("ID", apiKey.id);
+        printDetail("Key", apiKey.key);
+        printDetail("Active", apiKey.isActive ? "Yes" : "No");
+        printDetail("Expires At", apiKey.expiresAt ? new Date(apiKey.expiresAt).toLocaleString() : "-");
+        printDetail("Created", new Date(apiKey.createdAt).toLocaleString());
+        console.log(chalk9.yellow("\nSave this key now. It will not be shown again."));
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: apiKey,
+          ids: [apiKey.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/clients/api-keys/revoke.ts
+import { Command as Command14 } from "commander";
+import { confirm as confirm2 } from "@inquirer/prompts";
+function createApiKeysRevokeCommand() {
+  const cmd = new Command14("revoke").description("Permanently revoke an API key for a client").argument("<clientId>", "Client ID").argument("<keyId>", "API Key ID to revoke").option("-y, --yes", "Skip confirmation prompt").addHelpText("after", `
+Examples:
+  $ nebulaos clients api-keys revoke my-client key-123      Revoke with confirmation
+  $ nebulaos clients api-keys revoke my-client key-123 -y   Revoke without confirmation
+`).action(async (clientId, keyId, options) => {
+    try {
+      if (!options.yes) {
+        const shouldProceed = await confirm2({
+          message: `Revoke API key '${keyId}' for client '${clientId}'?`,
+          default: false
+        });
+        if (!shouldProceed) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      const api = getApiClient();
+      await api.delete(`/clients/${clientId}/api-keys/${keyId}`);
+      printSuccess(`API key '${keyId}' revoked successfully.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/clients/api-keys/index.ts
+function createApiKeysCommand() {
+  const apiKeys = new Command15("api-keys").description("Create, list, and revoke API keys for clients");
+  apiKeys.addCommand(createApiKeysListCommand());
+  apiKeys.addCommand(createApiKeysCreateCommand());
+  apiKeys.addCommand(createApiKeysRevokeCommand());
+  return apiKeys;
+}
+
+// src/commands/clients/index.ts
+function createClientsCommand() {
+  const clients = new Command16("clients").description("Register and manage clients and their API keys");
+  clients.addCommand(createClientsListCommand());
+  clients.addCommand(createClientsGetCommand());
+  clients.addCommand(createClientsCreateCommand());
+  clients.addCommand(createApiKeysCommand());
+  return clients;
+}
+
+// src/commands/resources/index.ts
+import { Command as Command22 } from "commander";
+
+// src/commands/resources/list.ts
+import { Command as Command17, Option as Option2 } from "commander";
+function createResourcesListCommand() {
+  const cmd = new Command17("list").description("List registered resources (agents, workflows, tools) with optional filters").addHelpText("after", `
+Examples:
+  $ nebulaos resources list                         List all resources
+  $ nebulaos resources list --type agent             List only agents
+  $ nebulaos resources list --status official         List official resources
+  $ nebulaos resources list --type workflow -o json   List workflows as JSON
+`).addOption(
+    new Option2("--type <type>", "Filter by resource type").choices(["agent", "workflow", "tool"])
+  ).addOption(
+    new Option2("--status <status>", "Filter by resource status").choices(["discovered", "official"])
+  ).action(async (options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const params = {};
+      if (options.type) params.type = options.type;
+      if (options.status) params.status = options.status;
+      if (globalOpts.page) params.page = String(globalOpts.page);
+      if (globalOpts.pageSize) params.pageSize = String(globalOpts.pageSize);
+      const { data } = await api.get("/resources", { params });
+      const resources = Array.isArray(data) ? data : data.data ?? [];
+      output(format, {
+        table: {
+          headers: ["ID", "Name", "Type", "Status", "Online", "Created At"],
+          rows: resources.map((r) => [
+            r.id,
+            r.displayName || r.name || "-",
+            r.type,
+            r.lifecycleStatus || r.status || "-",
+            r.isOnline ? "Yes" : "No",
+            r.firstSeenAt || r.createdAt ? new Date(r.firstSeenAt || r.createdAt).toLocaleString() : "-"
+          ])
+        },
+        data: resources,
+        ids: resources.map((r) => r.id)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  addPaginationFlags(cmd);
+  return cmd;
+}
+
+// src/commands/resources/get.ts
+import { Command as Command18 } from "commander";
+import chalk10 from "chalk";
+function createResourcesGetCommand() {
+  const cmd = new Command18("get").description("Get detailed information about a specific resource").argument("<id>", "Resource ID").addHelpText("after", `
+Examples:
+  $ nebulaos resources get 550e8400-e29b-41d4...   View resource details
+  $ nebulaos resources get my-resource -o json      Output as JSON
+`).action(async (id, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data: resource } = await api.get(`/resources/${id}`);
+      if (format === "table") {
+        console.log(chalk10.bold("Resource Details\n"));
+        printDetail("ID", resource.id);
+        printDetail("Name", resource.displayName || resource.name || "-");
+        printDetail("Type", resource.type);
+        printDetail("Status", resource.lifecycleStatus || resource.status || "-");
+        if (resource.kind) printDetail("Kind", resource.kind);
+        if (resource.description) printDetail("Description", resource.description);
+        if (resource.clientId) printDetail("Client ID", resource.clientId);
+        if (resource.runtimeResourceId) printDetail("Runtime ID", resource.runtimeResourceId);
+        printDetail("Online", resource.isOnline ? "Yes" : "No");
+        printDetail("Created At", resource.createdAt ? new Date(resource.createdAt).toLocaleString() : "-");
+        printDetail("Updated At", resource.updatedAt ? new Date(resource.updatedAt).toLocaleString() : "-");
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: resource,
+          ids: [resource.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/resources/archive.ts
+import { Command as Command19 } from "commander";
+function createResourcesArchiveCommand() {
+  const cmd = new Command19("archive").description("Archive a resource to hide it from active listings").argument("<id>", "Resource ID").addHelpText("after", `
+Examples:
+  $ nebulaos resources archive 550e8400-e29b...   Archive a resource by ID
+
+Archived resources can be restored with the 'unarchive' command.
+`).action(async (id) => {
+    try {
+      const api = getApiClient();
+      await api.patch(`/resources/${id}/archive`);
+      printSuccess(`Resource '${id}' archived successfully.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/resources/unarchive.ts
+import { Command as Command20 } from "commander";
+function createResourcesUnarchiveCommand() {
+  const cmd = new Command20("unarchive").description("Restore an archived resource back to active status").argument("<id>", "Resource ID").addHelpText("after", `
+Examples:
+  $ nebulaos resources unarchive 550e8400-e29b...   Restore an archived resource
+`).action(async (id) => {
+    try {
+      const api = getApiClient();
+      await api.patch(`/resources/${id}/unarchive`);
+      printSuccess(`Resource '${id}' unarchived successfully.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/resources/promote.ts
+import { Command as Command21 } from "commander";
+function createResourcesPromoteCommand() {
+  const cmd = new Command21("promote").description("Promote a discovered resource to official status").argument("<id>", "Resource ID").addHelpText("after", `
+Examples:
+  $ nebulaos resources promote 550e8400-e29b...   Promote a resource to official
+
+Discovered resources are auto-registered by clients. Promoting makes them official.
+`).action(async (id) => {
+    try {
+      const api = getApiClient();
+      await api.patch(`/resources/${id}/promote`);
+      printSuccess(`Resource '${id}' promoted to official.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/resources/index.ts
+function createResourcesCommand() {
+  const resources = new Command22("resources").description("List, inspect, archive, and promote resources (agents, workflows, tools)");
+  resources.addCommand(createResourcesListCommand());
+  resources.addCommand(createResourcesGetCommand());
+  resources.addCommand(createResourcesArchiveCommand());
+  resources.addCommand(createResourcesUnarchiveCommand());
+  resources.addCommand(createResourcesPromoteCommand());
+  return resources;
+}
+
+// src/commands/execution/index.ts
+import { Command as Command27 } from "commander";
+
+// src/commands/execution/run.ts
+import { Command as Command23 } from "commander";
+import ora from "ora";
+import chalk11 from "chalk";
+function createExecutionRunCommand() {
+  const cmd = new Command23("run").description("Trigger execution of an agent or workflow by resource ID").argument("<resourceId>", "Resource ID to execute").option("-i, --input <json>", "Input data as JSON string").addHelpText("after", `
+Examples:
+  $ nebulaos exec run 550e8400-e29b...                            Run a resource
+  $ nebulaos exec run my-agent -i '{"prompt":"Hello"}'            Run with JSON input
+  $ nebulaos exec run my-workflow -i '{"data":[1,2,3]}' -o json   Run and output as JSON
+`).action(async (resourceId, options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      let input4;
+      if (options.input) {
+        try {
+          input4 = JSON.parse(options.input);
+        } catch {
+          throw new CLIError(
+            "Invalid JSON input. Provide valid JSON with --input.",
+            7 /* ValidationError */
+          );
+        }
+      }
+      const spinner = ora("Starting execution...").start();
+      const { data: execution } = await api.post("/execution", {
+        resourceId,
+        input: input4
+      });
+      spinner.succeed("Execution started.");
+      if (format === "table") {
+        console.log(chalk11.bold("\nExecution Details\n"));
+        printDetail("Execution ID", execution.id);
+        printDetail("Resource ID", execution.resourceId || resourceId);
+        printDetail("Status", execution.status);
+        if (execution.result !== void 0) {
+          printDetail("Result", JSON.stringify(execution.result));
+        }
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: execution,
+          ids: [execution.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/execution/list.ts
+import { Command as Command24, Option as Option3 } from "commander";
+function createExecutionListCommand() {
+  const cmd = new Command24("list").description("List past and ongoing executions with optional status filter").addHelpText("after", `
+Examples:
+  $ nebulaos exec list                       List recent executions
+  $ nebulaos exec list --status running      Show only running executions
+  $ nebulaos exec list --limit 5             Show last 5 executions
+  $ nebulaos exec list -o json               Output as JSON
+`).addOption(
+    new Option3("--status <status>", "Filter by execution status")
+  ).addOption(
+    new Option3("--limit <number>", "Limit number of results").argParser(parseInt)
+  ).action(async (options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const params = {};
+      if (options.status) params.status = options.status;
+      if (options.limit) params.limit = String(options.limit);
+      if (globalOpts.page) params.page = String(globalOpts.page);
+      if (globalOpts.pageSize) params.pageSize = String(globalOpts.pageSize);
+      const { data } = await api.get("/execution", { params });
+      const executions = Array.isArray(data) ? data : data.items ?? data.data ?? [];
+      output(format, {
+        table: {
+          headers: ["ID", "Resource", "Status", "Started At", "Duration"],
+          rows: executions.map((e) => [
+            e.id,
+            e.targetName,
+            e.status,
+            e.startedAt ? new Date(e.startedAt).toLocaleString() : "-",
+            e.completedAt && e.startedAt ? `${new Date(e.completedAt).getTime() - new Date(e.startedAt).getTime()}ms` : "-"
+          ])
+        },
+        data: executions,
+        ids: executions.map((e) => e.id)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  addPaginationFlags(cmd);
+  return cmd;
+}
+
+// src/commands/execution/get.ts
+import { Command as Command25 } from "commander";
+import chalk12 from "chalk";
+function createExecutionGetCommand() {
+  const cmd = new Command25("get").description("Get detailed status and result of a specific execution").argument("<id>", "Execution ID").addHelpText("after", `
+Examples:
+  $ nebulaos exec get 550e8400-e29b-41d4...   View execution details
+  $ nebulaos exec get my-exec-id -o json      Output as JSON
+`).action(async (id, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data: execution } = await api.get(`/execution/${id}`);
+      if (format === "table") {
+        console.log(chalk12.bold("Execution Details\n"));
+        printDetail("ID", execution.id);
+        if (execution.resourceId) printDetail("Resource ID", execution.resourceId);
+        if (execution.resourceName) printDetail("Resource", execution.resourceName);
+        printDetail("Status", execution.status);
+        if (execution.startedAt) printDetail("Started At", new Date(execution.startedAt).toLocaleString());
+        if (execution.completedAt) printDetail("Completed At", new Date(execution.completedAt).toLocaleString());
+        if (execution.duration) printDetail("Duration", `${execution.duration}ms`);
+        if (execution.error) printDetail("Error", execution.error);
+        if (execution.result !== void 0) {
+          printDetail("Result", JSON.stringify(execution.result, null, 2));
+        }
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: execution,
+          ids: [execution.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/execution/logs.ts
+import { Command as Command26 } from "commander";
+import chalk13 from "chalk";
+function createExecutionLogsCommand() {
+  const cmd = new Command26("logs").description("View execution cost items and LLM calls for a specific execution").argument("<id>", "Execution ID").option("-l, --limit <n>", "Limit number of items", "50").addHelpText("after", `
+Examples:
+  $ nebulaos exec logs 550e8400-e29b...      View execution cost items
+  $ nebulaos exec logs my-exec-id --limit 10 Show last 10 items
+  $ nebulaos exec logs my-exec-id -o json    Output as JSON
+`).action(async (id, options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data } = await api.get(`/execution/${id}/cost-items`, {
+        params: { limit: options.limit }
+      });
+      const items = Array.isArray(data) ? data : data.data ?? [];
+      if (format === "table") {
+        if (items.length === 0) {
+          console.log(chalk13.gray("No cost items available for this execution."));
+          return;
+        }
+        console.log(chalk13.bold("\nExecution Cost Items\n"));
+        for (const item of items) {
+          const timestamp = item.createdAt ? chalk13.gray(new Date(item.createdAt).toLocaleTimeString()) : "";
+          const type = formatType(item.type);
+          const model = item.model ? chalk13.cyan(`[${item.model}]`) : "";
+          const tokens = item.inputTokens || item.outputTokens ? chalk13.yellow(`(${item.inputTokens || 0}\u2192${item.outputTokens || 0} tokens)`) : "";
+          const cost = item.totalCost ? chalk13.green(`$${item.totalCost.toFixed(6)}`) : "";
+          console.log(`${timestamp} ${type} ${model} ${tokens} ${cost}`);
+          if (item.input && globalOpts.verbose) {
+            console.log(chalk13.gray(`  Input: ${truncate(JSON.stringify(item.input), 100)}`));
+          }
+          if (item.output && globalOpts.verbose) {
+            console.log(chalk13.gray(`  Output: ${truncate(JSON.stringify(item.output), 100)}`));
+          }
+        }
+        console.log(chalk13.gray(`
+Showing ${items.length} items. Use --limit to see more.`));
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: items,
+          ids: items.map((i) => i.id ?? "")
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+function formatType(type) {
+  switch (type?.toLowerCase()) {
+    case "llm_call":
+    case "llm":
+      return chalk13.blue("[LLM]  ");
+    case "tool_call":
+    case "tool":
+      return chalk13.magenta("[TOOL] ");
+    case "embedding":
+      return chalk13.cyan("[EMBED]");
+    default:
+      return chalk13.gray("[ITEM] ");
+  }
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+
+// src/commands/execution/index.ts
+function createExecutionCommand() {
+  const execution = new Command27("execution").alias("exec").description("Run agents/workflows and inspect execution results and logs");
+  execution.addCommand(createExecutionRunCommand());
+  execution.addCommand(createExecutionListCommand());
+  execution.addCommand(createExecutionGetCommand());
+  execution.addCommand(createExecutionLogsCommand());
+  return execution;
+}
+
+// src/commands/rag/index.ts
+import { Command as Command36 } from "commander";
+
+// src/commands/rag/connections/index.ts
+import { Command as Command34 } from "commander";
+
+// src/commands/rag/connections/list.ts
+import { Command as Command28 } from "commander";
+function createConnectionsListCommand() {
+  const cmd = new Command28("list").description("List all configured RAG connections").addHelpText("after", `
+Examples:
+  $ nebulaos rag connections list              List all connections
+  $ nebulaos rag connections list -o json      Output as JSON
+  $ nebulaos rag connections list --page 2     Show page 2
+`).action(async (_options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const params = {};
+      if (globalOpts.page) params.page = globalOpts.page;
+      if (globalOpts.pageSize) params.pageSize = globalOpts.pageSize;
+      const { data } = await api.get("/rag/openai-connections", { params });
+      const connections = Array.isArray(data) ? data : data.data || [];
+      output(format, {
+        table: {
+          headers: ["ID", "Name", "Type", "Status", "Created At"],
+          rows: connections.map((c) => [
+            c.id,
+            c.name || "-",
+            c.type || "-",
+            c.status || "-",
+            c.createdAt || "-"
+          ])
+        },
+        data: connections,
+        ids: connections.map((c) => c.id)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  addPaginationFlags(cmd);
+  return cmd;
+}
+
+// src/commands/rag/connections/get.ts
+import { Command as Command29 } from "commander";
+import chalk14 from "chalk";
+function createConnectionsGetCommand() {
+  const cmd = new Command29("get").description("Get detailed information about a RAG connection").argument("<id>", "Connection ID").addHelpText("after", `
+Examples:
+  $ nebulaos rag connections get conn-123         View connection details
+  $ nebulaos rag connections get conn-123 -o json Output as JSON
+`).action(async (id, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data } = await api.get(`/rag/openai-connections/${id}`);
+      if (format === "table") {
+        console.log(chalk14.bold("RAG Connection\n"));
+        printDetail("ID", data.id);
+        printDetail("Name", data.name || "-");
+        printDetail("Type", data.type || "-");
+        printDetail("Status", data.status || "-");
+        if (data.baseUrl) printDetail("Base URL", data.baseUrl);
+        if (data.model) printDetail("Model", data.model);
+        printDetail("Created At", data.createdAt || "-");
+        printDetail("Updated At", data.updatedAt || "-");
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data,
+          ids: [data.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/rag/connections/create.ts
+import { Command as Command30 } from "commander";
+function createConnectionsCreateCommand() {
+  const cmd = new Command30("create").description("Create a new RAG connection to a vector store provider").requiredOption("--name <name>", "Connection name").requiredOption("--type <type>", "Connection type (e.g., openai, azure)").option("--base-url <url>", "Base URL for the connection").option("--api-key <key>", "API key for the connection").option("--model <model>", "Model name").option("--dimensions <number>", "Embedding dimensions", parseInt).addHelpText("after", `
+Examples:
+  $ nebulaos rag connections create --name my-store --type openai \\
+      --api-key sk-... --model text-embedding-3-small
+  $ nebulaos rag connections create --name azure-store --type azure \\
+      --base-url https://my-resource.openai.azure.com --api-key abc123 \\
+      --dimensions 1536
+`).action(async (options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const body = {
+        name: options.name,
+        type: options.type
+      };
+      if (options.baseUrl) body.baseUrl = options.baseUrl;
+      if (options.apiKey) body.apiKey = options.apiKey;
+      if (options.model) body.model = options.model;
+      if (options.dimensions) body.dimensions = options.dimensions;
+      const { data } = await api.post("/rag/openai-connections", body);
+      if (format === "table") {
+        printSuccess("RAG connection created successfully.");
+        printDetail("ID", data.id);
+        printDetail("Name", data.name);
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data,
+          ids: [data.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/rag/connections/update.ts
+import { Command as Command31 } from "commander";
+function createConnectionsUpdateCommand() {
+  const cmd = new Command31("update").description("Update an existing RAG connection's configuration").argument("<id>", "Connection ID").option("--name <name>", "Connection name").option("--base-url <url>", "Base URL for the connection").option("--api-key <key>", "API key for the connection").option("--model <model>", "Model name").option("--dimensions <number>", "Embedding dimensions", parseInt).addHelpText("after", `
+Examples:
+  $ nebulaos rag connections update conn-123 --name new-name      Rename connection
+  $ nebulaos rag connections update conn-123 --api-key sk-new...  Rotate API key
+  $ nebulaos rag connections update conn-123 --model text-embedding-3-large
+`).action(async (id, options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const body = {};
+      if (options.name) body.name = options.name;
+      if (options.baseUrl) body.baseUrl = options.baseUrl;
+      if (options.apiKey) body.apiKey = options.apiKey;
+      if (options.model) body.model = options.model;
+      if (options.dimensions) body.dimensions = options.dimensions;
+      const { data } = await api.patch(`/rag/openai-connections/${id}`, body);
+      if (format === "table") {
+        printSuccess("RAG connection updated successfully.");
+        printDetail("ID", data.id);
+        printDetail("Name", data.name);
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data,
+          ids: [data.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/rag/connections/delete.ts
+import { Command as Command32 } from "commander";
+import { confirm as confirm3 } from "@inquirer/prompts";
+function createConnectionsDeleteCommand() {
+  const cmd = new Command32("delete").description("Permanently delete a RAG connection").argument("<id>", "Connection ID").option("-y, --yes", "Skip confirmation prompt").addHelpText("after", `
+Examples:
+  $ nebulaos rag connections delete conn-123       Delete with confirmation
+  $ nebulaos rag connections delete conn-123 -y    Delete without confirmation
+`).action(async (id, options) => {
+    try {
+      if (!options.yes) {
+        const shouldProceed = await confirm3({
+          message: `Delete RAG connection '${id}'?`,
+          default: false
+        });
+        if (!shouldProceed) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      const api = getApiClient();
+      await api.delete(`/rag/openai-connections/${id}`);
+      printSuccess(`RAG connection '${id}' deleted.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/rag/connections/test.ts
+import { Command as Command33 } from "commander";
+import chalk15 from "chalk";
+function createConnectionsTestCommand() {
+  const cmd = new Command33("test").description("Test connectivity and authentication of a RAG connection").argument("<id>", "Connection ID").addHelpText("after", `
+Examples:
+  $ nebulaos rag connections test conn-123         Test a connection
+  $ nebulaos rag connections test conn-123 -o json Output result as JSON
+`).action(async (id, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      console.log("Testing connection...");
+      const { data } = await api.post(`/rag/openai-connections/${id}/test`);
+      if (format === "table") {
+        if (data.success) {
+          console.log(chalk15.green("Connection test passed."));
+        } else {
+          console.log(chalk15.red(`Connection test failed: ${data.error || "Unknown error"}`));
+        }
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data,
+          ids: [id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/rag/connections/index.ts
+function createConnectionsCommand() {
+  const connections = new Command34("connections").description("Create, configure, and test RAG vector store connections");
+  connections.addCommand(createConnectionsListCommand());
+  connections.addCommand(createConnectionsGetCommand());
+  connections.addCommand(createConnectionsCreateCommand());
+  connections.addCommand(createConnectionsUpdateCommand());
+  connections.addCommand(createConnectionsDeleteCommand());
+  connections.addCommand(createConnectionsTestCommand());
+  return connections;
+}
+
+// src/commands/rag/search.ts
+import { Command as Command35 } from "commander";
+function createRagSearchCommand() {
+  const cmd = new Command35("search").description("Perform a semantic search against a RAG connection").requiredOption("--connection <id>", "Connection ID to search against").requiredOption("--query <query>", "Search query").option("--limit <number>", "Maximum number of results", parseInt).addHelpText("after", `
+Examples:
+  $ nebulaos rag search --connection conn-123 --query "patient intake process"
+  $ nebulaos rag search --connection conn-123 --query "billing codes" --limit 5
+  $ nebulaos rag search --connection conn-123 --query "diagnosis" -o json
+`).action(async (options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const body = {
+        connectionId: options.connection,
+        query: options.query
+      };
+      if (options.limit) body.limit = options.limit;
+      const { data } = await api.post("/rag/search", body);
+      const results = Array.isArray(data) ? data : data.results || [];
+      output(format, {
+        table: {
+          headers: ["#", "Score", "Content"],
+          rows: results.map((r, i) => [
+            String(i + 1),
+            String(r.score ?? "-"),
+            String(r.content || r.text || "-").slice(0, 100)
+          ])
+        },
+        data: results,
+        ids: results.map((_, i) => String(i + 1))
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/rag/index.ts
+function createRagCommand() {
+  const rag = new Command36("rag").description("Manage RAG connections and perform semantic searches");
+  rag.addCommand(createConnectionsCommand());
+  rag.addCommand(createRagSearchCommand());
+  return rag;
+}
+
+// src/commands/features/index.ts
+import { Command as Command43 } from "commander";
+
+// src/commands/features/catalog.ts
+import { Command as Command37 } from "commander";
+function createFeaturesCatalogCommand() {
+  const cmd = new Command37("catalog").description("List all available features in the platform catalog").addHelpText("after", `
+Examples:
+  $ nebulaos features catalog              Browse all available features
+  $ nebulaos features catalog -o json      Output as JSON
+`).action(async (_options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data } = await api.get("/features/catalog");
+      const features = Array.isArray(data) ? data : data.data || [];
+      output(format, {
+        table: {
+          headers: ["Key", "Name", "Description", "Category"],
+          rows: features.map((f) => [
+            f.key,
+            f.name || "-",
+            f.description || "-",
+            f.category || "-"
+          ])
+        },
+        data: features,
+        ids: features.map((f) => f.key)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/features/list.ts
+import { Command as Command38 } from "commander";
+function createFeaturesListCommand() {
+  const cmd = new Command38("list").description("List features enabled for the current organization").addHelpText("after", `
+Examples:
+  $ nebulaos features list              List enabled features
+  $ nebulaos features list -o json      Output as JSON
+`).action(async (_options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data } = await api.get("/features");
+      const features = Array.isArray(data) ? data : data.data || [];
+      output(format, {
+        table: {
+          headers: ["Key", "Name", "Enabled", "Updated At"],
+          rows: features.map((f) => [
+            String(f.key),
+            String(f.name || "-"),
+            String(f.enabled ?? f.isEnabled ?? "-"),
+            String(f.updatedAt || "-")
+          ])
+        },
+        data: features,
+        ids: features.map((f) => f.key)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/features/get.ts
+import { Command as Command39 } from "commander";
+import chalk16 from "chalk";
+function createFeaturesGetCommand() {
+  const cmd = new Command39("get").description("Get details and configuration of a specific feature").argument("<key>", "Feature key").addHelpText("after", `
+Examples:
+  $ nebulaos features get llm-gateway        View feature details
+  $ nebulaos features get rag -o json        Output as JSON
+`).action(async (key, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data } = await api.get(`/features/${key}`);
+      if (format === "table") {
+        console.log(chalk16.bold("Feature\n"));
+        printDetail("Key", data.key);
+        printDetail("Name", data.name || "-");
+        printDetail("Description", data.description || "-");
+        printDetail("Enabled", data.enabled ?? data.isEnabled ? "true" : "false");
+        if (data.config) {
+          printDetail("Config", JSON.stringify(data.config, null, 2));
+        }
+        printDetail("Updated At", data.updatedAt || "-");
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data,
+          ids: [data.key]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/features/enable.ts
+import { Command as Command40 } from "commander";
+function createFeaturesEnableCommand() {
+  const cmd = new Command40("enable").description("Enable a feature for the current organization").argument("<key>", "Feature key").addHelpText("after", `
+Examples:
+  $ nebulaos features enable llm-gateway     Enable the LLM gateway feature
+  $ nebulaos features enable rag             Enable the RAG feature
+`).action(async (key) => {
+    try {
+      const api = getApiClient();
+      await api.post(`/features/${key}/enable`);
+      printSuccess(`Feature '${key}' enabled.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/features/disable.ts
+import { Command as Command41 } from "commander";
+function createFeaturesDisableCommand() {
+  const cmd = new Command41("disable").description("Disable a feature for the current organization").argument("<key>", "Feature key").addHelpText("after", `
+Examples:
+  $ nebulaos features disable llm-gateway    Disable the LLM gateway feature
+  $ nebulaos features disable rag            Disable the RAG feature
+`).action(async (key) => {
+    try {
+      const api = getApiClient();
+      await api.post(`/features/${key}/disable`);
+      printSuccess(`Feature '${key}' disabled.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/features/config.ts
+import { Command as Command42 } from "commander";
+import chalk17 from "chalk";
+function createFeaturesConfigCommand() {
+  const cmd = new Command42("config").description("View or update key-value configuration for a feature").argument("<key>", "Feature key").option("--set <entries...>", "Set config values (key=value)").addHelpText("after", `
+Examples:
+  $ nebulaos features config llm-gateway                       View current config
+  $ nebulaos features config llm-gateway --set max_tokens=4096 Update a config value
+  $ nebulaos features config rag --set provider=openai model=text-embedding-3-small
+  $ nebulaos features config llm-gateway -o json               Output as JSON
+`).action(async (key, options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      if (options.set && options.set.length > 0) {
+        const configValues = {};
+        for (const entry of options.set) {
+          const eqIndex = entry.indexOf("=");
+          if (eqIndex === -1) {
+            throw new CLIError(
+              `Invalid config entry '${entry}'. Use key=value format.`,
+              7 /* ValidationError */
+            );
+          }
+          const k = entry.slice(0, eqIndex);
+          const v = entry.slice(eqIndex + 1);
+          configValues[k] = v;
+        }
+        await api.patch(`/features/${key}/config`, configValues);
+        printSuccess(`Feature '${key}' configuration updated.`);
+      } else {
+        const { data } = await api.get(`/features/${key}`);
+        const featureConfig = data.config || {};
+        if (format === "table") {
+          console.log(chalk17.bold(`Feature '${key}' Configuration
+`));
+          const entries = Object.entries(featureConfig);
+          if (entries.length === 0) {
+            console.log("No configuration set.");
+          } else {
+            for (const [k, v] of entries) {
+              console.log(`  ${chalk17.bold(k)}: ${v}`);
+            }
+          }
+        } else {
+          output(format, {
+            table: { headers: [], rows: [] },
+            data: featureConfig,
+            ids: Object.keys(featureConfig)
+          });
+        }
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/features/index.ts
+function createFeaturesCommand() {
+  const features = new Command43("features").description("Browse, enable, disable, and configure platform feature flags");
+  features.addCommand(createFeaturesCatalogCommand());
+  features.addCommand(createFeaturesListCommand());
+  features.addCommand(createFeaturesGetCommand());
+  features.addCommand(createFeaturesEnableCommand());
+  features.addCommand(createFeaturesDisableCommand());
+  features.addCommand(createFeaturesConfigCommand());
+  return features;
+}
+
+// src/commands/observability/index.ts
+import { Command as Command48 } from "commander";
+
+// src/commands/observability/traces/index.ts
+import { Command as Command46 } from "commander";
+
+// src/commands/observability/traces/search.ts
+import { Command as Command44 } from "commander";
+function createTracesSearchCommand() {
+  const cmd = new Command44("search").description("Search traces by status, agent, or time range").option("--status <status>", "Filter by status").option("--limit <number>", "Maximum number of results", parseInt).option("--agent <name>", "Filter by agent name").option("--from <date>", "Start date (ISO format)").option("--to <date>", "End date (ISO format)").addHelpText("after", `
+Examples:
+  $ nebulaos obs traces search                                  List recent traces
+  $ nebulaos obs traces search --agent my-agent                 Filter by agent
+  $ nebulaos obs traces search --status error --limit 10        Find error traces
+  $ nebulaos obs traces search --from 2026-01-01 --to 2026-01-31 -o json
+`).action(async (options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const params = {};
+      if (options.status) params.status = options.status;
+      if (options.limit) params.limit = options.limit;
+      if (options.agent) params.agent = options.agent;
+      if (options.from) params.from = options.from;
+      if (options.to) params.to = options.to;
+      if (globalOpts.page) params.page = globalOpts.page;
+      if (globalOpts.pageSize) params.pageSize = globalOpts.pageSize;
+      const { data } = await api.get("/observability/traces/search", { params });
+      const traces = Array.isArray(data) ? data : data.data || [];
+      output(format, {
+        table: {
+          headers: ["Trace ID", "Status", "Duration", "Agent", "Started At"],
+          rows: traces.map((t) => [
+            t.traceId || t.id || "-",
+            t.status || "-",
+            t.duration ? `${t.duration}ms` : "-",
+            t.agent || t.agentName || "-",
+            t.startedAt || t.createdAt || "-"
+          ])
+        },
+        data: traces,
+        ids: traces.map((t) => t.traceId || t.id)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  addPaginationFlags(cmd);
+  return cmd;
+}
+
+// src/commands/observability/traces/get.ts
+import { Command as Command45 } from "commander";
+import chalk18 from "chalk";
+function createTracesGetCommand() {
+  const cmd = new Command45("get").description("Get detailed trace information including all spans").argument("[traceId]", "Trace ID").option("--execution-id <executionId>", "Lookup trace by execution ID").addHelpText("after", `
+Examples:
+  $ nebulaos obs traces get abc123-def456...              View trace by trace ID
+  $ nebulaos obs traces get --execution-id exec-789...    View trace by execution ID
+  $ nebulaos obs traces get abc123 -o json                Output as JSON
+`).action(async (traceId, options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      if (!traceId && !options.executionId) {
+        console.error("Error: provide either a <traceId> argument or --execution-id <executionId>");
+        process.exit(1);
+      }
+      const url = options.executionId ? `/observability/executions/${options.executionId}/trace` : `/observability/traces/${traceId}`;
+      const { data } = await api.get(url);
+      if (format === "table") {
+        console.log(chalk18.bold("Trace\n"));
+        printDetail("Trace ID", data.traceId || data.id || "-");
+        printDetail("Status", data.status || "-");
+        printDetail("Duration", data.duration ? `${data.duration}ms` : "-");
+        printDetail("Agent", data.agent || data.agentName || "-");
+        printDetail("Started At", data.startedAt || data.createdAt || "-");
+        printDetail("Ended At", data.endedAt || "-");
+        if (data.spans && data.spans.length > 0) {
+          console.log(chalk18.bold("\nSpans:"));
+          for (const span of data.spans) {
+            console.log(`  ${span.spanId} - ${span.name || span.operationName || "unknown"} (${span.duration ? span.duration + "ms" : "-"})`);
+          }
+        }
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data,
+          ids: [data.traceId || data.id]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/observability/traces/index.ts
+function createTracesCommand() {
+  const traces = new Command46("traces").description("Search and inspect distributed traces from agent executions");
+  traces.addCommand(createTracesSearchCommand());
+  traces.addCommand(createTracesGetCommand());
+  return traces;
+}
+
+// src/commands/observability/metrics.ts
+import { Command as Command47 } from "commander";
+function createMetricsCommand() {
+  const cmd = new Command47("metrics").description("View observability metrics with optional time range and type filters").option("--type <type>", "Metric type filter").option("--from <date>", "Start date (ISO format)").option("--to <date>", "End date (ISO format)").addHelpText("after", `
+Examples:
+  $ nebulaos obs metrics                                     List all metrics
+  $ nebulaos obs metrics --type latency                      Filter by metric type
+  $ nebulaos obs metrics --from 2026-01-01 --to 2026-01-31  Filter by date range
+  $ nebulaos obs metrics -o json                             Output as JSON
+`).action(async (options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const params = {};
+      if (options.type) params.type = options.type;
+      if (options.from) params.from = options.from;
+      if (options.to) params.to = options.to;
+      const { data } = await api.get("/observability/metrics", { params });
+      const metrics = Array.isArray(data) ? data : data.data || [];
+      output(format, {
+        table: {
+          headers: ["Name", "Type", "Value", "Timestamp"],
+          rows: metrics.map((m) => [
+            m.name || "-",
+            m.type || "-",
+            String(m.value ?? "-"),
+            m.timestamp || "-"
+          ])
+        },
+        data: metrics,
+        ids: metrics.map((m) => m.name || m.id)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/observability/index.ts
+function createObservabilityCommand() {
+  const observability = new Command48("observability").alias("obs").description("Inspect traces and metrics from your agents and workflows");
+  observability.addCommand(createTracesCommand());
+  observability.addCommand(createMetricsCommand());
+  return observability;
+}
+
+// src/commands/config/index.ts
+import { Command as Command52 } from "commander";
+
+// src/commands/config/get.ts
+import { Command as Command49 } from "commander";
+function createConfigGetCommand() {
+  const cmd = new Command49("get").description("Get the current value of a configuration key").argument("<key>", "Configuration key (e.g., defaults.output, defaults.pageSize)").addHelpText("after", `
+Examples:
+  $ nebulaos config get defaults.output      Get default output format
+  $ nebulaos config get defaults.pageSize    Get default page size
+  $ nebulaos config get currentContext       Get active context name
+`).action(async (key, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const config2 = getConfig();
+      const parts = key.split(".");
+      let value = config2;
+      for (const part of parts) {
+        if (value && typeof value === "object" && part in value) {
+          value = value[part];
+        } else {
+          throw new CLIError(`Configuration key '${key}' not found.`, 5 /* NotFound */);
+        }
+      }
+      if (format === "table") {
+        printDetail(key, String(value));
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: { key, value },
+          ids: [key]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/config/set.ts
+import { Command as Command50 } from "commander";
+var VALID_KEYS = {
+  "defaults.output": (v) => {
+    const valid = ["table", "json", "yaml", "quiet"];
+    if (!valid.includes(v)) {
+      throw new CLIError(
+        `Invalid output format '${v}'. Valid values: ${valid.join(", ")}`,
+        7 /* ValidationError */
+      );
+    }
+    return v;
+  },
+  "defaults.pageSize": (v) => {
+    const n = parseInt(v, 10);
+    if (isNaN(n) || n < 1 || n > 100) {
+      throw new CLIError(
+        "Page size must be a number between 1 and 100.",
+        7 /* ValidationError */
+      );
+    }
+    return n;
+  }
+};
+function createConfigSetCommand() {
+  const cmd = new Command50("set").description("Set a CLI configuration value").argument("<key>", "Configuration key (e.g., defaults.output, defaults.pageSize)").argument("<value>", "Configuration value").addHelpText("after", `
+Examples:
+  $ nebulaos config set defaults.output json      Set default output to JSON
+  $ nebulaos config set defaults.output table     Set default output to table
+  $ nebulaos config set defaults.pageSize 25      Set default page size to 25
+
+Valid keys:
+  defaults.output    Output format (table, json, yaml, quiet)
+  defaults.pageSize  Number of items per page (1-100)
+`).action(async (key, value, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const parser = VALID_KEYS[key];
+      if (!parser) {
+        throw new CLIError(
+          `Unknown configuration key '${key}'. Valid keys: ${Object.keys(VALID_KEYS).join(", ")}`,
+          7 /* ValidationError */
+        );
+      }
+      const parsed = parser(value);
+      const parts = key.split(".");
+      if (parts[0] === "defaults" && parts.length === 2) {
+        setDefault(parts[1], parsed);
+      }
+      output(format, {
+        table: {
+          headers: ["Key", "Value"],
+          rows: [[key, String(parsed)]]
+        },
+        data: { key, value: parsed },
+        ids: [key]
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/config/list.ts
+import { Command as Command51 } from "commander";
+import chalk19 from "chalk";
+function createConfigListCommand() {
+  const cmd = new Command51("list").description("Display all configuration values and registered contexts").addHelpText("after", `
+Examples:
+  $ nebulaos config list              Show all config and contexts
+  $ nebulaos config list -o json      Output as JSON
+`).action(async (_options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const config2 = getConfig();
+      if (format === "table") {
+        console.log(chalk19.bold("Configuration\n"));
+        printDetail("Config File", getConfigPath());
+        printDetail("Current Context", config2.currentContext || "(none)");
+        printDetail("Output Format", config2.defaults.output);
+        printDetail("Page Size", String(config2.defaults.pageSize));
+        const contextNames = Object.keys(config2.contexts);
+        if (contextNames.length > 0) {
+          console.log(chalk19.bold("\nContexts:"));
+          for (const name of contextNames) {
+            const ctx = config2.contexts[name];
+            const active = name === config2.currentContext ? chalk19.green(" (active)") : "";
+            console.log(`  ${name}${active} - ${ctx.apiUrl}`);
+          }
+        }
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data: config2,
+          ids: Object.keys(config2.contexts)
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/config/index.ts
+function createConfigCommand() {
+  const config2 = new Command52("config").description("View and modify CLI configuration (output format, page size, contexts)");
+  config2.addCommand(createConfigGetCommand());
+  config2.addCommand(createConfigSetCommand());
+  config2.addCommand(createConfigListCommand());
+  return config2;
+}
+
+// src/commands/llm-gateway/index.ts
+import { Command as Command66 } from "commander";
+
+// src/commands/llm-gateway/routes/index.ts
+import { Command as Command58 } from "commander";
+
+// src/commands/llm-gateway/routes/list.ts
+import { Command as Command53 } from "commander";
+function createRoutesListCommand() {
+  const cmd = new Command53("list").description("List all configured LLM gateway routes").addHelpText("after", `
+Examples:
+  $ nebulaos llm routes list              List all routes
+  $ nebulaos llm routes list -o json      Output as JSON
+`).action(async (_options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data } = await api.get("/llm-gateway/routes");
+      output(format, {
+        table: {
+          headers: ["Alias", "Description", "Model", "Status", "Provisioning", "Updated"],
+          rows: data.map((r) => [
+            r.name,
+            r.description || "-",
+            r.primaryModel,
+            r.status,
+            r.provisioningStatus,
+            r.updatedAt ? new Date(r.updatedAt).toLocaleString() : "-"
+          ])
+        },
+        data,
+        ids: data.map((r) => r.name)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/llm-gateway/routes/get.ts
+import { Command as Command54 } from "commander";
+import chalk20 from "chalk";
+function createRoutesGetCommand() {
+  const cmd = new Command54("get").description("Get full details of an LLM gateway route including fallback chain").argument("<alias>", "Route alias").addHelpText("after", `
+Examples:
+  $ nebulaos llm routes get my-route         View route details
+  $ nebulaos llm routes get my-route -o json Output as JSON
+`).action(async (alias, _options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data } = await api.get(`/llm-gateway/routes/${alias}`);
+      if (format === "table") {
+        console.log(chalk20.bold(`Route: ${data.name}
+`));
+        printDetail("Alias", data.name);
+        printDetail("Description", data.description || "-");
+        printDetail("Provider", data.provider || "-");
+        printDetail("Model", data.modelName || data.primaryModel);
+        printDetail("Status", data.status);
+        printDetail("Provisioning", data.provisioningStatus);
+        if (data.maxTokens) printDetail("Max Tokens", String(data.maxTokens));
+        if (data.timeoutMs) printDetail("Timeout (ms)", String(data.timeoutMs));
+        if (data.retries) printDetail("Retries", String(data.retries));
+        if (data.fallbackChain?.length) {
+          printDetail("Fallback Chain", data.fallbackChain.join(" -> "));
+        }
+        printDetail("Updated", data.updatedAt ? new Date(data.updatedAt).toLocaleString() : "-");
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data,
+          ids: [data.name]
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/llm-gateway/routes/create.ts
+import { Command as Command55 } from "commander";
+import { input as input2 } from "@inquirer/prompts";
+function createRoutesCreateCommand() {
+  const cmd = new Command55("create").description("Create a new LLM gateway route (interactive or via flags)").option("--alias <alias>", "Route alias").option("--provider <provider>", "LLM provider (e.g. openai, anthropic, azure)").option("--model <model>", "Model name (e.g. gpt-4o, claude-3-opus)").option("--description <description>", "Route description").option("--max-tokens <number>", "Max tokens limit", parseInt).option("--timeout <ms>", "Timeout in milliseconds", parseInt).option("--retries <count>", "Retry count", parseInt).option("--credential <key=value>", "Credential key=value pair (repeatable)", collectKeyValue, {}).addHelpText("after", `
+Examples:
+  $ nebulaos llm routes create                                         Interactive mode
+  $ nebulaos llm routes create --alias gpt4 --provider openai --model gpt-4o
+  $ nebulaos llm routes create --alias claude --provider anthropic --model claude-3-opus \\
+      --credential api_key=sk-...
+  $ nebulaos llm routes create --alias fast --provider openai --model gpt-4o-mini \\
+      --max-tokens 4096 --timeout 30000 --retries 2
+`).action(async (options, command) => {
+    try {
+      const api = getApiClient();
+      const alias = options.alias || await input2({ message: "Route alias:" });
+      const provider = options.provider || await input2({ message: "Provider (e.g. openai, anthropic, azure):" });
+      const modelName = options.model || await input2({ message: "Model name:" });
+      const description = options.description || await input2({ message: "Description (optional):", default: "" });
+      let credentials = options.credential;
+      if (Object.keys(credentials).length === 0) {
+        const apiKey = await input2({ message: "API key for provider:" });
+        credentials = { api_key: apiKey };
+      }
+      const body = {
+        alias,
+        provider,
+        modelName,
+        credentials
+      };
+      if (description) body.description = description;
+      if (options.maxTokens) body.maxTokens = options.maxTokens;
+      if (options.timeout) body.timeoutMs = options.timeout;
+      if (options.retries) body.retryCount = options.retries;
+      await api.post("/llm-gateway/routes", body);
+      printSuccess(`Route '${alias}' created successfully.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+function collectKeyValue(value, previous) {
+  const [k, ...rest] = value.split("=");
+  if (k && rest.length > 0) {
+    previous[k] = rest.join("=");
+  }
+  return previous;
+}
+
+// src/commands/llm-gateway/routes/update.ts
+import { Command as Command56 } from "commander";
+function createRoutesUpdateCommand() {
+  const cmd = new Command56("update").description("Update an existing LLM gateway route configuration").argument("<alias>", "Route alias").option("--description <description>", "Route description").option("--provider <provider>", "LLM provider").option("--model <model>", "Model name").option("--max-tokens <number>", "Max tokens limit", parseInt).option("--timeout <ms>", "Timeout in milliseconds", parseInt).option("--retries <count>", "Retry count", parseInt).option("--credential <key=value>", "Credential key=value pair (repeatable)", collectKeyValue2, {}).addHelpText("after", `
+Examples:
+  $ nebulaos llm routes update my-route --model gpt-4o-mini   Change model
+  $ nebulaos llm routes update my-route --max-tokens 8192     Update token limit
+  $ nebulaos llm routes update my-route --credential api_key=sk-new...  Update credentials
+  $ nebulaos llm routes update my-route --timeout 60000 --retries 3     Update timeouts
+`).action(async (alias, options, command) => {
+    try {
+      const api = getApiClient();
+      const body = {};
+      if (options.description !== void 0) body.description = options.description;
+      if (options.provider) body.provider = options.provider;
+      if (options.model) body.modelName = options.model;
+      if (options.maxTokens) body.maxTokens = options.maxTokens;
+      if (options.timeout) body.timeoutMs = options.timeout;
+      if (options.retries) body.retryCount = options.retries;
+      if (Object.keys(options.credential).length > 0) body.credentials = options.credential;
+      await api.put(`/llm-gateway/routes/${alias}`, body);
+      printSuccess(`Route '${alias}' updated successfully.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+function collectKeyValue2(value, previous) {
+  const [k, ...rest] = value.split("=");
+  if (k && rest.length > 0) {
+    previous[k] = rest.join("=");
+  }
+  return previous;
+}
+
+// src/commands/llm-gateway/routes/delete.ts
+import { Command as Command57 } from "commander";
+import { confirm as confirm4 } from "@inquirer/prompts";
+function createRoutesDeleteCommand() {
+  const cmd = new Command57("delete").description("Permanently delete an LLM gateway route").argument("<alias>", "Route alias").option("-y, --yes", "Skip confirmation prompt").addHelpText("after", `
+Examples:
+  $ nebulaos llm routes delete my-route        Delete with confirmation prompt
+  $ nebulaos llm routes delete my-route -y     Delete without confirmation
+`).action(async (alias, options) => {
+    try {
+      if (!options.yes) {
+        const shouldProceed = await confirm4({
+          message: `Delete route '${alias}'? This cannot be undone.`,
+          default: false
+        });
+        if (!shouldProceed) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      const api = getApiClient();
+      await api.delete(`/llm-gateway/routes/${alias}`);
+      printSuccess(`Route '${alias}' deleted successfully.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/llm-gateway/routes/index.ts
+function createRoutesCommand() {
+  const routes = new Command58("routes").description("Create, update, and manage LLM gateway routes (model configurations)");
+  routes.addCommand(createRoutesListCommand());
+  routes.addCommand(createRoutesGetCommand());
+  routes.addCommand(createRoutesCreateCommand());
+  routes.addCommand(createRoutesUpdateCommand());
+  routes.addCommand(createRoutesDeleteCommand());
+  return routes;
+}
+
+// src/commands/llm-gateway/keys/index.ts
+import { Command as Command62 } from "commander";
+
+// src/commands/llm-gateway/keys/list.ts
+import { Command as Command59 } from "commander";
+function createKeysListCommand() {
+  const cmd = new Command59("list").description("List all LLM gateway API keys and their allowed routes").addHelpText("after", `
+Examples:
+  $ nebulaos llm keys list              List all gateway API keys
+  $ nebulaos llm keys list -o json      Output as JSON
+`).action(async (_options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data } = await api.get("/llm-gateway/keys");
+      output(format, {
+        table: {
+          headers: ["ID", "Name", "User", "Status", "Allowed Routes", "Last Used"],
+          rows: data.map((k) => [
+            k.id,
+            k.name,
+            k.user,
+            k.status,
+            k.allowedRoutes?.length ? k.allowedRoutes.join(", ") : "all",
+            k.lastUsedAt ? new Date(k.lastUsedAt).toLocaleString() : "never"
+          ])
+        },
+        data,
+        ids: data.map((k) => k.id)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/llm-gateway/keys/create.ts
+import { Command as Command60 } from "commander";
+import { input as input3, select } from "@inquirer/prompts";
+import chalk21 from "chalk";
+function createKeysCreateCommand() {
+  const cmd = new Command60("create").description("Create a new LLM gateway API key (interactive or via flags)").option("--name <name>", "Key name").option("--type <type>", "Key type (personal or service)").option("--allowed-routes <routes>", "Comma-separated list of allowed route aliases").addHelpText("after", `
+Examples:
+  $ nebulaos llm keys create                                     Interactive mode
+  $ nebulaos llm keys create --name my-key --type personal       Create personal key
+  $ nebulaos llm keys create --name svc-key --type service \\
+      --allowed-routes gpt4,claude                               Restrict to specific routes
+
+Note: The API key is displayed only once after creation. Save it securely.
+`).action(async (options) => {
+    try {
+      const api = getApiClient();
+      const name = options.name || await input3({ message: "Key name:" });
+      const type = options.type || await select({
+        message: "Key type:",
+        choices: [
+          { name: "personal", value: "personal" },
+          { name: "service", value: "service" }
+        ]
+      });
+      const body = { name, type };
+      if (options.allowedRoutes) {
+        body.allowedRoutes = options.allowedRoutes.split(",").map((s) => s.trim());
+      }
+      const { data } = await api.post("/llm-gateway/keys", body);
+      printSuccess(`API key '${name}' created successfully.`);
+      console.log(`
+${chalk21.bold("Key:")} ${data.key}`);
+      console.log(chalk21.yellow("\nSave this key now. It will not be shown again."));
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/llm-gateway/keys/revoke.ts
+import { Command as Command61 } from "commander";
+import { confirm as confirm5 } from "@inquirer/prompts";
+function createKeysRevokeCommand() {
+  const cmd = new Command61("revoke").description("Permanently revoke an LLM gateway API key").argument("<keyId>", "API key ID").option("-y, --yes", "Skip confirmation prompt").addHelpText("after", `
+Examples:
+  $ nebulaos llm keys revoke key-123       Revoke with confirmation prompt
+  $ nebulaos llm keys revoke key-123 -y    Revoke without confirmation
+`).action(async (keyId, options) => {
+    try {
+      if (!options.yes) {
+        const shouldProceed = await confirm5({
+          message: `Revoke API key '${keyId}'? This cannot be undone.`,
+          default: false
+        });
+        if (!shouldProceed) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      const api = getApiClient();
+      await api.delete(`/llm-gateway/keys/${keyId}`);
+      printSuccess(`API key '${keyId}' revoked successfully.`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/llm-gateway/keys/index.ts
+function createKeysCommand() {
+  const keys = new Command62("keys").description("Create, list, and revoke LLM gateway API keys");
+  keys.addCommand(createKeysListCommand());
+  keys.addCommand(createKeysCreateCommand());
+  keys.addCommand(createKeysRevokeCommand());
+  return keys;
+}
+
+// src/commands/llm-gateway/requests.ts
+import { Command as Command63 } from "commander";
+function createRequestsCommand() {
+  const cmd = new Command63("requests").description("List recent LLM gateway requests with token usage and cost details").option("--limit <number>", "Maximum number of requests to return", parseInt).option("--route <alias>", "Filter by route alias").option("--status <status>", "Filter by status (success or error)").addHelpText("after", `
+Examples:
+  $ nebulaos llm requests                       List recent requests
+  $ nebulaos llm requests --limit 10            Show last 10 requests
+  $ nebulaos llm requests --route my-route      Filter by route
+  $ nebulaos llm requests --status error         Show only failed requests
+  $ nebulaos llm requests -o json               Output as JSON
+`).action(async (options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const params = {};
+      if (options.limit) params.limit = String(options.limit);
+      if (options.route) params.routeAlias = options.route;
+      if (options.status) params.status = options.status;
+      const { data } = await api.get("/llm-gateway/requests", { params });
+      output(format, {
+        table: {
+          headers: ["Request ID", "Timestamp", "Route", "Model", "Tokens", "Duration (ms)", "Status", "Cost"],
+          rows: data.map((r) => [
+            r.requestId.substring(0, 12) + "...",
+            new Date(r.timestamp).toLocaleString(),
+            r.routeAlias,
+            r.modelFinal,
+            r.totalTokens != null ? String(r.totalTokens) : "-",
+            r.durationMs != null ? String(r.durationMs) : "-",
+            r.status,
+            r.costUsd != null ? `$${r.costUsd.toFixed(4)}` : "-"
+          ])
+        },
+        data,
+        ids: data.map((r) => r.requestId)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/llm-gateway/usage.ts
+import { Command as Command64 } from "commander";
+function createUsageCommand() {
+  const cmd = new Command64("usage").description("Show aggregated LLM gateway usage statistics (tokens and costs)").addHelpText("after", `
+Examples:
+  $ nebulaos llm usage              Show usage summary
+  $ nebulaos llm usage -o json      Output as JSON
+  $ nebulaos llm usage -o yaml      Output as YAML
+`).action(async (_options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const { data } = await api.get("/llm-gateway/usage");
+      output(format, {
+        table: {
+          headers: ["Date", "Route", "Model", "Tokens", "Cost", "Status"],
+          rows: data.map((u) => [
+            u.date,
+            u.route,
+            u.model,
+            String(u.tokens),
+            u.costUsd != null ? `$${u.costUsd.toFixed(4)}` : "-",
+            u.status
+          ])
+        },
+        data,
+        ids: data.map((u) => `${u.date}-${u.route}`)
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/llm-gateway/catalog.ts
+import { Command as Command65 } from "commander";
+function createCatalogCommand() {
+  const cmd = new Command65("catalog").description("Browse available LLM models with pricing and provider info").option("--search <query>", "Search models by name").option("--provider <provider>", "Filter by provider").option("--page <number>", "Page number", parseInt).option("--limit <number>", "Items per page", parseInt).addHelpText("after", `
+Examples:
+  $ nebulaos llm catalog                           List all available models
+  $ nebulaos llm catalog --search gpt-4            Search for GPT-4 models
+  $ nebulaos llm catalog --provider openai          Show only OpenAI models
+  $ nebulaos llm catalog --provider anthropic -o json  Output Anthropic models as JSON
+`).action(async (options, command) => {
+    try {
+      const globalOpts = command.optsWithGlobals();
+      const format = resolveFormat(globalOpts.output);
+      const api = getApiClient();
+      const params = {};
+      if (options.search) params.q = options.search;
+      if (options.provider) params.provider = options.provider;
+      if (options.page) params.page = String(options.page);
+      if (options.limit) params.limit = String(options.limit);
+      const { data } = await api.get("/llm-gateway/catalog", { params });
+      if (format === "table") {
+        output(format, {
+          table: {
+            headers: ["Model", "Provider", "Modality", "Input Price", "Output Price", "Status"],
+            rows: data.items.map((m) => [
+              m.model,
+              m.provider,
+              m.modality,
+              m.priceInput != null ? `$${m.priceInput}` : "-",
+              m.priceOutput != null ? `$${m.priceOutput}` : "-",
+              m.status
+            ])
+          },
+          data: data.items,
+          ids: data.items.map((m) => m.model)
+        });
+        console.log(`
+Page ${data.page} of ${Math.ceil(data.total / data.limit)} (${data.total} total models)`);
+      } else {
+        output(format, {
+          table: { headers: [], rows: [] },
+          data,
+          ids: data.items.map((m) => m.model)
+        });
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/llm-gateway/index.ts
+function createLlmGatewayCommand() {
+  const llmGateway = new Command66("llm-gateway").alias("llm").description("Manage LLM Gateway routes, API keys, model catalog, and usage");
+  llmGateway.addCommand(createRoutesCommand());
+  llmGateway.addCommand(createKeysCommand());
+  llmGateway.addCommand(createRequestsCommand());
+  llmGateway.addCommand(createUsageCommand());
+  llmGateway.addCommand(createCatalogCommand());
+  return llmGateway;
+}
+
+// src/program.ts
+function createProgram() {
+  const program = new Command67();
+  program.name("nebulaos").description("NebulaOS CLI - Manage your AI agents, workflows, and resources").version("0.1.0").configureHelp({
+    sortSubcommands: true,
+    sortOptions: true
+  });
+  addGlobalFlags(program);
+  program.exitOverride();
+  program.hook("preAction", (_thisCommand, actionCommand) => {
+    const opts = actionCommand.optsWithGlobals();
+    if (opts.noColor) {
+      process.env.NO_COLOR = "1";
+    }
+    if (opts.verbose) {
+      process.env.NEBULAOS_VERBOSE = "1";
+    }
+  });
+  program.addCommand(createAuthCommand());
+  program.addCommand(createOrgsCommand());
+  program.addCommand(createClientsCommand());
+  program.addCommand(createResourcesCommand());
+  program.addCommand(createExecutionCommand());
+  program.addCommand(createRagCommand());
+  program.addCommand(createFeaturesCommand());
+  program.addCommand(createObservabilityCommand());
+  program.addCommand(createConfigCommand());
+  program.addCommand(createLlmGatewayCommand());
+  process.on("uncaughtException", handleError);
+  process.on("unhandledRejection", (reason) => handleError(reason));
+  return program;
+}
+
+// src/bin/nebulaos.ts
+async function main() {
+  const program = createProgram();
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof CommanderError && error.code === "commander.helpDisplayed") {
+      process.exit(0);
+    }
+    if (error instanceof CommanderError && error.code === "commander.version") {
+      process.exit(0);
+    }
+    handleError(error);
+  }
+}
+main();
+//# sourceMappingURL=nebulaos.js.map