automate-it 0.2.0 → 0.4.0

package/ait.mjs

@@ -3,10 +3,15 @@
 //
 // Zero-dependency ESM script (Node 18+ or Bun). Speaks the Model Context
 // Protocol (StreamableHTTP, stateless) to Automate It's public MCP server,
-// authenticating with an API key (ak_*) — so the CLI can do everything a
-// remote MCP client can, headlessly. `ait call <tool>` passes any MCP tool
-// through verbatim; the named commands are ergonomic wrappers over the
-// common ones. Every command goes through MCP — there is no REST path.
+// authenticating with an API key (ak_*). Every command goes through MCP —
+// there is no REST path.
+//
+// The command surface is a closed set: every tool the workspace MCP server
+// exposes has exactly one named command here, and there is no generic
+// passthrough. Adding a tool to the server means adding its command here —
+// that's deliberate, so the skill's capabilities can be read off its docs.
+// Scopes and workspace role still bound what runs, enforced server-side, and
+// tools that destroy data additionally require an explicit --yes.
 //
 // Tool output is printed verbatim on stdout; errors go to stderr as
 // {"error": "..."} with exit code 1.
@@ -26,12 +31,14 @@ Environment:
   AUTOMATE_IT_WORKSPACE  Default workspace id (else pass --workspace, else
                          auto-resolved when the key has exactly one workspace)
 
+Destructive commands (task delete, task delete-content, task clear-content,
+automation delete, folders delete) permanently remove data and refuse to run
+without --yes. Only pass it when the operator asked for that deletion by name.
+
 Discovery:
-  ait tools                            List every available MCP tool
-  ait call <tool> [--args '<json>']    Call any MCP tool directly (workspaceId
-                                       is injected automatically if omitted)
   ait workspaces                       List workspaces the key can access
   ait whoami                           Show the user this key acts as
+  ait integrations                     Platforms connected for publishing
 
 Tasks (the review-gate loop):
   ait task create --title <t>          Create a task
@@ -64,8 +71,9 @@ Tasks (the review-gate loop):
       [--media '<json array>'] [--sort-order <n>]
   ait task update-content <taskId> <contentItemId>
       [--body <text>] [--title <t>]    Rewrite a content item in place
-  ait task delete-content <taskId> <contentItemId>
-  ait task clear-content <taskId>      Remove every content item from a task
+  ait task delete-content <taskId> <contentItemId> --yes
+  ait task clear-content <taskId> --yes
+                                       Remove every content item from a task
   ait task complete <taskId>           Finish work (status → review/approved)
   ait task comment <taskId> --comment <text>
                                        Leave a note for the human reviewer
@@ -78,7 +86,7 @@ Tasks (the review-gate loop):
                                        later; --auto picks the next open slot
                                        per the workspace's scheduling rules;
                                        --clear returns it to manual
-  ait task delete <taskId>
+  ait task delete <taskId> --yes
 
 Skills (workspace voice, formatting rules, bundled reference files):
   ait skills list                      id, name, description for each skill
@@ -91,7 +99,9 @@ Automations:
   ait automation get <automationId>
   ait automation update <automationId> [--name <n>] [--instructions <text>]
       [--output-types x,...] [--schedule <json>]
-  ait automation delete <automationId>
+  ait automation delete <automationId> --yes
+                                       Also deletes every task it spawned,
+                                       published ones included
   ait automation run <automationId>    Trigger now; returns the spawned task
 
 Files:
@@ -100,13 +110,55 @@ Files:
   ait files list [--search <s>] [--mime-type <m>] [--limit <n>]
   ait files download-url <fileId> [--expires-in <seconds>]
                                        Presigned URL — download it yourself
