hereya-cli 0.89.1 → 0.90.1

package/dist/backend/cloud/cloud-backend/apps-deploy.js

@@ -0,0 +1,94 @@
+import { safeResponseJson } from './utils.js';
+export async function deployApp(config, input) {
+    const body = {
+        workspace: input.workspace,
+    };
+    if (input.version)
+        body.version = input.version;
+    if (input.parameters)
+        body.parameters = input.parameters;
+    const response = await fetch(`${config.url}/api/apps/${encodeURIComponent(input.name)}/deployments`, {
+        body: JSON.stringify(body),
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return { reason: error.error || `Failed to deploy app (status ${response.status})`, success: false };
+    }
+    const result = await response.json();
+    return { deploymentId: result.deploymentId, jobId: result.jobId, success: true };
+}
+export async function destroyApp(config, input) {
+    const body = input.parameters ? JSON.stringify({ parameters: input.parameters }) : undefined;
+    const response = await fetch(`${config.url}/api/apps/${encodeURIComponent(input.name)}/deployments/${encodeURIComponent(input.workspace)}`, {
+        body,
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+            ...(body ? { 'Content-Type': 'application/json' } : {}),
+        },
+        method: 'DELETE',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return { reason: error.error || `Failed to destroy app (status ${response.status})`, success: false };
+    }
+    const result = await response.json();
+    return { jobId: result.jobId, success: true };
+}
+export async function getAppDeployment(config, input) {
+    const response = await fetch(`${config.url}/api/apps/${encodeURIComponent(input.name)}/deployments/${encodeURIComponent(input.workspace)}`, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        let errorMessage = error.error || `Failed to get app deployment (status ${response.status})`;
+        if (response.status === 404) {
+            errorMessage = `Deployment for app '${input.name}' on workspace '${input.workspace}' not found`;
+        }
+        return { reason: errorMessage, success: false };
+    }
+    const result = await response.json();
+    return { deployment: result.deployment, success: true };
+}
+export async function listAppDeployments(config, name) {
+    const response = await fetch(`${config.url}/api/apps/${encodeURIComponent(name)}/deployments`, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return { reason: error.error || `Failed to list app deployments (status ${response.status})`, success: false };
+    }
+    const result = await response.json();
+    return { deployments: result.deployments || [], success: true };
+}
+export async function updateAppDeployment(config, input) {
+    const body = { status: input.status };
+    if (input.state !== undefined)
+        body.state = input.state;
+    if (input.env !== undefined)
+        body.env = input.env;
+    if (input.lastJobId !== undefined)
+        body.lastJobId = input.lastJobId;
+    const response = await fetch(`${config.url}/api/apps/${encodeURIComponent(input.name)}/deployments/${encodeURIComponent(input.workspace)}`, {
+        body: JSON.stringify(body),
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return {
+            reason: error.error || `Failed to update app deployment (status ${response.status})`,
+            success: false,
+        };
+    }
+    return { success: true };
+}

package/dist/backend/cloud/cloud-backend/apps-versions.d.ts

@@ -0,0 +1,69 @@
+import { IParameterSpec } from '../../../lib/package/index.js';
+import { CloudHttpConfig } from './utils.js';
+export interface AppSummary {
+    description?: null | string;
+    name: string;
+    visibility?: string;
+}
+export interface AppVersionSummary {
+    commit?: string;
+    parameters?: Record<string, IParameterSpec>;
+    publishedAt?: string;
+    repository?: string;
+    sha256?: string;
+    version: string;
+}
+export type PublishAppVersionInput = {
+    commit: string;
+    description?: string;
+    hereyaYaml: string;
+    name: string;
+    parameters?: Record<string, IParameterSpec>;
+    repository: string;
+    sha256: string;
+    version: string;
+    visibility?: 'private' | 'public';
+};
+export type PublishAppVersionOutput = {
+    app: {
+        id?: string;
+        name: string;
+        version: string;
+    };
+    success: true;
+} | {
+    reason: string;
+    success: false;
+};
+export declare function getApp(config: CloudHttpConfig, name: string): Promise<{
+    app: AppSummary;
+    success: true;
+} | {
+    reason: string;
+    success: false;
+}>;
+export declare function getAppVersion(config: CloudHttpConfig, input: {
+    name: string;
+    version?: string;
+}): Promise<{
+    appVersion: AppVersionSummary;
+    success: true;
+} | {
+    reason: string;
+    success: false;
+}>;
+export declare function listApps(config: CloudHttpConfig): Promise<{
+    apps: AppSummary[];
+    success: true;
+} | {
+    reason: string;
+    success: false;
+}>;
+export declare function listAppVersions(config: CloudHttpConfig, name: string): Promise<{
+    reason: string;
+    success: false;
+} | {
+    success: true;
+    versions: AppVersionSummary[];
+}>;
+export declare function publishAppVersion(config: CloudHttpConfig, input: PublishAppVersionInput): Promise<PublishAppVersionOutput>;

package/dist/backend/cloud/cloud-backend/apps-versions.js

@@ -0,0 +1,113 @@
+import { safeResponseJson } from './utils.js';
+export async function getApp(config, name) {
+    const response = await fetch(`${config.url}/api/apps/${encodeURIComponent(name)}`, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        let errorMessage = error.error || `Failed to get app (status ${response.status})`;
+        if (response.status === 404) {
+            errorMessage = `App '${name}' not found`;
+        }
+        return { reason: errorMessage, success: false };
+    }
+    const result = await response.json();
+    return { app: result.app, success: true };
+}
+export async function getAppVersion(config, input) {
+    const url = input.version
+        ? `${config.url}/api/apps/${encodeURIComponent(input.name)}/versions/${encodeURIComponent(input.version)}`
+        : `${config.url}/api/apps/${encodeURIComponent(input.name)}/versions/latest`;
+    const response = await fetch(url, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        let errorMessage = error.error || `Failed to get app version (status ${response.status})`;
+        if (response.status === 404) {
+            errorMessage = input.version
+                ? `App version '${input.name}@${input.version}' not found`
+                : `App '${input.name}' not found`;
+        }
+        return { reason: errorMessage, success: false };
+    }
+    const result = await response.json();
+    return { appVersion: result.appVersion ?? result.version, success: true };
+}
+export async function listApps(config) {
+    const response = await fetch(`${config.url}/api/apps`, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return { reason: error.error || `Failed to list apps (status ${response.status})`, success: false };
+    }
+    const result = await response.json();
+    return { apps: result.apps || [], success: true };
+}
+export async function listAppVersions(config, name) {
+    const response = await fetch(`${config.url}/api/apps/${encodeURIComponent(name)}/versions`, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return { reason: error.error || `Failed to list app versions (status ${response.status})`, success: false };
+    }
+    const result = await response.json();
+    return { success: true, versions: result.versions || [] };
+}
+export async function publishAppVersion(config, input) {
+    const requestBody = {
+        commit: input.commit,
+        hereyaYaml: input.hereyaYaml,
+        repository: input.repository,
+        sha256: input.sha256,
+        version: input.version,
+    };
+    if (input.description !== undefined)
+        requestBody.description = input.description;
+    if (input.visibility !== undefined)
+        requestBody.visibility = input.visibility;
+    if (input.parameters !== undefined)
+        requestBody.parameters = input.parameters;
+    const response = await fetch(`${config.url}/api/apps/${encodeURIComponent(input.name)}/versions`, {
+        body: JSON.stringify(requestBody),
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    const result = await safeResponseJson(response);
+    if (!response.ok) {
+        let errorMessage = result.error || 'Failed to publish app version';
+        switch (response.status) {
+            case 401: {
+                errorMessage = 'Authentication failed. Please run `hereya login` to refresh your credentials.';
+                break;
+            }
+            case 403: {
+                errorMessage = `Permission denied: ${errorMessage}`;
+                break;
+            }
+            case 409: {
+                errorMessage = `Conflict: ${errorMessage}`;
+                break;
+            }
+        }
+        return { reason: errorMessage, success: false };
+    }
+    const app = result.appVersion ?? result.app ?? { name: input.name, version: input.version };
+    return {
+        app: {
+            id: app.id,
+            name: app.name ?? input.name,
+            version: app.version ?? input.version,
+        },
+        success: true,
+    };
+}

package/dist/backend/cloud/cloud-backend/executor-jobs.d.ts

@@ -0,0 +1,75 @@
+import { CloudHttpConfig } from './utils.js';
+export declare function generateExecutorToken(config: CloudHttpConfig, input: {
+    workspace: string;
+}): Promise<{
+    expiresAt: string;
+    success: true;
+    token: string;
+} | {
+    reason: string;
+    success: false;
+}>;
+export declare function getExecutorJobStatus(config: CloudHttpConfig, input: {
+    jobId: string;
+    lastStatus?: string;
+    poll?: boolean;
+    workspace: string;
+}): Promise<{
+    job: {
+        id: string;
+        logs: string;
+        result: any;
+        status: string;
+        updatedAt: string;
+    };
+    success: true;
+} | {
+    reason: string;
+    success: false;
+}>;
+export declare function pollExecutorJobs(config: CloudHttpConfig, input: {
+    executorId?: string;
+    workspace: string;
+}): Promise<{
+    job: null | {
+        id: string;
+        payload: any;
+        type: string;
+    };
+    success: true;
+} | {
+    reason: string;
+    success: false;
+    unauthorized?: true;
+}>;
+export declare function revokeExecutorToken(config: CloudHttpConfig, input: {
+    workspace: string;
+}): Promise<{
+    reason: string;
+    success: false;
+} | {
+    success: true;
+}>;
+export declare function submitExecutorJob(config: CloudHttpConfig, input: {
+    payload: object;
+    type: 'app-deploy' | 'app-destroy' | 'deploy' | 'destroy' | 'provision' | 'resolve-env' | 'undeploy';
+    workspace: string;
+}): Promise<{
+    jobId: string;
+    success: true;
+} | {
+    reason: string;
+    success: false;
+}>;
+export declare function updateExecutorJob(config: CloudHttpConfig, input: {
+    jobId: string;
+    logs?: string;
+    result?: object;
+    status?: 'completed' | 'failed';
+}): Promise<{
+    reason: string;
+    success: false;
+    unauthorized?: true;
+} | {
+    success: true;
+}>;

package/dist/backend/cloud/cloud-backend/executor-jobs.js

@@ -0,0 +1,110 @@
+import { safeResponseJson } from './utils.js';
+export async function generateExecutorToken(config, input) {
+    const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/executor-token`, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return { reason: error.error || 'Failed to generate executor token', success: false };
+    }
+    const result = await response.json();
+    return { expiresAt: result.expiresAt, success: true, token: result.token };
+}
+export async function getExecutorJobStatus(config, input) {
+    const url = new URL(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/jobs/${encodeURIComponent(input.jobId)}`);
+    if (input.poll) {
+        url.searchParams.set('poll', 'true');
+    }
+    if (input.lastStatus) {
+        url.searchParams.set('lastStatus', input.lastStatus);
+    }
+    const response = await fetch(url.toString(), {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            return { reason: 'Unauthorized', success: false };
+        }
+        const error = await safeResponseJson(response);
+        return { reason: error.error || 'Failed to get job status', success: false };
+    }
+    const result = await response.json();
+    return { job: result.job, success: true };
+}
+export async function pollExecutorJobs(config, input) {
+    const url = new URL(`${config.url}/api/executor/jobs`);
+    url.searchParams.set('workspace', input.workspace);
+    if (input.executorId) {
+        url.searchParams.set('executorId', input.executorId);
+    }
+    const response = await fetch(url.toString(), {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            return { reason: 'Unauthorized', success: false, unauthorized: true };
+        }
+        const error = await safeResponseJson(response);
+        return { reason: error.error || 'Failed to poll for jobs', success: false };
+    }
+    const result = await response.json();
+    return { job: result.job, success: true };
+}
+export async function revokeExecutorToken(config, input) {
+    const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/executor-token`, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'DELETE',
+    });
+    if (!response.ok) {
+        const error = await safeResponseJson(response);
+        return { reason: error.error || 'Failed to revoke executor token', success: false };
+    }
+    return { success: true };
+}
+export async function submitExecutorJob(config, input) {
+    const formData = new FormData();
+    formData.append('type', input.type);
+    formData.append('payload', JSON.stringify(input.payload));
+    const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/jobs`, {
+        body: formData,
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            return { reason: 'Unauthorized', success: false };
+        }
+        const error = await safeResponseJson(response);
+        return { reason: error.error || 'Failed to submit executor job', success: false };
+    }
+    const result = await response.json();
+    return { jobId: result.jobId, success: true };
+}
+export async function updateExecutorJob(config, input) {
+    const formData = new FormData();
+    if (input.logs) {
+        formData.append('logs', input.logs);
+    }
+    if (input.status) {
+        formData.append('status', input.status);
+    }
+    if (input.result) {
+        formData.append('result', JSON.stringify(input.result));
+    }
+    const response = await fetch(`${config.url}/api/executor/jobs/${encodeURIComponent(input.jobId)}`, {
+        body: formData,
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'PATCH',
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            return { reason: 'Unauthorized', success: false, unauthorized: true };
+        }
+        const error = await safeResponseJson(response);
+        return { reason: error.error || 'Failed to update job', success: false };
+    }
+    return { success: true };
+}

package/dist/backend/cloud/cloud-backend/misc.d.ts

@@ -0,0 +1,5 @@
+import { ExportBackendOutput, GetProvisioningIdInput, GetProvisioningIdOutput, ImportBackendInput, ImportBackendOutput } from '../../common.js';
+import { CloudHttpConfig } from './utils.js';
+export declare function getProvisioningId(config: CloudHttpConfig, input: GetProvisioningIdInput): Promise<GetProvisioningIdOutput>;
+export declare function exportBackend(config: CloudHttpConfig): Promise<ExportBackendOutput>;
+export declare function importBackend(config: CloudHttpConfig, input: ImportBackendInput): Promise<ImportBackendOutput>;

package/dist/backend/cloud/cloud-backend/misc.js

@@ -0,0 +1,78 @@
+import { safeResponseJson } from './utils.js';
+export async function getProvisioningId(config, input) {
+    const formData = new FormData();
+    formData.append('packageCanonicalName', input.packageCanonicalName);
+    formData.append('logicalId', input.logicalId);
+    if (input.app) {
+        formData.append('app', input.app);
+    }
+    if (input.project) {
+        formData.append('project', input.project);
+    }
+    if (input.workspace) {
+        formData.append('workspace', input.workspace);
+    }
+    const response = await fetch(`${config.url}/api/provisioning-id`, {
+        body: formData,
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        return {
+            reason: JSON.stringify(await safeResponseJson(response)),
+            success: false,
+        };
+    }
+    const result = await response.json();
+    return {
+        id: result.provisioningId.id,
+        success: true,
+    };
+}
+export async function exportBackend(config) {
+    const response = await fetch(`${config.url}/api/export`, {
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        return {
+            reason: JSON.stringify(await safeResponseJson(response)),
+            success: false,
+        };
+    }
+    const result = await response.json();
+    if (!result.success) {
+        return {
+            reason: JSON.stringify(result),
+            success: false,
+        };
+    }
+    return {
+        data: JSON.stringify(result.data),
+        success: true,
+    };
+}
+export async function importBackend(config, input) {
+    const formData = new FormData();
+    formData.append('data', input.data);
+    const response = await fetch(`${config.url}/api/import`, {
+        body: formData,
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        return {
+            reason: JSON.stringify(await safeResponseJson(response)),
+            success: false,
+        };
+    }
+    return {
+        success: true,
+    };
+}

package/dist/backend/cloud/cloud-backend/packages-publish.d.ts

@@ -0,0 +1,3 @@
+import { PublishPackageInput, PublishPackageOutput } from '../../common.js';
+import { CloudHttpConfig } from './utils.js';
+export declare function publishPackage(config: CloudHttpConfig, input: PublishPackageInput): Promise<PublishPackageOutput>;

package/dist/backend/cloud/cloud-backend/packages-publish.js

@@ -0,0 +1,99 @@
+import { safeResponseJson } from './utils.js';
+export async function publishPackage(config, input) {
+    const formData = new FormData();
+    formData.append('name', input.name);
+    formData.append('version', input.version);
+    formData.append('description', input.description);
+    formData.append('repository', input.repository);
+    formData.append('commit', input.commit);
+    formData.append('sha256', input.sha256);
+    formData.append('iac', input.iac);
+    formData.append('infra', input.infra);
+    if (input.doc) {
+        formData.append('doc', input.doc);
+    }
+    if (input.visibility) {
+        formData.append('visibility', input.visibility);
+    }
+    if (input.onDeployPkg) {
+        formData.append('onDeployPkg', input.onDeployPkg);
+    }
+    if (input.onDeployVersion) {
+        formData.append('onDeployVersion', input.onDeployVersion);
+    }
+    const response = await fetch(`${config.url}/api/registry/packages`, {
+        body: formData,
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'POST',
+    });
+    const result = await safeResponseJson(response);
+    if (!response.ok) {
+        return formatPublishError(result, response.status);
+    }
+    return {
+        package: result.package,
+        success: true,
+    };
+}
+function formatPublishError(result, status) {
+    // Handle validation errors (field-specific errors)
+    if (result.errors && typeof result.errors === 'object') {
+        const errorMessages = [];
+        if (result.error) {
+            errorMessages.push(result.error, '');
+        }
+        for (const [field, messages] of Object.entries(result.errors)) {
+            if (Array.isArray(messages)) {
+                errorMessages.push(`${field}: ${messages.join(', ')}`);
+            }
+        }
+        if (result.help) {
+            errorMessages.push('', `ℹ️  ${result.help}`);
+        }
+        return {
+            reason: errorMessages.join('\n'),
+            success: false,
+        };
+    }
+    const errorMessages = [];
+    const errorMessage = result.error || 'Unknown error occurred';
+    if (result.errorType) {
+        errorMessages.push(`[${result.errorType}] ${errorMessage}`);
+    }
+    else {
+        switch (status) {
+            case 401: {
+                errorMessages.push('Authentication failed. Please run `hereya login` to refresh your credentials.');
+                break;
+            }
+            case 403: {
+                errorMessages.push(`Permission denied: ${errorMessage}`);
+                break;
+            }
+            case 409: {
+                errorMessages.push(`Conflict: ${errorMessage}`);
+                break;
+            }
+            default: {
+                if (status >= 500) {
+                    errorMessages.push(`Server error: ${errorMessage} (status ${status})`);
+                }
+                else {
+                    errorMessages.push(errorMessage);
+                }
+            }
+        }
+    }
+    if (result.help) {
+        errorMessages.push('', `ℹ️  ${result.help}`);
+    }
+    if (result.package) {
+        errorMessages.push('', `Package: ${result.package.name}@${result.package.version}`);
+    }
+    return {
+        reason: errorMessages.join('\n'),
+        success: false,
+    };
+}

package/dist/backend/cloud/cloud-backend/packages-registry.d.ts

@@ -0,0 +1,6 @@
+import { GetPackageOutput, ListPackageVersionsOutput, SearchPackagesInput, SearchPackagesOutput } from '../../common.js';
+import { CloudHttpConfig } from './utils.js';
+export declare function getPackageByVersion(config: CloudHttpConfig, name: string, version: string): Promise<GetPackageOutput>;
+export declare function getPackageLatest(config: CloudHttpConfig, name: string): Promise<GetPackageOutput>;
+export declare function listPackageVersions(config: CloudHttpConfig, name: string): Promise<ListPackageVersionsOutput>;
+export declare function searchPackages(config: CloudHttpConfig, input: SearchPackagesInput): Promise<SearchPackagesOutput>;