hereya-cli 0.89.1 → 0.91.0

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

@@ -1,1137 +1,150 @@
-import { resolveWorkspaceName } from '../../lib/workspace-utils.js';
+import * as appsDeploy from './cloud-backend/apps-deploy.js';
+import * as appsVersions from './cloud-backend/apps-versions.js';
+import * as executorBroker from './cloud-backend/executor-broker.js';
+import * as executorJobs from './cloud-backend/executor-jobs.js';
+import * as misc from './cloud-backend/misc.js';
+import * as packagesPublish from './cloud-backend/packages-publish.js';
+import * as packagesRegistry from './cloud-backend/packages-registry.js';
+import * as packagesWorkspace from './cloud-backend/packages-workspace.js';
+import * as projects from './cloud-backend/projects.js';
+import * as state from './cloud-backend/state.js';
+import * as workspaceEnv from './cloud-backend/workspace-env.js';
+import * as workspaces from './cloud-backend/workspaces.js';
 export class CloudBackend {
     config;
     constructor(config) {
         this.config = config;
     }
-    async addPackageToWorkspace(input) {
-        const formData = new FormData();
-        formData.append('package', input.package);
-        formData.append('infra', input.infra);
-        formData.append('env', JSON.stringify(input.env));
-        if (input.parameters) {
-            formData.append('parameters', JSON.stringify(input.parameters));
-        }
-        if (input.version) {
-            formData.append('version', input.version);
-        }
-        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/packages`, {
-            body: formData,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        const result = await response.json();
-        return {
-            success: true,
-            workspace: this.convertWorkspace(result.workspace),
-        };
+    addPackageToWorkspace(input) {
+        return packagesWorkspace.addPackageToWorkspace(this.config, input);
     }
-    async createWorkspace(input) {
-        const formData = new FormData();
-        formData.append('name', input.name);
-        if (input.mirrorOf) {
-            formData.append('mirrorOf', input.mirrorOf);
-        }
-        if (input.profile) {
-            formData.append('profile', input.profile);
-        }
-        if (input.isDeploy !== undefined) {
-            formData.append('isDeploy', String(input.isDeploy));
-        }
-        const response = await fetch(`${this.config.url}/api/workspaces`, {
-            body: formData,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        const result = await response.json();
-        return {
-            isNew: true,
-            success: true,
-            workspace: this.convertWorkspace(result.workspace),
-        };
+    createWorkspace(input) {
+        return workspaces.createWorkspace(this.config, input);
     }
-    async deleteState(input) {
-        const response = await fetch(`${this.config.url}/api/projects/${encodeURIComponent(input.project)}/state/${encodeURIComponent(input.workspace)}`, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'DELETE',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        return {
-            message: `State for project ${input.project} in workspace ${input.workspace} deleted successfully`,
-            success: true,
-        };
+    deleteState(input) {
+        return state.deleteState(this.config, input);
     }
-    async deleteWorkspace(input) {
-        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.name)}`, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'DELETE',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        return {
-            success: true,
-        };
+    deleteWorkspace(input) {
+        return workspaces.deleteWorkspace(this.config, input);
     }
-    async deployApp(input) {
-        const body = {
-            workspace: input.workspace,
-        };
-        if (input.version)
-            body.version = input.version;
-        if (input.parameters)
-            body.parameters = input.parameters;
-        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(input.name)}/deployments`, {
-            body: JSON.stringify(body),
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-                'Content-Type': 'application/json',
-            },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            const error = await this.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 };
+    deployApp(input) {
+        return appsDeploy.deployApp(this.config, input);
     }
-    async destroyApp(input) {
-        const body = input.parameters ? JSON.stringify({ parameters: input.parameters }) : undefined;
-        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(input.name)}/deployments/${encodeURIComponent(input.workspace)}`, {
-            body,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-                ...(body ? { 'Content-Type': 'application/json' } : {}),
-            },
-            method: 'DELETE',
-        });
-        if (!response.ok) {
-            const error = await this.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 };
+    destroyApp(input) {
+        return appsDeploy.destroyApp(this.config, input);
     }
