@factorialco/fcode-cli 1.1.0

package/dist/commands/remote/add.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const global_1 = require("../../config/global");
+const base_command_1 = require("../../core/commands/base-command");
+const types_1 = require("../../core/types");
+const cli_1 = require("../../utils/cli");
+class RemoteAdd extends base_command_1.default {
+    async init() {
+        const { args } = await this.parse(RemoteAdd);
+        let { url } = (0, global_1.parseTeamOrigin)(args.team || '');
+        await super.init(url);
+    }
+    async run() {
+        const { args } = await this.parse(RemoteAdd);
+        const slugWithOptionalUrl = args.team || '';
+        let { slug, url } = (0, global_1.parseTeamOrigin)(slugWithOptionalUrl);
+        // Access is enforced by the platform on pull; the cached group list is only a hint
+        // (it goes stale for teams created after login), never a permission gate.
+        if (!slug) {
+            const userInfo = await new global_1.default().getUserInfo(url);
+            cli_1.default.log(`🏢  Your teams: \n\t${(userInfo.groups ?? []).join('\n\t')}`);
+            return;
+        }
+        await this.workspaceConfig.setActiveTeam(slugWithOptionalUrl);
+        cli_1.default.log(`🌩️  ${slugWithOptionalUrl} team workspace remote added successfully and set as active!\n`);
+        cli_1.default.log(`Change active team with command 'fcode remote:set [team]'`);
+    }
+}
+RemoteAdd.args = types_1.TeamNameArg;
+RemoteAdd.description = 'Add a remote team workspace';
+RemoteAdd.examples = ['$ fcode remote:add'];
+exports.default = RemoteAdd;

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

@@ -0,0 +1,7 @@
+import BaseCommand from '../../core/commands/base-command';
+export default class RemoteList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    init(): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/remote/list.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_command_1 = require("../../core/commands/base-command");
+const cli_1 = require("../../utils/cli");
+const color_1 = require("@oclif/color");
+const workspace_1 = require("../../config/workspace");
+class RemoteList extends base_command_1.default {
+    async init() {
+        this.workspaceConfig = new workspace_1.default();
+    }
+    async run() {
+        const config = await this.workspaceConfig.getAll();
+        const teams = Object.keys(config.teams || {});
+        const activeTeam = (await this.workspaceConfig.get('activeTeam')) || '';
+        if (teams.length === 0) {
+            cli_1.default.log('📋 No remote team workspaces added yet.');
+            cli_1.default.log(`Add one with ${color_1.default.cyan('fcode remote:add [team]')}`);
+            return;
+        }
+        cli_1.default.log('🏢 Remote team workspaces:\n');
+        for (const team of teams) {
+            const isActive = team === activeTeam;
+            const prefix = isActive ? `${color_1.default.green('*')} ` : '  ';
+            const suffix = isActive ? ` ${color_1.default.green('(active)')}` : '';
+            cli_1.default.log(`${prefix}${team}${suffix}`);
+        }
+        cli_1.default.log('');
+        cli_1.default.log(`Set active team with ${color_1.default.cyan('fcode remote:set [team]')}`);
+    }
+}
+RemoteList.description = 'List remote team workspaces';
+RemoteList.examples = ['$ fcode remote:list'];
+exports.default = RemoteList;

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

@@ -0,0 +1,10 @@
+import BaseCommand from '../../core/commands/base-command';
+export default class RemoteSet 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>;
+}

package/dist/commands/remote/set.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const global_1 = require("../../config/global");
+const base_command_1 = require("../../core/commands/base-command");
+const types_1 = require("../../core/types");
+const cli_1 = require("../../utils/cli");
+class RemoteSet extends base_command_1.default {
+    async init() {
+        const { args } = await this.parse(RemoteSet);
+        let { url } = (0, global_1.parseTeamOrigin)(args.team || '');
+        await super.init(url);
+    }
+    async run() {
+        const { args } = await this.parse(RemoteSet);
+        const slugWithOptionalUrl = args.team || '';
+        let { slug } = (0, global_1.parseTeamOrigin)(slugWithOptionalUrl);
+        if (!slug) {
+            cli_1.default.log(`🏢  Added teams: \n\t${(await this.workspaceConfig.getAddedTeams()).join('\n\t')}`);
+            return;
+        }
+        await this.workspaceConfig.setActiveTeam(slugWithOptionalUrl);
+        cli_1.default.log(`🔔  ${slugWithOptionalUrl} team workspace remote set as active!\n`);
+    }
+}
+RemoteSet.args = types_1.TeamNameArg;
+RemoteSet.description = 'Set the active remote team workspace';
+RemoteSet.examples = ['$ fcode remote:set [team]'];
+exports.default = RemoteSet;

