@factorialco/fcode-cli 1.1.0

package/dist/core/types.d.ts

@@ -0,0 +1,290 @@
+export type Credentials = {
+    url: string;
+    authUrl: string;
+    email?: string;
+    password?: string;
+    clientId?: string;
+    clientSecret?: string;
+    accessToken?: string;
+};
+export interface Token {
+    access_token: string;
+    refresh_token: string;
+}
+export interface UserInfo {
+    groups: string[];
+    name: string;
+}
+export interface AuthInfo {
+    authUrl: string;
+    token: Token;
+    userInfo: UserInfo;
+}
+export interface AuthConfig {
+    clientId: string;
+    url: string;
+}
+export interface TeamOrigin {
+    url: string;
+    slug: string;
+}
+export interface TeamMetadata {
+    [key: string]: any;
+    modules: {
+        [key: string]: ScriptLibrary;
+    };
+    processes: {
+        [key: string]: Process;
+    };
+    slug: string;
+    variables: {
+        [key: string]: Variable;
+    };
+    dependencies: {
+        [key: string]: ProgrammingLanguageManifest;
+    };
+    team?: {
+        contentHash?: string;
+    };
+}
+export interface RemoteMetadata {
+    [key: string]: any;
+}
+export interface Config {
+    [key: string]: any;
+}
+export interface Settings {
+    [key: string]: string;
+}
+export interface GlobalConfig extends Config {
+    auth?: AuthInfo;
+    versionCheckTime?: number;
+    settings?: Settings;
+}
+export interface WorkspaceConfig {
+    activeTeam: string;
+    teams: TeamMetadata[];
+}
+export type ResourceRepositoryOptions = {
+    name: string;
+};
+export declare abstract class Resource {
+    abstract readonly contentHash: string;
+    id: string | undefined;
+    slug: string;
+    errorPushing: boolean | undefined;
+    resolvingTeamSlug?: string;
+    sameAs(other: Resource): boolean;
+}
+export declare enum OnConflictResolution {
+    KEEP_LOCAL = 0,
+    KEEP_REMOTE = 1
+}
+export declare enum ResourceStatus {
+    CONFLICT = "\uD83D\uDD25 (conflict)",
+    REMOTE_REMOVED = "\uD83D\uDDD1\uFE0F\uD83C\uDF29\uFE0F (removed-remote)",
+    LOCAL_REMOVED = "\uD83D\uDDD1\uFE0F\uD83D\uDCBB (removed-local)",
+    MODIFIED = "\uD83D\uDD3A (modified)",
+    REMOTE_NEW = "\uD83C\uDF29\uFE0F (new-remote)",
+    LOCAL_NEW = "\u2728 (new-local)",
+    OUT_OF_DATE = "\uD83D\uDD3B (out-of-date)",
+    UP_TO_DATE = "\u2705 (up-to-date)",
+    SENSITIVE = "\uD83D\uDD12 (sensitive)",
+    SENSITIVITY_CHANGED = "\uD83D\uDEAB (sensitivity-changed)"
+}
+type MergedResourceRecord = Record<string, unknown> & Resource;
+export type MergedResource = MergedResourceRecord & {
+    status: ResourceStatus;
+};
+export type ProgrammingLanguage = 'JAVASCRIPT' | 'PYTHON';
+export declare const programmingLanguageDisplayName: (programmingLanguage: ProgrammingLanguage) => string;
+export interface ProcessWebhook {
+    enabled: boolean;
+    username?: string;
+    password?: string;
+}
+export interface ProcessForm {
+    enabled: boolean;
+}
+export interface ProcessVisibility {
+    isPublic: boolean;
+}
+export interface ProcessMetadataFields {
+    name: string;
+    description?: string;
+    tags: string[];
+    webhook?: ProcessWebhook;
+    form?: ProcessForm;
+    visibility?: ProcessVisibility;
+}
+export declare class Process extends Resource {
+    id: string;
+    slug: string;
+    name: string;
+    description?: string;
+    readme: string;
+    tags: string[];
+    webhook?: ProcessWebhook;
+    form?: ProcessForm;
+    visibility?: ProcessVisibility;
+    script: {
+        parametersSchema: any;
+        programmingLanguage: ProgrammingLanguage;
+        sourceCode: string;
+    };
+    manifest: {
+        dependencies: Array<Dependency>;
+    };
+    settings: {
+        dependencies: {
+            scopedToProcess: boolean;
+        };
+    };
+    constructor(id: string, slug: string, script: any, readme: string, manifest: {
+        dependencies: Array<Dependency>;
+    } | null, settings: {
+        dependencies: {
+            scopedToProcess: boolean;
+        };
+    }, metadata: ProcessMetadataFields, resolvingTeamSlug?: string);
+    get contentHash(): string;
+}
+export declare class VersionedProcess extends Resource {
+    id: string;
+    slug: string;
+    tag: string;
+    readme: string;
+    script: {
+        parametersSchema: any;
+        programmingLanguage: ProgrammingLanguage;
+        sourceCode: string;
+    };
+    constructor(id: string, tag: string, script: any, readme: string);
+    get contentHash(): string;
+}
+export declare class ScriptLibrary extends Resource {
+    id: string;
+    slug: string;
+    name: string;
+    programmingLanguage: ProgrammingLanguage;
+    sourceCode: string;
+    constructor(id: string, name: string, sourceCode: string, programmingLanguage: ProgrammingLanguage, resolvingTeamSlug?: string);
+    get contentHash(): string;
+}
+export declare class VersionedScriptLibrary extends Resource {
+    id: string;
+    slug: string;
+    tag: string;
+    programmingLanguage: ProgrammingLanguage;
+    sourceCode: string;
+    constructor(id: string, tag: string, sourceCode: string, programmingLanguage: ProgrammingLanguage);
+    get contentHash(): string;
+}
+export declare class Variable extends Resource {
+    static ENV_KEY_MAX_LENGTH: number;
+    static ENV_KEY_REGEX: RegExp;
+    id: string | undefined;
+    slug: string;
+    isSensitive: boolean;
+    key: string;
+    value: string;
+    overriddenLocally?: boolean;
+    constructor(id: string | undefined, key: string, value: string, isSensitive: boolean);
+    static validate(variable: Variable): Variable;
+    get contentHash(): string;
+}
+export declare class ProgrammingLanguageManifest extends Resource {
+    id: string | undefined;
+    slug: string;
+    programmingLanguage: ProgrammingLanguage;
+    dependencies: Array<Dependency>;
+    constructor(id: string, slug: string, programmingLanguage: ProgrammingLanguage, dependencies: Array<Dependency>);
+    get contentHash(): string;
+}
+export interface ErrorHandlerConfig {
+    processSlug: string;
+    tag?: string | null;
+}
+export declare class Team extends Resource {
+    id: string | undefined;
+    slug: string;
+    zoneId?: string;
+    errorHandlerConfig?: ErrorHandlerConfig;
+    parentTeamSlugs: string[];
+    constructor(slug: string, parentTeamSlugs: string[], zoneId?: string, errorHandlerConfig?: ErrorHandlerConfig);
+    get contentHash(): string;
+}
+export interface RawErrorHandlerConfig {
+    processId: string;
+    tag?: string | null;
+}
+export interface RawTeamSettings {
+    slug: string;
+    zoneId?: string;
+    errorHandlerConfig?: RawErrorHandlerConfig | null;
+    parentTeamSlugs: string[];
+}
+export interface TeamUpdateInput {
+    zoneId?: string;
+    parentTeamSlugs?: string[];
+    executionErrorHandlerConfig?: RawErrorHandlerConfig | null;
+}
+export type ResourceMetadata = {
+    [key: string]: any;
+};
+export interface AddResourceOptions {
+    variableSensitive: boolean;
+}
+export type FcodeGraphQLClientOptions = {
+    accessToken: string;
+    teamSlug: string;
+};
+export declare class ProcessNotFound extends Error {
+}
+export declare class ScriptLibraryNotFound extends Error {
+}
+export interface WebhookRequest {
+    headers: Record<string, string>;
+    rawBody: string;
+    query: Record<string, string>;
+    method: string;
+}
+export type ExecutionOptions = {
+    version: string | undefined;
+    parameters: any;
+    variables: Array<Variable>;
+    logLevel: string;
+    request?: WebhookRequest;
+    jsonLogs?: boolean;
+    hookFilePath?: string;
+    hookFunction?: string;
+    silent?: boolean;
+};
+export declare const ForceFlag: {
+    force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+export declare const ResourceSlugArg: {
+    resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+};
+export declare const TeamNameArg: {
+    team: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+};
+export declare const DependenciesFlags: {
+    check: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    reset: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+export declare class Dependency {
+    name: string;
+    specifier: string;
+}
+export declare class ServiceAccount extends Resource {
+    id: string;
+    slug: string;
+    name: string;
+    clientId: string;
+    clientSecret: string;
+    constructor(id: string, name: string, clientId: string, clientSecret: string);
+    get contentHash(): string;
+}
+export {};

package/dist/core/types.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceAccount = exports.Dependency = exports.DependenciesFlags = exports.TeamNameArg = exports.ResourceSlugArg = exports.ForceFlag = exports.ScriptLibraryNotFound = exports.ProcessNotFound = exports.Team = exports.ProgrammingLanguageManifest = exports.Variable = exports.VersionedScriptLibrary = exports.ScriptLibrary = exports.VersionedProcess = exports.Process = exports.programmingLanguageDisplayName = exports.ResourceStatus = exports.OnConflictResolution = exports.Resource = void 0;
+const core_1 = require("@oclif/core");
+const crypto = require("node:crypto");
+const canonical_hash_1 = require("../utils/canonical-hash");
+class Resource {
+    sameAs(other) {
+        return this.slug === other.slug;
+    }
+}
+exports.Resource = Resource;
+var OnConflictResolution;
+(function (OnConflictResolution) {
+    OnConflictResolution[OnConflictResolution["KEEP_LOCAL"] = 0] = "KEEP_LOCAL";
+    OnConflictResolution[OnConflictResolution["KEEP_REMOTE"] = 1] = "KEEP_REMOTE";
+})(OnConflictResolution || (exports.OnConflictResolution = OnConflictResolution = {}));
+var ResourceStatus;
+(function (ResourceStatus) {
+    ResourceStatus["CONFLICT"] = "\uD83D\uDD25 (conflict)";
+    ResourceStatus["REMOTE_REMOVED"] = "\uD83D\uDDD1\uFE0F\uD83C\uDF29\uFE0F (removed-remote)";
+    ResourceStatus["LOCAL_REMOVED"] = "\uD83D\uDDD1\uFE0F\uD83D\uDCBB (removed-local)";
+    ResourceStatus["MODIFIED"] = "\uD83D\uDD3A (modified)";
+    ResourceStatus["REMOTE_NEW"] = "\uD83C\uDF29\uFE0F (new-remote)";
+    ResourceStatus["LOCAL_NEW"] = "\u2728 (new-local)";
+    ResourceStatus["OUT_OF_DATE"] = "\uD83D\uDD3B (out-of-date)";
+    ResourceStatus["UP_TO_DATE"] = "\u2705 (up-to-date)";
+    ResourceStatus["SENSITIVE"] = "\uD83D\uDD12 (sensitive)";
+    ResourceStatus["SENSITIVITY_CHANGED"] = "\uD83D\uDEAB (sensitivity-changed)";
+})(ResourceStatus || (exports.ResourceStatus = ResourceStatus = {}));
+const programmingLanguageDisplayName = (programmingLanguage) => {
+    switch (programmingLanguage) {
+        case 'JAVASCRIPT':
+            return 'JavaScript';
+        case 'PYTHON':
+            return 'Python';
+    }
+};
+exports.programmingLanguageDisplayName = programmingLanguageDisplayName;
+class Process extends Resource {
+    constructor(id, slug, script, readme, manifest, settings, metadata, resolvingTeamSlug) {
+        super();
+        this.id = id;
+        this.slug = slug;
+        this.name = metadata.name;
+        this.description = metadata.description;
+        this.tags = metadata.tags;
+        this.webhook = metadata.webhook;
+        this.form = metadata.form;
+        this.visibility = metadata.visibility;
+        this.script = script;
+        this.readme = readme;
+        this.manifest = settings.dependencies.scopedToProcess && manifest !== null ? manifest : { dependencies: [] };
+        this.settings = settings;
+        this.resolvingTeamSlug = resolvingTeamSlug;
+    }
+    get contentHash() {
+        return (0, canonical_hash_1.canonicalJsonHash)({
+            name: this.name || '',
+            description: this.description || '',
+            parametersSchema: this.script?.parametersSchema || {},
+            readme: this.readme || '',
+            sourceCode: this.script?.sourceCode || '',
+            tags: this.tags || [],
+            webhook: this.webhook || null,
+            form: this.form || null,
+            visibility: this.visibility || null,
+            manifestDependencies: this.manifest.dependencies,
+            dependenciesScopedToProcess: this.settings.dependencies.scopedToProcess,
+        });
+    }
+}
+exports.Process = Process;
+class VersionedProcess extends Resource {
+    constructor(id, tag, script, readme) {
+        super();
+        this.id = id;
+        this.slug = id;
+        this.tag = tag;
+        this.script = script;
+        this.readme = readme;
+    }
+    get contentHash() {
+        return crypto
+            .createHash('md5')
+            .update(JSON.stringify({ parametersSchema: this.script?.parametersSchema || {}, readme: this.readme || '', sourceCode: this.script?.sourceCode || '' }))
+            .digest('hex');
+    }
+}
+exports.VersionedProcess = VersionedProcess;
+class ScriptLibrary extends Resource {
+    constructor(id, name, sourceCode, programmingLanguage, resolvingTeamSlug) {
+        super();
+        this.id = id;
+        this.slug = name;
+        this.name = name;
+        this.sourceCode = sourceCode;
+        this.programmingLanguage = programmingLanguage;
+        this.resolvingTeamSlug = resolvingTeamSlug;
+    }
+    get contentHash() {
+        return crypto.createHash('md5').update(this.sourceCode).digest('hex');
+    }
+}
+exports.ScriptLibrary = ScriptLibrary;
+class VersionedScriptLibrary extends Resource {
+    constructor(id, tag, sourceCode, programmingLanguage) {
+        super();
+        this.id = id;
+        this.slug = id;
+        this.tag = tag;
+        this.sourceCode = sourceCode;
+        this.programmingLanguage = programmingLanguage;
+    }
+    get contentHash() {
+        return crypto.createHash('md5').update(this.sourceCode).digest('hex');
+    }
+}
+exports.VersionedScriptLibrary = VersionedScriptLibrary;
+class Variable extends Resource {
+    constructor(id, key, value, isSensitive) {
+        super();
+        this.id = id;
+        this.slug = key;
+        this.key = key;
+        this.value = value;
+        this.isSensitive = isSensitive;
+    }
+    static validate(variable) {
+        if (!Variable.ENV_KEY_REGEX.test(variable.key)) {
+            throw new Error(`Variable key "${variable.key}" is not valid. Use letters, '_' or numbers, and don't start with a number`);
+        }
+        if (variable.key.length > Variable.ENV_KEY_MAX_LENGTH) {
+            throw new Error(`Variable key "${variable.key}" exceed ${Variable.ENV_KEY_MAX_LENGTH} characters`);
+        }
+        return variable;
+    }
+    get contentHash() {
+        if (this.isSensitive) {
+            return '';
+        }
+        return crypto
+            .createHash('md5')
+            .update(this.value || '')
+            .digest('hex');
+    }
+}
+exports.Variable = Variable;
+Variable.ENV_KEY_MAX_LENGTH = 64;
+Variable.ENV_KEY_REGEX = /^[A-Z_a-z]\w*$/;
+class ProgrammingLanguageManifest extends Resource {
+    constructor(id, slug, programmingLanguage, dependencies) {
+        super();
+        this.id = id;
+        this.slug = slug;
+        this.programmingLanguage = programmingLanguage;
+        this.dependencies = dependencies;
+    }
+    get contentHash() {
+        return crypto
+            .createHash('md5')
+            .update(JSON.stringify({ slug: this.slug, programmingLanguage: this.programmingLanguage, dependencies: this.dependencies }))
+            .digest('hex');
+    }
+}
+exports.ProgrammingLanguageManifest = ProgrammingLanguageManifest;
+class Team extends Resource {
+    constructor(slug, parentTeamSlugs, zoneId, errorHandlerConfig) {
+        super();
+        this.slug = slug;
+        this.parentTeamSlugs = parentTeamSlugs;
+        this.zoneId = zoneId;
+        this.errorHandlerConfig = errorHandlerConfig;
+    }
+    get contentHash() {
+        return (0, canonical_hash_1.canonicalJsonHash)({
+            zoneId: this.zoneId || null,
+            errorHandlerConfig: this.errorHandlerConfig || null,
+            parentTeamSlugs: [...(this.parentTeamSlugs || [])].sort(),
+        });
+    }
+}
+exports.Team = Team;
+class ProcessNotFound extends Error {
+}
+exports.ProcessNotFound = ProcessNotFound;
+class ScriptLibraryNotFound extends Error {
+}
+exports.ScriptLibraryNotFound = ScriptLibraryNotFound;
+exports.ForceFlag = {
+    force: core_1.Flags.boolean({
+        char: 'f',
+        description: 'Force command',
+    }),
+};
+exports.ResourceSlugArg = {
+    resourceSlug: core_1.Args.string({
+        description: 'Resource slug',
+        name: 'slug',
+    }),
+};
+exports.TeamNameArg = {
+    team: core_1.Args.string({ description: 'Team name', name: 'team' }),
+};
+exports.DependenciesFlags = {
+    check: core_1.Flags.boolean({
+        char: 'c',
+        description: 'Check if is needed to install dependencies',
+    }),
+    reset: core_1.Flags.boolean({
+        char: 'r',
+        description: 'Remove all existing dependencies before installing',
+    }),
+    force: core_1.Flags.boolean({
+        char: 'f',
+        description: 'Force dependencies installation even if they are already installed',
+    }),
+};
+class Dependency {
+}
+exports.Dependency = Dependency;
+class ServiceAccount extends Resource {
+    constructor(id, name, clientId, clientSecret) {
+        super();
+        this.id = id;
+        this.slug = name;
+        this.name = name;
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+    }
+    get contentHash() {
+        return crypto
+            .createHash('md5')
+            .update(JSON.stringify({ name: this.name, clientId: this.clientId, clientSecret: this.clientSecret }))
+            .digest('hex');
+    }
+}
+exports.ServiceAccount = ServiceAccount;

package/dist/core/utils/dependencies.d.ts

@@ -0,0 +1,5 @@
+import type { Dependency, Process, ProgrammingLanguage } from '../types';
+export declare function getDependenciesPath(programmingLanguage: ProgrammingLanguage): Promise<string>;
+export declare function getProcessDependenciesPath(process: Process): string;
+export declare function dependenciesToFile(programmingLanguage: ProgrammingLanguage, dependencies?: Array<Dependency>): string;
+export declare function dependenciesFromFile(programmingLanguage: ProgrammingLanguage, fileContent: string): Array<Dependency>;

package/dist/core/utils/dependencies.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependenciesPath = getDependenciesPath;
+exports.getProcessDependenciesPath = getProcessDependenciesPath;
+exports.dependenciesToFile = dependenciesToFile;
+exports.dependenciesFromFile = dependenciesFromFile;
+const path = require("node:path");
+const workspace_1 = require("../../config/workspace");
+const programming_language_manifest_1 = require("../../repositories/programming-language-manifest");
+const env_dependencies_command_1 = require("../dependencies/env-dependencies-command");
+async function getDependenciesPath(programmingLanguage) {
+    const basePath = (0, workspace_1.baseDependenciesPath)(programmingLanguage);
+    const repo = new programming_language_manifest_1.default();
+    const programmingLanguageManifest = await repo.find(programmingLanguage);
+    const dependenciesDirectory = (0, env_dependencies_command_1.dependenciesHash)(programmingLanguageManifest.dependencies);
+    return path.join(basePath, dependenciesDirectory);
+}
+function getProcessDependenciesPath(process) {
+    const basePath = (0, workspace_1.baseDependenciesPath)(process.script.programmingLanguage);
+    const dependenciesDirectory = (0, env_dependencies_command_1.dependenciesHash)(process.manifest?.dependencies ?? []);
+    return path.join(basePath, dependenciesDirectory);
+}
+function dependenciesToFile(programmingLanguage, dependencies = []) {
+    switch (programmingLanguage) {
+        case 'JAVASCRIPT':
+            if (dependencies.length === 0) {
+                return '{\n  \n}\n';
+            }
+            return '{\n' + dependencies.map((dependency) => `  "${dependency.name}": "${dependency.specifier}"`).join(',\n') + '\n}\n';
+        case 'PYTHON':
+            return (dependencies
+                .map((dependency) => {
+                if (dependency.specifier.startsWith('git+')) {
+                    return `${dependency.name} @ ${dependency.specifier}`;
+                }
+                return `${dependency.name}==${dependency.specifier}`;
+            })
+                .join('\n') + '\n');
+        default:
+            return '';
+    }
+}
+function dependenciesFromFile(programmingLanguage, fileContent) {
+    if (!fileContent.trim()) {
+        return [];
+    }
+    const dependencies = new Array();
+    switch (programmingLanguage) {
+        case 'JAVASCRIPT':
+            let dependenciesObject = JSON.parse(fileContent);
+            if (typeof dependenciesObject?.dependencies === 'object') {
+                dependenciesObject = dependenciesObject.dependencies;
+            }
+            for (const dependency of Object.keys(dependenciesObject)) {
+                dependencies.push({
+                    name: dependency,
+                    specifier: dependenciesObject[dependency],
+                });
+            }
+            break;
+        case 'PYTHON':
+            fileContent.split('\n').map((line) => {
+                let tokens;
+                if (line.includes(' @ ')) {
+                    tokens = line.split(' @ ');
+                }
+                else {
+                    tokens = line.split('==');
+                }
+                if (tokens.length !== 2) {
+                    return;
+                }
+                dependencies.push({
+                    name: tokens[0],
+                    specifier: tokens[1],
+                });
+            });
+            break;
+        default:
+    }
+    return dependencies.sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/core/utils/variables.d.ts

@@ -0,0 +1,4 @@
+export declare const getVariablesObject: (variables: Array<{
+    key: string;
+    value: string;
+}>) => {};

package/dist/core/utils/variables.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVariablesObject = void 0;
+const getVariablesObject = (variables) => 
+// eslint-disable-next-line unicorn/no-array-reduce, unicorn/prefer-object-from-entries
+variables.reduce((teamVariables, { key, value }) => ({
+    ...teamVariables,
+    [key]: value,
+}), {});
+exports.getVariablesObject = getVariablesObject;

package/dist/hooks/init/auth.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const auth: Hook<'init'>;
+export default auth;

package/dist/hooks/init/auth.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = require("dotenv");
+const auth_service_1 = require("../../services/auth-service");
+const credential_prompter_1 = require("../../services/credential-prompter");
+const oauth_browser_service_1 = require("../../services/oauth-browser-service");
+const global_1 = require("../../config/global");
+const url_utils_1 = require("../../utils/url-utils");
+const auth = async function ({ argv }) {
+    const url = argv[0] || global_1.FCODE_CLOUD_URL;
+    const authUrl = argv[1] || (0, url_utils_1.buildAuthUrl)(url);
+    const isAuthenticated = await auth_service_1.default.isAuthenticated(url);
+    if (!isAuthenticated) {
+        (0, dotenv_1.config)();
+        const accessToken = argv[6];
+        const prompt = argv[7];
+        if (accessToken) {
+            await auth_service_1.default.login({ url, authUrl, accessToken });
+        }
+        else if (prompt || argv[2] || argv[3] || (argv[4] && argv[5])) {
+            await credential_prompter_1.default.prompt({ url, authUrl, email: argv[2], password: argv[3], clientId: argv[4], clientSecret: argv[5] });
+        }
+        else {
+            await (0, oauth_browser_service_1.loginViaBrowser)(url, authUrl, argv[4]);
+        }
+    }
+};
+exports.default = auth;

package/dist/hooks/init/update.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const updateNotifier: Hook<'init'>;
+export default updateNotifier;