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

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/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;

package/dist/transport.js

@@ -1,5 +1,7 @@
+import { normalizePublicErrorCode, readPublicErrorCodeFromType } from "./error-code.js";
 import { extractRefreshTokenFromHeaders } from "./session.js";
 export class ApiError extends Error {
+    code;
     detail;
     details;
     instance;
@@ -10,6 +12,7 @@ export class ApiError extends Error {
     constructor(input) {
         super(input.detail);
         this.name = "ApiError";
+        this.code = normalizePublicErrorCode(input.code ?? readPublicErrorCodeFromType(input.type));
         this.detail = input.detail;
         if (input.details) {
             this.details = input.details;
@@ -66,6 +69,52 @@ export function createPlatformTransport(input) {
             await input.sessionStore.write(session);
             return session;
         },
+        async startDeviceLogin(baseUrl) {
+            const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+            const path = "/api/v1/auth/device/start";
+            const response = await fetch(joinBaseUrl(normalizedBaseUrl, path), {
+                method: "POST"
+            });
+            return handleJsonResponse(response, path);
+        },
+        async claimDeviceLogin(claim) {
+            const normalizedBaseUrl = normalizeBaseUrl(claim.baseUrl);
+            const path = "/api/v1/auth/device/claim";
+            const response = await fetch(joinBaseUrl(normalizedBaseUrl, path), {
+                body: JSON.stringify({
+                    deviceCode: claim.deviceCode
+                }),
+                headers: {
+                    "content-type": "application/json"
+                },
+                method: "POST"
+            });
+            if (!response.ok) {
+                throw await toApiError(response, path);
+            }
+            const payload = await response.json();
+            if (payload.status !== "approved") {
+                return { status: payload.status };
+            }
+            if (!payload.tokens || !payload.user) {
+                throw new Error("Device login approval response did not include a session.");
+            }
+            const refreshToken = extractRefreshTokenFromHeaders(response.headers);
+            if (!refreshToken) {
+                throw new Error("Refresh token cookie was not returned by the Platform API.");
+            }
+            const session = {
+                accessToken: payload.tokens.accessToken,
+                accessTokenPayload: payload.tokens.accessTokenPayload,
+                activeOrg: null,
+                baseUrl: normalizedBaseUrl,
+                refreshToken,
+                refreshTokenExpiresAt: payload.tokens.refreshTokenExpiresAt,
+                user: payload.user
+            };
+            await input.sessionStore.write(session);
+            return { session, status: "approved" };
+        },
         async refreshSession(session) {
             const response = await fetch(joinBaseUrl(session.baseUrl, "/api/v1/auth/refresh"), {
                 body: JSON.stringify({
@@ -243,11 +292,12 @@ async function readResponseBytes(response, request) {
 }
 function createMaxBytesError(request, actualBytes, maxBytes) {
     return request.createMaxBytesError?.({ actualBytes, maxBytes }) ?? new ApiError({
+        code: "request/too_large",
         detail: `Response body is ${String(actualBytes)} bytes, which exceeds the limit of ${String(maxBytes)} bytes.`,
         instance: request.path,
         status: 413,
         title: "Payload Too Large",
-        type: "https://errors.kora.dev/request/too-large"
+        type: "https://errors.kora.dev/request/too_large"
     });
 }
 function concatBytes(chunks, totalBytes) {
@@ -271,10 +321,11 @@ async function toApiError(response, path) {
     if (contentType.includes("application/json")) {
         const rawBody = await response.text();
         const parsed = tryParseJsonErrorBody(rawBody);
-        const code = parsed?.error?.code ?? "internal/error";
+        const code = normalizePublicErrorCode(parsed?.error?.code ?? "internal/error");
         const rawDetail = (parsed?.error?.message ?? rawBody) || response.statusText;
         const detail = relabelBackendText(rawDetail || response.statusText);
         return new ApiError({
+            code,
             detail,
             ...(parsed?.error?.details ? { details: parsed.error.details } : {}),
             instance: path,
@@ -286,6 +337,7 @@ async function toApiError(response, path) {
     }
     const rawDetail = await response.text();
     return new ApiError({
+        code: "internal/error",
         detail: relabelBackendText(rawDetail),
         instance: path,
         ...(rawDetail ? { rawDetail } : {}),

package/package.json

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