-    async exportBackend() {
-        const response = await fetch(`${this.config.url}/api/export`, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.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,
-        };
+    exportBackend() {
+        return misc.exportBackend(this.config);
     }
-    async generateExecutorToken(input) {
-        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/executor-token`, {
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            const error = await this.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 };
+    generateExecutorToken(input) {
+        return executorJobs.generateExecutorToken(this.config, input);
     }
-    async getApp(name) {
-        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(name)}`, {
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            const error = await this.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 };
+    getApp(name) {
+        return appsVersions.getApp(this.config, name);
     }
-    async getAppDeployment(input) {
-        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(input.name)}/deployments/${encodeURIComponent(input.workspace)}`, {
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            const error = await this.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 };
+    getAppDeployment(input) {
+        return appsDeploy.getAppDeployment(this.config, input);
     }
-    async getAppVersion(input) {
-        const url = input.version
-            ? `${this.config.url}/api/apps/${encodeURIComponent(input.name)}/versions/${encodeURIComponent(input.version)}`
-            : `${this.config.url}/api/apps/${encodeURIComponent(input.name)}/versions/latest`;
-        const response = await fetch(url, {
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            const error = await this.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 };
+    getAppVersion(input) {
+        return appsVersions.getAppVersion(this.config, input);
     }
-    async getExecutorJobStatus(input) {
-        const url = new URL(`${this.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 ${this.config.accessToken}` },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            if (response.status === 401) {
-                return { reason: 'Unauthorized', success: false };
-            }
-            const error = await this.safeResponseJson(response);
-            return { reason: error.error || 'Failed to get job status', success: false };
-        }
-        const result = await response.json();
-        return { job: result.job, success: true };
+    getExecutorJobStatus(input) {
+        return executorJobs.getExecutorJobStatus(this.config, input);
     }
-    async getPackageByVersion(name, version) {
-        const response = await fetch(`${this.config.url}/api/registry/packages/${encodeURIComponent(name)}/${encodeURIComponent(version)}`, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'GET',
-        });
-        const result = await this.safeResponseJson(response);
-        if (!response.ok) {
-            // Handle error responses
-            let errorMessage = result.error || 'Failed to get package';
-            switch (response.status) {
-                case 401: {
-                    errorMessage = 'Authentication failed. Please run `hereya login` to refresh your credentials.';
-                    break;
-                }
-                case 403: {
-                    errorMessage = `Access denied: ${errorMessage}`;
-                    break;
-                }
-                case 404: {
-                    errorMessage = `Package '${name}@${version}' not found`;
-                    break;
-                }
-            }
-            return {
-                reason: errorMessage,
-                success: false,
-            };
-        }
-        return {
-            package: result.package,
-            success: true,
-        };
+    getPackageByVersion(name, version) {
+        return packagesRegistry.getPackageByVersion(this.config, name, version);
     }
-    async getPackageLatest(name) {
-        const response = await fetch(`${this.config.url}/api/registry/packages/${encodeURIComponent(name)}`, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'GET',
-        });
-        const result = await this.safeResponseJson(response);
-        if (!response.ok) {
-            // Handle error responses
-            let errorMessage = result.error || 'Failed to get package';
-            switch (response.status) {
-                case 401: {
-                    errorMessage = 'Authentication failed. Please run `hereya login` to refresh your credentials.';
-                    break;
-                }
-                case 403: {
-                    errorMessage = `Access denied: ${errorMessage}`;
-                    break;
-                }
-                case 404: {
-                    errorMessage = `Package '${name}' not found`;
-                    break;
-                }
-            }
-            return {
-                reason: errorMessage,
-                success: false,
-            };
-        }
-        return {
-            package: result.package,
-            success: true,
-        };
+    getPackageLatest(name) {
+        return packagesRegistry.getPackageLatest(this.config, name);
     }
-    async getProjectMetadata(input) {
-        const response = await fetch(`${this.config.url}/api/projects/${encodeURIComponent(input.project)}/metadata`, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            return {
-                found: false,
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-            };
-        }
-        const result = await this.safeResponseJson(response);
-        if (!result.metadata) {
-            return {
-                found: false,
-            };
-        }
-        return {
-            defaultWorkspace: result.defaultWorkspace,
-            found: true,
-            metadata: result.metadata,
-        };
+    getProjectMetadata(input) {
+        return projects.getProjectMetadata(this.config, input);
     }
-    async getProvisioningId(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(`${this.config.url}/api/provisioning-id`, {
-            body: formData,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        const result = await response.json();
-        return {
-            id: result.provisioningId.id,
-            success: true,
-        };
+    getProvisioningId(input) {
+        return misc.getProvisioningId(this.config, input);
     }
-    async getState(input) {
-        const url = new URL(`${this.config.url}/api/projects/${encodeURIComponent(input.project)}/state`);
-        url.searchParams.append('workspace', input.workspace);
-        const response = await fetch(url, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            return {
-                found: false,
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-            };
-        }
-        const result = await response.json();
-        if (!result.success) {
-            return {
-                found: false,
-            };
-        }
-        const deploy = {};
-        for (const item of result.config.deploy) {
-            deploy[item.name] = { version: item.version };
-        }
-        const packages = {};
-        for (const item of result.config.packages) {
-            packages[item.name] = { version: item.version };
-        }
-        return {
-            config: {
-                deploy,
-                packages,
-                project: input.project,
-                workspace: input.workspace,
-            },
-            found: true,
-        };
+    getState(input) {
+        return state.getState(this.config, input);
     }
-    async getWorkspace(name) {
-        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(name)}`, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'GET',
-        });
-        // Handle 404 as "not found" rather than error
-        if (response.status === 404) {
-            return {
-                found: false,
-            };
-        }
-        if (!response.ok) {
-            const error = await this.safeResponseJson(response);
-            return {
-                error: JSON.stringify(error),
-                found: true,
-                hasError: true,
-            };
-        }
-        const result = await response.json();
-        return {
-            found: true,
-            hasError: false,
-            workspace: this.convertWorkspace(result.workspace),
-        };
+    getWorkspace(name) {
+        return workspaces.getWorkspace(this.config, name);
     }
-    async getWorkspaceEnv(input) {
-        // Apply org prefix if project has one and workspace doesn't
-        const workspaceName = resolveWorkspaceName(input.workspace, input.project);
-        const workspace$ = await this.getWorkspace(workspaceName);
-        if (!workspace$.found) {
-            return {
-                reason: `Workspace ${input.workspace} not found`,
-                success: false,
-            };
-        }
-        if (workspace$.hasError) {
-            return {
-                reason: workspace$.error,
-                success: false,
-            };
-        }
-        return {
-            env: workspace$.workspace.env ?? {},
-            success: true,
-        };
+    getWorkspaceEnv(input) {
+        return workspaceEnv.getWorkspaceEnv(this.config, input);
     }
-    async importBackend(input) {
-        const formData = new FormData();
-        formData.append('data', input.data);
-        const response = await fetch(`${this.config.url}/api/import`, {
-            body: formData,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        return {
-            success: true,
-        };
+    importBackend(input) {
+        return misc.importBackend(this.config, input);
     }
-    async importProject(input) {
-        const response = await fetch(`${this.config.url}/api/projects/${encodeURIComponent(input.project)}/import`, {
-            body: JSON.stringify({ repoUrl: input.repoUrl, workspace: input.workspace }),
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-                'Content-Type': 'application/json',
-            },
-            method: 'POST',
-        });
-        const result = await this.safeResponseJson(response);
-        if (!response.ok) {
-            const reason = typeof result?.error === 'string'
-                ? result.error
-                : (result?.errors && typeof result.errors === 'object'
-                    ? JSON.stringify(result.errors)
-                    : JSON.stringify(result));
-            return {
-                ...(typeof result?.code === 'string' ? { code: result.code } : {}),
-                reason,
-                success: false,
-            };
-        }
-        if (!result?.success || !result?.project) {
-            return {
-                reason: typeof result?.error === 'string' ? result.error : 'Unexpected response from server',
-                success: false,
-            };
-        }
-        return {
-            project: {
-                defaultWorkspace: result.project.defaultWorkspace,
-                name: result.project.name,
-            },
-            success: true,
-        };
+    importProject(input) {
+        return projects.importProject(this.config, input);
     }
-    async init(input) {
-        const formData = new FormData();
-        formData.append('name', input.project);
-        formData.append('workspace', input.workspace);
-        const response = await fetch(`${this.config.url}/api/projects`, {
-            body: formData,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            throw new Error(JSON.stringify(await this.safeResponseJson(response)));
-        }
-        const result = await response.json();
-        return {
-            project: {
-                id: result.project.id,
-                name: result.project.name,
-            },
-            workspace: {
-                id: result.project.defaultWorkspace.id,
-                name: result.project.defaultWorkspace.name,
-            },
-        };
+    init(input) {
+        return projects.init(this.config, input);
     }
-    async listAppDeployments(name) {
-        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(name)}/deployments`, {
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            const error = await this.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 };
+    listAppDeployments(name) {
+        return appsDeploy.listAppDeployments(this.config, name);
     }
-    async listApps() {
-        const response = await fetch(`${this.config.url}/api/apps`, {
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            const error = await this.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 };
+    listApps() {
+        return appsVersions.listApps(this.config);
     }
-    async listAppVersions(name) {
-        const response = await fetch(`${this.config.url}/api/apps/${encodeURIComponent(name)}/versions`, {
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            const error = await this.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 || [] };
+    listAppVersions(name) {
+        return appsVersions.listAppVersions(this.config, name);
     }
-    async listPackageVersions(name) {
-        const response = await fetch(`${this.config.url}/api/registry/packages/${encodeURIComponent(name)}?versions=all`, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'GET',
-        });
-        const result = await this.safeResponseJson(response);
-        if (!response.ok) {
-            // Handle error responses
-            let errorMessage = result.error || 'Failed to list package versions';
-            switch (response.status) {
-                case 401: {
-                    errorMessage = 'Authentication failed. Please run `hereya login` to refresh your credentials.';
-                    break;
-                }
-                case 403: {
-                    errorMessage = `Access denied: ${errorMessage}`;
-                    break;
-                }
-                case 404: {
-                    errorMessage = `Package '${name}' not found`;
-                    break;
-                }
-            }
-            return {
-                reason: errorMessage,
-                success: false,
-            };
-        }
-        return {
-            packages: result.packages || [],
-            success: true,
-        };
+    listPackageVersions(name) {
+        return packagesRegistry.listPackageVersions(this.config, name);
     }
-    async listProjects() {
-        const response = await fetch(`${this.config.url}/api/projects`, {
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            throw new Error(JSON.stringify(await this.safeResponseJson(response)));
-        }
-        const result = await response.json();
-        return (result.projects ?? []).map((p) => ({
-            defaultWorkspace: p.defaultWorkspace?.name ?? '-',
-            name: p.name,
-        }));
+    listProjects() {
+        return projects.listProjects(this.config);
     }
-    async listWorkspaces(input) {
-        const url = new URL(`${this.config.url}/api/workspaces`);
-        if (input?.org) {
-            url.searchParams.set('org', input.org);
-        }
-        const response = await fetch(url.toString(), {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            throw new Error(JSON.stringify(await this.safeResponseJson(response)));
-        }
-        const result = await response.json();
-        return result.workspaces.map((workspace) => workspace.name);
+    listWorkspaces(input) {
+        return workspaces.listWorkspaces(this.config, input);
     }
-    async pollExecutorJobs(input) {
-        const url = new URL(`${this.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 ${this.config.accessToken}` },
-            method: 'GET',
-        });
-        if (!response.ok) {
-            if (response.status === 401) {
-                return { reason: 'Unauthorized', success: false, unauthorized: true };
-            }
-            const error = await this.safeResponseJson(response);
-            return { reason: error.error || 'Failed to poll for jobs', success: false };
-        }
-        const result = await response.json();
-        return { job: result.job, success: true };
+    pollExecutorJobs(input) {
+        return executorJobs.pollExecutorJobs(this.config, input);
     }
-    async publishAppVersion(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(`${this.config.url}/api/apps/${encodeURIComponent(input.name)}/versions`, {
-            body: JSON.stringify(requestBody),
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-                'Content-Type': 'application/json',
-            },
-            method: 'POST',
-        });
-        const result = await this.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,
-        };
+    publishAppVersion(input) {
+        return appsVersions.publishAppVersion(this.config, input);
     }
-    async publishPackage(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(`${this.config.url}/api/registry/packages`, {
-            body: formData,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'POST',
-        });
-        const result = await this.safeResponseJson(response);
-        if (!response.ok) {
-            // Handle validation errors (field-specific errors)
-            if (result.errors && typeof result.errors === 'object') {
-                const errorMessages = [];
-                // Add main error message if present
-                if (result.error) {
-                    errorMessages.push(result.error, ''); // Empty line for separation
-                }
-                // Add field-specific errors
-                for (const [field, messages] of Object.entries(result.errors)) {
-                    if (Array.isArray(messages)) {
-                        errorMessages.push(`${field}: ${messages.join(', ')}`);
-                    }
-                }
-                // Add help message if present
-                if (result.help) {
-                    errorMessages.push('', `ℹ️  ${result.help}`);
-                }
-                return {
-                    reason: errorMessages.join('\n'),
-                    success: false,
-                };
-            }
-            // Handle other errors with more context
-            const errorMessages = [];
-            const errorMessage = result.error || 'Unknown error occurred';
-            // Add main error with context based on errorType or status code
-            if (result.errorType) {
-                errorMessages.push(`[${result.errorType}] ${errorMessage}`);
-            }
-            else {
-                // Fallback to status-based context
-                switch (response.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 (response.status >= 500) {
-                            errorMessages.push(`Server error: ${errorMessage} (status ${response.status})`);
-                        }
-                        else {
-                            errorMessages.push(errorMessage);
-                        }
-                    }
-                }
-            }
-            // Add help message if present
-            if (result.help) {
-                errorMessages.push('', `ℹ️  ${result.help}`);
-            }
-            // Add package info if present (helpful for debugging)
-            if (result.package) {
-                errorMessages.push('', `Package: ${result.package.name}@${result.package.version}`);
-            }
-            return {
-                reason: errorMessages.join('\n'),
-                success: false,
-            };
-        }
-        return {
-            package: result.package,
-            success: true,
-        };
+    publishPackage(input) {
+        return packagesPublish.publishPackage(this.config, input);
     }
-    async removePackageFromWorkspace(input) {
-        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/packages/${encodeURIComponent(input.package)}`, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'DELETE',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        const result = await response.json();
-        return {
-            success: true,
-            workspace: this.convertWorkspace(result.workspace),
-        };
+    registerExecutorBroker(input) {
+        return executorBroker.registerExecutorBroker(this.config, input);
     }
-    async revokeExecutorToken(input) {
-        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/executor-token`, {
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'DELETE',
-        });
-        if (!response.ok) {
-            const error = await this.safeResponseJson(response);
-            return { reason: error.error || 'Failed to revoke executor token', success: false };
-        }
-        return { success: true };
+    removePackageFromWorkspace(input) {
+        return packagesWorkspace.removePackageFromWorkspace(this.config, input);
     }
-    async saveProjectMetadata(input) {
-        const formData = new FormData();
-        formData.append('metadata', JSON.stringify(input.metadata));
-        const response = await fetch(`${this.config.url}/api/projects/${encodeURIComponent(input.project)}/metadata`, {
-            body: formData,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        return {
-            success: true,
-        };
+    revokeExecutorToken(input) {
+        return executorJobs.revokeExecutorToken(this.config, input);
     }
-    async saveState(config, workspace) {
-        const formData = new FormData();
-        if (workspace) {
-            formData.append('workspace', workspace);
-        }
-        if (config.deploy) {
-            const deployArray = Object.entries(config.deploy).map(([name, { version }]) => ({ name, version })).sort((a, b) => a.name.localeCompare(b.name));
-            formData.append('deploy', JSON.stringify(deployArray));
-        }
-        if (config.packages) {
-            const packagesArray = Object.entries(config.packages).map(([name, { version }]) => ({ name, version })).sort((a, b) => a.name.localeCompare(b.name));
-            formData.append('packages', JSON.stringify(packagesArray));
-        }
-        const response = await fetch(`${this.config.url}/api/projects/${encodeURIComponent(config.project)}/state`, {
-            body: formData,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            throw new Error(JSON.stringify(await this.safeResponseJson(response)));
-        }
+    saveProjectMetadata(input) {
+        return projects.saveProjectMetadata(this.config, input);
     }
-    async searchPackages(input) {
-        const url = new URL(`${this.config.url}/api/registry/packages/search`);
-        url.searchParams.append('q', input.query);
-        if (input.limit !== undefined) {
-            url.searchParams.append('limit', String(input.limit));
-        }
-        if (input.offset !== undefined) {
-            url.searchParams.append('offset', String(input.offset));
-        }
-        const response = await fetch(url, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'GET',
-        });
-        const result = await this.safeResponseJson(response);
-        if (!response.ok) {
-            let errorMessage = result.error || 'Failed to search packages';
-            switch (response.status) {
-                case 400: {
-                    errorMessage = `Invalid search query: ${errorMessage}`;
-                    break;
-                }
-                case 401: {
-                    errorMessage = 'Authentication failed. Please run `hereya login` to refresh your credentials.';
-                    break;
-                }
-                case 500: {
-                    errorMessage = `Server error: ${errorMessage}`;
-                    break;
-                }
-            }
-            return {
-                reason: errorMessage,
-                success: false,
-            };
-        }
-        return {
-            hasMore: result.hasMore ?? false,
-            packages: result.packages || [],
-            success: true,
-        };
+    saveState(config, workspace) {
+        return state.saveState(this.config, config, workspace);
     }
-    async setEnvVar(input) {
-        const formData = new FormData();
-        formData.append('key', input.name);
-        formData.append('value', input.value);
-        formData.append('infrastructure', input.infrastructure);
-        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/env`, {
-            body: formData,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        return {
-            success: true,
-        };
+    searchPackages(input) {
+        return packagesRegistry.searchPackages(this.config, input);
     }
-    async submitExecutorJob(input) {
-        const formData = new FormData();
-        formData.append('type', input.type);
-        formData.append('payload', JSON.stringify(input.payload));
-        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/jobs`, {
-            body: formData,
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'POST',
-        });
-        if (!response.ok) {
-            if (response.status === 401) {
-                return { reason: 'Unauthorized', success: false };
-            }
-            const error = await this.safeResponseJson(response);
-            return { reason: error.error || 'Failed to submit executor job', success: false };
-        }
-        const result = await response.json();
-        return { jobId: result.jobId, success: true };
+    setEnvVar(input) {
+        return workspaceEnv.setEnvVar(this.config, input);
     }
-    async unsetEnvVar(input) {
-        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/env/${encodeURIComponent(input.name)}`, {
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'DELETE',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        return {
-            success: true,
-        };
+    submitExecutorJob(input) {
+        return executorJobs.submitExecutorJob(this.config, input);
     }
-    async updateAppDeployment(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(`${this.config.url}/api/apps/${encodeURIComponent(input.name)}/deployments/${encodeURIComponent(input.workspace)}`, {
-            body: JSON.stringify(body),
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-                'Content-Type': 'application/json',
-            },
-            method: 'PATCH',
-        });
-        if (!response.ok) {
-            const error = await this.safeResponseJson(response);
-            return { reason: error.error || `Failed to update app deployment (status ${response.status})`, success: false };
-        }
-        return { success: true };
+    unregisterExecutorBroker(input) {
+        return executorBroker.unregisterExecutorBroker(this.config, input);
     }
-    async updateExecutorJob(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(`${this.config.url}/api/executor/jobs/${encodeURIComponent(input.jobId)}`, {
-            body: formData,
-            headers: { 'Authorization': `Bearer ${this.config.accessToken}` },
-            method: 'PATCH',
-        });
-        if (!response.ok) {
-            if (response.status === 401) {
-                return { reason: 'Unauthorized', success: false, unauthorized: true };
-            }
-            const error = await this.safeResponseJson(response);
-            return { reason: error.error || 'Failed to update job', success: false };
-        }
-        return { success: true };
+    unsetEnvVar(input) {
+        return workspaceEnv.unsetEnvVar(this.config, input);
     }
-    async updateWorkspace(input) {
-        const formData = new FormData();
-        if (input.profile !== undefined) {
-            formData.append('profile', input.profile === null ? '' : input.profile);
-        }
-        if (input.hasExecutor !== undefined) {
-            formData.append('hasExecutor', input.hasExecutor === null ? '' : String(input.hasExecutor));
-        }
-        if (input.isDeploy !== undefined) {
-            formData.append('isDeploy', input.isDeploy === null ? '' : String(input.isDeploy));
-        }
-        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(input.name)}`, {
-            body: formData,
-            headers: {
-                'Authorization': `Bearer ${this.config.accessToken}`,
-            },
-            method: 'PATCH',
-        });
-        if (!response.ok) {
-            return {
-                reason: JSON.stringify(await this.safeResponseJson(response)),
-                success: false,
-            };
-        }
-        const result = await response.json();
-        return {
-            success: true,
-            workspace: this.convertWorkspace(result.workspace),
-        };
+    updateAppDeployment(input) {
+        return appsDeploy.updateAppDeployment(this.config, input);
     }
-    convertWorkspace(workspace) {
-        const env = {};
-        if (workspace.packages) {
-            for (const pkg of workspace.packages) {
-                if (pkg.env) {
-                    for (const e of pkg.env) {
-                        env[e.key] = `${e.infrastructure}:${e.value}`;
-                    }
-                }
-            }
-        }
-        if (workspace.env) {
-            for (const e of workspace.env) {
-                env[e.key] = `${e.infrastructure}:${e.value}`;
-            }
-        }
-        const packages = {};
-        if (workspace.packages) {
-            for (const pkg of workspace.packages) {
-                packages[pkg.name] = {
-                    parameters: pkg.parameters,
-                    version: pkg.version,
-                };
-            }
-        }
-        let ownPackages;
-        if (workspace.ownPackages) {
-            ownPackages = {};
-            for (const pkg of workspace.ownPackages) {
-                ownPackages[pkg.name] = {
-                    parameters: pkg.parameters,
-                    version: pkg.version,
-                };
-            }
-        }
-        return {
-            env,
-            hasExecutor: workspace.hasExecutor ?? undefined,
-            id: workspace.id,
-            isDeploy: workspace.isDeploy,
-            mirrorOf: workspace.mirrorOf?.name,
-            name: workspace.name,
-            ...(ownPackages === undefined ? {} : { ownPackages }),
-            packages,
-            profile: workspace.profile === null ? undefined : workspace.profile,
-        };
+    updateExecutorJob(input) {
+        return executorJobs.updateExecutorJob(this.config, input);
     }
-    async safeResponseJson(response) {
-        const text = await response.text();
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return { error: text || 'Unknown error' };
-        }
+    updateWorkspace(input) {
+        return workspaces.updateWorkspace(this.config, input);
     }
 }