@contrail/flexplm 1.6.1-alpha.75cfe7f → 1.7.0-alpha.71b4d30

package/lib/cli/commands/shared/prompts.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptHidden = exports.prompt = void 0;
+const readline = __importStar(require("readline"));
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const onSigint = () => {
+        rl.close();
+        process.stdout.write('\n');
+        process.exit(130);
+    };
+    process.once('SIGINT', onSigint);
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            process.removeListener('SIGINT', onSigint);
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+exports.prompt = prompt;
+function promptHidden(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+        const rlAny = rl;
+        rlAny._writeToOutput = (str) => {
+            if (str.includes(question)) {
+                rlAny.output.write(str);
+            }
+        };
+        rl.question(question, (answer) => {
+            rl.close();
+            process.stdout.write('\n');
+            resolve(answer);
+        });
+    });
+}
+exports.promptHidden = promptHidden;

package/lib/cli/commands/shared/upload-base.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+export interface UploadOptions {
+    filePath: string;
+    message?: string;
+    branch?: string;
+    skipGit: boolean;
+    updateConfig: boolean;
+}
+export interface PreparedUpload {
+    orgName: string;
+    appIdentifier: string;
+    uploadBuffer: Buffer;
+    uploadFileName: string;
+    uploadContentType: string;
+    configPropertyName: string;
+    filesToCommit: string[];
+}
+export interface UploadStrategy {
+    topicLabel: string;
+    sourceExtension: string;
+    prepare(absSourcePath: string): Promise<PreparedUpload>;
+}
+export declare function parseUploadArgs(args: string[], sourceLabel: string): UploadOptions;
+export declare function runUpload(strategy: UploadStrategy, args: string[]): Promise<void>;