package/dist/commands/reset.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Reset extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/reset.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const reset_1 = require("./processes/reset");
+const reset_2 = require("./modules/reset");
+const reset_3 = require("./variables/reset");
+const reset_4 = require("./dependencies/reset");
+class Reset extends core_1.Command {
+    async run() {
+        await this.parse(Reset);
+        await reset_1.default.run([]);
+        await reset_2.default.run([]);
+        await reset_3.default.run([]);
+        await reset_4.default.run([]);
+    }
+}
+Reset.description = 'Reset team workspace with contents from current remote';
+Reset.examples = ['$ fcode reset'];
+exports.default = Reset;

package/dist/commands/run.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class Run extends Command {
+    static args: {
+        slug: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static 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>;
+        jsonLogs: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        variablesFile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/run.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const path = require("node:path");
+const core_2 = require("@oclif/core");
+const process_runner_1 = require("../services/process-runner");
+class Run extends core_2.Command {
+    async run() {
+        const { args: { slug }, flags: { parameters: parametersFlag, version, logLevel, jsonLogs, variablesFile }, } = await this.parse(Run);
+        let parameters;
+        if (parametersFlag) {
+            try {
+                parameters = JSON.parse(parametersFlag);
+            }
+            catch (error) {
+                parameters = await Promise.resolve(`${path.resolve(parametersFlag)}`).then(s => require(s));
+            }
+        }
+        await (0, process_runner_1.runProcess)({ slug, parameters, version, logLevel, jsonLogs, extraVariablesFile: variablesFile });
+    }
+}
+Run.args = {
+    slug: core_1.Args.string({
+        description: 'Process slug',
+        name: 'slug',
+        required: true,
+    }),
+};
+Run.description = 'Run Factorial Code processes locally';
+Run.examples = ['$ fcode run [process-slug]', '$ fcode run --parameters ./parameters.json [process-slug]'];
+Run.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'],
+    }),
+    jsonLogs: core_1.Flags.boolean({
+        char: 'j',
+        description: 'Output process logs as newline-delimited JSON (NDJSON)',
+        default: false,
+    }),
+    variablesFile: core_1.Flags.string({
+        char: 'e',
+        description: 'Path to a .env file whose variables override workspace variables',
+    }),
+};
+exports.default = Run;

