@protoboxai/cli 1.0.0

package/dist/commands/toolsets.js

@@ -0,0 +1,464 @@
+import { Command } from "commander";
+import { readFile } from "fs/promises";
+import { confirm } from "@inquirer/prompts";
+import ora from "ora";
+import chalk from "chalk";
+import { createSdk } from "../utils/sdk-factory.js";
+import {
+  printSuccess,
+  printError,
+  printInfo,
+  printLabel,
+  printBlank,
+  printSimpleTable,
+  isJsonOutput,
+  printJson,
+  formatDate
+} from "../utils/output.js";
+const TOOLSET_TEMPLATE = {
+  name: "my-toolset",
+  description: "A curated collection of tools for a specific use case",
+  tools: ["tool-id-1", "tool-id-2"],
+  toolOverrides: {
+    "tool-id-1": {
+      name: "custom_name",
+      description: "Override description for this tool"
+    }
+  },
+  isEnabled: true,
+  tags: ["production", "customer-facing"]
+};
+function createToolsetsCommand() {
+  const toolsets = new Command("toolsets").description("Manage MCP toolsets (collections of tools)").addHelpText(
+    "after",
+    `
+What are Toolsets?
+  Toolsets group multiple tools together and allow you to customize how they
+  appear to AI agents. Use toolsets to:
+  - Create curated tool collections for specific use cases
+  - Override tool names/descriptions per context
+  - Enable/disable entire groups of tools at once
+
+Examples:
+  $ chanl toolsets list                    # List all toolsets
+  $ chanl toolsets create -f toolset.json  # Create new toolset
+  $ chanl toolsets add-tools <id> -t id1,id2  # Add tools to toolset`
+  );
+  toolsets.command("list").description("List all toolsets in the workspace").option("-e, --enabled", "Show only enabled toolsets").option("-d, --disabled", "Show only disabled toolsets").option("--tag <tag>", "Filter by tag").option("-s, --search <search>", "Search by name or description").option("-l, --limit <number>", "Items per page (default: 20)", "20").option("-p, --page <number>", "Page number (default: 1)", "1").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl toolsets list                    # List all
+  $ chanl toolsets list --enabled          # Only enabled
+  $ chanl toolsets list --search "api"     # Search by name`
+  ).action(handleToolsetsList);
+  toolsets.command("get <id>").description("Get detailed info about a toolset").addHelpText(
+    "after",
+    `
+Example:
+  $ chanl toolsets get 507f1f77bcf86cd799439011`
+  ).action(handleToolsetsGet);
+  toolsets.command("create").description("Create a new toolset from JSON file").option("-f, --file <path>", "Path to JSON file with toolset definition").option("--template", "Output a sample JSON template").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl toolsets create --template > my-toolset.json  # Generate template
+  $ chanl toolsets create -f my-toolset.json            # Create from file
+
+Required JSON fields:
+  name          Toolset name
+  description   What this toolset is for
+  tools         Array of tool IDs to include
+
+Optional fields:
+  toolOverrides Override name/description per tool
+  isEnabled     Enable immediately (default: true)
+  tags          Array of category tags`
+  ).action(handleToolsetsCreate);
+  toolsets.command("update <id>").description("Update a toolset from JSON file").requiredOption("-f, --file <path>", "Path to JSON file with updates").addHelpText(
+    "after",
+    `
+Example:
+  $ chanl toolsets update 507f1f77bcf86cd799439011 -f updates.json`
+  ).action(handleToolsetsUpdate);
+  toolsets.command("delete <id>").description("Delete a toolset permanently").option("-y, --yes", "Skip confirmation prompt").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl toolsets delete 507f1f77bcf86cd799439011       # With confirmation
+  $ chanl toolsets delete 507f1f77bcf86cd799439011 -y    # Skip confirmation`
+  ).action(handleToolsetsDelete);
+  toolsets.command("enable <id>").description("Enable a toolset (makes its tools available)").action(handleToolsetsEnable);
+  toolsets.command("disable <id>").description("Disable a toolset (hides its tools)").action(handleToolsetsDisable);
+  toolsets.command("add-tools <id>").description("Add tools to an existing toolset").requiredOption("-t, --tools <ids>", "Comma-separated tool IDs").addHelpText(
+    "after",
+    `
+Example:
+  $ chanl toolsets add-tools 507f1f77bcf86cd799439011 -t tool1,tool2,tool3`
+  ).action(handleToolsetsAddTools);
+  toolsets.command("remove-tools <id>").description("Remove tools from a toolset").requiredOption("-t, --tools <ids>", "Comma-separated tool IDs").addHelpText(
+    "after",
+    `
+Example:
+  $ chanl toolsets remove-tools 507f1f77bcf86cd799439011 -t tool1,tool2`
+  ).action(handleToolsetsRemoveTools);
+  return toolsets;
+}
+async function handleToolsetsList(options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching toolsets...").start();
+  try {
+    let enabled;
+    if (options.enabled) enabled = true;
+    else if (options.disabled) enabled = false;
+    const response = await sdk.toolsets.list({
+      enabled,
+      tag: options.tag,
+      search: options.search,
+      limit: parseInt(options.limit, 10),
+      page: parseInt(options.page, 10)
+    });
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch toolsets", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const toolsets = response.data.items || response.data.data || [];
+    const total = response.data.total ?? response.data.pagination?.total ?? toolsets.length;
+    const pagination = response.data.pagination || {
+      page: parseInt(options.page, 10),
+      limit: parseInt(options.limit, 10),
+      totalPages: Math.ceil(total / parseInt(options.limit, 10)),
+      hasNext: false,
+      hasPrev: false
+    };
+    if (isJsonOutput()) {
+      printJson({ toolsets, total, pagination });
+      return;
+    }
+    if (toolsets.length === 0) {
+      printInfo("No toolsets found");
+      return;
+    }
+    printBlank();
+    printSimpleTable(
+      ["Name", "Tool Count", "Enabled", "Tags", "Version"],
+      toolsets.map((toolset) => [
+        toolset.name,
+        (toolset.toolCount ?? toolset.tools?.length ?? 0).toString(),
+        toolset.enabled ? chalk.green("Yes") : chalk.red("No"),
+        toolset.tags && toolset.tags.length > 0 ? toolset.tags.join(", ") : "-",
+        toolset.version
+      ])
+    );
+    printBlank();
+    printInfo(`Total: ${total} toolsets (Page ${pagination.page} of ${pagination.totalPages})`);
+  } catch (error) {
+    spinner.fail("Failed to fetch toolsets");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsetsGet(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching toolset...").start();
+  try {
+    const response = await sdk.toolsets.get(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch toolset", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const toolset = response.data;
+    if (isJsonOutput()) {
+      printJson(toolset);
+      return;
+    }
+    printBlank();
+    printToolsetDetails(toolset);
+  } catch (error) {
+    spinner.fail("Failed to fetch toolset");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsetsCreate(options) {
+  if (options.template) {
+    console.log(JSON.stringify(TOOLSET_TEMPLATE, null, 2));
+    return;
+  }
+  if (!options.file) {
+    printError("Missing required option", "Use '-f, --file <path>' or '--template' for sample JSON");
+    printInfo("Run 'chanl toolsets create --help' for usage");
+    process.exitCode = 1;
+    return;
+  }
+  const sdk = createSdk();
+  if (!sdk) return;
+  let input;
+  try {
+    const content = await readFile(options.file, "utf-8");
+    input = JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Failed to read file", message);
+    process.exitCode = 1;
+    return;
+  }
+  const spinner = ora("Creating toolset...").start();
+  try {
+    const response = await sdk.toolsets.create(input);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to create toolset", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const toolset = response.data;
+    if (isJsonOutput()) {
+      printJson({ success: true, toolset });
+      return;
+    }
+    printSuccess(`Created toolset: ${toolset.name} (${toolset.id})`);
+  } catch (error) {
+    spinner.fail("Failed to create toolset");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsetsUpdate(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  let input;
+  try {
+    const content = await readFile(options.file, "utf-8");
+    input = JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Failed to read file", message);
+    process.exitCode = 1;
+    return;
+  }
+  const spinner = ora("Updating toolset...").start();
+  try {
+    const response = await sdk.toolsets.update(id, input);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to update toolset", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const toolset = response.data;
+    if (isJsonOutput()) {
+      printJson({ success: true, toolset });
+      return;
+    }
+    printSuccess(`Updated toolset: ${toolset.name} (${toolset.id})`);
+  } catch (error) {
+    spinner.fail("Failed to update toolset");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsetsDelete(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  if (!options.yes) {
+    try {
+      const confirmed = await confirm({
+        message: `Are you sure you want to delete toolset '${id}'?`,
+        default: false
+      });
+      if (!confirmed) {
+        printInfo("Deletion cancelled");
+        return;
+      }
+    } catch {
+      printBlank();
+      printInfo("Deletion cancelled");
+      return;
+    }
+  }
+  const spinner = ora("Deleting toolset...").start();
+  try {
+    const response = await sdk.toolsets.delete(id);
+    spinner.stop();
+    if (!response.success) {
+      printError("Failed to delete toolset", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson({ success: true, deleted: true, id });
+      return;
+    }
+    printSuccess(`Deleted toolset: ${id}`);
+  } catch (error) {
+    spinner.fail("Failed to delete toolset");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsetsEnable(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Enabling toolset...").start();
+  try {
+    const response = await sdk.toolsets.enable(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to enable toolset", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const toolset = response.data;
+    if (isJsonOutput()) {
+      printJson({ success: true, toolset });
+      return;
+    }
+    printSuccess(`Enabled toolset: ${toolset.name} (${toolset.id})`);
+  } catch (error) {
+    spinner.fail("Failed to enable toolset");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsetsDisable(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Disabling toolset...").start();
+  try {
+    const response = await sdk.toolsets.disable(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to disable toolset", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const toolset = response.data;
+    if (isJsonOutput()) {
+      printJson({ success: true, toolset });
+      return;
+    }
+    printSuccess(`Disabled toolset: ${toolset.name} (${toolset.id})`);
+  } catch (error) {
+    spinner.fail("Failed to disable toolset");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsetsAddTools(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const toolIds = options.tools.split(",").map((t) => t.trim()).filter(Boolean);
+  if (toolIds.length === 0) {
+    printError("No tool IDs provided", "Provide tool IDs with --tools flag");
+    process.exitCode = 1;
+    return;
+  }
+  const spinner = ora("Adding tools to toolset...").start();
+  try {
+    const response = await sdk.toolsets.manageTools(id, { add: toolIds });
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to add tools", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const toolset = response.data;
+    if (isJsonOutput()) {
+      printJson({ success: true, toolset });
+      return;
+    }
+    printSuccess(`Added ${toolIds.length} tool(s) to toolset: ${toolset.name}`);
+    printInfo(`Toolset now has ${toolset.toolCount} tool(s)`);
+  } catch (error) {
+    spinner.fail("Failed to add tools");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsetsRemoveTools(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const toolIds = options.tools.split(",").map((t) => t.trim()).filter(Boolean);
+  if (toolIds.length === 0) {
+    printError("No tool IDs provided", "Provide tool IDs with --tools flag");
+    process.exitCode = 1;
+    return;
+  }
+  const spinner = ora("Removing tools from toolset...").start();
+  try {
+    const response = await sdk.toolsets.manageTools(id, { remove: toolIds });
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to remove tools", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const toolset = response.data;
+    if (isJsonOutput()) {
+      printJson({ success: true, toolset });
+      return;
+    }
+    printSuccess(`Removed ${toolIds.length} tool(s) from toolset: ${toolset.name}`);
+    printInfo(`Toolset now has ${toolset.toolCount} tool(s)`);
+  } catch (error) {
+    spinner.fail("Failed to remove tools");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+function printToolsetDetails(toolset) {
+  printLabel("Name", toolset.name);
+  printLabel("ID", toolset.id);
+  printLabel("Description", toolset.description);
+  printLabel("Version", toolset.version);
+  printLabel("Enabled", toolset.enabled ? chalk.green("Yes") : chalk.red("No"));
+  printLabel("Public", toolset.isPublic ? chalk.green("Yes") : chalk.red("No"));
+  if (toolset.registryId) {
+    printLabel("Registry ID", toolset.registryId);
+  }
+  if (toolset.tags && toolset.tags.length > 0) {
+    printLabel("Tags", toolset.tags.join(", "));
+  }
+  printBlank();
+  printInfo(`Tools (${toolset.toolCount}):`);
+  if (toolset.tools.length > 0) {
+    for (const toolId of toolset.tools) {
+      console.log(chalk.gray(`  - ${toolId}`));
+    }
+  } else {
+    console.log(chalk.gray("  No tools in this toolset"));
+  }
+  if (toolset.toolOverrides && Object.keys(toolset.toolOverrides).length > 0) {
+    printBlank();
+    printInfo("Tool Overrides:");
+    for (const [toolId, override] of Object.entries(toolset.toolOverrides)) {
+      console.log(chalk.gray(`  ${toolId}:`));
+      if (override.name) console.log(chalk.gray(`    name: ${override.name}`));
+      if (override.description) console.log(chalk.gray(`    description: ${override.description}`));
+    }
+  }
+  printBlank();
+  printLabel("Created", formatDate(toolset.createdAt));
+  printLabel("Updated", formatDate(toolset.updatedAt));
+  printBlank();
+}
+export {
+  createToolsetsCommand
+};
+//# sourceMappingURL=toolsets.js.map

package/dist/commands/workspaces.js

@@ -0,0 +1,170 @@
+import { Command } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import { createSdk } from "../utils/sdk-factory.js";
+import { configStore } from "../utils/config-store.js";
+import {
+  printError,
+  printSuccess,
+  printInfo,
+  printBlank,
+  printSimpleTable,
+  printLabel,
+  isJsonOutput,
+  printJson,
+  formatDate
+} from "../utils/output.js";
+function createWorkspacesCommand() {
+  const workspaces = new Command("workspaces").description("Manage workspaces").addHelpText(
+    "after",
+    `
+What are Workspaces?
+  Workspaces are isolated environments for organizing agents, tools, and
+  configurations. Switch between workspaces to manage different projects.
+
+Quick Start:
+  $ chanl workspaces list                     # List your workspaces
+  $ chanl workspaces get <id>                 # View workspace details
+  $ chanl workspaces use <id>                 # Set active workspace`
+  );
+  workspaces.command("list").description("List workspaces").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl workspaces list                     # List all workspaces
+  $ chanl workspaces list --json              # Output as JSON`
+  ).action(handleWorkspacesList);
+  workspaces.command("get <id>").description("Get workspace details").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl workspaces get ws_abc123            # Get workspace details
+  $ chanl workspaces get ws_abc123 --json     # Output as JSON`
+  ).action(handleWorkspacesGet);
+  workspaces.command("use <id>").description("Set active workspace (saves to config)").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl workspaces use ws_abc123            # Switch to workspace
+
+This saves the workspace ID to your CLI config. All subsequent commands
+will use this workspace by default.`
+  ).action(handleWorkspacesUse);
+  return workspaces;
+}
+async function handleWorkspacesList() {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching workspaces...").start();
+  try {
+    const response = await sdk.workspace.getAll();
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch workspaces", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const workspaces = Array.isArray(response.data) ? response.data : [];
+    const currentWorkspaceId = configStore.getWorkspaceId();
+    if (isJsonOutput()) {
+      printJson(workspaces);
+      return;
+    }
+    if (workspaces.length === 0) {
+      printInfo("No workspaces found");
+      return;
+    }
+    printBlank();
+    printSimpleTable(
+      ["", "ID", "Name", "Description", "Created"],
+      workspaces.map((ws) => [
+        ws.id === currentWorkspaceId ? chalk.green("*") : " ",
+        ws.id,
+        (ws.name || "Untitled").slice(0, 30),
+        (ws.description || "-").slice(0, 40),
+        formatDate(ws.createdAt)
+      ])
+    );
+    printBlank();
+    if (currentWorkspaceId) {
+      printInfo(`Active workspace: ${currentWorkspaceId}`);
+    }
+    printInfo(`Total: ${workspaces.length} workspaces`);
+  } catch (error) {
+    spinner.fail("Failed to fetch workspaces");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleWorkspacesGet(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching workspace...").start();
+  try {
+    const response = await sdk.workspace.getById(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch workspace", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const workspace = response.data;
+    if (isJsonOutput()) {
+      printJson(workspace);
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold("Workspace Details:"));
+    printLabel("ID", workspace.id);
+    printLabel("Name", workspace.name);
+    if (workspace.description) printLabel("Description", workspace.description);
+    if (workspace.createdAt) printLabel("Created", formatDate(workspace.createdAt));
+    if (workspace.updatedAt) printLabel("Updated", formatDate(workspace.updatedAt));
+    const currentWorkspaceId = configStore.getWorkspaceId();
+    if (workspace.id === currentWorkspaceId) {
+      printBlank();
+      printInfo("This is your active workspace");
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to fetch workspace");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleWorkspacesUse(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Verifying workspace...").start();
+  try {
+    const response = await sdk.workspace.getById(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Workspace not found", response.message || `Could not find workspace: ${id}`);
+      process.exitCode = 1;
+      return;
+    }
+    const workspace = response.data;
+    configStore.setWorkspaceId(id);
+    if (isJsonOutput()) {
+      printJson({
+        success: true,
+        workspaceId: id,
+        name: workspace.name
+      });
+      return;
+    }
+    printSuccess(`Active workspace set to: ${workspace.name} (${id})`);
+  } catch (error) {
+    spinner.fail("Failed to set workspace");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+export {
+  createWorkspacesCommand
+};
+//# sourceMappingURL=workspaces.js.map

package/dist/index.js

@@ -0,0 +1,6 @@
+import { run } from "./cli.js";
+run().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map