@factorialco/fcode-cli 1.1.0

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

@@ -0,0 +1,11 @@
+import ApiClientCommand from '../../core/commands/api-client-command';
+import TeamRepository from '../../repositories/team';
+export default class TeamPushCommand extends ApiClientCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    _teamRepository: TeamRepository;
+    run(): Promise<void>;
+}

package/dist/commands/team/push.js

@@ -0,0 +1,41 @@
+"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 types_1 = require("../../core/types");
+const cli_1 = require("../../utils/cli");
+class TeamPushCommand extends api_client_command_1.default {
+    constructor() {
+        super(...arguments);
+        this._teamRepository = new team_1.default();
+    }
+    async run() {
+        const { flags: { force }, } = await this.parse(TeamPushCommand);
+        if (!this._teamRepository.exists()) {
+            return;
+        }
+        cli_1.default.log(color_1.default.cyan('\n☁️  pushing team settings...'));
+        const team = await this._teamRepository.find();
+        const storedHash = await this.workspaceConfig.getTeamStoredHash();
+        if (!force && storedHash === team.contentHash) {
+            cli_1.default.log('Team settings already up to date');
+            return;
+        }
+        const update = { parentTeamSlugs: team.parentTeamSlugs };
+        if (team.zoneId !== undefined) {
+            update.zoneId = team.zoneId;
+        }
+        if (team.errorHandlerConfig) {
+            const processId = await this._teamRepository.resolveSlugToId(team.errorHandlerConfig.processSlug);
+            update.executionErrorHandlerConfig = { processId, tag: team.errorHandlerConfig.tag ?? null };
+        }
+        await this._fcodeGraphQLClient.pushTeam(update);
+        await this.workspaceConfig.setTeamStoredHash(team.contentHash);
+        cli_1.default.log(color_1.default.green('✅ team settings pushed'));
+    }
+}
+TeamPushCommand.description = 'Update cloud team settings (timezone, error handler, inheritance) from team.json';
+TeamPushCommand.examples = ['$ fcode team:push'];
+TeamPushCommand.flags = types_1.ForceFlag;
+exports.default = TeamPushCommand;

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

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

package/dist/commands/team/status.js

@@ -0,0 +1,40 @@
+"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 TeamStatusCommand extends api_client_command_1.default {
+    constructor() {
+        super(...arguments);
+        this._teamRepository = new team_1.default();
+    }
+    async run() {
+        await this.parse(TeamStatusCommand);
+        cli_1.default.log(color_1.default.cyan('\nteam status'));
+        if (!this._teamRepository.exists()) {
+            cli_1.default.log('No team.json found');
+            return;
+        }
+        const local = await this._teamRepository.find();
+        const storedHash = await this.workspaceConfig.getTeamStoredHash();
+        const remote = await this._teamRepository.fromRaw(await this._fcodeGraphQLClient.team());
+        const localChanged = storedHash !== local.contentHash;
+        const remoteChanged = storedHash !== remote.contentHash;
+        if (localChanged && remoteChanged) {
+            cli_1.default.log(color_1.default.red('🔥 team settings conflict (changed both locally and in the cloud)'));
+        }
+        else if (localChanged) {
+            cli_1.default.log(color_1.default.yellow('🔺 team settings modified locally (run fcode team:push)'));
+        }
+        else if (remoteChanged) {
+            cli_1.default.log(color_1.default.yellow('🔻 team settings out of date (run fcode team:pull)'));
+        }
+        else {
+            cli_1.default.log(color_1.default.green('✅ team settings up to date'));
+        }
+    }
+}
+TeamStatusCommand.description = 'Show whether team settings (timezone, error handler, inheritance) differ from the cloud';
+TeamStatusCommand.examples = ['$ fcode team:status'];
+exports.default = TeamStatusCommand;

package/dist/commands/test/scaffold.d.ts

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

