automate-it 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Working Dev's Hero LLC
+
+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/README.md

@@ -0,0 +1,48 @@
+# automate-it
+
+CLI for [Automate It](https://automate.it.com) — AI agents create content tasks, submit them through a human review gate, and publish everywhere.
+
+`ait` is a single-file, zero-dependency CLI (Node 18+ or Bun) that speaks Automate It's MCP server. Everything a remote MCP client can do, headlessly: create and work tasks, submit finished content straight into the human review queue, revise after rejection, read workspace skills, and fetch links to published posts.
+
+## Install
+
+```sh
+npm install -g automate-it
+ait --help
+```
+
+Or without installing: `npx automate-it --help`
+
+## Configure
+
+```sh
+export AUTOMATE_IT_API_KEY="ak_..."           # required — create under Profile → API keys
+export AUTOMATE_IT_WORKSPACE="<workspace-id>" # optional; auto-resolved if the key sees one workspace
+```
+
+## Quick start
+
+```sh
+ait workspaces                                  # verify access
+
+# Delegate: the built-in worker generates the content
+ait task create --title "Post about our launch" \
+  --instructions "Write an upbeat announcement." --output-types x
+
+# Or bring your own content — one shot, straight into human review
+ait task submit --title "Launch post" --type x \
+  --body "We're live — new API, faster everything."
+
+ait task get <taskId>                           # todo → working → review → approved → published
+ait task links <taskId>                         # live post URLs once published
+```
+
+Every task passes a human review gate before anything publishes — the reviewer approves, rejects with feedback (revise with `ait task update-content`, then `ait task complete`), or publishes. Your agent never needs your social credentials.
+
+## Documentation
+
+Full setup for Claude Code, Codex, Cursor, OpenClaw, and Hermes, plus the worker-mode loop and complete command reference: **[docs.automate.it.com](https://docs.automate.it.com)**
+
+## License
+
+MIT © Working Dev's Hero LLC

package/ait.mjs

@@ -0,0 +1,637 @@
+#!/usr/bin/env node
+// ait — Automate It CLI for AI agents.
+//
+// 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.
+//
+// Tool output is printed verbatim on stdout; errors go to stderr as
+// {"error": "..."} with exit code 1.
+
+import { pathToFileURL } from "node:url";
+import { realpathSync } from "node:fs";
+
+const DEFAULT_API_URL = "https://api.automate.it.com";
+const REQUEST_TIMEOUT_MS = 120_000;
+const PUBLISH_MODES = ["immediate", "scheduled", "manual"];
+
+export const USAGE = `ait — Automate It CLI for AI agents
+
+Environment:
+  AUTOMATE_IT_API_KEY    (required) API key (ak_*), created in Profile → API keys
+  AUTOMATE_IT_API_URL    API base URL (default: ${DEFAULT_API_URL})
+  AUTOMATE_IT_WORKSPACE  Default workspace id (else pass --workspace, else
+                         auto-resolved when the key has exactly one workspace)
+
+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
+
+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>]
+      [--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
+      content, then: task add-content → task complete.
+      --skills accepts skill names or ids (see \`ait skills list\`).
+      --assign gives the task to a workspace member; the built-in worker
+      skips assigned tasks and the assignee works them.
+  ait task submit --title <t> --body <text>
+      [--type <contentType>] [--media '<json array>'] [same flags as create]
+      One-shot: creates the task WITH finished content — it skips todo/working
+      and lands directly in the human review queue.
+  ait task list [--status <s>] [--mine] [--limit <n>] [--offset <n>]
+      --mine filters to tasks assigned to you (find your agent's work with
+      --mine --status todo).
+                                       Statuses: todo working review approved
+                                       publishing published deleted failed
+  ait task get <taskId>                Full task detail, incl. reviewer comments
+  ait task links <taskId>              Published post URLs for a task
+  ait task claim-next                  Atomically claim the oldest todo task
+  ait task claim <taskId>              Claim a specific todo task
+  ait task add-content <taskId>        Add generated content to a claimed task
+      [--body <text>] [--type <contentType>] [--title <t>]
+      [--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 complete <taskId>           Finish work (status → review/approved)
+  ait task comment <taskId> --comment <text>
+                                       Leave a note for the human reviewer
+  ait task next-review                 Next task waiting for human review
+  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>
+
+Skills (workspace voice, formatting rules, bundled reference files):
+  ait skills list                      id, name, description for each skill
+  ait skills get <skillId>             Full instructions + bundled file ids
+
+Automations:
+  ait automation create --name <n>     [--instructions <text>]
+      [--output-types x,...] [--schedule <json>] [--no-review]
+  ait automation list
+  ait automation get <automationId>
+  ait automation update <automationId> [--name <n>] [--instructions <text>]
+      [--output-types x,...] [--schedule <json>]
+  ait automation delete <automationId>
+  ait automation run <automationId>    Trigger now; returns the spawned task
+
+Files:
+  ait upload-url --filename <f> --mime-type <m>
+                                       Presigned upload URL for media
+  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\`)
+
+All workspace commands accept --workspace <id>.`;
+
+export class CliError extends Error {}
+
+const BOOLEAN_FLAGS = new Set(["no-review", "claim", "mine", "help"]);
+
+export function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    let key = arg.slice(2);
+    let value;
+    const eq = key.indexOf("=");
+    if (eq !== -1) {
+      value = key.slice(eq + 1);
+      key = key.slice(0, eq);
+      if (BOOLEAN_FLAGS.has(key)) value = value !== "false";
+    } else if (BOOLEAN_FLAGS.has(key)) {
+      value = true;
+    } else {
+      value = argv[++i];
+      if (value === undefined) throw new CliError(`Missing value for --${key}`);
+    }
+    flags[key] = value;
+  }
+  return { positional, flags };
+}
+
+function csv(value) {
+  if (!value) return [];
+  return String(value)
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function parseJsonFlag(value, flagName) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new CliError(`--${flagName} must be valid JSON`);
+  }
+}
+
+// Tool results are text designed for agent consumption; some prefix JSON
+// with a status line ("Successfully created task:\n{...}"). This pulls the
+// first JSON value out of such text.
+export function extractJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    // fall through to bracket scan
+  }
+  const candidates = ["{", "["]
+    .map((ch) => text.indexOf(ch))
+    .filter((i) => i !== -1);
+  if (candidates.length === 0) return null;
+  try {
+    return JSON.parse(text.slice(Math.min(...candidates)));
+  } catch {
+    return null;
+  }
+}
+
+function parseRpcResponse(contentType, text) {
+  if (contentType.includes("text/event-stream")) {
+    for (const line of text.split("\n")) {
+      if (!line.startsWith("data:")) continue;
+      let message;
+      try {
+        message = JSON.parse(line.slice(5).trim());
+      } catch {
+        continue;
+      }
+      if (message.result !== undefined || message.error !== undefined) return message;
+    }
+    throw new CliError("No JSON-RPC response found in MCP event stream");
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new CliError(`Unparseable MCP response: ${text.slice(0, 200)}`);
+  }
+}
+
+function baseUrl(ctx) {
+  return (ctx.env.AUTOMATE_IT_API_URL || DEFAULT_API_URL).replace(/\/+$/, "");
+}
+
+function apiKey(ctx) {
+  const key = ctx.env.AUTOMATE_IT_API_KEY;
+  if (!key) {
+    throw new CliError(
+      "AUTOMATE_IT_API_KEY is not set. Create an API key in Automate It (Profile → API keys) and export it."
+    );
+  }
+  return key;
+}
+
+async function mcpRequest(ctx, method, params) {
+  const url = `${baseUrl(ctx)}/mcp`;
+  let res;
+  try {
+    res = await ctx.fetchFn(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey(ctx)}`,
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+      },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+  } catch (err) {
+    throw new CliError(`Request to ${url} failed: ${err?.message || err}`);
+  }
+  const text = await res.text();
+  if (!res.ok) {
+    const detail = extractJson(text)?.error ?? text.slice(0, 200) ?? res.statusText;
+    throw new CliError(`MCP HTTP ${res.status}: ${typeof detail === "string" ? detail : JSON.stringify(detail)}`);
+  }
+  const message = parseRpcResponse(res.headers.get("content-type") || "", text);
+  if (message.error) {
+    throw new CliError(`MCP error ${message.error.code}: ${message.error.message}`);
+  }
+  return message.result;
+}
+
+async function callTool(ctx, name, args) {
+  const result = await mcpRequest(ctx, "tools/call", { name, arguments: args });
+  const text = (result?.content ?? [])
+    .filter((c) => c.type === "text")
+    .map((c) => c.text)
+    .join("\n");
+  if (result?.isError) throw new CliError(text || `Tool ${name} failed`);
+  return text;
+}
+
+async function resolveWorkspace(ctx, flags) {
+  if (flags.workspace) return flags.workspace;
+  if (ctx.env.AUTOMATE_IT_WORKSPACE) return ctx.env.AUTOMATE_IT_WORKSPACE;
+  const workspaces = extractJson(await callTool(ctx, "list_workspaces", {}));
+  if (!Array.isArray(workspaces) || workspaces.length === 0) {
+    throw new CliError("This API key has no workspaces.");
+  }
+  if (workspaces.length === 1) return workspaces[0].id;
+  const options = workspaces.map((w) => `${w.id} (${w.name})`).join(", ");
+  throw new CliError(
+    `Multiple workspaces available — pass --workspace <id> or set AUTOMATE_IT_WORKSPACE. Options: ${options}`
+  );
+}
+
+export function shapeLinks(task) {
+  const results = Array.isArray(task?.publishResults) ? task.publishResults : [];
+  return {
+    taskId: task?.id ?? null,
+    status: task?.status ?? null,
+    links: results.map((r) => ({
+      platform: r.platform ?? null,
+      postUrl: r.postUrl ?? null,
+      postId: r.postId ?? null,
+    })),
+  };
+}
+
+/** 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)) {
+    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,
+    ...(flags["publish-at"] ? { publishAt: flags["publish-at"] } : {}),
+    requiresReview: flags["no-review"] !== true,
+  };
+}
+
+function requirePositional(rest, name, usage) {
+  const value = rest[0];
+  if (!value) throw new CliError(`Usage: ${usage} — missing <${name}>`);
+  return value;
+}
+
+function requirePositionalAt(rest, index, name, usage) {
+  const value = rest[index];
+  if (!value) throw new CliError(`Usage: ${usage} — missing <${name}>`);
+  return value;
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * Turn `--skills "brand-voice,<uuid>"` into skill ids. Agents know skills by
+ * name, so anything that isn't already a uuid is looked up via list_skills.
+ */
+async function resolveSkillIds(ctx, workspaceId, value) {
+  const entries = csv(value);
+  if (entries.length === 0) return [];
+
+  const needsLookup = entries.some((entry) => !UUID_RE.test(entry));
+  if (!needsLookup) return entries;
+
+  const text = await callTool(ctx, "list_skills", { workspaceId });
+  const skills = extractJson(text);
+  if (!Array.isArray(skills)) {
+    throw new CliError(`No skills in this workspace to match ${entries.filter((e) => !UUID_RE.test(e)).join(", ")}`);
+  }
+
+  return entries.map((entry) => {
+    if (UUID_RE.test(entry)) return entry;
+    const match = skills.find((skill) => skill.name?.toLowerCase() === entry.toLowerCase());
+    if (!match) {
+      throw new CliError(`Unknown skill "${entry}". Available: ${skills.map((s) => s.name).join(", ") || "(none)"}`);
+    }
+    return match.id;
+  });
+}
+
+export async function runCommand(argv, opts = {}) {
+  const ctx = {
+    fetchFn: opts.fetchFn || globalThis.fetch,
+    env: opts.env || process.env,
+  };
+  const { positional, flags } = parseArgs(argv);
+  const [resource, action, ...rest] = positional;
+
+  if (!resource || resource === "help" || flags.help === true) {
+    return USAGE;
+  }
+
+  const SINGLE_WORD_COMMANDS = new Set(["tools", "call", "workspaces", "whoami", "upload-url"]);
+  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", {});
+
+    case "whoami":
+      return callTool(ctx, "get_clerk_user_data", {});
+
+    case "upload-url": {
+      if (!flags.filename || !flags["mime-type"]) {
+        throw new CliError("--filename and --mime-type are required for upload-url");
+      }
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "get_upload_url", {
+        workspaceId,
+        filename: flags.filename,
+        mimeType: flags["mime-type"],
+      });
+    }
+
+    case "task create": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      const skillIds = await resolveSkillIds(ctx, workspaceId, flags.skills);
+      return callTool(ctx, "create_task", {
+        workspaceId,
+        ...buildCreateTaskArgs(flags),
+        ...(flags.claim === true ? { claim: true } : {}),
+        ...(flags.assign ? { assignToUserId: flags.assign } : {}),
+        ...(skillIds.length > 0 ? { skillIds } : {}),
+      });
+    }
+
+    case "task submit": {
+      if (!flags.body && !flags.media) {
+        throw new CliError("task submit requires --body and/or --media (finished content)");
+      }
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      const skillIds = await resolveSkillIds(ctx, workspaceId, flags.skills);
+      return callTool(ctx, "create_task", {
+        workspaceId,
+        ...buildCreateTaskArgs(flags),
+        ...(flags.assign ? { assignToUserId: flags.assign } : {}),
+        ...(skillIds.length > 0 ? { skillIds } : {}),
+        content: [
+          {
+            ...(flags.body ? { body: flags.body } : {}),
+            ...(flags.type ? { contentType: flags.type } : {}),
+            ...(flags.media ? { media: parseJsonFlag(flags.media, "media") } : {}),
+          },
+        ],
+      });
+    }
+
+    case "task list": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "list_tasks", {
+        workspaceId,
+        ...(flags.status ? { status: flags.status } : {}),
+        ...(flags.mine === true ? { assignedTo: "me" } : {}),
+        ...(flags.limit !== undefined ? { limit: Number(flags.limit) } : {}),
+        ...(flags.offset !== undefined ? { offset: Number(flags.offset) } : {}),
+      });
+    }
+
+    case "task get":
+    case "task links": {
+      const taskId = requirePositional(rest, "taskId", `ait task ${action} <taskId>`);
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      const text = await callTool(ctx, "get_task", { workspaceId, taskId });
+      if (action === "get") return text;
+      const task = extractJson(text);
+      if (!task) throw new CliError(`Could not parse task detail from MCP response: ${text.slice(0, 200)}`);
+      return shapeLinks(task);
+    }
+
+    case "task claim":
+    case "task complete":
+    case "task approve":
+    case "task delete": {
+      const toolByAction = {
+        claim: "claim_task",
+        complete: "complete_task",
+        approve: "approve_task",
+        delete: "delete_task",
+      };
+      const taskId = requirePositional(rest, "taskId", `ait task ${action} <taskId>`);
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, toolByAction[action], { workspaceId, taskId });
+    }
+
+    case "task reject": {
+      const taskId = requirePositional(rest, "taskId", "ait task reject <taskId> [--comment <text>]");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "reject_task", {
+        workspaceId,
+        taskId,
+        ...(flags.comment ? { comment: flags.comment } : {}),
+      });
+    }
+
+    case "task publish": {
+      const taskId = requirePositional(rest, "taskId", "ait task publish <taskId> [--platforms a,b]");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "publish_task", {
+        workspaceId,
+        taskId,
+        ...(flags.platforms ? { platforms: csv(flags.platforms) } : {}),
+      });
+    }
+
+    case "task add-content": {
+      const taskId = requirePositional(rest, "taskId", "ait task add-content <taskId> --body <text>");
+      if (!flags.body && !flags.media) {
+        throw new CliError("task add-content requires --body and/or --media");
+      }
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "add_content_to_task", {
+        workspaceId,
+        taskId,
+        ...(flags.title ? { title: flags.title } : {}),
+        ...(flags.body ? { body: flags.body } : {}),
+        ...(flags.type ? { contentType: flags.type } : {}),
+        ...(flags.media ? { media: parseJsonFlag(flags.media, "media") } : {}),
+        ...(flags["sort-order"] !== undefined ? { sortOrder: Number(flags["sort-order"]) } : {}),
+      });
+    }
+
+    case "task next-review": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "get_next_review_task", { workspaceId });
+    }
+
+    case "automation create": {
+      if (!flags.name) throw new CliError("--name is required for automation create");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "create_automation", {
+        workspaceId,
+        name: flags.name,
+        ...(flags.instructions ? { instructions: flags.instructions } : {}),
+        outputTypes: csv(flags["output-types"]),
+        ...(flags.schedule ? { schedule: parseJsonFlag(flags.schedule, "schedule") } : {}),
+        requiresReview: flags["no-review"] !== true,
+      });
+    }
+
+    case "automation list": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "list_automations", { workspaceId });
+    }
+
+    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";
+      return callTool(ctx, tool, { workspaceId, automationId });
+    }
+
+    case "automation update": {
+      const automationId = requirePositional(rest, "automationId", "ait automation update <automationId> [flags]");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "update_automation", {
+        workspaceId,
+        automationId,
+        ...(flags.name ? { name: flags.name } : {}),
+        ...(flags.instructions ? { instructions: flags.instructions } : {}),
+        ...(flags["output-types"] ? { outputTypes: csv(flags["output-types"]) } : {}),
+        ...(flags.schedule ? { schedule: parseJsonFlag(flags.schedule, "schedule") } : {}),
+      });
+    }
+
+    case "automation run": {
+      const automationId = requirePositional(rest, "automationId", "ait automation run <automationId>");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "run_automation", { workspaceId, automationId });
+    }
+
+    case "task claim-next": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "claim_next_task", { workspaceId });
+    }
+
+    case "task comment": {
+      const taskId = requirePositional(rest, "taskId", 'ait task comment <taskId> --comment "..."');
+      if (!flags.comment) throw new CliError("--comment is required for task comment");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "add_task_comment", { workspaceId, taskId, comment: flags.comment });
+    }
+
+    case "task update-content": {
+      const usage = "ait task update-content <taskId> <contentItemId>";
+      const taskId = requirePositionalAt(rest, 0, "taskId", usage);
+      const contentItemId = requirePositionalAt(rest, 1, "contentItemId", usage);
+      if (flags.body === undefined && flags.title === undefined) {
+        throw new CliError("at least one of --body or --title is required for task update-content");
+      }
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "update_content_item", {
+        workspaceId,
+        taskId,
+        contentItemId,
+        ...(flags.body !== undefined ? { body: flags.body } : {}),
+        ...(flags.title !== undefined ? { title: flags.title } : {}),
+      });
+    }
+
+    case "task delete-content": {
+      const usage = "ait task delete-content <taskId> <contentItemId>";
+      const taskId = requirePositionalAt(rest, 0, "taskId", usage);
+      const contentItemId = requirePositionalAt(rest, 1, "contentItemId", usage);
+      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 workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "clear_task_content", { workspaceId, taskId });
+    }
+
+    case "skills list": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "list_skills", { workspaceId });
+    }
+
+    case "skills get": {
+      const skillId = requirePositional(rest, "skillId", "ait skills get <skillId>");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "get_skill", { workspaceId, skillId });
+    }
+
+    case "files download-url": {
+      const fileId = requirePositional(rest, "fileId", "ait files download-url <fileId>");
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "get_download_url", {
+        workspaceId,
+        fileId,
+        ...(flags["expires-in"] !== undefined ? { expiresIn: Number(flags["expires-in"]) } : {}),
+      });
+    }
+
+    case "files list": {
+      const workspaceId = await resolveWorkspace(ctx, flags);
+      return callTool(ctx, "list_workspace_files", {
+        workspaceId,
+        ...(flags.search ? { search: flags.search } : {}),
+        ...(flags["mime-type"] ? { mimeType: flags["mime-type"] } : {}),
+        ...(flags.limit !== undefined ? { limit: Number(flags.limit) } : {}),
+      });
+    }
+
+    default:
+      throw new CliError(`Unknown command "${command}". Run "ait help" for usage, or "ait tools" to list MCP tools for "ait call".`);
+  }
+}
+
+const isMain = (() => {
+  try {
+    // realpath both sides: npm installs the bin as a symlink, so argv[1] is
+    // the link while import.meta.url is the resolved file.
+    return import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href;
+  } catch {
+    return false;
+  }
+})();
+
+if (isMain) {
+  runCommand(process.argv.slice(2))
+    .then((result) => {
+      const output = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+      process.stdout.write(`${output}\n`);
+    })
+    .catch((err) => {
+      process.stderr.write(`${JSON.stringify({ error: err?.message || String(err) })}\n`);
+      process.exit(1);
+    });
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "automate-it",
+  "version": "0.1.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": {
+    "ait": "./ait.mjs"
+  },
+  "files": [
+    "ait.mjs"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "homepage": "https://docs.automate.it.com",
+  "keywords": [
+    "automate-it",
+    "mcp",
+    "ai-agents",
+    "agent-skills",
+    "cli",
+    "content-automation",
+    "social-media",
+    "human-in-the-loop"
+  ]
+}