@kora-platform/cli 0.8.0-rc1 → 0.8.0-rc3

package/dist/api-client.d.ts

@@ -84,14 +84,6 @@ export declare function createPlatformApiClient(input: PlatformApiClientInput):
     }): Promise<{
         variables: RuntimeVariableRecord[];
     }>;
-    importRuntimeVariables(session: CliSessionState, orgId: string, inputData: {
-        content: string;
-        environment: string;
-        fileName?: string | null;
-    }): Promise<{
-        importedCount: number;
-        variables: RuntimeVariableRecord[];
-    }>;
     listOrgSecrets(session: CliSessionState, orgId: string, inputData?: {
         environment?: string;
     }): Promise<{

package/dist/api-client.js

@@ -96,15 +96,6 @@ export function createPlatformApiClient(input) {
                 session
             });
         },
-        async importRuntimeVariables(session, orgId, inputData) {
-            const { environment, ...body } = inputData;
-            return transport.requestJson({
-                body,
-                method: "POST",
-                path: withQuery(`/api/v1/orgs/${encodeURIComponent(orgId)}/runtime-variables/import`, { environment }),
-                session
-            });
-        },
         async listOrgSecrets(session, orgId, inputData = {}) {
             return transport.requestJson({
                 path: withQuery(`/api/v1/orgs/${encodeURIComponent(orgId)}/secrets`, inputData),

package/dist/command-registry.js

@@ -870,7 +870,7 @@ const RAW_CLI_COMMANDS = [
         requiresActiveOrg: true
     }),
     command(["extensions", "validate"], "Validate an extension package directory or archive-expanded root.", {
-        labels: ["read", "extension"],
+        labels: ["read", "chat-read", "extension"],
         args: [arg("path", "Path to an extension package directory.")],
         flags: [
             flag("subdir", "Validate a subdirectory from a zip archive.", {
@@ -913,7 +913,7 @@ const RAW_CLI_COMMANDS = [
         requiresActiveOrg: true
     }),
     command(["extensions", "publish"], "Publish a validated extension package revision.", {
-        labels: ["write", "extension"],
+        labels: ["write", "chat-write", "extension"],
         args: [arg("path", "Path to an extension package directory.")],
         flags: [
             flag("subdir", "Publish a subdirectory from a zip archive.", {
@@ -1119,16 +1119,6 @@ const RAW_CLI_COMMANDS = [
         ],
         requiresActiveOrg: true
     }),
-    command(["env", "import"], "Import runtime variables from a .env file.", {
-        labels: ["write", "env"],
-        args: [arg("path-to-.env", "Path to a .env file.")],
-        flags: [flag("environment", "Target environment.", {
-                acceptsValue: true,
-                required: true,
-                valueType: "string"
-            })],
-        requiresActiveOrg: true
-    }),
     command(["secrets", "list"], "List organization secret names without values.", {
         labels: ["read", "secret"],
         flags: [flag("environment", "Target environment.", {

package/dist/commands.js

@@ -6,7 +6,7 @@ import { authProblem, genericProblem, notFoundProblem, usageProblem } from "./cl
 import { readOptionalNumberFlag, readOptionalStringFlag, readRequiredStringFlag } from "./command-flags.js";
 import { executeArtifactDownload, executeArtifactArchive, executeArtifactInspect, executeArtifactInventory, executeArtifactList, executeArtifactPurge, executeArtifactRead, executeArtifactRestore, executeArtifactUpload } from "./artifact-commands.js";
 import { executeAudit } from "./audit-commands.js";
-import { isZipArchivePath, readArchiveBytes, readImportEntries, readJsonInputSpecifier, readWorkspaceTestEntries, readTextInputSpecifier, parseEnvFile, writeReleaseSourceFiles } from "./files.js";
+import { isZipArchivePath, readArchiveBytes, readImportEntries, readJsonInputSpecifier, readWorkspaceTestEntries, readTextInputSpecifier, writeReleaseSourceFiles } from "./files.js";
 import { renderDiffSummary, renderKeyValue, renderPrettyJson, renderSuccess, renderTable } from "./format.js";
 import { buildTaskDetailPresentation } from "./task-detail.js";
 import { confirmDestructive } from "./interaction.js";
@@ -165,7 +165,6 @@ export async function executeParsedCommand(parsed, context) {
         case "env.list":
         case "env.get":
         case "env.replace":
-        case "env.import":
             return executeEnv(parsed, context, api);
         case "secrets.list":
         case "secrets.set":
@@ -1224,24 +1223,6 @@ async function executeEnv(parsed, context, api) {
                 meta: { command: parsed.definition.path.join(" "), environment, orgId: org.id }
             };
         }
-        case "env.import": {
-            const environment = readRequiredCliEnvironmentFlag(parsed);
-            const filePath = readRequiredArg(parsed, "path-to-.env");
-            const content = await readTextInputSpecifier(`@${filePath}`, context.stdin, parsed.definition.id);
-            const preview = await parseEnvFile(filePath);
-            announceResolvedEnvironment(parsed, context, environment);
-            const data = await api.importRuntimeVariables(session, org.id, {
-                content,
-                environment,
-                fileName: filePath
-            });
-            return {
-                data,
-                human: renderSuccess(`Imported ${data.importedCount} variables from ${filePath} into ${environment}. Parsed ${preview.length}.`),
-                kind: "authoring_env_import",
-                meta: { command: parsed.definition.path.join(" "), environment, orgId: org.id }
-            };
-        }
         default:
             throw genericProblem(`Unhandled env command ${parsed.definition.id}.`, parsed.definition.id);
     }

package/dist/extension-commands.js

@@ -54,7 +54,7 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
                 ? await api.validateExtensionPackageArchive(session, org.id, await readArchiveBytes(path, parsed.definition.id), {
                     ...(subdir ? { subdir } : {})
                 })
-                : await api.validateExtensionPackage(session, org.id, { files: await readPackageFileEntries(path) });
+                : await api.validateExtensionPackage(session, org.id, { files: await readPackageFileEntries(path, parsed.definition.id) });
             return {
                 data,
                 exitCode: data.ok ? 0 : 1,
@@ -70,7 +70,7 @@ export async function executeExtensions(parsed, context, api, resolveOrgScope) {
                 ? await api.publishExtensionPackageArchive(session, org.id, await readArchiveBytes(path, parsed.definition.id), {
                     ...(subdir ? { subdir } : {})
                 })
-                : await api.publishExtensionPackage(session, org.id, { files: await readPackageFileEntries(path) });
+                : await api.publishExtensionPackage(session, org.id, { files: await readPackageFileEntries(path, parsed.definition.id) });
             return {
                 data,
                 human: renderSuccess(`Published extension ${data.package.name} revision ${data.revision.id}.`),

package/dist/files.d.ts

@@ -34,11 +34,7 @@ export declare function writePackageExport(outPath: string, envelope: {
     }>;
     metadata: Record<string, unknown>;
 }): Promise<void>;
-export declare function readPackageFileEntries(pathValue: string): Promise<Array<{
+export declare function readPackageFileEntries(pathValue: string, instance: string): Promise<Array<{
     contentBase64: string;
     path: string;
 }>>;
-export declare function parseEnvFile(pathValue: string): Promise<Array<{
-    name: string;
-    value: string;
-}>>;

package/dist/files.js

@@ -2,7 +2,6 @@ import { Buffer } from "node:buffer";
 import { lstat, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { usageProblem } from "./cli-errors.js";
-import { parseDotEnv } from "./dotenv.js";
 import { shouldIgnoreWorkspacePath } from "./workspace-source.js";
 const MAX_IMPORT_FILE_COUNT = 500;
 const MAX_IMPORT_FILE_BYTES = 1_000_000;
@@ -56,7 +55,11 @@ async function readUtf8Entries(pathValue, options) {
         throw usageProblem("Import path must be a regular file or directory, not a symbolic link.", options.instance);
     }
     if (pathStat.isFile()) {
-        const content = await readLimitedUtf8File(absolutePath, basename(absolutePath), {
+        const pathName = basename(absolutePath);
+        if (shouldIgnoreSourceImportPath(pathName)) {
+            return [];
+        }
+        const content = await readLimitedUtf8File(absolutePath, pathName, {
             fileCount: 0,
             totalBytes: 0
         }, options);
@@ -146,17 +149,17 @@ export async function writePackageExport(outPath, envelope) {
     await mkdir(dirname(metadataPath), { recursive: true });
     await writeFile(metadataPath, `${JSON.stringify(envelope.metadata, null, 2)}\n`, "utf8");
 }
-export async function readPackageFileEntries(pathValue) {
+export async function readPackageFileEntries(pathValue, instance) {
     const absolutePath = resolve(pathValue);
     const pathStat = await lstat(absolutePath);
     if (pathStat.isSymbolicLink()) {
-        throw usageProblem("Package path must be a regular file or directory, not a symbolic link.", "extensions.publish");
+        throw usageProblem("Package path must be a regular file or directory, not a symbolic link.", instance);
     }
     if (pathStat.isFile()) {
         assertPackageFileCanBeRead(pathStat.size, basename(absolutePath), {
             fileCount: 0,
             totalBytes: 0
-        });
+        }, instance);
         return [{
                 contentBase64: (await readFile(absolutePath)).toString("base64"),
                 path: basename(absolutePath)
@@ -166,17 +169,10 @@ export async function readPackageFileEntries(pathValue) {
     await walkPackageDirectory(absolutePath, absolutePath, entries, {
         fileCount: 0,
         totalBytes: 0
-    });
+    }, instance);
     entries.sort((left, right) => left.path.localeCompare(right.path));
     return entries;
 }
-export async function parseEnvFile(pathValue) {
-    const content = await readFile(pathValue, "utf8");
-    return Object.entries(parseDotEnv(content)).map(([name, value]) => ({
-        name,
-        value
-    }));
-}
 function readJsonObject(source, instance) {
     let parsed;
     try {
@@ -203,7 +199,7 @@ async function walkImportDirectory(root, current, entries, counters, options) {
     for (const child of children) {
         const childPath = join(current, child.name);
         const relativePath = relative(root, childPath).replaceAll("\\", "/");
-        if (shouldIgnoreImportPath(relativePath)) {
+        if (shouldIgnoreSourceImportPath(relativePath)) {
             continue;
         }
         if (child.isDirectory()) {
@@ -220,7 +216,7 @@ async function walkImportDirectory(root, current, entries, counters, options) {
         });
     }
 }
-async function walkPackageDirectory(root, current, entries, counters) {
+async function walkPackageDirectory(root, current, entries, counters, instance) {
     const children = await readdir(current, { withFileTypes: true });
     children.sort((left, right) => left.name.localeCompare(right.name));
     for (const child of children) {
@@ -230,14 +226,14 @@ async function walkPackageDirectory(root, current, entries, counters) {
             continue;
         }
         if (child.isDirectory()) {
-            await walkPackageDirectory(root, childPath, entries, counters);
+            await walkPackageDirectory(root, childPath, entries, counters, instance);
             continue;
         }
         if (!child.isFile()) {
             continue;
         }
         const childStat = await lstat(childPath);
-        assertPackageFileCanBeRead(childStat.size, relativePath, counters);
+        assertPackageFileCanBeRead(childStat.size, relativePath, counters, instance);
         entries.push({
             contentBase64: (await readFile(childPath)).toString("base64"),
             path: relativePath
@@ -247,6 +243,12 @@ async function walkPackageDirectory(root, current, entries, counters) {
 function shouldIgnoreImportPath(pathValue) {
     return shouldIgnoreWorkspacePath(pathValue);
 }
+function shouldIgnoreSourceImportPath(pathValue) {
+    return shouldIgnoreImportPath(pathValue) || isRemovedRuntimeEnvironmentPath(pathValue);
+}
+function isRemovedRuntimeEnvironmentPath(pathValue) {
+    return pathValue === ".env" || pathValue === ".env.example";
+}
 async function assertExportOutputIsEmpty(absolutePath, instance, outputLabel = "Export") {
     try {
         const pathStat = await lstat(absolutePath);
@@ -299,15 +301,15 @@ async function readLimitedUtf8File(filePath, displayPath, counters, options) {
     counters.totalBytes += bytes;
     return { content };
 }
-function assertPackageFileCanBeRead(bytes, displayPath, counters) {
+function assertPackageFileCanBeRead(bytes, displayPath, counters, instance) {
     if (counters.fileCount >= MAX_IMPORT_FILE_COUNT) {
-        throw usageProblem(`Package has more than ${String(MAX_IMPORT_FILE_COUNT)} files.`, "extensions.publish");
+        throw usageProblem(`Package has more than ${String(MAX_IMPORT_FILE_COUNT)} files.`, instance);
     }
     if (bytes > MAX_PACKAGE_FILE_BYTES) {
-        throw usageProblem(`Package file ${displayPath} exceeds the per-file byte limit.`, "extensions.publish");
+        throw usageProblem(`Package file ${displayPath} exceeds the per-file byte limit.`, instance);
     }
     if (counters.totalBytes + bytes > MAX_IMPORT_TOTAL_BYTES) {
-        throw usageProblem(`Package exceeds the ${String(MAX_IMPORT_TOTAL_BYTES)} byte limit.`, "extensions.publish");
+        throw usageProblem(`Package exceeds the ${String(MAX_IMPORT_TOTAL_BYTES)} byte limit.`, instance);
     }
     counters.fileCount += 1;
     counters.totalBytes += bytes;

package/dist/schema-registry-data.d.ts

@@ -2943,14 +2943,6 @@ export declare const CLI_SCHEMA_REGISTRY_DATA: readonly [{
                                 readonly maxLength: 4096;
                                 readonly type: "string";
                             };
-                            readonly env: {
-                                readonly type: "object";
-                                readonly patternProperties: {
-                                    readonly "^(.*)$": {
-                                        readonly type: "string";
-                                    };
-                                };
-                            };
                             readonly parseStdoutAsJson: {
                                 readonly type: "boolean";
                             };
@@ -2964,39 +2956,91 @@ export declare const CLI_SCHEMA_REGISTRY_DATA: readonly [{
                             };
                         };
                     };
-                    readonly runtimeSdk: {
-                        readonly additionalProperties: true;
-                        readonly type: "object";
-                        readonly properties: {};
-                    };
-                    readonly credentials: {
+                    readonly bindings: {
+                        readonly additionalProperties: false;
                         readonly type: "object";
-                        readonly patternProperties: {
-                            readonly "^(.*)$": {
-                                readonly additionalProperties: false;
-                                readonly type: "object";
-                                readonly required: readonly ["bindingKind", "connectionRef", "inject"];
-                                readonly properties: {
-                                    readonly bindingKind: {
+                        readonly properties: {
+                            readonly env: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly anyOf: readonly [{
                                         readonly minLength: 1;
                                         readonly maxLength: 128;
+                                        readonly pattern: "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$";
                                         readonly type: "string";
-                                    };
-                                    readonly connectionRef: {
+                                    }, {
+                                        readonly additionalProperties: false;
+                                        readonly type: "object";
+                                        readonly required: readonly ["name"];
+                                        readonly properties: {
+                                            readonly name: {
+                                                readonly minLength: 1;
+                                                readonly maxLength: 128;
+                                                readonly pattern: "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$";
+                                                readonly type: "string";
+                                            };
+                                            readonly as: {
+                                                readonly minLength: 1;
+                                                readonly maxLength: 128;
+                                                readonly pattern: "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$";
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    }];
+                                };
+                            };
+                            readonly secrets: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly anyOf: readonly [{
                                         readonly minLength: 1;
                                         readonly maxLength: 128;
+                                        readonly pattern: "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$";
                                         readonly type: "string";
-                                    };
-                                    readonly inject: {
+                                    }, {
                                         readonly additionalProperties: false;
                                         readonly type: "object";
-                                        readonly required: readonly ["env"];
+                                        readonly required: readonly ["name"];
                                         readonly properties: {
-                                            readonly env: {
+                                            readonly name: {
                                                 readonly minLength: 1;
                                                 readonly maxLength: 128;
+                                                readonly pattern: "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$";
                                                 readonly type: "string";
                                             };
+                                            readonly as: {
+                                                readonly minLength: 1;
+                                                readonly maxLength: 128;
+                                                readonly pattern: "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$";
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    }];
+                                };
+                            };
+                            readonly extensions: {
+                                readonly type: "object";
+                                readonly patternProperties: {
+                                    readonly "^(.*)$": {
+                                        readonly additionalProperties: false;
+                                        readonly type: "object";
+                                        readonly required: readonly ["install", "functions"];
+                                        readonly properties: {
+                                            readonly install: {
+                                                readonly minLength: 1;
+                                                readonly maxLength: 128;
+                                                readonly type: "string";
+                                            };
+                                            readonly functions: {
+                                                readonly minItems: 1;
+                                                readonly uniqueItems: true;
+                                                readonly type: "array";
+                                                readonly items: {
+                                                    readonly minLength: 1;
+                                                    readonly maxLength: 128;
+                                                    readonly type: "string";
+                                                };
+                                            };
                                         };
                                     };
                                 };

package/dist/schema-registry-data.js

@@ -3486,14 +3486,6 @@ export const CLI_SCHEMA_REGISTRY_DATA = [
                                     "maxLength": 4096,
                                     "type": "string"
                                 },
-                                "env": {
-                                    "type": "object",
-                                    "patternProperties": {
-                                        "^(.*)$": {
-                                            "type": "string"
-                                        }
-                                    }
-                                },
                                 "parseStdoutAsJson": {
                                     "type": "boolean"
                                 },
@@ -3507,44 +3499,103 @@ export const CLI_SCHEMA_REGISTRY_DATA = [
                                 }
                             }
                         },
-                        "runtimeSdk": {
-                            "additionalProperties": true,
-                            "type": "object",
-                            "properties": {}
-                        },
-                        "credentials": {
+                        "bindings": {
+                            "additionalProperties": false,
                             "type": "object",
-                            "patternProperties": {
-                                "^(.*)$": {
-                                    "additionalProperties": false,
+                            "properties": {
+                                "env": {
+                                    "type": "array",
+                                    "items": {
+                                        "anyOf": [
+                                            {
+                                                "minLength": 1,
+                                                "maxLength": 128,
+                                                "pattern": "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$",
+                                                "type": "string"
+                                            },
+                                            {
+                                                "additionalProperties": false,
+                                                "type": "object",
+                                                "required": [
+                                                    "name"
+                                                ],
+                                                "properties": {
+                                                    "name": {
+                                                        "minLength": 1,
+                                                        "maxLength": 128,
+                                                        "pattern": "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$",
+                                                        "type": "string"
+                                                    },
+                                                    "as": {
+                                                        "minLength": 1,
+                                                        "maxLength": 128,
+                                                        "pattern": "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$",
+                                                        "type": "string"
+                                                    }
+                                                }
+                                            }
+                                        ]
+                                    }
+                                },
+                                "secrets": {
+                                    "type": "array",
+                                    "items": {
+                                        "anyOf": [
+                                            {
+                                                "minLength": 1,
+                                                "maxLength": 128,
+                                                "pattern": "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$",
+                                                "type": "string"
+                                            },
+                                            {
+                                                "additionalProperties": false,
+                                                "type": "object",
+                                                "required": [
+                                                    "name"
+                                                ],
+                                                "properties": {
+                                                    "name": {
+                                                        "minLength": 1,
+                                                        "maxLength": 128,
+                                                        "pattern": "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$",
+                                                        "type": "string"
+                                                    },
+                                                    "as": {
+                                                        "minLength": 1,
+                                                        "maxLength": 128,
+                                                        "pattern": "^(?!KORA_)[A-Za-z_][A-Za-z0-9_]*$",
+                                                        "type": "string"
+                                                    }
+                                                }
+                                            }
+                                        ]
+                                    }
+                                },
+                                "extensions": {
                                     "type": "object",
-                                    "required": [
-                                        "bindingKind",
-                                        "connectionRef",
-                                        "inject"
-                                    ],
-                                    "properties": {
-                                        "bindingKind": {
-                                            "minLength": 1,
-                                            "maxLength": 128,
-                                            "type": "string"
-                                        },
-                                        "connectionRef": {
-                                            "minLength": 1,
-                                            "maxLength": 128,
-                                            "type": "string"
-                                        },
-                                        "inject": {
+                                    "patternProperties": {
+                                        "^(.*)$": {
                                             "additionalProperties": false,
                                             "type": "object",
                                             "required": [
-                                                "env"
+                                                "install",
+                                                "functions"
                                             ],
                                             "properties": {
-                                                "env": {
+                                                "install": {
                                                     "minLength": 1,
                                                     "maxLength": 128,
                                                     "type": "string"
+                                                },
+                                                "functions": {
+                                                    "minItems": 1,
+                                                    "uniqueItems": true,
+                                                    "type": "array",
+                                                    "items": {
+                                                        "minLength": 1,
+                                                        "maxLength": 128,
+                                                        "type": "string"
+                                                    }
                                                 }
                                             }
                                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kora-platform/cli",
-  "version": "0.8.0-rc1",
+  "version": "0.8.0-rc3",
   "private": false,
   "type": "module",
   "main": "dist/library.js",

package/dist/dotenv.d.ts

@@ -1 +0,0 @@
-export declare function parseDotEnv(source: string): Record<string, string>;

package/dist/dotenv.js

@@ -1,26 +0,0 @@
-const ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/u;
-export function parseDotEnv(source) {
-    const parsed = {};
-    const lines = source.split(/\r?\n/u);
-    for (const rawLine of lines) {
-        const line = rawLine.trim();
-        if (line.length === 0 || line.startsWith("#")) {
-            continue;
-        }
-        const separatorIndex = line.indexOf("=");
-        if (separatorIndex <= 0) {
-            continue;
-        }
-        const rawName = line.slice(0, separatorIndex).trim();
-        if (!ENV_NAME_PATTERN.test(rawName)) {
-            continue;
-        }
-        let value = line.slice(separatorIndex + 1).trim();
-        if ((value.startsWith("\"") && value.endsWith("\"")) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        parsed[rawName] = value;
-    }
-    return parsed;
-}