@factorialco/fcode-cli 1.1.0

package/bin/dev

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+const oclif = require('@oclif/core')
+
+const path = require('path')
+const project = path.join(__dirname, '..', 'tsconfig.json')
+
+// In dev mode -> use ts-node and dev plugins
+process.env.NODE_ENV = 'development'
+
+require('ts-node').register({project})
+
+// In dev mode, always show stack traces
+oclif.settings.debug = true;
+
+// Start the CLI
+oclif.run().then(oclif.flush).catch(oclif.Errors.handle)

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\dev" %*

package/bin/run

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+const { run, handle, flush } = require('@oclif/core')
+
+run()
+  .catch(async (error) => handle(error))
+  .finally(async () => flush())

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/dist/commands/add.d.ts

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

package/dist/commands/add.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_command_1 = require("../core/commands/base-command");
+const add_1 = require("./processes/add");
+const add_2 = require("./modules/add");
+const add_3 = require("./variables/add");
+const add_4 = require("./dependencies/add");
+const cli_1 = require("../utils/cli");
+class AddCommand extends base_command_1.default {
+    async run() {
+        await this.parse(AddCommand);
+        await this.logActiveTeam();
+        cli_1.default.log('');
+        await add_1.default.run([]);
+        await add_2.default.run([]);
+        await add_3.default.run([]);
+        await add_4.default.run([]);
+    }
+}
+AddCommand.description = 'Keeps track of new local components';
+AddCommand.examples = ['$ fcode add'];
+exports.default = AddCommand;

package/dist/commands/clone.d.ts