package/lib/cli/commands/shared/upload-base.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpload = exports.parseUploadArgs = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sdk_1 = require("@contrail/sdk");
+const prompts_1 = require("./prompts");
+const git_1 = require("./git");
+function parseUploadArgs(args, sourceLabel) {
+    let filePath;
+    let message;
+    let branch;
+    let skipGit = false;
+    let updateConfig = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '-m') {
+            message = args[++i];
+            if (message === undefined) {
+                throw new Error('-m requires a commit message argument');
+            }
+        }
+        else if (a === '-b') {
+            branch = args[++i];
+            if (branch === undefined) {
+                throw new Error('-b requires a branch name argument');
+            }
+        }
+        else if (a === '--skip-git' || a === '--skipGit') {
+            skipGit = true;
+        }
+        else if (a === '--update-config') {
+            updateConfig = true;
+        }
+        else if (a.startsWith('-')) {
+            throw new Error(`Unknown option: ${a}`);
+        }
+        else if (!filePath) {
+            filePath = a;
+        }
+        else {
+            throw new Error(`Unexpected argument: ${a}`);
+        }
+    }
+    if (!filePath) {
+        throw new Error(`upload: missing <${sourceLabel}> argument`);
+    }
+    return { filePath, message, branch, skipGit, updateConfig };
+}
+exports.parseUploadArgs = parseUploadArgs;
+async function runUpload(strategy, args) {
+    const sourceLabel = `path${strategy.sourceExtension}`;
+    const options = parseUploadArgs(args, sourceLabel);
+    const absSourcePath = path.resolve(process.cwd(), options.filePath);
+    if (!fs.existsSync(absSourcePath)) {
+        throw new Error(`File not found: ${absSourcePath}`);
+    }
+    if (!absSourcePath.endsWith(strategy.sourceExtension)) {
+        throw new Error(`Expected a ${strategy.sourceExtension} file, got: ${absSourcePath}`);
+    }
+    const prepared = await strategy.prepare(absSourcePath);
+    let email = process.env.CONTRAIL_CLI_EMAIL;
+    let password = process.env.CONTRAIL_CLI_PASSWORD;
+    if (!email) {
+        email = await (0, prompts_1.prompt)('Email: ');
+    }
+    if (!password) {
+        password = await (0, prompts_1.promptHidden)('Password: ');
+    }
+    if (!email || !password) {
+        throw new Error('Email and password are required');
+    }
+    await (0, sdk_1.login)({ orgSlug: prepared.orgName, email, password });
+    console.log(`Logged in to org "${prepared.orgName}" as ${email}`);
+    const apps = await new sdk_1.Entities().get({
+        entityName: 'app',
+        criteria: { identifier: prepared.appIdentifier },
+    });
+    if (!apps || apps.length !== 1) {
+        throw new Error(`Expected exactly one app with identifier "${prepared.appIdentifier}" in org "${prepared.orgName}", found ${apps ? apps.length : 0}`);
+    }
+    const app = apps[0];
+    const fileOwner = `app:${app.id}`;
+    const uploadedFile = await new sdk_1.Files().createAndUploadFileFromBuffer(prepared.uploadBuffer, prepared.uploadContentType, prepared.uploadFileName, fileOwner);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const responsePath = `${absSourcePath}.uploaded-${timestamp}.json`;
+    fs.writeFileSync(responsePath, JSON.stringify(uploadedFile, null, 2), 'utf8');
+    console.log(`Wrote response to ${responsePath}`);
+    console.log(`FILE ID: ${uploadedFile.id}`);
+    if (options.updateConfig) {
+        const appOrgs = await new sdk_1.Entities().get({
+            entityName: 'app-org',
+            criteria: { appId: app.id },
+        });
+        if (!appOrgs || appOrgs.length === 0) {
+            throw new Error(`App "${prepared.appIdentifier}" is not installed in org "${prepared.orgName}". Install it via the admin console before using --update-config.`);
+        }
+        if (appOrgs.length > 1) {
+            throw new Error(`Expected exactly one app-org for app "${prepared.appIdentifier}" in org "${prepared.orgName}", found ${appOrgs.length}`);
+        }
+        const appOrg = appOrgs[0];
+        const nextAppConfig = { ...(appOrg.appConfig || {}), [prepared.configPropertyName]: uploadedFile.id };
+        await new sdk_1.Entities().update({
+            entityName: 'app-org',
+            id: appOrg.id,
+            object: { appConfig: nextAppConfig },
+        });
+        console.log(`Updated app-org ${appOrg.id}: appConfig.${prepared.configPropertyName} = ${uploadedFile.id}`);
+    }
+    if (options.skipGit) {
+        return;
+    }
+    await (0, git_1.commitFiles)(prepared.filesToCommit, uploadedFile.id, options);
+}
+exports.runUpload = runUpload;

