hereya-cli 0.34.0 → 0.36.0

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

@@ -0,0 +1,379 @@
+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));
+        }
+        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 response.json()),
+                success: false,
+            };
+        }
+        const result = await response.json();
+        return {
+            success: true,
+            workspace: this.convertWorkspace(result.workspace),
+        };
+    }
+    async createWorkspace(input) {
+        const formData = new FormData();
+        formData.append('name', input.name);
+        if (input.mirrorOf) {
+            formData.append('mirrorOf', input.mirrorOf);
+        }
+        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 response.json()),
+                success: false,
+            };
+        }
+        const result = await response.json();
+        return {
+            isNew: true,
+            success: true,
+            workspace: {
+                id: result.workspace.id,
+                name: result.workspace.name,
+            },
+        };
+    }
+    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 response.json()),
+                success: false,
+            };
+        }
+        return {
+            success: true,
+        };
+    }
+    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 response.json()),
+                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,
+        };
+    }
+    async getProvisioningId(input) {
+        const formData = new FormData();
+        formData.append('packageCanonicalName', input.packageCanonicalName);
+        formData.append('logicalId', input.logicalId);
+        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 response.json()),
+                success: false,
+            };
+        }
+        const result = await response.json();
+        return {
+            id: result.provisioningId.id,
+            success: true,
+        };
+    }
+    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 response.json()),
+            };
+        }
+        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,
+        };
+    }
+    async getWorkspace(name) {
+        const response = await fetch(`${this.config.url}/api/workspaces/${encodeURIComponent(name)}`, {
+            headers: {
+                'Authorization': `Bearer ${this.config.accessToken}`,
+            },
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return {
+                error: JSON.stringify(error),
+                found: true,
+                hasError: true,
+            };
+        }
+        const result = await response.json();
+        return {
+            found: true,
+            hasError: false,
+            workspace: this.convertWorkspace(result.workspace),
+        };
+    }
+    async getWorkspaceEnv(input) {
+        const workspace$ = await this.getWorkspace(input.workspace);
+        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,
+        };
+    }
+    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 response.json()),
+                success: false,
+            };
+        }
+        return {
+            success: true,
+        };
+    }
+    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 response.json()));
+        }
+        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,
+            },
+        };
+    }
+    async listWorkspaces() {
+        const response = await fetch(`${this.config.url}/api/workspaces`, {
+            headers: {
+                'Authorization': `Bearer ${this.config.accessToken}`,
+            },
+            method: 'GET',
+        });
+        if (!response.ok) {
+            throw new Error(JSON.stringify(await response.json()));
+        }
+        const result = await response.json();
+        return result.workspaces.map((workspace) => workspace.name);
+    }
+    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 response.json()),
+                success: false,
+            };
+        }
+        const result = await response.json();
+        return {
+            success: true,
+            workspace: this.convertWorkspace(result.workspace),
+        };
+    }
+    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 response.json()));
+        }
+    }
+    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 response.json()),
+                success: false,
+            };
+        }
+        return {
+            success: true,
+        };
+    }
+    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 response.json()),
+                success: false,
+            };
+        }
+        return {
+            success: true,
+        };
+    }
+    convertWorkspace(workspace) {
+        const env = {};
+        for (const pkg of workspace.packages) {
+            for (const e of pkg.env) {
+                env[e.key] = `${e.infrastructure}:${e.value}`;
+            }
+        }
+        for (const e of workspace.env) {
+            env[e.key] = `${e.infrastructure}:${e.value}`;
+        }
+        const packages = {};
+        for (const pkg of workspace.packages) {
+            packages[pkg.name] = {
+                parameters: pkg.parameters,
+                version: pkg.version,
+            };
+        }
+        return {
+            env,
+            id: workspace.id,
+            mirrorOf: workspace.mirrorOf?.name,
+            name: workspace.name,
+            packages,
+        };
+    }
+}

package/dist/backend/cloud/login.d.ts

@@ -0,0 +1,16 @@
+export declare function loginToCloudBackend(url: string): Promise<{
+    accessToken: string;
+    clientId: string;
+    refreshToken: string;
+    success: true;
+} | {
+    error: string;
+    success: false;
+}>;
+export declare function registerDevice(url: string): Promise<{
+    clientId: string;
+    success: true;
+} | {
+    error: string;
+    success: false;
+}>;

package/dist/backend/cloud/login.js