@@ -0,0 +1,26 @@
+import { Command } from '@oclif/core';
+import { TeamOrigin } from '../core/types';
+export default class Clone extends Command {
+    static args: {
+        team: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        skipSkillsSetup: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    checkWorkspaceAlreadyCloned(slug: string): Promise<void>;
+    checkWorkspaceIsEmpty(slug: string): Promise<void>;
+    cloneTeam(origin: TeamOrigin, skipSkillsSetup?: boolean): Promise<void>;
+    createWorkspaceConfig(origin: TeamOrigin): Promise<void>;
+    createWorkspaceDatastore(slug: string): void;
+    createWorkspaceStorage(slug: string): void;
+    createWorkspaceGitIgnore(slug: string): Promise<void>;
+    createWorkspaceLocalVariables(slug: string): Promise<void>;
+    private skillsInstallHint;
+    setupSkills(): Promise<void>;
+    catch(error: any): Promise<void>;
+    init(): Promise<void>;
+    mkdirWorkspace(slug: string): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/clone.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const node_child_process_1 = require("node:child_process");
+const fs = require("fs-extra");
+const path = require("node:path");
+const global_1 = require("../config/global");
+const workspace_1 = require("../config/workspace");
+const pull_1 = require("./pull");
+const types_1 = require("../core/types");
+const cli_1 = require("../utils/cli");
+const settings_1 = require("../config/settings");
+const SKILLS_REPO = 'factorialco/factorial-code-skills';
+class Clone extends core_1.Command {
+    async checkWorkspaceAlreadyCloned(slug) {
+        try {
+            await new workspace_1.default(path.join(process.cwd(), slug)).getActiveTeam();
+        }
+        catch {
+            return;
+        }
+        this.error(`Workspace '${slug}' already cloned.`, {
+            code: 'ERR_WORKSPACE_ALREADY_CLONED',
+            exit: 1,
+            suggestions: [`cd ${slug}`, 'fcode pull'],
+        });
+    }
+    async checkWorkspaceIsEmpty(slug) {
+        const files = fs.readdirSync(slug);
+        if (files.length == 0) {
+            return;
+        }
+        const envValue = process.env.IGNORE_WORKSPACE_NOT_EMPTY;
+        const ignoreWorkspaceNotEmpty = envValue === 'true' || envValue === 'false'
+            ? envValue === 'true'
+            : (await new global_1.default().getSetting(settings_1.SettingKeys.IGNORE_WORKSPACE_NOT_EMPTY)) === 'true';
+        if (!ignoreWorkspaceNotEmpty) {
+            this.error(`Destination path '${slug}' already exists and is not empty.`, {
+                code: 'ERR_WORKSPACE_DIR_IS_NOT_EMPTY',
+                exit: 1,
+            });
+        }
+    }
+    async cloneTeam(origin, skipSkillsSetup = false) {
+        await this.mkdirWorkspace(origin.slug);
+        await this.createWorkspaceConfig(origin);
+        await this.createWorkspaceGitIgnore(origin.slug);
+        this.createWorkspaceDatastore(origin.slug);
+        this.createWorkspaceStorage(origin.slug);
+        await this.createWorkspaceLocalVariables(origin.slug);
+        process.chdir(origin.slug);
+        await pull_1.default.run([]);
+        if (!skipSkillsSetup) {
+            await this.setupSkills();
+        }
+    }
+    async createWorkspaceConfig(origin) {
+        const config = new workspace_1.default(path.join(process.cwd(), origin.slug));
+        await config.init(origin);
+    }
+    createWorkspaceDatastore(slug) {
+        fs.outputFileSync(path.join(slug, 'datastore.json'), '{}');
+    }
+    createWorkspaceStorage(slug) {
+        fs.mkdirSync(path.join(slug, 'storage'));
+    }
+    async createWorkspaceGitIgnore(slug) {
+        const globalConfig = new global_1.default();
+        const localVariablesFileName = await globalConfig.getSetting(settings_1.SettingKeys.LOCAL_VARIABLES_FILE_NAME);
+        const gitIgnorePatterns = [localVariablesFileName, 'datastore.json', '.env', 'storage/*'];
+        fs.outputFileSync(path.join(slug, '.gitignore'), gitIgnorePatterns.join('\n'));
+    }
+    async createWorkspaceLocalVariables(slug) {
+        const globalConfig = new global_1.default();
+        const localVariablesFileName = await globalConfig.getSetting(settings_1.SettingKeys.LOCAL_VARIABLES_FILE_NAME);
+        fs.outputFileSync(path.join(slug, localVariablesFileName), '');
+    }
+    skillsInstallHint() {
+        cli_1.default.log('💡 Install the Factorial Code agent skills later with:');
+        cli_1.default.log(`   npx skills add ${SKILLS_REPO} -s '*'`);
+    }
+    async setupSkills() {
+        cli_1.default.log('');
+        // `npx --yes skills add <repo> -s '*'` — preselect all skills; the skills CLI
+        // then handles scope (project/global) and assistant selection interactively.
+        await new Promise((resolve) => {
+            const child = (0, node_child_process_1.spawn)('npx', ['--yes', 'skills', 'add', SKILLS_REPO, '-s', '*'], { stdio: 'inherit' });
+            child.on('error', () => {
+                // npx not available (or failed to launch) — don't fail the clone, just tell the user how to do it.
+                cli_1.default.log("\n⚠️  Couldn't run npx automatically (is Node.js / npx installed?).");
+                this.skillsInstallHint();
+                resolve();
+            });
+            child.on('close', (code) => {
+                if (code !== 0) {
+                    cli_1.default.log("\n⚠️  Skill installation didn't complete.");
+                    this.skillsInstallHint();
+                }
+                resolve();
+            });
+        });
+    }
+    async catch(error) {
+        const suggestions = error?.suggestions ?? [];
+        const hint = suggestions.length > 0 ? ` Try this: ${suggestions.map((suggestion) => `'${suggestion}'`).join('\n')} \n` : '';
+        cli_1.default.error(error.message + hint);
+    }
+    async init() {
+        const { args } = await this.parse(Clone);
+        let { url } = (0, global_1.parseTeamOrigin)(args.team || '');
+        const { authUrl } = await new global_1.default().getAuthInfo(url);
+        await this.config.runHook('auth', { argv: [url, authUrl], id: 'login' });
+    }
+    async mkdirWorkspace(slug) {
+        return new Promise((resolve, reject) => {
+            fs.mkdir(slug, {}, (error) => {
+                if (error) {
+                    if (error.code === 'EEXIST') {
+                        this.checkWorkspaceAlreadyCloned(slug)
+                            .then(() => this.checkWorkspaceIsEmpty(slug))
+                            .then(() => resolve())
+                            .catch((err) => reject(err));
+                    }
+                    else {
+                        reject(error);
+                    }
+                }
+                else {
+                    const globalConfig = new global_1.default();
+                    globalConfig
+                        .getSetting(settings_1.SettingKeys.VARIABLES_FILE_NAME)
+                        .then((variablesFileName) => {
+                        fs.mkdirSync(path.join(slug, 'processes'));
+                        fs.mkdirSync(path.join(slug, 'modules'));
+                        fs.mkdirSync(path.join(slug, 'dependencies'));
+                        fs.createFileSync(path.join(slug, variablesFileName));
+                        resolve();
+                    })
+                        .catch((err) => reject(err));
+                }
+            });
+        });
+    }
+    async run() {
+        const { args, flags } = await this.parse(Clone);
+        let { slug, url } = (0, global_1.parseTeamOrigin)(args.team || '');
+        // Team access is enforced by the platform when pulling; we no longer gate on the
+        // locally cached group list, which goes stale for teams created after login.
+        if (!slug) {
+            const userInfo = await new global_1.default().getUserInfo(url);
+            const teams = userInfo.groups ?? [];
+            if (teams.length === 0) {
+                cli_1.default.log(`ℹ️  Pass a team to clone: fcode clone [team]`);
+            }
+            else {
+                cli_1.default.log(`🏢  Your teams: \n\t${teams.join('\n\t')}`);
+            }
+            return;
+        }
+        let skipSkillsSetup = flags.skipSkillsSetup;
+        if (skipSkillsSetup === undefined) {
+            skipSkillsSetup = (await new global_1.default().getSetting(settings_1.SettingKeys.SKIP_SKILLS_SETUP)) === 'true';
+        }
+        await this.cloneTeam({ url, slug }, skipSkillsSetup);
+        cli_1.default.log(`\n🎉  ${args.team} team workspace cloned successfully!\n`);
+        cli_1.default.log(`$ cd ${slug}\n`);
+    }
+}
+Clone.args = types_1.TeamNameArg;
+Clone.description = 'Clone team workspace from cloud';
+Clone.examples = ['$ fcode clone', '$ fcode clone [team]'];
+Clone.flags = {
+    skipSkillsSetup: core_1.Flags.boolean({
+        description: 'Skip installation of the Factorial Code agent skills',
+    }),
+};
+exports.default = Clone;

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

@@ -0,0 +1,9 @@
+import DependencyCommand from '../../core/commands/dependency-command';
+export default class DependenciesAdd extends DependencyCommand {
+    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/dependencies/add.js

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

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

@@ -0,0 +1,14 @@
+import BaseCommand from '../../core/commands/base-command';
+export default class Dependencies extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        programmingLanguage: import("@oclif/core/lib/interfaces").Arg<string, 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/dependencies/install.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../core/commands/base-command");
+const python_env_dependencies_1 = require("../../core/dependencies/python-env-dependencies");
+const javascript_env_dependencies_1 = require("../../core/dependencies/javascript-env-dependencies");
+const types_1 = require("../../core/types");
+class Dependencies extends base_command_1.default {
+    async run() {
+        await super.init();
+        const { args: { programmingLanguage }, flags: { check, reset, force }, } = await this.parse(Dependencies);
+        const languages = programmingLanguage === 'all' ? ['javascript', 'python'] : [programmingLanguage];
+        const args = [];
+        if (check) {
+            args.push('--check');
+        }
+        if (reset) {
+            args.push('--reset');
+        }
+        if (force) {
+            args.push('--force');
+        }
+        for (const language of languages) {
+            if ('PYTHON' === language.toUpperCase()) {
+                await python_env_dependencies_1.default.run(args);
+            }
+            else {
+                await javascript_env_dependencies_1.default.run(args);
+            }
+        }
+    }
+}
+Dependencies.description = 'Install Factorial Code dependencies';
+Dependencies.examples = ['$ fcode dependencies:install [programmingLanguage]'];
+Dependencies.args = {
+    programmingLanguage: core_1.Args.string({
+        description: 'Programming language',
+        name: 'programmingLanguage',
+        default: 'all',
+        options: ['all', 'javascript', 'python'],
+    }),
+};
+Dependencies.flags = types_1.DependenciesFlags;
+exports.default = Dependencies;

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

@@ -0,0 +1,12 @@
+import DependencyCommand from '../../core/commands/dependency-command';
+export default class DependenciesPull extends DependencyCommand {
+    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/dependencies/pull.js

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

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

@@ -0,0 +1,12 @@
+import DependencyCommand from '../../core/commands/dependency-command';
+export default class DependenciesPush extends DependencyCommand {
+    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/dependencies/push.js

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

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

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

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

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

@@ -0,0 +1,9 @@
+import DependencyCommand from '../../core/commands/dependency-command';
+export default class DependenciesStatus extends DependencyCommand {
+    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/dependencies/status.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dependency_command_1 = require("../../core/commands/dependency-command");
+const types_1 = require("../../core/types");
+class DependenciesStatus extends dependency_command_1.default {
+    async run() {
+        await this.resourcesLog();
+    }
+}
+DependenciesStatus.description = 'List all dependencies status';
+DependenciesStatus.examples = ['$ fcode dependencies:status'];
+DependenciesStatus.args = types_1.ResourceSlugArg;
+exports.default = DependenciesStatus;

package/dist/commands/http.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+export default class Http extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        port: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        logLevel: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'auth-user': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'auth-password': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        jsonLogs: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Enforces the process's configured webhook basic auth, simulating the cloud
+     * webhook endpoint. The username/password come from processes/<slug>/metadata.json;
+     * an env-var placeholder (e.g. $WEBHOOK_PASSWORD) is resolved against the workspace
+     * variables. Returns true when the request may proceed, false after writing a 401.
+     */
+    private _checkWebhookAuth;
+    private _handleProcessExecution;
+    private _sendResponse;
+}