@protoboxai/cli 1.0.0

package/dist/commands/config.js

@@ -0,0 +1,237 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { configStore } from "../utils/config-store.js";
+import {
+  printSuccess,
+  printError,
+  printLabel,
+  printBlank,
+  printTable,
+  isJsonOutput,
+  printJson,
+  maskString
+} from "../utils/output.js";
+const VALID_KEYS = [
+  "apiKey",
+  "baseUrl",
+  "server",
+  "deployment",
+  "apiPrefix",
+  "workspaceId",
+  "defaultFormat"
+];
+const ENVIRONMENT_PRESETS = {
+  production: "https://platform.chanl.ai"
+};
+const KEY_DESCRIPTIONS = {
+  apiKey: "Chanl API key for authentication",
+  jwtToken: "JWT access token (from browser login)",
+  refreshToken: "JWT refresh token (from browser login)",
+  baseUrl: "Base URL for the Chanl API",
+  server: "Alias for baseUrl (e.g. http://localhost:18005)",
+  deployment: "local | cloud \u2014 local rewrites /api/v1 paths for OSS scenario servers",
+  apiPrefix: "Override API prefix; empty string for flat /scenarios routes",
+  workspaceId: "Default workspace ID",
+  appUrl: "App URL for browser-based flows",
+  defaultFormat: "Default output format (table or json)"
+};
+function createConfigCommand() {
+  const config = new Command("config").description("Manage CLI configuration");
+  config.command("list").description("List all configuration values").action(handleConfigList);
+  config.command("get <key>").description("Get a configuration value").action(handleConfigGet);
+  config.command("set <key> <value>").description("Set a configuration value").action(handleConfigSet);
+  config.command("delete <key>").alias("unset").description("Delete a configuration value").action(handleConfigDelete);
+  config.command("path").description("Show path to configuration file").action(handleConfigPath);
+  config.command("use <environment>").description("Reset to production API (or set a custom base URL with `config set baseUrl`)").action(handleConfigUse);
+  return config;
+}
+function handleConfigList() {
+  const allConfig = configStore.getAll();
+  if (isJsonOutput()) {
+    const safeConfig = {
+      ...allConfig,
+      apiKey: allConfig.apiKey ? maskString(allConfig.apiKey) : void 0
+    };
+    printJson(safeConfig);
+    return;
+  }
+  printBlank();
+  const rows = VALID_KEYS.map((key) => {
+    let value = allConfig[key];
+    const source = getConfigSource(key);
+    if (key === "apiKey" && typeof value === "string") {
+      value = maskString(value);
+    }
+    return {
+      key,
+      value: value ?? chalk.dim("(not set)"),
+      source,
+      description: KEY_DESCRIPTIONS[key]
+    };
+  });
+  printTable(
+    [
+      { header: "Key", key: "key", width: 15 },
+      { header: "Value", key: "value", width: 30 },
+      { header: "Source", key: "source", width: 10 }
+    ],
+    rows
+  );
+  printBlank();
+  printLabel("Config file", configStore.getPath());
+  printBlank();
+}
+function handleConfigGet(key) {
+  if (!isValidKey(key)) {
+    printError(`Unknown configuration key: ${key}`);
+    printBlank();
+    printLabel("Valid keys", VALID_KEYS.join(", "));
+    process.exitCode = 1;
+    return;
+  }
+  const typedKey = key;
+  let value;
+  switch (typedKey) {
+    case "apiKey":
+      value = configStore.getApiKey();
+      break;
+    case "baseUrl":
+      value = configStore.getBaseUrl();
+      break;
+    case "workspaceId":
+      value = configStore.getWorkspaceId();
+      break;
+    default:
+      value = configStore.get(typedKey);
+  }
+  if (isJsonOutput()) {
+    printJson({
+      key,
+      value: key === "apiKey" && value ? maskString(value) : value,
+      source: getConfigSource(typedKey)
+    });
+    return;
+  }
+  if (value === void 0) {
+    console.log(chalk.dim("(not set)"));
+    return;
+  }
+  if (key === "apiKey") {
+    console.log(maskString(value));
+  } else {
+    console.log(value);
+  }
+}
+function handleConfigSet(key, value) {
+  if (!isValidKey(key)) {
+    printError(`Unknown configuration key: ${key}`);
+    printBlank();
+    printLabel("Valid keys", VALID_KEYS.join(", "));
+    process.exitCode = 1;
+    return;
+  }
+  const typedKey = key;
+  if (typedKey === "defaultFormat") {
+    if (value !== "table" && value !== "json") {
+      printError(`Invalid format: ${value}`);
+      printLabel("Valid values", "table, json");
+      process.exitCode = 1;
+      return;
+    }
+  }
+  if (typedKey === "baseUrl") {
+    try {
+      new URL(value);
+    } catch {
+      printError(`Invalid URL: ${value}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  configStore.set(typedKey, value);
+  if (isJsonOutput()) {
+    printJson({
+      success: true,
+      key,
+      value: key === "apiKey" ? maskString(value) : value
+    });
+    return;
+  }
+  const displayValue = key === "apiKey" ? maskString(value) : value;
+  printSuccess(`Set ${key} = ${displayValue}`);
+}
+function handleConfigDelete(key) {
+  if (!isValidKey(key)) {
+    printError(`Unknown configuration key: ${key}`);
+    printBlank();
+    printLabel("Valid keys", VALID_KEYS.join(", "));
+    process.exitCode = 1;
+    return;
+  }
+  const typedKey = key;
+  if (!configStore.has(typedKey)) {
+    if (isJsonOutput()) {
+      printJson({ success: true, key, message: "Key was not set" });
+    } else {
+      printSuccess(`${key} was not set`);
+    }
+    return;
+  }
+  configStore.delete(typedKey);
+  if (isJsonOutput()) {
+    printJson({ success: true, key, message: "Deleted" });
+    return;
+  }
+  printSuccess(`Deleted ${key}`);
+}
+function handleConfigPath() {
+  const path = configStore.getPath();
+  if (isJsonOutput()) {
+    printJson({ path });
+    return;
+  }
+  console.log(path);
+}
+function isValidKey(key) {
+  return VALID_KEYS.includes(key);
+}
+function getConfigSource(key) {
+  const envVarMap = {
+    apiKey: "CHANL_API_KEY",
+    baseUrl: "CHANL_BASE_URL",
+    workspaceId: "CHANL_WORKSPACE_ID"
+  };
+  const envVar = envVarMap[key];
+  if (envVar && process.env[envVar]) {
+    return chalk.cyan("env");
+  }
+  if (configStore.has(key)) {
+    return chalk.green("config");
+  }
+  return chalk.dim("default");
+}
+function handleConfigUse(environment) {
+  const env = environment.toLowerCase();
+  const url = ENVIRONMENT_PRESETS[env];
+  if (!url) {
+    printError(`Unknown environment: ${environment}`);
+    printBlank();
+    printLabel("Available environments", Object.keys(ENVIRONMENT_PRESETS).join(", "));
+    process.exitCode = 1;
+    return;
+  }
+  configStore.set("baseUrl", url);
+  if (isJsonOutput()) {
+    printJson({
+      success: true,
+      environment: env,
+      baseUrl: url
+    });
+    return;
+  }
+  printSuccess(`Switched to ${env}: ${url}`);
+}
+export {
+  createConfigCommand
+};
+//# sourceMappingURL=config.js.map

package/dist/commands/health.js

@@ -0,0 +1,59 @@
+import { Command } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import { ChanlSDK } from "@protoboxai/sdk";
+import { configStore } from "../utils/config-store.js";
+import {
+  printSuccess,
+  printError,
+  printBlank,
+  isJsonOutput,
+  printJson
+} from "../utils/output.js";
+function createHealthCommand() {
+  const health = new Command("health").description("Check API health status").action(handleHealth);
+  return health;
+}
+async function handleHealth() {
+  const baseUrl = configStore.getBaseUrl();
+  const sdk = new ChanlSDK({ baseUrl });
+  const spinner = ora("Checking API health...").start();
+  try {
+    const response = await sdk.health.getHealth();
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("API health check failed", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson(response.data);
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold("API Health Status:"));
+    const isHealthy = response.data.status === "healthy" || response.data.status === "ok";
+    console.log(`  Status:   ${isHealthy ? chalk.green("\u2713 healthy") : chalk.red("\u2717 unhealthy")}`);
+    console.log(`  API URL:  ${baseUrl}`);
+    if (response.data.version) {
+      const version = typeof response.data.version === "object" ? response.data.version.commit || JSON.stringify(response.data.version) : response.data.version;
+      console.log(`  Version:  ${version}`);
+    }
+    if (response.data.uptime) {
+      console.log(`  Uptime:   ${Math.floor(response.data.uptime / 60)} min`);
+    }
+    printBlank();
+    if (isHealthy) {
+      printSuccess("API is healthy");
+    }
+  } catch (error) {
+    spinner.fail("Health check failed");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+export {
+  createHealthCommand
+};
+//# sourceMappingURL=health.js.map

package/dist/commands/index.js

@@ -0,0 +1,25 @@
+import { createAuthCommand, createLoginCommand, createLogoutCommand } from "./auth.js";
+import { createConfigCommand } from "./config.js";
+import { createToolsCommand } from "./tools.js";
+import { createToolsetsCommand } from "./toolsets.js";
+import { createHealthCommand } from "./health.js";
+import { createMcpCommand } from "./mcp.js";
+import { createKnowledgeCommand } from "./knowledge.js";
+import { createChatCommand } from "./chat.js";
+import { createPromptsCommand } from "./prompts.js";
+import { createWorkspacesCommand } from "./workspaces.js";
+export {
+  createAuthCommand,
+  createChatCommand,
+  createConfigCommand,
+  createHealthCommand,
+  createKnowledgeCommand,
+  createLoginCommand,
+  createLogoutCommand,
+  createMcpCommand,
+  createPromptsCommand,
+  createToolsCommand,
+  createToolsetsCommand,
+  createWorkspacesCommand
+};
+//# sourceMappingURL=index.js.map