@quantum-hub/qhubctl 1.0.0

package/dist/lib/fetch.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorMessage = exports.fetchOrThrow = exports.PlatformError = void 0;
+class PlatformError extends Error {
+    response;
+    constructor(response) {
+        super(response.statusText);
+        this.response = response;
+    }
+    async getErrorMessage() {
+        return (0, exports.getErrorMessage)(this.response);
+    }
+}
+exports.PlatformError = PlatformError;
+const fetchOrThrow = async (input, init) => {
+    const response = await fetch(input, init);
+    if (!response.ok) {
+        throw new PlatformError(response);
+    }
+    return response;
+};
+exports.fetchOrThrow = fetchOrThrow;
+const getErrorMessage = async (response) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        // ignore
+    }
+    const httpStatus = response.status && response.statusText ? `${response.status} - ${response.statusText}` : response.status;
+    // message is either in body.errorMessage, body.error or body.detail
+    let errorMessage;
+    if (body && body.errorMessage)
+        errorMessage = body.errorMessage;
+    if (!errorMessage && body && body.error)
+        errorMessage = body.error;
+    if (!errorMessage && body && body.detail)
+        errorMessage = body.detail;
+    return errorMessage ? `${errorMessage} (${httpStatus})` : `${httpStatus}`;
+};
+exports.getErrorMessage = getErrorMessage;

package/dist/lib/init-user-input.d.ts

@@ -0,0 +1,18 @@
+import { GpuType, Runtime } from '../model/managed-service-config';
+export interface StarterInput {
+    url: string;
+    runtime: Runtime;
+}
+export interface UserInput {
+    cpu: number;
+    descriptionFile?: string;
+    gpu?: GpuType;
+    memory: number;
+    name: string;
+    starter?: StarterInput;
+}
+export declare const DEFAULT_STARTER: {
+    url: string;
+    runtime: Runtime;
+};
+export declare const promptUserInput: (defaultName: string) => Promise<UserInput>;

package/dist/lib/init-user-input.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptUserInput = exports.DEFAULT_STARTER = void 0;
+const prompts_1 = require("@inquirer/prompts");
+const managed_service_config_1 = require("../model/managed-service-config");
+exports.DEFAULT_STARTER = {
+    url: 'https://gitlab.com/planqk-foss/planqk-starter-python/-/archive/main/planqk-starter-python-main.zip',
+    runtime: managed_service_config_1.Runtime.PYTHON_TEMPLATE
+};
+const promptUserInput = async (defaultName) => {
+    const name = await (0, prompts_1.input)({
+        message: `Service name (${defaultName}):`,
+        default: defaultName,
+    });
+    const starter = await (0, prompts_1.select)({
+        message: 'Choose a starter template',
+        choices: [
+            {
+                name: 'Python Starter (recommended to get started quickly)',
+                value: exports.DEFAULT_STARTER,
+            },
+            {
+                name: 'Docker Starter (setup for experienced users)',
+                value: {
+                    url: 'https://gitlab.com/planqk-foss/planqk-starter-docker/-/archive/main/planqk-starter-docker-main.zip',
+                    runtime: managed_service_config_1.Runtime.DOCKER
+                },
+            },
+            {
+                name: 'NVIDIA CUDA-Q Starter (for GPU accelerated applications; setup for experienced users)',
+                value: {
+                    url: 'https://gitlab.com/planqk-foss/planqk-starter-gpu/-/archive/main/planqk-starter-gpu-main.zip',
+                    runtime: managed_service_config_1.Runtime.DOCKER
+                },
+            },
+            { name: 'None (creates "qhub.json" in current directory)', value: undefined },
+        ],
+        default: exports.DEFAULT_STARTER,
+    });
+    const cpu = await (0, prompts_1.number)({
+        message: 'Enter vCPU configuration (may be between 1 and 220 vCPUs, depending on your account):',
+        default: 1,
+        validate: (input) => {
+            if (input === null || input === undefined || !Number.isInteger(input)) {
+                return 'Please enter a valid integer';
+            }
+            if (input < 1 || input > 220) {
+                return 'vCPU must be between 1 and 220';
+            }
+            return true;
+        },
+    });
+    const memory = await (0, prompts_1.number)({
+        message: 'Enter memory configuration in GB (may be between 1 and 848 GBs, depending on your account):',
+        default: 1,
+        validate: (input) => {
+            if (input === null || input === undefined || !Number.isInteger(input)) {
+                return 'Please enter a valid integer';
+            }
+            if (input < 1 || input > 848) {
+                return 'Memory must be between 1 and 848 GB';
+            }
+            return true;
+        },
+    });
+    let gpu = undefined;
+    if (!starter || starter.url.includes('planqk-starter-gpu')) {
+        gpu = await (0, prompts_1.select)({
+            message: 'Choose your GPU configuration',
+            choices: [
+                { name: 'No GPU support', value: undefined },
+                { name: 'NVIDIA® T4', value: managed_service_config_1.GpuType.NVIDIA_TESLA_T4 },
+                { name: 'NVIDIA® V100', value: managed_service_config_1.GpuType.NVIDIA_TESLA_V100 },
+            ],
+            default: undefined,
+        });
+    }
+    return {
+        name,
+        starter,
+        cpu: cpu,
+        memory: memory,
+        gpu,
+        descriptionFile: 'README.md',
+    };
+};
+exports.promptUserInput = promptUserInput;

