@factorialco/fcode-cli 1.1.0

package/dist/commands/http.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = require("node:crypto");
+const core_1 = require("@oclif/core");
+const http_server_1 = require("../services/http-server");
+const process_runner_1 = require("../services/process-runner");
+const process_1 = require("../repositories/process");
+const variable_1 = require("../repositories/variable");
+const workspace_1 = require("../config/workspace");
+class Http extends core_1.Command {
+    async run() {
+        const { flags: { port, logLevel, 'auth-user': authUser, 'auth-password': authPassword, jsonLogs }, } = await this.parse(Http);
+        const useBasicAuth = authUser !== undefined && authPassword !== undefined;
+        const expectedCredentials = useBasicAuth
+            ? Buffer.from(`${authUser}:${authPassword}`).toString('base64')
+            : null;
+        const { slug: teamSlug } = await new workspace_1.default().getTeamOrigin();
+        const processRepository = new process_1.default();
+        const handler = async (req, res) => {
+            // CORS headers
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Fcode-Async');
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            // Basic auth check
+            if (useBasicAuth) {
+                const authHeader = req.headers['authorization'] ?? '';
+                const match = authHeader.match(/^Basic (.+)$/);
+                if (!match || match[1] !== expectedCredentials) {
+                    res.setHeader('WWW-Authenticate', 'Basic realm="Factorial Code"');
+                    res.writeHead(401, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: false, error: 'Unauthorized' }));
+                    return;
+                }
+            }
+            const urlObj = new URL(req.url ?? '/', `http://localhost:${port}`);
+            // Expected path: /api/<team-slug>/<prefix>/<process-slug>
+            const segments = urlObj.pathname.replace(/^\//, '').split('/');
+            const [api, team, prefix, slug] = segments;
+            if (api !== 'api' || team !== teamSlug) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: false, error: `Not found. Expected path prefix: /api/${teamSlug}/` }));
+                return;
+            }
+            // Route: GET|POST /api/<team-slug>/forms/:slug
+            // GET  → return process parameters schema
+            // POST → trigger process execution (same as webhooks)
+            if (prefix === 'forms') {
+                if (!slug) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: false, error: `Process slug required in path (e.g. /api/${teamSlug}/forms/my-process)` }));
+                    return;
+                }
+                if (req.method === 'GET') {
+                    try {
+                        const process = await processRepository.find(slug);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ schema: process.script.parametersSchema ?? {} }));
+                    }
+                    catch (err) {
+                        res.writeHead(404, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: false, error: err?.message ?? String(err) }));
+                    }
+                    return;
+                }
+                await this._handleProcessExecution(req, res, slug, urlObj, logLevel, jsonLogs);
+                return;
+            }
+            // Route: GET|POST /api/<team-slug>/webhooks/:slug
+            if (prefix === 'webhooks') {
+                if (!slug) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: false, error: `Process slug required in path (e.g. /api/${teamSlug}/webhooks/my-process)` }));
+                    return;
+                }
+                if (!(await this._checkWebhookAuth(req, res, processRepository, slug))) {
+                    return;
+                }
+                await this._handleProcessExecution(req, res, slug, urlObj, logLevel, jsonLogs);
+                return;
+            }
+            // No matching route
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: `Not found. Available: /api/${teamSlug}/webhooks/:process-slug, /api/${teamSlug}/forms/:process-slug` }));
+        };
+        const server = await (0, http_server_1.startServer)(port, '0.0.0.0', (req, res) => {
+            handler(req, res).catch((err) => {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: false, error: String(err) }));
+            });
+        });
+        console.log(`HTTP server listening on http://0.0.0.0:${port}`);
+        console.log(`  GET|POST /api/${teamSlug}/webhooks/:process-slug — trigger a process`);
+        console.log(`  GET      /api/${teamSlug}/forms/:process-slug    — get process parameters schema`);
+        console.log(`  POST     /api/${teamSlug}/forms/:process-slug    — trigger a process`);
+        console.log(`\nExample:`);
+        console.log(`  curl -X POST http://localhost:${port}/api/${teamSlug}/webhooks/<process-slug> \\`);
+        console.log(`    -H "Content-Type: application/json" \\`);
+        console.log(`    -d '{"param1": "value1"}'`);
+        process.on('SIGINT', async () => {
+            console.log('\nShutting down HTTP server...');
+            await (0, http_server_1.stopServer)(server);
+            process.exit(0);
+        });
+        // Keep process alive
+        await new Promise(() => { });
+    }
+    /**
+     * 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.
+     */
+    async _checkWebhookAuth(req, res, processRepository, slug) {
+        let webhook;
+        try {
+            webhook = (await processRepository.find(slug)).webhook;
+        }
+        catch {
+            // Unknown process: let the execution path report the 404.
+            return true;
+        }
+        if (!webhook || (!webhook.username && !webhook.password)) {
+            return true;
+        }
+        const variables = await new variable_1.default().findAllForExecution();
+        const values = new Map(variables.map((variable) => [variable.key, variable.value]));
+        const resolvePlaceholder = (value) => {
+            if (!value)
+                return '';
+            const match = value.match(/^\$\{?([A-Za-z_]\w*)\}?$/);
+            return match ? values.get(match[1]) ?? value : value;
+        };
+        const expected = Buffer.from(`${resolvePlaceholder(webhook.username)}:${resolvePlaceholder(webhook.password)}`).toString('base64');
+        const authHeader = req.headers['authorization'] ?? '';
+        const match = authHeader.match(/^Basic (.+)$/);
+        if (!match || match[1] !== expected) {
+            res.setHeader('WWW-Authenticate', 'Basic realm="Factorial Code Webhook"');
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'Unauthorized' }));
+            return false;
+        }
+        return true;
+    }
+    async _handleProcessExecution(req, res, slug, urlObj, logLevel, jsonLogs) {
+        if (req.method !== 'GET' && req.method !== 'POST') {
+            res.writeHead(405, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'Method Not Allowed' }));
+            return;
+        }
+        const queryParams = {};
+        urlObj.searchParams.forEach((value, key) => {
+            queryParams[key] = value;
+        });
+        // Read request body
+        const rawBody = await new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+            req.on('error', reject);
+        });
+        // Parse body as JSON parameters
+        let bodyParams = {};
+        if (rawBody.trim()) {
+            try {
+                bodyParams = JSON.parse(rawBody);
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: false, error: 'Invalid JSON body' }));
+                return;
+            }
+        }
+        // Merge query params + body (body takes precedence)
+        const parameters = { ...queryParams, ...bodyParams };
+        // Async mode detection
+        const isAsync = req.headers['fcode-async'] === 'true' || queryParams['async'] === 'true';
+        // Build request context
+        const headers = {};
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (typeof value === 'string')
+                headers[key] = value;
+            else if (Array.isArray(value))
+                headers[key] = value.join(', ');
+        }
+        const webhookRequest = {
+            headers,
+            rawBody,
+            query: queryParams,
+            method: req.method ?? 'GET',
+        };
+        if (isAsync) {
+            const executionId = crypto.randomUUID();
+            const asyncResponse = queryParams['async_response'];
+            if (asyncResponse === 'false') {
+                res.writeHead(201);
+                res.end();
+            }
+            else if (asyncResponse !== undefined) {
+                res.writeHead(201, { 'Content-Type': 'text/plain' });
+                res.end(asyncResponse);
+            }
+            else {
+                res.writeHead(201, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ id: executionId, status: 'CREATED', data: null }));
+            }
+            // Fire and forget
+            (0, process_runner_1.runProcess)({ slug, parameters, logLevel, request: webhookRequest, jsonLogs }).catch((err) => {
+                console.error(`[http] Error executing process '${slug}':`, err);
+            });
+            return;
+        }
+        // Synchronous execution
+        try {
+            const returnValue = await (0, process_runner_1.runProcess)({ slug, parameters, logLevel, request: webhookRequest, jsonLogs });
+            this._sendResponse(res, returnValue);
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: err?.message ?? String(err) }));
+        }
+    }
+    _sendResponse(res, returnValue) {
+        if (returnValue !== null && returnValue !== undefined && typeof returnValue === 'object' && !Array.isArray(returnValue)) {
+            const rv = returnValue;
+            const status = typeof rv['status'] === 'number' ? rv['status'] : 200;
+            const customHeaders = rv['headers'] && typeof rv['headers'] === 'object' ? rv['headers'] : {};
+            const body = 'body' in rv ? rv['body'] : returnValue;
+            res.writeHead(status, { 'Content-Type': 'application/json', ...customHeaders });
+            res.end(JSON.stringify(body));
+        }
+        else {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(returnValue ?? { success: true }));
+        }
+    }
+}
+Http.description = 'Start a local HTTP server to trigger Factorial Code processes via webhooks and expose forms schema';
+Http.examples = [
+    '$ fcode http',
+    '$ fcode http --port 8080',
+    '$ fcode http --auth-user admin --auth-password secret',
+];
+Http.flags = {
+    port: core_1.Flags.integer({
+        char: 'P',
+        description: 'Port to listen on',
+        default: 3000,
+    }),
+    logLevel: core_1.Flags.string({
+        char: 'l',
+        description: 'Log level to use in process executions',
+        default: 'DEBUG',
+        options: ['DEBUG', 'INFO', 'WARNING', 'ERROR'],
+    }),
+    'auth-user': core_1.Flags.string({
+        description: 'Basic auth username',
+    }),
+    'auth-password': core_1.Flags.string({
+        description: 'Basic auth password',
+    }),
+    jsonLogs: core_1.Flags.boolean({
+        char: 'j',
+        description: 'Output process logs as newline-delimited JSON (NDJSON)',
+        default: false,
+    }),
+};
+exports.default = Http;

