@inkeep/agents-cli 0.39.4 → 0.40.0

package/dist/utils/profiles/types.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+
+//#region src/utils/profiles/types.ts
+/**
+* Baked-in URLs for Inkeep Cloud deployment
+*/
+const CLOUD_REMOTE = {
+	manageApi: "https://manage-api.inkeep.com",
+	manageUi: "https://manage.inkeep.com",
+	runApi: "https://run-api.inkeep.com"
+};
+/**
+* Schema for explicit remote URLs (custom/local deployments)
+*/
+const explicitRemoteSchema = z.object({
+	manageApi: z.string().url("manageApi must be a valid URL"),
+	manageUi: z.string().url("manageUi must be a valid URL"),
+	runApi: z.string().url("runApi must be a valid URL")
+});
+/**
+* Schema for remote configuration - either 'cloud' shorthand or explicit URLs
+*/
+const remoteSchema = z.union([z.literal("cloud"), explicitRemoteSchema]);
+/**
+* Profile name validation - alphanumeric + hyphens only
+*/
+const profileNameSchema = z.string().min(1, "Profile name cannot be empty").max(64, "Profile name too long (max 64 characters)").regex(/^[a-z0-9-]+$/, "Profile name must be lowercase alphanumeric with hyphens only");
+/**
+* Schema for a single profile configuration
+*/
+const profileSchema = z.object({
+	remote: remoteSchema,
+	credential: z.string().min(1, "Credential reference cannot be empty"),
+	environment: z.string().min(1, "Environment cannot be empty")
+});
+/**
+* Schema for the entire profiles.yaml configuration
+* Note: We use z.record(z.string(), profileSchema) for Zod v4 compatibility
+* Profile name validation is done separately in addProfile
+*/
+const profilesConfigSchema = z.object({
+	activeProfile: z.string().min(1, "activeProfile cannot be empty"),
+	profiles: z.record(z.string(), profileSchema)
+});
+/**
+* Default cloud profile configuration
+*/
+const DEFAULT_CLOUD_PROFILE = {
+	remote: "cloud",
+	credential: "inkeep-cloud",
+	environment: "production"
+};
+/**
+* Default profiles.yaml content when creating for the first time
+*/
+const DEFAULT_PROFILES_CONFIG = {
+	activeProfile: "cloud",
+	profiles: { cloud: DEFAULT_CLOUD_PROFILE }
+};
+
+//#endregion
+export { CLOUD_REMOTE, DEFAULT_CLOUD_PROFILE, DEFAULT_PROFILES_CONFIG, explicitRemoteSchema, profileNameSchema, profileSchema, profilesConfigSchema, remoteSchema };

package/dist/utils/project-directory.js

@@ -0,0 +1,33 @@
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { findUp } from "find-up";
+
+//#region src/utils/project-directory.ts
+/**
+* Find project directory by looking for inkeep.config.ts
+* @param projectId - Optional project ID or path to look for
+* @param configPath - Optional specific config file path to use
+* @returns Path to project directory or null if not found
+*/
+async function findProjectDirectory(projectId, configPath) {
+	if (configPath) {
+		const absoluteConfigPath = resolve(process.cwd(), configPath);
+		if (existsSync(absoluteConfigPath)) return resolve(absoluteConfigPath, "..");
+	}
+	if (projectId) {
+		if (projectId.includes("/") || projectId.includes("\\")) {
+			const projectPath = resolve(process.cwd(), projectId);
+			if (existsSync(join(projectPath, "inkeep.config.ts"))) return projectPath;
+		} else {
+			const projectPath = join(process.cwd(), projectId);
+			if (existsSync(join(projectPath, "inkeep.config.ts"))) return projectPath;
+		}
+		return null;
+	}
+	const foundConfigPath = await findUp("inkeep.config.ts");
+	if (foundConfigPath) return resolve(foundConfigPath, "..");
+	return null;
+}
+
+//#endregion
+export { findProjectDirectory };

package/dist/utils/project-loader.js