package/dist/lib/random-name.d.ts

@@ -0,0 +1 @@
+export declare const randomName: () => string;

package/dist/lib/random-name.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomName = void 0;
+const randomName = () => {
+    const suffix = Math.random().toString(36).slice(2, 7);
+    const randomAdjective = adjectives[Math.floor(Math.random() * adjectives.length)];
+    const randomAnimal = animals[Math.floor(Math.random() * animals.length)];
+    return `${randomAdjective}-${randomAnimal}-${suffix}`;
+};
+exports.randomName = randomName;
+const adjectives = [
+    'admiring',
+    'adoring',
+    'agile',
+    'ambitious',
+    'blissful',
+    'bold',
+    'brave',
+    'brilliant',
+    'calm',
+    'charming',
+    'cozy',
+    'creative',
+    'curious',
+    'dazzling',
+    'delightful',
+    'diligent',
+    'dynamic',
+    'eager',
+    'efficient',
+    'elegant',
+    'fantastic',
+    'fierce',
+    'fluffy',
+    'focused',
+    'generous',
+    'gentle',
+    'gloomy',
+    'graceful',
+    'harmonious',
+    'honest',
+    'innovative',
+    'intelligent',
+    'jolly',
+    'joyful',
+    'jubilant',
+    'kind',
+    'lively',
+    'luminous',
+    'magnificent',
+    'misty',
+    'noble',
+    'optimistic',
+    'peaceful',
+    'precious',
+    'quiet',
+    'radiant',
+    'resilient',
+    'serene',
+    'silly',
+    'trustworthy',
+    'unique',
+    'vibrant',
+    'wise',
+    'xenial',
+    'youthful',
+    'zealous',
+];
+const animals = [
+    'aardvark',
+    'alpaca',
+    'anaconda',
+    'antelope',
+    'armadillo',
+    'baboon',
+    'badger',
+    'bat',
+    'bear',
+    'beaver',
+    'bison',
+    'boar',
+    'buffalo',
+    'camel',
+    'cat',
+    'cheetah',
+    'chimpanzee',
+    'chinchilla',
+    'cobra',
+    'cougar',
+    'coyote',
+    'crocodile',
+    'deer',
+    'dingo',
+    'dog',
+    'dolphin',
+    'donkey',
+    'eagle',
+    'elephant',
+    'elk',
+    'falcon',
+    'ferret',
+    'flamingo',
+    'fox',
+    'gazelle',
+    'giraffe',
+    'goat',
+    'gorilla',
+    'grizzly bear',
+    'hamster',
+    'hedgehog',
+    'hippopotamus',
+    'horse',
+    'hummingbird',
+    'hyena',
+    'iguana',
+    'jackal',
+    'jaguar',
+    'kangaroo',
+    'koala',
+    'lemur',
+    'leopard',
+    'lion',
+    'llama',
+    'lynx',
+    'mantis',
+    'marmot',
+    'mongoose',
+    'moose',
+    'narwhal',
+    'octopus',
+    'orangutan',
+    'ostrich',
+    'otter',
+    'panda',
+    'panther',
+    'peacock',
+    'penguin',
+    'platypus',
+    'puma',
+    'quail',
+    'rabbit',
+    'raccoon',
+    'raven',
+    'rhinoceros',
+    'salamander',
+    'seal',
+    'shark',
+    'skunk',
+    'sloth',
+    'squirrel',
+    'tapir',
+    'tiger',
+    'turtle',
+    'viper',
+    'walrus',
+    'whale',
+    'wombat',
+    'wolverine',
+    'yak',
+    'zebra',
+];

