@aident-ai/cli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aident AI, Inc.
+
+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,120 @@
+# @aident-ai/cli
+
+The Aident command-line interface — agent-friendly access to 1000+ integrations, automation playbooks, and the full Aident platform.
+
+```bash
+aident login
+aident capabilities search --query "send email"
+aident playbooks list --json
+```
+
+This is the recommended way to use Aident from any coding agent (Claude Code, OpenClaw, HermesAgent, Cursor, …) or shell automation. The CLI is a thin wrapper around the Aident command engine — every command you run on the platform UI is available here, with the same semantics.
+
+## Install
+
+### One-line install (recommended)
+
+**macOS / Linux:**
+
+```bash
+curl -fsSL https://app.aident.ai/cli/install.sh | bash
+```
+
+**Windows (PowerShell, with Git Bash installed):**
+
+```powershell
+& "C:\Program Files\Git\bin\bash.exe" -c 'curl -fsSL https://app.aident.ai/cli/install.sh | bash'
+```
+
+The installer requires Node ≥ 18. If you don't have it, install via [nodejs.org](https://nodejs.org) or a version manager (`brew install node`, `nvm install --lts`, `fnm install --lts`) and re-run.
+
+### Manual install
+
+```bash
+# One-off (no install)
+npx -y @aident-ai/cli <command>
+
+# Global
+npm install -g @aident-ai/cli
+```
+
+## Get started
+
+```bash
+aident setup           # interactive: pick base URL + log in
+aident doctor          # validate installation
+aident --help          # discover packages and domains
+```
+
+The browser-based sign-in uses PKCE on a localhost loopback. If you can't bind a port (locked-down sandboxes, remote shells), pass `--oob`:
+
+```bash
+aident login --oob
+```
+
+That falls back to the OOB copy-paste flow.
+
+## Common commands
+
+```bash
+aident capabilities --help                             # list commands in a domain
+aident capabilities search --help                      # show input schema and examples
+aident capabilities search --query "send email"        # run a command (TUI output)
+aident playbooks list --json                           # JSON output for piping
+aident playbooks execute --playbookId pb_123           # run a playbook
+aident integrations status                             # see connected integrations
+aident logout                                          # revoke and clear creds
+```
+
+Use `--json` for machine-readable output. The CLI auto-detects whether stdout is a TTY.
+
+## Configuration
+
+The CLI persists settings to `~/.aident/config.json` and credentials to `~/.aident/credentials.json` — the same `~/.aident/` directory used by the Aident skill, the desktop sandbox app, and any other Aident tooling.
+
+```bash
+aident config show                       # print all config
+aident config get baseUrl                # print one value
+aident config set baseUrl https://...    # persist a value
+aident config unset baseUrl              # remove an override
+aident config path                       # print the config file path
+```
+
+| Key       | Default                 | Purpose                                                    |
+| --------- | ----------------------- | ---------------------------------------------------------- |
+| `baseUrl` | `https://app.aident.ai` | API host used for new logins. Save once, reuse everywhere. |
+
+### Resolution order for the API base URL
+
+1. `AIDENT_BASE_URL` env var (per-invocation override)
+2. `aident login --base-url <url>` (only at login time)
+3. `~/.aident/config.json` `baseUrl`
+4. Active credentials file (after login carries its own host)
+5. Default `https://app.aident.ai`
+
+### Environment overrides
+
+| Variable          | Purpose                                                                   |
+| ----------------- | ------------------------------------------------------------------------- |
+| `AIDENT_TOKEN`    | Use this Bearer token directly; skips the credentials file. Useful in CI. |
+| `AIDENT_BASE_URL` | Override the default server for a single invocation.                      |
+
+## Where files live
+
+| Path                                 | Owner               | Purpose                                      |
+| ------------------------------------ | ------------------- | -------------------------------------------- |
+| `~/.aident/config.json`              | CLI (this package)  | Persistent settings (`baseUrl`, …)           |
+| `~/.aident/credentials.json`         | CLI + Aident skill  | OAuth tokens for `aident` / agent skill REST |
+| `~/.aident/sandbox-credentials.json` | Sandbox desktop app | Tokens used by the local sandbox runtime     |
+| `~/.aident/sandbox-workspaces.json`  | Sandbox desktop app | Tracked workspace directories                |
+| `~/.aident/sandbox/`                 | Sandbox daemon      | Daemon PID, status, logs                     |
+
+All Aident tooling shares this directory; nothing escapes outside `~/.aident/`.
+
+## How it works
+
+`aident <domain> <command> [args]` makes a `POST /api/cli/exec` request to the Aident server with `{ domain, command, args }`, the same shape used internally by the platform's CLI engine. Discovery (`--help`, schemas, examples) comes from `GET /api/cli`. The CLI is a thin layer — there is no Aident logic baked in. Anything you can do on the web app, you can do here.
+
+## License
+
+MIT

package/dist/cli.mjs