@@ -0,0 +1,29 @@
+import { importWithTypeScriptSupport } from "./tsx-loader.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/utils/project-loader.ts
+/**
+* Load and validate project from index.ts
+*
+* This utility is shared between push and pull commands to ensure
+* consistent project loading behavior across the CLI.
+*
+* @param projectDir - The directory containing the index.ts file
+* @returns The loaded Project instance
+* @throws Error if index.ts not found or no valid project export found
+*/
+async function loadProject(projectDir) {
+	const indexPath = join(projectDir, "index.ts");
+	if (!existsSync(indexPath)) throw new Error(`index.ts not found in project directory: ${projectDir}`);
+	const module = await importWithTypeScriptSupport(indexPath);
+	const exports = Object.keys(module);
+	for (const exportKey of exports) {
+		const value = module[exportKey];
+		if (value && typeof value === "object" && value.__type === "project") return value;
+	}
+	throw new Error("No project export found in index.ts. Expected an export with __type = \"project\"");
+}
+
+//#endregion
+export { loadProject };

package/dist/utils/schema-introspection.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+
+//#region src/utils/schema-introspection.ts
+/**
+* Schema Introspection Utilities
+*
+* Utilities to extract required fields and other metadata from Zod schemas.
+* This ensures CLI generators stay in sync with the actual validation schemas.
+*/
+/**
+* Simple utility to get required fields by attempting validation with empty object
+* and analyzing which fields are reported as missing
+*/
+function getRequiredFieldsFromValidation(schema) {
+	try {
+		schema.parse({});
+		return [];
+	} catch (error) {
+		if (error instanceof z.ZodError) return error.issues.filter((err) => err.code === "invalid_type" && err.expected !== "undefined").map((err) => err.path[0]).filter((field) => typeof field === "string").filter((field, index, arr) => arr.indexOf(field) === index);
+		return [];
+	}
+}
+/**
+* Extract required field names from a Zod object schema
+*/
+function getRequiredFields(schema) {
+	return getRequiredFieldsFromValidation(schema);
+}
+/**
+* Get a human-readable summary of schema requirements
+*/
+function getSchemaInfo(schema) {
+	const requiredFields = getRequiredFields(schema);
+	let allFields = [];
+	if ("shape" in schema && schema.shape) allFields = Object.keys(schema.shape);
+	return {
+		requiredFields,
+		optionalFields: allFields.filter((field) => !requiredFields.includes(field)),
+		allFields
+	};
+}
+
+//#endregion
+export { getRequiredFields, getSchemaInfo };

package/dist/utils/templates.js