package/lib/cli/commands/shared/upload-base.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/cli/commands/shared/upload-base.spec.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@contrail/sdk', () => ({
+    Entities: jest.fn(),
+    Files: jest.fn(),
+    login: jest.fn(),
+}));
+const upload_base_1 = require("./upload-base");
+const git_1 = require("./git");
+describe('parseUploadArgs', () => {
+    it('parses a bare file path', () => {
+        const opts = (0, upload_base_1.parseUploadArgs)(['mapping.ts'], 'path.ts');
+        expect(opts).toEqual({
+            filePath: 'mapping.ts',
+            message: undefined,
+            branch: undefined,
+            skipGit: false,
+            updateConfig: false,
+        });
+    });
+    it('parses -m commit message option', () => {
+        const opts = (0, upload_base_1.parseUploadArgs)(['mapping.ts', '-m', 'my message'], 'path.ts');
+        expect(opts.message).toEqual('my message');
+        expect(opts.skipGit).toBe(false);
+    });
+    it('parses -b branch option', () => {
+        const opts = (0, upload_base_1.parseUploadArgs)(['mapping.ts', '-b', 'feature/x'], 'path.ts');
+        expect(opts.branch).toEqual('feature/x');
+    });
+    it('parses --skip-git flag', () => {
+        const opts = (0, upload_base_1.parseUploadArgs)(['mapping.ts', '--skip-git'], 'path.ts');
+        expect(opts.skipGit).toBe(true);
+    });
+    it('accepts the legacy --skipGit alias', () => {
+        const opts = (0, upload_base_1.parseUploadArgs)(['mapping.ts', '--skipGit'], 'path.ts');
+        expect(opts.skipGit).toBe(true);
+    });
+    it('parses --update-config flag', () => {
+        const opts = (0, upload_base_1.parseUploadArgs)(['mapping.ts', '--update-config'], 'path.ts');
+        expect(opts.updateConfig).toBe(true);
+    });
+    it('parses options before the file path', () => {
+        const opts = (0, upload_base_1.parseUploadArgs)(['-m', 'msg', '-b', 'br', 'mapping.ts'], 'path.ts');
+        expect(opts).toEqual({
+            filePath: 'mapping.ts',
+            message: 'msg',
+            branch: 'br',
+            skipGit: false,
+            updateConfig: false,
+        });
+    });
+    it('parses all options together', () => {
+        const opts = (0, upload_base_1.parseUploadArgs)(['mapping.ts', '-m', 'msg', '-b', 'br', '--skip-git', '--update-config'], 'path.ts');
+        expect(opts).toEqual({
+            filePath: 'mapping.ts',
+            message: 'msg',
+            branch: 'br',
+            skipGit: true,
+            updateConfig: true,
+        });
+    });
+    it('throws when -m is missing its value', () => {
+        expect(() => (0, upload_base_1.parseUploadArgs)(['mapping.ts', '-m'], 'path.ts')).toThrow(/-m requires a commit message/);
+    });
+    it('throws when -b is missing its value', () => {
+        expect(() => (0, upload_base_1.parseUploadArgs)(['mapping.ts', '-b'], 'path.ts')).toThrow(/-b requires a branch name/);
+    });
+    it('throws on unknown option', () => {
+        expect(() => (0, upload_base_1.parseUploadArgs)(['mapping.ts', '--bogus'], 'path.ts')).toThrow(/Unknown option: --bogus/);
+    });
+    it('throws when an extra positional argument is supplied', () => {
+        expect(() => (0, upload_base_1.parseUploadArgs)(['mapping.ts', 'extra.ts'], 'path.ts')).toThrow(/Unexpected argument: extra\.ts/);
+    });
+    it('throws when no file path is provided', () => {
+        expect(() => (0, upload_base_1.parseUploadArgs)([], 'path.ts')).toThrow(/missing <path\.ts>/);
+    });
+    it('throws when only options are provided', () => {
+        expect(() => (0, upload_base_1.parseUploadArgs)(['--skip-git'], 'path.ts')).toThrow(/missing <path\.ts>/);
+    });
+    it('uses the supplied source label in the missing-argument error', () => {
+        expect(() => (0, upload_base_1.parseUploadArgs)([], 'path.json')).toThrow(/missing <path\.json>/);
+    });
+});
+describe('buildCommitMessage', () => {
+    it('appends fileId to the first line of a single-line message', () => {
+        expect((0, git_1.buildCommitMessage)('initial commit', 'abc123')).toEqual('initial commit [fileId: abc123]');
+    });
+    it('only appends fileId to the first line of a multi-line message', () => {
+        const result = (0, git_1.buildCommitMessage)('header line\nbody line 1\nbody line 2', 'xyz');
+        expect(result).toEqual('header line [fileId: xyz]\nbody line 1\nbody line 2');
+    });
+    it('handles CRLF line endings', () => {
+        const result = (0, git_1.buildCommitMessage)('header\r\nbody', 'fid');
+        expect(result).toEqual('header [fileId: fid]\nbody');
+    });
+    it('handles an empty message', () => {
+        expect((0, git_1.buildCommitMessage)('', 'fid')).toEqual(' [fileId: fid]');
+    });
+});

package/lib/cli/index.js

@@ -2,57 +2,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = exports.Cli = void 0;
-const create_1 = require("./commands/create");
-const compile_1 = require("./commands/compile");
-const upload_1 = require("./commands/upload");
-const USAGE = `Usage: flexplm-mapping <command> [args]
+const mapping_file_1 = require("./commands/mapping-file");
+const config_file_1 = require("./commands/config-file");
+const USAGE = `Usage: flexplm <topic> <subcommand> [args]
 