@@ -0,0 +1,145 @@
+/* eslint-disable n/no-unsupported-features/node-builtins */
+import machineId from 'node-machine-id';
+import crypto from 'node:crypto';
+import http from 'node:http';
+import net from 'node:net';
+import { browserUtils } from './utils.js';
+export async function loginToCloudBackend(url) {
+    const registerResult = await registerDevice(url);
+    if (!registerResult.success) {
+        return registerResult;
+    }
+    const { clientId } = registerResult;
+    const codeVerifier = crypto.randomBytes(32).toString('hex');
+    const codeChallengeRaw = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(codeVerifier));
+    const codeChallenge = Buffer.from(codeChallengeRaw).toString('base64');
+    const availablePort = await getAvailablePort(3000);
+    const myRedirectUri = `http://localhost:${availablePort}/auth/cli/callback`;
+    const redirectUrl = `${url}/auth/cli/login?client_id=${clientId}&code_challenge=${codeChallenge}&redirect_uri=${myRedirectUri}`;
+    console.log('Opening browser to', redirectUrl);
+    browserUtils.open(redirectUrl);
+    const codeResult = await waitForAuthorizationCode(availablePort);
+    if (!codeResult.success) {
+        return {
+            error: codeResult.error,
+            success: false,
+        };
+    }
+    const { code } = codeResult;
+    const formData = new FormData();
+    formData.append('clientId', clientId);
+    formData.append('code', code);
+    formData.append('codeVerifier', codeVerifier);
+    const tokenResult = await fetch(`${url}/auth/cli/code`, {
+        body: formData,
+        method: 'POST',
+    });
+    if (!tokenResult.ok) {
+        return {
+            error: `Failed to get token: ${JSON.stringify(await tokenResult.json())}`,
+            success: false,
+        };
+    }
+    const token = (await tokenResult.json());
+    return {
+        accessToken: token.data.accessToken,
+        clientId,
+        refreshToken: token.data.refreshToken,
+        success: true,
+    };
+}
+export async function registerDevice(url) {
+    const registerUrl = `${url}/auth/cli/register`;
+    const deviceId = await machineId.machineId();
+    const formData = new FormData();
+    formData.append('deviceId', deviceId);
+    const response = await fetch(registerUrl, {
+        body: formData,
+        method: 'POST',
+    });
+    if (!response.ok) {
+        return {
+            error: `Failed to register device: ${JSON.stringify(await response.json())}`,
+            success: false,
+        };
+    }
+    const result = (await response.json());
+    return {
+        clientId: result.data.clientId,
+        success: true,
+    };
+}
+async function getAvailablePort(startPort) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.unref();
+        server.on('error', () => {
+            server.listen(++startPort);
+        });
+        server.listen(startPort, () => {
+            server.close(() => resolve(startPort));
+        });
+    });
+}
+async function waitForAuthorizationCode(port) {
+    return new Promise((resolve) => {
+        const server = http.createServer((req, res) => {
+            const searchParams = new URLSearchParams(req.url.split('?')[1]);
+            const code = searchParams.get('code');
+            if (code) {
+                resolve({ code, success: true });
+            }
+            else {
+                resolve({ error: 'No authorization code received', success: false });
+            }
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(`
+<!DOCTYPE html>
+<html>
+<head>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      background: #f5f5f5;
+    }
+    .card {
+      background: white;
+      padding: 2rem;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+      text-align: center;
+    }
+    .success-icon {
+      color: #10B981;
+      font-size: 3rem;
+      margin-bottom: 1rem;
+    }
+    .message {
+      color: #666;
+      font-size: 0.9rem;
+      margin-top: 1rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="success-icon">✓</div>
+    <h2>Authorization Successful!</h2>
+    <p class="message">You can close this tab now (Ctrl+W or Cmd+W)</p>
+  </div>
+</body>
+</html>
+`);
+            server.closeAllConnections();
+            server.close();
+        });
+        server.listen(port, () => {
+            console.log(`Waiting for authorization code on port ${port}...`);
+        });
+    });
+}

package/dist/backend/cloud/logout.d.ts

@@ -0,0 +1,9 @@
+export declare function logoutFromCloudBackend({ secret, url }: {
+    secret: null | {
+        refreshToken: string;
+    };
+    url: string;
+}): Promise<Response | {
+    didDelete: boolean;
+    success: boolean;
+}>;

package/dist/backend/cloud/logout.js

