@factorialco/fcode-cli 1.1.0

package/dist/services/http-server.d.ts

@@ -0,0 +1,3 @@
+import * as http from 'node:http';
+export declare function startServer(port: number, host: string, handler: http.RequestListener): Promise<http.Server>;
+export declare function stopServer(server: http.Server): Promise<void>;

package/dist/services/http-server.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+exports.stopServer = stopServer;
+const http = require("node:http");
+async function startServer(port, host, handler) {
+    const server = http.createServer(handler);
+    await new Promise((resolve) => {
+        server.listen(port, host, () => resolve());
+    });
+    return server;
+}
+async function stopServer(server) {
+    await new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+    });
+}

package/dist/services/oauth-browser-service.d.ts

@@ -0,0 +1,9 @@
+import type { AuthInfo } from '../core/types';
+/**
+ * OAuth 2.0 Authorization Code flow with PKCE.
+ * Starts a local HTTP server to receive the redirect after the user logs in via browser.
+ * Requires the IdP (Keycloak) to have the CLI client configured with:
+ * - Access type: public
+ * - Valid redirect URI: http://127.0.0.1:6363/callback
+ */
+export declare function loginViaBrowser(url: string, authUrl: string, clientId?: string): Promise<AuthInfo>;

package/dist/services/oauth-browser-service.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginViaBrowser = loginViaBrowser;
+const openidClient = require("openid-client");
+const open = require('open');
+const { Issuer, generators } = openidClient;
+const global_1 = require("../config/global");
+const cli_1 = require("../utils/cli");
+const auth_service_1 = require("./auth-service");
+const http_server_1 = require("./http-server");
+const OAUTH_CALLBACK_PORT = 6363;
+const REDIRECT_URI = `http://127.0.0.1:${OAUTH_CALLBACK_PORT}/callback`;
+const OAUTH_SCOPE = 'openid profile email offline_access';
+const LOGIN_COMPLETED_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Login completed - Factorial Code</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" />
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.2.1/css/all.min.css" integrity="sha512-MV7K8+y+gLIBoVD59lQIYicR65iaqukzvf/nwasF0nqhPay5w/9lJmVM2hMDcnK1OnMGCdVK+iQrJ7lzPJQd1w==" crossorigin="anonymous" referrerpolicy="no-referrer" />
+  <style>
+    /* f0 design system tokens (light mode) */
+    :root {
+      --f1-foreground: hsl(218 48% 10%);
+      --f1-foreground-secondary: hsl(217 96% 11% / 0.61);
+      --f1-background: hsl(0 0% 100%);
+      --f1-border: hsl(213 87% 15% / 0.20);
+      --f1-positive: hsl(160 84% 39%);
+      --shadow: 218 48% 10%;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      font-family: 'Inter', ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      font-size: 0.875rem;
+      letter-spacing: -0.005em;
+      line-height: 1.25rem;
+      -webkit-font-smoothing: antialiased;
+      -moz-osx-font-smoothing: grayscale;
+      background: hsl(210 20% 98%);
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      padding: 1.5rem;
+      color: var(--f1-foreground);
+    }
+    .card {
+      background: var(--f1-background);
+      border-radius: 1rem;
+      padding: 2rem;
+      max-width: 24rem;
+      width: 100%;
+      text-align: center;
+      box-shadow: 0 2px 20px 0 hsl(var(--shadow) / 0.08);
+      border: 1px solid var(--f1-border);
+    }
+    .logo { width: 140px; height: auto; margin-bottom: 1.5rem; }
+    .icon {
+      width: 3rem;
+      height: 3rem;
+      margin: 0 auto 1rem;
+      border-radius: 50%;
+      background: hsl(160 84% 39% / 0.1);
+      color: var(--f1-positive);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 1.25rem;
+    }
+    h1 { font-size: 1.125rem; font-weight: 600; margin: 0 0 0.5rem; color: var(--f1-foreground); }
+    p { margin: 0; font-size: 0.875rem; color: var(--f1-foreground-secondary); line-height: 1.5; }
+    .hint { margin-top: 1rem; font-size: 0.75rem; color: var(--f1-foreground-secondary); }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <img src="https://code.factorialhr.com/images/factorial-code-logo-red.svg" alt="Factorial Code" class="logo" />
+    <div class="icon"><i class="fa-solid fa-circle-check"></i></div>
+    <h1>You’re signed in</h1>
+    <p>Login completed successfully. You can close this window and return to the terminal.</p>
+  </div>
+</body>
+</html>`;
+/**
+ * OAuth 2.0 Authorization Code flow with PKCE.
+ * Starts a local HTTP server to receive the redirect after the user logs in via browser.
+ * Requires the IdP (Keycloak) to have the CLI client configured with:
+ * - Access type: public
+ * - Valid redirect URI: http://127.0.0.1:6363/callback
+ */
+async function loginViaBrowser(url, authUrl, clientId) {
+    const normalizedAuthUrl = authUrl.endsWith('/') ? authUrl.slice(0, -1) : authUrl;
+    const resolvedClientId = clientId || process.env.FCODE_CLIENT_ID || 'cli';
+    const issuer = await Issuer.discover(normalizedAuthUrl);
+    const client = new issuer.Client({
+        client_id: resolvedClientId,
+        redirect_uris: [REDIRECT_URI],
+        token_endpoint_auth_method: 'none',
+    });
+    const codeVerifier = generators.codeVerifier();
+    const codeChallenge = generators.codeChallenge(codeVerifier);
+    const state = generators.state();
+    const authorizationUrl = client.authorizationUrl({
+        scope: OAUTH_SCOPE,
+        code_challenge: codeChallenge,
+        code_challenge_method: 'S256',
+        state,
+    });
+    let callbackUrl;
+    const server = await (0, http_server_1.startServer)(OAUTH_CALLBACK_PORT, '127.0.0.1', (req, res) => {
+        if (!req.url) {
+            res.statusCode = 400;
+            res.end();
+            return;
+        }
+        if (req.url.startsWith('/callback') || req.url.startsWith('/?')) {
+            callbackUrl = `http://127.0.0.1:${OAUTH_CALLBACK_PORT}${req.url}`;
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'text/html; charset=utf-8');
+            res.end(LOGIN_COMPLETED_HTML);
+        }
+        else {
+            res.statusCode = 404;
+            res.end('Not found');
+        }
+    });
+    cli_1.default.log('🌐  Opening browser for login...');
+    await open(authorizationUrl);
+    while (callbackUrl === undefined) {
+        await new Promise((r) => setTimeout(r, 200));
+    }
+    const callbackUrlObj = new URL(callbackUrl);
+    const callbackParams = {};
+    callbackUrlObj.searchParams.forEach((value, key) => {
+        callbackParams[key] = value;
+    });
+    try {
+        const tokenSet = await client.callback(REDIRECT_URI, callbackParams, { state, code_verifier: codeVerifier });
+        const token = {
+            access_token: tokenSet.access_token ?? '',
+            refresh_token: tokenSet.refresh_token ?? '',
+        };
+        const userInfo = await auth_service_1.default.getUserInfo(normalizedAuthUrl, token);
+        const authInfo = {
+            authUrl: normalizedAuthUrl,
+            token,
+            userInfo,
+        };
+        await new global_1.default().setAuthInfo(url, authInfo);
+        return authInfo;
+    }
+    catch (error) {
+        cli_1.default.error('Error logging in via browser: ' + error);
+        throw error;
+    }
+    finally {
+        await (0, http_server_1.stopServer)(server);
+    }
+}

