@usecontextlayer/cli 0.16.2 → 0.18.0

package/dist/{resources--XCCMeP6.mjs → resources-0GJALfam.mjs}

@@ -1,21 +1,23 @@
-import { C as ZodError, S as uuid, _ as strictObject, c as array, f as literal, g as record, h as object, l as boolean, m as number, n as getAccessToken, o as _enum, s as _null, u as discriminatedUnion, v as string, x as url, y as union } from "./auth-DOsE8GwJ.mjs";
+import { a as boolean, c as literal, d as record, g as uuid, o as discriminatedUnion, p as string, u as object } from "./schemas-D9UReYiT.mjs";
+import { c as resourcesSchema, i as collectSlateResources, o as declarationSchema, r as readLocalSecret } from "./env-C_tllJ4u.mjs";
 import { glob, mkdir, readFile, writeFile } from "node:fs/promises";
-import { constants } from "node:os";
 import path, { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { EventEmitter, addAbortListener, on, once, setMaxListeners } from "node:events";
 import { ChildProcess, execFile, spawn, spawnSync } from "node:child_process";
 import fs, { appendFileSync, closeSync, createReadStream, createWriteStream, openSync, readFileSync, readSync, statSync, writeFileSync } from "node:fs";
 import process$1, { execArgv, execPath, hrtime, platform } from "node:process";
 import { aborted, callbackify, debuglog, inspect, promisify, stripVTControlCharacters } from "node:util";
-import { fileURLToPath } from "node:url";
 import { StringDecoder } from "node:string_decoder";
 import tty from "node:tty";
 import { scheduler, setImmediate, setTimeout } from "node:timers/promises";
+import { constants } from "node:os";
 import { serialize } from "node:v8";
 import { Buffer } from "node:buffer";
 import { finished } from "node:stream/promises";
 import { Duplex, PassThrough, Readable, Transform, Writable, getDefaultHighWaterMark } from "node:stream";
 import path$1 from "node:path/win32";
+import { createHash } from "node:crypto";
 //#region ../../node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
 	if (typeof value !== "object" || value === null) return false;
@@ -6350,132 +6352,6 @@ createExeca(mapNode);
 createExeca(mapScriptAsync, {}, deepScriptOptions, setScriptSync);
 const { sendMessage, getOneMessage, getEachMessage, getCancelSignal } = getIpcExport();
 //#endregion
-//#region ../shared/dist/databases.mjs
-const databaseJournalSchema = object({ entries: array(object({
-	breakpoints: boolean(),
-	idx: number().int().nonnegative(),
-	tag: string().min(1),
-	when: number()
-})) });
-const databaseMigrationsSchema = object({
-	journal: databaseJournalSchema,
-	migrations: record(string(), string())
-});
-async function readDatabaseMigrations(slug, read) {
-	const directory = `databases/${slug}/migrations`;
-	const contents = await read(`${directory}/meta/_journal.json`);
-	if (contents === null) return {
-		journal: { entries: [] },
-		migrations: {}
-	};
-	const journal = databaseJournalSchema.parse(JSON.parse(contents));
-	const migrations = await Promise.all(journal.entries.map(async (entry) => {
-		const sql = await read(`${directory}/${entry.tag}.sql`);
-		if (sql === null) throw new Error(`Missing database migration: ${slug}/${entry.tag}.sql`);
-		return [`m${entry.idx.toString().padStart(4, "0")}`, sql];
-	}));
-	return {
-		journal,
-		migrations: Object.fromEntries(migrations)
-	};
-}
-const sqlValueSchema = union([
-	string(),
-	number(),
-	_null()
-]);
-const databaseQuerySchema = strictObject({
-	params: array(sqlValueSchema).default([]),
-	slug: string().min(1),
-	sql: string().min(1)
-});
-const databaseResultSchema = object({
-	columns: array(string()),
-	rows: array(array(sqlValueSchema)),
-	rowsRead: number(),
-	rowsWritten: number()
-});
-//#endregion
-//#region ../shared/dist/declaration.mjs
-const credentialModeSchema = _enum(["viewer", "owner"]);
-const connectionRequirementSchema = strictObject({
-	mode: credentialModeSchema,
-	toolkit: string().min(1)
-});
-const secretNameSchema = string().regex(/^[A-Z_][A-Z0-9_]*$/);
-const secretRequirementSchema = strictObject({ mode: credentialModeSchema });
-const databaseRequirementSchema = strictObject({ mode: credentialModeSchema });
-const databaseSlugSchema = string().min(1).regex(/^(?!\.{1,2}$)[^/\\]+$/);
-const declarationSchema = strictObject({
-	connections: record(string().min(1), connectionRequirementSchema),
-	databases: record(databaseSlugSchema, databaseRequirementSchema).default({}),
-	secrets: record(secretNameSchema, secretRequirementSchema).default({})
-});
-strictObject({
-	agents: record(string().min(1), declarationSchema),
-	app: declarationSchema
-});
-const resourceConsumerSchema = discriminatedUnion("type", [strictObject({ type: literal("app") }), strictObject({
-	name: string().min(1),
-	type: literal("agent")
-})]);
-const resourcesSchema = declarationSchema.extend({
-	connections: record(string().min(1), connectionRequirementSchema.extend({ consumers: array(resourceConsumerSchema) })),
-	databases: record(databaseSlugSchema, databaseRequirementSchema.extend({ consumers: array(resourceConsumerSchema) })),
-	secrets: record(secretNameSchema, secretRequirementSchema.extend({ consumers: array(resourceConsumerSchema) }))
-});
-function collectSlateResources(slateDeclarations) {
-	const declarations = [{
-		consumer: { type: "app" },
-		declaration: slateDeclarations.app
-	}, ...Object.entries(slateDeclarations.agents).map(([name, declaration]) => ({
-		consumer: {
-			name,
-			type: "agent"
-		},
-		declaration
-	}))];
-	return {
-		connections: collectRequirements("connections", declarations, (declaration) => declaration.connections),
-		databases: collectRequirements("databases", declarations, (declaration) => declaration.databases),
-		secrets: collectRequirements("secrets", declarations, (declaration) => declaration.secrets)
-	};
-}
-function resourcesForConsumer(resources, consumer) {
-	return {
-		connections: filterRequirements(resources.connections, consumer),
-		databases: filterRequirements(resources.databases, consumer),
-		secrets: filterRequirements(resources.secrets, consumer)
-	};
-}
-function filterRequirements(requirements, consumer) {
-	return Object.fromEntries(Object.entries(requirements).filter(([, requirement]) => requirement.consumers.some((declared) => declared.type === consumer.type && (consumer.type === "app" || declared.type === "agent" && declared.name === consumer.name))));
-}
-function collectRequirements(category, declarations, select) {
-	const resources = /* @__PURE__ */ new Map();
-	for (const { consumer, declaration } of declarations) for (const [key, requirement] of Object.entries(select(declaration))) {
-		const existing = resources.get(key);
-		if (!existing) {
-			resources.set(key, {
-				...requirement,
-				consumers: [consumer]
-			});
-			continue;
-		}
-		if (existing.mode !== requirement.mode || existing.toolkit !== requirement.toolkit) throw new ZodError([{
-			code: "custom",
-			message: `Conflicting ${category} requirement "${key}": declarations must agree on mode${category === "connections" ? " and toolkit" : ""}`,
-			path: [
-				...consumer.type === "app" ? ["app"] : ["agents", consumer.name],
-				category,
-				key
-			]
-		}]);
-		existing.consumers.push(consumer);
-	}
-	return Object.fromEntries(resources);
-}
-//#endregion
 //#region ../shared/dist/slate-usage.mjs
 const ownerSchema = discriminatedUnion("type", [object({
 	id: string().min(1),
@@ -6493,52 +6369,30 @@ object({
 const noCommitSchema = object({ reason: literal("no-commit") });
 const slateResourceConfigurationSchema = resourcesSchema.extend({
 	connections: record(resourcesSchema.shape.connections.keyType, resourcesSchema.shape.connections.valueType.extend({
-		connection_id: string().nullable(),
+		account_id: string().nullable(),
 		owner: ownerSchema
 	})),
 	databases: record(resourcesSchema.shape.databases.keyType, resourcesSchema.shape.databases.valueType.extend({
 		instance_name: string().min(1),
 		owner: ownerSchema
 	})),
-	secrets: record(resourcesSchema.shape.secrets.keyType, resourcesSchema.shape.secrets.valueType.extend({ owner: ownerSchema }))
+	secrets: record(resourcesSchema.shape.secrets.keyType, discriminatedUnion("mode", [resourcesSchema.shape.secrets.valueType.extend({
+		mode: literal("owner"),
+		owner: ownerSchema
+	}), resourcesSchema.shape.secrets.valueType.extend({
+		mode: literal("viewer"),
+		owner: ownerSchema,
+		supplied: boolean()
+	})]))
 });
 object({ resources: slateResourceConfigurationSchema });
 const localResourceConfigurationSchema = resourcesSchema.extend({
-	connections: record(resourcesSchema.shape.connections.keyType, resourcesSchema.shape.connections.valueType.extend({ connection_id: string().min(1).nullable() })),
-	databases: record(resourcesSchema.shape.databases.keyType, resourcesSchema.shape.databases.valueType.extend({
-		instance_name: string().min(1),
-		migrations: databaseMigrationsSchema
-	})),
+	connections: record(resourcesSchema.shape.connections.keyType, resourcesSchema.shape.connections.valueType.extend({ account_id: string().min(1).nullable() })),
+	databases: record(resourcesSchema.shape.databases.keyType, resourcesSchema.shape.databases.valueType.extend({ instance_name: string().min(1) })),
 	secrets: record(resourcesSchema.shape.secrets.keyType, resourcesSchema.shape.secrets.valueType.extend({ value: string().nullable() }))
 });
 //#endregion
-//#region env.ts
-function readLocalSecret(name) {
-	return process.env[name] ?? null;
-}
-const env = object({
-	CTX_AUTH_CLIENT_ID: string().min(1).default("QBFOYTTCdjpEiXwgDNnovDPoJBYAfRpF"),
-	CTX_AUTH_ISSUER: url().default("https://www.usecontextlayer.com/api/auth"),
-	CTX_PLATFORM_URL: url().default("https://platform.usecontextlayer.com")
-}).parse(process.env);
-//#endregion
 //#region slate.ts
-async function resolveSlateTarget(target) {
-	return target === "local" ? getLocalSlateId() : target;
-}
-async function joinSlate(target) {
-	const slateTarget = await resolveSlateTarget(target);
-	const response = await fetch(new URL(`/api/slates/${encodeURIComponent(slateTarget)}/join`, env.CTX_PLATFORM_URL), {
-		headers: { authorization: `Bearer ${await getAccessToken(env)}` },
-		method: "POST"
-	});
-	if (!response.ok) throw new Error(`Slate join failed: HTTP ${response.status}`);
-	const member = object({
-		slate_id: uuid(),
-		user_id: string().min(1)
-	}).parse(await response.json());
-	console.log(JSON.stringify(member));
-}
 async function getLocalSlateId() {
 	const { stdout: remote } = await execa("git", [
 		"remote",
@@ -6577,43 +6431,37 @@ async function readLocalConnections(directory) {
 	const contents = await readOptionalFile(resolve(directory, ".contextlayer/connections.json"));
 	return localConnectionsSchema.parse(contents === null ? {} : JSON.parse(contents));
 }
-async function prepareLocalDirectory(directory) {
-	await mkdir(resolve(directory, ".contextlayer"), { recursive: true });
-	const ignorePath = resolve(directory, ".gitignore");
-	const contents = await readOptionalFile(ignorePath) ?? "";
-	if (!contents.split(/\r?\n/).includes("/.contextlayer/")) await writeFile(ignorePath, `${contents}${contents && !contents.endsWith("\n") ? "\n" : ""}/.contextlayer/\n`);
+function getLocalResourcesWorkerName() {
+	return `ctx-local-resources-${createHash("sha256").update(process.cwd()).digest("hex").slice(0, 16)}`;
 }
 async function prepareLocalResourceConfiguration(directory = process.cwd()) {
 	const resources = await readLocalResources(directory);
 	const assignments = new Map(Object.entries(await readLocalConnections(directory)));
-	const configuration = localResourceConfigurationSchema.parse({
+	return localResourceConfigurationSchema.parse({
 		connections: Object.fromEntries(Object.entries(resources.connections).map(([slug, requirement]) => [slug, {
 			...requirement,
-			connection_id: assignments.get(slug) ?? null
+			account_id: assignments.get(slug) ?? null
 		}])),
-		databases: Object.fromEntries(await Promise.all(Object.entries(resources.databases).map(async ([slug, requirement]) => [slug, {
+		databases: Object.fromEntries(Object.entries(resources.databases).map(([slug, requirement]) => [slug, {
 			...requirement,
-			instance_name: slug,
-			migrations: await readDatabaseMigrations(slug, (path) => readOptionalFile(resolve(directory, path)))
-		}]))),
+			instance_name: slug
+		}])),
 		secrets: Object.fromEntries(Object.entries(resources.secrets).map(([name, requirement]) => [name, {
 			...requirement,
 			value: readLocalSecret(name)
 		}]))
 	});
-	await prepareLocalDirectory(directory);
-	return configuration;
 }
-async function saveLocalConnection(slug, connectionId, directory = process.cwd()) {
-	const assignment = localConnectionsSchema.parse({ [slug]: connectionId });
+async function saveLocalConnection(slug, accountId, directory = process.cwd()) {
+	const assignment = localConnectionsSchema.parse({ [slug]: accountId });
 	const connections = {
 		...await readLocalConnections(directory),
 		...assignment
 	};
-	await prepareLocalDirectory(directory);
+	await mkdir(resolve(directory, ".contextlayer"), { recursive: true });
 	await writeFile(resolve(directory, ".contextlayer/connections.json"), `${JSON.stringify(connections, null, 2)}\n`);
 }
 //#endregion
-export { env as a, ownerSchema as c, databaseQuerySchema as d, databaseResultSchema as f, joinSlate as i, resourcesForConsumer as l, saveLocalConnection as n, noCommitSchema as o, execa as p, getLocalSlateId as r, slateResourceConfigurationSchema as s, prepareLocalResourceConfiguration as t, secretNameSchema as u };
+export { noCommitSchema as a, execa as c, getLocalSlateId as i, prepareLocalResourceConfiguration as n, slateResourceConfigurationSchema as o, saveLocalConnection as r, ownerSchema as s, getLocalResourcesWorkerName as t };
 
-//# sourceMappingURL=resources--XCCMeP6.mjs.map
+//# sourceMappingURL=resources-0GJALfam.mjs.map