automate-it 0.1.1 → 0.3.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,17 +31,21 @@ 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
       [--instructions <text>] [--output-types x,linkedin,...]
       [--publish-mode manual|immediate|scheduled] [--publish-at <ISO date>]
+      Omitted --publish-mode falls back to the workspace's default publish
+      mode; scheduled without --publish-at auto-schedules at approval.
       [--no-review] [--claim] [--skills <names or ids>] [--assign <userId|me>]
       --claim creates the task already claimed (status "working") so the
       built-in worker never picks it up — use it when YOU will generate the
@@ -62,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
@@ -71,7 +81,12 @@ Tasks (the review-gate loop):
   ait task approve <taskId>            Approve (reviewer/admin keys)
   ait task reject <taskId> [--comment <text>]
   ait task publish <taskId> [--platforms a,b]
-  ait task delete <taskId>
+  ait task schedule <taskId> --at <ISO date> | --auto | --clear
+                                       Schedule an approved task to publish
+                                       later; --auto picks the next open slot
+                                       per the workspace's scheduling rules;
+                                       --clear returns it to manual
+  ait task delete <taskId> --yes
 
 Skills (workspace voice, formatting rules, bundled reference files):
   ait skills list                      id, name, description for each skill
@@ -84,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:
@@ -93,13 +110,52 @@ 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 x-limit [--text <draft>]         X's limit for the connected account
+                                       (280 or 25000). With --text, returns the
+                                       draft's weighted length and whether it
+                                       fits — a URL counts 23, emoji 2.
+  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", "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 = [];
@@ -268,18 +324,15 @@ export function shapeLinks(task) {
 /** Fields shared by `task create` and `task submit`. */
 function buildCreateTaskArgs(flags) {
   if (!flags.title) throw new CliError("--title is required for task create");
-  const publishMode = flags["publish-mode"] || "manual";
-  if (!PUBLISH_MODES.includes(publishMode)) {
+  const publishMode = flags["publish-mode"];
+  if (publishMode && !PUBLISH_MODES.includes(publishMode)) {
     throw new CliError(`--publish-mode must be one of: ${PUBLISH_MODES.join(", ")}`);
   }
-  if (publishMode === "scheduled" && !flags["publish-at"]) {
-    throw new CliError('--publish-at is required when --publish-mode is "scheduled"');
-  }
   return {
     title: flags.title,
     ...(flags.instructions ? { instructions: flags.instructions } : {}),
     outputTypes: csv(flags["output-types"]),
-    publishMode,
+    ...(publishMode ? { publishMode } : {}),
     ...(flags["publish-at"] ? { publishAt: flags["publish-at"] } : {}),
     requiresReview: flags["no-review"] !== true,
   };
@@ -338,28 +391,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",
+    "x-limit",
+    "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", {});
 
@@ -444,6 +488,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 });
     }
@@ -468,6 +513,27 @@ export async function runCommand(argv, opts = {}) {
       });
     }
 
+    case "task schedule": {
+      const taskId = requirePositional(rest, "taskId", "ait task schedule <taskId> --at <ISO date> | --auto | --clear");
+      const modes = [flags.at ? "--at" : null, flags.auto === true ? "--auto" : null, flags.clear === true ? "--clear" : null].filter(Boolean);
+      if (modes.length > 1) {
+        throw new CliError(`Use only one of --at, --auto, --clear (got ${modes.join(" and ")})`);
+      }
+      let publishAt = null;
+      if (flags.auto === true) {
+        publishAt = "auto";
+      } else if (flags.clear !== true) {
+        if (!flags.at) {
+          throw new CliError("task schedule requires --at <ISO date>, --auto, or --clear");
+        }
+        const at = new Date(flags.at);
+        if (isNaN(at.getTime())) throw new CliError(`--at is not a valid date: ${flags.at}`);
+        publishAt = at.toISOString();
+      }
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "schedule_task", { workspaceId, taskId, publishAt });
+    }
+
     case "task add-content": {
       const taskId = requirePositional(rest, "taskId", "ait task add-content <taskId> --body <text>");
       if (!flags.body && !flags.media) {
@@ -511,8 +577,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 });
     }
 
@@ -565,15 +632,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 });
     }
@@ -609,8 +678,78 @@ 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 "x-limit": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "get_x_character_limit", {
+        workspaceId,
+        ...(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.1.1",
+  "version": "0.3.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": {