package/dist/services/process-parameters-sampler.d.ts

@@ -0,0 +1,2 @@
+import type { Process } from '../core/types';
+export declare const generateParametersSample: (process: Process) => any;

package/dist/services/process-parameters-sampler.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateParametersSample = void 0;
+const processHasParametersSchema = (process) => {
+    const processParameters = process.script.parametersSchema;
+    return Boolean(processParameters && Object.keys(processParameters).length > 0);
+};
+const jsonSchemaPropertyToSampleValue = (property) => {
+    if (['password', 'string'].includes(property.type)) {
+        return '';
+    }
+    if (['integer', 'number'].includes(property.type)) {
+        return 0;
+    }
+    if (property.type === 'boolean') {
+        return true;
+    }
+    if (property.type === 'array') {
+        return [jsonSchemaPropertyToSampleValue(property.items)];
+    }
+    if (property.type === 'object') {
+        return {
+            ...jsonSchemaPropertiesToSampleObject(property.properties),
+        };
+    }
+    return null;
+};
+const jsonSchemaPropertiesToSampleObject = (properties) => {
+    if (!properties) {
+        return {};
+    }
+    const entries = Object.entries(properties).map(([key, property]) => [key, jsonSchemaPropertyToSampleValue(property)]);
+    return Object.fromEntries(entries);
+};
+const generateParametersSample = (process) => {
+    if (!processHasParametersSchema(process)) {
+        return {};
+    }
+    return jsonSchemaPropertiesToSampleObject(process.script.parametersSchema.properties);
+};
+exports.generateParametersSample = generateParametersSample;

package/dist/services/process-runner.d.ts