package/dist/commands/runtime-env.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+import VariableRepository from '../repositories/variable';
+export default class RuntimeEnv extends Command {
+    static readonly hidden = true;
+    static readonly args: {
+        language: 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[];
+    _variableRepository: VariableRepository;
+    run(): Promise<void>;
+}

package/dist/commands/runtime-env.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const path = require("node:path");
+const dependencies_1 = require("../core/utils/dependencies");
+const variable_1 = require("../repositories/variable");
+class RuntimeEnv extends core_1.Command {
+    constructor() {
+        super(...arguments);
+        this._variableRepository = new variable_1.default();
+    }
+    async run() {
+        const parsed = await this.parse(RuntimeEnv);
+        let { args: { language }, } = parsed;
+        const variables = await this._variableRepository.findAllForExecution();
+        const dependenciesPath = await (0, dependencies_1.getDependenciesPath)(language);
+        const libraryPath = path.join(__dirname, '..', 'runtime', 'libs', language === 'PYTHON' ? 'python' : 'node');
+        variables.forEach((variable) => {
+            console.log(`${variable.key}=${variable.value}`);
+        });
+        console.log('DEPENDENCIES_PATH=' + dependenciesPath);
+        console.log('LIBRARY_PATH=' + libraryPath);
+        if (language === 'PYTHON') {
+            console.log('PYTHONPATH=' + [dependenciesPath, libraryPath, process.cwd()].join(':'));
+        }
+        else {
+            console.log('NODE_PATH=' + [dependenciesPath, libraryPath, process.cwd()].join(':'));
+        }
+    }
+}
+RuntimeEnv.hidden = true;
+RuntimeEnv.args = {
+    language: core_1.Args.string({
+        description: 'Programming language',
+        name: 'language',
+        required: true,
+        options: ['PYTHON', 'JAVASCRIPT'],
+    }),
+};
+RuntimeEnv.description = 'Debug preparation for Factorial Code processes locally (without execution)';
+RuntimeEnv.examples = ['$ fcode runtime-env PYTHON', '$ fcode runtime-env JAVASCRIPT'];
+exports.default = RuntimeEnv;

package/dist/commands/settings/get.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class SettingsGet extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        key: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/settings/get.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const global_1 = require("../../config/global");
+const settings_1 = require("../../config/settings");
+const cli_1 = require("../../utils/cli");
+const color_1 = require("@oclif/color");
+class SettingsGet extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(SettingsGet);
+        const { key } = args;
+        try {
+            const globalConfig = new global_1.default();
+            const settings = (await globalConfig.get('settings')) || {};
+            if (key) {
+                const value = settings[key];
+                if (value != undefined) {
+                    cli_1.default.log(value);
+                }
+            }
+            else {
+                const allSettings = {};
+                if (flags['all']) {
+                    for (const settingDef of settings_1.SETTINGS_DEFINITIONS) {
+                        allSettings[settingDef.key] = settings[settingDef.key] !== undefined ? settings[settingDef.key] : settingDef.default;
+                    }
+                    const definedKeys = settings_1.SETTINGS_DEFINITIONS.map((def) => def.key);
+                    for (const [settingKey, settingValue] of Object.entries(settings)) {
+                        if (!definedKeys.includes(settingKey)) {
+                            allSettings[settingKey] = settingValue;
+                        }
+                    }
+                }
+                else {
+                    for (const [settingKey, settingValue] of Object.entries(settings)) {
+                        allSettings[settingKey] = settingValue;
+                    }
+                }
+                if (Object.keys(allSettings).length === 0) {
+                    cli_1.default.log(color_1.default.yellow('No settings are currently set'));
+                }
+                else {
+                    cli_1.default.log(JSON.stringify(allSettings, null, 2));
+                }
+            }
+        }
+        catch (error) {
+            cli_1.default.error(error.message);
+        }
+    }
+}
+SettingsGet.description = 'Get a setting value or all settings';
+SettingsGet.examples = [`$ fcode settings:get ${settings_1.SettingKeys.DISABLE_UPDATE_NOTIFIER}`, '$ fcode settings:get', '$ fcode settings:get --all'];
+SettingsGet.args = {
+    key: core_1.Args.string({
+        description: 'Setting key (optional, shows all settings if omitted)',
+        name: 'key',
+        required: false,
+    }),
+};
+SettingsGet.flags = {
+    all: core_1.Flags.boolean({
+        char: 'a',
+        description: 'Show all settings including defaults',
+    }),
+};
+exports.default = SettingsGet;

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

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class SettingsRemove extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        key: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/settings/remove.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const global_1 = require("../../config/global");
+const cli_1 = require("../../utils/cli");
+const color_1 = require("@oclif/color");
+const settings_1 = require("../../config/settings");
+class SettingsRemove extends core_1.Command {
+    async run() {
+        const { args } = await this.parse(SettingsRemove);
+        const { key } = args;
+        try {
+            const globalConfig = new global_1.default();
+            const removed = await globalConfig.removeSetting(key);
+            if (!removed) {
+                cli_1.default.log(color_1.default.yellow(`Setting '${key}' is not set`));
+                return;
+            }
+            cli_1.default.log(color_1.default.green(`✓ Setting '${key}' removed`));
+        }
+        catch (error) {
+            cli_1.default.error(error.message);
+        }
+    }
+}
+SettingsRemove.description = 'Remove a setting value';
+SettingsRemove.examples = [`$ fcode settings:remove ${settings_1.SettingKeys.DISABLE_UPDATE_NOTIFIER}`];
+SettingsRemove.args = {
+    key: core_1.Args.string({
+        description: 'Setting key',
+        name: 'key',
+        required: true,
+    }),
+};
+exports.default = SettingsRemove;