package/dist/commands/test/scaffold.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("node:fs");
+const path = require("node:path");
+const core_1 = require("@oclif/core");
+const core_2 = require("@oclif/core");
+const process_1 = require("../../repositories/process");
+class TestScaffold extends core_2.Command {
+    async run() {
+        const { args: { slug } } = await this.parse(TestScaffold);
+        const processRepository = new process_1.default();
+        const fcodeProcess = await processRepository.find(slug);
+        const isPython = fcodeProcess.script.programmingLanguage === 'PYTHON';
+        const testsDir = path.join(process.cwd(), 'processes', slug, 'tests');
+        const testCaseDir = path.join(testsDir, '01-first-test');
+        if (fs.existsSync(testCaseDir)) {
+            this.error(`Test directory already exists: ${testCaseDir}`);
+        }
+        fs.mkdirSync(testCaseDir, { recursive: true });
+        fs.writeFileSync(path.join(testCaseDir, 'input.json'), JSON.stringify({}, null, 2) + '\n');
+        fs.writeFileSync(path.join(testCaseDir, 'output.json'), JSON.stringify({}, null, 2) + '\n');
+        const hooksFile = isPython ? 'testHooks.py' : 'testHooks.js';
+        const hooksContent = isPython
+            ? `def before():
+    pass
+    # fcode.datastore.set("key", "value")
+
+
+def after():
+    pass
+    # fcode.datastore.del_("key")
+`
+            : `module.exports.before = async function before() {
+  // await fcode.datastore.set('key', 'value')
+}
+
+module.exports.after = async function after() {
+  // await fcode.datastore.del('key')
+}
+`;
+        fs.writeFileSync(path.join(testCaseDir, hooksFile), hooksContent);
+        this.log(`Created test scaffold for '${slug}':`);
+        this.log(`  processes/${slug}/tests/01-first-test/input.json`);
+        this.log(`  processes/${slug}/tests/01-first-test/output.json`);
+        this.log(`  processes/${slug}/tests/01-first-test/${hooksFile}`);
+        this.log(`\nEdit input.json with the parameters to pass, and output.json with the expected return value.`);
+        this.log(`Run with: fcode test ${slug}`);
+    }
+}
+TestScaffold.args = {
+    slug: core_1.Args.string({
+        description: 'Process slug to scaffold tests for',
+        name: 'slug',
+        required: true,
+    }),
+};
+TestScaffold.description = 'Create a starter test structure for a process';
+TestScaffold.examples = [
+    '$ fcode test:scaffold my-process',
+];
+exports.default = TestScaffold;

package/dist/commands/test.d.ts

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

package/dist/commands/test.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const core_2 = require("@oclif/core");
+const process_1 = require("../repositories/process");
+const test_runner_1 = require("../services/test-runner");
+class Test extends core_2.Command {
+    async run() {
+        const { args: { slug }, flags: { logLevel, jsonLogs }, } = await this.parse(Test);
+        const processRepository = new process_1.default();
+        const options = { logLevel, jsonLogs };
+        if (slug) {
+            const fcodeProcess = await processRepository.find(slug);
+            const suiteResult = await (0, test_runner_1.runProcessTests)(fcodeProcess, options);
+            if (suiteResult.results.length === 0) {
+                this.log(`No tests found for process '${slug}'. Add a 'tests/' folder under processes/${slug}/.`);
+                return;
+            }
+            (0, test_runner_1.printTestResults)([suiteResult]);
+            const anyFailed = suiteResult.results.some((r) => !r.passed);
+            if (anyFailed)
+                this.exit(1);
+        }
+        else {
+            const processes = await processRepository.findAll();
+            if (processes.length === 0) {
+                this.log('No processes found in workspace.');
+                return;
+            }
+            const suiteResults = [];
+            for (const p of processes) {
+                suiteResults.push(await (0, test_runner_1.runProcessTests)(p, options));
+            }
+            const withTests = suiteResults.filter((s) => s.results.length > 0);
+            if (withTests.length === 0) {
+                this.log("No tests found. Add a 'tests/' folder to any process directory to get started.");
+                return;
+            }
+            (0, test_runner_1.printTestResults)(withTests);
+            const anyFailed = withTests.some((s) => s.results.some((r) => !r.passed));
+            if (anyFailed)
+                this.exit(1);
+        }
+    }
+}
+Test.args = {
+    slug: core_1.Args.string({
+        description: 'Process slug (omit to test all processes)',
+        name: 'slug',
+        required: false,
+    }),
+};
+Test.description = 'Run tests for Factorial Code processes';
+Test.examples = [
+    '$ fcode test',
+    '$ fcode test [process-slug]',
+    '$ fcode test --logLevel DEBUG [process-slug]',
+];
+Test.flags = {
+    logLevel: core_1.Flags.string({
+        char: 'l',
+        description: 'Log level for process execution during tests',
+        default: 'ERROR',
+        options: ['DEBUG', 'INFO', 'WARNING', 'ERROR'],
+    }),
+    jsonLogs: core_1.Flags.boolean({
+        char: 'j',
+        description: 'Output process logs as newline-delimited JSON (NDJSON)',
+        default: false,
+    }),
+};
+exports.default = Test;

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

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