@@ -0,0 +1,12 @@
+/* eslint-disable n/no-unsupported-features/node-builtins */
+export async function logoutFromCloudBackend({ secret, url }) {
+    if (!secret) {
+        return { didDelete: false, success: true };
+    }
+    return fetch(`${url}/auth/cli/logout`, {
+        headers: {
+            Authorization: `Bearer ${secret.refreshToken}`,
+        },
+        method: 'POST',
+    });
+}

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

@@ -0,0 +1,3 @@
+export declare const browserUtils: {
+    open(url: string): void;
+};

package/dist/backend/cloud/utils.js

@@ -0,0 +1,6 @@
+import open from 'open';
+export const browserUtils = {
+    open(url) {
+        open(url);
+    },
+};

package/dist/backend/common.d.ts

@@ -5,10 +5,12 @@ export interface Backend {
     addPackageToWorkspace(input: AddPackageToWorkspaceInput): Promise<AddPackageToWorkspaceOutput>;
     createWorkspace(input: CreateWorkspaceInput): Promise<CreateWorkspaceOutput>;
     deleteWorkspace(input: DeleteWorkspaceInput): Promise<DeleteWorkspaceOutput>;
+    exportBackend(): Promise<ExportBackendOutput>;
     getProvisioningId(input: GetProvisioningIdInput): Promise<GetProvisioningIdOutput>;
     getState(input: GetStateInput): Promise<GetStateOutput>;
     getWorkspace(workspace: string): Promise<GetWorkspaceOutput>;
     getWorkspaceEnv(input: GetWorkspaceEnvInput): Promise<GetWorkspaceEnvOutput>;
+    importBackend(input: ImportBackendInput): Promise<ImportBackendOutput>;
     init(options: InitProjectInput): Promise<InitProjectOutput>;
     listWorkspaces(): Promise<string[]>;
     removePackageFromWorkspace(input: RemovePackageFromWorkspaceInput): Promise<RemovePackageFromWorkspaceOutput>;
@@ -100,6 +102,13 @@ export type CreateWorkspaceOutput = {
     reason: string;
     success: false;
 };
+export type ExportBackendOutput = {
+    data: string;
+    success: true;
+} | {
+    reason: string;
+    success: false;
+};
 export type GetWorkspaceEnvInput = {
     project?: string;
     workspace: string;
@@ -133,6 +142,7 @@ export type GetStateOutput = {
     found: true;
 } | {
     found: false;
+    reason?: string;
 };
 export type DeleteWorkspaceInput = {
     name: string;
@@ -157,7 +167,17 @@ export type GetProvisioningIdOutput = {
     reason: string;
     success: false;
 };
+export type ImportBackendInput = {
+    data: string;
+};
+export type ImportBackendOutput = {
+    reason: string;
+    success: false;
+} | {
+    success: true;
+};
 export type SetEnvVarInput = {
+    infrastructure: InfrastructureType;
     name: string;
     value: string;
     workspace: string;
@@ -169,6 +189,7 @@ export type SetEnvVarOutput = {
     success: true;
 };
 export type UnsetEnvVarInput = {
+    infrastructure: InfrastructureType;
     name: string;
     workspace: string;
 };

package/dist/backend/config.d.ts

@@ -1,10 +1,37 @@
-import { BackendType } from "./index.js";
+import { BackendType } from './index.js';
 export declare function getCurrentBackendType(): Promise<BackendType>;
 export declare function setBackendType(type: BackendType): Promise<void>;
-export declare function loadBackendConfig(): Promise<{
-    current: BackendType;
+export declare function loadBackendConfig(): Promise<BackendConfig>;
+export declare function saveCloudCredentials(credentials: {
+    accessToken: string;
+    clientId: string;
+    refreshToken: string;
+    url: string;
+}): Promise<void>;
+export declare function deleteCloudCredentials(): Promise<{
+    didDelete: boolean;
+    originalConfig: {
+        cloud?: {
+            clientId: string;
+            url: string;
+        };
+        current: BackendType;
+    };
+    secret: {
+        accessToken: string;
+        refreshToken: string;
+    } | null;
+    success: boolean;
 }>;
+export declare function getCloudCredentials(clientId: string): Promise<{
+    accessToken: string;
+    refreshToken: string;
+} | null>;
 export declare function getBackendConfigPath(): string;
 export type BackendConfig = {
+    cloud?: {
+        clientId: string;
+        url: string;
+    };
     current: BackendType;
 };