@@ -0,0 +1,198 @@
+import { getLogger } from "@inkeep/agents-core";
+import path from "node:path";
+import fs from "fs-extra";
+import degit from "degit";
+
+//#region src/utils/templates.ts
+getLogger("templates");
+async function cloneTemplate(templatePath, targetPath, replacements) {
+	await fs.mkdir(targetPath, { recursive: true });
+	const emitter = degit(templatePath.replace("https://github.com/", ""));
+	try {
+		await emitter.clone(targetPath);
+		if (replacements && replacements.length > 0) await replaceContentInFiles(targetPath, replacements);
+	} catch (_error) {
+		console.log(`❌ Error cloning template: ${_error}`);
+		process.exit(1);
+	}
+}
+async function cloneTemplateLocal(templatePath, targetPath, replacements) {
+	await fs.mkdir(targetPath, { recursive: true });
+	try {
+		await fs.copy(templatePath, targetPath, {
+			overwrite: true,
+			errorOnExist: false
+		});
+		if (replacements && replacements.length > 0) await replaceContentInFiles(targetPath, replacements);
+	} catch (error) {
+		console.error(`Failed to clone template from ${templatePath}:`, error);
+		process.exit(1);
+	}
+}
+/**
+* Replace content in cloned template files
+*/
+async function replaceContentInFiles(targetPath, replacements) {
+	for (const replacement of replacements) {
+		const filePath = path.join(targetPath, replacement.filePath);
+		if (!await fs.pathExists(filePath)) {
+			console.warn(`Warning: File ${filePath} not found, skipping replacements`);
+			continue;
+		}
+		const updatedContent = await replaceObjectProperties(await fs.readFile(filePath, "utf-8"), replacement.replacements);
+		await fs.writeFile(filePath, updatedContent, "utf-8");
+	}
+}
+/**
+* Replace object properties in TypeScript code content
+*/
+async function replaceObjectProperties(content, replacements) {
+	let updatedContent = content;
+	for (const [propertyPath, replacement] of Object.entries(replacements)) updatedContent = replaceObjectProperty(updatedContent, propertyPath, replacement);
+	return updatedContent;
+}
+/**
+* Replace a specific object property in TypeScript code
+* This implementation uses line-by-line parsing for better accuracy
+* If the property doesn't exist, it will be added to the object
+*/
+function replaceObjectProperty(content, propertyPath, replacement) {
+	if (content.match(new RegExp(`^(.+{[^{}]*${propertyPath}\\s*:\\s*{[^{}]*}[^{}]*}.*)$`, "m"))) {
+		const singleLinePattern = /* @__PURE__ */ new RegExp(`((^|\\s|{)${propertyPath}\\s*:\\s*)({[^}]*})`);
+		return content.replace(singleLinePattern, `$1${JSON.stringify(replacement).replace(/"/g, "'").replace(/:/g, ": ").replace(/,/g, ", ")}`);
+	}
+	const replacementStr = JSON.stringify(replacement, null, 2).replace(/"/g, "'");
+	const lines = content.split("\n");
+	const result = [];
+	let inTargetProperty = false;
+	let braceCount = 0;
+	let targetPropertyIndent = "";
+	let foundProperty = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const trimmedLine = line.trim();
+		if (inTargetProperty) {
+			for (const char of line) {
+				if (char === "{") braceCount++;
+				if (char === "}") braceCount--;
+			}
+			if (braceCount <= 0) {
+				const hasTrailingComma = line.includes(",") || i + 1 < lines.length && lines[i + 1].trim().startsWith("}") === false && lines[i + 1].trim() !== "";
+				const indentedReplacement = replacementStr.split("\n").map((replacementLine, index) => {
+					if (index === 0) return `${targetPropertyIndent}${propertyPath}: ${replacementLine}`;
+					return `${targetPropertyIndent}${replacementLine}`;
+				}).join("\n");
+				result.push(`${indentedReplacement}${hasTrailingComma ? "," : ""}`);
+				inTargetProperty = false;
+				foundProperty = true;
+				continue;
+			}
+			continue;
+		}
+		const propertyPattern = /* @__PURE__ */ new RegExp(`(^|\\s+)${propertyPath}\\s*:`);
+		if (trimmedLine.startsWith(`${propertyPath}:`) || propertyPattern.test(line)) {
+			inTargetProperty = true;
+			braceCount = 0;
+			if (line.includes(" = { ")) targetPropertyIndent = `${line.match(/^\s*/)?.[0] || ""}  `;
+			else {
+				const propertyMatch = line.match(/* @__PURE__ */ new RegExp(`(.*?)(^|\\s+)${propertyPath}\\s*:`));
+				targetPropertyIndent = propertyMatch ? propertyMatch[1] : line.match(/^\s*/)?.[0] || "";
+			}
+			for (const char of line) {
+				if (char === "{") braceCount++;
+				if (char === "}") braceCount--;
+			}
+			if (braceCount <= 0) {
+				const hasTrailingComma = line.includes(",");
+				const indentedReplacement = replacementStr.split("\n").map((replacementLine, index) => {
+					if (index === 0) return `${targetPropertyIndent}${propertyPath}: ${replacementLine}`;
+					return `${targetPropertyIndent}${replacementLine}`;
+				}).join("\n");
+				result.push(`${indentedReplacement}${hasTrailingComma ? "," : ""}`);
+				inTargetProperty = false;
+				foundProperty = true;
+				continue;
+			}
+			continue;
+		}
+		result.push(line);
+	}
+	if (!foundProperty) return injectPropertyIntoObject(result.join("\n"), propertyPath, replacement);
+	return result.join("\n");
+}
+/**
+* Inject a new property into a TypeScript object when the property doesn't exist
+*/
+function injectPropertyIntoObject(content, propertyPath, replacement) {
+	const replacementStr = JSON.stringify(replacement, null, 2).replace(/"/g, "'");
+	const lines = content.split("\n");
+	const result = [];
+	let foundObjectStart = false;
+	let objectDepth = 0;
+	let insertionPoint = -1;
+	let baseIndent = "";
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const trimmedLine = line.trim();
+		if (!foundObjectStart && (trimmedLine.includes("({") || trimmedLine.endsWith(" = {") || line.includes(" = { "))) {
+			foundObjectStart = true;
+			baseIndent = line.match(/^\s*/)?.[0] || "";
+			objectDepth = 0;
+			for (const char of line) {
+				if (char === "{") objectDepth++;
+				if (char === "}") objectDepth--;
+			}
+		} else if (foundObjectStart) {
+			for (const char of line) {
+				if (char === "{") objectDepth++;
+				if (char === "}") objectDepth--;
+			}
+			if (objectDepth === 0 && trimmedLine.startsWith("}")) {
+				insertionPoint = i;
+				break;
+			}
+		}
+	}
+	if (insertionPoint !== -1) {
+		const propertyIndent = `${baseIndent}  `;
+		let needsCommaPrefix = false;
+		if (insertionPoint > 0) {
+			const prevLine = lines[insertionPoint - 1].trim();
+			needsCommaPrefix = prevLine !== "" && !prevLine.endsWith(",") && !prevLine.startsWith("}");
+		}
+		const indentedReplacement = replacementStr.split("\n").map((replacementLine, index) => {
+			if (index === 0) return `${propertyIndent}${propertyPath}: ${replacementLine}`;
+			return `${propertyIndent}${replacementLine}`;
+		}).join("\n");
+		for (let i = 0; i < lines.length; i++) {
+			if (i === insertionPoint) result.push(indentedReplacement);
+			if (i === insertionPoint - 1 && needsCommaPrefix) result.push(`${lines[i]},`);
+			else result.push(lines[i]);
+		}
+		return result.join("\n");
+	}
+	console.warn(`Could not inject property "${propertyPath}" - no suitable object found in content`);
+	return content;
+}
+async function getAvailableTemplates(templatePath = "template-projects", local) {
+	if (local && local.length > 0) {
+		const fullTemplatePath = path.join(local, templatePath);
+		const items = await fs.readdir(fullTemplatePath);
+		const directories = [];
+		for (const item of items) if ((await fs.stat(path.join(fullTemplatePath, item))).isDirectory() && item !== "weather-project") directories.push(item);
+		return directories;
+	}
+	const response = await fetch(`https://api.github.com/repos/inkeep/agents/contents/agents-cookbook/${templatePath}`);
+	if (!response.ok) throw new Error(`Failed to fetch templates. Please check your internet connection and try again.`);
+	let contents;
+	try {
+		contents = await response.json();
+	} catch (error) {
+		throw new Error(`Failed to parse templates response. Please check your internet connection and try again. ${error}`);
+	}
+	if (!Array.isArray(contents)) throw new Error("Unexpected response format from templates. Please check your internet connection and try again");
+	return contents.filter((item) => item.type === "dir" && item.name !== "weather-project").map((item) => item.name);
+}
+
+//#endregion
+export { cloneTemplate, cloneTemplateLocal, getAvailableTemplates, replaceContentInFiles, replaceObjectProperties };

