@alexkroman1/aai-cli 5.5.1 → 5.7.0

package/dist/{deploy-1eaXcfUw.mjs → deploy-Cp-wgME3.mjs}

@@ -2,17 +2,18 @@
 import { n as log, t as fmtUrl, u as ok } from "./_ui-8kOEB-JH.mjs";
 import { a as errorMessage } from "./_utils-Ch0J4s6a.mjs";
 import { t as buildAgentBundle } from "./_bundler-Cjaxa2wi.mjs";
-import { c as writeProjectConfig } from "./_config-5AEqhh-O.mjs";
+import { s as updateProjectConfig } from "./_config-Y5V-5Krn.mjs";
 import { t as resolveServerEnv } from "./_server-common-CnaP_Urf.mjs";
-import { i as resolveDeployTarget } from "./_agent-DMyOab9_.mjs";
-import { t as assertTypechecks } from "./_typecheck-gate-9IHWDnl1.mjs";
-import { n as apiRequest } from "./_api-client-MenP4-O7.mjs";
+import { i as resolveDeployTarget } from "./_agent-2nVugrN3.mjs";
+import { assertTypechecks } from "./_typecheck-gate-DvE8S3aQ.mjs";
+import { n as apiRequest } from "./_api-client-B-upMGkc.mjs";
 import { gzipSync } from "node:zlib";
 //#region _deploy.ts
 async function runDeploy(opts) {
 	const body = gzipSync(JSON.stringify({
 		...opts.slug ? { slug: opts.slug } : {},
 		...opts.allowMissingSecrets ? { credentialPolicy: "warn" } : {},
+		...opts.allowPreviewSlug ? { allowPreviewSlug: true } : {},
 		env: opts.env,
 		worker: opts.bundle.worker,
 		clientFiles: opts.bundle.clientFiles
@@ -55,11 +56,12 @@ async function executeDeploy(opts) {
 		},
 		...slug ? { slug } : {},
 		...opts.allowMissingSecrets ? { allowMissingSecrets: true } : {},
+		...opts.allowPreviewSlug ? { allowPreviewSlug: true } : {},
 		apiKey
 	});
 	const agentUrl = `${serverUrl}/${deployed.slug}`;
 	try {
-		await writeProjectConfig(cwd, {
+		await updateProjectConfig(cwd, {
 			slug: deployed.slug,
 			serverUrl
 		});

package/dist/deploy.d.ts

@@ -9,6 +9,8 @@ export declare function executeDeploy(opts: {
     server?: string | undefined;
     /** See DeployOpts.allowMissingSecrets (`--allow-missing-secrets`). */
     allowMissingSecrets?: boolean | undefined;
+    /** See DeployOpts.allowPreviewSlug (`--allow-preview-slug`; studio-internal). */
+    allowPreviewSlug?: boolean | undefined;
     /** `--skipTypecheck`: deploy without the tsc gate. */
     skipTypecheck?: boolean | undefined;
 }): Promise<CommandResult<DeployData>>;

package/dist/{dev-gVNdGFYY.mjs → dev-C4KyxouE.mjs}

@@ -11,7 +11,7 @@ import { styleText } from "node:util";
 async function executeDev(opts) {
 	const port = parsePort(opts.port);
 	const agentName = path.basename(path.resolve(opts.cwd));
-	const { startDevServer } = await import("./_dev-server-vV05Fnki.mjs");
+	const { startDevServer } = await import("./_dev-server-BB5N8kdh.mjs");
 	let cleanup;
 	let shuttingDown = false;
 	const onSignal = () => {

package/dist/{init-DoU4_txp.mjs → init-BT-IU9AR.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { a as unwrapCancel, n as log, u as ok } from "./_ui-8kOEB-JH.mjs";
 import { a as errorMessage, c as readJson, l as resolveCwd, o as fileExists, t as AGENT_ENTRY } from "./_utils-Ch0J4s6a.mjs";
-import { r as isDevMode, t as getMonorepoRoot } from "./_agent-DMyOab9_.mjs";
+import { r as isDevMode, t as getMonorepoRoot } from "./_agent-2nVugrN3.mjs";
 import path from "node:path";
 import { styleText } from "node:util";
 import * as p from "@clack/prompts";
@@ -72,27 +72,28 @@ async function installDeps(cwd, silent) {
 function resolveTargetDir(dir) {
 	return path.resolve(resolveCwd(), dir);
 }
-/** Run deploy after init and return deploy metadata if successful. */
-async function tryDeploy(cwd, server) {
-	const { executeDeploy } = await import("./deploy-1eaXcfUw.mjs");
+/** Publish after init and return deploy metadata if successful. */
+async function tryPublish(cwd, server) {
+	const { executePublish } = await import("./studio-sXvYUxr5.mjs");
 	try {
-		const result = await executeDeploy({
+		const result = await executePublish({
 			cwd,
 			...server ? { server } : {}
 		});
 		return result.ok ? {
 			slug: result.data.slug,
-			url: result.data.url
+			url: result.data.url,
+			studioUrl: result.data.studioUrl
 		} : null;
 	} catch (err) {
-		log.warn(`Deploy failed: ${errorMessage(err)}`);
-		log.warn("Your project was still created — run `aai deploy` in it to retry.");
+		log.warn(`Publish failed: ${errorMessage(err)}`);
+		log.warn("Your project was still created — run `aai publish` in it to retry.");
 		return null;
 	}
 }
 /** Scaffold the project, optionally showing a spinner. */
 async function scaffoldProject(dir, cwd, template, silent) {
-	const { runInit } = await import("./_init-BZ9t_Kz-.mjs");
+	const { runInit } = await import("./_init-D7JIT-IJ.mjs");
 	const s = silent ? void 0 : p.spinner();
 	s?.start(`Creating ${dir}`);
 	await runInit({
@@ -120,13 +121,13 @@ async function executeInit(opts, extra) {
 	let deployed = false;
 	let slug;
 	let url;
-	if (!installed) log.warn("Skipping deploy because dependencies were not installed.");
+	if (!installed) log.warn("Skipping publish because dependencies were not installed.");
 	else if (!opts.skipDeploy) {
-		const deployInfo = await tryDeploy(cwd, opts.server);
-		if (deployInfo) {
+		const published = await tryPublish(cwd, opts.server);
+		if (published) {
 			deployed = true;
-			slug = deployInfo.slug;
-			url = deployInfo.url;
+			slug = published.slug;
+			url = published.url;
 		}
 	}
 	if (!suppressUi) printPostInitInfo(cwd, monorepoRoot);

package/dist/login-AA_UdRI-.mjs

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import { n as log, o as CliError, u as ok } from "./_ui-8kOEB-JH.mjs";
+import { c as writeGlobalConfig, i as readGlobalConfig, r as getConfigDir, t as approveServer } from "./_config-Y5V-5Krn.mjs";
+import { a as resolveServerUrl } from "./_agent-2nVugrN3.mjs";
+import { spawn } from "node:child_process";
+import { setTimeout } from "node:timers/promises";
+import { randomBytes } from "node:crypto";
+//#region login.ts
+/**
+* `aai login` — link the CLI to an account that is ALREADY signed in to the
+* browser studio, ending with the account's AssemblyAI API key stored in
+* the global config (the same slot `ensureApiKey` reads), so every other
+* command is untouched by how the key was acquired.
+*
+* The CLI deliberately performs no sign-in of its own — it cannot create an
+* account, and it never sees a session token. Device-link flow:
+* 1. `GET /studio/auth` — fail fast when the server has no browser login
+*    configured (nobody could ever approve the link).
+* 2. Mint an unguessable one-shot code (32 random bytes, base64url) and
+*    open the browser at `<server>/?cli-link=<code>`. The studio — where
+*    the user signs in with GitHub (or the local-dev login) if they aren't
+*    already — shows a "link the CLI to this account?" approval displaying
+*    the same short confirmation code this terminal printed, so a phished
+*    approval link has a visible mismatch (no terminal to match against).
+* 3. Poll `POST /studio/cli-link/exchange` with the code. Approval grants
+*    the code ONE exchange for the account's stored API key, which is
+*    saved locally. An account with no stored key can't approve — the
+*    studio's own onboarding gate runs first — so the CLI never sets keys.
+*/
+const LINK_POLL_INTERVAL_MS = 2e3;
+const LINK_TIMEOUT_MS = 3e5;
+async function jsonBody(res, what) {
+	const body = await res.json().catch(() => null);
+	if (!res.ok) throw new CliError("login_failed", `${what} failed: ${body?.error ?? body?.msg ?? `HTTP ${res.status}`}`);
+	if (body === null) throw new CliError("login_failed", `${what} returned an invalid response`);
+	return body;
+}
+/**
+* Fetch, turning a transport failure into an error that names the server.
+*
+* A connection failure here is undici's bare `TypeError: fetch failed` — no
+* URL, no cause worth printing — and `aai login` is exactly where it is least
+* diagnosable: the target is resolved (dev mode pins `localhost:8080`
+* whenever the CLI itself lives in the monorepo, whatever the cwd), so the
+* user cannot tell which server was unreachable, or that a local one was
+* expected at all. `apiRequest` has always said "could not reach <url>";
+* login used raw fetch and said nothing.
+*/
+async function reachable(fetchFn, url, serverUrl) {
+	try {
+		return await fetchFn(url);
+	} catch (err) {
+		throw unreachableError(serverUrl, err);
+	}
+}
+/**
+* "Could not reach <server>", with advice chosen by the kind of host and the
+* original transport failure preserved as the cause.
+*/
+function unreachableError(serverUrl, cause) {
+	const hint = isLoopback(serverUrl) ? "That's a local server — start it with `pnpm dev:aai-server`, or pass `--server <url>` to log in elsewhere. (A CLI installed from the monorepo targets localhost by default; set AAI_NO_DEV=1 to use the hosted platform.)" : "Check your network connection and verify the server URL is correct.";
+	return new CliError("login_unreachable", `Could not reach ${serverUrl}.`, hint, { cause });
+}
+/** Whether `url`'s host is loopback — used only to pick a better hint. */
+function isLoopback(url) {
+	try {
+		const { hostname } = new URL(url);
+		return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+	} catch {
+		return false;
+	}
+}
+/**
+* Poll the exchange until the browser approves the link, or the deadline.
+*
+* A transport failure is retried rather than fatal: the user is off in a
+* browser approving, and a dev server reloading in that window would
+* otherwise lose a login that was about to succeed. The last one is
+* remembered, so a server that never comes back is reported as unreachable
+* rather than as "you didn't approve in time" — which would blame the user
+* for someone else's outage.
+*/
+async function pollForGrant(fetchFn, serverUrl, code, opts) {
+	let lastTransportError;
+	for (;;) {
+		let res = null;
+		try {
+			res = await fetchFn(`${serverUrl}/studio/cli-link/exchange`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ code })
+			});
+			lastTransportError = void 0;
+		} catch (err) {
+			lastTransportError = err;
+		}
+		if (res && res.status !== 404) return await jsonBody(res, "Linking your account");
+		if (Date.now() >= opts.deadline) {
+			if (lastTransportError !== void 0) throw unreachableError(serverUrl, lastTransportError);
+			throw new CliError("login_timeout", "Timed out waiting for the link to be approved in the browser.", "Run `aai login` again and approve the link within five minutes.");
+		}
+		await setTimeout(opts.intervalMs);
+	}
+}
+function requireTty() {
+	if (!process.stdin.isTTY) throw new CliError("login_interactive", "`aai login` is interactive and needs a TTY.", "Non-interactive setups can set the ASSEMBLYAI_API_KEY environment variable instead.");
+}
+function openerFor(platform) {
+	if (platform === "darwin") return ["open", []];
+	if (platform === "win32") return ["cmd", [
+		"/c",
+		"start",
+		""
+	]];
+	return ["xdg-open", []];
+}
+/**
+* Human-matchable confirmation derived from the link code — printed in the
+* terminal AND shown on the browser approval gate (aai-studio-client's
+* cli-link.ts derives the same value; keep the two in lockstep). Not a
+* secret: both ends already hold the full code. It exists so someone who
+* lands on an approval page they didn't cause has a concrete mismatch to
+* notice ("what terminal?") instead of a bare Approve button.
+*/
+function linkConfirmationCode(code) {
+	const head = code.slice(0, 8).toUpperCase();
+	return `${head.slice(0, 4)}-${head.slice(4)}`;
+}
+/** Best-effort: the link URL is always printed, so a failure is fine. */
+function defaultOpenBrowser(url) {
+	const [cmd, args] = openerFor(process.platform);
+	try {
+		const child = spawn(cmd, [...args, url], {
+			stdio: "ignore",
+			detached: true
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
+}
+async function executeLogin(opts, deps = {}) {
+	const fetchFn = deps.fetchFn ?? globalThis.fetch;
+	requireTty();
+	const globalConfig = await readGlobalConfig();
+	const serverUrl = resolveServerUrl(opts.server, void 0, globalConfig.approvedServers ?? []);
+	if (opts.server) await approveServer(serverUrl);
+	if ((await jsonBody(await reachable(fetchFn, `${serverUrl}/studio/auth`, serverUrl), "Reading the server's login configuration")).mode === "none") throw new CliError("login_unavailable", "This server has no browser login configured, so there is no account to link.", "Set the ASSEMBLYAI_API_KEY environment variable instead — it's the only other way to authenticate.");
+	const code = randomBytes(32).toString("base64url");
+	const linkUrl = `${serverUrl}/?cli-link=${code}`;
+	log.info(`Opening the browser to link your account…\n  ${linkUrl}`);
+	log.info(`Confirmation code: ${linkConfirmationCode(code)}`);
+	log.info("Approve the link in the browser (sign in there first if you need to) — the approval page shows the same code.");
+	(deps.openBrowser ?? defaultOpenBrowser)(linkUrl);
+	const granted = await pollForGrant(fetchFn, serverUrl, code, {
+		intervalMs: deps.pollIntervalMs ?? LINK_POLL_INTERVAL_MS,
+		deadline: Date.now() + (deps.timeoutMs ?? LINK_TIMEOUT_MS)
+	});
+	if (!granted.apiKey) throw new CliError("login_failed", "Linking your account did not return an API key.");
+	const dir = getConfigDir();
+	await writeGlobalConfig(dir, {
+		...await readGlobalConfig(dir),
+		apiKey: granted.apiKey
+	});
+	const email = granted.email ?? "your account";
+	log.success(`Linked ${email} — your API key is saved for future commands.`);
+	return ok({
+		email,
+		server: serverUrl
+	});
+}
+//#endregion
+export { executeLogin };

package/dist/login.d.ts

@@ -1,31 +1,44 @@
 /**
- * `aai login` — email sign-in against the platform, ending with the
- * account's AssemblyAI API key stored in the global config (the same slot
- * `ensureApiKey` reads), so every other command is untouched by how the
- * key was acquired.
+ * `aai login` — link the CLI to an account that is ALREADY signed in to the
+ * browser studio, ending with the account's AssemblyAI API key stored in
+ * the global config (the same slot `ensureApiKey` reads), so every other
+ * command is untouched by how the key was acquired.
  *
- * Flow (the CLI mirror of the browser studio's two gates):
- * 1. `GET /studio/auth` names the login mode.
- *    - `supabase`: Supabase email OTP — `POST /auth/v1/otp` emails a
- *      one-time code, the user types it here, `POST /auth/v1/verify`
- *      returns the session. The magic LINK in the same email targets the
- *      browser; the CLI uses the code because a terminal has no redirect
- *      to land on. (The Supabase email template must include the
- *      `{{ .Token }}` code for this to work.)
- *    - `dev`: mint the same self-describing dev token the studio's local
- *      login mints — nothing is emailed anywhere.
- * 2. `GET /studio/account` — when no key is on file yet, prompt for one
- *    and `PUT /studio/account/key` (the same mandatory onboarding step
- *    the browser shows after sign-in).
- * 3. `GET /studio/account/key` — fetch the key and save it locally.
- *    Unlike the browser, the CLI needs the RAW key: `aai dev` runs the
- *    provider pipeline in-process on it.
+ * The CLI deliberately performs no sign-in of its own — it cannot create an
+ * account, and it never sees a session token. Device-link flow:
+ * 1. `GET /studio/auth` — fail fast when the server has no browser login
+ *    configured (nobody could ever approve the link).
+ * 2. Mint an unguessable one-shot code (32 random bytes, base64url) and
+ *    open the browser at `<server>/?cli-link=<code>`. The studio — where
+ *    the user signs in with GitHub (or the local-dev login) if they aren't
+ *    already — shows a "link the CLI to this account?" approval displaying
+ *    the same short confirmation code this terminal printed, so a phished
+ *    approval link has a visible mismatch (no terminal to match against).
+ * 3. Poll `POST /studio/cli-link/exchange` with the code. Approval grants
+ *    the code ONE exchange for the account's stored API key, which is
+ *    saved locally. An account with no stored key can't approve — the
+ *    studio's own onboarding gate runs first — so the CLI never sets keys.
  */
 import { type CommandResult } from "./_output.ts";
 export type LoginDeps = {
     /** Test seam — never set outside tests. */
     fetchFn?: typeof globalThis.fetch;
+    /** Test seam — never set outside tests. */
+    openBrowser?: (url: string) => void;
+    /** Test seam — never set outside tests. */
+    pollIntervalMs?: number;
+    /** Test seam — never set outside tests. */
+    timeoutMs?: number;
 };
+/**
+ * Human-matchable confirmation derived from the link code — printed in the
+ * terminal AND shown on the browser approval gate (aai-studio-client's
+ * cli-link.ts derives the same value; keep the two in lockstep). Not a
+ * secret: both ends already hold the full code. It exists so someone who
+ * lands on an approval page they didn't cause has a concrete mismatch to
+ * notice ("what terminal?") instead of a bare Approve button.
+ */
+export declare function linkConfirmationCode(code: string): string;
 export declare function executeLogin(opts: {
     server?: string | undefined;
 }, deps?: LoginDeps): Promise<CommandResult<{

package/dist/scaffold/package.json

@@ -8,18 +8,18 @@
     "dev": "aai dev",
     "build": "aai build",
     "test": "aai test",
-    "deploy": "aai deploy"
+    "publish:agent": "aai publish"
   },
   "dependencies": {
-    "@alexkroman1/aai": "^5.5.1",
-    "@alexkroman1/aai-ui": "^5.5.1",
+    "@alexkroman1/aai": "^5.7.0",
+    "@alexkroman1/aai-ui": "^5.7.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "tailwindcss": "^4.0.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@alexkroman1/aai-cli": "^5.5.1",
+    "@alexkroman1/aai-cli": "^5.7.0",
     "@tailwindcss/vite": "^4.3.3",
     "@types/node": "^26.1.1",
     "@types/react": "^19.2.17",

package/dist/{secret-CGAIAbUx.mjs → secret-Dr0qnxeb.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { a as unwrapCancel, n as log, s as fail, u as ok } from "./_ui-8kOEB-JH.mjs";
-import { t as slugRequest } from "./_slug-api-DaqQJHk8.mjs";
+import { t as slugRequest } from "./_slug-api-CGJSST9B.mjs";
 import * as p from "@clack/prompts";
 import { text } from "node:stream/consumers";
 //#region secret.ts

package/dist/{storage-CnhOayhm.mjs → storage-CoQB8d-u.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { n as log, s as fail, u as ok } from "./_ui-8kOEB-JH.mjs";
-import { t as slugRequest } from "./_slug-api-DaqQJHk8.mjs";
+import { t as slugRequest } from "./_slug-api-CGJSST9B.mjs";
 import * as p from "@clack/prompts";
 //#region storage.ts
 async function storageRequest(cwd, init, server) {