@apso/cli 0.7.4 → 0.8.2

package/dist/lib/api/client.js

@@ -0,0 +1,305 @@
+"use strict";
+/**
+ * Platform API Client
+ *
+ * HTTP client for making authenticated requests to the Apso platform.
+ * Features:
+ * - Automatic token refresh
+ * - Request/response interceptors
+ * - Retry with exponential backoff
+ * - Timeout handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = exports.apiRequest = exports.checkNetworkConnectivity = exports.ApiClientError = void 0;
+const config_1 = require("../config");
+/**
+ * Default request timeout in milliseconds
+ */
+const DEFAULT_TIMEOUT = 30000;
+/**
+ * Maximum retry attempts for failed requests
+ */
+const MAX_RETRIES = 3;
+/**
+ * Base delay for exponential backoff in milliseconds
+ */
+const BACKOFF_BASE_DELAY = 1000;
+/**
+ * Custom error class for API errors
+ */
+class ApiClientError extends Error {
+    constructor(message, statusCode, details) {
+        super(message);
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = "ApiClientError";
+    }
+    /**
+     * Check if error is due to authentication failure
+     */
+    isAuthError() {
+        return this.statusCode === 401;
+    }
+    /**
+     * Check if error is a rate limit error
+     */
+    isRateLimitError() {
+        return this.statusCode === 429;
+    }
+    /**
+     * Check if error is a server error (5xx)
+     */
+    isServerError() {
+        return this.statusCode >= 500 && this.statusCode < 600;
+    }
+}
+exports.ApiClientError = ApiClientError;
+/**
+ * Check if we're running in an environment with network access
+ */
+async function checkNetworkConnectivity() {
+    try {
+        const config = config_1.globalConfig.read();
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 5000);
+        const response = await fetch(`${config.apiUrl}/health`, {
+            method: "HEAD",
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+exports.checkNetworkConnectivity = checkNetworkConnectivity;
+/**
+ * Sleep for a given number of milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+/**
+ * Calculate backoff delay with jitter
+ */
+function getBackoffDelay(attempt) {
+    const delay = BACKOFF_BASE_DELAY * 2 ** attempt;
+    const jitter = Math.random() * 0.3 * delay;
+    return delay + jitter;
+}
+/**
+ * Build URL with query parameters
+ */
+function buildUrl(baseUrl, path, params) {
+    const url = new URL(path, baseUrl);
+    if (params) {
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined) {
+                url.searchParams.append(key, String(value));
+            }
+        });
+    }
+    return url.toString();
+}
+/**
+ * Refresh the access token using the refresh token
+ */
+async function refreshAccessToken() {
+    const creds = config_1.credentials.read();
+    if (!creds) {
+        return false;
+    }
+    try {
+        const config = config_1.globalConfig.read();
+        const response = await fetch(`${config.apiUrl}/auth/cli/refresh`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                refreshToken: creds.tokens.refreshToken,
+            }),
+        });
+        if (!response.ok) {
+            return false;
+        }
+        const data = (await response.json());
+        // Update stored credentials with new access token
+        config_1.credentials.write({
+            tokens: {
+                ...creds.tokens,
+                accessToken: data.accessToken,
+                expiresAt: new Date(Date.now() + data.expiresIn * 1000).toISOString(),
+            },
+            user: creds.user,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Make an authenticated request to the platform API
+ * Note: Sequential retries are intentional for proper backoff behavior
+ */
+/* eslint-disable no-await-in-loop */
+async function apiRequest(path, options = {}) {
+    const { method = "GET", body, params, headers = {}, timeout = DEFAULT_TIMEOUT, skipAuth = false, } = options;
+    const config = config_1.globalConfig.read();
+    const url = buildUrl(config.apiUrl, path, params);
+    // Build request headers
+    const requestHeaders = {
+        "Content-Type": "application/json",
+        "User-Agent": `apso-cli/${getCliVersion()}`,
+        ...headers,
+    };
+    // Add authentication if not skipped
+    if (!skipAuth) {
+        const creds = config_1.credentials.read();
+        if (!creds) {
+            throw new ApiClientError("Not authenticated. Run 'apso login' first.", 401);
+        }
+        // Check if token needs refresh
+        if (config_1.credentials.needsRefresh()) {
+            const refreshed = await refreshAccessToken();
+            if (!refreshed) {
+                throw new ApiClientError("Session expired. Please run 'apso login' again.", 401);
+            }
+        }
+        // Re-read credentials after potential refresh
+        const freshCreds = config_1.credentials.read();
+        if (freshCreds) {
+            requestHeaders.Authorization = `Bearer ${freshCreds.tokens.accessToken}`;
+        }
+    }
+    // Make request with retries
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            const response = await fetch(url, {
+                method,
+                headers: requestHeaders,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            // Handle response
+            if (response.ok) {
+                // Handle empty responses
+                const contentType = response.headers.get("content-type");
+                if ((contentType === null || contentType === void 0 ? void 0 : contentType.includes("application/json")) &&
+                    response.status !== 204) {
+                    return (await response.json());
+                }
+                return {};
+            }
+            // Parse error response
+            let errorData;
+            try {
+                errorData = await response.json();
+            }
+            catch {
+                errorData = {
+                    statusCode: response.status,
+                    message: response.statusText,
+                };
+            }
+            // Handle 401 - try refresh once
+            if (response.status === 401 && attempt === 0 && !skipAuth) {
+                const refreshed = await refreshAccessToken();
+                if (refreshed) {
+                    // Retry with new token
+                    continue;
+                }
+                throw new ApiClientError("Session expired. Please run 'apso login' again.", 401);
+            }
+            // Handle rate limiting
+            if (response.status === 429) {
+                const retryAfter = response.headers.get("retry-after");
+                const waitTime = retryAfter
+                    ? Number.parseInt(retryAfter, 10) * 1000
+                    : getBackoffDelay(attempt);
+                await sleep(waitTime);
+                continue;
+            }
+            // Handle server errors with retry
+            if (response.status >= 500) {
+                lastError = new ApiClientError(errorData.message || "Server error", response.status, errorData.details);
+                await sleep(getBackoffDelay(attempt));
+                continue;
+            }
+            // Client errors - don't retry
+            throw new ApiClientError(errorData.message || "Request failed", response.status, errorData.details);
+        }
+        catch (error) {
+            if (error instanceof ApiClientError) {
+                throw error;
+            }
+            // Handle abort/timeout
+            if (error instanceof Error && error.name === "AbortError") {
+                lastError = new ApiClientError("Request timeout", 408);
+                continue;
+            }
+            // Network errors
+            lastError = new ApiClientError(error instanceof Error ? error.message : "Network error", 0);
+            await sleep(getBackoffDelay(attempt));
+        }
+    }
+    throw lastError || new ApiClientError("Request failed after retries", 500);
+}
+exports.apiRequest = apiRequest;
+/* eslint-enable no-await-in-loop */
+/**
+ * Get CLI version for User-Agent header
+ */
+function getCliVersion() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pkg = require("../../../package.json");
+        return pkg.version;
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+/**
+ * Platform API client with typed methods
+ */
+exports.api = {
+    /**
+     * Make a GET request
+     */
+    get(path, options) {
+        return apiRequest(path, { ...options, method: "GET" });
+    },
+    /**
+     * Make a POST request
+     */
+    post(path, body, options) {
+        return apiRequest(path, { ...options, method: "POST", body });
+    },
+    /**
+     * Make a PUT request
+     */
+    put(path, body, options) {
+        return apiRequest(path, { ...options, method: "PUT", body });
+    },
+    /**
+     * Make a PATCH request
+     */
+    patch(path, body, options) {
+        return apiRequest(path, { ...options, method: "PATCH", body });
+    },
+    /**
+     * Make a DELETE request
+     */
+    delete(path, options) {
+        return apiRequest(path, { ...options, method: "DELETE" });
+    },
+};

package/dist/lib/api/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Platform API Module
+ *
+ * Exports API client, types, and service functions.
+ */
+export * from "./types";
+export { api, apiRequest, ApiClientError, checkNetworkConnectivity } from "./client";
+export { authApi, workspacesApi, servicesApi, schemaApi, buildApi, githubApi, } from "./services";

package/dist/lib/api/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Platform API Module
+ *
+ * Exports API client, types, and service functions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubApi = exports.buildApi = exports.schemaApi = exports.servicesApi = exports.workspacesApi = exports.authApi = exports.checkNetworkConnectivity = exports.ApiClientError = exports.apiRequest = exports.api = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types"), exports);
+var client_1 = require("./client");
+Object.defineProperty(exports, "api", { enumerable: true, get: function () { return client_1.api; } });
+Object.defineProperty(exports, "apiRequest", { enumerable: true, get: function () { return client_1.apiRequest; } });
+Object.defineProperty(exports, "ApiClientError", { enumerable: true, get: function () { return client_1.ApiClientError; } });
+Object.defineProperty(exports, "checkNetworkConnectivity", { enumerable: true, get: function () { return client_1.checkNetworkConnectivity; } });
+var services_1 = require("./services");
+Object.defineProperty(exports, "authApi", { enumerable: true, get: function () { return services_1.authApi; } });
+Object.defineProperty(exports, "workspacesApi", { enumerable: true, get: function () { return services_1.workspacesApi; } });
+Object.defineProperty(exports, "servicesApi", { enumerable: true, get: function () { return services_1.servicesApi; } });
+Object.defineProperty(exports, "schemaApi", { enumerable: true, get: function () { return services_1.schemaApi; } });
+Object.defineProperty(exports, "buildApi", { enumerable: true, get: function () { return services_1.buildApi; } });
+Object.defineProperty(exports, "githubApi", { enumerable: true, get: function () { return services_1.githubApi; } });

package/dist/lib/api/services.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Platform API Services
+ *
+ * Typed API methods for interacting with platform resources.
+ */
+import { UserProfile, Workspace, Service, ServiceSchema, GitHubRepo, GitHubConnection, BuildStatus, PaginatedResponse, TokenExchangeResponse } from "./types";
+/**
+ * Authentication API
+ */
+export declare const authApi: {
+    /**
+     * Exchange OAuth authorization code for tokens
+     */
+    exchangeCode(code: string): Promise<TokenExchangeResponse>;
+    /**
+     * Get current user profile
+     */
+    getProfile(): Promise<UserProfile>;
+    /**
+     * Revoke current session
+     */
+    logout(): Promise<void>;
+};
+/**
+ * Workspaces API
+ */
+export declare const workspacesApi: {
+    /**
+     * List all workspaces the user has access to
+     */
+    list(): Promise<Workspace[]>;
+    /**
+     * Get a specific workspace by slug
+     */
+    get(slug: string): Promise<Workspace>;
+    /**
+     * Get workspace by ID
+     */
+    getById(id: string): Promise<Workspace>;
+};
+/**
+ * Services API
+ */
+export declare const servicesApi: {
+    /**
+     * List all services in a workspace
+     */
+    list(workspaceSlug: string, options?: {
+        status?: string;
+        page?: number;
+        pageSize?: number;
+    }): Promise<PaginatedResponse<Service>>;
+    /**
+     * Get a specific service by slug
+     */
+    get(workspaceSlug: string, serviceSlug: string): Promise<Service>;
+    /**
+     * Get service by ID
+     */
+    getById(id: string): Promise<Service>;
+    /**
+     * Create a new service
+     */
+    create(workspaceSlug: string, data: {
+        name: string;
+        slug?: string;
+        description?: string;
+        githubRepo?: string;
+        githubBranch?: string;
+    }): Promise<Service>;
+    /**
+     * Update a service
+     */
+    update(workspaceSlug: string, serviceSlug: string, data: Partial<{
+        name: string;
+        description: string;
+        githubRepo: string;
+        githubBranch: string;
+    }>): Promise<Service>;
+    /**
+     * Delete a service
+     */
+    delete(workspaceSlug: string, serviceSlug: string): Promise<void>;
+};
+/**
+ * Schema API
+ */
+export declare const schemaApi: {
+    /**
+     * Get the current schema for a service
+     */
+    get(workspaceSlug: string, serviceSlug: string): Promise<ServiceSchema>;
+    /**
+     * Get schema by service ID
+     */
+    getByServiceId(serviceId: string): Promise<ServiceSchema>;
+    /**
+     * Update the schema for a service (push)
+     */
+    update(workspaceSlug: string, serviceSlug: string, schema: Omit<ServiceSchema, "id" | "serviceId" | "version" | "createdAt" | "updatedAt">): Promise<ServiceSchema>;
+    /**
+     * Validate a schema without saving
+     */
+    validate(workspaceSlug: string, serviceSlug: string, schema: Omit<ServiceSchema, "id" | "serviceId" | "version" | "createdAt" | "updatedAt">): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+    /**
+     * Get schema diff between local and remote
+     */
+    diff(workspaceSlug: string, serviceSlug: string, localSchema: Omit<ServiceSchema, "id" | "serviceId" | "version" | "createdAt" | "updatedAt">): Promise<{
+        hasChanges: boolean;
+        added: string[];
+        removed: string[];
+        modified: string[];
+    }>;
+};
+/**
+ * Build API
+ */
+export declare const buildApi: {
+    /**
+     * Trigger a build for a service
+     */
+    trigger(workspaceSlug: string, serviceSlug: string): Promise<BuildStatus>;
+    /**
+     * Get build status
+     */
+    getStatus(buildId: string): Promise<BuildStatus>;
+    /**
+     * Get latest build for a service
+     */
+    getLatest(workspaceSlug: string, serviceSlug: string): Promise<BuildStatus | null>;
+    /**
+     * Poll for build completion
+     * Note: Sequential polling is intentional for proper status checking
+     */
+    waitForCompletion(buildId: string, options?: {
+        maxWait?: number | undefined;
+        pollInterval?: number | undefined;
+        onProgress?: ((status: BuildStatus) => void) | undefined;
+    } | undefined): Promise<BuildStatus>;
+};
+/**
+ * GitHub API
+ */
+export declare const githubApi: {
+    /**
+     * Get GitHub connection status for a workspace
+     */
+    getConnection(workspaceSlug: string): Promise<GitHubConnection>;
+    /**
+     * List available GitHub repositories
+     */
+    listRepos(workspaceSlug: string, options?: {
+        page?: number;
+        pageSize?: number;
+        search?: string;
+    }): Promise<PaginatedResponse<GitHubRepo>>;
+    /**
+     * Get OAuth URL for GitHub connection
+     */
+    getConnectUrl(workspaceSlug: string): Promise<{
+        url: string;
+    }>;
+};

package/dist/lib/api/services.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * Platform API Services
+ *
+ * Typed API methods for interacting with platform resources.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubApi = exports.buildApi = exports.schemaApi = exports.servicesApi = exports.workspacesApi = exports.authApi = void 0;
+const client_1 = require("./client");
+/**
+ * Authentication API
+ */
+exports.authApi = {
+    /**
+     * Exchange OAuth authorization code for tokens
+     */
+    exchangeCode(code) {
+        return client_1.api.post("/auth/cli/exchange", { code }, { skipAuth: true });
+    },
+    /**
+     * Get current user profile
+     */
+    getProfile() {
+        return client_1.api.get("/auth/me");
+    },
+    /**
+     * Revoke current session
+     */
+    logout() {
+        return client_1.api.post("/auth/cli/logout");
+    },
+};
+/**
+ * Workspaces API
+ */
+exports.workspacesApi = {
+    /**
+     * List all workspaces the user has access to
+     */
+    list() {
+        return client_1.api.get("/workspaces");
+    },
+    /**
+     * Get a specific workspace by slug
+     */
+    get(slug) {
+        return client_1.api.get(`/workspaces/${slug}`);
+    },
+    /**
+     * Get workspace by ID
+     */
+    getById(id) {
+        return client_1.api.get(`/workspaces/by-id/${id}`);
+    },
+};
+/**
+ * Services API
+ */
+exports.servicesApi = {
+    /**
+     * List all services in a workspace
+     */
+    list(workspaceSlug, options) {
+        return client_1.api.get(`/workspaces/${workspaceSlug}/services`, { params: options });
+    },
+    /**
+     * Get a specific service by slug
+     */
+    get(workspaceSlug, serviceSlug) {
+        return client_1.api.get(`/workspaces/${workspaceSlug}/services/${serviceSlug}`);
+    },
+    /**
+     * Get service by ID
+     */
+    getById(id) {
+        return client_1.api.get(`/services/${id}`);
+    },
+    /**
+     * Create a new service
+     */
+    create(workspaceSlug, data) {
+        return client_1.api.post(`/workspaces/${workspaceSlug}/services`, data);
+    },
+    /**
+     * Update a service
+     */
+    update(workspaceSlug, serviceSlug, data) {
+        return client_1.api.patch(`/workspaces/${workspaceSlug}/services/${serviceSlug}`, data);
+    },
+    /**
+     * Delete a service
+     */
+    delete(workspaceSlug, serviceSlug) {
+        return client_1.api.delete(`/workspaces/${workspaceSlug}/services/${serviceSlug}`);
+    },
+};
+/**
+ * Schema API
+ */
+exports.schemaApi = {
+    /**
+     * Get the current schema for a service
+     */
+    get(workspaceSlug, serviceSlug) {
+        return client_1.api.get(`/workspaces/${workspaceSlug}/services/${serviceSlug}/schema`);
+    },
+    /**
+     * Get schema by service ID
+     */
+    getByServiceId(serviceId) {
+        return client_1.api.get(`/services/${serviceId}/schema`);
+    },
+    /**
+     * Update the schema for a service (push)
+     */
+    update(workspaceSlug, serviceSlug, schema) {
+        return client_1.api.put(`/workspaces/${workspaceSlug}/services/${serviceSlug}/schema`, schema);
+    },
+    /**
+     * Validate a schema without saving
+     */
+    validate(workspaceSlug, serviceSlug, schema) {
+        return client_1.api.post(`/workspaces/${workspaceSlug}/services/${serviceSlug}/schema/validate`, schema);
+    },
+    /**
+     * Get schema diff between local and remote
+     */
+    diff(workspaceSlug, serviceSlug, localSchema) {
+        return client_1.api.post(`/workspaces/${workspaceSlug}/services/${serviceSlug}/schema/diff`, localSchema);
+    },
+};
+/**
+ * Build API
+ */
+exports.buildApi = {
+    /**
+     * Trigger a build for a service
+     */
+    trigger(workspaceSlug, serviceSlug) {
+        return client_1.api.post(`/workspaces/${workspaceSlug}/services/${serviceSlug}/build`);
+    },
+    /**
+     * Get build status
+     */
+    getStatus(buildId) {
+        return client_1.api.get(`/builds/${buildId}`);
+    },
+    /**
+     * Get latest build for a service
+     */
+    getLatest(workspaceSlug, serviceSlug) {
+        return client_1.api.get(`/workspaces/${workspaceSlug}/services/${serviceSlug}/build/latest`);
+    },
+    /**
+     * Poll for build completion
+     * Note: Sequential polling is intentional for proper status checking
+     */
+    async waitForCompletion(buildId, options) {
+        var _a, _b;
+        const maxWait = (_a = options === null || options === void 0 ? void 0 : options.maxWait) !== null && _a !== void 0 ? _a : 300000; // 5 minutes default
+        const pollInterval = (_b = options === null || options === void 0 ? void 0 : options.pollInterval) !== null && _b !== void 0 ? _b : 3000; // 3 seconds
+        const startTime = Date.now();
+        /* eslint-disable no-await-in-loop */
+        while (Date.now() - startTime < maxWait) {
+            const status = await this.getStatus(buildId);
+            if (options === null || options === void 0 ? void 0 : options.onProgress) {
+                options.onProgress(status);
+            }
+            if (status.status === "success" || status.status === "failed") {
+                return status;
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, pollInterval);
+            });
+        }
+        /* eslint-enable no-await-in-loop */
+        throw new Error("Build timed out");
+    },
+};
+/**
+ * GitHub API
+ */
+exports.githubApi = {
+    /**
+     * Get GitHub connection status for a workspace
+     */
+    getConnection(workspaceSlug) {
+        return client_1.api.get(`/workspaces/${workspaceSlug}/github/connection`);
+    },
+    /**
+     * List available GitHub repositories
+     */
+    listRepos(workspaceSlug, options) {
+        return client_1.api.get(`/workspaces/${workspaceSlug}/github/repos`, { params: options });
+    },
+    /**
+     * Get OAuth URL for GitHub connection
+     */
+    getConnectUrl(workspaceSlug) {
+        return client_1.api.get(`/workspaces/${workspaceSlug}/github/connect-url`);
+    },
+};