-Commands:
-  create                  Scaffold a new mapping .ts file in the current directory
-  compile <path.ts>       Transpile a mapping .ts file to .js alongside it
-  upload  <path.ts> [opts] Compile a mapping .ts file and upload the resulting .js to VibeIQ
+Topics:
+  mapping-file <create|compile|upload>   Manage transform mapping .ts files
+  config-file  <create|upload>           Manage connector config .json files
 
-Upload options:
-  -m <message>            Git commit message (prompted if omitted)
-  -b <branch>             Create a new git branch before committing
-  --skip-git              Skip the post-upload git commit (default: commit)
-  --update-config         Patch the app-org appConfig.transformMapFile with the uploaded file ID without needing to paste into the admin console
-
-Environment (upload):
-  CONTRAIL_CLI_EMAIL      VibeIQ user email
-  CONTRAIL_CLI_PASSWORD   VibeIQ user password
+Run "flexplm <topic>" for topic-specific help. Examples:
+  flexplm mapping-file
+  flexplm config-file
 `;
 class Cli {
     async main() {
-        const [, , command, ...rest] = process.argv;
-        switch (command) {
-            case 'create':
-                await new create_1.CreateCommand().run();
-                return;
-            case 'compile':
-                if (!rest[0]) {
-                    console.error('compile: missing <path.ts> argument');
-                    console.error(USAGE);
-                    process.exit(1);
-                }
-                await new compile_1.CompileCommand().run(rest[0]);
+        const [, , topic, subcommand, ...rest] = process.argv;
+        switch (topic) {
+            case 'mapping-file':
+                await (0, mapping_file_1.runMappingFile)(subcommand, rest);
                 return;
-            case 'upload':
-                if (!rest[0]) {
-                    console.error('upload: missing <path.ts> argument');
-                    console.error(USAGE);
-                    process.exit(1);
-                }
-                await new upload_1.UploadCommand().run(rest);
+            case 'config-file':
+                await (0, config_file_1.runConfigFile)(subcommand, rest);
                 return;
             case undefined:
             case '-h':
             case '--help':
             case 'help':
                 console.log(USAGE);
+                console.log(mapping_file_1.MAPPING_FILE_USAGE);
+                console.log(config_file_1.CONFIG_FILE_USAGE);
                 return;
             default:
-                console.error(`Unknown command: ${command}`);
+                console.error(`Unknown topic: ${topic}`);
                 console.error(USAGE);
                 process.exit(1);
         }

package/lib/cli/index.spec.js

@@ -1,16 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const createRunMock = jest.fn().mockResolvedValue(undefined);
-const compileRunMock = jest.fn().mockResolvedValue(undefined);
-const uploadRunMock = jest.fn().mockResolvedValue(undefined);
-jest.mock('./commands/create', () => ({
-    CreateCommand: jest.fn().mockImplementation(() => ({ run: createRunMock })),
+const mappingCreateRun = jest.fn().mockResolvedValue(undefined);
+const mappingCompileRun = jest.fn().mockResolvedValue(undefined);
+const mappingUploadRun = jest.fn().mockResolvedValue(undefined);
+const configCreateRun = jest.fn().mockResolvedValue(undefined);
+const configUploadRun = jest.fn().mockResolvedValue(undefined);
+jest.mock('./commands/mapping-file/create', () => ({
+    CreateCommand: jest.fn().mockImplementation(() => ({ run: mappingCreateRun })),
 }));
-jest.mock('./commands/compile', () => ({
-    CompileCommand: jest.fn().mockImplementation(() => ({ run: compileRunMock })),
+jest.mock('./commands/mapping-file/compile', () => ({
+    CompileCommand: jest.fn().mockImplementation(() => ({ run: mappingCompileRun })),
 }));
-jest.mock('./commands/upload', () => ({
-    UploadCommand: jest.fn().mockImplementation(() => ({ run: uploadRunMock })),
+jest.mock('./commands/mapping-file/upload', () => ({
+    UploadCommand: jest.fn().mockImplementation(() => ({ run: mappingUploadRun })),
+}));
+jest.mock('./commands/config-file/create', () => ({
+    CreateCommand: jest.fn().mockImplementation(() => ({ run: configCreateRun })),
+}));
+jest.mock('./commands/config-file/upload', () => ({
+    UploadCommand: jest.fn().mockImplementation(() => ({ run: configUploadRun })),
 }));
 const index_1 = require("./index");
 describe('cli main dispatcher', () => {
@@ -20,9 +28,11 @@ describe('cli main dispatcher', () => {
     let exitSpy;
     beforeEach(() => {
         originalArgv = process.argv;
-        createRunMock.mockClear();
-        compileRunMock.mockClear();
-        uploadRunMock.mockClear();
+        mappingCreateRun.mockClear();
+        mappingCompileRun.mockClear();
+        mappingUploadRun.mockClear();
+        configCreateRun.mockClear();
+        configUploadRun.mockClear();
         logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
         errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
         exitSpy = jest.spyOn(process, 'exit').mockImplementation(((code) => {
@@ -38,48 +48,96 @@ describe('cli main dispatcher', () => {
     function setArgv(...args) {
         process.argv = ['node', 'cli', ...args];
     }
-    it('dispatches the create command', async () => {
-        setArgv('create');
-        await (0, index_1.main)();
-        expect(createRunMock).toHaveBeenCalledTimes(1);
-        expect(compileRunMock).not.toHaveBeenCalled();
-        expect(uploadRunMock).not.toHaveBeenCalled();
-    });
-    it('dispatches the compile command with its argument', async () => {
-        setArgv('compile', 'mapping.ts');
-        await (0, index_1.main)();
-        expect(compileRunMock).toHaveBeenCalledWith('mapping.ts');
-    });
-    it('exits when compile is missing its argument', async () => {
-        setArgv('compile');
-        await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
-        expect(compileRunMock).not.toHaveBeenCalled();
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.ts>/));
-    });
-    it('dispatches the upload command and forwards remaining args', async () => {
-        setArgv('upload', 'mapping.ts', '-m', 'msg', '--skip-git');
-        await (0, index_1.main)();
-        expect(uploadRunMock).toHaveBeenCalledWith(['mapping.ts', '-m', 'msg', '--skip-git']);
-    });
-    it('exits when upload is missing its argument', async () => {
-        setArgv('upload');
-        await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
-        expect(uploadRunMock).not.toHaveBeenCalled();
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.ts>/));
-    });
-    it.each(['help', '-h', '--help'])('prints usage for %s', async (helpFlag) => {
-        setArgv(helpFlag);
-        await (0, index_1.main)();
-        expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm-mapping/));
+    describe('mapping-file topic', () => {
+        it('dispatches mapping-file create', async () => {
+            setArgv('mapping-file', 'create');
+            await (0, index_1.main)();
+            expect(mappingCreateRun).toHaveBeenCalledTimes(1);
+            expect(mappingCompileRun).not.toHaveBeenCalled();
+            expect(mappingUploadRun).not.toHaveBeenCalled();
+        });
+        it('dispatches mapping-file compile with its argument', async () => {
+            setArgv('mapping-file', 'compile', 'mapping.ts');
+            await (0, index_1.main)();
+            expect(mappingCompileRun).toHaveBeenCalledWith('mapping.ts');
+        });
+        it('exits when mapping-file compile is missing its argument', async () => {
+            setArgv('mapping-file', 'compile');
+            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
+            expect(mappingCompileRun).not.toHaveBeenCalled();
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.ts>/));
+        });
+        it('dispatches mapping-file upload and forwards remaining args', async () => {
+            setArgv('mapping-file', 'upload', 'mapping.ts', '-m', 'msg', '--skip-git');
+            await (0, index_1.main)();
+            expect(mappingUploadRun).toHaveBeenCalledWith(['mapping.ts', '-m', 'msg', '--skip-git']);
+        });
+        it('exits when mapping-file upload is missing its argument', async () => {
+            setArgv('mapping-file', 'upload');
+            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
+            expect(mappingUploadRun).not.toHaveBeenCalled();
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.ts>/));
+        });
+        it.each(['help', '-h', '--help'])('prints mapping-file usage on %s', async (helpFlag) => {
+            setArgv('mapping-file', helpFlag);
+            await (0, index_1.main)();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm mapping-file/));
+        });
+        it('prints mapping-file usage when no subcommand is provided', async () => {
+            setArgv('mapping-file');
+            await (0, index_1.main)();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm mapping-file/));
+        });
+        it('exits on an unknown mapping-file subcommand', async () => {
+            setArgv('mapping-file', 'bogus');
+            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Unknown mapping-file subcommand: bogus/));
+        });
     });
-    it('prints usage when no command is provided', async () => {
-        setArgv();
-        await (0, index_1.main)();
-        expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm-mapping/));
+    describe('config-file topic', () => {
+        it('dispatches config-file create', async () => {
+            setArgv('config-file', 'create');
+            await (0, index_1.main)();
+            expect(configCreateRun).toHaveBeenCalledTimes(1);
+            expect(configUploadRun).not.toHaveBeenCalled();
+        });
+        it('dispatches config-file upload and forwards remaining args', async () => {
+            setArgv('config-file', 'upload', 'cfg.json', '--update-config', '--skip-git');
+            await (0, index_1.main)();
+            expect(configUploadRun).toHaveBeenCalledWith(['cfg.json', '--update-config', '--skip-git']);
+        });
+        it('exits when config-file upload is missing its argument', async () => {
+            setArgv('config-file', 'upload');
+            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
+            expect(configUploadRun).not.toHaveBeenCalled();
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.json>/));
+        });
+        it('prints config-file usage when no subcommand is provided', async () => {
+            setArgv('config-file');
+            await (0, index_1.main)();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm config-file/));
+        });
+        it('exits on an unknown config-file subcommand', async () => {
+            setArgv('config-file', 'bogus');
+            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Unknown config-file subcommand: bogus/));
+        });
     });
-    it('exits on an unknown command', async () => {
-        setArgv('bogus');
-        await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Unknown command: bogus/));
+    describe('top-level dispatcher', () => {
+        it.each(['help', '-h', '--help'])('prints top-level usage on %s', async (helpFlag) => {
+            setArgv(helpFlag);
+            await (0, index_1.main)();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm <topic>/));
+        });
+        it('prints top-level usage when no topic is provided', async () => {
+            setArgv();
+            await (0, index_1.main)();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm <topic>/));
+        });
+        it('exits on an unknown topic', async () => {
+            setArgv('bogus');
+            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Unknown topic: bogus/));
+        });
     });
 });

package/lib/cli/template/config-template.json.template

@@ -0,0 +1,5 @@
+{
+  "orgName": "<ORG_NAME>",
+  "appIdentifier": "@vibeiq/flexplm-connector",
+  "config": {}
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.6.1-alpha.75cfe7f",
+  "version": "1.7.0-alpha.71b4d30",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "bin": {
-    "flexplm-mapping": "lib/cli/index.js"
+    "flexplm": "lib/cli/index.js"
   },
   "files": [
     "lib/**/*",

package/scripts/copy-template.js

@@ -2,9 +2,20 @@
 const fs = require('fs');
 const path = require('path');
 
-const SRC = path.join('src', 'cli', 'template', 'mapping-template.ts.template');
-const DST = path.join('lib', 'cli', 'template', 'mapping-template.ts.template');
+const SRC_DIR = path.join('src', 'cli', 'template');
+const DST_DIR = path.join('lib', 'cli', 'template');
 
-fs.mkdirSync(path.dirname(DST), { recursive: true });
-fs.copyFileSync(SRC, DST);
-console.log(`Copied ${SRC} -> ${DST}`);
+fs.mkdirSync(DST_DIR, { recursive: true });
+
+const entries = fs.readdirSync(SRC_DIR).filter((name) => name.endsWith('.template'));
+if (entries.length === 0) {
+  console.warn(`No .template files found in ${SRC_DIR}`);
+  process.exit(0);
+}
+
+for (const name of entries) {
+  const src = path.join(SRC_DIR, name);
+  const dst = path.join(DST_DIR, name);
+  fs.copyFileSync(src, dst);
+  console.log(`Copied ${src} -> ${dst}`);
+}