@metacall/protocol 0.1.26 → 0.1.28

package/dist/index.d.ts

@@ -3,7 +3,8 @@ export * from './language';
 export * from './login';
 export * from './package';
 export * from './plan';
+export * from './protocol';
+export * from './signup';
 export * from './token';
 import metacallAPI from './protocol';
-export * from './protocol';
 export default metacallAPI;

package/dist/index.js

@@ -18,7 +18,8 @@ __exportStar(require("./language"), exports);
 __exportStar(require("./login"), exports);
 __exportStar(require("./package"), exports);
 __exportStar(require("./plan"), exports);
+__exportStar(require("./protocol"), exports);
+__exportStar(require("./signup"), exports);
 __exportStar(require("./token"), exports);
 const protocol_1 = __importDefault(require("./protocol"));
-__exportStar(require("./protocol"), exports);
 exports.default = protocol_1.default;

package/dist/language.d.ts

@@ -1,13 +1,23 @@
 import { LanguageId } from './deployment';
+export declare type Runner = 'nodejs' | 'python' | 'ruby' | 'csharp';
+export interface RunnerInfo {
+    id: Runner;
+    languageId: LanguageId;
+    filePatterns: RegExp[];
+    installCommand: string;
+    displayName: string;
+}
+export declare const Runners: Record<Runner, RunnerInfo>;
 interface Language {
     tag: string;
     displayName: string;
     hexColor: string;
     fileExtRegex: RegExp;
-    runnerName?: string;
+    runnerName?: Runner;
     runnerFilesRegexes: RegExp[];
 }
 export declare const Languages: Record<LanguageId, Language>;
 export declare const DisplayNameToLanguageId: Record<string, LanguageId>;
 export declare const RunnerToDisplayName: (runner: string) => string;
+export declare const detectRunnersFromFiles: (files: string[]) => Runner[];
 export {};

package/dist/language.js

