@robinmordasiewicz/f5xc-xcsh 6.46.0 → 6.48.0

package/dist/index.js

@@ -45354,8 +45354,8 @@ function getLogoModeFromEnv(envPrefix) {
 var CLI_NAME = "xcsh";
 var CLI_FULL_NAME = "F5 Distributed Cloud Shell";
 function getVersion() {
-  if ("6.46.0") {
-    return "6.46.0";
+  if ("6.48.0") {
+    return "6.48.0";
   }
   if (process.env.XCSH_VERSION) {
     return process.env.XCSH_VERSION;
@@ -47744,6 +47744,24 @@ var DebugProtocolImpl = class {
       stack: error instanceof Error ? error.stack : void 0
     });
   }
+  /**
+   * Emit headless mode event
+   */
+  headless(event, data = {}) {
+    this.emit("headless", event, data);
+  }
+  /**
+   * Emit command execution event
+   */
+  command(event, data = {}) {
+    this.emit("command", event, data);
+  }
+  /**
+   * Emit completion event
+   */
+  completion(event, data = {}) {
+    this.emit("completion", event, data);
+  }
   /**
    * Get all captured events
    */
@@ -51207,6 +51225,9 @@ function isCustomDomain(name) {
   const canonical = resolveDomainAlias(name);
   return customDomains.has(canonical);
 }
+function getDomainAliases() {
+  return new Map(domainAliases);
+}
 
 // src/extensions/types.ts
 var RESERVED_API_ACTIONS = /* @__PURE__ */ new Set([
@@ -53104,6 +53125,109 @@ async function executeAPICommand(session, ctx, cmd) {
     };
   }
 }
+function getCommandSuggestions(input, session) {
+  const ctx = session.getContextPath();
+  const suggestions = [];
+  if (ctx.isRoot()) {
+    for (const domain of customDomains.all()) {
+      if (!input || domain.name.toLowerCase().startsWith(input.toLowerCase())) {
+        suggestions.push({
+          text: domain.name,
+          description: domain.description,
+          category: "domain"
+        });
+      }
+    }
+    for (const [alias, canonical] of getDomainAliases()) {
+      if (!input || alias.toLowerCase().startsWith(input.toLowerCase())) {
+        const domain = customDomains.get(canonical);
+        suggestions.push({
+          text: alias,
+          description: domain ? `${domain.description} (alias)` : `Alias for ${canonical}`,
+          category: "domain"
+        });
+      }
+    }
+    for (const extDomain of extensionRegistry.getExtendedDomains()) {
+      if (isCustomDomain(extDomain) || isValidDomain(extDomain)) continue;
+      if (!input || extDomain.toLowerCase().startsWith(input.toLowerCase())) {
+        const merged = extensionRegistry.getMergedDomain(extDomain);
+        suggestions.push({
+          text: extDomain,
+          description: merged?.description ?? `${extDomain} commands`,
+          category: "domain"
+        });
+      }
+    }
+    allDomains().forEach((domain) => {
+      if (isCustomDomain(domain)) return;
+      if (!input || domain.toLowerCase().startsWith(input.toLowerCase())) {
+        const merged = extensionRegistry.getMergedDomain(domain);
+        const hasExt = merged?.hasExtension ? " (+ext)" : "";
+        suggestions.push({
+          text: domain,
+          description: `Navigate to ${domain} domain${hasExt}`,
+          category: "domain"
+        });
+      }
+    });
+    BUILTIN_COMMANDS.forEach((cmd) => {
+      if (!input || cmd.toLowerCase().startsWith(input.toLowerCase())) {
+        suggestions.push({
+          text: cmd,
+          description: getBuiltinDescription(cmd),
+          category: "builtin"
+        });
+      }
+    });
+  }
+  if (ctx.isDomain() && !ctx.isAction()) {
+    const domain = ctx.domain ?? "";
+    const extCmds = extensionRegistry.getExtensionCommandNames(domain);
+    for (const cmd of extCmds) {
+      if (!input || cmd.toLowerCase().startsWith(input.toLowerCase())) {
+        const cmdDef = extensionRegistry.getExtensionCommand(
+          domain,
+          cmd
+        );
+        suggestions.push({
+          text: cmd,
+          description: cmdDef?.description ?? `${cmd} command`,
+          category: "extension"
+        });
+      }
+    }
+    const commonActions = ["list", "get", "create", "delete", "update"];
+    commonActions.forEach((action) => {
+      if (!input || action.toLowerCase().startsWith(input.toLowerCase())) {
+        suggestions.push({
+          text: action,
+          description: `${action} ${domain} resources`,
+          category: "action"
+        });
+      }
+    });
+  }
+  return suggestions;
+}
+function getBuiltinDescription(cmd) {
+  const descriptions = /* @__PURE__ */ new Map([
+    ["help", "Show help information"],
+    ["clear", "Clear the screen"],
+    ["quit", "Exit the shell"],
+    ["exit", "Navigate up or exit"],
+    ["back", "Navigate up one level"],
+    ["..", "Navigate up one level"],
+    ["root", "Navigate to root"],
+    ["/", "Navigate to root"],
+    ["context", "Show current context"],
+    ["ctx", "Show current context"],
+    ["history", "Show command history"],
+    ["version", "Show version info"],
+    ["domains", "List available domains"]
+  ]);
+  return descriptions.get(cmd) ?? "Built-in command";
+}
 
 // src/repl/App.tsx
 var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
@@ -53457,13 +53581,314 @@ function App2({ initialSession } = {}) {
   ] });
 }
 