-  (folders/integrations: use \`ait call\` — see \`ait tools\`)
+  ait files move <fileId> [--folder <folderId>]
+                                       Move into a folder; omit --folder for
+                                       the workspace root
+  ait files copy <fileId> [--folder <folderId>]
+                                       Duplicate the file (new file + object)
+
+Folders:
+  ait folders list [--parent <folderId>] [--root]
+                                       --root lists top-level folders only
+  ait folders create --name <n> [--parent <folderId>]
+  ait folders rename <folderId> --name <n>
+  ait folders delete <folderId> --yes  Also deletes every file and nested
+                                       folder inside it
+
+Composing posts:
+  ait limits [--platform <p>]          Text limits for every platform, or one.
+       [--text <draft>]                With --text, returns the draft's length
+                                       under that platform's counting rule and
+                                       whether it fits. Platforms count
+                                       differently: X counts a URL as 23 and
+                                       emoji as 2, Threads counts emoji as
+                                       UTF-8 bytes, Bluesky counts graphemes.
+  ait shorten <url> [--title <t>]      Shorten a link for a post
 
 All workspace commands accept --workspace <id>.`;
 
 export class CliError extends Error {}
 
-const BOOLEAN_FLAGS = new Set(["no-review", "claim", "mine", "clear", "auto", "help"]);
+const BOOLEAN_FLAGS = new Set(["no-review", "claim", "mine", "clear", "auto", "help", "yes", "root"]);
+
+// MCP tools that permanently remove data, keyed to what they destroy. Keyed by
+// tool rather than by command so the gate lives next to the thing that does
+// the damage — a second command routing to one of these inherits it.
+const DESTRUCTIVE_TOOLS = new Map([
+  ["delete_task", "delete the task and everything attached to it"],
+  ["delete_content_item", "delete the content item"],
+  ["clear_task_content", "remove every content item from the task"],
+  ["delete_automation", "delete the automation and every task it ever spawned, published ones included"],
+  ["delete_folder", "delete the folder and every file and folder inside it"],
+]);
+
+/** Destructive tools need an explicit --yes; nothing else is affected. */
+function requireConfirmation(flags, toolName) {
+  const effect = DESTRUCTIVE_TOOLS.get(toolName);
+  if (!effect || flags.yes === true) return;
+  throw new CliError(
+    `Refusing to run without --yes: this would ${effect}. It cannot be undone — confirm with the operator, then re-run with --yes.`
+  );
+}
 
 export function parseArgs(argv) {
   const positional = [];
@@ -342,28 +394,19 @@ export async function runCommand(argv, opts = {}) {
     return USAGE;
   }
 
-  const SINGLE_WORD_COMMANDS = new Set(["tools", "call", "workspaces", "whoami", "upload-url"]);
+  const SINGLE_WORD_COMMANDS = new Set([
+    "workspaces",
+    "whoami",
+    "upload-url",
+    "integrations",
+    "limits",
+    "shorten",
+  ]);
   const command = SINGLE_WORD_COMMANDS.has(resource)
     ? resource
     : [resource, action].filter(Boolean).join(" ");
 
   switch (command) {
-    case "tools": {
-      const result = await mcpRequest(ctx, "tools/list", {});
-      return (result?.tools ?? [])
-        .map((t) => `${t.name} — ${(t.description || "").split("\n")[0]}`)
-        .join("\n");
-    }
-
-    case "call": {
-      const toolName = requirePositional([action, ...rest].filter(Boolean), "tool", "ait call <tool> [--args '<json>']");
-      const args = flags.args ? parseJsonFlag(flags.args, "args") : {};
-      if (args.workspaceId === undefined && toolName !== "list_workspaces" && toolName !== "get_clerk_user_data") {
-        args.workspaceId = await resolveWorkspace(ctx, flags);
-      }
-      return callTool(ctx, toolName, args);
-    }
-
     case "workspaces":
       return callTool(ctx, "list_workspaces", {});
 
@@ -448,6 +491,7 @@ export async function runCommand(argv, opts = {}) {
         delete: "delete_task",
       };
       const taskId = requirePositional(rest, "taskId", `ait task ${action} <taskId>`);
+      requireConfirmation(flags, toolByAction[action]);
       const workspaceId = await resolveWorkspace(ctx, flags);
       return callTool(ctx, toolByAction[action], { workspaceId, taskId });
     }
@@ -536,8 +580,9 @@ export async function runCommand(argv, opts = {}) {
     case "automation get":
     case "automation delete": {
       const automationId = requirePositional(rest, "automationId", `ait automation ${action} <automationId>`);
-      const workspaceId = await resolveWorkspace(ctx, flags);
       const tool = action === "get" ? "get_automation" : "delete_automation";
+      requireConfirmation(flags, tool);
+      const workspaceId = await resolveWorkspace(ctx, flags);
       return callTool(ctx, tool, { workspaceId, automationId });
     }
 
@@ -590,15 +635,17 @@ export async function runCommand(argv, opts = {}) {
     }
 
     case "task delete-content": {
-      const usage = "ait task delete-content <taskId> <contentItemId>";
+      const usage = "ait task delete-content <taskId> <contentItemId> --yes";
       const taskId = requirePositionalAt(rest, 0, "taskId", usage);
       const contentItemId = requirePositionalAt(rest, 1, "contentItemId", usage);
+      requireConfirmation(flags, "delete_content_item");
       const workspaceId = await resolveWorkspace(ctx, flags);
       return callTool(ctx, "delete_content_item", { workspaceId, taskId, contentItemId });
     }
 
     case "task clear-content": {
-      const taskId = requirePositional(rest, "taskId", "ait task clear-content <taskId>");
+      const taskId = requirePositional(rest, "taskId", "ait task clear-content <taskId> --yes");
+      requireConfirmation(flags, "clear_task_content");
       const workspaceId = await resolveWorkspace(ctx, flags);
       return callTool(ctx, "clear_task_content", { workspaceId, taskId });
     }
@@ -634,8 +681,79 @@ export async function runCommand(argv, opts = {}) {
       });
     }
 
+    case "files move":
+    case "files copy": {
+      const usage = `ait files ${action} <fileId> [--folder <folderId>]`;
+      const fileId = requirePositional(rest, "fileId", usage);
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      // Omitting --folder targets the workspace root, matching the tools'
+      // own default — for `move` that relocates the file, it isn't a no-op.
+      return callTool(ctx, action === "move" ? "move_file" : "copy_file", {
+        workspaceId,
+        fileId,
+        folderId: flags.folder ?? null,
+      });
+    }
+
+    case "folders list": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "list_folders", {
+        workspaceId,
+        ...(flags.parent ? { parentId: flags.parent } : {}),
+        ...(flags.root === true ? { root: true } : {}),
+      });
+    }
+
+    case "folders create": {
+      if (!flags.name) throw new CliError("--name is required for folders create");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "create_folder", {
+        workspaceId,
+        name: flags.name,
+        ...(flags.parent ? { parentId: flags.parent } : {}),
+      });
+    }
+
+    case "folders rename": {
+      const folderId = requirePositional(rest, "folderId", "ait folders rename <folderId> --name <n>");
+      if (!flags.name) throw new CliError("--name is required for folders rename");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "rename_folder", { workspaceId, folderId, name: flags.name });
+    }
+
+    case "folders delete": {
+      const folderId = requirePositional(rest, "folderId", "ait folders delete <folderId> --yes");
+      requireConfirmation(flags, "delete_folder");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "delete_folder", { workspaceId, folderId });
+    }
+
+    case "integrations": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "list_integrations", { workspaceId });
+    }
+
+    case "limits": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "get_platform_limit", {
+        workspaceId,
+        ...(flags.platform !== undefined ? { platform: flags.platform } : {}),
+        ...(flags.text !== undefined ? { text: flags.text } : {}),
+      });
+    }
+
+    case "shorten": {
+      const url = requirePositional([action, ...rest].filter(Boolean), "url", "ait shorten <url> [--title <t>]");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "shorten_url", {
+        workspaceId,
+        url,
+        ...(flags.title ? { title: flags.title } : {}),
+      });
+    }
+
     default:
-      throw new CliError(`Unknown command "${command}". Run "ait help" for usage, or "ait tools" to list MCP tools for "ait call".`);
+      throw new CliError(`Unknown command "${command}". Run "ait help" for the full command list.`);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automate-it",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "CLI for Automate It — AI agents create content tasks, submit them through a human review gate, and publish everywhere. Speaks the Automate It MCP server; zero dependencies.",
   "type": "module",
   "bin": {