@aident-ai/cli 0.1.7 → 0.1.8-rc.1

package/README.md

@@ -28,6 +28,11 @@ aident update --check
 aident --help
 ```
 
+`aident setup` installs or updates the verified Aident Skill globally, migrates recognized clean project copies that
+could shadow it, reuses or opens Aident authentication, verifies Loadout access, and records completion. Add
+`--client-name <name>` to record the agent client and `--json` for a single machine-readable report; a configured
+`AIDENT_TOKEN` makes the flow non-interactive.
+
 Use `--oob` for browserless auth environments:
 
 ```bash

package/dist/cli.mjs

@@ -45,7 +45,7 @@ function logErr(text) {
 // src/prompt.ts
 function readLine(prompt, options = {}) {
   return new Promise((resolve, reject) => {
-    process.stdout.write(prompt);
+    (options.output ?? process.stdout).write(prompt);
     let data = "";
     let timeout;
     const cleanup = () => {
@@ -86,13 +86,14 @@ var LOGIN_COMPLETE_TIMEOUT_AFTER_OPENED_MS = 5 * 60 * 1000;
 var LOGIN_OPENED_MESSAGE = `User opened the Aident login window. They have ${LOGIN_COMPLETE_TIMEOUT_AFTER_OPENED_MS / 60000} minutes to finish; if it fails, run \`aident login --oob\`, share the URL, and ask for the verification code.`;
 async function login(options) {
   const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const writeInfo = options.format === "json" ? logErr : logInfo;
   if (options.oob)
-    return loginOob(baseUrl);
+    return loginOob(baseUrl, writeInfo, options.format === "json" ? process.stderr : process.stdout);
   try {
-    return await loginLoopback(baseUrl);
+    return await loginLoopback(baseUrl, writeInfo);
   } catch (err) {
     logErr(`Loopback OAuth failed (${err instanceof Error ? err.message : String(err)}). Falling back to OOB flow.`);
-    return loginOob(baseUrl);
+    return loginOob(baseUrl, writeInfo, options.format === "json" ? process.stderr : process.stdout);
   }
 }
 async function refreshToken(creds) {
@@ -127,11 +128,11 @@ async function logout(creds) {
     return;
   });
 }
-async function loginLoopback(baseUrl) {
+async function loginLoopback(baseUrl, writeInfo) {
   const verifier = base64UrlEncode(randomBytes(48));
   const challenge = base64UrlEncode(createHash("sha256").update(verifier).digest());
   const state = base64UrlEncode(randomBytes(16));
-  const { server, port, codePromise, setExpectedOpenRedirectUrl } = await startCallbackServer(state);
+  const { server, port, codePromise, setExpectedOpenRedirectUrl } = await startCallbackServer(state, writeInfo);
   const redirectUri = `http://${LOOPBACK_HOST}:${port}/callback`;
   const clientId = await registerClient(baseUrl, [redirectUri]);
   const authorizeUrl = new URL(`${baseUrl}/api/mcp/oauth/authorize`);
@@ -145,8 +146,8 @@ async function loginLoopback(baseUrl) {
   const authorizeUrlString = authorizeUrl.toString();
   setExpectedOpenRedirectUrl(authorizeUrlString);
   const loginOpenUrl = buildLoginOpenUrl(port, state, authorizeUrlString);
-  logInfo(`Opening browser for Aident login...`);
-  logInfo(`If the browser does not open, visit: ${authorizeUrlString}`);
+  writeInfo(`Opening browser for Aident login...`);
+  writeInfo(`If the browser does not open, visit: ${authorizeUrlString}`);
   openBrowser(shouldUseLoopbackBrowserHandoff() ? loginOpenUrl : authorizeUrlString);
   let code;
   try {
@@ -157,7 +158,7 @@ async function loginLoopback(baseUrl) {
   const tok = await exchangeCode(baseUrl, clientId, code, redirectUri, verifier);
   return buildCreds(baseUrl, clientId, tok);
 }
-async function loginOob(baseUrl) {
+async function loginOob(baseUrl, writeInfo, promptOutput) {
   const redirectUri = `${baseUrl}/mcp/oob`;
   const verifier = base64UrlEncode(randomBytes(48));
   const challenge = base64UrlEncode(createHash("sha256").update(verifier).digest());
@@ -174,11 +175,12 @@ async function loginOob(baseUrl) {
     authorizeUrl.searchParams.set("code_challenge_method", "S256");
     authorizeUrl.searchParams.set("state", state);
     const authorizeUrlString = authorizeUrl.toString();
-    logInfo(`Opening browser for Aident login...`);
-    logInfo(`If the browser does not open, visit: ${authorizeUrlString}`);
+    writeInfo(`Opening browser for Aident login...`);
+    writeInfo(`If the browser does not open, visit: ${authorizeUrlString}`);
     openBrowser(authorizeUrlString);
-    logInfo("After approving, paste the 8-digit verification code shown on the Aident page below.");
+    writeInfo("After approving, paste the 8-digit verification code shown on the Aident page below.");
     const pastedInput = await readLine("Paste 8-digit code here: ", {
+      output: promptOutput,
       timeoutMs: LOGIN_COMPLETE_TIMEOUT_AFTER_OPENED_MS,
       timeoutMessage: `Verification code not received within ${LOGIN_COMPLETE_TIMEOUT_AFTER_OPENED_MS / 1000}s; aborting.`
     });
@@ -288,7 +290,7 @@ function updateCredsFromToken(creds, tok) {
     expires_at: expiresAt
   };
 }
-function startCallbackServer(expectedState) {
+function startCallbackServer(expectedState, writeInfo = logInfo) {
   return new Promise((resolve, reject) => {
     let codeResolver = () => {
       return;
@@ -310,7 +312,7 @@ function startCallbackServer(expectedState) {
     };
     const openTimeout = setTimeout(() => {
       if (!opened) {
-        logInfo(`Login window open signal not received within ${LOGIN_OPEN_TIMEOUT_MS / 1000}s; still waiting for login to finish.`);
+        writeInfo(`Login window open signal not received within ${LOGIN_OPEN_TIMEOUT_MS / 1000}s; still waiting for login to finish.`);
       }
     }, LOGIN_OPEN_TIMEOUT_MS);
     scheduleCompleteTimeout(LOGIN_COMPLETE_TIMEOUT_AFTER_OPENED_MS, `Authorization callback not received within ${LOGIN_COMPLETE_TIMEOUT_AFTER_OPENED_MS / 1000}s; aborting.`);
@@ -328,7 +330,7 @@ function startCallbackServer(expectedState) {
         return;
       opened = true;
       clearTimeout(openTimeout);
-      logInfo(LOGIN_OPENED_MESSAGE);
+      writeInfo(LOGIN_OPENED_MESSAGE);
       const timeoutMs = LOGIN_COMPLETE_TIMEOUT_AFTER_OPENED_MS;
       scheduleCompleteTimeout(timeoutMs, `Login page opened but did not complete within ${timeoutMs / 1000}s; aborting.`);
     };
@@ -596,7 +598,7 @@ function normalizeBaseUrl(url) {
 }
 
 // src/version.ts
-var VERSION = "0.1.7";
+var VERSION = "0.1.8-rc.1";
 
 // src/catalogCache.ts
 var CACHE_TTL_MS = 5 * 60 * 1000;
@@ -6177,6 +6179,30 @@ function mergeCatalogs(catalogs, packages, onCommand) {
 // src/credentials.ts
 import { mkdir as mkdir5, readFile as readFile6, rm, writeFile as writeFile5 } from "node:fs/promises";
 import { join as join7 } from "node:path";
+
+// ../web/shared/loadout/AidentCredentialOrigin.mjs
+function getSharedAidentOrigin(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || url.port !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "" || url.username !== "" || url.password !== "" || url.hostname !== "aident.ai" && !url.hostname.endsWith(".aident.ai")) {
+      return null;
+    }
+    return url.origin;
+  } catch {
+    return null;
+  }
+}
+function resolveAidentCredentialBaseUrl(credentialsBaseUrl, requestedBaseUrl) {
+  const credentialsUrl = credentialsBaseUrl.replace(/\/+$/, "");
+  const requestedUrl = requestedBaseUrl.replace(/\/+$/, "");
+  if (credentialsUrl === requestedUrl)
+    return requestedUrl;
+  if (!getSharedAidentOrigin(credentialsUrl))
+    return null;
+  return getSharedAidentOrigin(requestedUrl);
+}
+
+// src/credentials.ts
 var REFRESH_WINDOW_MS = 24 * 60 * 60 * 1000;
 function getCredentialsFile() {
   return join7(getAidentDir(), "credentials.json");
@@ -6200,16 +6226,8 @@ async function clearCredentials() {
   await rm(getCredentialsFile(), { force: true });
 }
 function credentialsForBaseUrl(creds, baseUrl) {
-  const credentialsBaseUrl = creds.base_url.replace(/\/+$/, "");
-  const requestedBaseUrl = baseUrl.replace(/\/+$/, "");
-  if (credentialsBaseUrl === requestedBaseUrl)
-    return { ...creds, base_url: requestedBaseUrl };
-  if (!getSharedAidentBaseUrl(credentialsBaseUrl))
-    return null;
-  const sharedBaseUrl = getSharedAidentBaseUrl(requestedBaseUrl);
-  if (!sharedBaseUrl)
-    return null;
-  return { ...creds, base_url: sharedBaseUrl };
+  const resolvedBaseUrl = resolveAidentCredentialBaseUrl(creds.base_url, baseUrl);
+  return resolvedBaseUrl ? { ...creds, base_url: resolvedBaseUrl } : null;
 }
 async function clearCredentialsForIncompatibleBaseUrl(baseUrl) {
   const creds = await readCredentials();
@@ -6226,17 +6244,6 @@ function isExpired(creds) {
     return false;
   return Date.now() >= expiresAt - REFRESH_WINDOW_MS;
 }
-function getSharedAidentBaseUrl(baseUrl) {
-  try {
-    const url = new URL(baseUrl);
-    if (url.protocol !== "https:" || url.port !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "" || url.username !== "" || url.password !== "" || url.hostname !== "aident.ai" && !url.hostname.endsWith(".aident.ai")) {
-      return null;
-    }
-    return url.origin;
-  } catch {
-    return null;
-  }
-}
 
 // src/doctor.ts
 import { existsSync as existsSync2 } from "node:fs";
@@ -6449,7 +6456,7 @@ var LOCAL_HELP_COMMANDS = [
   { command: "config get <key>", description: "Read a single value" },
   { command: "packages add <playbook|intern>", description: "Enable an add-on package" },
   { command: "doctor", description: "Validate installation" },
-  { command: "setup", description: "Interactive setup wizard" },
+  { command: "setup", description: "Install Aident globally, authenticate, and verify Loadout" },
   { command: "integrations migrate-local", description: "Plan migration from local MCP configs to Loadout" },
   { command: "<domain> <command> [--flag value ...] [--json]", description: "Run a catalog command after login" }
 ];
@@ -6467,7 +6474,7 @@ function getLocalHelp(version) {
       "aident config get <key>",
       "aident packages add <playbook|intern>",
       "aident doctor",
-      "aident setup",
+      "aident setup [--client-name <name>]",
       "aident integrations migrate-local",
       "aident <domain> <command> [--flag value ...] [--json]"
     ],
@@ -9432,32 +9439,128 @@ function formatAidentUpdateReport(report) {
 `);
 }
 async function runSetup(parsed) {
-  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}`);
+  if (parsed.isHelp) {
+    logInfo(renderSetupHelp());
+    return;
   }
-  logInfo("");
-  const existing = await readCredentials();
-  if (existing && credentialsForBaseUrl(existing, 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.");
+  const report = { schemaVersion: 1, success: false };
+  let errorCode = "invalid-input";
+  try {
+    const options = await getSetupOptions(parsed);
+    errorCode = "setup-failed";
+    report.baseUrl = options.baseUrl;
+    report.clientName = options.clientName;
+    if (options.persistBaseUrl)
+      await setConfigValue("baseUrl", options.baseUrl);
+    const update = await runAidentUpdate({
+      baseUrl: options.baseUrl,
+      currentVersion: VERSION,
+      mode: "apply" /* Apply */,
+      includeCli: true,
+      includeSkill: true,
+      includeProject: true
+    });
+    recordLoadoutUpdateTelemetry(options.baseUrl, getLoadoutUpdateCompletionTelemetry(update));
+    report.update = update;
+    if (!update.success) {
+      throw new Error(update.errors?.[0]?.message ?? update.skill?.detail ?? "Aident installation was incomplete");
+    }
+    const skillVersion = update.skill?.targetVersion;
+    let credentials = await readCredentials();
+    const hasEnvironmentToken = !!process.env.AIDENT_TOKEN?.trim();
+    if ((!credentials || !credentialsForBaseUrl(credentials, options.baseUrl)) && !hasEnvironmentToken) {
+      credentials = await login({ baseUrl: options.baseUrl, format: parsed.format, oob: options.oob });
+      await writeCredentials(credentials);
+    }
+    const client = await getAuthenticatedClient(["loadout"]);
+    if (!client)
+      throw new Error("Aident credentials could not be loaded after sign-in");
+    const catalog = await fetchCatalog(client);
+    if (!catalog)
+      throw new Error("Aident Loadout command catalog is unavailable");
+    const identity = await callWithRefresh(client, (activeClient) => activeClient.exec("account", "auth status", {}));
+    if (!identity.body.success) {
+      throw new Error(identity.body.error?.message ?? "Aident account verification failed");
+    }
+    report.authenticated = true;
+    report.account = identity.body.data;
+    const doctor = await runDoctor({
+      baseUrl: options.baseUrl,
+      configFile: getConfigFile(),
+      credentialsFile: getCredentialsFile()
+    });
+    report.doctor = doctor;
+    if (!doctor.ok)
+      throw new Error("Aident installation verification failed");
+    const completion = await callWithRefresh(client, (activeClient) => activeClient.exec("loadout", "setup complete", {
+      clientName: options.clientName,
+      ...skillVersion ? { skillVersion } : {}
+    }));
+    if (!completion.body.success || !completion.body.data?.recorded) {
+      throw new Error(completion.body.error?.message ?? "Aident setup completion was not recorded");
     }
+    report.completion = completion.body.data;
+    report.success = true;
+    await maybeOfferLocalIntegrationMigration(parsed);
+    emitSetupReport(parsed.format, report);
+  } catch (error) {
+    report.error = {
+      code: errorCode,
+      message: error instanceof Error ? error.message : String(error)
+    };
+    emitSetupReport(parsed.format, report);
+    process.exitCode = 1;
   }
-  await maybeOfferLocalIntegrationMigration(parsed);
-  logInfo("");
-  logInfo(`Done. Try ${colors.cyan}aident --help${colors.reset} or ${colors.cyan}aident doctor${colors.reset}.`);
+}
+async function getSetupOptions(parsed) {
+  if (parsed.positional.length !== 1)
+    throw new Error("Usage: aident setup [flags]");
+  const allowedFlags = new Set(["base-url", "client-name", "oob"]);
+  const unknownFlag = Object.keys(parsed.flags).find((flag) => !allowedFlags.has(flag));
+  if (unknownFlag)
+    throw new Error(`Unknown setup flag: --${unknownFlag}`);
+  const rawBaseUrl = getOptionalStringFlag(parsed.flags, "base-url");
+  const clientName = getOptionalStringFlag(parsed.flags, "client-name") ?? "Aident CLI";
+  if (clientName.length > 160)
+    throw new Error("--client-name must be at most 160 characters");
+  return {
+    baseUrl: rawBaseUrl ? normalizeBaseUrl(rawBaseUrl) : await resolveDefaultBaseUrl(),
+    clientName,
+    oob: getBooleanUpdateFlag(parsed.flags, "oob"),
+    persistBaseUrl: !!rawBaseUrl
+  };
+}
+function getOptionalStringFlag(flags, name) {
+  const value = flags[name];
+  if (value === undefined)
+    return;
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`--${name} requires a value`);
+  return value.trim();
+}
+function emitSetupReport(format, report) {
+  if (format === "json") {
+    logInfo(JSON.stringify(report));
+    return;
+  }
+  if (report.success) {
+    logInfo(`${colors.green}Aident Loadout setup is complete.${colors.reset}`);
+    return;
+  }
+  const error = report.error;
+  logErr(`${colors.red}Aident Loadout setup failed:${colors.reset} ${error?.message ?? "Unknown error"}`);
+}
+function renderSetupHelp() {
+  return [
+    `${colors.bold}AIDENT SETUP${colors.reset}`,
+    "",
+    "USAGE:",
+    "  aident setup [--client-name <name>] [--base-url <url>] [--oob] [--json]",
+    "",
+    "The setup command updates the CLI, installs or reconciles the verified Aident Skill globally, and opens sign-in when needed.",
+    "It verifies Loadout access and records completion. AIDENT_TOKEN enables non-interactive authentication."
+  ].join(`
+`);
 }
 async function maybeOfferLocalIntegrationMigration(parsed) {
   if (parsed.format !== "tui")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aident-ai/cli",
-  "version": "0.1.7",
+  "version": "0.1.8-rc.1",
   "description": "Aident CLI — umbrella access to Loadout integrations, Playbook automation, Intern tools, and the Aident platform.",
   "homepage": "https://aident.ai",
   "repository": {