@usecontextlayer/cli 0.14.1 → 0.14.3

package/dist/{app-CJgT3IKd.mjs → resources-DEdwfmku.mjs}

@@ -1,5 +1,5 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path, { join } from "node:path";
+import { glob, mkdir, readFile, writeFile } from "node:fs/promises";
+import path, { join, resolve } from "node:path";
 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";
@@ -9836,6 +9836,7 @@ const initializer = (inst, issues) => {
 		} }
 	});
 };
+const ZodError = /*@__PURE__*/ $constructor("ZodError", initializer);
 const ZodRealError = /*@__PURE__*/ $constructor("ZodError", initializer, { Parent: Error });
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/parse.js
@@ -10688,6 +10689,85 @@ function superRefine(fn, params) {
 	return /* @__PURE__ */ _superRefine(fn, params);
 }
 //#endregion
+//#region ../shared/dist/slate.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 folderRequirementSchema = strictObject({ mode: credentialModeSchema });
+const slateSchema = strictObject({
+	connections: record(string().min(1), connectionRequirementSchema),
+	folders: record(string().min(1), folderRequirementSchema).default({}),
+	secrets: record(secretNameSchema, secretRequirementSchema).default({})
+});
+strictObject({
+	agents: record(string().min(1), slateSchema),
+	app: slateSchema
+});
+const resourceConsumerSchema = discriminatedUnion("type", [strictObject({ type: literal("app") }), strictObject({
+	name: string().min(1),
+	type: literal("agent")
+})]);
+const resourcesSchema = slateSchema.extend({
+	connections: record(string().min(1), connectionRequirementSchema.extend({ consumers: array(resourceConsumerSchema) })),
+	folders: record(string().min(1), folderRequirementSchema.extend({ consumers: array(resourceConsumerSchema) })),
+	secrets: record(secretNameSchema, secretRequirementSchema.extend({ consumers: array(resourceConsumerSchema) }))
+});
+function collectAppResources(slates) {
+	const declarations = [{
+		consumer: { type: "app" },
+		slate: slates.app
+	}, ...Object.entries(slates.agents).map(([name, slate]) => ({
+		consumer: {
+			name,
+			type: "agent"
+		},
+		slate
+	}))];
+	return {
+		connections: collectRequirements("connections", declarations, (slate) => slate.connections),
+		folders: collectRequirements("folders", declarations, (slate) => slate.folders),
+		secrets: collectRequirements("secrets", declarations, (slate) => slate.secrets)
+	};
+}
+function resourcesForConsumer(resources, consumer) {
+	return {
+		connections: filterRequirements(resources.connections, consumer),
+		folders: filterRequirements(resources.folders, 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, slate } of declarations) for (const [name, requirement] of Object.entries(select(slate))) {
+		const existing = resources.get(name);
+		if (!existing) {
+			resources.set(name, {
+				...requirement,
+				consumers: [consumer]
+			});
+			continue;
+		}
+		if (existing.mode !== requirement.mode || existing.toolkit !== requirement.toolkit) throw new ZodError([{
+			code: "custom",
+			message: `Conflicting ${category} requirement "${name}": declarations must agree on mode${category === "connections" ? " and toolkit" : ""}`,
+			path: [
+				...consumer.type === "app" ? ["app"] : ["agents", consumer.name],
+				category,
+				name
+			]
+		}]);
+		existing.consumers.push(consumer);
+	}
+	return Object.fromEntries(resources);
+}
+//#endregion
 //#region ../../node_modules/.pnpm/oauth4webapi@3.8.8/node_modules/oauth4webapi/build/index.js
 let USER_AGENT$1;
 if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) USER_AGENT$1 = `oauth4webapi/v3.8.8`;
@@ -11807,6 +11887,9 @@ function retryable(err, options) {
 const retry = Symbol();
 //#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"),
@@ -11876,20 +11959,23 @@ async function whoami() {
 	console.log(user.id);
 }
 //#endregion
-//#region ../shared/dist/slate.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 slateSchema = strictObject({
-	connections: record(string().min(1), connectionRequirementSchema),
-	secrets: record(secretNameSchema, secretRequirementSchema).default({})
-});
-//#endregion
 //#region app.ts