package/dist/commands/login.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class Login extends Command {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        url: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        authUrl: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        email: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        password: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        clientId: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        clientSecret: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        accessToken: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        prompt: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    init(): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/login.js

@@ -0,0 +1,62 @@
+"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");
+class Login extends core_1.Command {
+    async init() {
+        const { flags } = await this.parse(Login);
+        const { failures } = await this.config.runHook('auth', {
+            argv: [flags.url, flags.authUrl, flags.email, flags.password, flags.clientId, flags.clientSecret, flags.accessToken, flags.prompt],
+            id: 'login',
+        });
+        if (failures.length > 0) {
+            throw failures[0].error;
+        }
+    }
+    async run() {
+        const { flags } = await this.parse(Login);
+        const userInfo = await new global_1.default().getUserInfo(flags.url);
+        cli_1.default.log(`👋 Hi, ${userInfo.name}!`);
+    }
+}
+Login.args = {};
+Login.description = 'Login with your Factorial Code credentials (browser OAuth or email/password)';
+Login.examples = ['$ fcode login', '$ fcode login --prompt', '$ fcode login -e you@example.com -p your-password'];
+Login.flags = {
+    url: core_1.Flags.string({
+        char: 'u',
+        description: 'Factorial Code Cloud endpoint',
+        default: global_1.FCODE_CLOUD_URL,
+    }),
+    authUrl: core_1.Flags.string({
+        char: 'a',
+        description: 'Factorial Code Auth endpoint (including realm, ie: https://code.factorial.dev/auth/realms/fcode)). Only needed if auth domain is different than used cloud endpoint',
+    }),
+    email: core_1.Flags.string({
+        char: 'e',
+        description: 'Email (to be used with password)',
+    }),
+    password: core_1.Flags.string({
+        char: 'p',
+        description: 'Password (to be used with email)',
+    }),
+    clientId: core_1.Flags.string({
+        char: 'c',
+        description: 'Client ID (for oauth, to be used with Client Secret)',
+    }),
+    clientSecret: core_1.Flags.string({
+        char: 's',
+        description: 'Client Secret (for oauth, to be used with Client ID)',
+    }),
+    accessToken: core_1.Flags.string({
+        char: 't',
+        description: 'Access Token (to be used instead of email and password)',
+    }),
+    prompt: core_1.Flags.boolean({
+        char: 'x',
+        description: 'Prompt for email and password (instead of opening browser)',
+        default: false,
+    }),
+};
+exports.default = Login;

