hereya-cli 0.89.0 → 0.90.1

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

@@ -0,0 +1,146 @@
+import { safeResponseJson } from './utils.js';
+export async function getPackageByVersion(config, name, version) {
+    const response = await fetch(`${config.url}/api/registry/packages/${encodeURIComponent(name)}/${encodeURIComponent(version)}`, {
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'GET',
+    });
+    const result = await safeResponseJson(response);
+    if (!response.ok) {
+        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,
+    };
+}
+export async function getPackageLatest(config, name) {
+    const response = await fetch(`${config.url}/api/registry/packages/${encodeURIComponent(name)}`, {
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'GET',
+    });
+    const result = await safeResponseJson(response);
+    if (!response.ok) {
+        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,
+    };
+}
+export async function listPackageVersions(config, name) {
+    const response = await fetch(`${config.url}/api/registry/packages/${encodeURIComponent(name)}?versions=all`, {
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'GET',
+    });
+    const result = await safeResponseJson(response);
+    if (!response.ok) {
+        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,
+    };
+}
+export async function searchPackages(config, input) {
+    const url = new URL(`${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 ${config.accessToken}`,
+        },
+        method: 'GET',
+    });
+    const result = await 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,
+    };
+}

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

@@ -0,0 +1,4 @@
+import { AddPackageToWorkspaceInput, AddPackageToWorkspaceOutput, RemovePackageFromWorkspaceInput, RemovePackageFromWorkspaceOutput } from '../../common.js';
+import { CloudHttpConfig } from './utils.js';
+export declare function addPackageToWorkspace(config: CloudHttpConfig, input: AddPackageToWorkspaceInput): Promise<AddPackageToWorkspaceOutput>;
+export declare function removePackageFromWorkspace(config: CloudHttpConfig, input: RemovePackageFromWorkspaceInput): Promise<RemovePackageFromWorkspaceOutput>;

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

@@ -0,0 +1,50 @@
+import { convertWorkspace, safeResponseJson } from './utils.js';
+export async function addPackageToWorkspace(config, 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(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/packages`, {
+        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 {
+        success: true,
+        workspace: convertWorkspace(result.workspace),
+    };
+}
+export async function removePackageFromWorkspace(config, input) {
+    const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/packages/${encodeURIComponent(input.package)}`, {
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'DELETE',
+    });
+    if (!response.ok) {
+        return {
+            reason: JSON.stringify(await safeResponseJson(response)),
+            success: false,
+        };
+    }
+    const result = await response.json();
+    return {
+        success: true,
+        workspace: convertWorkspace(result.workspace),
+    };
+}

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

@@ -0,0 +1,7 @@
+import { GetProjectMetadataInput, GetProjectMetadataOutput, ImportProjectInput, ImportProjectOutput, InitProjectInput, InitProjectOutput, ListProjectsOutput, SaveProjectMetadataInput, SaveProjectMetadataOutput } from '../../common.js';
+import { CloudHttpConfig } from './utils.js';
+export declare function init(config: CloudHttpConfig, input: InitProjectInput): Promise<InitProjectOutput>;
+export declare function getProjectMetadata(config: CloudHttpConfig, input: GetProjectMetadataInput): Promise<GetProjectMetadataOutput>;
+export declare function saveProjectMetadata(config: CloudHttpConfig, input: SaveProjectMetadataInput): Promise<SaveProjectMetadataOutput>;
+export declare function importProject(config: CloudHttpConfig, input: ImportProjectInput): Promise<ImportProjectOutput>;
+export declare function listProjects(config: CloudHttpConfig): Promise<ListProjectsOutput>;

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