@@ -0,0 +1,22 @@
+import { Process, Variable } from '../core/types';
+import type { WebhookRequest } from '../core/types';
+export type RunProcessOptions = {
+    slug: string;
+    parameters?: Record<string, unknown>;
+    version?: string;
+    logLevel?: string;
+    request?: WebhookRequest;
+    jsonLogs?: boolean;
+    variablesOverride?: Variable[];
+    extraVariablesFile?: string;
+    suppressElapsedLog?: boolean;
+};
+export type RunHookOptions = {
+    logLevel?: string;
+    jsonLogs?: boolean;
+    hookFunction?: string;
+};
+export declare function loadVariablesFromFile(filePath: string): Variable[];
+export declare function mergeVariables(base: Variable[], ...overrides: Variable[][]): Variable[];
+export declare function runProcess(options: RunProcessOptions): Promise<unknown>;
+export declare function runHook(hookFilePath: string, fcodeProcess: Process, variables: Variable[], options?: RunHookOptions): Promise<void>;

package/dist/services/process-runner.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadVariablesFromFile = loadVariablesFromFile;
+exports.mergeVariables = mergeVariables;
+exports.runProcess = runProcess;
+exports.runHook = runHook;
+const dotenv_1 = require("dotenv");
+const fs = require("node:fs");
+const javascript_execution_task_1 = require("../core/executors/javascript-execution-task");
+const python_execution_task_1 = require("../core/executors/python-execution-task");
+const process_1 = require("../repositories/process");
+const variable_1 = require("../repositories/variable");
+const types_1 = require("../core/types");
+const errors_1 = require("../core/errors");
+const env_utils_1 = require("../utils/env-utils");
+function loadVariablesFromFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const parsed = (0, dotenv_1.parse)(content);
+        return Object.entries(parsed).map(([key, value]) => new types_1.Variable(undefined, key, (0, env_utils_1.unescapeEnvValue)(value), false));
+    }
+    catch {
+        return [];
+    }
+}
+function mergeVariables(base, ...overrides) {
+    const map = new Map();
+    for (const v of base)
+        map.set(v.key, v);
+    for (const override of overrides) {
+        for (const v of override)
+            map.set(v.key, v);
+    }
+    return [...map.values()];
+}
+async function runProcess(options) {
+    const { slug, version, logLevel = 'DEBUG', request, jsonLogs = false, suppressElapsedLog = false } = options;
+    const processRepository = new process_1.default();
+    const variableRepository = new variable_1.default();
+    const fcodeProcess = await processRepository.find(slug, version);
+    const parameters = options.parameters ?? (await processRepository.findParameters(slug));
+    let variables;
+    if (options.variablesOverride) {
+        variables = options.variablesOverride;
+    }
+    else {
+        variables = await variableRepository.findAllForExecution();
+        if (options.extraVariablesFile) {
+            variables = mergeVariables(variables, loadVariablesFromFile(options.extraVariablesFile));
+        }
+    }
+    const ExecutionTask = fcodeProcess.script.programmingLanguage === 'PYTHON' ? python_execution_task_1.default : javascript_execution_task_1.default;
+    const executor = new ExecutionTask(fcodeProcess.script.programmingLanguage, fcodeProcess, { version, parameters, variables, logLevel, request, jsonLogs });
+    const start = Date.now();
+    try {
+        await executor.prepare();
+        await executor.run();
+        return executor.readReturnValue();
+    }
+    catch (runError) {
+        const errorValue = executor.readErrorValue();
+        throw new errors_1.ErrorExecutingProcess(errorValue?.message ?? (runError instanceof Error ? runError.message : String(runError)));
+    }
+    finally {
+        executor.cleanup();
+        if (!suppressElapsedLog) {
+            const elapsed = Date.now() - start;
+            if (jsonLogs) {
+                process.stdout.write(JSON.stringify({ timestamp: new Date().toISOString(), level: 'INFO', message: `Elapsed time: ${elapsed}ms` }) + '\n');
+            }
+            else {
+                console.log(`Elapsed time: ${elapsed}ms`);
+            }
+        }
+    }
+}
+async function runHook(hookFilePath, fcodeProcess, variables, options = {}) {
+    const { logLevel = 'ERROR', jsonLogs = false, hookFunction } = options;
+    const ExecutionTask = fcodeProcess.script.programmingLanguage === 'PYTHON' ? python_execution_task_1.default : javascript_execution_task_1.default;
+    const executor = new ExecutionTask(fcodeProcess.script.programmingLanguage, fcodeProcess, {
+        version: undefined,
+        parameters: {},
+        variables,
+        logLevel,
+        jsonLogs,
+        hookFilePath,
+        hookFunction,
+        silent: true,
+    });
+    try {
+        await executor.prepare();
+        await executor.run();
+    }
+    finally {
+        executor.cleanup();
+    }
+}