package/dist/commands/logout.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Logout extends Command {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        url: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/logout.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const auth_service_1 = require("../services/auth-service");
+const global_1 = require("../config/global");
+const errors_1 = require("../core/errors");
+const cli_1 = require("../utils/cli");
+class Logout extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(Logout);
+        try {
+            await auth_service_1.default.logout(flags.url);
+        }
+        catch (error) {
+            if (!(error instanceof errors_1.NotAuthenticated)) {
+                throw error;
+            }
+        }
+        finally {
+            cli_1.default.log('👋 Session ended. See you soon!');
+        }
+    }
+}
+Logout.args = {};
+Logout.description = 'Logout from Factorial Code';
+Logout.examples = ['$ fcode logout'];
+Logout.flags = {
+    url: core_1.Flags.string({
+        char: 'u',
+        description: 'Factorial Code Cloud endpoint',
+        default: global_1.FCODE_CLOUD_URL,
+    }),
+};
+exports.default = Logout;

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

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

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

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

@@ -0,0 +1,13 @@
+import ModulesCommand from '../../core/commands/modules-command';
+export default class ModulesPull extends ModulesCommand {
+    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/modules/pull.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@oclif/color");
+const modules_command_1 = require("../../core/commands/modules-command");
+const types_1 = require("../../core/types");
+const cli_1 = require("../../utils/cli");
+class ModulesPull extends modules_command_1.default {
+    async pullVersioned() {
+        const scriptLibraries = (await this._resourceRepository.findAll()).filter((scriptLibrary) => scriptLibrary.id);
+        const scriptLibraryRepository = this._resourceRepository;
+        const allPromises = [];
+        for (const scriptLibrary of scriptLibraries) {
+            allPromises.push(this._versionedResourceQuery(scriptLibrary.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 scriptLibraryRepository.getLocalVersionTags(scriptLibrary)) {
+                    if (!remoteVersionTags.has(localTag)) {
+                        cli_1.default.log(color_1.default.cyan(`🗑️  removing version '${localTag}' for module '${scriptLibrary.slug}'...`));
+                        scriptLibraryRepository.removeVersion(scriptLibrary, localTag);
+                    }
+                }
+                // Add only new (non-existing) versions
+                for (const versionedScriptLibrary of remoteVersions) {
+                    if (!scriptLibraryRepository.versionExistsLocally(scriptLibrary, versionedScriptLibrary.tag)) {
+                        cli_1.default.log(color_1.default.cyan(`🗂️  pulling version '${versionedScriptLibrary.tag}' for module '${scriptLibrary.slug}'...`));
+                        await scriptLibraryRepository.saveVersion(scriptLibrary, versionedScriptLibrary);
+                    }
+                }
+            }));
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        await Promise.allSettled(allPromises);
+    }
+    async run() {
+        await super.pullResources();
+        await this.pullVersioned();
+    }
+}
+ModulesPull.description = 'Fetch all modules from cloud and save them locally';
+ModulesPull.examples = ['$ fcode modules:pull'];
+ModulesPull.args = types_1.ResourceSlugArg;
+ModulesPull.flags = types_1.ForceFlag;
+exports.default = ModulesPull;

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