package/dist/commands/settings/set.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class SettingsSet extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        key: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/settings/set.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const global_1 = require("../../config/global");
+const cli_1 = require("../../utils/cli");
+const color_1 = require("@oclif/color");
+const settings_1 = require("../../config/settings");
+class SettingsSet extends core_1.Command {
+    async run() {
+        const { args } = await this.parse(SettingsSet);
+        const { key, value } = args;
+        try {
+            const globalConfig = new global_1.default();
+            await globalConfig.setSetting(key, value);
+            cli_1.default.log(color_1.default.green(`✓ Setting '${key}' set to ${JSON.stringify(value)}`));
+        }
+        catch (error) {
+            cli_1.default.error(error.message);
+        }
+    }
+}
+SettingsSet.description = 'Set a setting value';
+SettingsSet.examples = [
+    `$ fcode settings:set ${settings_1.SettingKeys.DISABLE_UPDATE_NOTIFIER} true`,
+    `$ fcode settings:set ${settings_1.SettingKeys.IGNORE_WORKSPACE_NOT_EMPTY} false`,
+];
+SettingsSet.args = {
+    key: core_1.Args.string({
+        description: 'Setting key',
+        name: 'key',
+        required: true,
+    }),
+    value: core_1.Args.string({
+        description: 'Setting value',
+        name: 'value',
+        required: true,
+    }),
+};
+exports.default = SettingsSet;

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

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+import ProcessRepository from '../repositories/process';
+export default class SetupDebug extends Command {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    _processRepository: ProcessRepository;
+    protected createLaunchFile(): Promise<void>;
+    protected createSettingsFile(): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/setup-debug.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const fs = require("fs-extra");
+const path = require("node:path");
+const cli_1 = require("../utils/cli");
+const dependencies_1 = require("../core/utils/dependencies");
+const process_1 = require("../repositories/process");
+class SetupDebug extends core_1.Command {
+    constructor() {
+        super(...arguments);
+        this._processRepository = new process_1.default();
+    }
+    async createLaunchFile() {
+        const launchJsonPath = path.join('.vscode', 'launch.json');
+        if (fs.existsSync(launchJsonPath)) {
+            if (!(await cli_1.default.confirm('⚠️  File .vscode/launch.json already exists. Do you want to overwrite it? yes/no'))) {
+                return;
+            }
+        }
+        if (!fs.existsSync('.vscode')) {
+            fs.mkdirSync('.vscode');
+        }
+        const processes = (await this._processRepository.findAll());
+        const configurations = [
+            {
+                name: 'Python Debugger: <Current File>',
+                type: 'debugpy',
+                request: 'launch',
+                program: path.join(__dirname, '..', 'runtime', 'executor.py'),
+                args: ['${file}'],
+                console: 'integratedTerminal',
+                justMyCode: true,
+                rules: [{ path: path.join(__dirname, '..', 'runtime'), include: false }],
+                env: {}
+            },
+            {
+                name: 'Node Debugger: <Current File>',
+                type: 'node',
+                request: 'launch',
+                program: path.join(__dirname, '..', 'runtime', 'executor.js'),
+                args: ['${file}'],
+                console: 'integratedTerminal',
+                env: {}
+            },
+        ];
+        for (const process of processes) {
+            if (process.script.programmingLanguage === 'PYTHON') {
+                configurations.push({
+                    name: `Python Debugger: ${process.slug}`,
+                    type: 'debugpy',
+                    request: 'launch',
+                    program: path.join(__dirname, '..', 'runtime', 'executor.py'),
+                    args: [await this._processRepository.getProcessFullPath(process.slug)],
+                    console: 'integratedTerminal',
+                    justMyCode: true,
+                    rules: [{ path: path.join(__dirname, '..', 'runtime'), include: false }],
+                    env: {}
+                });
+            }
+            else if (process.script.programmingLanguage === 'JAVASCRIPT') {
+                configurations.push({
+                    name: `Node Debugger: ${process.slug}`,
+                    type: 'node',
+                    request: 'launch',
+                    program: path.join(__dirname, '..', 'runtime', 'executor.js'),
+                    args: [await this._processRepository.getProcessFullPath(process.slug)],
+                    console: 'integratedTerminal',
+                    env: {}
+                });
+            }
+        }
+        if (process.env.YC_COMMAND) {
+            configurations.forEach((configuration) => {
+                configuration.env = {
+                    ...configuration.env,
+                    YC_COMMAND: process.env.YC_COMMAND
+                };
+            });
+        }
+        fs.outputJson(launchJsonPath, { configurations }, { encoding: 'utf-8', spaces: 2 });
+        console.log('✨ Created .vscode/launch.json');
+    }
+    async createSettingsFile() {
+        const settingsJsonPath = path.join('.vscode', 'settings.json');
+        let isUpdate = false;
+        let content = {};
+        if (fs.existsSync(settingsJsonPath)) {
+            if (!(await cli_1.default.confirm('⚠️  File .vscode/settings.json already exists. Do you want to overwrite configuration? yes/no'))) {
+                return;
+            }
+            content = fs.readJsonSync(settingsJsonPath);
+            isUpdate = true;
+        }
+        if (!fs.existsSync('.vscode')) {
+            fs.mkdirSync('.vscode');
+        }
+        const dependenciesPath = await (0, dependencies_1.getDependenciesPath)('PYTHON');
+        content['python.analysis.extraPaths'] = [path.join(__dirname, '..', 'runtime', 'libs', 'python'), dependenciesPath];
+        fs.writeJsonSync(settingsJsonPath, content, { encoding: 'utf-8', spaces: 2 });
+        if (isUpdate) {
+            console.log('✨ Updated .vscode/settings.json');
+        }
+        else {
+            console.log('✨ Created .vscode/settings.json');
+        }
+    }
+    async run() {
+        await this.parse(SetupDebug);
+        await this.createLaunchFile();
+        await this.createSettingsFile();
+    }
+}
+SetupDebug.args = {};
+SetupDebug.description = 'Setup vscode debug configurations';
+SetupDebug.examples = ['$ fcode setup-debug'];
+SetupDebug.flags = {};
+exports.default = SetupDebug;

package/dist/commands/status.d.ts

@@ -0,0 +1,6 @@
+import BaseCommand from '../core/commands/base-command';
+export default class Status extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/status.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_command_1 = require("../core/commands/base-command");
+const status_1 = require("./modules/status");
+const status_2 = require("./processes/status");
+const status_3 = require("./variables/status");
+const status_4 = require("./dependencies/status");
+const status_5 = require("./team/status");
+class Status extends base_command_1.default {
+    async run() {
+        await this.parse(Status);
+        await this.logActiveTeam();
+        await status_2.default.run([]);
+        await status_1.default.run([]);
+        await status_3.default.run([]);
+        await status_4.default.run([]);
+        await status_5.default.run([]);
+    }
+}
+Status.description = 'Show team workspace status';
+Status.examples = ['$ fcode status'];
+exports.default = Status;

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

@@ -0,0 +1,8 @@
+import ApiClientCommand from '../../core/commands/api-client-command';
+import TeamRepository from '../../repositories/team';
+export default class TeamPullCommand extends ApiClientCommand {
+    static description: string;
+    static examples: string[];
+    _teamRepository: TeamRepository;
+    run(): Promise<void>;
+}

package/dist/commands/team/pull.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@oclif/color");
+const api_client_command_1 = require("../../core/commands/api-client-command");
+const team_1 = require("../../repositories/team");
+const cli_1 = require("../../utils/cli");
+class TeamPullCommand extends api_client_command_1.default {
+    constructor() {
+        super(...arguments);
+        this._teamRepository = new team_1.default();
+    }
+    async run() {
+        await this.parse(TeamPullCommand);
+        cli_1.default.log(color_1.default.cyan('\n🗄️  pulling team settings...'));
+        const raw = await this._fcodeGraphQLClient.team();
+        const team = await this._teamRepository.fromRaw(raw);
+        this._teamRepository.save(team);
+        await this.workspaceConfig.setTeamStoredHash(team.contentHash);
+    }
+}
+TeamPullCommand.description = 'Fetch team settings (timezone, error handler, inheritance) from cloud into team.json';
+TeamPullCommand.examples = ['$ fcode team:pull'];
+exports.default = TeamPullCommand;