package/dist/commands/variables/add.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const variables_command_1 = require("../../core/commands/variables-command");
+const types_1 = require("../../core/types");
+class VariablesAdd extends variables_command_1.default {
+    async run() {
+        const { flags: { sensitive }, } = await this.parse(VariablesAdd);
+        await super.addResources({ variableSensitive: sensitive });
+    }
+}
+VariablesAdd.description = 'Keeps track of a new local variables';
+VariablesAdd.examples = ['$ fcode variables:add'];
+VariablesAdd.args = types_1.ResourceSlugArg;
+VariablesAdd.flags = {
+    sensitive: core_1.Flags.boolean({
+        char: 's',
+        description: 'Add variable as sensitive',
+    }),
+};
+exports.default = VariablesAdd;

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

@@ -0,0 +1,12 @@
+import VariablesCommand from '../../core/commands/variables-command';
+export default class VariablesPull extends VariablesCommand {
+    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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/variables/pull.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const variables_command_1 = require("../../core/commands/variables-command");
+const types_1 = require("../../core/types");
+class VariablesPull extends variables_command_1.default {
+    async run() {
+        await super.pullResources();
+    }
+}
+VariablesPull.description = 'Fetch all variables from cloud and save them locally';
+VariablesPull.examples = ['$ fcode variables:pull'];
+VariablesPull.args = types_1.ResourceSlugArg;
+VariablesPull.flags = types_1.ForceFlag;
+exports.default = VariablesPull;

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

@@ -0,0 +1,12 @@
+import VariablesCommand from '../../core/commands/variables-command';
+export default class VariablesPush extends VariablesCommand {
+    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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/variables/push.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const variables_command_1 = require("../../core/commands/variables-command");
+const types_1 = require("../../core/types");
+class VariablesPush extends variables_command_1.default {
+    async run() {
+        await super.pushResources();
+    }
+}
+VariablesPush.description = 'Create cloud variables from local ones';
+VariablesPush.examples = ['$ fcode variables:push'];
+VariablesPush.args = types_1.ResourceSlugArg;
+VariablesPush.flags = types_1.ForceFlag;
+exports.default = VariablesPush;

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

@@ -0,0 +1,9 @@
+import VariablesCommand from '../../core/commands/variables-command';
+export default class VariablesRemove extends VariablesCommand {
+    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/variables/remove.js

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

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

@@ -0,0 +1,9 @@
+import VariablesCommand from '../../core/commands/variables-command';
+export default class VariablesReset extends VariablesCommand {
+    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/variables/reset.js

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

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

@@ -0,0 +1,12 @@
+import { type MergedResource } from '../../core/types';
+import VariablesCommand from '../../core/commands/variables-command';
+export default class VariablesStatus extends VariablesCommand {
+    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>;
+    private logVariableWarnings;
+    run(): Promise<void>;
+}

package/dist/commands/variables/status.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("../../utils/cli");
+const types_1 = require("../../core/types");
+const variables_command_1 = require("../../core/commands/variables-command");
+const colorize_resource_1 = require("../../utils/colorize-resource");
+const variable_warnings_1 = require("../../utils/variable-warnings");
+const global_1 = require("../../config/global");
+const settings_1 = require("../../config/settings");
+class VariablesStatus extends variables_command_1.default {
+    async resourcesTableLog(resources) {
+        const globalConfig = new global_1.default();
+        const localVariablesFileName = await globalConfig.getSetting(settings_1.SettingKeys.LOCAL_VARIABLES_FILE_NAME);
+        cli_1.cli.table(resources, {
+            key: {
+                get({ key, status }) {
+                    return (0, colorize_resource_1.colorizeByStatus)(key, status);
+                },
+                header: 'key',
+            },
+            status: {
+                get({ status }) {
+                    return (0, colorize_resource_1.colorizeByStatus)(status, status);
+                },
+                header: 'status',
+            },
+            value: {
+                get({ isSensitive, value, status, overriddenLocally }) {
+                    if (!isSensitive) {
+                        return (0, colorize_resource_1.colorizeByStatus)(value || '', status);
+                    }
+                    return (0, colorize_resource_1.colorizeByStatus)(overriddenLocally ? '🤐' : `🤐 (use ${localVariablesFileName} to override)`, status);
+                },
+                header: 'value',
+            },
+            localOverride: {
+                get({ overriddenLocally }) {
+                    return overriddenLocally ? `↩︎ ${localVariablesFileName}` : '';
+                },
+                header: 'local override',
+            },
+        }, { sort: 'key' });
+        this.logVariableWarnings(resources, localVariablesFileName);
+    }
+    logVariableWarnings(resources, localVariablesFileName) {
+        const sensitivityChanged = resources.filter((resource) => resource.status === types_1.ResourceStatus.SENSITIVITY_CHANGED);
+        (0, variable_warnings_1.warnSensitivityChanged)(sensitivityChanged.map((resource) => resource.slug));
+        const tampered = resources.filter((resource) => (0, variable_warnings_1.isTamperedSensitive)(resource));
+        (0, variable_warnings_1.warnTamperedSensitive)(tampered.map((resource) => resource.slug), localVariablesFileName);
+    }
+    async run() {
+        await this.resourcesLog();
+    }
+}
+VariablesStatus.description = 'List all variables status';
+VariablesStatus.examples = ['$ fcode variables:status'];
+VariablesStatus.args = types_1.ResourceSlugArg;
+exports.default = VariablesStatus;

package/dist/config/global.d.ts

@@ -0,0 +1,15 @@
+import type { AuthInfo, TeamOrigin, UserInfo } from '../core/types';
+import Config from './index';
+export declare const FCODE_CLOUD_URL: string;
+export declare function parseTeamOrigin(slug: string): TeamOrigin;
+declare class GlobalConfig extends Config {
+    constructor();
+    clearAuthInfo(url: string): Promise<void>;
+    getAuthInfo(url: string): Promise<AuthInfo>;
+    getUserInfo(url: string): Promise<UserInfo>;
+    setAuthInfo(url: string, authInfo?: AuthInfo): Promise<void>;
+    getSetting(key: string): Promise<string>;
+    setSetting(key: string, value: string): Promise<void>;
+    removeSetting(key: string): Promise<boolean>;
+}
+export default GlobalConfig;

package/dist/config/global.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FCODE_CLOUD_URL = void 0;
+exports.parseTeamOrigin = parseTeamOrigin;
+const fs = require("fs-extra");
+const path = require("node:path");
+const errors_1 = require("../core/errors");
+const index_1 = require("./index");
+const settings_1 = require("./settings");
+exports.FCODE_CLOUD_URL = process.env.FCODE_CLOUD_URL || 'https://code.factorial.dev/platform';
+function parseTeamOrigin(slug) {
+    if (!slug) {
+        return { url: exports.FCODE_CLOUD_URL, slug: '' };
+    }
+    let url;
+    try {
+        const { origin } = new URL(slug);
+        slug = slug.replaceAll(origin + '/', '');
+        url = origin;
+    }
+    catch (e) {
+        url = exports.FCODE_CLOUD_URL;
+    }
+    return { url, slug };
+}
+class GlobalConfig extends index_1.default {
+    constructor() {
+        super(path.join(index_1.default.FCODE_CONFIG_PATH));
+    }
+    async clearAuthInfo(url) {
+        await this.setAuthInfo(url);
+    }
+    async getAuthInfo(url) {
+        if (await this.get('auth')) {
+            // TODO: Remove this legacy auth config
+            fs.removeSync(this.configPath);
+        }
+        const auth = await this.get(url);
+        if (auth) {
+            return auth;
+        }
+        throw new errors_1.NotAuthenticated(url);
+    }
+    async getUserInfo(url) {
+        const authInfo = await this.getAuthInfo(url);
+        if (authInfo) {
+            return authInfo.userInfo;
+        }
+        throw new errors_1.NotAuthenticated(url);
+    }
+    async setAuthInfo(url, authInfo) {
+        await this.set(url, authInfo);
+    }
+    async getSetting(key) {
+        const settings = (await this.get('settings')) || {};
+        if (settings[key] !== undefined) {
+            return settings[key];
+        }
+        const defaultValue = (0, settings_1.getSettingDefault)(key);
+        return defaultValue !== undefined ? defaultValue : '';
+    }
+    async setSetting(key, value) {
+        const currentSettings = (await this.get('settings')) || {};
+        const updatedSettings = { ...currentSettings, [key]: value };
+        await this.set('settings', updatedSettings);
+    }
+    async removeSetting(key) {
+        const currentSettings = (await this.get('settings')) || {};
+        if (!(key in currentSettings)) {
+            return false;
+        }
+        const { [key]: removed, ...updatedSettings } = currentSettings;
+        await this.set('settings', updatedSettings);
+        return true;
+    }
+}
+exports.default = GlobalConfig;

package/dist/config/index.d.ts

@@ -0,0 +1,14 @@
+import type { Config as ConfigType } from '../core/types';
+declare class Config {
+    static FCODE_CONFIG_PATH: string;
+    static FCODE_CONFIG_FILENAME: string;
+    static FCODE_DEPENDENCIES_FOLDER: string;
+    protected configPath: string;
+    protected configDir: string;
+    constructor(configDir: string, filename?: string);
+    static initConfig(configPath: string, config: ConfigType): void;
+    get<T>(key: string): Promise<T | undefined>;
+    getAll(): Promise<ConfigType>;
+    set<T>(key: string, value: T): Promise<void>;
+}
+export default Config;

package/dist/config/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = require("node:os");
+const fs = require("fs-extra");
+const path = require("node:path");
+const errors_1 = require("../core/errors");
+class Config {
+    constructor(configDir, filename = Config.FCODE_CONFIG_FILENAME) {
+        this.configDir = configDir;
+        this.configPath = path.join(configDir, filename);
+        if (!fs.pathExistsSync(this.configPath)) {
+            fs.mkdirpSync(path.dirname(this.configPath));
+        }
+    }
+    static initConfig(configPath, config) {
+        fs.writeJsonSync(configPath, config, { spaces: 2 });
+    }
+    async get(key) {
+        if (fs.pathExistsSync(this.configPath)) {
+            const { [key]: value } = await this.getAll();
+            return value;
+        }
+        return undefined;
+    }
+    async getAll() {
+        if (fs.pathExistsSync(this.configPath)) {
+            return fs.readJsonSync(this.configPath);
+        }
+        return {};
+    }
+    async set(key, value) {
+        const config = await this.getAll();
+        try {
+            fs.writeJsonSync(this.configPath, { ...config, [key]: value }, { spaces: 2 });
+        }
+        catch {
+            throw new errors_1.NotFcodeWorkspace();
+        }
+    }
+}
+Config.FCODE_CONFIG_PATH = path.join(process.env.FCODE_CONFIG_PATH || os.homedir(), '.fcode');
+Config.FCODE_CONFIG_FILENAME = 'fcode.json';
+Config.FCODE_DEPENDENCIES_FOLDER = 'dependencies';
+exports.default = Config;

package/dist/config/remote.d.ts

@@ -0,0 +1,15 @@
+import { TeamMetadata } from '../core/types';
+export default class RemoteConfig {
+    static FCODE_REMOTE_CONFIG_FILENAME: string;
+    private configPath;
+    private remote;
+    hash: string;
+    private static configPath;
+    static save(hash: any, team: TeamMetadata, configPath?: string): void;
+    static get(hash: string, configPath?: string): TeamMetadata | undefined;
+    private static sortDeeply;
+    private static sort;
+    constructor(remote: string, configPath?: string);
+    init(): void;
+    private createDir;
+}