@@ -0,0 +1,122 @@
+import { safeResponseJson } from './utils.js';
+export async function init(config, input) {
+    const formData = new FormData();
+    formData.append('name', input.project);
+    formData.append('workspace', input.workspace);
+    const response = await fetch(`${config.url}/api/projects`, {
+        body: formData,
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        throw new Error(JSON.stringify(await 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,
+        },
+    };
+}
+export async function getProjectMetadata(config, input) {
+    const response = await fetch(`${config.url}/api/projects/${encodeURIComponent(input.project)}/metadata`, {
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        return {
+            found: false,
+            reason: JSON.stringify(await safeResponseJson(response)),
+        };
+    }
+    const result = await safeResponseJson(response);
+    if (!result.metadata) {
+        return {
+            found: false,
+        };
+    }
+    return {
+        defaultWorkspace: result.defaultWorkspace,
+        found: true,
+        metadata: result.metadata,
+    };
+}
+export async function saveProjectMetadata(config, input) {
+    const formData = new FormData();
+    formData.append('metadata', JSON.stringify(input.metadata));
+    const response = await fetch(`${config.url}/api/projects/${encodeURIComponent(input.project)}/metadata`, {
+        body: formData,
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        return {
+            reason: JSON.stringify(await safeResponseJson(response)),
+            success: false,
+        };
+    }
+    return {
+        success: true,
+    };
+}
+export async function importProject(config, input) {
+    const response = await fetch(`${config.url}/api/projects/${encodeURIComponent(input.project)}/import`, {
+        body: JSON.stringify({ repoUrl: input.repoUrl, workspace: input.workspace }),
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    const result = await 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,
+    };
+}
+export async function listProjects(config) {
+    const response = await fetch(`${config.url}/api/projects`, {
+        headers: { 'Authorization': `Bearer ${config.accessToken}` },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        throw new Error(JSON.stringify(await safeResponseJson(response)));
+    }
+    const result = await response.json();
+    return (result.projects ?? []).map((p) => ({
+        defaultWorkspace: p.defaultWorkspace?.name ?? '-',
+        name: p.name,
+    }));
+}

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

@@ -0,0 +1,6 @@
+import { Config } from '../../../lib/config/common.js';
+import { DeleteStateInput, DeleteStateOutput, GetStateInput, GetStateOutput } from '../../common.js';
+import { CloudHttpConfig } from './utils.js';
+export declare function deleteState(config: CloudHttpConfig, input: DeleteStateInput): Promise<DeleteStateOutput>;
+export declare function getState(config: CloudHttpConfig, input: GetStateInput): Promise<GetStateOutput>;
+export declare function saveState(config: CloudHttpConfig, stateConfig: Config, workspace?: string): Promise<void>;

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

@@ -0,0 +1,86 @@
+import { safeResponseJson } from './utils.js';
+export async function deleteState(config, input) {
+    const response = await fetch(`${config.url}/api/projects/${encodeURIComponent(input.project)}/state/${encodeURIComponent(input.workspace)}`, {
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'DELETE',
+    });
+    if (!response.ok) {
+        return {
+            reason: JSON.stringify(await safeResponseJson(response)),
+            success: false,
+        };
+    }
+    return {
+        message: `State for project ${input.project} in workspace ${input.workspace} deleted successfully`,
+        success: true,
+    };
+}
+export async function getState(config, input) {
+    const url = new URL(`${config.url}/api/projects/${encodeURIComponent(input.project)}/state`);
+    url.searchParams.append('workspace', input.workspace);
+    const response = await fetch(url, {
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'GET',
+    });
+    if (!response.ok) {
+        return {
+            found: false,
+            reason: JSON.stringify(await 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,
+    };
+}
+export async function saveState(config, stateConfig, workspace) {
+    const formData = new FormData();
+    if (workspace) {
+        formData.append('workspace', workspace);
+    }
+    if (stateConfig.deploy) {
+        const deployArray = Object.entries(stateConfig.deploy)
+            .map(([name, { version }]) => ({ name, version }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        formData.append('deploy', JSON.stringify(deployArray));
+    }
+    if (stateConfig.packages) {
+        const packagesArray = Object.entries(stateConfig.packages)
+            .map(([name, { version }]) => ({ name, version }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        formData.append('packages', JSON.stringify(packagesArray));
+    }
+    const response = await fetch(`${config.url}/api/projects/${encodeURIComponent(stateConfig.project)}/state`, {
+        body: formData,
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        throw new Error(JSON.stringify(await safeResponseJson(response)));
+    }
+}

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

@@ -0,0 +1,55 @@
+import { InfrastructureType } from '../../../infrastructure/common.js';
+import { Workspace } from '../../common.js';
+export interface CloudHttpConfig {
+    accessToken: string;
+    url: string;
+}
+export declare function safeResponseJson(response: {
+    text(): Promise<string>;
+}): Promise<any>;
+interface RawWorkspace {
+    createdAt: Date;
+    env: {
+        id: string;
+        infrastructure: InfrastructureType;
+        key: string;
+        value: string;
+    }[];
+    hasExecutor?: boolean;
+    id: string;
+    isDeploy?: boolean;
+    mirrorOf: null | {
+        id: string;
+        name: string;
+    };
+    name: string;
+    ownerId: string;
+    ownPackages?: {
+        env?: {
+            id: string;
+            infrastructure: InfrastructureType;
+            key: string;
+            value: string;
+        }[];
+        id: string;
+        name: string;
+        parameters: Record<string, any>;
+        version: string;
+    }[];
+    packages: {
+        env: {
+            id: string;
+            infrastructure: InfrastructureType;
+            key: string;
+            value: string;
+        }[];
+        id: string;
+        name: string;
+        parameters: Record<string, any>;
+        version: string;
+    }[];
+    profile?: null | string;
+    updatedAt: Date;
+}
+export declare function convertWorkspace(workspace: RawWorkspace): Workspace;
+export {};

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

@@ -0,0 +1,56 @@
+export async function safeResponseJson(response) {
+    const text = await response.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { error: text || 'Unknown error' };
+    }
+}
+export function 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,
+    };
+}

package/dist/backend/cloud/cloud-backend/workspace-env.d.ts

@@ -0,0 +1,5 @@
+import { GetWorkspaceEnvInput, GetWorkspaceEnvOutput, SetEnvVarInput, SetEnvVarOutput, UnsetEnvVarInput, UnsetEnvVarOutput } from '../../common.js';
+import { CloudHttpConfig } from './utils.js';
+export declare function setEnvVar(config: CloudHttpConfig, input: SetEnvVarInput): Promise<SetEnvVarOutput>;
+export declare function unsetEnvVar(config: CloudHttpConfig, input: UnsetEnvVarInput): Promise<UnsetEnvVarOutput>;
+export declare function getWorkspaceEnv(config: CloudHttpConfig, input: GetWorkspaceEnvInput): Promise<GetWorkspaceEnvOutput>;

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

@@ -0,0 +1,63 @@
+import { resolveWorkspaceName } from '../../../lib/workspace-utils.js';
+import { safeResponseJson } from './utils.js';
+import { getWorkspace } from './workspaces.js';
+export async function setEnvVar(config, input) {
+    const formData = new FormData();
+    formData.append('key', input.name);
+    formData.append('value', input.value);
+    formData.append('infrastructure', input.infrastructure);
+    const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/env`, {
+        body: formData,
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        return {
+            reason: JSON.stringify(await safeResponseJson(response)),
+            success: false,
+        };
+    }
+    return {
+        success: true,
+    };
+}
+export async function unsetEnvVar(config, input) {
+    const response = await fetch(`${config.url}/api/workspaces/${encodeURIComponent(input.workspace)}/env/${encodeURIComponent(input.name)}`, {
+        headers: {
+            'Authorization': `Bearer ${config.accessToken}`,
+        },
+        method: 'DELETE',
+    });
+    if (!response.ok) {
+        return {
+            reason: JSON.stringify(await safeResponseJson(response)),
+            success: false,
+        };
+    }
+    return {
+        success: true,
+    };
+}
+export async function getWorkspaceEnv(config, input) {
+    // Apply org prefix if project has one and workspace doesn't
+    const workspaceName = resolveWorkspaceName(input.workspace, input.project);
+    const workspace$ = await getWorkspace(config, 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,
+    };
+}

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

@@ -0,0 +1,7 @@
+import { CreateWorkspaceInput, CreateWorkspaceOutput, DeleteWorkspaceInput, DeleteWorkspaceOutput, GetWorkspaceOutput, ListWorkspacesInput, UpdateWorkspaceInput, UpdateWorkspaceOutput } from '../../common.js';
+import { CloudHttpConfig } from './utils.js';
+export declare function createWorkspace(config: CloudHttpConfig, input: CreateWorkspaceInput): Promise<CreateWorkspaceOutput>;
+export declare function deleteWorkspace(config: CloudHttpConfig, input: DeleteWorkspaceInput): Promise<DeleteWorkspaceOutput>;
+export declare function getWorkspace(config: CloudHttpConfig, name: string): Promise<GetWorkspaceOutput>;
+export declare function listWorkspaces(config: CloudHttpConfig, input?: ListWorkspacesInput): Promise<string[]>;
+export declare function updateWorkspace(config: CloudHttpConfig, input: UpdateWorkspaceInput): Promise<UpdateWorkspaceOutput>;