+// src/headless/controller.ts
+import * as readline from "readline";
+
+// src/headless/protocol.ts
+function parseInput2(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const obj = parsed;
+    if (typeof obj.type !== "string") {
+      return null;
+    }
+    const validTypes = [
+      "command",
+      "completion_request",
+      "interrupt",
+      "exit"
+    ];
+    if (!validTypes.includes(obj.type)) {
+      return null;
+    }
+    const result = {
+      type: obj.type
+    };
+    if (typeof obj.value === "string") {
+      result.value = obj.value;
+    }
+    if (typeof obj.partial === "string") {
+      result.partial = obj.partial;
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function formatOutput2(output) {
+  return JSON.stringify({
+    ...output,
+    timestamp: output.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function createOutputMessage(content, format = "text") {
+  return {
+    type: "output",
+    content,
+    format,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createPromptMessage(prompt) {
+  return {
+    type: "prompt",
+    prompt,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createCompletionResponse(suggestions) {
+  return {
+    type: "completion_response",
+    suggestions,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createErrorMessage(message, code = 1) {
+  return {
+    type: "error",
+    message,
+    code,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createEventMessage(event, data = {}) {
+  return {
+    type: "event",
+    event,
+    data,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createExitMessage(code = 0) {
+  return {
+    type: "exit",
+    code,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/headless/controller.ts
+var HeadlessController = class {
+  session;
+  rl = null;
+  running = false;
+  constructor() {
+    this.session = new REPLSession();
+  }
+  /**
+   * Initialize the headless session
+   */
+  async initialize() {
+    await this.session.initialize();
+    debugProtocol.session("init", { mode: "headless" });
+    emitSessionState(this.session);
+    this.emitEvent(
+      "session_initialized",
+      this.getSessionState()
+    );
+  }
+  /**
+   * Get current session state for output
+   */
+  getSessionState() {
+    const ctx = this.session.getContextPath();
+    return {
+      authenticated: this.session.isAuthenticated(),
+      tokenValidated: this.session.isTokenValidated(),
+      namespace: this.session.getNamespace(),
+      serverUrl: this.session.getServerUrl(),
+      activeProfile: this.session.getActiveProfileName(),
+      context: {
+        domain: ctx.domain,
+        action: ctx.action
+      }
+    };
+  }
+  /**
+   * Build prompt string based on current context
+   */
+  buildPrompt() {
+    const ctx = this.session.getContextPath();
+    if (ctx.isRoot()) {
+      return `${CLI_NAME}> `;
+    }
+    if (ctx.isAction()) {
+      return `${CLI_NAME}:${ctx.domain}/${ctx.action}> `;
+    }
+    return `${CLI_NAME}:${ctx.domain}> `;
+  }
+  /**
+   * Write output to stdout
+   */
+  write(output) {
+    console.log(formatOutput2(output));
+  }
+  /**
+   * Emit an event
+   */
+  emitEvent(event, data = {}) {
+    this.write(createEventMessage(event, data));
+  }
+  /**
+   * Send prompt
+   */
+  sendPrompt() {
+    this.write(createPromptMessage(this.buildPrompt()));
+  }
+  /**
+   * Handle a command input
+   */
+  async handleCommand(value) {
+    debugProtocol.session("command_start", { command: value });
+    try {
+      const result = await executeCommand(value, this.session);
+      if (result.output.length > 0) {
+        const content = result.output.join("\n");
+        let format = "text";
+        if (content.startsWith("{") || content.startsWith("[")) {
+          format = "json";
+        } else if (content.includes(": ") && content.includes("\n")) {
+          format = "yaml";
+        }
+        this.write(createOutputMessage(content, format));
+      }
+      if (result.shouldExit) {
+        this.running = false;
+        this.write(createExitMessage(0));
+        return;
+      }
+      if (result.contextChanged) {
+        this.emitEvent("context_changed", {
+          context: {
+            domain: this.session.getContextPath().domain,
+            action: this.session.getContextPath().action
+          }
+        });
+      }
+      if (result.error) {
+        this.write(createErrorMessage(result.error, 1));
+      }
+      debugProtocol.session("command_complete", {
+        command: value,
+        success: !result.error
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.write(createErrorMessage(message, 1));
+      debugProtocol.error("command_failed", error, { command: value });
+    }
+    this.sendPrompt();
+  }
+  /**
+   * Handle completion request
+   */
+  handleCompletionRequest(partial) {
+    debugProtocol.session("completion_request", { partial });
+    const rawSuggestions = getCommandSuggestions(partial, this.session);
+    const suggestions = rawSuggestions.map((s) => ({
+      text: s.text,
+      description: s.description,
+      category: s.category
+    }));
+    this.write(createCompletionResponse(suggestions));
+  }
+  /**
+   * Handle interrupt signal
+   */
+  handleInterrupt() {
+    debugProtocol.session("interrupt", {});
+    this.emitEvent("interrupted", {});
+    this.sendPrompt();
+  }
+  /**
+   * Handle exit request
+   */
+  handleExit() {
+    this.running = false;
+    this.write(createExitMessage(0));
+  }
+  /**
+   * Process a single input message
+   */
+  async processInput(input) {
+    switch (input.type) {
+      case "command":
+        if (input.value !== void 0) {
+          await this.handleCommand(input.value);
+        } else {
+          this.write(
+            createErrorMessage(
+              'Missing "value" for command input',
+              1
+            )
+          );
+          this.sendPrompt();
+        }
+        break;
+      case "completion_request":
+        this.handleCompletionRequest(input.partial ?? "");
+        break;
+      case "interrupt":
+        this.handleInterrupt();
+        break;
+      case "exit":
+        this.handleExit();
+        break;
+      default:
+        this.write(
+          createErrorMessage(`Unknown input type: ${input.type}`, 1)
+        );
+        this.sendPrompt();
+    }
+  }
+  /**
+   * Run the headless controller
+   * Reads JSON messages from stdin, processes them, and writes responses to stdout
+   */
+  async run() {
+    await this.initialize();
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    this.running = true;
+    this.sendPrompt();
+    for await (const line of this.rl) {
+      if (!this.running) break;
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const input = parseInput2(trimmed);
+      if (!input) {
+        this.write(
+          createErrorMessage(`Invalid JSON input: ${trimmed}`, 1)
+        );
+        this.sendPrompt();
+        continue;
+      }
+      await this.processInput(input);
+    }
+    this.rl?.close();
+  }
+  /**
+   * Stop the controller
+   */
+  stop() {
+    this.running = false;
+    this.rl?.close();
+  }
+};
+
 // src/index.tsx
 var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
 var program2 = new Command();
 program2.configureHelp({
   formatHelp: () => formatRootHelp().join("\n")
 });
-program2.name(CLI_NAME).description("F5 Distributed Cloud Shell - Interactive CLI for F5 XC").version(CLI_VERSION, "-v, --version", "Show version number").option("--no-color", "Disable color output").option("--logo <mode>", "Logo display mode: image, ascii, none").option("-o, --output <format>", "Output format (json, yaml, table)").option("--spec", "Output command specification as JSON (for AI)").option("-h, --help", "Show help").argument("[command...]", "Command to execute non-interactively").allowUnknownOption(true).helpOption(false).action(
+program2.name(CLI_NAME).description("F5 Distributed Cloud Shell - Interactive CLI for F5 XC").version(CLI_VERSION, "-v, --version", "Show version number").option("--no-color", "Disable color output").option("--logo <mode>", "Logo display mode: image, ascii, none").option("-o, --output <format>", "Output format (json, yaml, table)").option("--spec", "Output command specification as JSON (for AI)").option("--headless", "Run in headless JSON protocol mode (for AI agents)").option("-h, --help", "Show help").argument("[command...]", "Command to execute non-interactively").allowUnknownOption(true).helpOption(false).action(
   async (commandArgs, options) => {
     if (options.help && commandArgs.length === 0) {
       formatRootHelp().forEach((line) => console.log(line));
@@ -53485,6 +53910,11 @@ program2.name(CLI_NAME).description("F5 Distributed Cloud Shell - Interactive CL
     if (options.spec && commandArgs.length > 0) {
       commandArgs.push("--spec");
     }
+    if (options.headless) {
+      const controller = new HeadlessController();
+      await controller.run();
+      return;
+    }
     if (commandArgs.length === 0) {
       if (!process.stdin.isTTY) {
         console.error(
@@ -53493,6 +53923,9 @@ program2.name(CLI_NAME).description("F5 Distributed Cloud Shell - Interactive CL
         console.error(
           "Use: xcsh <command> for non-interactive execution."
         );
+        console.error(
+          "Or use: xcsh --headless for AI agent JSON protocol mode."
+        );
         process.exit(1);
       }
       const cliLogoMode = options.logo && isValidLogoMode(options.logo) ? options.logo : void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robinmordasiewicz/f5xc-xcsh",
-  "version": "6.46.0",
+  "version": "6.48.0",
   "description": "F5 Distributed Cloud Shell - Interactive CLI for F5 XC",
   "type": "module",
   "bin": {