@kora-platform/cli 0.8.0-rc2 → 0.8.0-rc6

package/dist/files.js

@@ -2,20 +2,43 @@ 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;
 const MAX_PACKAGE_FILE_BYTES = 2_000_000;
 const MAX_IMPORT_TOTAL_BYTES = 10_000_000;
-export async function readJsonInputSpecifier(specifier, stdin, instance) {
+export async function readJsonInputSpecifier(specifier, stdin, instance, options = {}) {
     if (specifier === "-") {
-        return readJsonObject(await readStream(stdin), instance);
+        return readJsonObject(await readStream(stdin), instance, {
+            source: "stdin",
+            ...options
+        });
     }
     if (!specifier.startsWith("@")) {
-        throw usageProblem("Structured JSON input must use @file.json or - for stdin.", instance);
+        throw usageProblem("Structured JSON input must use @file.json or - for stdin.", instance, {
+            ...(options.flag ? { flag: options.flag } : {})
+        });
+    }
+    const filePath = resolve(specifier.slice(1));
+    let source;
+    try {
+        source = await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const nativeCode = readNodeErrorCode(error);
+        if (nativeCode && isLocalPathReadErrorCode(nativeCode)) {
+            throw usageProblem(`Structured JSON input file ${filePath} could not be read: ${nativeCode}.`, instance, {
+                filePath,
+                ...(options.flag ? { flag: options.flag } : {}),
+                nativeCode
+            });
+        }
+        throw error;
     }
-    return readJsonObject(await readFile(specifier.slice(1), "utf8"), instance);
+    return readJsonObject(source, instance, {
+        filePath,
+        ...options
+    });
 }
 export async function readTextInputSpecifier(specifier, stdin, instance) {
     if (specifier === "-") {
@@ -36,12 +59,26 @@ export function isZipArchivePath(pathValue) {
     return extname(pathValue).toLowerCase() === ".zip";
 }
 export async function readArchiveBytes(pathValue, instance) {
+    const file = await readLocalFileBytes(pathValue, instance, {
+        regularFileMessage: "Archive path must be a regular .zip file, not a directory or symbolic link."
+    });
+    return file.bytes;
+}
+export async function readLocalFileBytes(pathValue, instance, options = {}) {
     const absolutePath = resolve(pathValue);
-    const pathStat = await lstat(absolutePath);
+    const pathStat = await readLocalPathStat(absolutePath, instance);
     if (pathStat.isSymbolicLink() || !pathStat.isFile()) {
-        throw usageProblem("Archive path must be a regular .zip file, not a directory or symbolic link.", instance);
+        throw usageProblem(options.regularFileMessage ?? "Path must be a regular file, not a directory or symbolic link.", instance);
+    }
+    try {
+        return {
+            absolutePath,
+            bytes: await readFile(absolutePath)
+        };
+    }
+    catch (error) {
+        throwLocalPathReadProblem(error, absolutePath, instance);
     }
-    return await readFile(absolutePath);
 }
 export async function readWorkspaceTestEntries(pathValue) {
     return await readUtf8Entries(pathValue, {
@@ -51,12 +88,16 @@ export async function readWorkspaceTestEntries(pathValue) {
 }
 async function readUtf8Entries(pathValue, options) {
     const absolutePath = resolve(pathValue);
-    const pathStat = await lstat(absolutePath);
+    const pathStat = await readLocalPathStat(absolutePath, options.instance);
     if (pathStat.isSymbolicLink()) {
         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);
@@ -148,7 +189,7 @@ export async function writePackageExport(outPath, envelope) {
 }
 export async function readPackageFileEntries(pathValue, instance) {
     const absolutePath = resolve(pathValue);
-    const pathStat = await lstat(absolutePath);
+    const pathStat = await readLocalPathStat(absolutePath, instance);
     if (pathStat.isSymbolicLink()) {
         throw usageProblem("Package path must be a regular file or directory, not a symbolic link.", instance);
     }
@@ -158,7 +199,9 @@ export async function readPackageFileEntries(pathValue, instance) {
             totalBytes: 0
         }, instance);
         return [{
-                contentBase64: (await readFile(absolutePath)).toString("base64"),
+                contentBase64: (await readLocalFileBytes(absolutePath, instance, {
+                    regularFileMessage: "Package path must be a regular file or directory, not a symbolic link."
+                })).bytes.toString("base64"),
                 path: basename(absolutePath)
             }];
     }
@@ -170,23 +213,24 @@ export async function readPackageFileEntries(pathValue, 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) {
+function readJsonObject(source, instance, options) {
     let parsed;
     try {
         parsed = JSON.parse(source);
     }
     catch {
-        throw usageProblem("Structured JSON input must be valid JSON.", instance);
+        const sourceLabel = "filePath" in options ? `file ${options.filePath}` : "from stdin";
+        throw usageProblem(`Structured JSON input ${sourceLabel} must be valid JSON.`, instance, {
+            ...("filePath" in options ? { filePath: options.filePath } : { source: options.source }),
+            ...(options.flag ? { flag: options.flag } : {})
+        });
     }
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw usageProblem("Structured JSON input must be a JSON object.", instance);
+        const sourceLabel = "filePath" in options ? `file ${options.filePath}` : "from stdin";
+        throw usageProblem(`Structured JSON input ${sourceLabel} must be a JSON object.`, instance, {
+            ...("filePath" in options ? { filePath: options.filePath } : { source: options.source }),
+            ...(options.flag ? { flag: options.flag } : {})
+        });
     }
     return parsed;
 }
@@ -203,7 +247,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()) {
@@ -236,10 +280,10 @@ async function walkPackageDirectory(root, current, entries, counters, instance)
         if (!child.isFile()) {
             continue;
         }
-        const childStat = await lstat(childPath);
+        const childStat = await readLocalPathStat(childPath, instance);
         assertPackageFileCanBeRead(childStat.size, relativePath, counters, instance);
         entries.push({
-            contentBase64: (await readFile(childPath)).toString("base64"),
+            contentBase64: (await readLocalFileBytes(childPath, instance)).bytes.toString("base64"),
             path: relativePath
         });
     }
@@ -247,6 +291,12 @@ async function walkPackageDirectory(root, current, entries, counters, instance)
 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);
@@ -287,7 +337,13 @@ async function readLimitedUtf8File(filePath, displayPath, counters, options) {
     if (counters.fileCount >= MAX_IMPORT_FILE_COUNT) {
         throw usageProblem(`Import has more than ${String(MAX_IMPORT_FILE_COUNT)} files.`, options.instance);
     }
-    const content = await readFile(filePath, "utf8");
+    let content;
+    try {
+        content = await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        throwLocalPathReadProblem(error, filePath, options.instance);
+    }
     const bytes = Buffer.byteLength(content, "utf8");
     if (bytes > options.maxFileBytes) {
         throw usageProblem(`Import file ${displayPath} exceeds the per-file byte limit.`, options.instance);
@@ -318,3 +374,35 @@ function isNodeErrorWithCode(error, code) {
         "code" in error &&
         error.code === code;
 }
+function readNodeErrorCode(error) {
+    if (typeof error !== "object" || error === null || !("code" in error)) {
+        return undefined;
+    }
+    const code = error.code;
+    return typeof code === "string" && code.length > 0 ? code : undefined;
+}
+function isLocalPathReadErrorCode(code) {
+    return code === "EACCES" ||
+        code === "EISDIR" ||
+        code === "ENOENT" ||
+        code === "ENOTDIR" ||
+        code === "EPERM";
+}
+async function readLocalPathStat(absolutePath, instance) {
+    try {
+        return await lstat(absolutePath);
+    }
+    catch (error) {
+        throwLocalPathReadProblem(error, absolutePath, instance);
+    }
+}
+function throwLocalPathReadProblem(error, absolutePath, instance) {
+    const nativeCode = readNodeErrorCode(error);
+    if (nativeCode && isLocalPathReadErrorCode(nativeCode)) {
+        throw usageProblem(`Local path ${absolutePath} could not be read: ${nativeCode}.`, instance, {
+            nativeCode,
+            path: absolutePath
+        });
+    }
+    throw error;
+}

package/dist/format.d.ts

@@ -10,6 +10,7 @@ export declare function renderJsonEnvelope(input: {
     meta?: Record<string, unknown>;
 }): string;
 export declare function renderProblemJson(input: {
+    code: string;
     detail: string;
     details?: Record<string, unknown>;
     instance: string;

package/dist/format.js

@@ -7,12 +7,17 @@ export function renderJsonEnvelope(input) {
 }
 export function renderProblemJson(input) {
     return `${JSON.stringify({
-        detail: input.detail,
-        ...(input.details ? { details: input.details } : {}),
-        instance: input.instance,
-        status: input.status,
-        title: input.title,
-        type: input.type
+        error: {
+            code: input.code,
+            details: {
+                ...(input.details ?? {}),
+                instance: input.instance,
+                status: input.status,
+                title: input.title,
+                type: input.type
+            },
+            message: input.detail
+        }
     }, null, 2)}\n`;
 }
 export function renderTable(rows, columns) {

package/dist/runner.js

@@ -89,6 +89,7 @@ export async function runCli(argv, input = {}) {
                     : `${problem.title}: ${formatProblemDetail(problem.detail, details)}`}\n`,
             stdout: wantsJson
                 ? renderProblemJson({
+                    code: problem.code,
                     detail: problem.detail,
                     ...(details ? { details } : {}),
                     instance: problem.instance,

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/dist/transport.d.ts

@@ -10,6 +10,19 @@ export interface CliAuthSettings {
     oidcEnabled: boolean;
     selfServiceOrgCreationEnabled: boolean;
 }
+export interface CliDeviceLoginStart {
+    deviceCode: string;
+    expiresAt: string;
+    pollIntervalSeconds: number;
+    userCode: string;
+    verificationPath: string;
+}
+export type CliDeviceLoginClaim = {
+    session: CliSessionState;
+    status: "approved";
+} | {
+    status: "denied" | "expired" | "pending";
+};
 export type ApiErrorDetails = Record<string, unknown>;
 type RequestBody = unknown | ((session: CliSessionState) => unknown);
 type BytesRequest = {
@@ -26,6 +39,7 @@ type BytesRequest = {
     validateHeaders?: (headers: Headers) => void;
 };
 export declare class ApiError extends Error {
+    readonly code: string;
     readonly detail: string;
     readonly details?: ApiErrorDetails;
     readonly instance: string;
@@ -34,6 +48,7 @@ export declare class ApiError extends Error {
     readonly title: string;
     readonly type: string;
     constructor(input: {
+        code?: string;
         detail: string;
         details?: ApiErrorDetails;
         instance: string;
@@ -59,6 +74,11 @@ export declare function createPlatformTransport(input: {
         name: string;
         password: string;
     }): Promise<CliSessionState>;
+    startDeviceLogin(baseUrl: string): Promise<CliDeviceLoginStart>;
+    claimDeviceLogin(claim: {
+        baseUrl: string;
+        deviceCode: string;
+    }): Promise<CliDeviceLoginClaim>;
     refreshSession(session: CliSessionState): Promise<CliSessionState>;
     requestJson<T>(request: {
         body?: RequestBody;