package/dist/utils/tsx-loader.js

@@ -0,0 +1,27 @@
+import { extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { register } from "tsx/esm/api";
+
+//#region src/utils/tsx-loader.ts
+/**
+* Dynamically imports a file with TypeScript support
+* Registers tsx loader for .ts files automatically
+*/
+async function importWithTypeScriptSupport(filePath) {
+	if (extname(filePath) === ".ts") try {
+		const unregister = register();
+		try {
+			return await import(pathToFileURL(filePath).href);
+		} finally {
+			unregister();
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		if (errorMessage.includes("Dynamic require") || errorMessage.includes("tsx") || errorMessage.includes("register")) throw new Error(`Failed to load TypeScript file ${filePath}. Make sure tsx is installed: ${errorMessage}`);
+		throw error;
+	}
+	return await import(pathToFileURL(filePath).href);
+}
+
+//#endregion
+export { importWithTypeScriptSupport };

package/dist/utils/url.js

@@ -0,0 +1,26 @@
+//#region src/utils/url.ts
+/**
+* Normalizes a base URL by removing trailing slashes and validating format
+* @param url The URL to normalize
+* @returns The normalized URL
+* @throws Error if URL is invalid
+*/
+function normalizeBaseUrl(url) {
+	const trimmedUrl = url.trim();
+	if (!trimmedUrl.match(/^https?:\/\//i)) throw new Error(`Invalid URL format: ${url}. Must start with http:// or https://`);
+	return trimmedUrl.replace(/\/+$/, "");
+}
+/**
+* Constructs an agent view URL for the management UI
+* @param manageUiUrl The base management UI URL
+* @param tenantId The tenant ID
+* @param projectId The project ID
+* @param agentId The agent ID
+* @returns The complete agent view URL
+*/
+function buildAgentViewUrl(manageUiUrl, tenantId, projectId, agentId) {
+	return `${normalizeBaseUrl(manageUiUrl || "http://localhost:3000")}/${tenantId}/projects/${projectId}/agents/${agentId}`;
+}
+
+//#endregion
+export { buildAgentViewUrl, normalizeBaseUrl };

package/dist/utils/version-check.js

@@ -0,0 +1,79 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/utils/version-check.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+* The default package name for version checks and updates
+*/
+const DEFAULT_PACKAGE_NAME = "@inkeep/agents-cli";
+/**
+* Get the current installed version from package.json
+*/
+function getCurrentVersion() {
+	let packageJsonPath = join(__dirname, "..", "package.json");
+	if (!existsSync(packageJsonPath)) packageJsonPath = join(__dirname, "..", "..", "package.json");
+	return JSON.parse(readFileSync(packageJsonPath, "utf-8")).version;
+}
+/**
+* Fetch the latest version from npm registry
+*/
+async function getLatestVersion(packageName = DEFAULT_PACKAGE_NAME) {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), 1e4);
+	try {
+		const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, { signal: controller.signal });
+		if (!response.ok) throw new Error(`Failed to fetch latest version: ${response.statusText}`);
+		return (await response.json()).version;
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") throw new Error("Unable to check for updates: Request timed out after 10 seconds");
+		throw new Error(`Unable to check for updates: ${error instanceof Error ? error.message : "Unknown error"}`);
+	} finally {
+		clearTimeout(timeoutId);
+	}
+}
+/**
+* Compare two semver versions
+* Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+*
+* Note: This is a simplified semver comparison that handles basic major.minor.patch versions.
+* It does NOT handle pre-release versions (e.g., 1.0.0-beta.1) or build metadata (e.g., 1.0.0+build.1).
+* Pre-release tags and build metadata will be stripped before comparison.
+*
+* For the Inkeep CLI use case, this is sufficient as we only publish stable releases.
+*/
+function compareVersions(v1, v2) {
+	const cleanV1 = v1.split("-")[0].split("+")[0];
+	const cleanV2 = v2.split("-")[0].split("+")[0];
+	const parts1 = cleanV1.split(".").map(Number);
+	const parts2 = cleanV2.split(".").map(Number);
+	for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+		const part1 = parts1[i] || 0;
+		const part2 = parts2[i] || 0;
+		if (part1 < part2) return -1;
+		if (part1 > part2) return 1;
+	}
+	return 0;
+}
+/**
+* Check if an update is available
+*/
+async function checkForUpdate() {
+	const current = getCurrentVersion();
+	const latest = await getLatestVersion();
+	return {
+		current,
+		latest,
+		needsUpdate: compareVersions(current, latest) < 0
+	};
+}
+/**
+* Get the changelog URL for the package
+*/
+function getChangelogUrl() {
+	return `https://github.com/inkeep/agents/blob/main/agents-cli/CHANGELOG.md`;
+}
+
+//#endregion
+export { DEFAULT_PACKAGE_NAME, checkForUpdate, compareVersions, getChangelogUrl, getCurrentVersion, getLatestVersion };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-cli",
-  "version": "0.39.4",
+  "version": "0.40.0",
   "description": "Inkeep CLI tool",
   "type": "module",
   "main": "./dist/index.js",
