@usecontextlayer/cli 0.17.0 → 0.18.0

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import { a as login, i as listOrganizations, n as getAccessToken, r as getCurrentUser, t as LoginRequiredError } from "./auth-BL9AxZGb.mjs";
 import { a as boolean, c as literal, g as uuid, h as url, i as array, o as discriminatedUnion, p as string, r as _undefined, s as hostname, u as object } from "./schemas-D9UReYiT.mjs";
 import { a as databaseSlugSchema, l as secretNameSchema, n as env, s as resourcesForConsumer } from "./env-C_tllJ4u.mjs";
-import { a as noCommitSchema, c as execa, n as prepareLocalResourceConfiguration, o as slateResourceConfigurationSchema, r as saveLocalConnection, s as ownerSchema } from "./resources-BhJbHzU0.mjs";
+import { a as noCommitSchema, c as execa, n as prepareLocalResourceConfiguration, o as slateResourceConfigurationSchema, r as saveLocalConnection, s as ownerSchema } from "./resources-0GJALfam.mjs";
 import { t as databaseQuerySchema } from "./databases-SvX3IgqC.mjs";
 import { readFile } from "node:fs/promises";
 import path, { join, resolve } from "node:path";
@@ -2971,15 +2971,15 @@ function useColor() {
 }
 new Command();
 //#endregion
