@factorialco/fcode-cli 1.1.0

package/dist/utils/env-utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeEnvValue = escapeEnvValue;
+exports.unescapeEnvValue = unescapeEnvValue;
+function escapeEnvValue(value) {
+    if (value.includes('\n') || value.includes("'")) {
+        return `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
+    }
+    return value;
+}
+function unescapeEnvValue(value) {
+    if (value.includes('\n') || value.includes("'")) {
+        return value.replace(/\\([\s\S])/g, '$1');
+    }
+    return value;
+}

package/dist/utils/file-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Writes content to a file only if the content differs from what's already in the file.
+ *
+ * When `readOnly` is set, the file is left read-only (0o444); a previously read-only file
+ * is unlocked before being overwritten so re-pulling an inherited resource doesn't fail
+ * with EACCES, and is unlocked back to 0o644 when the resource stops being inherited.
+ * Owned (writable) files keep their existing mode, matching the previous behavior.
+ */
+export declare function outputFileSyncIfChanged(filePath: string, content: string, { readOnly }?: {
+    readOnly?: boolean;
+}): void;

package/dist/utils/file-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputFileSyncIfChanged = outputFileSyncIfChanged;
+const fs = require("fs-extra");
+/**
+ * Writes content to a file only if the content differs from what's already in the file.
+ *
+ * When `readOnly` is set, the file is left read-only (0o444); a previously read-only file
+ * is unlocked before being overwritten so re-pulling an inherited resource doesn't fail
+ * with EACCES, and is unlocked back to 0o644 when the resource stops being inherited.
+ * Owned (writable) files keep their existing mode, matching the previous behavior.
+ */
+function outputFileSyncIfChanged(filePath, content, { readOnly = false } = {}) {
+    const exists = fs.existsSync(filePath);
+    const isReadOnly = exists && (fs.statSync(filePath).mode & 0o200) === 0;
+    const changed = !exists || fs.readFileSync(filePath).toString() !== content;
+    if (!changed) {
+        if (readOnly && !isReadOnly) {
+            fs.chmodSync(filePath, 0o444);
+        }
+        else if (!readOnly && isReadOnly) {
+            fs.chmodSync(filePath, 0o644);
+        }
+        return;
+    }
+    if (isReadOnly) {
+        fs.chmodSync(filePath, 0o644);
+    }
+    fs.outputFileSync(filePath, content);
+    if (readOnly) {
+        fs.chmodSync(filePath, 0o444);
+    }
+}

package/dist/utils/filenamify.d.ts

@@ -0,0 +1,4 @@
+export default function filenamify(string: string, options?: {
+    maxLength?: number;
+    replacement?: string;
+}): string;

package/dist/utils/filenamify.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = filenamify;
+const MAX_FILENAME_LENGTH = 100;
+const reControlChars = /[\u0000-\u001F\u0080-\u009F]/g; // eslint-disable-line no-control-regex
+const reRelativePath = /^\.+/;
+const reTrailingPeriods = /\.+$/;
+function escapeStringRegexp(string) {
+    if (typeof string !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    // Escape characters with special meaning either inside or outside character sets.
+    // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+    return string.replaceAll(/[$()*+.?[\\\]^{|}]/g, '\\$&').replaceAll('-', '\\x2d');
+}
+function trimRepeated(string, target) {
+    if (typeof string !== 'string' || typeof target !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    const regex = new RegExp(`(?:${escapeStringRegexp(target)}){2,}`, 'g');
+    return string.replace(regex, target);
+}
+function filenameReservedRegex() {
+    return /[\t"*/:<>?\\|]/g;
+}
+function windowsReservedNameRegex() {
+    return /^(con|prn|aux|nul|com\d|lpt\d)$/i;
+}
+function stripOuter(string, substring) {
+    if (typeof string !== 'string' || typeof substring !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    if (string.startsWith(substring)) {
+        string = string.slice(substring.length);
+    }
+    if (string.endsWith(substring)) {
+        string = string.slice(0, -substring.length);
+    }
+    return string;
+}
+function filenamify(string, options = {}) {
+    if (typeof string !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    const replacement = options.replacement === undefined ? '!' : options.replacement;
+    if (filenameReservedRegex().test(replacement) &&
+        reControlChars.test(replacement)) {
+        throw new Error('Replacement string cannot contain reserved filename characters');
+    }
+    string = string.normalize('NFD');
+    string = string.replace(filenameReservedRegex(), replacement);
+    string = string.replaceAll(reControlChars, replacement);
+    string = string.replace(reRelativePath, replacement);
+    string = string.replace(reTrailingPeriods, '');
+    if (replacement.length > 0) {
+        string = trimRepeated(string, replacement);
+        string = string.length > 1 ? stripOuter(string, replacement) : string;
+    }
+    string = windowsReservedNameRegex().test(string)
+        ? string + replacement
+        : string;
+    const allowedLength = typeof options.maxLength === 'number'
+        ? options.maxLength
+        : MAX_FILENAME_LENGTH;
+    if (string.length > allowedLength) {
+        const extensionIndex = string.lastIndexOf('.');
+        const filename = extensionIndex === -1 ? string : string.slice(0, extensionIndex);
+        const extension = extensionIndex === -1 ? '' : string.slice(extensionIndex);
+        string =
+            filename.slice(0, Math.min(allowedLength, filename.length)) + extension;
+    }
+    return string;
+}

package/dist/utils/gitignore.d.ts

@@ -0,0 +1,17 @@
+export declare const INHERITED_BLOCK_START = "# BEGIN fcode inherited resources (auto-generated, do not edit)";
+export declare const INHERITED_BLOCK_END = "# END fcode inherited resources";
+/**
+ * Rebuilds the managed "inherited resources" block in a .gitignore.
+ *
+ * Any existing managed block (between the markers, inclusive) is stripped, and a
+ * freshly rendered block listing the sorted inherited paths is appended when there
+ * are any. All other lines are preserved verbatim. The output is idempotent:
+ * rendering the same input twice yields the same result.
+ */
+export declare function renderGitignoreWithInherited(existing: string, inheritedPaths: string[]): string;
+/**
+ * Refreshes the workspace .gitignore so inherited processes/modules (owned by a
+ * parent team and pulled read-only) are not tracked by git. Regenerated from the
+ * current workspace metadata, so resources that stop being inherited drop out.
+ */
+export declare function syncInheritedGitignore(workspaceDir?: string): Promise<void>;

package/dist/utils/gitignore.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INHERITED_BLOCK_END = exports.INHERITED_BLOCK_START = void 0;
+exports.renderGitignoreWithInherited = renderGitignoreWithInherited;
+exports.syncInheritedGitignore = syncInheritedGitignore;
+const path = require("node:path");
+const fs = require("fs-extra");
+const workspace_1 = require("../config/workspace");
+const filenamify_1 = require("./filenamify");
+const file_utils_1 = require("./file-utils");
+exports.INHERITED_BLOCK_START = '# BEGIN fcode inherited resources (auto-generated, do not edit)';
+exports.INHERITED_BLOCK_END = '# END fcode inherited resources';
+/**
+ * Rebuilds the managed "inherited resources" block in a .gitignore.
+ *
+ * Any existing managed block (between the markers, inclusive) is stripped, and a
+ * freshly rendered block listing the sorted inherited paths is appended when there
+ * are any. All other lines are preserved verbatim. The output is idempotent:
+ * rendering the same input twice yields the same result.
+ */
+function renderGitignoreWithInherited(existing, inheritedPaths) {
+    const base = stripManagedBlock(existing).replace(/\n+$/, '');
+    if (inheritedPaths.length === 0) {
+        return base ? base + '\n' : '';
+    }
+    const block = [exports.INHERITED_BLOCK_START, ...[...inheritedPaths].sort(), exports.INHERITED_BLOCK_END].join('\n');
+    return (base ? base + '\n\n' : '') + block + '\n';
+}
+function stripManagedBlock(content) {
+    const lines = content.split('\n');
+    const start = lines.indexOf(exports.INHERITED_BLOCK_START);
+    if (start === -1) {
+        return content;
+    }
+    const end = lines.indexOf(exports.INHERITED_BLOCK_END, start);
+    if (end === -1) {
+        return content;
+    }
+    lines.splice(start, end - start + 1);
+    return lines.join('\n');
+}
+/**
+ * Refreshes the workspace .gitignore so inherited processes/modules (owned by a
+ * parent team and pulled read-only) are not tracked by git. Regenerated from the
+ * current workspace metadata, so resources that stop being inherited drop out.
+ */
+async function syncInheritedGitignore(workspaceDir = process.cwd()) {
+    const team = await new workspace_1.default(workspaceDir).getActiveTeam();
+    const inheritedPaths = [
+        ...Object.values(team.processes)
+            .filter((process) => process.resolvingTeamSlug)
+            .map((process) => `processes/${(0, filenamify_1.default)(process.slug)}/`),
+        ...Object.values(team.modules)
+            .filter((module) => module.resolvingTeamSlug)
+            .map((module) => `modules/${(0, filenamify_1.default)(module.name)}/`),
+    ];
+    const gitignorePath = path.join(workspaceDir, '.gitignore');
+    const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';
+    (0, file_utils_1.outputFileSyncIfChanged)(gitignorePath, renderGitignoreWithInherited(existing, inheritedPaths));
+}

package/dist/utils/promise.d.ts

@@ -0,0 +1,4 @@
+export declare function chainedPromises<T>(items: Array<T>, action: (item: T) => Promise<T>): Promise<Array<T>>;
+export declare function chainedPromisesWithConfirmation<T>(items: Array<T>, confirmation: (promise: T) => Promise<boolean>, force?: boolean): Promise<Array<T>>;
+export declare function chainedPromisesWithArgs<T>(promises: Array<T>, action: (item: T) => Promise<T>): Promise<Array<T>>;
+export declare function chainedPromisesWithConfirmationAndArgs<T>(promises: Array<T>, confirmation: (promise: T) => Promise<boolean>, force?: boolean): Promise<Array<T>>;

package/dist/utils/promise.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainedPromises = chainedPromises;
+exports.chainedPromisesWithConfirmation = chainedPromisesWithConfirmation;
+exports.chainedPromisesWithArgs = chainedPromisesWithArgs;
+exports.chainedPromisesWithConfirmationAndArgs = chainedPromisesWithConfirmationAndArgs;
+async function chainedPromises(items, action) {
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return items.reduce((previousPromise, currentItem) => previousPromise.then(async (results) => {
+        await action(currentItem);
+        return [...results, currentItem];
+    }), Promise.resolve([]));
+}
+async function chainedPromisesWithConfirmation(items, confirmation, force) {
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return items.reduce((previousPromise, currentItem) => previousPromise.then(async (confirmedItems) => {
+        if (force || (await confirmation(currentItem))) {
+            return [...confirmedItems, currentItem];
+        }
+        return confirmedItems;
+    }), Promise.resolve([]));
+}
+async function chainedPromisesWithArgs(promises, action) {
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return promises.reduce((previousPromise, currentItem) => previousPromise.then(async (results) => {
+        await action(currentItem);
+        return [...results, currentItem];
+    }), Promise.resolve([]));
+}
+async function chainedPromisesWithConfirmationAndArgs(promises, confirmation, force) {
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return promises.reduce((previousPromise, currentItem) => previousPromise.then(async (confirmedItems) => {
+        if (force || (await confirmation(currentItem))) {
+            return [...confirmedItems, currentItem];
+        }
+        return confirmedItems;
+    }), Promise.resolve([]));
+}

package/dist/utils/url-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function buildAuthUrl(url: string): string;
+export declare function isDefaultAuthUrl(authUrl: string, baseUrl: string): boolean;

package/dist/utils/url-utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAuthUrl = buildAuthUrl;
+exports.isDefaultAuthUrl = isDefaultAuthUrl;
+function buildAuthUrl(url) {
+    return process.env.FCODE_AUTH_URL || new URL(url).origin + '/auth/realms/fcode';
+}
+function isDefaultAuthUrl(authUrl, baseUrl) {
+    return authUrl === buildAuthUrl(baseUrl);
+}

package/dist/utils/variable-warnings.d.ts

@@ -0,0 +1,8 @@
+import { Variable } from '../core/types';
+export declare function sensitivityChangedVariables(localVariables: Array<Variable>, remoteVariables: Array<Variable>): Array<Variable>;
+export declare function isTamperedSensitive(variable: {
+    isSensitive: boolean;
+    value: string;
+}): boolean;
+export declare function warnSensitivityChanged(slugs: Array<string>): void;
+export declare function warnTamperedSensitive(slugs: Array<string>, localVariablesFileName: string): void;

package/dist/utils/variable-warnings.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sensitivityChangedVariables = sensitivityChangedVariables;
+exports.isTamperedSensitive = isTamperedSensitive;
+exports.warnSensitivityChanged = warnSensitivityChanged;
+exports.warnTamperedSensitive = warnTamperedSensitive;
+const color_1 = require("@oclif/color");
+const cli_1 = require("./cli");
+const variable_1 = require("../repositories/variable");
+// A sensitive variable whose local isSensitive flag no longer matches remote.
+// isSensitive is immutable, so this is an error the developer must revert.
+function sensitivityChangedVariables(localVariables, remoteVariables) {
+    return localVariables.filter((local) => {
+        if (!local.id) {
+            return false;
+        }
+        const remote = remoteVariables.find((remoteVariable) => remoteVariable.slug === local.slug);
+        return remote !== undefined && local.isSensitive !== remote.isSensitive;
+    });
+}
+// A sensitive variable whose placeholder in variables.env was replaced with a
+// real value. Sensitive values are immutable there; overrides belong in the
+// local overrides file.
+function isTamperedSensitive(variable) {
+    return variable.isSensitive && variable.value !== '' && variable.value !== variable_1.DEFAULT_SENSITIVE_VALUE;
+}
+function warnSensitivityChanged(slugs) {
+    for (const slug of slugs) {
+        cli_1.default.log(color_1.default.red(`🚫 '${slug}' changed its isSensitive flag in variables.meta.json, but isSensitive is immutable. ` +
+            `Revert it to match remote; the change was not pushed.`));
+    }
+}
+function warnTamperedSensitive(slugs, localVariablesFileName) {
+    for (const slug of slugs) {
+        cli_1.default.log(color_1.default.yellow(`⚠️  '${slug}' is sensitive and its value cannot be changed in variables.env. ` +
+            `To override it locally, set it in ${localVariablesFileName}.`));
+    }
+}