@kora-platform/cli 0.7.0-rc1 → 0.8.0-rc2

package/dist/session.d.ts

@@ -16,6 +16,7 @@ export interface CliSessionState {
         status: string;
     } | null;
     baseUrl: string;
+    defaultEnvironment?: string;
     refreshToken: string;
     refreshTokenExpiresAt: string;
     user: {

package/dist/transport.d.ts

@@ -10,6 +10,7 @@ export interface CliAuthSettings {
     oidcEnabled: boolean;
     selfServiceOrgCreationEnabled: boolean;
 }
+export type ApiErrorDetails = Record<string, unknown>;
 type RequestBody = unknown | ((session: CliSessionState) => unknown);
 type BytesRequest = {
     createMaxBytesError?: (input: {
@@ -20,11 +21,13 @@ type BytesRequest = {
     maxBytes?: number;
     method?: string;
     path: string;
+    rawBody?: Uint8Array;
     session: CliSessionState | null;
     validateHeaders?: (headers: Headers) => void;
 };
 export declare class ApiError extends Error {
     readonly detail: string;
+    readonly details?: ApiErrorDetails;
     readonly instance: string;
     readonly rawDetail?: string;
     readonly status: number;
@@ -32,6 +35,7 @@ export declare class ApiError extends Error {
     readonly type: string;
     constructor(input: {
         detail: string;
+        details?: ApiErrorDetails;
         instance: string;
         rawDetail?: string;
         status: number;
@@ -49,6 +53,12 @@ export declare function createPlatformTransport(input: {
         email: string;
         password: string;
     }): Promise<CliSessionState>;
+    signup(credentials: {
+        baseUrl: string;
+        email: string;
+        name: string;
+        password: string;
+    }): Promise<CliSessionState>;
     refreshSession(session: CliSessionState): Promise<CliSessionState>;
     requestJson<T>(request: {
         body?: RequestBody;

package/dist/transport.js

@@ -1,6 +1,7 @@
 import { extractRefreshTokenFromHeaders } from "./session.js";
 export class ApiError extends Error {
     detail;
+    details;
     instance;
     rawDetail;
     status;
@@ -10,6 +11,9 @@ export class ApiError extends Error {
         super(input.detail);
         this.name = "ApiError";
         this.detail = input.detail;
+        if (input.details) {
+            this.details = input.details;
+        }
         this.instance = input.instance;
         if (input.rawDetail !== undefined) {
             this.rawDetail = input.rawDetail;
@@ -45,6 +49,23 @@ export function createPlatformTransport(input) {
             await input.sessionStore.write(session);
             return session;
         },
+        async signup(credentials) {
+            const normalizedBaseUrl = normalizeBaseUrl(credentials.baseUrl);
+            const response = await fetch(joinBaseUrl(normalizedBaseUrl, "/api/v1/auth/signup"), {
+                body: JSON.stringify({
+                    email: credentials.email,
+                    name: credentials.name,
+                    password: credentials.password
+                }),
+                headers: {
+                    "content-type": "application/json"
+                },
+                method: "POST"
+            });
+            const session = await parseSessionResponse(response, normalizedBaseUrl, "/api/v1/auth/signup");
+            await input.sessionStore.write(session);
+            return session;
+        },
         async refreshSession(session) {
             const response = await fetch(joinBaseUrl(session.baseUrl, "/api/v1/auth/refresh"), {
                 body: JSON.stringify({
@@ -255,6 +276,7 @@ async function toApiError(response, path) {
         const detail = relabelBackendText(rawDetail || response.statusText);
         return new ApiError({
             detail,
+            ...(parsed?.error?.details ? { details: parsed.error.details } : {}),
             instance: path,
             ...(rawDetail ? { rawDetail } : {}),
             status: response.status,

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 export type CommandPagination = "none" | "limit" | "limit-offset" | "cursor";
-export type CommandLabel = "access" | "action" | "activity" | "admin" | "artifact" | "auth" | "chat" | "completion" | "credential" | "destructive" | "env" | "execution" | "help" | "integration" | "local" | "mcp" | "org" | "org-model" | "output" | "probe" | "publish" | "read" | "release" | "run" | "schema" | "secret" | "skill" | "status" | "task" | "workflow" | "write";
+export type CommandLabel = "access" | "action" | "activity" | "admin" | "artifact" | "audit" | "auth" | "chat" | "chat-execution" | "chat-read" | "chat-write" | "completion" | "credential" | "destructive" | "env" | "environment" | "execution" | "extension" | "help" | "local" | "org" | "org-model" | "output" | "probe" | "publish" | "read" | "release" | "deployment" | "run" | "schema" | "secret" | "status" | "task" | "workspace" | "workflow" | "write";
 export interface CommandArgDefinition {
     description: string;
     name: string;
@@ -9,6 +9,7 @@ export interface CommandFlagDefinition {
     acceptsValue: boolean;
     defaultValue?: boolean | number | string;
     description: string;
+    hiddenWhenCommandFiltered?: boolean;
     knownValues?: string[];
     name: string;
     repeatable?: boolean;

package/dist/workspace-source.d.ts

@@ -0,0 +1 @@
+export declare function shouldIgnoreWorkspacePath(pathValue: string): boolean;

package/dist/workspace-source.js

@@ -0,0 +1,13 @@
+const IGNORED_WORKSPACE_DIRECTORY_NAMES = new Set([
+    ".git",
+    ".kora",
+    "coverage",
+    "dist",
+    "node_modules"
+]);
+const IGNORED_WORKSPACE_FILE_NAMES = new Set([".DS_Store", "Thumbs.db"]);
+export function shouldIgnoreWorkspacePath(pathValue) {
+    const segments = pathValue.replace(/\\/gu, "/").split("/").filter((segment) => segment.length > 0);
+    return segments.some((segment) => IGNORED_WORKSPACE_DIRECTORY_NAMES.has(segment)) ||
+        IGNORED_WORKSPACE_FILE_NAMES.has(segments.at(-1) ?? "");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kora-platform/cli",
-  "version": "0.7.0-rc1",
+  "version": "0.8.0-rc2",
   "private": false,
   "type": "module",
   "main": "dist/library.js",
@@ -34,6 +34,7 @@
   "engines": {
     "node": ">=24.0.0"
   },
+  "dependencies": {},
   "scripts": {
     "build": "pnpm run clean && pnpm run generate:schema-registry && tsc -b tsconfig.build.json",
     "check:package": "pnpm run build && node ../../../scripts/check-cli-pack-output.mjs",

package/dist/integration-api-client.d.ts

@@ -1,29 +0,0 @@
-import type { ManagedIntegrationActionDescriptor, ManagedIntegrationActionInput, ManagedIntegrationActionResult, ManagedIntegrationConnectionSummary, ManagedIntegrationDiagnostic, ManagedIntegrationPromptGuidance, ManagedIntegrationSummary } from "./api-types.js";
-import type { CliSessionState } from "./transport.js";
-import { createPlatformTransport } from "./transport.js";
-export interface PlatformIntegrationApiClientInput {
-    sessionStore: Parameters<typeof createPlatformTransport>[0]["sessionStore"];
-}
-export declare function createPlatformIntegrationApiClient(input: PlatformIntegrationApiClientInput): {
-    listManagedIntegrations(session: CliSessionState, orgId: string): Promise<{
-        integrations: ManagedIntegrationSummary[];
-    }>;
-    listManagedIntegrationDiagnostics(session: CliSessionState, orgId: string): Promise<{
-        integrations: ManagedIntegrationDiagnostic[];
-    }>;
-    getManagedIntegration(session: CliSessionState, orgId: string, integrationId: string): Promise<{
-        integration: ManagedIntegrationSummary;
-    }>;
-    listManagedIntegrationConnections(session: CliSessionState, orgId: string, integrationId: string): Promise<{
-        connections: ManagedIntegrationConnectionSummary[];
-    }>;
-    listManagedIntegrationActions(session: CliSessionState, orgId: string, integrationId: string): Promise<{
-        actions: ManagedIntegrationActionDescriptor[];
-    }>;
-    executeManagedIntegrationAction(session: CliSessionState, orgId: string, integrationId: string, actionId: string, inputData: ManagedIntegrationActionInput): Promise<{
-        result: ManagedIntegrationActionResult;
-    }>;
-    listManagedIntegrationPromptGuidance(session: CliSessionState, orgId: string): Promise<{
-        guidance: ManagedIntegrationPromptGuidance[];
-    }>;
-};

package/dist/integration-api-client.js

@@ -1,50 +0,0 @@
-import { createPlatformTransport } from "./transport.js";
-export function createPlatformIntegrationApiClient(input) {
-    const transport = createPlatformTransport(input);
-    return {
-        async listManagedIntegrations(session, orgId) {
-            return transport.requestJson({
-                path: `/api/v1/orgs/${encodeURIComponent(orgId)}/integration-host/integrations`,
-                session
-            });
-        },
-        async listManagedIntegrationDiagnostics(session, orgId) {
-            return transport.requestJson({
-                path: `/api/v1/orgs/${encodeURIComponent(orgId)}/integration-host/integrations/diagnostics`,
-                session
-            });
-        },
-        async getManagedIntegration(session, orgId, integrationId) {
-            return transport.requestJson({
-                path: `/api/v1/orgs/${encodeURIComponent(orgId)}/integration-host/integrations/${encodeURIComponent(integrationId)}`,
-                session
-            });
-        },
-        async listManagedIntegrationConnections(session, orgId, integrationId) {
-            return transport.requestJson({
-                path: `/api/v1/orgs/${encodeURIComponent(orgId)}/integration-host/integrations/${encodeURIComponent(integrationId)}/connections`,
-                session
-            });
-        },
-        async listManagedIntegrationActions(session, orgId, integrationId) {
-            return transport.requestJson({
-                path: `/api/v1/orgs/${encodeURIComponent(orgId)}/integration-host/integrations/${encodeURIComponent(integrationId)}/actions`,
-                session
-            });
-        },
-        async executeManagedIntegrationAction(session, orgId, integrationId, actionId, inputData) {
-            return transport.requestJson({
-                body: inputData,
-                method: "POST",
-                path: `/api/v1/orgs/${encodeURIComponent(orgId)}/integration-host/integrations/${encodeURIComponent(integrationId)}/actions/${encodeURIComponent(actionId)}`,
-                session
-            });
-        },
-        async listManagedIntegrationPromptGuidance(session, orgId) {
-            return transport.requestJson({
-                path: `/api/v1/orgs/${encodeURIComponent(orgId)}/integration-host/prompt-guidance`,
-                session
-            });
-        }
-    };
-}

package/dist/integration-commands.js

@@ -1,208 +0,0 @@
-import { shouldAutoOpenBrowser, openBrowser } from "./browser.js";
-import { genericProblem, notFoundProblem, usageProblem } from "./cli-errors.js";
-import { readOptionalStringFlag } from "./command-flags.js";
-import { readJsonInputSpecifier } from "./files.js";
-import { renderPrettyJson, renderTable } from "./format.js";
-import { createPlatformIntegrationApiClient } from "./integration-api-client.js";
-import { isInteractive } from "./prompts.js";
-export async function executeIntegrations(parsed, context, api, resolveOrgScope) {
-    const { org, session } = await resolveOrgScope(parsed, context, api);
-    const integrationApi = createPlatformIntegrationApiClient({
-        sessionStore: context.sessionStore
-    });
-    switch (parsed.definition.id) {
-        case "integrations.list": {
-            const data = redactIntegrationCliOutput(await integrationApi.listManagedIntegrations(session, org.id));
-            return {
-                data,
-                human: renderTable(data.integrations, [
-                    { key: "id", label: "Integration" },
-                    { key: "displayName", label: "Name" },
-                    { key: "description", label: "Description" }
-                ]),
-                kind: "integrations_list",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        case "integrations.diagnostics": {
-            const data = redactIntegrationCliOutput(await integrationApi.listManagedIntegrationDiagnostics(session, org.id));
-            return {
-                data,
-                human: renderTable(data.integrations, [
-                    { key: "id", label: "Integration" },
-                    { key: "displayName", label: "Name" },
-                    { key: "status", label: "Status" },
-                    { key: "message", label: "Message" },
-                    { key: "missingConfigFields", label: "Missing config" },
-                    { key: "invalidConfigFields", label: "Invalid config" }
-                ]),
-                kind: "integrations_diagnostics",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        case "integrations.get": {
-            const data = redactIntegrationCliOutput(await integrationApi.getManagedIntegration(session, org.id, readRequiredArg(parsed, "integration-id")));
-            return {
-                data,
-                human: renderPrettyJson(data.integration),
-                kind: "integrations_get",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        case "integrations.actions": {
-            const data = redactIntegrationCliOutput(await integrationApi.listManagedIntegrationActions(session, org.id, readRequiredArg(parsed, "integration-id")));
-            return {
-                data,
-                human: renderTable(data.actions, [
-                    { key: "id", label: "Action" },
-                    { key: "label", label: "Label" },
-                    { key: "cliSafe", label: "CLI" },
-                    { key: "description", label: "Description" }
-                ]),
-                kind: "integrations_actions",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        case "integrations.connections": {
-            const data = redactIntegrationCliOutput(await integrationApi.listManagedIntegrationConnections(session, org.id, readRequiredArg(parsed, "integration-id")));
-            return {
-                data,
-                human: renderTable(data.connections, [
-                    { key: "connectionRef", label: "Connection" },
-                    { key: "displayName", label: "Name" },
-                    { key: "status", label: "Status" },
-                    { key: "labels", label: "Labels" }
-                ]),
-                kind: "integrations_connections",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        case "integrations.action": {
-            const integrationId = readRequiredArg(parsed, "integration-id");
-            const actionId = readRequiredArg(parsed, "action-id");
-            const actions = (await integrationApi.listManagedIntegrationActions(session, org.id, integrationId)).actions;
-            const action = requireFound(actions.find((entry) => entry.id === actionId) ?? null, `Integration action '${actionId}' was not found.`, parsed.definition.id);
-            if (!action.cliSafe) {
-                throw usageProblem(`Integration action '${actionId}' requires the Settings UI.`, parsed.definition.id);
-            }
-            const input = await buildIntegrationActionInput(parsed, context);
-            const data = redactIntegrationCliOutput(await integrationApi.executeManagedIntegrationAction(session, org.id, integrationId, actionId, input));
-            await handleIntegrationExternalUrls(data.result.effects, parsed, context);
-            return {
-                data,
-                human: renderIntegrationActionHuman(data.result),
-                kind: "integrations_action_execute",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        default:
-            throw genericProblem(`Unhandled integrations command ${parsed.definition.id}.`, parsed.definition.id);
-    }
-}
-async function buildIntegrationActionInput(parsed, context) {
-    const input = {};
-    const connectionRef = readOptionalStringFlag(parsed, "connection");
-    if (connectionRef) {
-        input.connectionRef = connectionRef;
-    }
-    const inputSpecifier = readOptionalStringFlag(parsed, "input");
-    if (inputSpecifier) {
-        const value = await readJsonInputSpecifier(inputSpecifier, context.stdin, parsed.definition.id);
-        if (!isManagedIntegrationJsonObject(value)) {
-            throw usageProblem("Integration action input must be a JSON object.", parsed.definition.id);
-        }
-        input.input = value;
-    }
-    return input;
-}
-async function handleIntegrationExternalUrls(effects, parsed, context) {
-    const externalUrls = effects.filter((effect) => effect.kind === "open_external_url");
-    if (externalUrls.length === 0) {
-        return;
-    }
-    const explicitOpen = parsed.flags.open === true;
-    const shouldOpen = shouldAutoOpenBrowser({
-        env: context.env,
-        explicitNoOpen: parsed.flags["no-open"] === true,
-        explicitOpen,
-        interactive: isInteractive(context),
-        openBrowserConfig: context.config.openBrowser
-    });
-    if (!shouldOpen) {
-        return;
-    }
-    for (const effect of externalUrls) {
-        const opened = await openBrowser(effect.url);
-        if (explicitOpen && !opened) {
-            throw genericProblem(`Could not open a browser automatically. Visit ${effect.url}`, parsed.definition.id);
-        }
-    }
-}
-function renderIntegrationActionHuman(result) {
-    const lines = [`Integration action ${result.actionId} completed.`];
-    for (const effect of result.effects) {
-        switch (effect.kind) {
-            case "user_message":
-                lines.push(effect.message);
-                break;
-            case "open_external_url":
-                lines.push(`${effect.label ?? "Open"}: ${effect.url}`);
-                break;
-            case "connection_ready":
-                lines.push(`Connection ready: ${effect.displayName} (${effect.connectionRef})`);
-                break;
-            case "terminal_failure":
-                lines.push(`Failure: ${effect.message}`);
-                break;
-            case "schedule_poll":
-                lines.push(`Polling scheduled in ${String(effect.intervalMs)}ms${effect.reason ? `: ${effect.reason}` : ""}.`);
-                break;
-            case "refresh_state":
-                lines.push(`State refresh requested${effect.reason ? `: ${effect.reason}` : ""}.`);
-                break;
-            default:
-                assertNever(effect);
-        }
-    }
-    return lines.join("\n");
-}
-function redactIntegrationCliOutput(value) {
-    return redactIntegrationCliValue(value, null);
-}
-function redactIntegrationCliValue(value, key) {
-    if (key !== null && isSecretLikeKey(key) && value !== null && value !== undefined) {
-        return "[redacted]";
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry) => redactIntegrationCliValue(entry, null));
-    }
-    if (typeof value === "object" && value !== null) {
-        return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [
-            entryKey,
-            redactIntegrationCliValue(entryValue, entryKey)
-        ]));
-    }
-    return value;
-}
-function isSecretLikeKey(key) {
-    return /(?:access|refresh)?token|secret|private[_-]?key|password|credential|authorization/i.test(key);
-}
-function isManagedIntegrationJsonObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readRequiredArg(parsed, name) {
-    const value = parsed.args[name];
-    if (!value) {
-        throw usageProblem(`Missing required argument <${name}>.`, parsed.definition.id);
-    }
-    return value;
-}
-function requireFound(value, detail, instance) {
-    if (value === null || value === undefined) {
-        throw notFoundProblem(detail, instance);
-    }
-    return value;
-}
-function assertNever(value) {
-    throw new Error(`Unhandled integration host effect: ${JSON.stringify(value)}`);
-}