package/dist/lib/random-string.d.ts

@@ -0,0 +1 @@
+export declare const randomString: (length: number) => string;

package/dist/lib/random-string.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomString = void 0;
+const characters = 'abcdefghijklmnopqrstuvwxyz0123456789';
+const randomString = (length) => {
+    let value = '';
+    for (let i = 0; i < length; i++) {
+        value += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return value;
+};
+exports.randomString = randomString;

package/dist/lib/repository.d.ts

@@ -0,0 +1,3 @@
+import AdmZip from 'adm-zip';
+export declare const downloadRepository: (url: string) => Promise<AdmZip>;
+export declare const extractStarter: (zip: AdmZip, starterName: string, targetDirectory: string) => void;

package/dist/lib/repository.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractStarter = exports.downloadRepository = void 0;
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const debug_1 = require("./debug");
+const fetch_1 = require("./fetch");
+const downloadRepository = async (url) => {
+    const config = {
+        cache: 'no-cache',
+        method: 'GET',
+        mode: 'same-origin',
+        referrerPolicy: 'no-referrer',
+        responseType: 'arraybuffer',
+    };
+    let zip;
+    try {
+        const response = await (0, fetch_1.fetchOrThrow)(url, config);
+        const buffer = await response.arrayBuffer();
+        zip = new adm_zip_1.default(Buffer.from(buffer), {});
+    }
+    catch (error) {
+        if (error instanceof fetch_1.PlatformError) {
+            const errorMessage = await error.getErrorMessage();
+            throw new Error(errorMessage);
+        }
+        if ((0, debug_1.debugEnabled)()) {
+            console.error(JSON.stringify(error));
+        }
+        throw new Error('Internal error occurred, please contact your Quantum Hub administrator');
+    }
+    return zip;
+};
+exports.downloadRepository = downloadRepository;
+const extractStarter = (zip, starterName, targetDirectory) => {
+    const templateFolder = `${starterName}/`;
+    for (const entry of zip.getEntries()) {
+        if (!entry.isDirectory && entry.entryName.startsWith(templateFolder)) {
+            let destinationPath = targetDirectory;
+            // check if file is in sub-folder
+            if (entry.entryName.replace(templateFolder, '').includes('/')) {
+                const pathWithinFolder = entry.entryName.replace(templateFolder, '');
+                destinationPath = destinationPath + '/' + pathWithinFolder.slice(0, Math.max(0, pathWithinFolder.lastIndexOf('/')));
+            }
+            zip.extractEntryTo(entry.entryName, destinationPath, false, true);
+        }
+    }
+};
+exports.extractStarter = extractStarter;

package/dist/lib/stream-to-blob.d.ts

@@ -0,0 +1,2 @@
+import { ReadStream } from 'fs-extra';
+export declare const streamToBlob: (stream: ReadStream, mimeType?: string) => Promise<Blob>;

package/dist/lib/stream-to-blob.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamToBlob = void 0;
+const streamToBlob = (stream, mimeType) => {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on('data', (chunk) => {
+            // ReadStream can emit either string or Buffer, ensure we have Buffer
+            if (typeof chunk === 'string') {
+                chunks.push(Buffer.from(chunk));
+            }
+            else {
+                chunks.push(chunk);
+            }
+        });
+        stream.on('end', () => {
+            // Concatenate all chunks into a single Buffer, then convert to Blob
+            const buffer = Buffer.concat(chunks);
+            const blob = new Blob([buffer], { type: mimeType || 'application/octet-stream' });
+            resolve(blob);
+        });
+        stream.on('error', (error) => {
+            reject(error);
+        });
+    });
+};
+exports.streamToBlob = streamToBlob;

package/dist/lib/up/get-description.d.ts

@@ -0,0 +1 @@
+export declare function getDescriptionText(workingDirectory?: string): Promise<string>;