+async function resolveAppTarget(target) {
+	return target === "local" ? getLocalAppId() : target;
+}
+async function joinApp(target) {
+	const appTarget = await resolveAppTarget(target);
+	const response = await fetch(new URL(`/api/apps/${encodeURIComponent(appTarget)}/join`, env.CTX_PLATFORM_URL), {
+		headers: { authorization: `Bearer ${await getAccessToken()}` },
+		method: "POST"
+	});
+	if (!response.ok) throw new Error(`App join failed: HTTP ${response.status}`);
+	const member = object({
+		app_id: uuid(),
+		user_id: string().min(1)
+	}).parse(await response.json());
+	console.log(JSON.stringify(member));
+}
 async function getLocalAppId() {
 	const { stdout: remote } = await execa("git", [
 		"remote",
@@ -11898,10 +11984,102 @@ async function getLocalAppId() {
 	]);
 	return uuid().parse(new URL(remote).pathname.replace(/^\/git\//, ""));
 }
-async function readLocalManifest() {
-	return slateSchema.parse(JSON.parse(await readFile("public/slate.json", "utf8")));
+async function readLocalResources(directory = process.cwd()) {
+	const app = await readLocalSlate(join(directory, "public/slate.json"));
+	const agents = {};
+	for await (const entry of glob("agents/*", {
+		cwd: directory,
+		withFileTypes: true
+	})) if (entry.isDirectory()) agents[entry.name] = await readLocalSlate(join(directory, "agents", entry.name, "slate.json"));
+	return collectAppResources({
+		agents,
+		app
+	});
+}
+async function readLocalSlate(path) {
+	return slateSchema.parse(JSON.parse(await readFile(path, "utf8")));
+}
+//#endregion
+//#region ../shared/dist/app-usage.mjs
+const ownerSchema = discriminatedUnion("type", [object({
+	id: string().min(1),
+	type: literal("user")
+}), object({
+	id: string().min(1),
+	type: literal("organization")
+})]);
+object({
+	id: uuid(),
+	owner: ownerSchema
+});
+//#endregion
+//#region ../shared/dist/app-resources.mjs
+const appResourceConfigurationSchema = resourcesSchema.extend({
+	connections: record(resourcesSchema.shape.connections.keyType, resourcesSchema.shape.connections.valueType.extend({
+		connection_id: string().nullable(),
+		owner: ownerSchema
+	})),
+	folders: record(resourcesSchema.shape.folders.keyType, resourcesSchema.shape.folders.valueType.extend({ owner: ownerSchema })),
+	secrets: record(resourcesSchema.shape.secrets.keyType, resourcesSchema.shape.secrets.valueType.extend({ owner: ownerSchema }))
+});
+object({ resources: appResourceConfigurationSchema });
+const localResourceConfigurationSchema = resourcesSchema.extend({
+	connections: record(resourcesSchema.shape.connections.keyType, resourcesSchema.shape.connections.valueType.extend({ connection_id: string().min(1).nullable() })),
+	folders: record(resourcesSchema.shape.folders.keyType.regex(/^(?!\.{1,2}$)[^/\\]+$/), resourcesSchema.shape.folders.valueType.extend({ path: string().min(1) })),
+	secrets: record(resourcesSchema.shape.secrets.keyType, resourcesSchema.shape.secrets.valueType.extend({ value: string().nullable() }))
+});
+//#endregion
+//#region resources.ts
+const localConnectionsSchema = record(resourcesSchema.shape.connections.keyType, string().min(1));
+async function readOptionalFile(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	}
 }
-//#endregion
-export { execa as S, record as _, getAccessToken as a, url as b, whoami as c, boolean as d, discriminatedUnion as f, object as g, looseObject as h, secretNameSchema as i, env as l, literal as m, readLocalManifest as n, getCurrentUser as o, hostname as p, connectionRequirementSchema as r, login as s, getLocalAppId as t, array as u, string as v, uuid as x, unknown as y };
+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`);
+}
+async function prepareLocalResourceConfiguration(directory = process.cwd()) {
+	const resources = await readLocalResources(directory);
+	const bindings = new Map(Object.entries(await readLocalConnections(directory)));
+	const configuration = localResourceConfigurationSchema.parse({
+		connections: Object.fromEntries(Object.entries(resources.connections).map(([slug, requirement]) => [slug, {
+			...requirement,
+			connection_id: bindings.get(slug) ?? null
+		}])),
+		folders: Object.fromEntries(Object.entries(resources.folders).map(([slug, requirement]) => [slug, {
+			...requirement,
+			path: resolve(directory, ".contextlayer", "folders", slug)
+		}])),
+		secrets: Object.fromEntries(Object.entries(resources.secrets).map(([name, requirement]) => [name, {
+			...requirement,
+			value: readLocalSecret(name)
+		}]))
+	});
+	await prepareLocalDirectory(directory);
+	await Promise.all(Object.values(configuration.folders).map(({ path }) => mkdir(path, { recursive: true })));
+	return configuration;
+}
+async function saveLocalConnection(slug, connectionId, directory = process.cwd()) {
+	const binding = localConnectionsSchema.parse({ [slug]: connectionId });
+	const connections = {
+		...await readLocalConnections(directory),
+		...binding
+	};
+	await prepareLocalDirectory(directory);
+	await writeFile(resolve(directory, ".contextlayer/connections.json"), `${JSON.stringify(connections, null, 2)}\n`);
+}
+//#endregion
+export { unknown as C, execa as E, union as S, uuid as T, literal as _, getLocalAppId as a, record as b, getCurrentUser as c, env as d, resourcesForConsumer as f, hostname as g, boolean as h, ownerSchema as i, login as l, array as m, saveLocalConnection as n, joinApp as o, secretNameSchema as p, appResourceConfigurationSchema as r, getAccessToken as s, prepareLocalResourceConfiguration as t, whoami as u, looseObject as v, url as w, string as x, object as y };
 
-//# sourceMappingURL=app-CJgT3IKd.mjs.map
+//# sourceMappingURL=resources-DEdwfmku.mjs.map