enact-cli 1.0.1 → 1.0.4

package/dist/index.js

@@ -7049,7 +7049,7 @@ var require_public_api = __commonJS((exports) => {
 });
 
 // src/index.ts
-var import_picocolors8 = __toESM(require_picocolors(), 1);
+var import_picocolors10 = __toESM(require_picocolors(), 1);
 import { parseArgs } from "util";
 
 // node_modules/@clack/prompts/dist/index.mjs
@@ -7285,6 +7285,9 @@ function BD(e, u) {
 }
 var AD = globalThis.process.platform.startsWith("win");
 var S = Symbol("clack:cancel");
+function pD(e) {
+  return e === S;
+}
 function m(e, u) {
   const t = e;
   t.isTTY && t.setRawMode(u);
@@ -7755,55 +7758,82 @@ var $visitAsync = visit.visitAsync;
 
 // src/utils/help.ts
 var import_picocolors3 = __toESM(require_picocolors(), 1);
+import { readFileSync } from "fs";
+import { join } from "path";
+var __dirname = "/Users/keithgroves/projects/keithagroves/enact-project/enact-cli/src/utils";
+function getVersion() {
+  try {
+    const packageJsonPath = join(__dirname, "../../package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return packageJson.version || "0.1.0";
+  } catch (error) {
+    return "0.1.0";
+  }
+}
 function showHelp() {
+  const version = getVersion();
   console.log(`
-${import_picocolors3.default.bold("Enact CLI")} ${import_picocolors3.default.dim("v0.1.0")}
-${import_picocolors3.default.dim("A simple CLI tool to publish documents")}
+${import_picocolors3.default.bold("Enact CLI")} ${import_picocolors3.default.dim(`v${version}`)}
+${import_picocolors3.default.dim("A CLI tool for managing and publishing Enact tools")}
 
 ${import_picocolors3.default.bold("Usage:")}
   ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("<command>")} [options]
 
 ${import_picocolors3.default.bold("Commands:")}
-  ${import_picocolors3.default.green("publish")}    Publishes a document to a server
-  
-${import_picocolors3.default.bold("Options:")}
-  ${import_picocolors3.default.yellow("--help, -h")}    Show this help message
-  ${import_picocolors3.default.yellow("--version, -v")} Show version information
+  ${import_picocolors3.default.green("auth")}       Manage authentication (login, logout, status, token)
+  ${import_picocolors3.default.green("init")}       Create a new tool definition
+  ${import_picocolors3.default.green("publish")}    Publish a tool to the registry
+  ${import_picocolors3.default.green("search")}     Search for tools in the registry
+  ${import_picocolors3.default.green("remote")}     Manage remote servers (add, list, remove)
+  ${import_picocolors3.default.green("user")}       User operations (get public key)
+
+${import_picocolors3.default.bold("Global Options:")}
+  ${import_picocolors3.default.yellow("--help, -h")}     Show help message
+  ${import_picocolors3.default.yellow("--version, -v")}  Show version information
 
 ${import_picocolors3.default.bold("Examples:")}
-  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("publish")} document.md
-  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("publish")} ${import_picocolors3.default.yellow("--url")} https://example.com/api document.md
+  ${import_picocolors3.default.cyan("enact")}                    ${import_picocolors3.default.dim("# Interactive mode")}
+  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("search")} ${import_picocolors3.default.yellow("--tags")} web,api     ${import_picocolors3.default.dim("# Search tools by tags")}
+  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("publish")} my-tool.yaml        ${import_picocolors3.default.dim("# Publish a tool")}
+  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("auth")} login               ${import_picocolors3.default.dim("# Login with OAuth")}
+  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("init")} ${import_picocolors3.default.yellow("--minimal")}           ${import_picocolors3.default.dim("# Create minimal tool template")}
+
+${import_picocolors3.default.bold("More Help:")}
+  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("<command>")} ${import_picocolors3.default.yellow("--help")}          ${import_picocolors3.default.dim("# Show command-specific help")}
 `);
 }
 function showVersion() {
-  console.log(`enact-cli v0.1.0`);
+  const version = getVersion();
+  console.log(`enact-cli v${version}`);
 }
 function showPublishHelp() {
   console.log(`
 ${import_picocolors3.default.bold("Usage:")} ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("publish")} [options] [file]
 
-${import_picocolors3.default.bold("Publishes a document to a server")}
+${import_picocolors3.default.bold("Publish a tool to the Enact registry")}
 
 ${import_picocolors3.default.bold("Arguments:")}
-  ${import_picocolors3.default.green("file")}        The file to publish. If not provided, will prompt for a file.
+  ${import_picocolors3.default.blue("file")}         The tool definition file to publish (YAML format)
 
 ${import_picocolors3.default.bold("Options:")}
-  ${import_picocolors3.default.yellow("--help, -h")}    Show this help message
-  ${import_picocolors3.default.yellow("--url")}         Specify the server URL to publish to
+  ${import_picocolors3.default.yellow("--help, -h")}     Show this help message
+  ${import_picocolors3.default.yellow("--url")}          Specify the registry URL
+  ${import_picocolors3.default.yellow("--token, -t")}    Specify authentication token
 
 ${import_picocolors3.default.bold("Examples:")}
-  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("publish")} document.md
-  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("publish")} ${import_picocolors3.default.yellow("--url")} https://example.com/api document.md
+  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("publish")} my-tool.yaml
+  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("publish")} ${import_picocolors3.default.yellow("--url")} https://registry.example.com my-tool.yaml
+  ${import_picocolors3.default.cyan("enact")} ${import_picocolors3.default.green("publish")} ${import_picocolors3.default.yellow("--token")} abc123 my-tool.yaml
 `);
 }
 
 // src/utils/config.ts
 import { homedir } from "os";
-import { join } from "path";
+import { join as join2 } from "path";
 import { existsSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
-var CONFIG_DIR = join(homedir(), ".enact");
-var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = join2(homedir(), ".enact");
+var CONFIG_FILE = join2(CONFIG_DIR, "config.json");
 async function ensureConfig() {
   if (!existsSync(CONFIG_DIR)) {
     await mkdir(CONFIG_DIR, { recursive: true });
@@ -7855,18 +7885,304 @@ async function getDefaultUrl() {
 var import_picocolors4 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync2 } from "fs";
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { homedir as homedir2 } from "os";
 import { createServer } from "http";
 import { parse } from "url";
 import { randomBytes, createHash } from "crypto";
 import { exec } from "child_process";
 import { promisify } from "util";
+
+// src/api/enact-api.ts
+class EnactApiClient {
+  baseUrl;
+  supabaseUrl;
+  constructor(baseUrl = "https://enact.tools", supabaseUrl = "https://xjnhhxwxovjifdxdwzih.supabase.co") {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.supabaseUrl = supabaseUrl.replace(/\/$/, "");
+  }
+  async makeRequest(endpoint, options = {}, token, tokenType = "jwt") {
+    const url = endpoint.startsWith("http") ? endpoint : `${this.supabaseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    if (token) {
+      if (tokenType === "jwt") {
+        headers["Authorization"] = `Bearer ${token}`;
+      } else {
+        headers["X-API-Key"] = token;
+      }
+    }
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new EnactApiError(`${errorData.error || response.statusText}`, response.status, endpoint);
+    }
+    const responseData = await response.json();
+    if (true) {
+      console.log(`API Response for ${endpoint}:`, responseData);
+    }
+    return responseData;
+  }
+  async getTools(params) {
+    const searchParams = new URLSearchParams;
+    if (params?.limit)
+      searchParams.set("limit", params.limit.toString());
+    if (params?.offset)
+      searchParams.set("offset", params.offset.toString());
+    if (params?.tags)
+      searchParams.set("tags", params.tags.join(","));
+    if (params?.author)
+      searchParams.set("author", params.author);
+    const query = searchParams.toString();
+    const endpoint = `/functions/v1/tools${query ? `?${query}` : ""}`;
+    const response = await this.makeRequest(endpoint);
+    if (Array.isArray(response)) {
+      return response;
+    } else if (response.data && Array.isArray(response.data)) {
+      return response.data;
+    } else if (response.tools && Array.isArray(response.tools)) {
+      return response.tools;
+    } else {
+      console.warn("Unexpected response structure for getTools:", response);
+      return [];
+    }
+  }
+  async getTool(name) {
+    const endpoint = `/functions/v1/tools/${encodeURIComponent(name)}`;
+    return this.makeRequest(endpoint);
+  }
+  async getToolUsage(name) {
+    const endpoint = `/functions/v1/tools/${encodeURIComponent(name)}/usage`;
+    return this.makeRequest(endpoint);
+  }
+  async logToolUsage(name, usage) {
+    const endpoint = `/functions/v1/tools/${encodeURIComponent(name)}/usage`;
+    return this.makeRequest(endpoint, {
+      method: "POST",
+      body: JSON.stringify(usage)
+    });
+  }
+  async searchTools(query) {
+    const endpoint = "/functions/v1/tools-search";
+    const response = await this.makeRequest(endpoint, {
+      method: "POST",
+      body: JSON.stringify(query)
+    });
+    if (Array.isArray(response)) {
+      return response;
+    } else if (response.data && Array.isArray(response.data)) {
+      return response.data;
+    } else if (response.results && Array.isArray(response.results)) {
+      return response.results;
+    } else if (response.tools && Array.isArray(response.tools)) {
+      return response.tools;
+    } else {
+      console.warn("Unexpected response structure for searchTools:", response);
+      return [];
+    }
+  }
+  async publishTool(tool, token, tokenType = "cli") {
+    const endpoint = "/functions/v1/tools";
+    return this.makeRequest(endpoint, {
+      method: "POST",
+      body: JSON.stringify(tool)
+    }, token, tokenType);
+  }
+  async updateTool(name, tool, token, tokenType = "cli") {
+    const endpoint = `/functions/v1/tools/${encodeURIComponent(name)}`;
+    return this.makeRequest(endpoint, {
+      method: "PUT",
+      body: JSON.stringify(tool)
+    }, token, tokenType);
+  }
+  async deleteTool(name, token, tokenType = "cli") {
+    const endpoint = `/functions/v1/tools/${encodeURIComponent(name)}`;
+    return this.makeRequest(endpoint, {
+      method: "DELETE"
+    }, token, tokenType);
+  }
+  async createCLIToken(tokenData, jwtToken) {
+    const endpoint = "/functions/v1/cli-token";
+    return this.makeRequest(endpoint, {
+      method: "POST",
+      body: JSON.stringify(tokenData)
+    }, jwtToken, "jwt");
+  }
+  async getCLITokens(jwtToken) {
+    const endpoint = "/functions/v1/cli-token";
+    return this.makeRequest(endpoint, {
+      method: "GET"
+    }, jwtToken, "jwt");
+  }
+  async deleteCLIToken(tokenId, jwtToken) {
+    const endpoint = `/functions/v1/cli-token/${tokenId}`;
+    return this.makeRequest(endpoint, {
+      method: "DELETE"
+    }, jwtToken, "jwt");
+  }
+  async exchangeOAuthCode(oauthData) {
+    const endpoint = "/functions/v1/cli-oauth";
+    return this.makeRequest(endpoint, {
+      method: "POST",
+      body: JSON.stringify(oauthData)
+    });
+  }
+  async generateEmbeddings(data, token, tokenType = "cli") {
+    const endpoint = "/functions/v1/generate-embeddings";
+    return this.makeRequest(endpoint, {
+      method: "POST",
+      body: JSON.stringify(data)
+    }, token, tokenType);
+  }
+  async toolExists(name) {
+    try {
+      await this.getTool(name);
+      return true;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("404")) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async publishOrUpdateTool(tool, token, tokenType = "cli") {
+    let exists;
+    try {
+      exists = await this.toolExists(tool.name);
+    } catch (error) {
+      exists = false;
+    }
+    if (exists) {
+      const result = await this.updateTool(tool.name, tool, token, tokenType);
+      return { isUpdate: true, result };
+    } else {
+      const result = await this.publishTool(tool, token, tokenType);
+      return { isUpdate: false, result };
+    }
+  }
+  async getToolsByTags(tags, limit = 20) {
+    return this.searchTools({
+      query: tags.join(" "),
+      tags,
+      limit
+    });
+  }
+  async getToolsByAuthor(author, limit = 20) {
+    return this.getTools({
+      author,
+      limit
+    });
+  }
+  async getUserPublicKey(userId) {
+    const url = `${this.supabaseUrl}/functions/v1/tools/user/public-key/${userId}`;
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    };
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+        try {
+          const errorJson = JSON.parse(errorText);
+          if (errorJson.message) {
+            errorMessage = errorJson.message;
+          } else if (errorJson.error) {
+            errorMessage = errorJson.error;
+          }
+        } catch {}
+        throw new EnactApiError(errorMessage, response.status);
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      if (error instanceof EnactApiError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.message.includes("fetch")) {
+          throw new EnactApiError("Network error: Could not connect to Enact API", 0);
+        }
+        throw new EnactApiError(error.message, 0);
+      }
+      throw new EnactApiError("Unknown error occurred", 0);
+    }
+  }
+  generateOAuthUrl(options) {
+    const params = new URLSearchParams({
+      response_type: "code",
+      client_id: options.clientId,
+      redirect_uri: options.redirectUri,
+      scope: options.scope,
+      state: options.state,
+      code_challenge: options.codeChallenge,
+      code_challenge_method: options.codeChallengeMethod
+    });
+    return `${this.baseUrl}/auth/cli/oauth?${params.toString()}`;
+  }
+  validateTool(tool) {
+    const errors2 = [];
+    if (!tool.name || typeof tool.name !== "string") {
+      errors2.push("Tool name is required and must be a string");
+    } else if (!/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_\/-]+$/.test(tool.name)) {
+      errors2.push("Tool name must follow hierarchical format: org/category/tool-name");
+    }
+    if (!tool.description || typeof tool.description !== "string") {
+      errors2.push("Tool description is required and must be a string");
+    }
+    if (!tool.command || typeof tool.command !== "string") {
+      errors2.push("Tool command is required and must be a string");
+    }
+    if (tool.timeout && typeof tool.timeout === "string") {
+      if (!/^\d+[smh]$/.test(tool.timeout)) {
+        errors2.push('Timeout must be in Go duration format (e.g., "30s", "5m", "1h")');
+      }
+    }
+    if (tool.tags && !Array.isArray(tool.tags)) {
+      errors2.push("Tags must be an array of strings");
+    }
+    if (tool.inputSchema && typeof tool.inputSchema !== "object") {
+      errors2.push("inputSchema must be a valid JSON Schema object");
+    }
+    if (tool.outputSchema && typeof tool.outputSchema !== "object") {
+      errors2.push("outputSchema must be a valid JSON Schema object");
+    }
+    return {
+      valid: errors2.length === 0,
+      errors: errors2
+    };
+  }
+}
+var enactApi = new EnactApiClient;
+
+class EnactApiError extends Error {
+  statusCode;
+  endpoint;
+  constructor(message, statusCode, endpoint) {
+    super(message);
+    this.statusCode = statusCode;
+    this.endpoint = endpoint;
+    this.name = "EnactApiError";
+  }
+}
+function createEnactApiClient(baseUrl, supabaseUrl) {
+  return new EnactApiClient(baseUrl, supabaseUrl);
+}
+
+// src/commands/auth.ts
 var execAsync = promisify(exec);
-var CONFIG_DIR2 = join2(homedir2(), ".enact");
-var AUTH_FILE = join2(CONFIG_DIR2, "auth.json");
+var CONFIG_DIR2 = join3(homedir2(), ".enact");
+var AUTH_FILE = join3(CONFIG_DIR2, "auth.json");
 var DEFAULT_SERVER = "https://enact.tools";
-var SUPABASE_PROJECT_URL = "https://xjnhhxwxovjifdxdwzih.supabase.co";
 async function handleAuthCommand(args, options) {
   if (options.help || !args[0]) {
     console.log(`
@@ -7930,16 +8246,14 @@ async function handleLogin(serverUrl, callbackPort) {
     const codeChallenge = generateCodeChallenge(codeVerifier);
     const state = generateState();
     const redirectUri = `http://localhost:${callbackPort}/callback`;
-    const authParams = new URLSearchParams({
-      response_type: "code",
-      client_id: "enact-cli",
-      redirect_uri: redirectUri,
+    const authUrl = enactApi.generateOAuthUrl({
+      clientId: "enact-cli",
+      redirectUri,
       scope: "publish read write",
       state,
-      code_challenge: codeChallenge,
-      code_challenge_method: "S256"
+      codeChallenge,
+      codeChallengeMethod: "S256"
     });
-    const authUrl = `${serverUrl}/auth/cli/oauth?${authParams.toString()}`;
     const s = Y2();
     s.start("Starting OAuth flow...");
     let server = null;
@@ -8102,49 +8416,20 @@ async function startCallbackServerWithFallback(port, serverUrl, codeVerifier, st
   });
 }
 async function exchangeCodeForToken(code, redirectUri, codeVerifier, serverUrl) {
-  const tokenEndpoint = `${SUPABASE_PROJECT_URL}/functions/v1/cli-oauth`;
-  console.log(`Exchanging code for token at: ${tokenEndpoint}`);
+  console.log(`Exchanging code for token...`);
   console.log("Exchange params:", {
     code: code.substring(0, 8) + "...",
     redirectUri,
     codeVerifier: codeVerifier.substring(0, 8) + "..."
   });
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), 30000);
   try {
-    const tokenResponse = await fetch(tokenEndpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        grant_type: "authorization_code",
-        code,
-        redirect_uri: redirectUri,
-        client_id: "enact-cli",
-        code_verifier: codeVerifier
-      }),
-      signal: controller.signal
+    const tokenData = await enactApi.exchangeOAuthCode({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirectUri,
+      client_id: "enact-cli",
+      code_verifier: codeVerifier
     });
-    clearTimeout(timeoutId);
-    const responseText = await tokenResponse.text();
-    console.log("Token exchange response status:", tokenResponse.status);
-    if (!tokenResponse.ok) {
-      console.error("Token exchange failed with status:", tokenResponse.status);
-      console.error("Response body:", responseText);
-      throw new Error(`Token exchange failed (${tokenResponse.status}): ${responseText}`);
-    }
-    let tokenData;
-    try {
-      tokenData = JSON.parse(responseText);
-    } catch (parseError) {
-      console.error("Failed to parse token response as JSON:", responseText);
-      throw new Error(`Invalid JSON response from token endpoint`);
-    }
-    if (!tokenData.access_token) {
-      console.error("No access token in response:", tokenData);
-      throw new Error("No access token received from server");
-    }
     const expiresAt = new Date(Date.now() + tokenData.expires_in * 1000);
     await writeAuthConfig({
       token: tokenData.access_token,
@@ -8155,8 +8440,8 @@ async function exchangeCodeForToken(code, redirectUri, codeVerifier, serverUrl)
     });
     console.log("✓ Token stored successfully");
   } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error("Token exchange request timed out");
+    if (error instanceof EnactApiError) {
+      throw new Error(`Token exchange failed: ${error.message}`);
     }
     throw error;
   }
@@ -8295,15 +8580,13 @@ async function handlePublishCommand(args, options) {
     return;
   }
   Ie(import_picocolors5.default.bgBlue(import_picocolors5.default.white(" Publish Enact Tool ")));
-  let authHeaders;
+  let token;
   try {
     if (options.token) {
-      authHeaders = {
-        "Content-Type": "application/json",
-        "X-API-Key": options.token
-      };
+      token = options.token;
     } else {
-      authHeaders = await getAuthHeaders();
+      const authHeaders = await getAuthHeaders();
+      token = authHeaders["X-API-Key"];
     }
   } catch (error) {
     Se(import_picocolors5.default.red(`✗ Authentication required. Run "enact auth login" to authenticate.`));
@@ -8311,45 +8594,8 @@ async function handlePublishCommand(args, options) {
   }
   let filePath = args[0];
   if (!filePath) {
-    const history = await getHistory();
-    if (history.length > 0) {
-      const action = await ve({
-        message: "Select a tool manifest to publish:",
-        options: [
-          { value: "select", label: "Choose from recent files" },
-          { value: "new", label: "Specify a new file" }
-        ]
-      });
-      if (action === "select") {
-        const fileOptions = history.filter((file) => existsSync3(file) && isEnactFile(file)).map((file) => ({
-          value: file,
-          label: file
-        }));
-        if (fileOptions.length > 0) {
-          filePath = await ve({
-            message: "Select a tool manifest:",
-            options: fileOptions
-          });
-        } else {
-          Me("No recent Enact tool manifests found.", "History");
-          filePath = await he({
-            message: "Enter the path to the tool manifest (.yaml or .yml):",
-            validate: validateEnactFile
-          });
-        }
-      } else {
-        filePath = await he({
-          message: "Enter the path to the tool manifest (.yaml or .yml):",
-          validate: validateEnactFile
-        });
-      }
-    } else {
-      filePath = await he({
-        message: "Enter the path to the tool manifest (.yaml or .yml):",
-        validate: validateEnactFile
-      });
-    }
-    if (filePath === null) {
+    filePath = await getFilePathInteractively();
+    if (!filePath) {
       Se(import_picocolors5.default.yellow("Operation cancelled"));
       return;
     }
@@ -8364,9 +8610,11 @@ async function handlePublishCommand(args, options) {
   try {
     const content = await readFile3(filePath, "utf8");
     toolDefinition = $parse(content);
-    const validation = validateToolDefinition(toolDefinition);
-    if (validation) {
-      Se(import_picocolors5.default.red(`Invalid tool manifest: ${validation}`));
+    const validation = enactApi.validateTool(toolDefinition);
+    if (!validation.valid) {
+      Se(import_picocolors5.default.red(`Invalid tool manifest:
+${validation.errors.join(`
+`)}`));
       return;
     }
   } catch (error) {
@@ -8426,66 +8674,38 @@ Command: ${import_picocolors5.default.dim(toolDefinition.command)}`, "Tool Detai
   const spinner = Y2();
   spinner.start("Publishing tool to Enact registry");
   try {
-    let isUpdate = false;
-    try {
-      const checkResponse = await fetch(`${apiUrl}/${encodeURIComponent(toolDefinition.name)}`, {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-      if (checkResponse.ok) {
-        isUpdate = true;
-        spinner.message("Tool exists, updating...");
-      }
-    } catch (checkError) {}
-    const toolData = {
-      ...toolDefinition,
-      inputSchema: toolDefinition.inputSchema,
-      outputSchema: toolDefinition.outputSchema,
-      env: toolDefinition.env,
-      enact: toolDefinition.enact || "1.0.0"
-    };
-    const method = isUpdate ? "PUT" : "POST";
-    const url = isUpdate ? `${apiUrl}/${encodeURIComponent(toolDefinition.name)}` : apiUrl;
-    spinner.message(`Publishing to URL: ${url} with method: ${method}`);
-    const publishResponse = await fetch(url, {
-      method,
-      headers: authHeaders,
-      body: JSON.stringify(toolData)
-    });
-    if (!publishResponse.ok) {
-      const errorData = await publishResponse.json().catch(() => ({ error: "Unknown error" }));
-      if (publishResponse.status === 409) {
-        throw new Error(`Tool '${toolDefinition.name}' already exists. Use a different name or update the existing tool.`);
-      } else if (publishResponse.status === 400) {
-        throw new Error(`Invalid tool definition: ${errorData.error || "Bad request"}`);
-      } else {
-        throw new Error(`Publish failed (${publishResponse.status}): ${errorData.error || publishResponse.statusText}`);
-      }
-    }
-    const result = await publishResponse.json();
+    const apiClient = apiUrl ? createEnactApiClient(apiUrl) : enactApi;
+    Me(`Using API URL: ${import_picocolors5.default.cyan(apiClient.baseUrl)}`, "API Client");
+    const result = await apiClient.publishOrUpdateTool(toolDefinition, token, "cli");
     await addToHistory(filePath);
-    spinner.stop(`Tool ${isUpdate ? "updated" : "published"} successfully`);
-    let successMessage = `✓ ${import_picocolors5.default.bold(toolDefinition.name)} ${isUpdate ? "updated" : "published"} to Enact registry`;
-    if (result.tool?.id) {
+    spinner.stop(`Tool ${result.isUpdate ? "updated" : "published"} successfully`);
+    let successMessage = `✓ ${import_picocolors5.default.bold(toolDefinition.name)} ${result.isUpdate ? "updated" : "published"} to Enact registry`;
+    if (result.result?.tool?.id) {
       successMessage += `
-\uD83D\uDCC4 Tool ID: ${import_picocolors5.default.cyan(result.tool.id)}`;
+\uD83D\uDCC4 Tool ID: ${import_picocolors5.default.cyan(result.result.tool.id)}`;
     }
-    if (result.tool?.name) {
+    if (result.result?.tool?.name) {
       successMessage += `
-\uD83D\uDD27 Tool Name: ${import_picocolors5.default.blue(result.tool.name)}`;
+\uD83D\uDD27 Tool Name: ${import_picocolors5.default.blue(result.result.tool.name)}`;
     }
     successMessage += `
 \uD83D\uDD0D Discoverable via: "enact search ${toolDefinition.tags?.join(" ") || toolDefinition.name}"`;
     Se(import_picocolors5.default.green(successMessage));
   } catch (error) {
     spinner.stop("Failed to publish tool");
-    if (error instanceof Error) {
-      if (error.message.includes("401") || error.message.includes("403")) {
+    if (error instanceof EnactApiError) {
+      if (error.statusCode === 401 || error.statusCode === 403) {
         Me("Authentication failed. Your token may have expired.", "Error");
         Me('Run "enact auth login" to re-authenticate.', "Suggestion");
-      } else if (error.message.includes("ENOTFOUND") || error.message.includes("ECONNREFUSED")) {
+      } else if (error.statusCode === 409) {
+        Me(`Tool '${toolDefinition.name}' already exists and you don't have permission to update it.`, "Error");
+      } else if (error.statusCode === 400) {
+        Me(`Invalid tool definition: ${error.message}`, "Error");
+      } else {
+        Me(error.message, "Error");
+      }
+    } else if (error instanceof Error) {
+      if (error.message.includes("ENOTFOUND") || error.message.includes("ECONNREFUSED")) {
         Me("Could not connect to the Enact registry. Check your internet connection and registry URL.", "Error");
       } else {
         Me(error.message, "Error");
@@ -8494,6 +8714,46 @@ Command: ${import_picocolors5.default.dim(toolDefinition.command)}`, "Tool Detai
     Se(import_picocolors5.default.red("Publish failed"));
   }
 }
+async function getFilePathInteractively() {
+  const history = await getHistory();
+  if (history.length > 0) {
+    const action = await ve({
+      message: "Select a tool manifest to publish:",
+      options: [
+        { value: "select", label: "Choose from recent files" },
+        { value: "new", label: "Specify a new file" }
+      ]
+    });
+    if (action === "select") {
+      const fileOptions = history.filter((file) => existsSync3(file) && isEnactFile(file)).map((file) => ({
+        value: file,
+        label: file
+      }));
+      if (fileOptions.length > 0) {
+        return await ve({
+          message: "Select a tool manifest:",
+          options: fileOptions
+        });
+      } else {
+        Me("No recent Enact tool manifests found.", "History");
+        return await he({
+          message: "Enter the path to the tool manifest (.yaml or .yml):",
+          validate: validateEnactFile
+        });
+      }
+    } else {
+      return await he({
+        message: "Enter the path to the tool manifest (.yaml or .yml):",
+        validate: validateEnactFile
+      });
+    }
+  } else {
+    return await he({
+      message: "Enter the path to the tool manifest (.yaml or .yml):",
+      validate: validateEnactFile
+    });
+  }
+}
 function isEnactFile(filePath) {
   const ext = extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
@@ -8507,46 +8767,15 @@ function validateEnactFile(value) {
     return "File must be a YAML file (.yaml or .yml)";
   return;
 }
-function validateToolDefinition(tool) {
-  if (!tool)
-    return "Tool definition is required";
-  if (!tool.name || typeof tool.name !== "string") {
-    return "Tool name is required and must be a string";
-  }
-  if (!tool.description || typeof tool.description !== "string") {
-    return "Tool description is required and must be a string";
-  }
-  if (!tool.command || typeof tool.command !== "string") {
-    return "Tool command is required and must be a string";
-  }
-  if (!/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_\/-]+$/.test(tool.name)) {
-    return "Tool name must follow hierarchical format: org/category/tool-name";
-  }
-  if (tool.timeout && typeof tool.timeout === "string") {
-    if (!/^\d+[smh]$/.test(tool.timeout)) {
-      return 'Timeout must be in Go duration format (e.g., "30s", "5m", "1h")';
-    }
-  }
-  if (tool.tags && !Array.isArray(tool.tags)) {
-    return "Tags must be an array of strings";
-  }
-  if (tool.inputSchema && typeof tool.inputSchema !== "object") {
-    return "inputSchema must be a valid JSON Schema object";
-  }
-  if (tool.outputSchema && typeof tool.outputSchema !== "object") {
-    return "outputSchema must be a valid JSON Schema object";
-  }
-  return;
-}
 
 // src/commands/remote.ts
 var import_picocolors6 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync4 } from "fs";
 import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { homedir as homedir3 } from "os";
-var CONFIG_DIR3 = join3(homedir3(), ".enact");
-var CONFIG_FILE2 = join3(CONFIG_DIR3, "config.json");
+var CONFIG_DIR3 = join4(homedir3(), ".enact");
+var CONFIG_FILE2 = join4(CONFIG_DIR3, "config.json");
 async function handleRemoteCommand(args, options) {
   if (options.help || !args[0]) {
     console.log(`
@@ -9195,6 +9424,401 @@ function yamlStringify(obj, indent = 0) {
   return result;
 }
 
+// src/commands/search.ts
+var import_picocolors8 = __toESM(require_picocolors(), 1);
+async function handleSearchCommand(args, options) {
+  if (options.help) {
+    console.log(`
+Usage: enact search [query] [options]
+
+Search for Enact tools in the registry.
+
+Arguments:
+  query               Search query (keywords, tool names, descriptions)
+
+Options:
+  --help, -h          Show this help message
+  --limit <number>    Maximum number of results (default: 20)
+  --tags <tags>       Filter by tags (comma-separated)
+  --format <format>   Output format: table, json, list (default: table)
+  --author <author>   Filter by author
+
+Examples:
+  enact search "text processing"
+  enact search formatter --tags cli,text
+  enact search --author myorg
+  enact search prettier --limit 5 --format json
+`);
+    return;
+  }
+  if (args.length === 0 && !options.author) {
+    Ie(import_picocolors8.default.bgGreen(import_picocolors8.default.white(" Search Enact Tools ")));
+  }
+  let query = args.join(" ");
+  if (!query && !options.author) {
+    const queryResponse = await he({
+      message: "What are you looking for?",
+      placeholder: "Enter keywords, tool names, or descriptions...",
+      validate: (value) => {
+        if (!value.trim())
+          return "Please enter a search query";
+        return;
+      }
+    });
+    if (queryResponse === null) {
+      Se(import_picocolors8.default.yellow("Search cancelled"));
+      return;
+    }
+    query = queryResponse;
+  }
+  let limit = options.limit;
+  let tags = options.tags;
+  let format = options.format || "table";
+  let author = options.author;
+  if (args.length === 0 && !options.author) {
+    const addFilters = await ye({
+      message: "Add additional filters?",
+      initialValue: false
+    });
+    if (addFilters) {
+      const tagsInput = await he({
+        message: "Filter by tags (comma-separated, optional):",
+        placeholder: "cli, text, formatter"
+      });
+      if (tagsInput) {
+        tags = tagsInput.split(",").map((t) => t.trim()).filter((t) => t);
+      }
+      const authorInput = await he({
+        message: "Filter by author (optional):",
+        placeholder: "myorg, username"
+      });
+      if (authorInput) {
+        author = authorInput;
+      }
+      limit = await he({
+        message: "Maximum results:",
+        placeholder: "20",
+        initialValue: "20",
+        validate: (value) => {
+          const num = parseInt(value);
+          if (isNaN(num) || num < 1 || num > 100) {
+            return "Please enter a number between 1 and 100";
+          }
+          return;
+        }
+      }).then((val) => parseInt(val));
+      format = await ve({
+        message: "Output format:",
+        options: [
+          { value: "table", label: "Table (default)" },
+          { value: "list", label: "Simple list" },
+          { value: "json", label: "JSON output" }
+        ]
+      });
+    }
+  }
+  const spinner = Y2();
+  spinner.start("Searching tools...");
+  try {
+    let results;
+    if (author && !query) {
+      results = await enactApi.getToolsByAuthor(author, limit || 20);
+    } else if (query) {
+      results = await enactApi.searchTools({
+        query,
+        limit: limit || 20,
+        tags,
+        format
+      });
+    } else {
+      results = await enactApi.getTools({
+        limit: limit || 20,
+        tags,
+        author
+      });
+    }
+    spinner.stop(`Found ${results.length} tool${results.length === 1 ? "" : "s"}`);
+    if (results.length === 0) {
+      Me("No tools found matching your criteria.", "No Results");
+      Me(`Try:
+• Broader keywords
+• Removing filters
+• Different spelling`, "Suggestions");
+      Se("");
+      return;
+    }
+    if (format === "json") {
+      console.log(JSON.stringify(results, null, 2));
+    } else if (format === "list") {
+      displayResultsList(results);
+    } else {
+      displayResultsTable(results);
+    }
+    if (args.length === 0 && !options.author && results.length > 1) {
+      const viewDetail = await ye({
+        message: "View details for a specific tool?",
+        initialValue: false
+      });
+      if (viewDetail) {
+        const selectedTool = await ve({
+          message: "Select a tool to view details:",
+          options: results.map((tool) => ({
+            value: tool.name,
+            label: `${tool.name} - ${tool.description.substring(0, 60)}${tool.description.length > 60 ? "..." : ""}`
+          }))
+        });
+        if (selectedTool) {
+          await showToolDetails(selectedTool);
+        }
+      }
+    }
+    if (args.length === 0 && !options.author) {
+      Se(import_picocolors8.default.green("Search completed"));
+    }
+  } catch (error) {
+    spinner.stop("Search failed");
+    if (error instanceof EnactApiError) {
+      Me(error.message, "Error");
+    } else if (error instanceof Error) {
+      if (error.message.includes("ENOTFOUND") || error.message.includes("ECONNREFUSED")) {
+        Me("Could not connect to the Enact registry. Check your internet connection.", "Error");
+      } else {
+        Me(error.message, "Error");
+      }
+    }
+    if (args.length === 0 && !options.author) {
+      Se(import_picocolors8.default.red("Search failed"));
+    } else {
+      console.error(import_picocolors8.default.red(`Search failed: ${error.message}`));
+    }
+  }
+}
+function displayResultsTable(results) {
+  console.log(`
+` + import_picocolors8.default.bold("Search Results:"));
+  console.log("═".repeat(100));
+  const nameWidth = 25;
+  const descWidth = 50;
+  const tagsWidth = 20;
+  console.log(import_picocolors8.default.bold(import_picocolors8.default.cyan("NAME".padEnd(nameWidth))) + " │ " + import_picocolors8.default.bold(import_picocolors8.default.cyan("DESCRIPTION".padEnd(descWidth))) + " │ " + import_picocolors8.default.bold(import_picocolors8.default.cyan("TAGS".padEnd(tagsWidth))));
+  console.log("─".repeat(nameWidth) + "─┼─" + "─".repeat(descWidth) + "─┼─" + "─".repeat(tagsWidth));
+  results.forEach((tool) => {
+    const name = tool.name.length > nameWidth ? tool.name.substring(0, nameWidth - 3) + "..." : tool.name.padEnd(nameWidth);
+    const desc = tool.description.length > descWidth ? tool.description.substring(0, descWidth - 3) + "..." : tool.description.padEnd(descWidth);
+    const tags = (tool.tags || []).join(", ");
+    const tagsDisplay = tags.length > tagsWidth ? tags.substring(0, tagsWidth - 3) + "..." : tags.padEnd(tagsWidth);
+    console.log(import_picocolors8.default.green(name) + " │ " + import_picocolors8.default.dim(desc) + " │ " + import_picocolors8.default.yellow(tagsDisplay));
+  });
+  console.log("═".repeat(100));
+  console.log(import_picocolors8.default.dim(`Total: ${results.length} tool${results.length === 1 ? "" : "s"}`));
+}
+function displayResultsList(results) {
+  console.log(`
+` + import_picocolors8.default.bold("Search Results:"));
+  console.log("");
+  results.forEach((tool, index) => {
+    console.log(`${import_picocolors8.default.cyan(`${index + 1}.`)} ${import_picocolors8.default.bold(import_picocolors8.default.green(tool.name))}`);
+    console.log(`   ${import_picocolors8.default.dim(tool.description)}`);
+    if (tool.tags && tool.tags.length > 0) {
+      console.log(`   ${import_picocolors8.default.yellow("Tags:")} ${tool.tags.join(", ")}`);
+    }
+    console.log("");
+  });
+  console.log(import_picocolors8.default.dim(`Total: ${results.length} tool${results.length === 1 ? "" : "s"}`));
+}
+async function showToolDetails(toolName) {
+  const spinner = Y2();
+  spinner.start(`Loading details for ${toolName}...`);
+  try {
+    const tool = await enactApi.getTool(toolName);
+    const usage = await enactApi.getToolUsage(toolName);
+    spinner.stop("Tool details loaded");
+    console.log(`
+` + import_picocolors8.default.bold(import_picocolors8.default.bgBlue(import_picocolors8.default.white(` ${tool.name} `))));
+    console.log("");
+    console.log(import_picocolors8.default.bold("Description:"));
+    console.log(tool.description);
+    console.log("");
+    console.log(import_picocolors8.default.bold("Command:"));
+    console.log(import_picocolors8.default.cyan(tool.command));
+    console.log("");
+    if (tool.tags && tool.tags.length > 0) {
+      console.log(import_picocolors8.default.bold("Tags:"));
+      console.log(tool.tags.map((tag) => import_picocolors8.default.yellow(tag)).join(", "));
+      console.log("");
+    }
+    if (tool.timeout) {
+      console.log(import_picocolors8.default.bold("Timeout:"));
+      console.log(tool.timeout);
+      console.log("");
+    }
+    if (tool.inputSchema) {
+      console.log(import_picocolors8.default.bold("Input Schema:"));
+      console.log(JSON.stringify(tool.inputSchema, null, 2));
+      console.log("");
+    }
+    if (tool.examples && tool.examples.length > 0) {
+      console.log(import_picocolors8.default.bold("Examples:"));
+      tool.examples.forEach((example, index) => {
+        console.log(import_picocolors8.default.cyan(`Example ${index + 1}:`));
+        if (example.description) {
+          console.log(`  Description: ${example.description}`);
+        }
+        console.log(`  Input: ${JSON.stringify(example.input)}`);
+        if (example.output) {
+          console.log(`  Output: ${example.output}`);
+        }
+        console.log("");
+      });
+    }
+    if (tool.env && Object.keys(tool.env).length > 0) {
+      console.log(import_picocolors8.default.bold("Environment Variables:"));
+      Object.entries(tool.env).forEach(([key, config]) => {
+        console.log(`  ${import_picocolors8.default.yellow(key)}: ${config.description}`);
+        if (config.required) {
+          console.log(`    Required: ${import_picocolors8.default.red("Yes")}`);
+        } else {
+          console.log(`    Required: ${import_picocolors8.default.green("No")}`);
+          if (config.default) {
+            console.log(`    Default: ${config.default}`);
+          }
+        }
+      });
+      console.log("");
+    }
+    if (usage) {
+      console.log(import_picocolors8.default.bold("Usage Statistics:"));
+      console.log(`  Views: ${usage.views || 0}`);
+      console.log(`  Downloads: ${usage.downloads || 0}`);
+      console.log(`  Executions: ${usage.executions || 0}`);
+      console.log("");
+    }
+  } catch (error) {
+    spinner.stop("Failed to load tool details");
+    Me(`Failed to load details: ${error.message}`, "Error");
+  }
+}
+
+// src/commands/user.ts
+var import_picocolors9 = __toESM(require_picocolors(), 1);
+async function handleUserCommand(args, options) {
+  if (options.help) {
+    showUserHelp();
+    return;
+  }
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "public-key":
+      await handlePublicKeyCommand(args.slice(1), options);
+      break;
+    default:
+      if (!subcommand) {
+        console.error(import_picocolors9.default.red("Missing subcommand. Use --help for usage information."));
+      } else {
+        console.error(import_picocolors9.default.red(`Unknown subcommand: ${subcommand}`));
+      }
+      showUserHelp();
+      process.exit(1);
+  }
+}
+async function handlePublicKeyCommand(args, options) {
+  Ie(import_picocolors9.default.bgBlue(import_picocolors9.default.white(" Get User Public Key ")));
+  let token;
+  try {
+    if (options.token) {
+      token = options.token;
+    } else {
+      const authHeaders = await getAuthHeaders();
+    }
+  } catch (error) {
+    Se(import_picocolors9.default.red(`✗ Authentication required. Run "enact auth login" to authenticate.`));
+    return;
+  }
+  let userId = args[0];
+  if (!userId) {
+    userId = await he({
+      message: "Enter user ID:",
+      placeholder: "user-123",
+      validate: (value) => {
+        if (!value)
+          return "User ID is required";
+        return;
+      }
+    });
+    if (pD(userId)) {
+      Se(import_picocolors9.default.yellow("Operation cancelled"));
+      return;
+    }
+  }
+  let apiUrl = options.server;
+  if (!apiUrl) {
+    const defaultUrl = await getDefaultUrl();
+    console.log("defaultUrl", defaultUrl);
+    if (defaultUrl) {} else {
+      apiUrl = "https://api.enact.dev";
+    }
+  }
+  const spinner = Y2();
+  spinner.start("Fetching public key...");
+  try {
+    const apiClient = apiUrl ? createEnactApiClient(apiUrl) : enactApi;
+    const data = await apiClient.getUserPublicKey(userId);
+    spinner.stop("Public key retrieved successfully");
+    if (options.format === "json") {
+      console.log(JSON.stringify(data, null, 2));
+    } else if (options.format === "raw" && data.publicKey) {
+      console.log(data.publicKey);
+    } else {
+      Me(`User ID: ${import_picocolors9.default.cyan(userId)}
+Public Key: ${import_picocolors9.default.yellow(data.publicKey || "Not available")}
+Key Type: ${import_picocolors9.default.blue(data.keyType || "Unknown")}
+Created: ${import_picocolors9.default.gray(data.createdAt ? new Date(data.createdAt).toLocaleString() : "Unknown")}`, "Public Key Information");
+    }
+    Se(import_picocolors9.default.green("✓ Public key retrieved successfully"));
+  } catch (error) {
+    spinner.stop("Failed to fetch public key" + error);
+    if (error instanceof EnactApiError) {
+      if (error.statusCode === 401 || error.statusCode === 403) {
+        Me("Authentication failed. Your token may have expired.", "Error");
+        Me('Run "enact auth login" to re-authenticate.', "Suggestion");
+      } else if (error.statusCode === 404) {
+        Me(`User '${userId}' not found or no public key available.`, "Error");
+      } else if (error.statusCode === 400) {
+        Me(`Invalid user ID: ${error.message}`, "Error");
+      } else {
+        Me(error.message, "Error");
+      }
+    } else if (error instanceof Error) {
+      if (error.message.includes("ENOTFOUND") || error.message.includes("ECONNREFUSED")) {
+        Me("Could not connect to the Enact API. Check your internet connection and server URL.", "Error");
+      } else {
+        Me(error.message, "Error");
+      }
+    }
+    Se(import_picocolors9.default.red("Failed to fetch public key"));
+  }
+}
+function showUserHelp() {
+  console.log(`
+${import_picocolors9.default.bold("USAGE")}
+  enact user <subcommand> [options]
+
+${import_picocolors9.default.bold("SUBCOMMANDS")}
+  public-key [userId]    Get a user's public key
+
+${import_picocolors9.default.bold("OPTIONS")}
+  -h, --help            Show help information
+  -s, --server <url>    API server URL (default: https://api.enact.dev)
+  -t, --token <token>   Authentication token
+  -f, --format <format> Output format (json|raw|default)
+
+${import_picocolors9.default.bold("EXAMPLES")}
+  enact user public-key user-123
+  enact user public-key --format json
+  enact user public-key user-456 --token your-token
+`);
+}
+
 // src/index.ts
 var { values, positionals } = parseArgs({
   args: process.argv,
@@ -9225,6 +9849,21 @@ var { values, positionals } = parseArgs({
     minimal: {
       type: "boolean",
       short: "m"
+    },
+    limit: {
+      type: "string",
+      short: "l"
+    },
+    tags: {
+      type: "string"
+    },
+    format: {
+      type: "string",
+      short: "f"
+    },
+    author: {
+      type: "string",
+      short: "a"
     }
   },
   allowPositionals: true,
@@ -9257,6 +9896,15 @@ async function main() {
           token: values.token
         });
         break;
+      case "search":
+        await handleSearchCommand(commandArgs, {
+          help: values.help,
+          limit: values.limit ? parseInt(values.limit) : undefined,
+          tags: values.tags ? (values.tags + "").split(",").map((t) => t.trim()) : undefined,
+          format: values.format,
+          author: values.author
+        });
+        break;
       case "remote":
         await handleRemoteCommand(commandArgs, {
           help: values.help
@@ -9268,20 +9916,30 @@ async function main() {
           minimal: values.minimal
         });
         break;
+      case "user":
+        await handleUserCommand(commandArgs, {
+          help: values.help,
+          server: values.server,
+          token: values.token,
+          format: values.format
+        });
+        break;
       case undefined:
         if (values.help) {
           showHelp();
         } else {
-          Ie(import_picocolors8.default.bgCyan(import_picocolors8.default.black(" Enact CLI ")));
+          Ie(import_picocolors10.default.bgCyan(import_picocolors10.default.black(" Enact CLI ")));
           const action = await ve({
             message: "What would you like to do?",
             options: [
-              { value: "auth", label: "Manage authentication" },
-              { value: "publish", label: "Publish a document" },
-              { value: "init", label: "Create a new tool definition" },
-              { value: "remote", label: "Manage remote servers" },
-              { value: "help", label: "Show help" },
-              { value: "exit", label: "Exit" }
+              { value: "search", label: "\uD83D\uDD0D Search for tools" },
+              { value: "publish", label: "\uD83D\uDCE4 Publish a tool" },
+              { value: "init", label: "\uD83D\uDCDD Create a new tool definition" },
+              { value: "auth", label: "\uD83D\uDD10 Manage authentication" },
+              { value: "remote", label: "\uD83C\uDF10 Manage remote servers" },
+              { value: "user", label: "\uD83D\uDC64 User operations" },
+              { value: "help", label: "❓ Show help" },
+              { value: "exit", label: "\uD83D\uDC4B Exit" }
             ]
           });
           if (action === null || action === "exit") {
@@ -9292,14 +9950,18 @@ async function main() {
             showHelp();
             return;
           }
+          if (action === "search") {
+            await handleSearchCommand([], {});
+            return;
+          }
           if (action === "auth") {
             const authAction = await ve({
               message: "Authentication:",
               options: [
-                { value: "login", label: "Login (OAuth)" },
-                { value: "status", label: "Check auth status" },
-                { value: "logout", label: "Logout" },
-                { value: "token", label: "Show token" }
+                { value: "login", label: "\uD83D\uDD11 Login (OAuth)" },
+                { value: "status", label: "\uD83D\uDCCA Check auth status" },
+                { value: "logout", label: "\uD83D\uDEAA Logout" },
+                { value: "token", label: "\uD83D\uDD10 Show token" }
               ]
             });
             if (authAction !== null) {
@@ -9309,17 +9971,19 @@ async function main() {
           }
           if (action === "publish") {
             await handlePublishCommand([], {});
+            return;
           }
           if (action === "init") {
             await handleInitCommand([], {});
+            return;
           }
           if (action === "remote") {
             const remoteAction = await ve({
               message: "Remote management:",
               options: [
-                { value: "add", label: "Add remote server" },
-                { value: "list", label: "List remote servers" },
-                { value: "remove", label: "Remove remote server" }
+                { value: "add", label: "➕ Add remote server" },
+                { value: "list", label: "\uD83D\uDCCB List remote servers" },
+                { value: "remove", label: "\uD83D\uDDD1️ Remove remote server" }
               ]
             });
             if (remoteAction !== null) {
@@ -9327,15 +9991,27 @@ async function main() {
             }
             return;
           }
+          if (action === "user") {
+            const userAction = await ve({
+              message: "User operations:",
+              options: [
+                { value: "public-key", label: "\uD83D\uDD11 Get user public key" }
+              ]
+            });
+            if (userAction !== null) {
+              await handleUserCommand([userAction], {});
+            }
+            return;
+          }
         }
         break;
       default:
-        console.error(import_picocolors8.default.red(`Unknown command: ${command}`));
+        console.error(import_picocolors10.default.red(`Unknown command: ${command}`));
         showHelp();
         process.exit(1);
     }
   } catch (error) {
-    console.error(import_picocolors8.default.red(`Error: ${error.message}`));
+    console.error(import_picocolors10.default.red(`Error: ${error.message}`));
     process.exit(1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enact-cli",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "Official CLI for the Enact Protocol - package, secure, and discover AI tools",
   "type": "module",
   "main": "./dist/index.js",
@@ -61,4 +61,4 @@
     "picocolors": "^1.1.1",
     "yaml": "^2.8.0"
   }
-}
+}