@@ -0,0 +1,13 @@
+import ModulesCommand from '../../core/commands/modules-command';
+export default class ModulesPush extends ModulesCommand {
+    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/modules/push.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@oclif/color");
+const modules_command_1 = require("../../core/commands/modules-command");
+const types_1 = require("../../core/types");
+const cli_1 = require("../../utils/cli");
+class ModulesPush extends modules_command_1.default {
+    async pushVersioned() {
+        const scriptLibraries = (await this._resourceRepository.findAll()).filter((process) => process.id);
+        const scriptLibraryRepository = this._resourceRepository;
+        const allPromises = [];
+        for (const scriptLibrary of scriptLibraries) {
+            allPromises.push(this._versionedResourceQuery(scriptLibrary.id).then(async (remoteVersionedScriptLibraries) => {
+                const localVersionedScriptLibraries = await scriptLibraryRepository.getVersions(scriptLibrary);
+                for (const localVersionedScriptLibrary of localVersionedScriptLibraries) {
+                    if (!remoteVersionedScriptLibraries.find((remoteVersionedScriptLibrary) => remoteVersionedScriptLibrary.tag === localVersionedScriptLibrary.tag)) {
+                        cli_1.default.log(color_1.default.cyan(`🗂️ pushing version '${localVersionedScriptLibrary.tag}' for module '${scriptLibrary.slug}'...`));
+                        await this._pushVersionedResourceMutation(localVersionedScriptLibrary);
+                    }
+                }
+            }));
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        await Promise.allSettled(allPromises);
+    }
+    async run() {
+        await super.pushResources();
+        await this.pushVersioned();
+    }
+}
+ModulesPush.description = 'Update cloud modules with local ones';
+ModulesPush.examples = ['$ fcode modules:push'];
+ModulesPush.args = types_1.ResourceSlugArg;
+ModulesPush.flags = types_1.ForceFlag;
+exports.default = ModulesPush;

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+import ModulesCommand from '../../core/commands/modules-command';
+import { MergedResource } from '../../core/types';
+export default class ModulesStatus extends ModulesCommand {
+    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/modules/status.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_command_1 = require("../../core/commands/modules-command");
+const types_1 = require("../../core/types");
+const colorize_resource_1 = require("../../utils/colorize-resource");
+const cli_1 = require("../../utils/cli");
+class ModulesStatus extends modules_command_1.default {
+    async resourcesTableLog(resources) {
+        const hasInherited = resources.some((resource) => resource.resolvingTeamSlug);
+        cli_1.cli.table(resources, {
+            name: {
+                get({ slug, status }) {
+                    return (0, colorize_resource_1.colorizeByStatus)(slug, status);
+                },
+                header: 'name',
+            },
+            ...(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();
+    }
+}
+ModulesStatus.description = 'List all modules status';
+ModulesStatus.examples = ['$ fcode modules:status'];
+ModulesStatus.args = types_1.ResourceSlugArg;
+exports.default = ModulesStatus;