@@ -6,7 +6,38 @@
 
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnerToDisplayName = exports.DisplayNameToLanguageId = exports.Languages = void 0;
+exports.detectRunnersFromFiles = exports.RunnerToDisplayName = exports.DisplayNameToLanguageId = exports.Languages = exports.Runners = void 0;
+const path_1 = require("path");
+exports.Runners = {
+    nodejs: {
+        id: 'nodejs',
+        languageId: 'node',
+        filePatterns: [/^package\.json$/],
+        installCommand: 'npm install',
+        displayName: 'NPM'
+    },
+    python: {
+        id: 'python',
+        languageId: 'py',
+        filePatterns: [/^requirements\.txt$/],
+        installCommand: 'pip install -r requirements.txt',
+        displayName: 'Pip'
+    },
+    ruby: {
+        id: 'ruby',
+        languageId: 'rb',
+        filePatterns: [/^Gemfile$/],
+        installCommand: 'bundle install',
+        displayName: 'Gem'
+    },
+    csharp: {
+        id: 'csharp',
+        languageId: 'cs',
+        filePatterns: [/^project\.json$/, /\.csproj$/],
+        installCommand: 'dotnet restore',
+        displayName: 'NuGet'
+    }
+};
 exports.Languages = {
     cs: {
         tag: 'cs',
@@ -14,7 +45,7 @@ exports.Languages = {
         hexColor: '#953dac',
         fileExtRegex: /^cs$/,
         runnerName: 'csharp',
-        runnerFilesRegexes: [/^project\.json$/, /\.csproj$/]
+        runnerFilesRegexes: exports.Runners.csharp.filePatterns
     },
     py: {
         tag: 'py',
@@ -22,7 +53,7 @@ exports.Languages = {
         hexColor: '#ffd43b',
         fileExtRegex: /^py$/,
         runnerName: 'python',
-        runnerFilesRegexes: [/^requirements\.txt$/]
+        runnerFilesRegexes: exports.Runners.python.filePatterns
     },
     rb: {
         tag: 'rb',
@@ -30,7 +61,7 @@ exports.Languages = {
         hexColor: '#e53935',
         fileExtRegex: /^rb$/,
         runnerName: 'ruby',
-        runnerFilesRegexes: [/^Gemfile$/]
+        runnerFilesRegexes: exports.Runners.ruby.filePatterns
     },
     node: {
         tag: 'node',
@@ -38,7 +69,7 @@ exports.Languages = {
         hexColor: '#3c873a',
         fileExtRegex: /^js$/,
         runnerName: 'nodejs',
-        runnerFilesRegexes: [/^package\.json$/]
+        runnerFilesRegexes: exports.Runners.nodejs.filePatterns
     },
     ts: {
         tag: 'ts',
@@ -46,7 +77,7 @@ exports.Languages = {
         hexColor: '#007acc',
         fileExtRegex: /^(ts|tsx)$/,
         runnerName: 'nodejs',
-        runnerFilesRegexes: [/^package\.json$/] // TODO: Use tsconfig instead?
+        runnerFilesRegexes: exports.Runners.nodejs.filePatterns
     },
     file: {
         tag: 'file',
@@ -77,12 +108,23 @@ exports.DisplayNameToLanguageId = Object.keys(exports.Languages).reduce((obj, la
     [exports.Languages[lang].displayName]: lang
 }), {});
 const RunnerToDisplayName = (runner) => {
-    const displayNameMap = {
-        nodejs: 'NPM',
-        python: 'Pip',
-        ruby: 'Gem',
-        csharp: 'NuGet'
-    };
-    return displayNameMap[runner] || 'Build';
+    const match = exports.Runners[runner];
+    return match ? match.displayName : 'Build';
 };
 exports.RunnerToDisplayName = RunnerToDisplayName;
+const detectRunnersFromFiles = (files) => {
+    const runners = new Set();
+    for (const file of files) {
+        const fileName = path_1.basename(file);
+        for (const runner of Object.values(exports.Runners)) {
+            for (const pattern of runner.filePatterns) {
+                if (pattern.exec(fileName)) {
+                    runners.add(runner.id);
+                    break;
+                }
+            }
+        }
+    }
+    return Array.from(runners);
+};
+exports.detectRunnersFromFiles = detectRunnersFromFiles;

package/dist/package.d.ts

@@ -1,8 +1,10 @@
 import { MetaCallJSON } from './deployment';
+import { Runner } from './language';
 export declare const findFilesPath: (path?: string, ignoreFiles?: string[]) => Promise<string[]>;
 export declare const pathIsMetaCallJson: (path: string) => boolean;
 export declare const findMetaCallJsons: (files: string[]) => string[];
-export declare const findRunners: (files: string[]) => Set<string>;
+export declare const findRunners: (files: string[]) => Set<Runner>;
+export declare const detectRunners: (path?: string, ignoreFiles?: string[]) => Promise<Runner[]>;
 export declare enum PackageError {
     Empty = "No files found in the current folder",
     JsonNotFound = "No metacall.json found in the current folder",
@@ -12,7 +14,7 @@ interface PackageDescriptor {
     error: PackageError;
     files: string[];
     jsons: string[];
-    runners: string[];
+    runners: Runner[];
 }
 export declare const generatePackage: (path?: string) => Promise<PackageDescriptor>;
 export declare const generateJsonsFromFiles: (files: string[]) => MetaCallJSON[];

package/dist/package.js

@@ -16,7 +16,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateJsonsFromFiles = exports.generatePackage = exports.PackageError = exports.findRunners = exports.findMetaCallJsons = exports.pathIsMetaCallJson = exports.findFilesPath = void 0;
+exports.generateJsonsFromFiles = exports.generatePackage = exports.PackageError = exports.detectRunners = exports.findRunners = exports.findMetaCallJsons = exports.pathIsMetaCallJson = exports.findFilesPath = void 0;
 const ignore_walk_1 = __importDefault(require("ignore-walk"));
 const path_1 = require("path");
 const language_1 = require("./language");
@@ -31,22 +31,10 @@ const pathIsMetaCallJson = (path) => !!/^metacall(-.+)?\.json$/.exec(path_1.base
 exports.pathIsMetaCallJson = pathIsMetaCallJson;
 const findMetaCallJsons = (files) => files.filter(exports.pathIsMetaCallJson);
 exports.findMetaCallJsons = findMetaCallJsons;
-const findRunners = (files) => {
-    const runners = new Set();
-    for (const file of files) {
-        const fileName = path_1.basename(file);
-        for (const langId of Object.keys(language_1.Languages)) {
-            const lang = language_1.Languages[langId];
-            for (const re of lang.runnerFilesRegexes) {
-                if (re.exec(fileName) && lang.runnerName) {
-                    runners.add(lang.runnerName);
-                }
-            }
-        }
-    }
-    return runners;
-};
+const findRunners = (files) => new Set(language_1.detectRunnersFromFiles(files));
 exports.findRunners = findRunners;
+const detectRunners = async (path = process.cwd(), ignoreFiles = ['.gitignore']) => language_1.detectRunnersFromFiles(await exports.findFilesPath(path, ignoreFiles));
+exports.detectRunners = detectRunners;
 var PackageError;
 (function (PackageError) {
     PackageError["Empty"] = "No files found in the current folder";

package/dist/protocol.d.ts

@@ -1,6 +1,11 @@
 import { AxiosError } from 'axios';
 import { Create, Deployment, LogType, MetaCallJSON } from './deployment';
 import { Plans } from './plan';
+/**
+ * Type guard for protocol-specific errors (Axios errors in this case).
+ * @param err - The unknown error to check.
+ * @returns True if the error is an ProtocolError, false otherwise.
+ */
 export declare const isProtocolError: (err: unknown) => boolean;
 export { AxiosError as ProtocolError };
 declare type SubscriptionMap = Record<string, number>;
@@ -20,13 +25,47 @@ export interface AddResponse {
 export interface Branches {
     branches: [string];
 }
+export declare enum InvokeType {
+    Call = "call",
+    Await = "await"
+}
+export interface DeployCreateRequest {
+    suffix: string;
+    resourceType: ResourceType;
+    release: string;
+    env: {
+        name: string;
+        value: string;
+    }[];
+    plan: Plans;
+    version: string;
+}
+export interface DeployDeleteRequest {
+    prefix: string;
+    suffix: string;
+    version: string;
+}
+export interface RepositoryAddRequest {
+    url: string;
+    branch: string;
+    jsons: MetaCallJSON[];
+}
+export interface RepositoryBranchListRequest {
+    url: string;
+}
+export interface RepositoryFileListRequest {
+    url: string;
+    branch: string;
+}
 export interface API {
     refresh(): Promise<string>;
+    ready(): Promise<boolean>;
     validate(): Promise<boolean>;
     deployEnabled(): Promise<boolean>;
     listSubscriptions(): Promise<SubscriptionMap>;
     listSubscriptionsDeploys(): Promise<SubscriptionDeploy[]>;
     inspect(): Promise<Deployment[]>;
+    inspectByName(suffix: string): Promise<Deployment>;
     upload(name: string, blob: unknown, jsons?: MetaCallJSON[], runners?: string[]): Promise<string>;
     add(url: string, branch: string, jsons: MetaCallJSON[]): Promise<AddResponse>;
     deploy(name: string, env: {
@@ -37,6 +76,50 @@ export interface API {
     logs(container: string, type: LogType, suffix: string, prefix: string, version?: string): Promise<string>;
     branchList(url: string): Promise<Branches>;
     fileList(url: string, branch: string): Promise<string[]>;
+    invoke<Result, Args = unknown>(type: InvokeType, prefix: string, suffix: string, version: string, name: string, args?: Args): Promise<Result>;
+    call<Result, Args = unknown>(prefix: string, suffix: string, version: string, name: string, args?: Args): Promise<Result>;
+    await<Result, Args = unknown>(prefix: string, suffix: string, version: string, name: string, args?: Args): Promise<Result>;
 }
 declare const _default: (token: string, baseURL: string) => API;
 export default _default;
+export declare const MaxRetries = 30;
+export declare const MaxRetryInterval = 2000;
+export declare const MaxFuncLength = 64;
+/**
+ * Executes an asynchronous function with automatic retry logic.
+ *
+ * The function will be retried up to `maxRetries` times, waiting `interval`
+ * milliseconds between each attempt. If all retries fail, the last error is
+ * wrapped in a new `Error` with a descriptive message, including:
+ * - Function name (or string representation truncated to `MaxFuncLength` chars if anonymous)
+ * - Number of retries attempted
+ * - Original error message
+ *
+ * Error handling is fully type-safe:
+ * - If the error is an ProtocolError (checked via `isProtocolError`), its
+ *   message is used.
+ * - If the error is a standard `Error`, its `message` is used.
+ * - Otherwise, the error is converted to a string.
+ *
+ * @typeParam T - The return type of the function being retried.
+ * @param fn - A lambda or bound function returning a `Promise<T>`. The
+ *             function should contain the logic you want to retry.
+ * @param maxRetries - Maximum number of retry attempts. Default: `MaxRetries`.
+ * @param interval - Delay between retries in milliseconds. Default: `MaxRetryInterval`.
+ * @returns A `Promise` resolving to the return value of `fn` if successful.
+ * @throws Error If all retry attempts fail, throws a new Error containing
+ *                 information about the function and the last error.
+ *
+ * @example
+ * ```ts
+ * const deployment = await waitFor(() => api.inspectByName('my-suffix'));
+ * ```
+ *
+ * @example
+ * ```ts
+ * const result = await waitFor(
+ *   () => api.deploy(name, env, plan, resourceType)
+ * );
+ * ```
+ */
+export declare const waitFor: <T>(fn: () => Promise<T>, maxRetries?: number, interval?: number) => Promise<T>;

package/dist/protocol.js

@@ -18,14 +18,40 @@
     branchList: get the branches of a repository
     fileList: get files of a repository by branch
 */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceType = exports.isProtocolError = void 0;
-const axios_1 = __importDefault(require("axios"));
+exports.waitFor = exports.MaxFuncLength = exports.MaxRetryInterval = exports.MaxRetries = exports.InvokeType = exports.ResourceType = exports.ProtocolError = exports.isProtocolError = void 0;
+const axios_1 = __importStar(require("axios"));
+Object.defineProperty(exports, "ProtocolError", { enumerable: true, get: function () { return axios_1.AxiosError; } });
 const form_data_1 = __importDefault(require("form-data"));
+const url_1 = require("url");
 const deployment_1 = require("./deployment");
+/**
+ * Type guard for protocol-specific errors (Axios errors in this case).
+ * @param err - The unknown error to check.
+ * @returns True if the error is an ProtocolError, false otherwise.
+ */
 const isProtocolError = (err) => axios_1.default.isAxiosError(err);
 exports.isProtocolError = isProtocolError;
 var ResourceType;
@@ -33,27 +59,36 @@ var ResourceType;
     ResourceType["Package"] = "Package";
     ResourceType["Repository"] = "Repository";
 })(ResourceType = exports.ResourceType || (exports.ResourceType = {}));
+var InvokeType;
+(function (InvokeType) {
+    InvokeType["Call"] = "call";
+    InvokeType["Await"] = "await";
+})(InvokeType = exports.InvokeType || (exports.InvokeType = {}));
 exports.default = (token, baseURL) => {
+    const getURL = (path) => new url_1.URL(path, baseURL).toString();
+    const getConfig = (headers = {}) => {
+        return {
+            headers: {
+                Authorization: 'jwt ' + token,
+                ...headers
+            }
+        };
+    };
     const api = {
         refresh: () => axios_1.default
-            .get(baseURL + '/api/account/refresh-token', {
-            headers: { Authorization: 'jwt ' + token }
-        })
+            .get(getURL('/api/account/refresh-token'), getConfig())
             .then(res => res.data),
+        ready: () => axios_1.default
+            .get(getURL('/api/readiness'), getConfig())
+            .then(res => res.status == 200),
         validate: () => axios_1.default
-            .get(baseURL + '/validate', {
-            headers: { Authorization: 'jwt ' + token }
-        })
+            .get(getURL('/validate'), getConfig())
             .then(res => res.data),
         deployEnabled: () => axios_1.default
-            .get(baseURL + '/api/account/deploy-enabled', {
-            headers: { Authorization: 'jwt ' + token }
-        })
+            .get(getURL('/api/account/deploy-enabled'), getConfig())
             .then(res => res.data),
         listSubscriptions: async () => {
-            const res = await axios_1.default.get(baseURL + '/api/billing/list-subscriptions', {
-                headers: { Authorization: 'jwt ' + token }
-            });
+            const res = await axios_1.default.get(getURL('/api/billing/list-subscriptions'), getConfig());
             const subscriptions = {};
             for (const id of res.data) {
                 if (subscriptions[id] === undefined) {
@@ -65,18 +100,21 @@ exports.default = (token, baseURL) => {
             }
             return subscriptions;
         },
-        listSubscriptionsDeploys: async () => axios_1.default
-            .get(baseURL + '/api/billing/list-subscriptions-deploys', {
-            headers: { Authorization: 'jwt ' + token }
-        })
+        listSubscriptionsDeploys: () => axios_1.default
+            .get(getURL('/api/billing/list-subscriptions-deploys'), getConfig())
             .then(res => res.data),
-        inspect: async () => axios_1.default
-            .get(baseURL + '/api/inspect', {
-            headers: { Authorization: 'jwt ' + token }
-        })
+        inspect: () => axios_1.default
+            .get(getURL('/api/inspect'), getConfig())
             .then(res => res.data),
+        inspectByName: async (suffix) => {
+            const deployments = await api.inspect();
+            const deploy = deployments.find(deploy => deploy.suffix == suffix);
+            if (!deploy) {
+                throw new Error(`Deployment with suffix '${suffix}' not found`);
+            }
+            return deploy;
+        },
         upload: async (name, blob, jsons = [], runners = []) => {
-            var _a, _b;
             const fd = new form_data_1.default();
             fd.append('id', name);
             fd.append('type', 'application/x-zip-compressed');
@@ -86,70 +124,130 @@ exports.default = (token, baseURL) => {
                 filename: 'blob',
                 contentType: 'application/x-zip-compressed'
             });
-            const res = await axios_1.default.post(baseURL + '/api/package/create', fd, {
-                headers: {
-                    Authorization: 'jwt ' + token,
-                    ...((_b = (_a = fd.getHeaders) === null || _a === void 0 ? void 0 : _a.call(fd)) !== null && _b !== void 0 ? _b : {}) // operator chaining to make it compatible with frontend
-                }
-            });
+            const res = await axios_1.default.post(getURL('/api/package/create'), fd, getConfig() // Axios automatically sets multipart headers
+            );
             return res.data;
         },
         add: (url, branch, jsons = []) => axios_1.default
-            .post(baseURL + '/api/repository/add', {
+            .post(getURL('/api/repository/add'), {
             url,
             branch,
             jsons
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
-            .then((res) => res.data),
+        }, getConfig())
+            .then(res => res.data),
         branchList: (url) => axios_1.default
-            .post(baseURL + '/api/repository/branchlist', {
+            .post(getURL('/api/repository/branchlist'), {
             url
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
-            .then((res) => res.data),
+        }, getConfig())
+            .then(res => res.data),
         deploy: (name, env, plan, resourceType, release = Date.now().toString(16), version = 'v1') => axios_1.default
-            .post(baseURL + '/api/deploy/create', {
+            .post(getURL('/api/deploy/create'), {
             resourceType,
             suffix: name,
             release,
             env,
             plan,
             version
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
+        }, getConfig())
             .then(res => res.data),
         deployDelete: (prefix, suffix, version = 'v1') => axios_1.default
-            .post(baseURL + '/api/deploy/delete', {
+            .post(getURL('/api/deploy/delete'), {
             prefix,
             suffix,
             version
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
+        }, getConfig())
             .then(res => res.data),
         logs: (container, type = deployment_1.LogType.Deploy, suffix, prefix, version = 'v1') => axios_1.default
-            .post(baseURL + '/api/deploy/logs', {
+            .post(getURL('/api/deploy/logs'), {
             container,
             type,
             suffix,
             prefix,
             version
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
+        }, getConfig())
             .then(res => res.data),
         fileList: (url, branch) => axios_1.default
-            .post(baseURL + '/api/repository/filelist', {
+            .post(getURL('/api/repository/filelist'), {
             url,
             branch
-        }, {
-            headers: { Authorization: 'jwt ' + token }
-        })
-            .then(res => res.data['files'])
+        }, getConfig())
+            .then(res => res.data['files']),
+        invoke: (type, prefix, suffix, version = 'v1', name, args) => {
+            const url = getURL(`/${prefix}/${suffix}/${version}/${type}/${name}`);
+            const config = getConfig();
+            const req = args === undefined
+                ? axios_1.default.get(url, config)
+                : axios_1.default.post(url, args, config);
+            return req.then(res => res.data);
+        },
+        call: (prefix, suffix, version = 'v1', name, args) => api.invoke(InvokeType.Call, prefix, suffix, version, name, args),
+        await: (prefix, suffix, version = 'v1', name, args) => api.invoke(InvokeType.Await, prefix, suffix, version, name, args)
     };
     return api;
 };
+exports.MaxRetries = 30;
+exports.MaxRetryInterval = 2000;
+exports.MaxFuncLength = 64;
+/**
+ * Executes an asynchronous function with automatic retry logic.
+ *
+ * The function will be retried up to `maxRetries` times, waiting `interval`
+ * milliseconds between each attempt. If all retries fail, the last error is
+ * wrapped in a new `Error` with a descriptive message, including:
+ * - Function name (or string representation truncated to `MaxFuncLength` chars if anonymous)
+ * - Number of retries attempted
+ * - Original error message
+ *
+ * Error handling is fully type-safe:
+ * - If the error is an ProtocolError (checked via `isProtocolError`), its
+ *   message is used.
+ * - If the error is a standard `Error`, its `message` is used.
+ * - Otherwise, the error is converted to a string.
+ *
+ * @typeParam T - The return type of the function being retried.
+ * @param fn - A lambda or bound function returning a `Promise<T>`. The
+ *             function should contain the logic you want to retry.
+ * @param maxRetries - Maximum number of retry attempts. Default: `MaxRetries`.
+ * @param interval - Delay between retries in milliseconds. Default: `MaxRetryInterval`.
+ * @returns A `Promise` resolving to the return value of `fn` if successful.
+ * @throws Error If all retry attempts fail, throws a new Error containing
+ *                 information about the function and the last error.
+ *
+ * @example
+ * ```ts
+ * const deployment = await waitFor(() => api.inspectByName('my-suffix'));
+ * ```
+ *
+ * @example
+ * ```ts
+ * const result = await waitFor(
+ *   () => api.deploy(name, env, plan, resourceType)
+ * );
+ * ```
+ */
+const waitFor = async (fn, maxRetries = exports.MaxRetries, interval = exports.MaxRetryInterval) => {
+    let retry = 0;
+    for (;;) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            retry++;
+            if (retry >= maxRetries) {
+                const fnStr = fn.toString();
+                const func = fn.name ||
+                    (fnStr.length > exports.MaxFuncLength
+                        ? fnStr.slice(0, exports.MaxFuncLength) + '...'
+                        : fnStr);
+                const message = exports.isProtocolError(error)
+                    ? error.message
+                    : error instanceof Error
+                        ? error.message
+                        : String(error);
+                throw new Error(`Failed to execute '${func}' after ${maxRetries} retries: ${message}`);
+            }
+            await new Promise(r => setTimeout(r, interval));
+        }
+    }
+};
+exports.waitFor = waitFor;

package/dist/token.js

@@ -11,6 +11,6 @@ const expiresIn = (token) => {
         return 0;
     }
     const now = Date.now() / 1000;
-    return new Date(((decoded === null || decoded === void 0 ? void 0 : decoded['exp']) || now) * 1000).getTime() - now * 1000;
+    return new Date((decoded?.['exp'] || now) * 1000).getTime() - now * 1000;
 };
 exports.expiresIn = expiresIn;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@metacall/protocol",
-	"version": "0.1.26",
+	"version": "0.1.28",
 	"description": "Tool for deploying into MetaCall FaaS platform.",
 	"exports": {
 		"./*": "./dist/*.js",
@@ -85,7 +85,7 @@
 		}
 	},
 	"dependencies": {
-		"axios": "^0.21.0",
+		"axios": "^1.13.5",
 		"form-data": "^3.0.0",
 		"ignore-walk": "^3.0.4",
 		"jsonwebtoken": "^9.0.0"
@@ -111,4 +111,4 @@
 		"typescript": "4.3.2",
 		"yamljs": "^0.3.0"
 	}
-}
+}

package/src/index.ts

@@ -3,7 +3,9 @@ export * from './language';
 export * from './login';
 export * from './package';
 export * from './plan';
+export * from './protocol';
+export * from './signup';
 export * from './token';
+
 import metacallAPI from './protocol';
-export * from './protocol';
 export default metacallAPI;

package/src/language.ts

@@ -5,14 +5,56 @@
 
 */
 
+import { basename } from 'path';
 import { LanguageId } from './deployment';
 
+export type Runner = 'nodejs' | 'python' | 'ruby' | 'csharp';
+
+export interface RunnerInfo {
+	id: Runner;
+	languageId: LanguageId;
+	filePatterns: RegExp[];
+	installCommand: string;
+	displayName: string;
+}
+
+export const Runners: Record<Runner, RunnerInfo> = {
+	nodejs: {
+		id: 'nodejs',
+		languageId: 'node',
+		filePatterns: [/^package\.json$/],
+		installCommand: 'npm install',
+		displayName: 'NPM'
+	},
+	python: {
+		id: 'python',
+		languageId: 'py',
+		filePatterns: [/^requirements\.txt$/],
+		installCommand: 'pip install -r requirements.txt',
+		displayName: 'Pip'
+	},
+	ruby: {
+		id: 'ruby',
+		languageId: 'rb',
+		filePatterns: [/^Gemfile$/],
+		installCommand: 'bundle install',
+		displayName: 'Gem'
+	},
+	csharp: {
+		id: 'csharp',
+		languageId: 'cs',
+		filePatterns: [/^project\.json$/, /\.csproj$/],
+		installCommand: 'dotnet restore',
+		displayName: 'NuGet'
+	}
+};
+
 interface Language {
 	tag: string; // Tag which corresponds to language_id in metacall.json
 	displayName: string; // Name for displaying the language
 	hexColor: string; // Color for displaying the language related things
 	fileExtRegex: RegExp; // Regex for selecting the metacall.json scripts field
-	runnerName?: string; // Id of the runner
+	runnerName?: Runner; // Id of the runner
 	runnerFilesRegexes: RegExp[]; // Regex for generating the runners list
 }
 
@@ -23,7 +65,7 @@ export const Languages: Record<LanguageId, Language> = {
 		hexColor: '#953dac',
 		fileExtRegex: /^cs$/,
 		runnerName: 'csharp',
-		runnerFilesRegexes: [/^project\.json$/, /\.csproj$/]
+		runnerFilesRegexes: Runners.csharp.filePatterns
 	},
 	py: {
 		tag: 'py',
@@ -31,7 +73,7 @@ export const Languages: Record<LanguageId, Language> = {
 		hexColor: '#ffd43b',
 		fileExtRegex: /^py$/,
 		runnerName: 'python',
-		runnerFilesRegexes: [/^requirements\.txt$/]
+		runnerFilesRegexes: Runners.python.filePatterns
 	},
 	rb: {
 		tag: 'rb',
@@ -39,7 +81,7 @@ export const Languages: Record<LanguageId, Language> = {
 		hexColor: '#e53935',
 		fileExtRegex: /^rb$/,
 		runnerName: 'ruby',
-		runnerFilesRegexes: [/^Gemfile$/]
+		runnerFilesRegexes: Runners.ruby.filePatterns
 	},
 	node: {
 		tag: 'node',
@@ -47,7 +89,7 @@ export const Languages: Record<LanguageId, Language> = {
 		hexColor: '#3c873a',
 		fileExtRegex: /^js$/,
 		runnerName: 'nodejs',
-		runnerFilesRegexes: [/^package\.json$/]
+		runnerFilesRegexes: Runners.nodejs.filePatterns
 	},
 	ts: {
 		tag: 'ts',
@@ -55,7 +97,7 @@ export const Languages: Record<LanguageId, Language> = {
 		hexColor: '#007acc',
 		fileExtRegex: /^(ts|tsx)$/,
 		runnerName: 'nodejs',
-		runnerFilesRegexes: [/^package\.json$/] // TODO: Use tsconfig instead?
+		runnerFilesRegexes: Runners.nodejs.filePatterns
 	},
 	file: {
 		tag: 'file',
@@ -94,12 +136,26 @@ export const DisplayNameToLanguageId: Record<string, LanguageId> = Object.keys(
 );
 
 export const RunnerToDisplayName = (runner: string): string => {
-	const displayNameMap: Record<string, string> = {
-		nodejs: 'NPM',
-		python: 'Pip',
-		ruby: 'Gem',
-		csharp: 'NuGet'
-	};
+	const match = Runners[runner as Runner];
+
+	return match ? match.displayName : 'Build';
+};
+
+export const detectRunnersFromFiles = (files: string[]): Runner[] => {
+	const runners = new Set<Runner>();
+
+	for (const file of files) {
+		const fileName = basename(file);
+
+		for (const runner of Object.values(Runners)) {
+			for (const pattern of runner.filePatterns) {
+				if (pattern.exec(fileName)) {
+					runners.add(runner.id);
+					break;
+				}
+			}
+		}
+	}
 
-	return displayNameMap[runner] || 'Build';
+	return Array.from(runners);
 };

package/src/package.ts

@@ -15,7 +15,7 @@
 import walk from 'ignore-walk';
 import { basename, extname } from 'path';
 import { LanguageId, MetaCallJSON } from './deployment';
-import { Languages } from './language';
+import { detectRunnersFromFiles, Languages, Runner } from './language';
 
 export const findFilesPath = async (
 	path: string = process.cwd(),
@@ -36,23 +36,14 @@ export const pathIsMetaCallJson = (path: string): boolean =>
 export const findMetaCallJsons = (files: string[]): string[] =>
 	files.filter(pathIsMetaCallJson);
 
-export const findRunners = (files: string[]): Set<string> => {
-	const runners: Set<string> = new Set<string>();
-
-	for (const file of files) {
-		const fileName = basename(file);
-		for (const langId of Object.keys(Languages)) {
-			const lang = Languages[langId as LanguageId];
-			for (const re of lang.runnerFilesRegexes) {
-				if (re.exec(fileName) && lang.runnerName) {
-					runners.add(lang.runnerName);
-				}
-			}
-		}
-	}
+export const findRunners = (files: string[]): Set<Runner> =>
+	new Set<Runner>(detectRunnersFromFiles(files));
 
-	return runners;
-};
+export const detectRunners = async (
+	path: string = process.cwd(),
+	ignoreFiles: string[] = ['.gitignore']
+): Promise<Runner[]> =>
+	detectRunnersFromFiles(await findFilesPath(path, ignoreFiles));
 
 export enum PackageError {
 	Empty = 'No files found in the current folder',
@@ -64,7 +55,7 @@ interface PackageDescriptor {
 	error: PackageError;
 	files: string[];
 	jsons: string[];
-	runners: string[];
+	runners: Runner[];
 }
 
 const NullPackage: PackageDescriptor = {

package/src/protocol.ts

@@ -18,11 +18,18 @@
 	fileList: get files of a repository by branch
 */
 
-import axios, { AxiosError, AxiosResponse } from 'axios';
+import axios, { AxiosError, AxiosRequestConfig } from 'axios';
 import FormData from 'form-data';
+import { URL } from 'url';
 import { Create, Deployment, LogType, MetaCallJSON } from './deployment';
 import { Plans } from './plan';
+import { ProtocolError } from './protocol';
 
+/**
+ * Type guard for protocol-specific errors (Axios errors in this case).
+ * @param err - The unknown error to check.
+ * @returns True if the error is an ProtocolError, false otherwise.
+ */
 export const isProtocolError = (err: unknown): boolean =>
 	axios.isAxiosError(err);
 
@@ -50,13 +57,50 @@ export interface Branches {
 	branches: [string];
 }
 
+export enum InvokeType {
+	Call = 'call',
+	Await = 'await'
+}
+
+export interface DeployCreateRequest {
+	suffix: string;
+	resourceType: ResourceType;
+	release: string;
+	env: { name: string; value: string }[];
+	plan: Plans;
+	version: string;
+}
+
+export interface DeployDeleteRequest {
+	prefix: string;
+	suffix: string;
+	version: string;
+}
+
+export interface RepositoryAddRequest {
+	url: string;
+	branch: string;
+	jsons: MetaCallJSON[];
+}
+
+export interface RepositoryBranchListRequest {
+	url: string;
+}
+
+export interface RepositoryFileListRequest {
+	url: string;
+	branch: string;
+}
+
 export interface API {
 	refresh(): Promise<string>;
+	ready(): Promise<boolean>;
 	validate(): Promise<boolean>;
 	deployEnabled(): Promise<boolean>;
 	listSubscriptions(): Promise<SubscriptionMap>;
 	listSubscriptionsDeploys(): Promise<SubscriptionDeploy[]>;
 	inspect(): Promise<Deployment[]>;
+	inspectByName(suffix: string): Promise<Deployment>;
 	upload(
 		name: string,
 		blob: unknown,
@@ -90,37 +134,69 @@ export interface API {
 	): Promise<string>;
 	branchList(url: string): Promise<Branches>;
 	fileList(url: string, branch: string): Promise<string[]>;
+	invoke<Result, Args = unknown>(
+		type: InvokeType,
+		prefix: string,
+		suffix: string,
+		version: string,
+		name: string,
+		args?: Args
+	): Promise<Result>;
+	call<Result, Args = unknown>(
+		prefix: string,
+		suffix: string,
+		version: string,
+		name: string,
+		args?: Args
+	): Promise<Result>;
+	await<Result, Args = unknown>(
+		prefix: string,
+		suffix: string,
+		version: string,
+		name: string,
+		args?: Args
+	): Promise<Result>;
 }
 
 export default (token: string, baseURL: string): API => {
+	const getURL = (path: string): string => new URL(path, baseURL).toString();
+	const getConfig = (headers = {}): AxiosRequestConfig => {
+		return {
+			headers: {
+				Authorization: 'jwt ' + token,
+				...headers
+			}
+		};
+	};
+
 	const api: API = {
 		refresh: (): Promise<string> =>
 			axios
-				.get<string>(baseURL + '/api/account/refresh-token', {
-					headers: { Authorization: 'jwt ' + token }
-				})
+				.get<string>(getURL('/api/account/refresh-token'), getConfig())
 				.then(res => res.data),
 
+		ready: (): Promise<boolean> =>
+			axios
+				.get<boolean>(getURL('/api/readiness'), getConfig())
+				.then(res => res.status == 200),
+
 		validate: (): Promise<boolean> =>
 			axios
-				.get<boolean>(baseURL + '/validate', {
-					headers: { Authorization: 'jwt ' + token }
-				})
+				.get<boolean>(getURL('/validate'), getConfig())
 				.then(res => res.data),
 
 		deployEnabled: (): Promise<boolean> =>
 			axios
-				.get<boolean>(baseURL + '/api/account/deploy-enabled', {
-					headers: { Authorization: 'jwt ' + token }
-				})
+				.get<boolean>(
+					getURL('/api/account/deploy-enabled'),
+					getConfig()
+				)
 				.then(res => res.data),
 
 		listSubscriptions: async (): Promise<SubscriptionMap> => {
 			const res = await axios.get<string[]>(
-				baseURL + '/api/billing/list-subscriptions',
-				{
-					headers: { Authorization: 'jwt ' + token }
-				}
+				getURL('/api/billing/list-subscriptions'),
+				getConfig()
 			);
 
 			const subscriptions: SubscriptionMap = {};
@@ -136,23 +212,31 @@ export default (token: string, baseURL: string): API => {
 			return subscriptions;
 		},
 
-		listSubscriptionsDeploys: async (): Promise<SubscriptionDeploy[]> =>
+		listSubscriptionsDeploys: (): Promise<SubscriptionDeploy[]> =>
 			axios
 				.get<SubscriptionDeploy[]>(
-					baseURL + '/api/billing/list-subscriptions-deploys',
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getURL('/api/billing/list-subscriptions-deploys'),
+					getConfig()
 				)
 				.then(res => res.data),
 
-		inspect: async (): Promise<Deployment[]> =>
+		inspect: (): Promise<Deployment[]> =>
 			axios
-				.get<Deployment[]>(baseURL + '/api/inspect', {
-					headers: { Authorization: 'jwt ' + token }
-				})
+				.get<Deployment[]>(getURL('/api/inspect'), getConfig())
 				.then(res => res.data),
 
+		inspectByName: async (suffix: string): Promise<Deployment> => {
+			const deployments = await api.inspect();
+
+			const deploy = deployments.find(deploy => deploy.suffix == suffix);
+
+			if (!deploy) {
+				throw new Error(`Deployment with suffix '${suffix}' not found`);
+			}
+
+			return deploy;
+		},
+
 		upload: async (
 			name: string,
 			blob: unknown,
@@ -169,14 +253,9 @@ export default (token: string, baseURL: string): API => {
 				contentType: 'application/x-zip-compressed'
 			});
 			const res = await axios.post<string>(
-				baseURL + '/api/package/create',
+				getURL('/api/package/create'),
 				fd,
-				{
-					headers: {
-						Authorization: 'jwt ' + token,
-						...(fd.getHeaders?.() ?? {}) // operator chaining to make it compatible with frontend
-					}
-				}
+				getConfig() // Axios automatically sets multipart headers
 			);
 			return res.data;
 		},
@@ -186,30 +265,26 @@ export default (token: string, baseURL: string): API => {
 			jsons: MetaCallJSON[] = []
 		): Promise<AddResponse> =>
 			axios
-				.post<string>(
-					baseURL + '/api/repository/add',
+				.post<AddResponse>(
+					getURL('/api/repository/add'),
 					{
 						url,
 						branch,
 						jsons
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
-				.then((res: AxiosResponse) => res.data as AddResponse),
+				.then(res => res.data),
 		branchList: (url: string): Promise<Branches> =>
 			axios
-				.post<string>(
-					baseURL + '/api/repository/branchlist',
+				.post<Branches>(
+					getURL('/api/repository/branchlist'),
 					{
 						url
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
-				.then((res: AxiosResponse) => res.data as Branches),
+				.then(res => res.data),
 
 		deploy: (
 			name: string,
@@ -221,7 +296,7 @@ export default (token: string, baseURL: string): API => {
 		): Promise<Create> =>
 			axios
 				.post<Create>(
-					baseURL + '/api/deploy/create',
+					getURL('/api/deploy/create'),
 					{
 						resourceType,
 						suffix: name,
@@ -230,9 +305,7 @@ export default (token: string, baseURL: string): API => {
 						plan,
 						version
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
 				.then(res => res.data),
 
@@ -243,15 +316,13 @@ export default (token: string, baseURL: string): API => {
 		): Promise<string> =>
 			axios
 				.post<string>(
-					baseURL + '/api/deploy/delete',
+					getURL('/api/deploy/delete'),
 					{
 						prefix,
 						suffix,
 						version
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
 				.then(res => res.data),
 
@@ -264,7 +335,7 @@ export default (token: string, baseURL: string): API => {
 		): Promise<string> =>
 			axios
 				.post<string>(
-					baseURL + '/api/deploy/logs',
+					getURL('/api/deploy/logs'),
 					{
 						container,
 						type,
@@ -272,26 +343,137 @@ export default (token: string, baseURL: string): API => {
 						prefix,
 						version
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
 				.then(res => res.data),
 
 		fileList: (url: string, branch: string): Promise<string[]> =>
 			axios
 				.post<{ [k: string]: string[] }>(
-					baseURL + '/api/repository/filelist',
+					getURL('/api/repository/filelist'),
 					{
 						url,
 						branch
 					},
-					{
-						headers: { Authorization: 'jwt ' + token }
-					}
+					getConfig()
 				)
-				.then(res => res.data['files'])
+				.then(res => res.data['files']),
+
+		invoke: <Result, Args = unknown>(
+			type: InvokeType,
+			prefix: string,
+			suffix: string,
+			version = 'v1',
+			name: string,
+			args?: Args
+		): Promise<Result> => {
+			const url = getURL(
+				`/${prefix}/${suffix}/${version}/${type}/${name}`
+			);
+			const config = getConfig();
+
+			const req =
+				args === undefined
+					? axios.get<Result>(url, config)
+					: axios.post<Result>(url, args, config);
+
+			return req.then(res => res.data);
+		},
+
+		call: <Result, Args = unknown>(
+			prefix: string,
+			suffix: string,
+			version = 'v1',
+			name: string,
+			args?: Args
+		): Promise<Result> =>
+			api.invoke(InvokeType.Call, prefix, suffix, version, name, args),
+
+		await: <Result, Args = unknown>(
+			prefix: string,
+			suffix: string,
+			version = 'v1',
+			name: string,
+			args?: Args
+		): Promise<Result> =>
+			api.invoke(InvokeType.Await, prefix, suffix, version, name, args)
 	};
 
 	return api;
 };
+
+export const MaxRetries = 30;
+export const MaxRetryInterval = 2000;
+export const MaxFuncLength = 64;
+
+/**
+ * Executes an asynchronous function with automatic retry logic.
+ *
+ * The function will be retried up to `maxRetries` times, waiting `interval`
+ * milliseconds between each attempt. If all retries fail, the last error is
+ * wrapped in a new `Error` with a descriptive message, including:
+ * - Function name (or string representation truncated to `MaxFuncLength` chars if anonymous)
+ * - Number of retries attempted
+ * - Original error message
+ *
+ * Error handling is fully type-safe:
+ * - If the error is an ProtocolError (checked via `isProtocolError`), its
+ *   message is used.
+ * - If the error is a standard `Error`, its `message` is used.
+ * - Otherwise, the error is converted to a string.
+ *
+ * @typeParam T - The return type of the function being retried.
+ * @param fn - A lambda or bound function returning a `Promise<T>`. The
+ *             function should contain the logic you want to retry.
+ * @param maxRetries - Maximum number of retry attempts. Default: `MaxRetries`.
+ * @param interval - Delay between retries in milliseconds. Default: `MaxRetryInterval`.
+ * @returns A `Promise` resolving to the return value of `fn` if successful.
+ * @throws Error If all retry attempts fail, throws a new Error containing
+ *                 information about the function and the last error.
+ *
+ * @example
+ * ```ts
+ * const deployment = await waitFor(() => api.inspectByName('my-suffix'));
+ * ```
+ *
+ * @example
+ * ```ts
+ * const result = await waitFor(
+ *   () => api.deploy(name, env, plan, resourceType)
+ * );
+ * ```
+ */
+export const waitFor = async <T>(
+	fn: () => Promise<T>,
+	maxRetries: number = MaxRetries,
+	interval: number = MaxRetryInterval
+): Promise<T> => {
+	let retry = 0;
+
+	for (;;) {
+		try {
+			return await fn();
+		} catch (error) {
+			retry++;
+			if (retry >= maxRetries) {
+				const fnStr = fn.toString();
+				const func =
+					fn.name ||
+					(fnStr.length > MaxFuncLength
+						? fnStr.slice(0, MaxFuncLength) + '...'
+						: fnStr);
+				const message = isProtocolError(error)
+					? (error as ProtocolError).message
+					: error instanceof Error
+					? error.message
+					: String(error);
+
+				throw new Error(
+					`Failed to execute '${func}' after ${maxRetries} retries: ${message}`
+				);
+			}
+
+			await new Promise(r => setTimeout(r, interval));
+		}
+	}
+};

package/tsconfig.json

@@ -1,8 +1,9 @@
 {
 	"compilerOptions": {
 		"strict": true,
-		"lib": ["ES2020"],
-		"target": "ES2019",
+		"lib": ["es2020", "dom"],
+		"moduleResolution": "node",
+		"target": "es2020",
 		"module": "CommonJS",
 		"outDir": "dist",
 		"esModuleInterop": true,