@@ -23,47 +23,31 @@
     "@ai-sdk/anthropic": "3.0.0-beta.66",
     "@ai-sdk/google": "3.0.0-beta.62",
     "@ai-sdk/openai": "3.0.0-beta.74",
-    "@babel/parser": "^7.23.0",
-    "@babel/types": "^7.23.0",
-    "@better-auth/sso": "^1.4.0",
     "@clack/prompts": "^0.11.0",
-    "@nangohq/node": "^0.69.14",
-    "@opentelemetry/api-logs": "^0.206.0",
-    "@opentelemetry/instrumentation": "^0.206.0",
-    "@opentelemetry/sdk-logs": "^0.206.0",
     "@vercel/otel": "^2.0.1",
     "ai": "6.0.0-beta.124",
-    "ast-types": "^0.14.2",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.3",
     "commander": "^14.0.0",
     "degit": "^2.8.4",
-    "destr": "^2.0.3",
     "dotenv": "^17.2.1",
-    "drizzle-orm": "^0.44.5",
     "find-up": "^7.0.0",
     "fs-extra": "^11.2.0",
     "json-schema-to-zod": "^2.6.1",
     "keytar": "^7.9.0",
     "langfuse-vercel": "^3.38.6",
-    "picocolors": "^1.1.1",
-    "pg": "^8.16.3",
-    "pino": "^9.11.0",
-    "recast": "^0.23.0",
-    "traverse": "^0.6.10",
     "ts-morph": "^26.0.0",
     "tsx": "^4.20.5",
     "open": "^10.2.0",
     "yaml": "^2.7.0",