-//#region ../shared/dist/connections.mjs
-const connectionSchema = object({
+//#region ../shared/dist/accounts.mjs
+const accountSchema = object({
 	alias: string().nullable(),
 	display_name: string().nullable(),
 	id: string(),
 	status: literal("ACTIVE"),
 	toolkit: string()
 });
-const connectionsSchema = object({ connections: array(connectionSchema) });
+const accountsSchema = object({ accounts: array(accountSchema) });
 //#endregion
 //#region owner.ts
 const ownerOptionsSchema = object({ org: string().min(1).optional() });
@@ -3003,7 +3003,7 @@ function ownerPath(owner) {
 async function connectAccount(toolkit, org) {
 	const headers = { authorization: `Bearer ${await getAccessToken(env)}` };
 	const owner = await resolveOwner(org, headers);
-	const response = await fetch(new URL(`/api/connections/${ownerPath(owner)}`, env.CTX_PLATFORM_URL), {
+	const response = await fetch(new URL(`/api/accounts/${ownerPath(owner)}`, env.CTX_PLATFORM_URL), {
 		body: JSON.stringify({ toolkit }),
 		headers: {
 			...headers,
@@ -3016,19 +3016,19 @@ async function connectAccount(toolkit, org) {
 	console.log(`Open this link to connect the Owner's account:\n${redirect_url}`);
 	console.log("After connecting in your browser, assign the connected account to a slate's declared connection.");
 	if (!org) console.log("From your checkout, assign your connected account to a connection declared in slate.json:\n  npx @usecontextlayer/cli connections local assign <slug>");
-	console.log(`For a hosted slate, get the connected account ID and assign it:\n  npx @usecontextlayer/cli accounts${org ? ` --org '${org.replaceAll("'", "'\\''")}'` : ""} list\n  npx @usecontextlayer/cli connections <SlateID-or-hostname> assign <slug> <connection_id>`);
+	console.log(`For a hosted slate, get the connected account ID and assign it:\n  npx @usecontextlayer/cli accounts${org ? ` --org '${org.replaceAll("'", "'\\''")}'` : ""} list\n  npx @usecontextlayer/cli connections <SlateID-or-hostname> assign <slug> <account_id>`);
 }
 async function listAccounts(org) {
 	const headers = { authorization: `Bearer ${await getAccessToken(env)}` };
 	const owner = await resolveOwner(org, headers);
-	const response = await fetch(new URL(`/api/connections/${ownerPath(owner)}`, env.CTX_PLATFORM_URL), { headers });
+	const response = await fetch(new URL(`/api/accounts/${ownerPath(owner)}`, env.CTX_PLATFORM_URL), { headers });
 	if (!response.ok) throw new Error(`Connected account list failed: HTTP ${response.status}`);
-	const { connections } = connectionsSchema.parse(await response.json());
-	if (connections.length === 0) {
+	const { accounts } = accountsSchema.parse(await response.json());
+	if (accounts.length === 0) {
 		console.log("No connected accounts.");
 		return;
 	}
-	console.table(connections);
+	console.table(accounts);
 }
 //#endregion
 //#region agents.ts
@@ -3050,7 +3050,7 @@ async function runLocalAgent(name, prompt) {
 		name,
 		type: "agent"
 	});
-	const { openLocalDatabases } = await import("./local-databases-ChvVgJH6.mjs");
+	const { openLocalDatabases } = await import("./local-databases-C5qUZcUH.mjs");
 	const storage = await openLocalDatabases(bindings.workerName, configuration.databases);
 	const { query, createSdkMcpServer, tool } = await import("@anthropic-ai/claude-agent-sdk");
 	const run = query({
@@ -3952,58 +3952,58 @@ const slateConnectionsSchema = object({ connections: array(slateConnectionSchema
 //#endregion
 //#region connections.ts
 const connectionsCommandSchema = discriminatedUnion("operation", [object({
-	connection_id: _undefined(),
+	account_id: _undefined(),
 	operation: literal("list"),
 	slug: _undefined(),
 	target: string().min(1)
 }), object({
-	connection_id: string().min(1).optional(),
+	account_id: string().min(1).optional(),
 	operation: literal("assign"),
 	slug: string().min(1),
 	target: string().min(1)
 }).superRefine((input, ctx) => {
-	if (input.target !== "local" && input.connection_id === void 0) ctx.addIssue({
+	if (input.target !== "local" && input.account_id === void 0) ctx.addIssue({
 		code: "custom",
-		message: "Hosted assignment requires a connection ID",
-		path: ["connection_id"]
+		message: "Hosted assignment requires an account ID",
+		path: ["account_id"]
 	});
 })]);
-async function assignSlateConnection(target, slug, connectionId) {
+async function assignSlateConnection(target, slug, accountId) {
 	if (target === "local") {
 		const configuration = await prepareLocalResourceConfiguration();
 		const requirement = new Map(Object.entries(configuration.connections)).get(slug);
 		if (!requirement) throw new Error(`No local connection requirement for "${slug}"`);
-		if (connectionId === void 0 && !process.stdin.isTTY) throw new Error("Supply a connection ID when assigning without a terminal");
-		const url = new URL("/api/connections", env.CTX_PLATFORM_URL);
+		if (accountId === void 0 && !process.stdin.isTTY) throw new Error("Supply an account ID when assigning without a terminal");
+		const url = new URL("/api/accounts", env.CTX_PLATFORM_URL);
 		url.searchParams.set("toolkit", requirement.toolkit);
 		const response = await fetch(url, { headers: { authorization: `Bearer ${await getAccessToken(env)}` } });
 		if (!response.ok) throw new Error(`Personal connected account list failed: HTTP ${response.status}`);
-		const { connections } = connectionsSchema.parse(await response.json());
-		if (connections.length === 0) throw new Error(`No personal connected accounts for ${requirement.toolkit}. Run npx @usecontextlayer/cli accounts add ${requirement.toolkit} to connect an account in your browser, then rerun this assignment.`);
-		if (connectionId === void 0) {
-			const accountId = await select({
+		const { accounts } = accountsSchema.parse(await response.json());
+		if (accounts.length === 0) throw new Error(`No personal connected accounts for ${requirement.toolkit}. Run npx @usecontextlayer/cli accounts add ${requirement.toolkit} to connect an account in your browser, then rerun this assignment.`);
+		if (accountId === void 0) {
+			const selectedAccountId = await select({
 				message: `Assign a connected ${requirement.toolkit} account to ${slug}`,
-				options: connections.map((connection) => ({
-					label: `${connection.display_name ?? connection.alias ?? connection.id} (${connection.id}; ${connection.status})`,
-					value: connection.id
+				options: accounts.map((account) => ({
+					label: `${account.display_name ?? account.alias ?? account.id} (${account.id}; ${account.status})`,
+					value: account.id
 				})),
 				output: process.stderr
 			});
-			if (isCancel(accountId)) {
+			if (isCancel(selectedAccountId)) {
 				process.exitCode = 130;
 				return;
 			}
-			connectionId = accountId;
+			accountId = selectedAccountId;
 		}
-		if (!connections.some(({ id }) => id === connectionId)) throw new Error(`Connected account ${connectionId} is not one of your connected ${requirement.toolkit} accounts`);
-		await saveLocalConnection(slug, connectionId);
-		console.log(`${slug} → ${connectionId}`);
+		if (!accounts.some(({ id }) => id === accountId)) throw new Error(`Connected account ${accountId} is not one of your connected ${requirement.toolkit} accounts`);
+		await saveLocalConnection(slug, accountId);
+		console.log(`${slug} → ${accountId}`);
 		console.log("Start or restart pnpm dev to use this assignment.");
 		return;
 	}
 	const response = await fetch(new URL(`/api/slates/${encodeURIComponent(target)}/connections/assign`, env.CTX_PLATFORM_URL), {
 		body: JSON.stringify({
-			connection_id: connectionId,
+			account_id: accountId,
 			slug
 		}),
 		headers: {
@@ -4015,10 +4015,10 @@ async function assignSlateConnection(target, slug, connectionId) {
 	if (response.status === 409 && noCommitSchema.safeParse(await response.json()).success) throw new Error("Nothing has been pushed to this slate yet. Push to main before configuring hosted resources.");
 	if (!response.ok) throw new Error(`Connection assignment failed: HTTP ${response.status}`);
 	const assignment = object({
-		connection_id: string(),
+		account_id: string(),
 		slug: string()
 	}).parse(await response.json());
-	console.log(`${assignment.slug} → ${assignment.connection_id}`);
+	console.log(`${assignment.slug} → ${assignment.account_id}`);
 }
 async function prepareSlateConnections(target) {
 	if (target === "local") {
@@ -4046,9 +4046,9 @@ async function listSlateConnections(target) {
 		console.log("No connection requirements.");
 		return;
 	}
-	console.table(connections.map(({ connection_id, consumers, ...requirement }) => ({
+	console.table(connections.map(({ account_id, consumers, ...requirement }) => ({
 		...requirement,
-		connected_account: connection_id ?? "unassigned",
+		connected_account: account_id ?? "unassigned",
 		consumers: consumers.map((consumer) => consumer.type === "app" ? "app" : `agent:${consumer.name}`).join(", ")
 	})));
 }
@@ -4094,7 +4094,7 @@ async function gitCredential(operation) {
 }
 //#endregion
 //#region package.json
-var version = "0.17.0";
+var version = "0.18.0";
 //#endregion
 //#region secrets.ts
 const secretOptionsSchema = ownerOptionsSchema.extend({ stdin: boolean().default(false) });
@@ -4267,13 +4267,13 @@ const accounts = program.command("accounts").description("Connect and list the s
 accounts.command("list").description("List the selected Owner's connected accounts with their toolkit, identity, and status").action(async (_options, command) => {
 	await listAccounts(ownerOptionsSchema.parse(command.optsWithGlobals()).org);
 });
-accounts.command("add <toolkit>").description("Connect the selected Owner's account in your browser (for example, gmail), then assign it with ctx connections <target> assign <slug> [connection_id]").action(async (toolkit, _options, command) => {
+accounts.command("add <toolkit>").description("Connect the selected Owner's account in your browser (for example, gmail), then assign it with ctx connections <target> assign <slug> [account_id]").action(async (toolkit, _options, command) => {
 	const options = ownerOptionsSchema.parse(command.optsWithGlobals());
 	await connectAccount(string().min(1).parse(toolkit), options.org);
 });
-program.command("connections").description("List declared app and agent connections or assign connected accounts; local reads and saves checkout configuration, SlateID/hostname uses pushed declarations and hosted assignments").argument("<target>", "SlateID, public hostname, or local (run from the checkout root)").addArgument(new Argument("<operation>").choices(["list", "assign"])).argument("[slug]", "Required for assign: connection slug declared in slate.json (for example, work-email)").argument("[connection_id]", "For assign: connected account ID; omit locally to choose interactively; required for hosted targets").action(async (target, operation, slug, connectionId, _options, command) => {
+program.command("connections").description("List declared app and agent connections or assign connected accounts; local reads and saves checkout configuration, SlateID/hostname uses pushed declarations and hosted assignments").argument("<target>", "SlateID, public hostname, or local (run from the checkout root)").addArgument(new Argument("<operation>").choices(["list", "assign"])).argument("[slug]", "Required for assign: connection slug declared in slate.json (for example, work-email)").argument("[account_id]", "For assign: connected account ID; omit locally to choose interactively; required for hosted targets").action(async (target, operation, slug, accountId, _options, command) => {
 	const parsed = connectionsCommandSchema.safeParse({
-		connection_id: connectionId,
+		account_id: accountId,
 		operation,
 		slug,
 		target
@@ -4286,7 +4286,7 @@ program.command("connections").description("List declared app and agent connecti
 			await listSlateConnections(input.target);
 			break;
 		case "assign":
-			await assignSlateConnection(input.target, input.slug, input.connection_id);
+			await assignSlateConnection(input.target, input.slug, input.account_id);
 			break;
 		default: throw new Error(`Unhandled connections operation: ${JSON.stringify(input)}`);
 	}
@@ -4309,7 +4309,7 @@ secrets.command("drop").argument("<name>", "Secret name: uppercase letters, digi
 	await dropSecret(secretNameSchema.parse(name), secretOptionsSchema.parse(command.optsWithGlobals()).org);
 });
 program.command("db.codegen").argument("<slug>", "Database declared in public/slate.json or agents/<name>/slate.json").description("Generate databases/<slug>/types.ts from the migrated local database").addHelpText("after", "\nRun from the slate root with pnpm dev running.\nApply migrations with pnpm exec kysely before generating types.\n\nExample:\n  pnpm db.codegen notes").action(async (slug, _options, command) => {
-	const { generateDatabaseTypes } = await import("./database-codegen-C5TEhR5_.mjs");
+	const { generateDatabaseTypes } = await import("./database-codegen-CxDtyvam.mjs");
 	try {
 		await generateDatabaseTypes(databaseSlugSchema.parse(slug));
 	} catch (error) {