@soat/cli 0.0.1 → 0.4.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025, Terezinha Tech Operations (ttoss)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/soat

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-require('../dist/index.js');
+import('../dist/esm/index.js');

package/dist/esm/index.js

@@ -1,33 +1,1161 @@
 /** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+});
 
 // src/index.ts
+import { createHmac, timingSafeEqual } from "crypto";
+import { createServer } from "http";
+import input from "@inquirer/input";
+import password from "@inquirer/password";
+import * as sdk from "@soat/sdk";
 import { program } from "commander";
 
 // package.json
 var package_default = {
-  name: "soat",
-  version: "0.0.1",
+  name: "@soat/cli",
+  version: "0.4.4",
+  type: "module",
   scripts: {
-    build: "tsup",
-    test: "jest --projects tests/unit"
+    generate: "tsx scripts/generate.ts",
+    lint: "eslint src",
+    typecheck: "tsc --noEmit",
+    build: "pnpm generate && tsup"
   },
   dependencies: {
-    commander: "^14.0.2"
+    "@inquirer/input": "^5.0.12",
+    "@inquirer/password": "^5.0.12",
+    "@soat/sdk": "workspace:*",
+    "@ttoss/logger": "^0.8.10",
+    commander: "^14.0.3"
   },
   devDependencies: {
-    "@ttoss/config": "^1.35.12",
+    "@ttoss/config": "^1.37.10",
     "@types/jest": "^30.0.0",
-    jest: "^30.2.0",
+    "@types/js-yaml": "^4.0.9",
+    jest: "^30.3.0",
+    "js-yaml": "^4.1.1",
     tsup: "^8.5.1",
     tsx: "^4.21.0"
   },
-  files: ["dist"],
-  bin: "./bin/soat"
+  files: ["dist", "bin"],
+  repository: {
+    type: "git",
+    url: "https://github.com/ttoss/soat"
+  },
+  bin: "./bin/soat",
+  publishConfig: {
+    access: "public",
+    provenance: true
+  }
+};
+
+// src/config.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { createClient, createConfig } from "@soat/sdk";
+var CONFIG_FILE = path.join(os.homedir(), ".soat", "config.json");
+var readConfig = /* @__PURE__ */__name(() => {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}, "readConfig");
+var writeProfile = /* @__PURE__ */__name((name, profile) => {
+  const config = readConfig();
+  config[name] = profile;
+  fs.mkdirSync(path.dirname(CONFIG_FILE), {
+    recursive: true
+  });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}, "writeProfile");
+var resolveClient = /* @__PURE__ */__name(profileName => {
+  const envBaseUrl = process.env["SOAT_BASE_URL"];
+  const envToken = process.env["SOAT_TOKEN"];
+  if (envBaseUrl && envToken) {
+    return createClient(createConfig({
+      baseUrl: envBaseUrl,
+      headers: {
+        Authorization: `Bearer ${envToken}`
+      }
+    }));
+  }
+  if (envBaseUrl && !envToken) {
+    return createClient(createConfig({
+      baseUrl: envBaseUrl
+    }));
+  }
+  const name = profileName ?? process.env["SOAT_PROFILE"] ?? "default";
+  const config = readConfig();
+  const profile = config[name];
+  if (!profile) {
+    console.error(`Profile "${name}" not found. Run: soat configure${name !== "default" ? ` --profile ${name}` : ""}`);
+    process.exit(1);
+  }
+  return createClient(createConfig({
+    baseUrl: profile.baseUrl,
+    headers: {
+      Authorization: `Bearer ${profile.token}`
+    }
+  }));
+}, "resolveClient");
+
+// src/generated/routes.ts
+var routes = {
+  "list-actors": {
+    serviceClass: "Actors",
+    operationId: "listActors",
+    description: "List actors",
+    pathParams: [],
+    queryParams: ["project_id", "external_id", "limit", "offset"]
+  },
+  "create-actor": {
+    serviceClass: "Actors",
+    operationId: "createActor",
+    description: "Create an actor",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-actor": {
+    serviceClass: "Actors",
+    operationId: "getActor",
+    description: "Get an actor by ID",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "update-actor": {
+    serviceClass: "Actors",
+    operationId: "updateActor",
+    description: "Update an actor",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "delete-actor": {
+    serviceClass: "Actors",
+    operationId: "deleteActor",
+    description: "Delete an actor",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "get-actor-tags": {
+    serviceClass: "Actors",
+    operationId: "getActorTags",
+    description: "Get actor tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "replace-actor-tags": {
+    serviceClass: "Actors",
+    operationId: "replaceActorTags",
+    description: "Replace actor tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "merge-actor-tags": {
+    serviceClass: "Actors",
+    operationId: "mergeActorTags",
+    description: "Merge actor tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "list-agent-tools": {
+    serviceClass: "AgentTools",
+    operationId: "listAgentTools",
+    description: "List agent tools",
+    pathParams: [],
+    queryParams: ["project_id"]
+  },
+  "create-agent-tool": {
+    serviceClass: "AgentTools",
+    operationId: "createAgentTool",
+    description: "Create an agent tool",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-agent-tool": {
+    serviceClass: "AgentTools",
+    operationId: "getAgentTool",
+    description: "Get an agent tool",
+    pathParams: ["tool_id"],
+    queryParams: []
+  },
+  "update-agent-tool": {
+    serviceClass: "AgentTools",
+    operationId: "updateAgentTool",
+    description: "Update an agent tool",
+    pathParams: ["tool_id"],
+    queryParams: []
+  },
+  "delete-agent-tool": {
+    serviceClass: "AgentTools",
+    operationId: "deleteAgentTool",
+    description: "Delete an agent tool",
+    pathParams: ["tool_id"],
+    queryParams: []
+  },
+  "list-agent-traces": {
+    serviceClass: "AgentTraces",
+    operationId: "listAgentTraces",
+    description: "List agent traces",
+    pathParams: [],
+    queryParams: ["project_id", "limit", "offset"]
+  },
+  "get-agent-trace": {
+    serviceClass: "AgentTraces",
+    operationId: "getAgentTrace",
+    description: "Get a trace",
+    pathParams: ["trace_id"],
+    queryParams: []
+  },
+  "list-agents": {
+    serviceClass: "Agents",
+    operationId: "listAgents",
+    description: "List agents",
+    pathParams: [],
+    queryParams: ["project_id"]
+  },
+  "create-agent": {
+    serviceClass: "Agents",
+    operationId: "createAgent",
+    description: "Create an agent",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-agent": {
+    serviceClass: "Agents",
+    operationId: "getAgent",
+    description: "Get an agent",
+    pathParams: ["agent_id"],
+    queryParams: []
+  },
+  "update-agent": {
+    serviceClass: "Agents",
+    operationId: "updateAgent",
+    description: "Update an agent",
+    pathParams: ["agent_id"],
+    queryParams: []
+  },
+  "delete-agent": {
+    serviceClass: "Agents",
+    operationId: "deleteAgent",
+    description: "Delete an agent",
+    pathParams: ["agent_id"],
+    queryParams: []
+  },
+  "create-agent-generation": {
+    serviceClass: "Agents",
+    operationId: "createAgentGeneration",
+    description: "Run an agent generation",
+    pathParams: ["agent_id"],
+    queryParams: []
+  },
+  "submit-agent-tool-outputs": {
+    serviceClass: "Agents",
+    operationId: "submitAgentToolOutputs",
+    description: "Submit tool outputs for a paused generation",
+    pathParams: ["agent_id", "generation_id"],
+    queryParams: []
+  },
+  "create-agent-actor": {
+    serviceClass: "Agents",
+    operationId: "createAgentActor",
+    description: "Create an actor for an agent",
+    pathParams: ["agent_id"],
+    queryParams: []
+  },
+  "list-ai-providers": {
+    serviceClass: "AIProviders",
+    operationId: "listAiProviders",
+    description: "List AI providers",
+    pathParams: [],
+    queryParams: ["project_id", "limit", "offset"]
+  },
+  "create-ai-provider": {
+    serviceClass: "AIProviders",
+    operationId: "createAiProvider",
+    description: "Create an AI provider",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-ai-provider": {
+    serviceClass: "AIProviders",
+    operationId: "getAiProvider",
+    description: "Get an AI provider",
+    pathParams: ["ai_provider_id"],
+    queryParams: []
+  },
+  "update-ai-provider": {
+    serviceClass: "AIProviders",
+    operationId: "updateAiProvider",
+    description: "Update an AI provider",
+    pathParams: ["ai_provider_id"],
+    queryParams: []
+  },
+  "delete-ai-provider": {
+    serviceClass: "AIProviders",
+    operationId: "deleteAiProvider",
+    description: "Delete an AI provider",
+    pathParams: ["ai_provider_id"],
+    queryParams: []
+  },
+  "create-api-key": {
+    serviceClass: "APIKeys",
+    operationId: "createApiKey",
+    description: "Create an API key",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-api-key": {
+    serviceClass: "APIKeys",
+    operationId: "getApiKey",
+    description: "Get an API key",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "update-api-key": {
+    serviceClass: "APIKeys",
+    operationId: "updateApiKey",
+    description: "Update an API key",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "delete-api-key": {
+    serviceClass: "APIKeys",
+    operationId: "deleteApiKey",
+    description: "Delete an API key",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "list-chats": {
+    serviceClass: "Chats",
+    operationId: "listChats",
+    description: "List chats",
+    pathParams: [],
+    queryParams: ["project_id"]
+  },
+  "create-chat": {
+    serviceClass: "Chats",
+    operationId: "createChat",
+    description: "Create a chat",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-chat": {
+    serviceClass: "Chats",
+    operationId: "getChat",
+    description: "Get a chat",
+    pathParams: ["chat_id"],
+    queryParams: []
+  },
+  "delete-chat": {
+    serviceClass: "Chats",
+    operationId: "deleteChat",
+    description: "Delete a chat",
+    pathParams: ["chat_id"],
+    queryParams: []
+  },
+  "create-chat-completion-for-chat": {
+    serviceClass: "Chats",
+    operationId: "createChatCompletionForChat",
+    description: "Create a chat completion for a stored chat",
+    pathParams: ["chat_id"],
+    queryParams: []
+  },
+  "create-chat-completion": {
+    serviceClass: "Chats",
+    operationId: "createChatCompletion",
+    description: "Create a chat completion (stateless)",
+    pathParams: [],
+    queryParams: []
+  },
+  "create-chat-actor": {
+    serviceClass: "Chats",
+    operationId: "createChatActor",
+    description: "Create an actor for a chat",
+    pathParams: ["chat_id"],
+    queryParams: []
+  },
+  "list-conversations": {
+    serviceClass: "Conversations",
+    operationId: "listConversations",
+    description: "List conversations",
+    pathParams: [],
+    queryParams: ["project_id", "actor_id", "limit", "offset"]
+  },
+  "create-conversation": {
+    serviceClass: "Conversations",
+    operationId: "createConversation",
+    description: "Create a conversation",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-conversation": {
+    serviceClass: "Conversations",
+    operationId: "getConversation",
+    description: "Get a conversation by ID",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "update-conversation": {
+    serviceClass: "Conversations",
+    operationId: "updateConversation",
+    description: "Update a conversation",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "delete-conversation": {
+    serviceClass: "Conversations",
+    operationId: "deleteConversation",
+    description: "Delete a conversation",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "list-conversation-messages": {
+    serviceClass: "Conversations",
+    operationId: "listConversationMessages",
+    description: "List conversation messages",
+    pathParams: ["id"],
+    queryParams: ["limit", "offset"]
+  },
+  "add-conversation-message": {
+    serviceClass: "Conversations",
+    operationId: "addConversationMessage",
+    description: "Add a message to a conversation",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "generate-conversation-message": {
+    serviceClass: "Conversations",
+    operationId: "generateConversationMessage",
+    description: "Generate the next message in a conversation",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "list-conversation-actors": {
+    serviceClass: "Conversations",
+    operationId: "listConversationActors",
+    description: "List actors in a conversation",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "remove-conversation-message": {
+    serviceClass: "Conversations",
+    operationId: "removeConversationMessage",
+    description: "Remove a message from a conversation",
+    pathParams: ["id", "document_id"],
+    queryParams: []
+  },
+  "get-conversation-tags": {
+    serviceClass: "Conversations",
+    operationId: "getConversationTags",
+    description: "Get conversation tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "replace-conversation-tags": {
+    serviceClass: "Conversations",
+    operationId: "replaceConversationTags",
+    description: "Replace conversation tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "merge-conversation-tags": {
+    serviceClass: "Conversations",
+    operationId: "mergeConversationTags",
+    description: "Merge conversation tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "list-documents": {
+    serviceClass: "Documents",
+    operationId: "listDocuments",
+    description: "List documents",
+    pathParams: [],
+    queryParams: ["project_id"]
+  },
+  "create-document": {
+    serviceClass: "Documents",
+    operationId: "createDocument",
+    description: "Create a document",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-document": {
+    serviceClass: "Documents",
+    operationId: "getDocument",
+    description: "Get a document by ID",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "update-document": {
+    serviceClass: "Documents",
+    operationId: "updateDocument",
+    description: "Update a document",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "delete-document": {
+    serviceClass: "Documents",
+    operationId: "deleteDocument",
+    description: "Delete a document",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "get-document-tags": {
+    serviceClass: "Documents",
+    operationId: "getDocumentTags",
+    description: "Get document tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "replace-document-tags": {
+    serviceClass: "Documents",
+    operationId: "replaceDocumentTags",
+    description: "Replace document tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "merge-document-tags": {
+    serviceClass: "Documents",
+    operationId: "mergeDocumentTags",
+    description: "Merge document tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "search-documents": {
+    serviceClass: "Documents",
+    operationId: "searchDocuments",
+    description: "Semantic search over documents",
+    pathParams: [],
+    queryParams: []
+  },
+  "list-files": {
+    serviceClass: "Files",
+    operationId: "listFiles",
+    description: "List all files",
+    pathParams: [],
+    queryParams: ["project_id", "limit", "offset"]
+  },
+  "create-file": {
+    serviceClass: "Files",
+    operationId: "createFile",
+    description: "Create a file",
+    pathParams: [],
+    queryParams: []
+  },
+  "upload-file": {
+    serviceClass: "Files",
+    operationId: "uploadFile",
+    description: "Upload a file",
+    pathParams: [],
+    queryParams: []
+  },
+  "upload-file-base64": {
+    serviceClass: "Files",
+    operationId: "uploadFileBase64",
+    description: "Upload a file using base64 encoding",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-file": {
+    serviceClass: "Files",
+    operationId: "getFile",
+    description: "Get a file by ID",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "delete-file": {
+    serviceClass: "Files",
+    operationId: "deleteFile",
+    description: "Delete a file",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "download-file": {
+    serviceClass: "Files",
+    operationId: "downloadFile",
+    description: "Download a file",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "update-file-metadata": {
+    serviceClass: "Files",
+    operationId: "updateFileMetadata",
+    description: "Update file metadata",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "download-file-base64": {
+    serviceClass: "Files",
+    operationId: "downloadFileBase64",
+    description: "Download file as base64",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "get-file-tags": {
+    serviceClass: "Files",
+    operationId: "getFileTags",
+    description: "Get file tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "replace-file-tags": {
+    serviceClass: "Files",
+    operationId: "replaceFileTags",
+    description: "Replace file tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "merge-file-tags": {
+    serviceClass: "Files",
+    operationId: "mergeFileTags",
+    description: "Merge file tags",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "list-policies": {
+    serviceClass: "Policies",
+    operationId: "listPolicies",
+    description: "List all policies",
+    pathParams: [],
+    queryParams: []
+  },
+  "create-policy": {
+    serviceClass: "Policies",
+    operationId: "createPolicy",
+    description: "Create a policy",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-policy": {
+    serviceClass: "Policies",
+    operationId: "getPolicy",
+    description: "Get a policy",
+    pathParams: ["policy_id"],
+    queryParams: []
+  },
+  "update-policy": {
+    serviceClass: "Policies",
+    operationId: "updatePolicy",
+    description: "Update a policy",
+    pathParams: ["policy_id"],
+    queryParams: []
+  },
+  "delete-policy": {
+    serviceClass: "Policies",
+    operationId: "deletePolicy",
+    description: "Delete a policy",
+    pathParams: ["policy_id"],
+    queryParams: []
+  },
+  "create-project": {
+    serviceClass: "Projects",
+    operationId: "createProject",
+    description: "Create a project",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-project": {
+    serviceClass: "Projects",
+    operationId: "getProject",
+    description: "Get a project",
+    pathParams: ["project_id"],
+    queryParams: []
+  },
+  "delete-project": {
+    serviceClass: "Projects",
+    operationId: "deleteProject",
+    description: "Delete a project",
+    pathParams: ["project_id"],
+    queryParams: []
+  },
+  "list-secrets": {
+    serviceClass: "Secrets",
+    operationId: "listSecrets",
+    description: "List secrets",
+    pathParams: [],
+    queryParams: ["project_id", "limit", "offset"]
+  },
+  "create-secret": {
+    serviceClass: "Secrets",
+    operationId: "createSecret",
+    description: "Create a secret",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-secret": {
+    serviceClass: "Secrets",
+    operationId: "getSecret",
+    description: "Get a secret",
+    pathParams: ["secret_id"],
+    queryParams: []
+  },
+  "update-secret": {
+    serviceClass: "Secrets",
+    operationId: "updateSecret",
+    description: "Update a secret",
+    pathParams: ["secret_id"],
+    queryParams: []
+  },
+  "delete-secret": {
+    serviceClass: "Secrets",
+    operationId: "deleteSecret",
+    description: "Delete a secret",
+    pathParams: ["secret_id"],
+    queryParams: []
+  },
+  "list-agent-sessions": {
+    serviceClass: "Sessions",
+    operationId: "listAgentSessions",
+    description: "List sessions",
+    pathParams: ["agent_id"],
+    queryParams: ["actor_id", "status", "limit", "offset"]
+  },
+  "create-agent-session": {
+    serviceClass: "Sessions",
+    operationId: "createAgentSession",
+    description: "Create a session",
+    pathParams: ["agent_id"],
+    queryParams: []
+  },
+  "get-agent-session": {
+    serviceClass: "Sessions",
+    operationId: "getAgentSession",
+    description: "Get a session",
+    pathParams: ["agent_id", "session_id"],
+    queryParams: []
+  },
+  "update-session": {
+    serviceClass: "Sessions",
+    operationId: "updateSession",
+    description: "Update a session",
+    pathParams: ["agent_id", "session_id"],
+    queryParams: []
+  },
+  "delete-agent-session": {
+    serviceClass: "Sessions",
+    operationId: "deleteAgentSession",
+    description: "Delete a session",
+    pathParams: ["agent_id", "session_id"],
+    queryParams: []
+  },
+  "list-agent-session-messages": {
+    serviceClass: "Sessions",
+    operationId: "listAgentSessionMessages",
+    description: "List session messages",
+    pathParams: ["agent_id", "session_id"],
+    queryParams: ["limit", "offset"]
+  },
+  "add-session-message": {
+    serviceClass: "Sessions",
+    operationId: "addSessionMessage",
+    description: "Add a user message",
+    pathParams: ["agent_id", "session_id"],
+    queryParams: []
+  },
+  "generate-session-response": {
+    serviceClass: "Sessions",
+    operationId: "generateSessionResponse",
+    description: "Trigger agent generation",
+    pathParams: ["agent_id", "session_id"],
+    queryParams: ["async"]
+  },
+  "submit-session-tool-outputs": {
+    serviceClass: "Sessions",
+    operationId: "submitSessionToolOutputs",
+    description: "Submit tool outputs",
+    pathParams: ["agent_id", "session_id"],
+    queryParams: []
+  },
+  "get-session-tags": {
+    serviceClass: "Sessions",
+    operationId: "getSessionTags",
+    description: "Get session tags",
+    pathParams: ["agent_id", "session_id"],
+    queryParams: []
+  },
+  "replace-session-tags": {
+    serviceClass: "Sessions",
+    operationId: "replaceSessionTags",
+    description: "Replace session tags",
+    pathParams: ["agent_id", "session_id"],
+    queryParams: []
+  },
+  "merge-session-tags": {
+    serviceClass: "Sessions",
+    operationId: "mergeSessionTags",
+    description: "Merge session tags",
+    pathParams: ["agent_id", "session_id"],
+    queryParams: []
+  },
+  "list-users": {
+    serviceClass: "Users",
+    operationId: "listUsers",
+    description: "List all users",
+    pathParams: [],
+    queryParams: []
+  },
+  "create-user": {
+    serviceClass: "Users",
+    operationId: "createUser",
+    description: "Create a user",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-user": {
+    serviceClass: "Users",
+    operationId: "getUser",
+    description: "Get a user by ID",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "delete-user": {
+    serviceClass: "Users",
+    operationId: "deleteUser",
+    description: "Delete a user by ID",
+    pathParams: ["id"],
+    queryParams: []
+  },
+  "bootstrap-user": {
+    serviceClass: "Users",
+    operationId: "bootstrapUser",
+    description: "Create the first admin user",
+    pathParams: [],
+    queryParams: []
+  },
+  "login-user": {
+    serviceClass: "Users",
+    operationId: "loginUser",
+    description: "Login user",
+    pathParams: [],
+    queryParams: []
+  },
+  "get-user-policies": {
+    serviceClass: "Users",
+    operationId: "getUserPolicies",
+    description: "Get policies attached to a user",
+    pathParams: ["user_id"],
+    queryParams: []
+  },
+  "attach-user-policies": {
+    serviceClass: "Users",
+    operationId: "attachUserPolicies",
+    description: "Attach policies to a user",
+    pathParams: ["user_id"],
+    queryParams: []
+  },
+  "list-webhooks": {
+    serviceClass: "Webhooks",
+    operationId: "listWebhooks",
+    description: "List webhooks for a project",
+    pathParams: ["project_id"],
+    queryParams: []
+  },
+  "create-webhook": {
+    serviceClass: "Webhooks",
+    operationId: "createWebhook",
+    description: "Create a webhook",
+    pathParams: ["project_id"],
+    queryParams: []
+  },
+  "get-webhook": {
+    serviceClass: "Webhooks",
+    operationId: "getWebhook",
+    description: "Get a webhook",
+    pathParams: ["project_id", "webhook_id"],
+    queryParams: []
+  },
+  "update-webhook": {
+    serviceClass: "Webhooks",
+    operationId: "updateWebhook",
+    description: "Update a webhook",
+    pathParams: ["project_id", "webhook_id"],
+    queryParams: []
+  },
+  "delete-webhook": {
+    serviceClass: "Webhooks",
+    operationId: "deleteWebhook",
+    description: "Delete a webhook",
+    pathParams: ["project_id", "webhook_id"],
+    queryParams: []
+  },
+  "list-webhook-deliveries": {
+    serviceClass: "Webhooks",
+    operationId: "listWebhookDeliveries",
+    description: "List deliveries for a webhook",
+    pathParams: ["project_id", "webhook_id"],
+    queryParams: ["limit", "offset"]
+  },
+  "get-webhook-delivery": {
+    serviceClass: "Webhooks",
+    operationId: "getWebhookDelivery",
+    description: "Get a delivery",
+    pathParams: ["project_id", "webhook_id", "delivery_id"],
+    queryParams: []
+  },
+  "rotate-webhook-secret": {
+    serviceClass: "Webhooks",
+    operationId: "rotateWebhookSecret",
+    description: "Rotate webhook secret",
+    pathParams: ["project_id", "webhook_id"],
+    queryParams: []
+  }
 };
 
 // src/index.ts
-program.name("soat").description("SOAT CLI - Command Line Interface for SOAT").version(package_default.version);
-program.action(() => {
-  console.log("Work is in progress");
+var toCanonical = /* @__PURE__ */__name(s => {
+  return s.replace(/[-_]([a-z0-9])/g, (_, c) => {
+    return c.toUpperCase();
+  });
+}, "toCanonical");
+var kebabToSnake = /* @__PURE__ */__name(s => {
+  return s.replace(/-/g, "_");
+}, "kebabToSnake");
+var parseUnknown = /* @__PURE__ */__name(args => {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg?.startsWith("--")) {
+      const key = arg.slice(2);
+      const val = args[i + 1];
+      if (val !== void 0 && !val.startsWith("--")) {
+        result[key] = val;
+        i++;
+      } else {
+        result[key] = "true";
+      }
+    }
+  }
+  return result;
+}, "parseUnknown");
+var parseFlagValue = /* @__PURE__ */__name(value => {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[") || trimmed === "true" || trimmed === "false" || trimmed === "null" || /^-?\d+(\.\d+)?$/.test(trimmed)) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}, "parseFlagValue");
+var normalizeSymbol = /* @__PURE__ */__name(name => {
+  return name.toLowerCase().replace(/[^a-z0-9]/g, "");
+}, "normalizeSymbol");
+var resolveServiceClass = /* @__PURE__ */__name(serviceClassName => {
+  const sdkExports = sdk;
+  const exactMatch = sdkExports[serviceClassName];
+  if (exactMatch) return exactMatch;
+  const normalizedTarget = normalizeSymbol(serviceClassName);
+  const fuzzyMatches = Object.entries(sdkExports).filter(([exportName, value]) => {
+    return Boolean(value) && normalizeSymbol(exportName) === normalizedTarget;
+  });
+  if (fuzzyMatches.length === 1) {
+    return fuzzyMatches[0][1];
+  }
+  return void 0;
+}, "resolveServiceClass");
+program.name("soat").description("SOAT CLI").version(package_default.version).option("-p, --profile <name>", "config profile to use");
+program.command("configure").description("Save credentials to a named profile (~/.soat/config.json)").option("-p, --profile <name>", "profile name", "default").action(async opts => {
+  const baseUrl = await input({
+    message: "Base URL:"
+  });
+  const token = await password({
+    message: "Token (hidden):"
+  });
+  writeProfile(opts.profile, {
+    baseUrl,
+    token
+  });
+  console.log(`Profile "${opts.profile}" saved.`);
+});
+program.command("list-commands").description("List all available API commands").action(() => {
+  const pad = Math.max(...Object.keys(routes).map(k => {
+    return k.length;
+  }));
+  for (const [cmd, r] of Object.entries(routes).sort()) {
+    console.log(`  ${cmd.padEnd(pad)}  ${r.description}`);
+  }
+});
+var matchesFilter = /* @__PURE__ */__name((eventType, filter) => {
+  const patterns = filter.split(",").map(part => {
+    return part.trim();
+  }).filter(Boolean);
+  if (patterns.length === 0) return true;
+  return patterns.some(pattern => {
+    if (pattern === "*") return true;
+    if (pattern.endsWith("*")) {
+      return eventType.startsWith(pattern.slice(0, -1));
+    }
+    return eventType === pattern;
+  });
+}, "matchesFilter");
+var verifySignature = /* @__PURE__ */__name((secret, payload, signatureHeader) => {
+  const expected = createHmac("sha256", secret).update(payload).digest("hex");
+  const expectedBuffer = Buffer.from(expected, "utf8");
+  const actualBuffer = Buffer.from(signatureHeader, "utf8");
+  if (expectedBuffer.length !== actualBuffer.length) return false;
+  return timingSafeEqual(expectedBuffer, actualBuffer);
+}, "verifySignature");
+program.command("listen").description("Start a local webhook listener for testing deliveries").option("--port <number>", "port to listen on", "8787").option("--path <path>", "request path to accept", "/webhook").option("--secret <secret>", "verify X-Soat-Signature with this webhook secret").option("--filter <pattern>", "filter event type(s), supports prefix wildcard and comma separation (e.g. sessions.generation.*,files.*)").option("--json", "print one JSON object per line").action(opts => {
+  const port = Number(opts.port);
+  const path2 = opts.path;
+  const secret = opts.secret;
+  const filter = opts.filter;
+  const asJson = Boolean(opts.json);
+  if (!Number.isInteger(port) || port <= 0) {
+    console.error("Invalid port. Use a positive integer.");
+    process.exit(1);
+  }
+  const server = createServer((req, res) => {
+    if (req.method !== "POST" || req.url !== path2) {
+      res.writeHead(404, {
+        "Content-Type": "application/json"
+      });
+      res.end(JSON.stringify({
+        error: "not found"
+      }));
+      return;
+    }
+    const chunks = [];
+    req.on("data", chunk => {
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      const rawBody = Buffer.concat(chunks).toString("utf8");
+      const eventType = String(req.headers["x-soat-event"] ?? "unknown");
+      const deliveryId = String(req.headers["x-soat-delivery"] ?? "unknown");
+      const signature = String(req.headers["x-soat-signature"] ?? "");
+      if (filter && !matchesFilter(eventType, filter)) {
+        res.writeHead(200, {
+          "Content-Type": "application/json"
+        });
+        res.end(JSON.stringify({
+          ok: true,
+          skipped: true
+        }));
+        return;
+      }
+      let parsedPayload = rawBody;
+      try {
+        parsedPayload = JSON.parse(rawBody);
+      } catch {}
+      let isSignatureValid = null;
+      if (secret) {
+        isSignatureValid = verifySignature(secret, rawBody, signature);
+      }
+      const record = {
+        timestamp: (/* @__PURE__ */new Date()).toISOString(),
+        event_type: eventType,
+        delivery_id: deliveryId,
+        signature,
+        signature_valid: isSignatureValid,
+        payload: parsedPayload
+      };
+      if (asJson) {
+        console.log(JSON.stringify(record));
+      } else {
+        console.log("--- webhook received ---");
+        console.log("event_type:", eventType);
+        console.log("delivery_id:", deliveryId);
+        if (secret) {
+          console.log("signature_valid:", isSignatureValid);
+        }
+        console.log("payload:", JSON.stringify(parsedPayload, null, 2));
+      }
+      const responseStatus = secret && isSignatureValid === false ? 401 : 200;
+      res.writeHead(responseStatus, {
+        "Content-Type": "application/json"
+      });
+      res.end(JSON.stringify({
+        ok: responseStatus === 200,
+        event_type: eventType,
+        delivery_id: deliveryId,
+        signature_valid: isSignatureValid
+      }));
+    });
+  });
+  server.listen(port, () => {
+    console.log(`Listening for SOAT webhooks on http://localhost:${port}${path2}`);
+    if (filter) {
+      console.log(`Filter: ${filter}`);
+    }
+    if (secret) {
+      console.log("Signature verification: enabled");
+    }
+  });
+  process.on("SIGINT", () => {
+    server.close(() => {
+      process.exit(0);
+    });
+  });
+});
+program.argument("[command]", "API command in kebab-case (e.g. list-actors)").argument("[args...]").allowUnknownOption().action(async commandName => {
+  if (!commandName) {
+    program.help();
+    return;
+  }
+  const route = routes[commandName];
+  if (!route) {
+    console.error(`Unknown command: ${commandName}`);
+    console.error(`Run "soat list-commands" to see all available commands.`);
+    process.exit(1);
+  }
+  const rawIdx = process.argv.indexOf(commandName);
+  const rawArgs = rawIdx >= 0 ? process.argv.slice(rawIdx + 1) : [];
+  const flags = parseUnknown(rawArgs);
+  const pathArgs = {};
+  const queryArgs = {};
+  const bodyArgs = {};
+  for (const [flagKey, val] of Object.entries(flags)) {
+    if (flagKey === "profile") continue;
+    const canonical = toCanonical(flagKey);
+    const parsedValue = parseFlagValue(val);
+    const pathParam = route.pathParams.find(p => {
+      return toCanonical(p) === canonical;
+    });
+    const queryParam = route.queryParams.find(p => {
+      return toCanonical(p) === canonical;
+    });
+    if (pathParam) {
+      pathArgs[pathParam] = parsedValue;
+    } else if (queryParam) {
+      queryArgs[queryParam] = parsedValue;
+    } else {
+      bodyArgs[kebabToSnake(flagKey)] = parsedValue;
+    }
+  }
+  const profileOpt = flags["profile"] ?? program.opts().profile;
+  const client = resolveClient(profileOpt);
+  const serviceClass = resolveServiceClass(route.serviceClass);
+  if (!serviceClass) {
+    console.error(`SDK class "${route.serviceClass}" not found.`);
+    process.exit(1);
+  }
+  const method = serviceClass[route.operationId];
+  if (typeof method !== "function") {
+    console.error(`Method "${route.operationId}" not found on ${route.serviceClass}.`);
+    process.exit(1);
+  }
+  const callOpts = {
+    client
+  };
+  if (Object.keys(pathArgs).length) callOpts["path"] = pathArgs;
+  if (Object.keys(queryArgs).length) callOpts["query"] = queryArgs;
+  if (Object.keys(bodyArgs).length) callOpts["body"] = bodyArgs;
+  const result = await method(callOpts);
+  if (result.error) {
+    const status = result.response && "status" in result.response ? result.response.status : void 0;
+    console.error(JSON.stringify({
+      status,
+      error: result.error
+    }, null, 2));
+    process.exit(1);
+  }
+  console.log(JSON.stringify(result.data, null, 2));
 });
 program.parse();

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "@soat/cli",
-  "version": "0.0.1",
-  "scripts": {
-    "build": "tsup",
-    "test": "jest --projects tests/unit"
-  },
+  "version": "0.4.4",
+  "type": "module",
   "dependencies": {
-    "@ttoss/logger": "^0.7.1",
-    "commander": "^14.0.2"
+    "@inquirer/input": "^5.0.12",
+    "@inquirer/password": "^5.0.12",
+    "@ttoss/logger": "^0.8.10",
+    "commander": "^14.0.3",
+    "@soat/sdk": "0.4.4"
   },
   "devDependencies": {
-    "@ttoss/config": "^1.35.12",
+    "@ttoss/config": "^1.37.10",
     "@types/jest": "^30.0.0",
-    "jest": "^30.2.0",
+    "@types/js-yaml": "^4.0.9",
+    "jest": "^30.3.0",
+    "js-yaml": "^4.1.1",
     "tsup": "^8.5.1",
     "tsx": "^4.21.0"
   },
@@ -20,8 +22,19 @@
     "dist",
     "bin"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ttoss/soat"
+  },
   "bin": "./bin/soat",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "generate": "tsx scripts/generate.ts",
+    "lint": "eslint src",
+    "typecheck": "tsc --noEmit",
+    "build": "pnpm generate && tsup"
   }
-}
+}

package/dist/index.d.mts

@@ -1,2 +0,0 @@
-
-export {  }

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-
-export {  }

package/dist/index.js

@@ -1,34 +0,0 @@
-/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
-"use strict";
-
-// src/index.ts
-var import_commander = require("commander");
-
-// package.json
-var package_default = {
-  name: "soat",
-  version: "0.0.1",
-  scripts: {
-    build: "tsup",
-    test: "jest --projects tests/unit"
-  },
-  dependencies: {
-    commander: "^14.0.2"
-  },
-  devDependencies: {
-    "@ttoss/config": "^1.35.12",
-    "@types/jest": "^30.0.0",
-    jest: "^30.2.0",
-    tsup: "^8.5.1",
-    tsx: "^4.21.0"
-  },
-  files: ["dist"],
-  bin: "./bin/soat"
-};
-
-// src/index.ts
-import_commander.program.name("soat").description("SOAT CLI - Command Line Interface for SOAT").version(package_default.version);
-import_commander.program.action(() => {
-  console.log("Work is in progress");
-});
-import_commander.program.parse();