@factorialco/fcode-cli 1.1.0

package/dist/commands/pre-debug.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@oclif/core';
+import ProcessRepository from '../repositories/process';
+import VariableRepository from '../repositories/variable';
+export default class PreDebug extends Command {
+    static readonly hidden = true;
+    static readonly args: {
+        slug: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static readonly description = "Debug preparation for Factorial Code processes locally (without execution)";
+    static readonly examples: string[];
+    static readonly flags: {
+        parameters: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        logLevel: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        tempDir: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    _processRepository: ProcessRepository;
+    _variableRepository: VariableRepository;
+    run(): Promise<void>;
+}

package/dist/commands/pre-debug.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const path = require("node:path");
+const source_code_sanitizer_1 = require("../core/executors/source-code-sanitizer");
+const core_2 = require("@oclif/core");
+const javascript_execution_task_1 = require("../core/executors/javascript-execution-task");
+const python_execution_task_1 = require("../core/executors/python-execution-task");
+const process_1 = require("../repositories/process");
+const variable_1 = require("../repositories/variable");
+const getSlugFromFilePath = (filePath) => {
+    const pathSep = path.sep == '\\' ? '\\\\' : path.sep;
+    const processRegexPart = `[${pathSep}]processes[${pathSep}]([^${pathSep}]+)`;
+    const versionRegexPart = `[${pathSep}]versions[${pathSep}]([^${pathSep}]+)`;
+    const fileRegexPart = `[${pathSep}](main\\.py|index\\.js)`;
+    const regex = new RegExp(`${processRegexPart}(${versionRegexPart})?${fileRegexPart}$`);
+    const match = regex.exec(filePath);
+    if (!match) {
+        throw new Error('Invalid file path ' + filePath);
+    }
+    return {
+        slug: match[1],
+        version: match[3],
+    };
+};
+class PreDebug extends core_2.Command {
+    constructor() {
+        super(...arguments);
+        this._processRepository = new process_1.default();
+        this._variableRepository = new variable_1.default();
+    }
+    async run() {
+        const parsed = await this.parse(PreDebug);
+        const { flags: { parameters: parametersFlag, logLevel, tempDir }, } = parsed;
+        let version = parsed.flags.version;
+        let { args: { slug }, } = parsed;
+        if (slug.includes(path.sep)) {
+            const { slug: processSlug, version: processVersion } = getSlugFromFilePath(slug);
+            if (processVersion != null && version != null && processVersion != version) {
+                throw new Error('Version mismatch: ' + version + ' != ' + processVersion);
+            }
+            slug = processSlug;
+            version = processVersion;
+        }
+        const processData = await this._processRepository.find(slug, version);
+        const sourceCode = processData.script.sourceCode;
+        if ((0, source_code_sanitizer_1.isLegacySourceCode)(sourceCode, processData.script.programmingLanguage)) {
+            const pad = (text, char = ' ') => '###' + char + char + text.padEnd(82, char) + char + char + '###';
+            console.log();
+            console.log(pad('#', '#'));
+            console.log(pad('WARNING!!: Process does not cointain a main() function, breakpoints will not work.'));
+            console.log(pad('You should encapsulate your code in a main() function for full debugging support.'));
+            console.log(pad('#', '#'));
+            console.log(pad('// Sample process code:'));
+            console.log(pad(''));
+            if (processData.script.programmingLanguage === 'PYTHON') {
+                console.log(pad('from fcode import fcode, logger'));
+                console.log(pad('def main():'));
+                console.log(pad('  // your code'));
+            }
+            else if (processData.script.programmingLanguage === 'JAVASCRIPT') {
+                console.log(pad('const { fcode } = require("fcode");'));
+                console.log(pad('async function main() {'));
+                console.log(pad('  // your code'));
+                console.log(pad('}'));
+                console.log(pad('module.exports = { main }'));
+            }
+            console.log(pad(''));
+            console.log(pad('#', '#'));
+            console.log();
+        }
+        let parameters = {};
+        if (parametersFlag) {
+            try {
+                parameters = JSON.parse(parametersFlag);
+            }
+            catch (error) {
+                parameters = await Promise.resolve(`${path.resolve(parametersFlag)}`).then(s => require(s));
+            }
+        }
+        else {
+            parameters = await this._processRepository.findParameters(slug);
+        }
+        const variables = await this._variableRepository.findAllForExecution();
+        const ExecutionTask = processData.script.programmingLanguage === 'PYTHON' ? python_execution_task_1.default : javascript_execution_task_1.default;
+        const executor = new ExecutionTask(processData.script.programmingLanguage, processData, { version, parameters, variables, logLevel }, tempDir);
+        await executor.prepare();
+    }
+}
+PreDebug.hidden = true;
+PreDebug.args = {
+    slug: core_1.Args.string({
+        description: 'Process slug',
+        name: 'slug',
+        required: true,
+    }),
+};
+PreDebug.description = 'Debug preparation for Factorial Code processes locally (without execution)';
+PreDebug.examples = ['$ fcode pre-debug [process-slug]', '$ fcode pre-debug --parameters ./parameters.json [process-slug]'];
+PreDebug.flags = {
+    parameters: core_1.Flags.string({
+        char: 'p',
+        description: 'Parameters: stringified JSON or file path',
+    }),
+    version: core_1.Flags.string({
+        char: 'v',
+        description: 'Process version',
+    }),
+    logLevel: core_1.Flags.string({
+        char: 'l',
+        description: 'Log level to use in process execution',
+        default: 'DEBUG',
+        options: ['DEBUG', 'INFO', 'WARNING', 'ERROR'],
+    }),
+    tempDir: core_1.Flags.string({
+        char: 't',
+        description: 'Temporal directory to use in process build',
+    }),
+};
+exports.default = PreDebug;

package/dist/commands/process-metadata.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+import ProcessRepository from '../repositories/process';
+import VariableRepository from '../repositories/variable';
+export default class ProcessMetadata extends Command {
+    static readonly hidden = true;
+    static readonly args: {
+        slug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static readonly description = "Debug preparation for Factorial Code processes locally (without execution)";
+    static readonly examples: string[];
+    static readonly flags: {
+        parameters: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    _processRepository: ProcessRepository;
+    _variableRepository: VariableRepository;
+    run(): Promise<void>;
+}

package/dist/commands/process-metadata.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const path = require("node:path");
+const javascript_execution_task_1 = require("../core/executors/javascript-execution-task");
+const python_execution_task_1 = require("../core/executors/python-execution-task");
+const process_1 = require("../repositories/process");
+const variable_1 = require("../repositories/variable");
+const variables_1 = require("../core/utils/variables");
+class ProcessMetadata extends core_1.Command {
+    constructor() {
+        super(...arguments);
+        this._processRepository = new process_1.default();
+        this._variableRepository = new variable_1.default();
+    }
+    async run() {
+        const parsed = await this.parse(ProcessMetadata);
+        let { args: { slug }, flags: { parameters: parametersFlag, version }, } = parsed;
+        const variables = await this._variableRepository.findAllForExecution();
+        let parameters = {};
+        if (parametersFlag) {
+            try {
+                parameters = JSON.parse(parametersFlag);
+            }
+            catch (error) {
+                parameters = await Promise.resolve(`${path.resolve(parametersFlag)}`).then(s => require(s));
+            }
+        }
+        else if (slug) {
+            parameters = await this._processRepository.findParameters(slug);
+        }
+        if (slug) {
+            const processData = await this._processRepository.find(slug, version);
+            const ExecutionTask = processData.script.programmingLanguage === 'PYTHON' ? python_execution_task_1.default : javascript_execution_task_1.default;
+            const executor = new ExecutionTask(processData.script.programmingLanguage, processData, { version, parameters, variables, logLevel: 'INFO' }, undefined);
+            console.log(JSON.stringify(executor.getMetadata(), null, 2));
+        }
+        else {
+            console.log(JSON.stringify({ variables: (0, variables_1.getVariablesObject)(variables), parameters, execution: { process: { name: '', id: '' } } }));
+        }
+    }
+}
+ProcessMetadata.hidden = true;
+ProcessMetadata.args = {
+    slug: core_1.Args.string({
+        description: 'Process slug',
+        name: 'slug',
+        required: false,
+    }),
+};
+ProcessMetadata.description = 'Debug preparation for Factorial Code processes locally (without execution)';
+ProcessMetadata.examples = ['$ fcode process-metadata [process-slug]'];
+ProcessMetadata.flags = {
+    parameters: core_1.Flags.string({
+        char: 'p',
+        description: 'Parameters: stringified JSON or file path',
+    }),
+    version: core_1.Flags.string({
+        char: 'v',
+        description: 'Process version',
+    }),
+};
+exports.default = ProcessMetadata;

package/dist/commands/processes/add.d.ts

@@ -0,0 +1,9 @@
+import ProcessesCommand from '../../core/commands/processes-command';
+export default class ProcessesAdd extends ProcessesCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/processes/add.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const processes_command_1 = require("../../core/commands/processes-command");
+const types_1 = require("../../core/types");
+class ProcessesAdd extends processes_command_1.default {
+    async run() {
+        await super.addResources();
+    }
+}
+ProcessesAdd.description = 'Keeps track of a new local process';
+ProcessesAdd.examples = ['$ fcode processes:add'];
+ProcessesAdd.args = types_1.ResourceSlugArg;
+exports.default = ProcessesAdd;

package/dist/commands/processes/install-dependencies.d.ts

@@ -0,0 +1,14 @@
+import BaseCommand from '../../core/commands/base-command';
+export default class ProcessesInstallDependencies extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        check: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        reset: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/processes/install-dependencies.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_command_1 = require("../../core/commands/base-command");
+const env_process_dependencies_command_1 = require("../../core/dependencies/env-process-dependencies-command");
+const types_1 = require("../../core/types");
+class ProcessesInstallDependencies extends base_command_1.default {
+    async run() {
+        await super.init();
+        const { args: { resourceSlug }, flags: { check, reset, force }, } = await this.parse(ProcessesInstallDependencies);
+        const args = [];
+        if (resourceSlug) {
+            args.push(resourceSlug);
+        }
+        if (check) {
+            args.push('--check');
+        }
+        if (reset) {
+            args.push('--reset');
+        }
+        if (force) {
+            args.push('--force');
+        }
+        await env_process_dependencies_command_1.default.run(args);
+    }
+}
+ProcessesInstallDependencies.description = 'Install Factorial Code process dependencies';
+ProcessesInstallDependencies.examples = ['$ fcode processes:install-dependencies [processSlug]'];
+ProcessesInstallDependencies.args = types_1.ResourceSlugArg;
+ProcessesInstallDependencies.flags = types_1.DependenciesFlags;
+exports.default = ProcessesInstallDependencies;

package/dist/commands/processes/pull.d.ts

@@ -0,0 +1,13 @@
+import ProcessesCommand from '../../core/commands/processes-command';
+export default class ProcessesPull extends ProcessesCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    pullVersioned(): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/processes/pull.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@oclif/color");
+const processes_command_1 = require("../../core/commands/processes-command");
+const types_1 = require("../../core/types");
+const cli_1 = require("../../utils/cli");
+const settings_1 = require("../../config/settings");
+class ProcessesPull extends processes_command_1.default {
+    async pullVersioned() {
+        const processes = await this.getRemoteResources();
+        const processRepository = this._resourceRepository;
+        const allPromises = [];
+        for (const process of processes) {
+            allPromises.push(this._versionedResourceQuery(process.id).then(async (remoteVersions) => {
+                const remoteVersionTags = new Set(remoteVersions.map((v) => v.tag));
+                // Remove local versions that were deleted in remote
+                for (const localTag of processRepository.getLocalVersionTags(process)) {
+                    if (!remoteVersionTags.has(localTag)) {
+                        cli_1.default.log(color_1.default.cyan(`🗑️  removing version '${localTag}' for process '${process.slug}'...`));
+                        processRepository.removeVersion(process, localTag);
+                    }
+                }
+                // Add only new (non-existing) versions
+                for (const versionedProcess of remoteVersions) {
+                    if (!processRepository.versionExistsLocally(process, versionedProcess.tag)) {
+                        cli_1.default.log(color_1.default.cyan(`🗂️  pulling version '${versionedProcess.tag}' for process '${process.slug}'...`));
+                        await processRepository.saveVersion(process, versionedProcess);
+                    }
+                }
+            }));
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        await Promise.allSettled(allPromises);
+    }
+    async run() {
+        await super.pullResources();
+        const ignoreProcessVersions = (await this.globalConfig.getSetting(settings_1.SettingKeys.IGNORE_PROCESS_VERSIONS)) === 'true';
+        if (!ignoreProcessVersions) {
+            await this.pullVersioned();
+        }
+    }
+}
+ProcessesPull.description = 'Fetch all processes from cloud and save them locally';
+ProcessesPull.examples = ['$ fcode processes:pull'];
+ProcessesPull.args = types_1.ResourceSlugArg;
+ProcessesPull.flags = types_1.ForceFlag;
+exports.default = ProcessesPull;

package/dist/commands/processes/push.d.ts

@@ -0,0 +1,13 @@
+import ProcessesCommand from '../../core/commands/processes-command';
+export default class ProcessesPush extends ProcessesCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    pushVersioned(): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/processes/push.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@oclif/color");
+const processes_command_1 = require("../../core/commands/processes-command");
+const types_1 = require("../../core/types");
+const cli_1 = require("../../utils/cli");
+const settings_1 = require("../../config/settings");
+class ProcessesPush extends processes_command_1.default {
+    async pushVersioned() {
+        const processes = (await this._resourceRepository.findAll()).filter((process) => process.id);
+        const processRepository = this._resourceRepository;
+        const allPromises = [];
+        for (const process of processes) {
+            allPromises.push(this._versionedResourceQuery(process.id).then(async (remoteVersionedProcesses) => {
+                const localVersionedProcesses = await processRepository.getVersions(process);
+                for (const localVersionedProcess of localVersionedProcesses) {
+                    if (!remoteVersionedProcesses.find((remoteVersionedProcess) => remoteVersionedProcess.tag === localVersionedProcess.tag)) {
+                        cli_1.default.log(color_1.default.cyan(`🗂️ pushing version '${localVersionedProcess.tag}' for process '${process.slug}'...`));
+                        await this._pushVersionedResourceMutation(localVersionedProcess);
+                    }
+                }
+            }));
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        await Promise.allSettled(allPromises);
+    }
+    async run() {
+        await super.pushResources();
+        const ignoreProcessVersions = (await this.globalConfig.getSetting(settings_1.SettingKeys.IGNORE_PROCESS_VERSIONS)) === 'true';
+        if (!ignoreProcessVersions) {
+            await this.pushVersioned();
+        }
+    }
+}
+ProcessesPush.description = 'Update cloud processes with local ones';
+ProcessesPush.examples = ['$ fcode processes:push'];
+ProcessesPush.args = types_1.ResourceSlugArg;
+ProcessesPush.flags = types_1.ForceFlag;
+exports.default = ProcessesPush;

package/dist/commands/processes/remove.d.ts

@@ -0,0 +1,9 @@
+import ProcessesCommand from '../../core/commands/processes-command';
+export default class ProcessRemove extends ProcessesCommand {
+    static description: string;
+    static args: {
+        resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/processes/remove.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@oclif/color");
+const processes_command_1 = require("../../core/commands/processes-command");
+const types_1 = require("../../core/types");
+const cli_1 = require("../../utils/cli");
+class ProcessRemove extends processes_command_1.default {
+    async run() {
+        if (!this.resourceSlug) {
+            cli_1.default.log(color_1.default.red(`You must specify a process slug`));
+            return;
+        }
+        await super.removeResource(this.resourceSlug);
+    }
+}
+ProcessRemove.description = 'Remove track of local processes';
+ProcessRemove.args = types_1.ResourceSlugArg;
+ProcessRemove.examples = ['$ fcode process:remove process-slug'];
+exports.default = ProcessRemove;

package/dist/commands/processes/reset.d.ts

@@ -0,0 +1,9 @@
+import ProcessesCommand from '../../core/commands/processes-command';
+export default class ProcessesReset extends ProcessesCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/processes/reset.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const processes_command_1 = require("../../core/commands/processes-command");
+const types_1 = require("../../core/types");
+class ProcessesReset extends processes_command_1.default {
+    async run() {
+        await super.resetResources();
+    }
+}
+ProcessesReset.description = 'Reset processes with contents from current remote';
+ProcessesReset.examples = ['$ fcode processes:reset'];
+ProcessesReset.args = types_1.ResourceSlugArg;
+exports.default = ProcessesReset;

package/dist/commands/processes/status.d.ts

@@ -0,0 +1,11 @@
+import { type MergedResource } from '../../core/types';
+import ProcessesCommand from '../../core/commands/processes-command';
+export default class ProcessesStatus extends ProcessesCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    resourcesTableLog(resources: Array<MergedResource>): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/processes/status.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../core/types");
+const processes_command_1 = require("../../core/commands/processes-command");
+const colorize_resource_1 = require("../../utils/colorize-resource");
+const cli_1 = require("../../utils/cli");
+class ProcessesStatus extends processes_command_1.default {
+    async resourcesTableLog(resources) {
+        const hasInherited = resources.some((resource) => resource.resolvingTeamSlug);
+        cli_1.cli.table(resources, {
+            slug: {
+                get(resource) {
+                    return (0, colorize_resource_1.colorizeByStatus)(resource.slug, resource.status);
+                },
+                header: 'slug',
+            },
+            name: {
+                get(resource) {
+                    return (0, colorize_resource_1.colorizeByStatus)(resource.name, resource.status);
+                },
+                header: 'name',
+            },
+            programmingLanguage: {
+                get(resource) {
+                    return (0, colorize_resource_1.colorizeByStatus)(resource.script.programmingLanguage, resource.status);
+                },
+                header: 'language',
+            },
+            tags: {
+                get(resource) {
+                    return (0, colorize_resource_1.colorizeByStatus)(resource.tags?.join(', '), resource.status);
+                },
+                header: 'tags',
+            },
+            ...(hasInherited && {
+                inherited: {
+                    get(resource) {
+                        return (0, colorize_resource_1.colorizeByStatus)(resource.resolvingTeamSlug ? `🔗 ${resource.resolvingTeamSlug}` : '', resource.status);
+                    },
+                    header: 'inherited',
+                },
+            }),
+            status: {
+                get({ status }) {
+                    return (0, colorize_resource_1.colorizeByStatus)(status, status);
+                },
+                header: 'status',
+            },
+        }, { sort: 'name' });
+    }
+    async run() {
+        await this.resourcesLog();
+    }
+}
+ProcessesStatus.description = 'List all processes status';
+ProcessesStatus.examples = ['$ fcode processes:status'];
+ProcessesStatus.args = types_1.ResourceSlugArg;
+exports.default = ProcessesStatus;

package/dist/commands/pull.d.ts

@@ -0,0 +1,9 @@
+import BaseCommand from '../core/commands/base-command';
+export default class PullCommand extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/pull.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_command_1 = require("../core/commands/base-command");
+const pull_1 = require("./modules/pull");
+const pull_2 = require("./processes/pull");
+const pull_3 = require("./variables/pull");
+const pull_4 = require("./dependencies/pull");
+const pull_5 = require("./team/pull");
+const types_1 = require("../core/types");
+const gitignore_1 = require("../utils/gitignore");
+class PullCommand extends base_command_1.default {
+    async run() {
+        const { flags: { force }, } = await this.parse(PullCommand);
+        const args = [];
+        if (force) {
+            args.push('--force');
+        }
+        await pull_2.default.run(args);
+        await pull_1.default.run(args);
+        await pull_3.default.run(args);
+        await pull_4.default.run(args);
+        // Team settings are pulled last so process metadata is available to resolve the
+        // error-handler process id to its slug.
+        await pull_5.default.run([]);
+        // Keep inherited resources out of git now that all resource metadata is saved.
+        await (0, gitignore_1.syncInheritedGitignore)();
+    }
+}
+PullCommand.description = 'Fetch from cloud team workspace and update local workspace';
+PullCommand.examples = ['$ fcode pull'];
+PullCommand.flags = types_1.ForceFlag;
+exports.default = PullCommand;

package/dist/commands/push.d.ts

@@ -0,0 +1,9 @@
+import BaseCommand from '../core/commands/base-command';
+export default class PushCommand extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/push.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_command_1 = require("../core/commands/base-command");
+const push_1 = require("./modules/push");
+const push_2 = require("./processes/push");
+const push_3 = require("./variables/push");
+const push_4 = require("./dependencies/push");
+const push_5 = require("./team/push");
+const types_1 = require("../core/types");
+class PushCommand extends base_command_1.default {
+    async run() {
+        const { flags: { force }, } = await this.parse(PushCommand);
+        const args = [];
+        if (force) {
+            args.push('--force');
+        }
+        await push_2.default.run(args);
+        await push_1.default.run(args);
+        await push_3.default.run(args);
+        await push_4.default.run(args);
+        // Team settings are pushed last so the error-handler process exists to resolve
+        // its slug to an id.
+        await push_5.default.run(args);
+    }
+}
+PushCommand.description = 'Update cloud team workspace with local workspace';
+PushCommand.examples = ['$ fcode push'];
+PushCommand.flags = types_1.ForceFlag;
+exports.default = PushCommand;

package/dist/commands/remote/add.d.ts

@@ -0,0 +1,10 @@
+import BaseCommand from '../../core/commands/base-command';
+export default class RemoteAdd extends BaseCommand {
+    static args: {
+        team: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    init(): Promise<void>;
+    run(): Promise<void>;
+}