package/dist/services/resource-checker.d.ts

@@ -0,0 +1,8 @@
+import { OnConflictResolution, type Resource } from '../core/types';
+declare const _default: {
+    localResourceHasBeenModified(remoteResource?: Resource, localResource?: Resource): Promise<boolean>;
+    remoteResourceHasBeenModified(remoteResource?: Resource, localResource?: Resource): Promise<boolean>;
+    sameContent(resourceA: Resource, resourceB: Resource): boolean;
+    categorizeResources(localResources: Array<Resource>, remoteResources: Array<Resource>, onConflictResolution: OnConflictResolution, existsMetadata: (slug: string) => Promise<boolean>): Promise<any>;
+};
+export default _default;

package/dist/services/resource-checker.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const workspace_1 = require("../config/workspace");
+const types_1 = require("../core/types");
+const resource_merger_1 = require("../core/resource-merger");
+exports.default = {
+    async localResourceHasBeenModified(remoteResource, localResource) {
+        if (!localResource) {
+            return false;
+        }
+        if (remoteResource && this.sameContent(remoteResource, localResource)) {
+            return false;
+        }
+        if (localResource.contentHash === (await new workspace_1.default().getStoredHash(localResource))) {
+            return false;
+        }
+        return true;
+    },
+    async remoteResourceHasBeenModified(remoteResource, localResource) {
+        if (localResource && remoteResource && this.sameContent(remoteResource, localResource)) {
+            return false;
+        }
+        if (remoteResource && remoteResource.contentHash === (await new workspace_1.default().getStoredHash(remoteResource))) {
+            return false;
+        }
+        return true;
+    },
+    sameContent(resourceA, resourceB) {
+        return resourceA.contentHash === resourceB.contentHash;
+    },
+    async categorizeResources(localResources, remoteResources, onConflictResolution, existsMetadata) {
+        let newRemoteResources = [];
+        let newLocalResources = [];
+        let upToDateResources = [];
+        let conflictResources = [];
+        let modifiedResources = [];
+        let outOfDateResources = [];
+        let remoteRemovedResources = [];
+        let localRemovedResources = [];
+        const allResourceSlugs = [...new Set([...localResources, ...remoteResources].map((resource) => resource.slug))];
+        for (const resourceSlug of allResourceSlugs) {
+            const remoteResource = remoteResources.find((resource) => resource.slug === resourceSlug);
+            const localResource = localResources.find((resource) => resource.slug === resourceSlug);
+            switch (await (0, resource_merger_1.mapResourceStatus)(remoteResource, localResource, await existsMetadata(resourceSlug))) {
+                case types_1.ResourceStatus.REMOTE_NEW:
+                    newRemoteResources.push(remoteResource);
+                    break;
+                case types_1.ResourceStatus.LOCAL_NEW:
+                    newLocalResources.push(localResource);
+                    break;
+                case types_1.ResourceStatus.UP_TO_DATE:
+                    upToDateResources.push(localResource);
+                    break;
+                case types_1.ResourceStatus.CONFLICT:
+                    conflictResources.push(onConflictResolution === types_1.OnConflictResolution.KEEP_REMOTE ? remoteResource : localResource);
+                    break;
+                case types_1.ResourceStatus.MODIFIED:
+                    modifiedResources.push(localResource);
+                    break;
+                case types_1.ResourceStatus.OUT_OF_DATE:
+                    outOfDateResources.push(remoteResource);
+                    break;
+                case types_1.ResourceStatus.REMOTE_REMOVED:
+                    remoteRemovedResources.push(localResource);
+                    break;
+                case types_1.ResourceStatus.LOCAL_REMOVED:
+                    localRemovedResources.push(remoteResource);
+                    break;
+            }
+        }
+        return {
+            newRemoteResources,
+            newLocalResources,
+            upToDateResources,
+            conflictResources,
+            modifiedResources,
+            outOfDateResources,
+            remoteRemovedResources,
+            localRemovedResources,
+        };
+    },
+};

package/dist/services/test-runner.d.ts

@@ -0,0 +1,17 @@
+import { Process } from '../core/types';
+export type TestOptions = {
+    logLevel?: string;
+    jsonLogs?: boolean;
+};
+export type TestResult = {
+    name: string;
+    passed: boolean;
+    error?: string;
+    durationMs: number;
+};
+export type TestSuiteResult = {
+    processSlug: string;
+    results: TestResult[];
+};
+export declare function runProcessTests(fcodeProcess: Process, options?: TestOptions): Promise<TestSuiteResult>;
+export declare function printTestResults(suiteResults: TestSuiteResult[]): void;