package/dist/lib/up/get-description.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDescriptionText = getDescriptionText;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function getDescriptionPath(workingDirectory = process.cwd()) {
+    const configPath = node_path_1.default.join(workingDirectory, 'qhub.json');
+    if (node_fs_1.default.existsSync(configPath)) {
+        const config = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+        if (config.descriptionFile) {
+            return node_path_1.default.join(workingDirectory, config.descriptionFile);
+        }
+        return '';
+    }
+    throw new Error('qhub.json file not found');
+}
+async function getDescriptionText(workingDirectory = process.cwd()) {
+    const descriptionPath = getDescriptionPath(workingDirectory);
+    if (descriptionPath) {
+        if (node_fs_1.default.existsSync(descriptionPath)) {
+            return node_fs_1.default.readFileSync(descriptionPath, 'utf8');
+        }
+        throw new Error('Provided "descriptionFile" was not found');
+    }
+    return '';
+}

package/dist/lib/up/ignore.d.ts

@@ -0,0 +1 @@
+export declare function createIgnoreFileChecker(filePath?: string): Promise<(fullPath: string) => boolean>;

package/dist/lib/up/ignore.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIgnoreFileChecker = createIgnoreFileChecker;
+const ignore_1 = __importDefault(require("ignore"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const readFile = (0, node_util_1.promisify)(node_fs_1.default.readFile);
+async function createIgnoreFileChecker(filePath = process.cwd()) {
+    const ignoreFilePath = node_path_1.default.join(filePath, '.dockerignore');
+    if (!node_fs_1.default.existsSync(ignoreFilePath)) {
+        return () => false;
+    }
+    const ignoreFileContents = await readFile(ignoreFilePath, 'utf8');
+    const ig = (0, ignore_1.default)().add(ignoreFileContents.split('\n'));
+    ig.add('service.zip');
+    return (fullPath) => ig.ignores(fullPath);
+}

package/dist/lib/up/zip.d.ts

@@ -0,0 +1 @@
+export declare function zipProjectFolder(workingDirectory?: string, targetDirectory?: string, targetFilename?: string): Promise<Blob>;

package/dist/lib/up/zip.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipProjectFolder = zipProjectFolder;
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const stream_to_blob_1 = require("../stream-to-blob");
+const ignore_1 = require("./ignore");
+async function zipProjectFolder(workingDirectory = process.cwd(), targetDirectory = (0, node_os_1.tmpdir)(), targetFilename = 'user_code.zip') {
+    const targetFilePath = node_path_1.default.join(targetDirectory, '/', targetFilename);
+    if (fs_extra_1.default.existsSync(targetFilePath)) {
+        fs_extra_1.default.unlinkSync(targetFilePath);
+    }
+    const zip = new adm_zip_1.default();
+    const ignoreFile = await (0, ignore_1.createIgnoreFileChecker)(workingDirectory);
+    function addToZip(folderPath) {
+        const files = fs_extra_1.default.readdirSync(folderPath);
+        for (const file of files) {
+            const fullPath = node_path_1.default.join(folderPath, file);
+            if (ignoreFile(fullPath)) {
+                continue;
+            }
+            const stat = fs_extra_1.default.statSync(fullPath);
+            if (stat.isDirectory()) {
+                addToZip(fullPath);
+            }
+            else {
+                zip.addLocalFile(fullPath, node_path_1.default.relative(workingDirectory, folderPath));
+            }
+        }
+    }
+    addToZip(workingDirectory);
+    zip.writeZip(targetFilePath);
+    const userCode = fs_extra_1.default.createReadStream(node_path_1.default.join(targetFilePath));
+    return (0, stream_to_blob_1.streamToBlob)(userCode);
+}

package/dist/model/account.d.ts

@@ -0,0 +1,5 @@
+export default interface Account {
+    displayName: string;
+    id: string;
+    isOrganization: boolean;
+}

package/dist/model/account.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/model/command.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+import { Config } from '@oclif/core/lib/config';
+import UserConfig from './user-config';
+export declare abstract class AbstractCommand extends Command {
+    userConfig: UserConfig;
+    constructor(argv: string[], config: Config);
+    protected showCustomBasePathWarning(): void;
+}
+export declare abstract class AuthenticatedCommand extends AbstractCommand {
+    getContextOutputString(userConfig: UserConfig): Promise<string>;
+    init(printContext?: boolean): Promise<void>;
+}

package/dist/model/command.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticatedCommand = exports.AbstractCommand = void 0;
+const core_1 = require("@oclif/core");
+const auth_service_1 = __importDefault(require("../service/auth-service"));
+const user_config_service_1 = require("../service/user-config-service");
+class AbstractCommand extends core_1.Command {
+    userConfig;
+    constructor(argv, config) {
+        super(argv, config);
+        this.userConfig = (0, user_config_service_1.readUserConfig)(this.config.configDir);
+    }
+    showCustomBasePathWarning() {
+        core_1.ux.warn(`Using custom base path. This is intended for internal development use only.`);
+        core_1.ux.stdout('');
+    }
+}
+exports.AbstractCommand = AbstractCommand;
+class AuthenticatedCommand extends AbstractCommand {
+    async getContextOutputString(userConfig) {
+        if (userConfig?.context) {
+            const type = userConfig.context.isOrganization ? 'Organization' : 'Personal';
+            return `${userConfig.context.displayName} (${type})`;
+        }
+        return 'No context set. Use "qhubctl set-context" to set a context.';
+    }
+    async init(printContext = true) {
+        await super.init();
+        if (!this.userConfig.auth) {
+            throw new Error('No credentials provided. Use the "login" command to log-in.');
+        }
+        if (this.userConfig.endpoint?.basePath) {
+            this.showCustomBasePathWarning();
+        }
+        const auth = new auth_service_1.default(this.userConfig);
+        try {
+            await auth.authenticate(this.userConfig.auth.value);
+        }
+        catch {
+            (0, user_config_service_1.writeUserConfig)(this.config.configDir, {
+                ...this.userConfig,
+                auth: undefined,
+                context: undefined,
+            });
+            throw new Error('Invalid credentials provided. Use the "login" command to log-in.');
+        }
+        if (printContext) {
+            core_1.ux.stdout('Current context: ' + await this.getContextOutputString(this.userConfig));
+        }
+    }
+}
+exports.AuthenticatedCommand = AuthenticatedCommand;

package/dist/model/managed-service-config.d.ts

@@ -0,0 +1,28 @@
+export default interface ManagedServiceConfig {
+    descriptionFile?: string;
+    name: string;
+    summary?: string;
+    resources?: ResourceConfiguration;
+    runtime?: Runtime;
+    serviceId?: string;
+}
+export declare enum Runtime {
+    DOCKER = "DOCKER",
+    PYTHON = "PYTHON",
+    PYTHON_TEMPLATE = "PYTHON_TEMPLATE"
+}
+export interface ResourceConfiguration {
+    cpu: number;
+    gpu?: GpuConfiguration;
+    memory: number;
+}
+export interface GpuConfiguration {
+    count: number;
+    type: GpuType;
+}
+export declare enum GpuType {
+    NVIDIA_TESLA_A100 = "NVIDIA_TESLA_A100",
+    NVIDIA_TESLA_P100 = "NVIDIA_TESLA_P100",
+    NVIDIA_TESLA_T4 = "NVIDIA_TESLA_T4",
+    NVIDIA_TESLA_V100 = "NVIDIA_TESLA_V100"
+}

package/dist/model/managed-service-config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GpuType = exports.Runtime = void 0;
+var Runtime;
+(function (Runtime) {
+    Runtime["DOCKER"] = "DOCKER";
+    Runtime["PYTHON"] = "PYTHON";
+    Runtime["PYTHON_TEMPLATE"] = "PYTHON_TEMPLATE";
+})(Runtime || (exports.Runtime = Runtime = {}));
+var GpuType;
+(function (GpuType) {
+    GpuType["NVIDIA_TESLA_A100"] = "NVIDIA_TESLA_A100";
+    GpuType["NVIDIA_TESLA_P100"] = "NVIDIA_TESLA_P100";
+    GpuType["NVIDIA_TESLA_T4"] = "NVIDIA_TESLA_T4";
+    GpuType["NVIDIA_TESLA_V100"] = "NVIDIA_TESLA_V100";
+})(GpuType || (exports.GpuType = GpuType = {}));

package/dist/model/user-config.d.ts

@@ -0,0 +1,22 @@
+export declare enum AuthType {
+    API_KEY = "API_KEY"
+}
+export interface Authentication {
+    type: AuthType;
+    value: string;
+}
+export interface Endpoint {
+    basePath: string;
+    defaultHeaders: Record<string, string>;
+}
+export interface Context {
+    displayName: string;
+    id: string;
+    isOrganization: boolean;
+}
+export declare const defaultBasePath = "https://api.hub.kipu-quantum.com";
+export default interface UserConfig {
+    auth?: Authentication;
+    context?: Context;
+    endpoint?: Endpoint;
+}