@alexkroman1/aai-cli 5.5.1 → 5.7.0

package/dist/_studio.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Internals of the studio-workspace commands (`aai list/pull/push/publish`):
+ * the local source-file walk and the thin clients for the platform's
+ * `/studio/projects` routes. The workspace is the single source of truth —
+ * these helpers only move files between a local directory and the project's
+ * workspace row; production deploys happen exclusively through the studio's
+ * Publish route (which runs the deploy machinery in the project's sandbox).
+ */
+/**
+ * Mirrors of the studio workspace caps (`aai-studio-server/studio-limits.ts`)
+ * — by value, like `aai-guest/limits.ts`, since the CLI cannot depend on the
+ * private server package. The server re-validates every push; these exist so
+ * an oversized file is a named warning locally instead of a rejected upload.
+ */
+export declare const MAX_STUDIO_FILE_BYTES = 256000;
+export declare const MAX_STUDIO_FILES = 100;
+/**
+ * Walk a local project into the path→content record a workspace stores —
+ * the CLI-side twin of the guest's `snapshotWorkspace`: same ignored
+ * directories, same caps, oversized and non-text files skipped with a
+ * warning rather than failing the whole push.
+ */
+export declare function collectSourceFiles(dir: string): Promise<{
+    files: Record<string, string>;
+    warnings: string[];
+}>;
+/**
+ * A studio project name derived from a directory name, or null if unusable.
+ *
+ * A `-preview` suffix is deliberately unusable. Publishing a project deploys
+ * it under the project's own name, so a `*-preview` project would claim a
+ * slug the studio's orphan-preview sweep reaps hourly — deleting the agent,
+ * its app-database schema, and its secrets on a schedule the user never
+ * asked for. Refusing the name is recoverable (rename the directory); losing
+ * a published agent to the reaper is not.
+ */
+export declare function projectNameFromDir(dir: string): string | null;
+/** The shareable studio URL for a project — what every command prints. */
+export declare function studioProjectUrl(serverUrl: string, project: string): string;
+/** `GET /studio/projects/:project` — see `projectPayload` server-side. */
+export type StudioProject = {
+    files: Record<string, string>;
+    sourceHash: string;
+    deployedSlug?: string;
+    unpublished?: boolean;
+};
+export declare function listStudioProjects(serverUrl: string, apiKey: string): Promise<string[]>;
+/** Fetch a project, or null when it doesn't exist (the push existence probe). */
+export declare function fetchStudioProject(serverUrl: string, apiKey: string, project: string): Promise<StudioProject | null>;
+/** `PUT /studio/projects/:project/source` — the atomic whole-tree push. */
+export declare function pushStudioSource(serverUrl: string, apiKey: string, project: string, body: {
+    files: Record<string, string>;
+    baseHash?: string | undefined;
+}): Promise<{
+    sourceHash: string;
+    created: boolean;
+}>;
+/** `POST /studio/projects/:project/deploy` — Publish, in the project's sandbox. */
+export declare function publishStudioProject(serverUrl: string, apiKey: string, project: string): Promise<{
+    ok: true;
+    slug: string;
+    url: string;
+    output: string;
+}>;

package/dist/{_templates-Bv8CR800.mjs → _templates-Bt6u9_68.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { a as errorMessage } from "./_utils-Ch0J4s6a.mjs";
-import { t as getMonorepoRoot } from "./_agent-DMyOab9_.mjs";
+import { t as getMonorepoRoot } from "./_agent-2nVugrN3.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import fs from "node:fs/promises";
@@ -47,6 +47,22 @@ async function listTemplates(root = resolveTemplatesDir()) {
 	return available.filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 /**
+* Layer the base scaffold (package.json, tsconfig, …) into targetDir
+* WITHOUT overwriting anything already there. Shared by `aai init`
+* (underneath a template) and `aai pull` (underneath the studio workspace
+* files — the workspace stores source, and the scaffold completes it into a
+* runnable project the same way the guest's `ensureProjectShape` does
+* before an in-sandbox build).
+*/
+async function layerScaffold(targetDir) {
+	const scaffoldDir = path.join(resolveTemplatesDir(), "scaffold");
+	if (existsSync(scaffoldDir)) await fs.cp(scaffoldDir, targetDir, {
+		recursive: true,
+		force: false,
+		errorOnExist: false
+	});
+}
+/**
 * Copy a template into targetDir, merging scaffold files underneath.
 */
 async function downloadAndMergeTemplate(template, targetDir) {
@@ -58,12 +74,7 @@ async function downloadAndMergeTemplate(template, targetDir) {
 		recursive: true,
 		force: true
 	});
-	const scaffoldDir = path.join(root, "scaffold");
-	if (existsSync(scaffoldDir)) await fs.cp(scaffoldDir, targetDir, {
-		recursive: true,
-		force: false,
-		errorOnExist: false
-	});
+	await layerScaffold(targetDir);
 }
 //#endregion
-export { REPO_URL, downloadAndMergeTemplate, listTemplates };
+export { REPO_URL, downloadAndMergeTemplate, layerScaffold, listTemplates };

package/dist/_templates.d.ts

@@ -21,6 +21,15 @@ export declare function bundledTemplatesDir(): string;
  * can never drift.
  */
 export declare function listTemplates(root?: string): Promise<string[]>;
+/**
+ * Layer the base scaffold (package.json, tsconfig, …) into targetDir
+ * WITHOUT overwriting anything already there. Shared by `aai init`
+ * (underneath a template) and `aai pull` (underneath the studio workspace
+ * files — the workspace stores source, and the scaffold completes it into a
+ * runnable project the same way the guest's `ensureProjectShape` does
+ * before an in-sandbox build).
+ */
+export declare function layerScaffold(targetDir: string): Promise<void>;
 /**
  * Copy a template into targetDir, merging scaffold files underneath.
  */

package/dist/{_typecheck-gate-9IHWDnl1.mjs → _typecheck-gate-DvE8S3aQ.mjs}

@@ -14,4 +14,4 @@ async function assertTypechecks(cwd) {
 	if (!result.ok) throw new CliError("typecheck_failed", result.output, "Fix the type errors, or pass --skipTypecheck to build anyway");
 }
 //#endregion
-export { assertTypechecks as t };
+export { assertTypechecks };

package/dist/{build-D_PgQOD4.mjs → build-BXwDB78d.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { n as log, o as CliError, u as ok } from "./_ui-8kOEB-JH.mjs";
 import { r as evalWorkerBundle, t as buildAgentBundle } from "./_bundler-Cjaxa2wi.mjs";
-import { t as assertTypechecks } from "./_typecheck-gate-9IHWDnl1.mjs";
+import { assertTypechecks } from "./_typecheck-gate-DvE8S3aQ.mjs";
 import { classifyVitestError, runVitest } from "./test-3Gq4pqH_.mjs";
 //#region build.ts
 /**

package/dist/cli.mjs

@@ -5,7 +5,7 @@ import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { defineCommand, runMain } from "citty";
-//#region cli.ts
+//#region _cli-common.ts
 /** Shared arg definitions for citty commands. */
 const sharedArgs = {
 	server: {
@@ -23,21 +23,95 @@ const sharedArgs = {
 		description: "Output JSON (auto-detected in non-TTY)"
 	}
 };
-const cliDir = path.dirname(fileURLToPath(import.meta.url));
+/** Flags citty handles itself, so no command declares them. */
+const BUILTIN_FLAGS = /* @__PURE__ */ new Set([
+	"help",
+	"h",
+	"version",
+	"v"
+]);
 /**
-* Read this CLI's own version from its package.json (source layout keeps it
-* next to cli.ts; dist layout one level up). A missing or corrupt file must
-* not brick every command over a cosmetic string — warn and fall back.
+* Flags in `rawArgs` that `argsDef` doesn't declare, in the form the user
+* typed them.
+*
+* citty silently drops an unrecognized flag, so `aai push --serverr=http://x`
+* exited 0 having pushed to the DEFAULT server — production, for an installed
+* CLI — as if the flag had been honoured. Since `--server` is what decides
+* where the API key and secret values are sent, a typo quietly retargeting it
+* is worth failing on.
 */
-function readCliVersion(dir) {
-	for (const candidate of [path.join(dir, "package.json"), path.join(dir, "..", "package.json")]) try {
-		const parsed = JSON.parse(readFileSync(candidate, "utf-8"));
-		if (typeof parsed.version === "string") return parsed.version;
-	} catch {}
-	process.stderr.write("warning: could not read aai's package.json — reporting version unknown\n");
-	return "unknown";
+function findUnknownFlags(rawArgs, argsDef) {
+	const declared = declaredFlagNames(argsDef);
+	const unknown = [];
+	for (const raw of rawArgs) {
+		if (raw === "--") break;
+		const token = flagToken(raw);
+		if (token && !declared.has(canonicalFlag(token))) unknown.push(token);
+	}
+	return unknown;
+}
+/**
+* A flag's comparison key: dashes dropped and lower-cased, with a leading
+* `no` negation removed.
+*
+* citty accepts both `--allowMissingSecrets` and `--allow-missing-secrets` for
+* an arg declared as `allowMissingSecrets`, and the guest's in-sandbox Publish
+* spawns the kebab-case spelling. Comparing the literal text rejected
+* `--allow-missing-secrets` as unknown and broke Publish for every studio
+* user, so both sides are normalized to one key.
+*/
+function canonicalFlag(flag) {
+	return flag.replace(/^--?/, "").replace(/^no-/, "").replace(/-/g, "").toLowerCase();
+}
+/** Every flag name and alias `argsDef` declares, plus citty's built-ins. */
+function declaredFlagNames(argsDef) {
+	const declared = new Set([...BUILTIN_FLAGS].map(canonicalFlag));
+	for (const [name, def] of Object.entries(argsDef)) {
+		const { type, alias } = def;
+		if (type === "positional") continue;
+		declared.add(canonicalFlag(name));
+		if (typeof alias === "string") declared.add(canonicalFlag(alias));
+		else if (Array.isArray(alias)) for (const a of alias) declared.add(canonicalFlag(a));
+	}
+	return declared;
+}
+/** The flag part of `raw` (`--server` from `--server=x`), or null if positional. */
+function flagToken(raw) {
+	if (!raw.startsWith("-") || raw === "-" || /^-\d/.test(raw)) return null;
+	const eq = raw.indexOf("=");
+	return eq === -1 ? raw : raw.slice(0, eq);
+}
+/** Resolve a possibly-nested `Resolvable` citty field. */
+async function resolve(value) {
+	return typeof value === "function" ? await value() : await value;
+}
+/**
+* Unknown flags in `argv` for whichever (possibly nested) subcommand it
+* selects — `[]` when everything is declared.
+*
+* Walks the real command tree rather than re-listing flags, so this cannot
+* drift from what the commands accept. An unknown SUBCOMMAND is not reported:
+* citty already answers that with usage text and a non-zero exit.
+*/
+async function unknownFlagsForArgv(root, argv) {
+	let cmd = root;
+	let i = 0;
+	for (; i < argv.length; i++) {
+		const token = argv[i];
+		if (token === void 0 || token.startsWith("-")) break;
+		const subCommands = await resolve(cmd.subCommands);
+		const next = subCommands?.[token];
+		if (next === void 0) {
+			if (subCommands && Object.keys(subCommands).length > 0) return [];
+			break;
+		}
+		const resolved = await resolve(next);
+		if (resolved === void 0) break;
+		cmd = resolved;
+	}
+	const argsDef = await resolve(cmd.args) ?? {};
+	return findUnknownFlags(argv.slice(i), argsDef);
 }
-const VERSION = readCliVersion(cliDir);
 /** Shared command setup: resolve cwd, optionally require agent.ts. */
 async function setup(opts) {
 	const cwd = resolveCwd();
@@ -77,6 +151,140 @@ async function runCommand(args, fn) {
 	if (mode === "json") await writeLine(`${JSON.stringify(result)}\n`);
 	if (!result.ok) process.exit(1);
 }
+//#endregion
+//#region _studio-commands.ts
+const list = defineCommand({
+	meta: {
+		name: "list",
+		description: "List your studio projects"
+	},
+	args: {
+		server: sharedArgs.server,
+		json: sharedArgs.json
+	},
+	async run({ args }) {
+		await runCommand(args, async () => {
+			const cwd = resolveCwd();
+			const { executeList } = await import("./studio-sXvYUxr5.mjs");
+			return executeList({
+				cwd,
+				server: args.server
+			});
+		});
+	}
+});
+const pull = defineCommand({
+	meta: {
+		name: "pull",
+		description: "Pull a studio project into a local directory"
+	},
+	args: {
+		project: {
+			type: "positional",
+			description: "Studio project name (see `aai list`)",
+			required: true
+		},
+		dir: {
+			type: "positional",
+			description: "Target directory (default: the project name)",
+			required: false
+		},
+		force: {
+			type: "boolean",
+			alias: "f",
+			description: "Overwrite files in a non-empty directory"
+		},
+		server: sharedArgs.server,
+		json: sharedArgs.json
+	},
+	async run({ args }) {
+		await runCommand(args, async () => {
+			const cwd = resolveCwd();
+			const { executePull } = await import("./studio-sXvYUxr5.mjs");
+			return executePull({
+				cwd,
+				project: args.project,
+				dir: args.dir,
+				force: args.force,
+				server: args.server
+			});
+		});
+	}
+});
+const push = defineCommand({
+	meta: {
+		name: "push",
+		description: "Sync this project's source to its studio workspace"
+	},
+	args: {
+		force: {
+			type: "boolean",
+			alias: "f",
+			description: "Overwrite studio-side changes instead of failing the fast-forward check"
+		},
+		server: sharedArgs.server,
+		json: sharedArgs.json
+	},
+	async run({ args }) {
+		await runCommand(args, async () => {
+			const cwd = await setup({ agent: true });
+			const { executePush } = await import("./studio-sXvYUxr5.mjs");
+			return executePush({
+				cwd,
+				server: args.server,
+				force: args.force
+			});
+		});
+	}
+});
+const publish = defineCommand({
+	meta: {
+		name: "publish",
+		description: "Push to the studio and deploy to production (the studio's Publish button)"
+	},
+	args: {
+		force: {
+			type: "boolean",
+			alias: "f",
+			description: "Overwrite studio-side changes instead of failing the fast-forward check"
+		},
+		server: sharedArgs.server,
+		json: sharedArgs.json,
+		skipTypecheck: {
+			type: "boolean",
+			description: "Skip type checking before publishing"
+		}
+	},
+	async run({ args }) {
+		await runCommand(args, async () => {
+			const cwd = await setup({ agent: true });
+			const { executePublish } = await import("./studio-sXvYUxr5.mjs");
+			return executePublish({
+				cwd,
+				server: args.server,
+				force: args.force,
+				skipTypecheck: args.skipTypecheck
+			});
+		});
+	}
+});
+//#endregion
+//#region cli.ts
+const cliDir = path.dirname(fileURLToPath(import.meta.url));
+/**
+* Read this CLI's own version from its package.json (source layout keeps it
+* next to cli.ts; dist layout one level up). A missing or corrupt file must
+* not brick every command over a cosmetic string — warn and fall back.
+*/
+function readCliVersion(dir) {
+	for (const candidate of [path.join(dir, "package.json"), path.join(dir, "..", "package.json")]) try {
+		const parsed = JSON.parse(readFileSync(candidate, "utf-8"));
+		if (typeof parsed.version === "string") return parsed.version;
+	} catch {}
+	process.stderr.write("warning: could not read aai's package.json — reporting version unknown\n");
+	return "unknown";
+}
+const VERSION = readCliVersion(cliDir);
 const init = defineCommand({
 	meta: {
 		name: "init",
@@ -108,7 +316,7 @@ const init = defineCommand({
 	},
 	async run({ args }) {
 		await runCommand(args, async (mode) => {
-			const { executeInit } = await import("./init-DoU4_txp.mjs");
+			const { executeInit } = await import("./init-BT-IU9AR.mjs");
 			return executeInit({
 				dir: args.dir,
 				force: args.force,
@@ -137,7 +345,7 @@ const dev = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDev } = await import("./dev-gVNdGFYY.mjs");
+			const { executeDev } = await import("./dev-C4KyxouE.mjs");
 			return executeDev({
 				cwd,
 				port: args.port
@@ -178,7 +386,7 @@ const build = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeBuild } = await import("./build-D_PgQOD4.mjs");
+			const { executeBuild } = await import("./build-BXwDB78d.mjs");
 			return executeBuild({
 				cwd,
 				skipTests: args.skipTests,
@@ -190,7 +398,8 @@ const build = defineCommand({
 const deploy = defineCommand({
 	meta: {
 		name: "deploy",
-		description: "Bundle and deploy to production"
+		description: "(internal) used by studio Publish",
+		hidden: true
 	},
 	args: {
 		server: sharedArgs.server,
@@ -199,6 +408,10 @@ const deploy = defineCommand({
 			type: "boolean",
 			description: "Deploy even when the agent's providers are missing credentials (the server warns instead of rejecting; set them afterwards with `aai secret put`)"
 		},
+		allowPreviewSlug: {
+			type: "boolean",
+			description: "Permit a `-preview`-suffixed slug (reserved for studio auto-previews; studio-internal — a slug you claim this way is subject to the preview reaper)"
+		},
 		skipTypecheck: {
 			type: "boolean",
 			description: "Skip type checking before deploy"
@@ -207,11 +420,12 @@ const deploy = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup({ agent: true });
-			const { executeDeploy } = await import("./deploy-1eaXcfUw.mjs");
+			const { executeDeploy } = await import("./deploy-Cp-wgME3.mjs");
 			return executeDeploy({
 				cwd,
 				server: args.server,
 				allowMissingSecrets: args.allowMissingSecrets,
+				allowPreviewSlug: args.allowPreviewSlug,
 				skipTypecheck: args.skipTypecheck
 			});
 		});
@@ -220,7 +434,7 @@ const deploy = defineCommand({
 const del = defineCommand({
 	meta: {
 		name: "delete",
-		description: "Remove a deployed agent"
+		description: "Delete the studio project and its deployed agents"
 	},
 	args: {
 		server: sharedArgs.server,
@@ -229,7 +443,7 @@ const del = defineCommand({
 	async run({ args }) {
 		await runCommand(args, async () => {
 			const cwd = await setup();
-			const { executeDelete } = await import("./delete-DXilFBb1.mjs");
+			const { executeDelete } = await import("./delete-DRNfvczK.mjs");
 			return executeDelete({
 				cwd,
 				server: args.server
@@ -260,7 +474,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async (mode) => {
 					const cwd = await setup();
-					const { executeSecretPut, NO_INPUT, readStdin } = await import("./secret-CGAIAbUx.mjs");
+					const { executeSecretPut, NO_INPUT, readStdin } = await import("./secret-Dr0qnxeb.mjs");
 					const value = mode === "json" ? await readStdin() : void 0;
 					if (mode === "json" && !value) throw new CliError(...NO_INPUT);
 					return executeSecretPut(cwd, args.name, value, args.server);
@@ -284,7 +498,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretDelete } = await import("./secret-CGAIAbUx.mjs");
+					const { executeSecretDelete } = await import("./secret-Dr0qnxeb.mjs");
 					return executeSecretDelete(cwd, args.name, args.server);
 				});
 			}
@@ -301,7 +515,7 @@ const secret = defineCommand({
 			async run({ args }) {
 				await runCommand(args, async () => {
 					const cwd = await setup();
-					const { executeSecretList } = await import("./secret-CGAIAbUx.mjs");
+					const { executeSecretList } = await import("./secret-Dr0qnxeb.mjs");
 					return executeSecretList(cwd, args.server);
 				});
 			}
@@ -336,7 +550,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageStatus } = await import("./storage-CnhOayhm.mjs");
+					const { executeStorageStatus } = await import("./storage-CoQB8d-u.mjs");
 					return executeStorageStatus(resolveStorageCwd(args.dir), args.server);
 				});
 			}
@@ -353,7 +567,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageEnable } = await import("./storage-CnhOayhm.mjs");
+					const { executeStorageEnable } = await import("./storage-CoQB8d-u.mjs");
 					return executeStorageEnable(resolveStorageCwd(args.dir), args.server);
 				});
 			}
@@ -375,7 +589,7 @@ const storage = defineCommand({
 			},
 			async run({ args }) {
 				await runCommand(args, async () => {
-					const { executeStorageDisable } = await import("./storage-CnhOayhm.mjs");
+					const { executeStorageDisable } = await import("./storage-CoQB8d-u.mjs");
 					return executeStorageDisable(resolveStorageCwd(args.dir), {
 						server: args.server,
 						force: args.force
@@ -388,7 +602,7 @@ const storage = defineCommand({
 const login = defineCommand({
 	meta: {
 		name: "login",
-		description: "Sign in with your email and save your API key"
+		description: "Link your signed-in browser account and save your API key"
 	},
 	args: {
 		server: sharedArgs.server,
@@ -396,7 +610,7 @@ const login = defineCommand({
 	},
 	async run({ args }) {
 		await runCommand(args, async () => {
-			const { executeLogin } = await import("./login-C59ZHzuO.mjs");
+			const { executeLogin } = await import("./login-AA_UdRI-.mjs");
 			return executeLogin({ server: args.server });
 		});
 	}
@@ -409,7 +623,7 @@ const templates = defineCommand({
 	args: { json: sharedArgs.json },
 	async run({ args }) {
 		await runCommand(args, async (mode) => {
-			const { listTemplates } = await import("./_templates-Bv8CR800.mjs");
+			const { listTemplates } = await import("./_templates-Bt6u9_68.mjs");
 			const names = await listTemplates();
 			if (mode === "human") {
 				for (const name of names) log.message(name);
@@ -433,6 +647,10 @@ const mainCommand = defineCommand({
 		dev,
 		test,
 		build,
+		list,
+		pull,
+		push,
+		publish,
 		deploy,
 		delete: del,
 		login,
@@ -450,14 +668,28 @@ if (process.env.VITEST !== "true") {
 			return;
 		}
 		if (process.stdin.isTTY && process.stdout.isTTY) {
-			if (await (await import("@clack/prompts")).confirm({ message: "Deploy this agent to production?" }) !== true) {
+			if (await (await import("@clack/prompts")).confirm({ message: "Publish this agent to production?" }) !== true) {
 				log.info("Cancelled. Run `aai --help` to see all commands.");
 				process.exit(0);
 			}
 		}
-		process.argv.splice(2, 0, "deploy");
+		process.argv.splice(2, 0, "publish");
+	};
+	/**
+	* Refuse an unrecognized flag instead of ignoring it.
+	*
+	* citty drops one silently, so `aai push --serverr=http://x` exited 0 having
+	* pushed to the DEFAULT server. `--server` decides where the API key and
+	* secret values go, so a typo that quietly retargets it is worth failing on.
+	*/
+	const assertKnownFlags = async () => {
+		const unknown = await unknownFlagsForArgv(mainCommand, process.argv.slice(2));
+		if (unknown.length === 0) return;
+		log.error(`Unknown ${unknown.length === 1 ? "option" : "options"}: ${unknown.join(", ")}`);
+		log.info("Run `aai <command> --help` to see the options it accepts.");
+		process.exit(1);
 	};
-	runDefault().then(() => runMain(mainCommand)).catch((err) => {
+	runDefault().then(assertKnownFlags).then(() => runMain(mainCommand)).catch((err) => {
 		log.error(errorMessage(err));
 		process.exitCode = 1;
 	});

package/dist/delete-DRNfvczK.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { n as log, u as ok } from "./_ui-8kOEB-JH.mjs";
+import { l as writeProjectConfig } from "./_config-Y5V-5Krn.mjs";
+import { i as resolveDeployTarget, n as getServerInfo } from "./_agent-2nVugrN3.mjs";
+import { n as apiRequest, t as HINT_NOT_DEPLOYED } from "./_api-client-B-upMGkc.mjs";
+//#region delete.ts
+async function runDelete(opts) {
+	await apiRequest(`${opts.url}/${opts.slug}`, {
+		method: "DELETE",
+		apiKey: opts.apiKey,
+		action: "delete",
+		hints: { 404: HINT_NOT_DEPLOYED },
+		...opts.fetch ? { fetch: opts.fetch } : {}
+	});
+}
+/**
+* Delete THE PROJECT. A studio-linked directory deletes its studio project
+* (`DELETE /studio/projects/:project`), which cascades server-side to the
+* workspace, chat, and the project's deployed + preview agents — the exact
+* delete the studio's own Delete button runs. A directory that only knows a
+* slug (no studio link) deletes that deployed agent directly.
+*/
+async function executeDelete(opts) {
+	const { cwd } = opts;
+	const { config, serverUrl, apiKey } = await resolveDeployTarget(cwd, opts.server);
+	if (config?.studioProject) {
+		const project = config.studioProject;
+		log.step(`Deleting studio project ${project} (and its deployed agents)`);
+		await apiRequest(`${serverUrl}/studio/projects/${encodeURIComponent(project)}`, {
+			method: "DELETE",
+			apiKey,
+			action: "delete",
+			hints: { 404: "Run `aai list` to see your projects." }
+		});
+		log.success(`Deleted ${project}`);
+		await writeProjectConfig(cwd, { serverUrl });
+		return ok({
+			project,
+			...config.slug ? { slug: config.slug } : {}
+		});
+	}
+	const { slug } = await getServerInfo(cwd, opts.server);
+	log.step(`Deleting ${slug}`);
+	await runDelete({
+		url: serverUrl,
+		slug,
+		apiKey
+	});
+	log.success(`Deleted ${serverUrl}/${slug}`);
+	return ok({ slug });
+}
+//#endregion
+export { executeDelete };

package/dist/delete.d.ts

@@ -8,9 +8,16 @@ export type DeleteOpts = {
 };
 export declare function runDelete(opts: DeleteOpts): Promise<void>;
 type DeleteData = {
-    slug: string;
+    slug?: string;
+    project?: string;
 };
-/** Execute delete and return structured result. */
+/**
+ * Delete THE PROJECT. A studio-linked directory deletes its studio project
+ * (`DELETE /studio/projects/:project`), which cascades server-side to the
+ * workspace, chat, and the project's deployed + preview agents — the exact
+ * delete the studio's own Delete button runs. A directory that only knows a
+ * slug (no studio link) deletes that deployed agent directly.
+ */
 export declare function executeDelete(opts: {
     cwd: string;
     server?: string | undefined;