@@ -0,0 +1,1138 @@
+#!/usr/bin/env node
+
+// src/auth.ts
+import { spawn } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+
+// src/credentials.ts
+import { mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// src/config.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function getAidentDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || homedir();
+  return join(home, ".aident");
+}
+function getConfigFile() {
+  return join(getAidentDir(), "config.json");
+}
+var DEFAULT_BASE_URL = "https://app.aident.ai";
+var CONFIG_KEYS = ["baseUrl"];
+async function readConfig() {
+  try {
+    const text = await readFile(getConfigFile(), "utf-8");
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== "object")
+      return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function writeConfig(config) {
+  await mkdir(getAidentDir(), { recursive: true, mode: 448 });
+  await writeFile(getConfigFile(), JSON.stringify(config, null, 2) + `
+`, { mode: 420 });
+}
+async function setConfigValue(key, value) {
+  const config = await readConfig();
+  config[key] = value;
+  await writeConfig(config);
+}
+async function unsetConfigValue(key) {
+  const config = await readConfig();
+  delete config[key];
+  await writeConfig(config);
+}
+async function resolveDefaultBaseUrl() {
+  const env = process.env.AIDENT_BASE_URL?.trim();
+  if (env)
+    return env;
+  const config = await readConfig();
+  if (typeof config.baseUrl === "string" && config.baseUrl.trim() !== "") {
+    return config.baseUrl.trim();
+  }
+  return DEFAULT_BASE_URL;
+}
+function isKnownConfigKey(key) {
+  return CONFIG_KEYS.includes(key);
+}
+function normalizeBaseUrl(url) {
+  let trimmed = url.trim();
+  if (!/^https?:\/\//i.test(trimmed))
+    trimmed = `https://${trimmed}`;
+  return trimmed.replace(/\/+$/, "");
+}
+
+// src/credentials.ts
+function getCredentialsFile() {
+  return join2(getAidentDir(), "credentials.json");
+}
+async function readCredentials() {
+  try {
+    const content = await readFile2(getCredentialsFile(), "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed.access_token || !parsed.base_url)
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCredentials(creds) {
+  await mkdir2(getAidentDir(), { recursive: true, mode: 448 });
+  await writeFile2(getCredentialsFile(), JSON.stringify(creds, null, 2), { mode: 384 });
+}
+async function clearCredentials() {
+  await rm(getCredentialsFile(), { force: true });
+}
+function isExpired(creds) {
+  if (!creds.expires_at)
+    return false;
+  const expiresAt = Date.parse(creds.expires_at);
+  if (Number.isNaN(expiresAt))
+    return false;
+  return Date.now() >= expiresAt - 60000;
+}
+
+// src/output.ts
+var isTTY = process.stdout.isTTY === true;
+var colors = {
+  reset: isTTY ? "\x1B[0m" : "",
+  red: isTTY ? "\x1B[31m" : "",
+  green: isTTY ? "\x1B[32m" : "",
+  yellow: isTTY ? "\x1B[33m" : "",
+  cyan: isTTY ? "\x1B[36m" : "",
+  dim: isTTY ? "\x1B[2m" : "",
+  bold: isTTY ? "\x1B[1m" : ""
+};
+function logInfo(text) {
+  process.stdout.write(text + `
+`);
+}
+function logErr(text) {
+  process.stderr.write(text + `
+`);
+}
+
+// src/prompt.ts
+function readLine(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    let data = "";
+    const onData = (chunk) => {
+      const s = chunk.toString("utf-8");
+      const newlineIdx = s.indexOf(`
+`);
+      if (newlineIdx === -1) {
+        data += s;
+        return;
+      }
+      data += s.slice(0, newlineIdx);
+      process.stdin.removeListener("data", onData);
+      process.stdin.pause();
+      resolve(data.replace(/\r$/, ""));
+    };
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+
+// src/auth.ts
+var CLIENT_NAME = "aident-cli";
+async function login(options) {
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  if (options.oob)
+    return loginOob(baseUrl);
+  try {
+    return await loginLoopback(baseUrl);
+  } catch (err) {
+    logErr(`Loopback OAuth failed (${err instanceof Error ? err.message : String(err)}). Falling back to OOB flow.`);
+    return loginOob(baseUrl);
+  }
+}
+async function refreshToken(creds) {
+  if (!creds.refresh_token || !creds.client_id)
+    return null;
+  const baseUrl = creds.base_url.replace(/\/+$/, "");
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: creds.client_id,
+    refresh_token: creds.refresh_token
+  });
+  const res = await fetch(`${baseUrl}/api/mcp/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  if (!res.ok)
+    return null;
+  const tok = await res.json();
+  return updateCredsFromToken(creds, tok);
+}
+async function logout(creds) {
+  const baseUrl = creds.base_url.replace(/\/+$/, "");
+  await fetch(`${baseUrl}/api/mcp/oauth/revoke`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Bearer ${creds.access_token}`
+    },
+    body: new URLSearchParams({ token: creds.access_token })
+  }).catch(() => {
+    return;
+  });
+}
+async function loginLoopback(baseUrl) {
+  const verifier = base64UrlEncode(randomBytes(48));
+  const challenge = base64UrlEncode(createHash("sha256").update(verifier).digest());
+  const state = base64UrlEncode(randomBytes(16));
+  const { server, port, codePromise } = await startCallbackServer(state);
+  const redirectUri = `http://localhost:${port}/callback`;
+  const clientId = await registerClient(baseUrl, [redirectUri]);
+  const authorizeUrl = new URL(`${baseUrl}/api/mcp/oauth/authorize`);
+  authorizeUrl.searchParams.set("response_type", "code");
+  authorizeUrl.searchParams.set("client_id", clientId);
+  authorizeUrl.searchParams.set("redirect_uri", redirectUri);
+  authorizeUrl.searchParams.set("code_challenge", challenge);
+  authorizeUrl.searchParams.set("code_challenge_method", "S256");
+  authorizeUrl.searchParams.set("state", state);
+  logInfo(`Opening browser for Aident login...`);
+  logInfo(`If the browser does not open, visit: ${authorizeUrl.toString()}`);
+  openBrowser(authorizeUrl.toString());
+  let code;
+  try {
+    code = await codePromise;
+  } finally {
+    server.close();
+  }
+  const tok = await exchangeCode(baseUrl, clientId, code, redirectUri, verifier);
+  return buildCreds(baseUrl, clientId, tok);
+}
+async function loginOob(baseUrl) {
+  const redirectUri = `${baseUrl}/mcp/oob`;
+  const verifier = base64UrlEncode(randomBytes(48));
+  const challenge = base64UrlEncode(createHash("sha256").update(verifier).digest());
+  const state = base64UrlEncode(randomBytes(16));
+  const clientId = await reuseOrRegisterClient(baseUrl, [redirectUri]);
+  const authorizeUrl = new URL(`${baseUrl}/api/mcp/oauth/authorize`);
+  authorizeUrl.searchParams.set("response_type", "code");
+  authorizeUrl.searchParams.set("client_id", clientId);
+  authorizeUrl.searchParams.set("redirect_uri", redirectUri);
+  authorizeUrl.searchParams.set("code_challenge", challenge);
+  authorizeUrl.searchParams.set("code_challenge_method", "S256");
+  authorizeUrl.searchParams.set("state", state);
+  logInfo(`Opening browser for Aident login...`);
+  logInfo(`If the browser does not open, visit: ${authorizeUrl.toString()}`);
+  openBrowser(authorizeUrl.toString());
+  logInfo("After approving, paste the value shown on the Aident page below.");
+  logInfo("(It will be either an authorization code — preferred — or a raw access token.)");
+  const pasted = (await readLine("Paste here: ")).trim();
+  if (!pasted)
+    throw new Error("No token provided");
+  try {
+    const tok = await exchangeCode(baseUrl, clientId, pasted, redirectUri, verifier);
+    return buildCreds(baseUrl, clientId, tok);
+  } catch (err) {
+    if (err instanceof OAuthRejectedError) {
+      if (!looksLikeAccessToken(pasted)) {
+        throw new Error("Pasted value is neither a valid authorization code nor a recognizable access token. Please retry the login.");
+      }
+      logErr(`Server rejected the pasted value as an authorization code. Treating it as a raw access token. Note: token refresh is unavailable in this mode — when the token expires you'll need to run \`aident login\` again.`);
+      return { base_url: baseUrl, client_id: clientId, access_token: pasted };
+    }
+    throw err;
+  }
+}
+function looksLikeAccessToken(value) {
+  if (value.length < 20)
+    return false;
+  if (/\s/.test(value))
+    return false;
+  return /^[A-Za-z0-9._-]+$/.test(value);
+}
+async function reuseOrRegisterClient(baseUrl, redirectUris) {
+  const existing = await readCredentials();
+  if (existing && existing.client_id && existing.base_url === baseUrl)
+    return existing.client_id;
+  return registerClient(baseUrl, redirectUris);
+}
+async function registerClient(baseUrl, redirectUris) {
+  const res = await fetch(`${baseUrl}/api/mcp/oauth/register`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      client_name: CLIENT_NAME,
+      redirect_uris: redirectUris,
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none"
+    })
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Failed to register OAuth client (HTTP ${res.status}): ${text}`);
+  }
+  const json = await res.json();
+  if (!json.client_id)
+    throw new Error("OAuth registration response missing client_id");
+  return json.client_id;
+}
+
+class OAuthRejectedError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "OAuthRejectedError";
+  }
+}
+async function exchangeCode(baseUrl, clientId, code, redirectUri, verifier) {
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: clientId,
+    code,
+    redirect_uri: redirectUri,
+    code_verifier: verifier
+  });
+  const res = await fetch(`${baseUrl}/api/mcp/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    if (res.status >= 400 && res.status < 500) {
+      throw new OAuthRejectedError(`Token exchange rejected (HTTP ${res.status}): ${text}`, res.status);
+    }
+    throw new Error(`Token exchange failed (HTTP ${res.status}): ${text}`);
+  }
+  return await res.json();
+}
+function buildCreds(baseUrl, clientId, tok) {
+  const expiresAt = tok.expires_in ? new Date(Date.now() + tok.expires_in * 1000).toISOString() : undefined;
+  return {
+    base_url: baseUrl,
+    client_id: clientId,
+    access_token: tok.access_token,
+    refresh_token: tok.refresh_token,
+    expires_at: expiresAt
+  };
+}
+function updateCredsFromToken(creds, tok) {
+  const expiresAt = tok.expires_in ? new Date(Date.now() + tok.expires_in * 1000).toISOString() : creds.expires_at;
+  return {
+    ...creds,
+    access_token: tok.access_token,
+    refresh_token: tok.refresh_token ?? creds.refresh_token,
+    expires_at: expiresAt
+  };
+}
+var LOOPBACK_TIMEOUT_MS = 5 * 60 * 1000;
+function startCallbackServer(expectedState) {
+  return new Promise((resolve, reject) => {
+    let codeResolver = () => {
+      return;
+    };
+    let codeRejecter = () => {
+      return;
+    };
+    const codePromise = new Promise((res, rej) => {
+      codeResolver = res;
+      codeRejecter = rej;
+    });
+    const timeout = setTimeout(() => {
+      codeRejecter(new Error(`No callback received within ${LOOPBACK_TIMEOUT_MS / 1000}s; aborting.`));
+    }, LOOPBACK_TIMEOUT_MS);
+    codePromise.finally(() => clearTimeout(timeout));
+    const server = createServer((req, res) => {
+      if (!req.url) {
+        res.writeHead(400);
+        res.end("Bad request");
+        return;
+      }
+      const url = new URL(req.url, `http://localhost`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      if (error) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`<html><body><h2>Authentication error</h2><p>${escapeHtml(error)}</p></body></html>`);
+        codeRejecter(new Error(`OAuth error: ${error}`));
+        return;
+      }
+      if (!code || state !== expectedState) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h2>Invalid callback</h2></body></html>");
+        codeRejecter(new Error("Invalid callback (missing code or bad state)"));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(`<html><body style="font-family:system-ui;padding:40px;text-align:center"><h2>You're signed in.</h2><p>You can close this window and return to the terminal.</p></body></html>`);
+      codeResolver(code);
+    });
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolve({ server, port: addr.port, codePromise });
+    });
+  });
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  const args = process.platform === "win32" ? ["", url] : [url];
+  try {
+    spawn(cmd, args, { stdio: "ignore", detached: true, shell: process.platform === "win32" }).unref();
+  } catch {}
+}
+function base64UrlEncode(buf) {
+  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/version.ts
+var VERSION = "0.0.0";
+
+// src/client.ts
+class CliClient {
+  creds;
+  constructor(creds) {
+    this.creds = creds;
+  }
+  get baseUrl() {
+    return this.creds.base_url.replace(/\/+$/, "");
+  }
+  updateCredentials(creds) {
+    this.creds = creds;
+  }
+  async getCatalog() {
+    return this.fetchJson("GET", "/api/cli");
+  }
+  async exec(domain, command, args) {
+    return this.fetchJson("POST", "/api/cli/exec", { domain, command, args });
+  }
+  async fetchJson(method, path, body) {
+    const headers = {
+      Authorization: `Bearer ${this.creds.access_token}`,
+      "User-Agent": `@aident/cli/${VERSION}`
+    };
+    if (body !== undefined)
+      headers["Content-Type"] = "application/json";
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    const text = await res.text();
+    try {
+      return { status: res.status, body: JSON.parse(text) };
+    } catch {
+      return { status: res.status, body: invalidResponseFallback(text) };
+    }
+  }
+}
+function invalidResponseFallback(text) {
+  return { success: false, error: { code: "invalid-response", message: text } };
+}
+
+// src/doctor.ts
+async function runDoctor(opts) {
+  const checks = [];
+  checks.push(checkNodeVersion());
+  checks.push(await checkConfig());
+  checks.push(await checkCredentials(opts.baseUrl));
+  checks.push(await checkServerReachable(opts.baseUrl));
+  const ok = checks.every((c) => c.ok);
+  return { ok, checks, ...opts };
+}
+function checkNodeVersion() {
+  const version = process.versions.node;
+  const major = Number(version.split(".")[0]);
+  const ok = Number.isFinite(major) && major >= 18;
+  return {
+    name: "Node.js >= 18",
+    ok,
+    detail: ok ? `node v${version}` : `node v${version} (need >= 18)`
+  };
+}
+async function checkConfig() {
+  const config = await readConfig();
+  const hasBaseUrl = typeof config.baseUrl === "string" && config.baseUrl.length > 0;
+  return {
+    name: "Config file",
+    ok: true,
+    detail: hasBaseUrl ? `baseUrl=${config.baseUrl}` : "no overrides (using defaults)"
+  };
+}
+async function checkCredentials(baseUrl) {
+  if (process.env.AIDENT_TOKEN) {
+    return { name: "Authenticated", ok: true, detail: "using AIDENT_TOKEN env var" };
+  }
+  const creds = await readCredentials();
+  if (!creds) {
+    return { name: "Authenticated", ok: false, detail: "no credentials — run `aident login`" };
+  }
+  if (creds.base_url !== baseUrl) {
+    return {
+      name: "Authenticated",
+      ok: false,
+      detail: `credentials are for ${creds.base_url} but config baseUrl is ${baseUrl} — run \`aident login\``
+    };
+  }
+  return { name: "Authenticated", ok: true, detail: `signed in to ${creds.base_url}` };
+}
+async function checkServerReachable(baseUrl) {
+  try {
+    const res = await fetch(`${baseUrl}/api/cli`, {
+      method: "GET",
+      headers: { "User-Agent": `@aident/cli/${VERSION}` }
+    });
+    if (res.status === 426) {
+      const minVersion = res.headers.get("x-aident-min-cli-version") ?? "newer";
+      return {
+        name: "Server reachable",
+        ok: false,
+        detail: `${baseUrl} requires @aident/cli ≥ ${minVersion} — run \`npm install -g @aident/cli@latest\``
+      };
+    }
+    if (res.status === 401 || res.status === 200) {
+      return { name: "Server reachable", ok: true, detail: `${baseUrl} responded ${res.status}` };
+    }
+    return { name: "Server reachable", ok: false, detail: `${baseUrl} responded ${res.status}` };
+  } catch (err) {
+    return {
+      name: "Server reachable",
+      ok: false,
+      detail: `failed to reach ${baseUrl}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+
+// src/help.ts
+function renderHelp(catalog) {
+  const lines = [];
+  lines.push(`${colors.bold}AIDENT — Platform Feature CLI${colors.reset}`);
+  lines.push("");
+  lines.push("USAGE:");
+  lines.push("  aident <domain> <command> [--flag value ...] [--json]");
+  lines.push("  aident login            Authenticate with Aident");
+  lines.push("  aident logout           Revoke the current token");
+  lines.push("  aident whoami           Show current user");
+  lines.push("  aident <domain> help    List commands in a domain");
+  lines.push("  aident <domain> <command> help    Show input schema and examples");
+  lines.push("");
+  if (catalog.packages.length > 0) {
+    lines.push("PACKAGES:");
+    for (const pkg of catalog.packages) {
+      lines.push(`  ${pkg.name.padEnd(10)} ${pkg.description}`);
+    }
+    lines.push("");
+  }
+  lines.push("DOMAINS:");
+  for (const d of catalog.domains) {
+    const display = d.isAdmin ? `admin ${d.name.replace("admin:", "")}` : d.name;
+    lines.push(`  ${display.padEnd(28)} ${d.description} ${colors.dim}(${d.commandCount})${colors.reset}`);
+  }
+  return lines.join(`
+`);
+}
+function renderDomainHelp(catalog, domain) {
+  const cmds = catalog.commands.filter((c) => c.domain === domain);
+  if (cmds.length === 0)
+    return `Unknown domain: ${domain}`;
+  const dInfo = catalog.domains.find((d) => d.name === domain);
+  const display = domain.startsWith("admin:") ? `admin ${domain.replace("admin:", "")}` : domain;
+  const lines = [];
+  lines.push(`${colors.bold}AIDENT ${display.toUpperCase()}${colors.reset}`);
+  if (dInfo?.description) {
+    lines.push("");
+    lines.push(dInfo.description);
+  }
+  lines.push("");
+  lines.push("COMMANDS:");
+  for (const c of cmds) {
+    lines.push(`  ${c.command.padEnd(28)} ${c.description}`);
+  }
+  lines.push("");
+  lines.push(`Run "aident ${display} <command> help" for input schema and examples.`);
+  return lines.join(`
+`);
+}
+function renderCommandHelp(catalog, domain, command) {
+  const cmd = catalog.commands.find((c) => c.domain === domain && c.command === command);
+  if (!cmd)
+    return `Unknown command: ${domain} ${command}`;
+  const display = domain.startsWith("admin:") ? `admin ${domain.replace("admin:", "")}` : domain;
+  const lines = [];
+  lines.push(`${colors.bold}AIDENT ${display.toUpperCase()} ${command.toUpperCase()}${colors.reset}`);
+  lines.push("");
+  lines.push(cmd.description);
+  if (cmd.longDescription) {
+    lines.push("");
+    lines.push(cmd.longDescription);
+  }
+  const schema = cmd.inputSchema;
+  if (schema?.properties) {
+    const required = new Set(schema.required ?? []);
+    lines.push("");
+    lines.push("INPUT:");
+    for (const [key, val] of Object.entries(schema.properties)) {
+      const tag = required.has(key) ? "" : " (optional)";
+      const type = val.type ? ` ${colors.dim}<${val.type}>${colors.reset}` : "";
+      lines.push(`  --${key.padEnd(24)}${type} ${val.description ?? ""}${tag}`);
+    }
+  }
+  if (cmd.outputDescription) {
+    lines.push("");
+    lines.push(`OUTPUT: ${cmd.outputDescription}`);
+  }
+  if (cmd.examples && cmd.examples.length > 0) {
+    lines.push("");
+    lines.push("EXAMPLES:");
+    for (const ex of cmd.examples) {
+      lines.push(`  ${colors.dim}# ${ex.description}${colors.reset}`);
+      const argStr = Object.entries(ex.args).map(([k, v]) => `--${k} ${typeof v === "string" ? `"${v}"` : JSON.stringify(v)}`).join(" ");
+      lines.push(`  aident ${display} ${command} ${argStr}`);
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/parser.ts
+var RESERVED_CLI_FLAGS = ["base-url", "json", "tui", "help", "oob", "version"];
+function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  let isHelp = false;
+  let format = process.stdout.isTTY === true ? "tui" : "json";
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === undefined) {
+      i++;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h" || arg === "help") {
+      isHelp = true;
+      i++;
+      continue;
+    }
+    if (arg === "--json") {
+      format = "json";
+      i++;
+      continue;
+    }
+    if (arg === "--tui") {
+      format = "tui";
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next === undefined || next.startsWith("--")) {
+        flags[key] = true;
+        i++;
+      } else {
+        flags[key] = coerce(next);
+        i += 2;
+      }
+      continue;
+    }
+    positional.push(arg);
+    i++;
+  }
+  return { positional, flags, format, isHelp, raw: argv };
+}
+function coerce(val) {
+  if (val === "true")
+    return true;
+  if (val === "false")
+    return false;
+  if (val === "null")
+    return null;
+  if (val.startsWith("{") || val.startsWith("[")) {
+    try {
+      return JSON.parse(val);
+    } catch {}
+  }
+  if (val.trim() !== "" && /^-?\d+(\.\d+)?$/.test(val)) {
+    const n = Number(val);
+    if (Number.isFinite(n))
+      return n;
+  }
+  return val;
+}
+function resolveCommand(positional, knownCommands) {
+  if (positional.length === 0)
+    return null;
+  let domain = positional[0];
+  let consumed = 1;
+  if (domain === "admin" && positional.length >= 2) {
+    domain = `admin:${positional[1]}`;
+    consumed = 2;
+  }
+  const remaining = positional.slice(consumed);
+  if (remaining.length === 0)
+    return { domain, command: "", remaining: [] };
+  const domainCommands = knownCommands.filter((c) => c.domain === domain);
+  for (let len = Math.min(remaining.length, 5);len >= 1; len--) {
+    const candidate = remaining.slice(0, len).join(" ");
+    if (domainCommands.some((c) => c.command === candidate)) {
+      return { domain, command: candidate, remaining: remaining.slice(len) };
+    }
+  }
+  return { domain, command: remaining[0], remaining: remaining.slice(1) };
+}
+
+// src/refresh.ts
+var defaultDeps = {
+  readCredentials,
+  writeCredentials,
+  refreshToken,
+  onUpgradeRequired: (message) => {
+    logErr(`${colors.red}✗ upgrade-required:${colors.reset} ${message}`);
+    process.exitCode = 1;
+  }
+};
+async function callWithRefresh(client, call, deps = defaultDeps) {
+  const first = await call(client);
+  if (first.status === 426) {
+    deps.onUpgradeRequired(extractUpgradeMessage(first.body));
+    return first;
+  }
+  if (first.status !== 401)
+    return first;
+  const creds = await deps.readCredentials();
+  if (!creds)
+    return first;
+  const refreshed = await deps.refreshToken(creds);
+  if (!refreshed)
+    return first;
+  await deps.writeCredentials(refreshed);
+  client.updateCredentials(refreshed);
+  const retried = await call(client);
+  if (retried.status === 426) {
+    deps.onUpgradeRequired(extractUpgradeMessage(retried.body));
+  }
+  return retried;
+}
+function extractUpgradeMessage(body) {
+  const err = body?.error;
+  return err?.message ?? `This @aident/cli version is no longer supported. Run \`npm install -g @aident/cli@latest\` to upgrade.`;
+}
+
+// src/cli.ts
+async function main() {
+  const argv = process.argv.slice(2);
+  const parsed = parseArgs(argv);
+  const first = parsed.positional[0];
+  if (parsed.flags["version"] === true || first === "version") {
+    logInfo(`@aident/cli v${VERSION}`);
+    return;
+  }
+  if (!first || parsed.isHelp && parsed.positional.length === 0) {
+    await runHelp(parsed.format);
+    return;
+  }
+  switch (first) {
+    case "login":
+      await runLogin(parsed);
+      return;
+    case "logout":
+      await runLogout();
+      return;
+    case "whoami":
+      await runWhoami(parsed.format);
+      return;
+    case "doctor":
+      await runDoctorCmd(parsed.format);
+      return;
+    case "setup":
+      await runSetup();
+      return;
+    case "config":
+      await runConfigCmd(parsed);
+      return;
+    case "catalog":
+      await runCatalog(parsed.format);
+      return;
+    default:
+      await runCommand(parsed);
+  }
+}
+async function runHelp(format) {
+  const client = await getAuthenticatedClient();
+  if (!client) {
+    if (format === "json") {
+      logInfo(JSON.stringify({ error: "not-authenticated", message: "Run `aident login` first." }));
+    } else {
+      logInfo(`${colors.bold}Aident CLI v${VERSION}${colors.reset}`);
+      logInfo("");
+      logInfo("Run `aident login` to authenticate, then `aident --help` to list commands.");
+      logInfo("");
+      logInfo("USAGE:");
+      logInfo("  aident login [--oob] [--base-url <url>]   Authenticate with Aident");
+      logInfo("  aident logout                             Revoke the current token");
+      logInfo("  aident whoami                             Show current user");
+      logInfo("  aident config show                        Print persistent config");
+      logInfo("  aident config set <key> <value>           Persist a config value");
+      logInfo("  aident config get <key>                   Read a single value");
+      logInfo("  aident doctor                             Validate installation");
+      logInfo("  aident setup                              Interactive setup wizard");
+      logInfo("  aident <domain> <command> [--flag value ...] [--json]");
+    }
+    return;
+  }
+  const catalog = await fetchCatalog(client);
+  if (!catalog)
+    return;
+  if (format === "json") {
+    logInfo(JSON.stringify(catalog));
+  } else {
+    logInfo(renderHelp(catalog));
+  }
+}
+async function runLogin(parsed) {
+  const flagBaseUrlRaw = parsed.flags["base-url"];
+  const flagBaseUrl = typeof flagBaseUrlRaw === "string" ? flagBaseUrlRaw : undefined;
+  const baseUrl = flagBaseUrl ? normalizeBaseUrl(flagBaseUrl) : await resolveDefaultBaseUrl();
+  const oob = parsed.flags["oob"] === true;
+  const creds = await login({ baseUrl, oob });
+  await writeCredentials(creds);
+  logInfo(`${colors.green}Signed in to ${creds.base_url}${colors.reset}`);
+  await setConfigValue("baseUrl", creds.base_url);
+}
+async function runLogout() {
+  const creds = await readCredentials();
+  if (!creds) {
+    logInfo("Not signed in.");
+    return;
+  }
+  await logout(creds);
+  await clearCredentials();
+  logInfo(`${colors.green}Signed out.${colors.reset}`);
+}
+async function runWhoami(format) {
+  const client = await getAuthenticatedClient();
+  if (!client) {
+    if (format === "json") {
+      logInfo(JSON.stringify({ authenticated: false }));
+    } else {
+      logInfo("Not signed in. Run `aident login`.");
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const result = await callWithRefresh(client, (c) => c.exec("user", "me", {}));
+  if (format === "json") {
+    logInfo(JSON.stringify(result.body));
+    if (!result.body.success)
+      process.exitCode = 1;
+    return;
+  }
+  if (result.body.success && result.body.data) {
+    const data = result.body.data;
+    logInfo(`${colors.green}Signed in${colors.reset} as ${data.email ?? data.userId ?? "unknown"}`);
+    return;
+  }
+  const err = result.body.error;
+  logErr(`${colors.red}✗ ${err?.code ?? "error"}:${colors.reset} ${err?.message ?? "Unable to fetch user info."}`);
+  process.exitCode = 1;
+}
+async function runConfigCmd(parsed) {
+  const sub = parsed.positional[1];
+  if (!sub || sub === "show" || sub === "list") {
+    const config = await readConfig();
+    if (parsed.format === "json") {
+      logInfo(JSON.stringify({ ...config, configFile: getConfigFile() }));
+      return;
+    }
+    logInfo(`${colors.bold}Aident config${colors.reset}  ${colors.dim}(${getConfigFile()})${colors.reset}`);
+    if (Object.keys(config).length === 0) {
+      logInfo(`  ${colors.dim}(empty — using defaults)${colors.reset}`);
+      logInfo(`  ${colors.dim}baseUrl${colors.reset}        ${colors.dim}default: ${DEFAULT_BASE_URL}${colors.reset}`);
+      return;
+    }
+    for (const [key, val] of Object.entries(config)) {
+      logInfo(`  ${key.padEnd(15)} ${typeof val === "string" ? val : JSON.stringify(val)}`);
+    }
+    return;
+  }
+  if (sub === "path") {
+    logInfo(getConfigFile());
+    return;
+  }
+  if (sub === "get") {
+    const key = parsed.positional[2];
+    if (!key) {
+      logErr("Usage: aident config get <key>");
+      process.exitCode = 1;
+      return;
+    }
+    const config = await readConfig();
+    const val = config[key];
+    if (parsed.format === "json") {
+      logInfo(JSON.stringify(val ?? null));
+    } else if (val === undefined) {
+      logErr(`Not set: ${key}`);
+      process.exitCode = 1;
+    } else {
+      logInfo(typeof val === "string" ? val : JSON.stringify(val));
+    }
+    return;
+  }
+  if (sub === "set") {
+    const key = parsed.positional[2];
+    const rawValue = parsed.positional[3];
+    if (!key || rawValue === undefined) {
+      logErr("Usage: aident config set <key> <value>");
+      logErr(`Known keys: ${CONFIG_KEYS.join(", ")}`);
+      process.exitCode = 1;
+      return;
+    }
+    if (!isKnownConfigKey(key)) {
+      logErr(`Unknown config key: ${key}`);
+      logErr(`Known keys: ${CONFIG_KEYS.join(", ")}`);
+      process.exitCode = 1;
+      return;
+    }
+    const value = key === "baseUrl" ? normalizeBaseUrl(rawValue) : rawValue;
+    await setConfigValue(key, value);
+    logInfo(`${colors.green}Set${colors.reset} ${key} = ${value}`);
+    if (key === "baseUrl") {
+      const creds = await readCredentials();
+      if (creds && creds.base_url !== value) {
+        logInfo(`${colors.yellow}Note:${colors.reset} existing credentials are for ${creds.base_url}. Run \`aident login\` to authenticate against ${value}.`);
+      }
+    }
+    return;
+  }
+  if (sub === "unset") {
+    const key = parsed.positional[2];
+    if (!key) {
+      logErr("Usage: aident config unset <key>");
+      process.exitCode = 1;
+      return;
+    }
+    await unsetConfigValue(key);
+    logInfo(`${colors.green}Unset${colors.reset} ${key}`);
+    return;
+  }
+  logErr(`Unknown config subcommand: ${sub}`);
+  logErr("Usage: aident config [show | get <key> | set <key> <value> | unset <key> | path]");
+  process.exitCode = 1;
+}
+async function runDoctorCmd(format) {
+  const baseUrl = await resolveDefaultBaseUrl();
+  const report = await runDoctor({ baseUrl, configFile: getConfigFile(), credentialsFile: getCredentialsFile() });
+  if (format === "json") {
+    logInfo(JSON.stringify(report));
+    if (!report.ok)
+      process.exitCode = 1;
+    return;
+  }
+  logInfo(`${colors.bold}Aident CLI doctor${colors.reset}`);
+  logInfo("");
+  for (const c of report.checks) {
+    const mark = c.ok ? `${colors.green}✓${colors.reset}` : `${colors.red}✗${colors.reset}`;
+    logInfo(`  ${mark} ${c.name.padEnd(22)} ${colors.dim}${c.detail}${colors.reset}`);
+  }
+  logInfo("");
+  logInfo(`  baseUrl:      ${baseUrl}`);
+  logInfo(`  config:       ${getConfigFile()}`);
+  logInfo(`  credentials:  ${getCredentialsFile()}`);
+  if (!report.ok)
+    process.exitCode = 1;
+}
+async function runSetup() {
+  logInfo(`${colors.bold}Aident CLI setup${colors.reset}`);
+  logInfo("");
+  const current = await resolveDefaultBaseUrl();
+  const input = (await readLine(`Base URL [${current}]: `)).trim();
+  const chosen = input ? normalizeBaseUrl(input) : current;
+  if (chosen !== current) {
+    await setConfigValue("baseUrl", chosen);
+    logInfo(`${colors.green}Saved${colors.reset} baseUrl = ${chosen}`);
+  }
+  logInfo("");
+  const existing = await readCredentials();
+  if (existing && existing.base_url === chosen) {
+    logInfo(`${colors.green}Already signed in${colors.reset} to ${chosen}.`);
+  } else {
+    const proceed = (await readLine(`Open browser to authenticate now? [Y/n]: `)).trim().toLowerCase();
+    if (proceed === "" || proceed === "y" || proceed === "yes") {
+      const creds = await login({ baseUrl: chosen });
+      await writeCredentials(creds);
+      logInfo(`${colors.green}Signed in to ${creds.base_url}${colors.reset}`);
+    } else {
+      logInfo("Skipped login. Run `aident login` whenever you want.");
+    }
+  }
+  logInfo("");
+  logInfo(`Done. Try ${colors.cyan}aident --help${colors.reset} or ${colors.cyan}aident doctor${colors.reset}.`);
+}
+async function runCatalog(format) {
+  const client = await getAuthenticatedClient();
+  if (!client) {
+    process.exitCode = 1;
+    return;
+  }
+  const catalog = await fetchCatalog(client);
+  if (!catalog)
+    return;
+  logInfo(JSON.stringify(catalog, null, format === "json" ? 0 : 2));
+}
+async function runCommand(parsed) {
+  const client = await getAuthenticatedClient();
+  if (!client) {
+    if (parsed.format === "json") {
+      logInfo(JSON.stringify({ success: false, error: { code: "not-authenticated", message: "Run `aident login` first." } }));
+    } else {
+      logErr("Not signed in. Run `aident login` first.");
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const catalog = await fetchCatalog(client);
+  if (!catalog)
+    return;
+  const resolved = resolveCommand(parsed.positional, catalog.commands);
+  if (!resolved?.command) {
+    if (resolved && (parsed.isHelp || parsed.format === "tui")) {
+      logInfo(renderDomainHelp(catalog, resolved.domain));
+      return;
+    }
+    if (parsed.format === "json") {
+      logInfo(JSON.stringify({ success: false, error: { code: "unknown-command", message: "Unknown command" } }));
+    } else {
+      logErr("Unknown command. Run `aident --help` to see available commands.");
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const cmdInfo = catalog.commands.find((c) => c.domain === resolved.domain && c.command === resolved.command);
+  if (!cmdInfo) {
+    if (parsed.format === "json") {
+      logInfo(JSON.stringify({
+        success: false,
+        error: { code: "unknown-command", message: `Unknown command: ${resolved.domain} ${resolved.command}` }
+      }));
+    } else {
+      logErr(`Unknown command: ${resolved.domain} ${resolved.command}`);
+      logErr(`Run \`aident ${resolved.domain} --help\` to see available commands in this domain.`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  if (parsed.isHelp) {
+    logInfo(renderCommandHelp(catalog, resolved.domain, resolved.command));
+    return;
+  }
+  const args = { ...parsed.flags };
+  for (const reserved of RESERVED_CLI_FLAGS) {
+    delete args[reserved];
+  }
+  if (resolved.remaining.length > 0) {
+    const schema = cmdInfo.inputSchema;
+    const required = new Set(schema?.required ?? []);
+    const props = schema?.properties ?? {};
+    for (const key of Object.keys(props)) {
+      if (resolved.remaining.length === 0)
+        break;
+      if (!required.has(key))
+        continue;
+      if (key in args)
+        continue;
+      args[key] = resolved.remaining.shift();
+    }
+  }
+  const result = await callWithRefresh(client, (c) => c.exec(resolved.domain, resolved.command, args));
+  emitResult(result, parsed.format, resolved);
+}
+function emitResult(result, format, resolved) {
+  const body = result.body;
+  if (format === "json") {
+    logInfo(JSON.stringify(body));
+    if (!body.success)
+      process.exitCode = 1;
+    return;
+  }
+  if (body.success) {
+    logInfo(`${colors.green}✓${colors.reset} ${resolved.domain} ${resolved.command}`);
+    if (body.data !== undefined)
+      logInfo(JSON.stringify(body.data, null, 2));
+    if (body.meta)
+      logInfo(`${colors.cyan}meta:${colors.reset} ${JSON.stringify(body.meta)}`);
+  } else {
+    logErr(`${colors.red}✗ ${body.error?.code ?? "error"}:${colors.reset} ${body.error?.message ?? "Unknown error"}`);
+    process.exitCode = 1;
+  }
+}
+async function getAuthenticatedClient() {
+  const envToken = process.env.AIDENT_TOKEN;
+  const envBaseUrl = process.env.AIDENT_BASE_URL?.trim();
+  if (envToken) {
+    const baseUrl = envBaseUrl || (await readCredentials())?.base_url || await resolveDefaultBaseUrl();
+    return new CliClient({
+      base_url: normalizeBaseUrl(baseUrl),
+      client_id: "",
+      access_token: envToken
+    });
+  }
+  let creds = await readCredentials();
+  if (!creds)
+    return null;
+  if (envBaseUrl && normalizeBaseUrl(envBaseUrl) !== creds.base_url) {
+    logErr(`${colors.yellow}Warning:${colors.reset} AIDENT_BASE_URL=${envBaseUrl} does not match the host your token was issued for (${creds.base_url}). Ignoring the env override; run \`aident login --base-url ${envBaseUrl}\` to authenticate against the new host.`);
+  }
+  if (isExpired(creds)) {
+    const refreshed = await refreshToken(creds);
+    if (refreshed) {
+      await writeCredentials(refreshed);
+      creds = refreshed;
+    }
+  }
+  return new CliClient(creds);
+}
+var catalogCache = null;
+async function fetchCatalog(client) {
+  if (catalogCache)
+    return catalogCache;
+  const res = await callWithRefresh(client, (c) => c.getCatalog());
+  if (res.status === 401) {
+    logErr(`Not authenticated (HTTP ${res.status}). Run \`aident login\`.`);
+    process.exitCode = 1;
+    return null;
+  }
+  if (res.status !== 200 || !isCommandCatalog(res.body)) {
+    logErr(`Failed to fetch command catalog (HTTP ${res.status}): ${JSON.stringify(res.body)}`);
+    process.exitCode = 1;
+    return null;
+  }
+  catalogCache = res.body;
+  return catalogCache;
+}
+function isCommandCatalog(body) {
+  if (!body || typeof body !== "object")
+    return false;
+  const b = body;
+  return Array.isArray(b.packages) && Array.isArray(b.domains) && Array.isArray(b.commands);
+}
+main().catch((err) => {
+  logErr(`${colors.red}Error:${colors.reset} ${err instanceof Error ? err.message : String(err)}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@aident-ai/cli",
+  "version": "0.0.1",
+  "description": "Aident CLI — agent-friendly access to 1000+ integrations, playbooks, and the Aident automation platform.",
+  "homepage": "https://aident.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Aident-AI/aident.ai.git",
+    "directory": "apps/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/Aident-AI/aident.ai/issues"
+  },
+  "license": "MIT",
+  "author": "Aident AI",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "aident": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "imports": {
+    "~cli/*": "./src/*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.3.3",
+    "@aident/typescript-config": "0.0.0",
+    "@aident/eslint-config": "1.0.0",
+    "@aident/prettier-config": "1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "aident",
+    "cli",
+    "automation",
+    "integrations",
+    "playbooks",
+    "agent",
+    "ai",
+    "skill",
+    "mcp"
+  ],
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "dev": "bun run src/cli.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "format": "pnpm exec prettier . --write",
+    "lint": "pnpm exec eslint ./src --cache --cache-location ../../.eslintcache"
+  }
+}