-    "@inkeep/agents-core": "^0.39.4",
-    "@inkeep/agents-sdk": "^0.39.4"
+    "@inkeep/agents-core": "^0.40.0",
+    "@inkeep/agents-sdk": "^0.40.0"
   },
   "devDependencies": {
     "@types/degit": "^2.8.6",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.10.0",
     "@vitest/coverage-v8": "^3.2.4",
-    "pino-pretty": "^13.1.1",
     "tsdown": "^0.18.0",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4"
@@ -88,6 +72,7 @@
     "directory": "agents-cli"
   },
   "scripts": {
+    "knip": "knip --directory .. --workspace agents-cli --dependencies",
     "build": "tsdown",
     "cli": "node ./dist/index.js",
     "postinstall": "node scripts/ensure-keytar.mjs || true",

package/dist/component-parser.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { t as buildComponentRegistryFromParsing } from "./component-parser2.js";
-
-export { buildComponentRegistryFromParsing };

package/dist/component-updater.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { a as copyProjectToTemp, i as cleanupStaleComponents, o as updateModifiedComponents, r as checkAndPromptForStaleComponentCleanup } from "./index.js";
-
-export { updateModifiedComponents };

package/dist/config2.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { A as findConfigFile, F as validateConfiguration, M as loadConfig, N as loadConfigFromFile, P as maskSensitiveConfig, j as getConfigFileNames, k as findAllConfigFiles } from "./index.js";
-
-export { validateConfiguration };

package/dist/credential-stores.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { q as KeyChainStore } from "./index.js";
-
-export { KeyChainStore };

package/dist/environment-generator.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { _ as generateEnvironmentIndexFile, b as generateEnvironmentSettingsFile, g as generateEnvironmentIndexDefinition, h as generateEnvironmentFile, v as generateEnvironmentIndexImports, x as generateEnvironmentSettingsImports, y as generateEnvironmentSettingsDefinition } from "./index.js";
-
-export { generateEnvironmentIndexFile };

package/dist/nodefs.js

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-import { B as ur, G as u, L as C } from "./index.js";
-import * as s from "fs";
-import * as o from "path";
-
-//#region ../node_modules/.pnpm/@electric-sql+pglite@0.3.14/node_modules/@electric-sql/pglite/dist/fs/nodefs.js
-u();
-var m = class extends ur {
-	constructor(t) {
-		super(t), this.rootDir = o.resolve(t), s.existsSync(o.join(this.rootDir)) || s.mkdirSync(this.rootDir);
-	}
-	async init(t, e) {
-		return this.pg = t, { emscriptenOpts: {
-			...e,
-			preRun: [...e.preRun || [], (r) => {
-				let c = r.FS.filesystems.NODEFS;
-				r.FS.mkdir(C), r.FS.mount(c, { root: this.rootDir }, C);
-			}]
-		} };
-	}
-	async closeFs() {
-		this.pg.Module.FS.quit();
-	}
-};
-
-//#endregion
-export { m as NodeFS };