@contrail/flexplm 1.3.0 → 1.3.1-alpha.56221f6

package/lib/cli/commands/compile.d.ts

@@ -0,0 +1 @@
+export declare function runCompile(tsPath: string): Promise<void>;

package/lib/cli/commands/compile.js

@@ -0,0 +1,71 @@
+"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.runCompile = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function loadTypescript() {
+    try {
+        return require('typescript');
+    }
+    catch (e) {
+        throw new Error('compile requires the "typescript" package. Install it in your project: npm install --save-dev typescript');
+    }
+}
+async function runCompile(tsPath) {
+    const absPath = path.resolve(process.cwd(), tsPath);
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`File not found: ${absPath}`);
+    }
+    if (!absPath.endsWith('.ts')) {
+        throw new Error(`Expected a .ts file, got: ${absPath}`);
+    }
+    const ts = loadTypescript();
+    const source = fs.readFileSync(absPath, 'utf8');
+    const result = ts.transpileModule(source, {
+        fileName: path.basename(absPath),
+        compilerOptions: {
+            module: ts.ModuleKind.CommonJS,
+            target: ts.ScriptTarget.ES2020,
+            esModuleInterop: true,
+        },
+        reportDiagnostics: true,
+    });
+    const diagnostics = result.diagnostics || [];
+    if (diagnostics.length > 0) {
+        const formatHost = {
+            getCanonicalFileName: (f) => f,
+            getCurrentDirectory: () => process.cwd(),
+            getNewLine: () => '\n',
+        };
+        const formatted = ts.formatDiagnosticsWithColorAndContext(diagnostics, formatHost);
+        process.stderr.write(formatted);
+        throw new Error(`Compile failed: ${diagnostics.length} diagnostic(s)`);
+    }
+    const outPath = absPath.replace(/\.ts$/, '.js');
+    fs.writeFileSync(outPath, result.outputText, 'utf8');
+    console.log(`Compiled ${outPath}`);
+}
+exports.runCompile = runCompile;

package/lib/cli/commands/compile.spec.d.ts

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

package/lib/cli/commands/compile.spec.js

@@ -0,0 +1,80 @@
+"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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const compile_1 = require("./compile");
+describe('runCompile', () => {
+    let tempDir;
+    let originalCwd;
+    let logSpy;
+    let stderrSpy;
+    beforeEach(() => {
+        originalCwd = process.cwd();
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flexplm-compile-'));
+        process.chdir(tempDir);
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        stderrSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+        stderrSpy.mockRestore();
+        process.chdir(originalCwd);
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('transpiles a .ts file to a sibling .js file', async () => {
+        const tsPath = path.join(tempDir, 'mapping.ts');
+        fs.writeFileSync(tsPath, `export const mapping = { orgName: 'acme' };\n`, 'utf8');
+        await (0, compile_1.runCompile)('mapping.ts');
+        const jsPath = path.join(tempDir, 'mapping.js');
+        expect(fs.existsSync(jsPath)).toBe(true);
+        const js = fs.readFileSync(jsPath, 'utf8');
+        expect(js).toContain('exports.mapping');
+        expect(js).toContain("orgName: 'acme'");
+    });
+    it('resolves the input path relative to cwd', async () => {
+        const subdir = path.join(tempDir, 'nested');
+        fs.mkdirSync(subdir);
+        const tsPath = path.join(subdir, 'm.ts');
+        fs.writeFileSync(tsPath, 'export const x = 1;\n', 'utf8');
+        await (0, compile_1.runCompile)('nested/m.ts');
+        expect(fs.existsSync(path.join(subdir, 'm.js'))).toBe(true);
+    });
+    it('throws when the input file does not exist', async () => {
+        await expect((0, compile_1.runCompile)('nope.ts')).rejects.toThrow(/File not found/);
+    });
+    it('throws when the input is not a .ts file', async () => {
+        const jsPath = path.join(tempDir, 'mapping.js');
+        fs.writeFileSync(jsPath, 'module.exports = {};', 'utf8');
+        await expect((0, compile_1.runCompile)('mapping.js')).rejects.toThrow(/Expected a \.ts file/);
+    });
+    it('throws on a TypeScript syntax error', async () => {
+        const tsPath = path.join(tempDir, 'broken.ts');
+        fs.writeFileSync(tsPath, 'export const = ;\n', 'utf8');
+        await expect((0, compile_1.runCompile)('broken.ts')).rejects.toThrow(/Compile failed/);
+        expect(fs.existsSync(path.join(tempDir, 'broken.js'))).toBe(false);
+    });
+});

package/lib/cli/commands/create.d.ts

@@ -0,0 +1 @@
+export declare function runCreate(): Promise<void>;

package/lib/cli/commands/create.js

@@ -0,0 +1,75 @@
+"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.runCreate = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const TEMPLATE_FILENAME = 'mapping-template.ts.template';
+const PLACEHOLDER = '<ORG_NAME>';
+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);
+        });
+    });
+}
+function findTemplate() {
+    const candidates = [
+        path.join(__dirname, '..', 'template', TEMPLATE_FILENAME),
+        path.join(__dirname, '..', '..', '..', 'src', 'cli', 'template', TEMPLATE_FILENAME),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`Could not locate ${TEMPLATE_FILENAME}. Tried:\n  ${candidates.join('\n  ')}`);
+}
+async function runCreate() {
+    const orgName = (await prompt('orgName: ')).trim();
+    if (!orgName) {
+        throw new Error('orgName is required');
+    }
+    const templatePath = findTemplate();
+    const templateBody = fs.readFileSync(templatePath, 'utf8');
+    const rendered = templateBody.split(PLACEHOLDER).join(orgName);
+    const outPath = path.resolve(process.cwd(), `${orgName}-transformMapping.ts`);
+    if (fs.existsSync(outPath)) {
+        throw new Error(`Refusing to overwrite existing file: ${outPath}`);
+    }
+    fs.writeFileSync(outPath, rendered, 'utf8');
+    console.log(`Created ${outPath}`);
+}
+exports.runCreate = runCreate;

package/lib/cli/commands/create.spec.d.ts

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

package/lib/cli/commands/create.spec.js

@@ -0,0 +1,78 @@
+"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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+let nextAnswer = '';
+jest.mock('readline', () => ({
+    createInterface: () => ({
+        question: (_q, cb) => cb(nextAnswer),
+        close: () => { },
+    }),
+}));
+const create_1 = require("./create");
+describe('runCreate', () => {
+    let tempDir;
+    let originalCwd;
+    let logSpy;
+    beforeEach(() => {
+        originalCwd = process.cwd();
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flexplm-create-'));
+        process.chdir(tempDir);
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        nextAnswer = '';
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+        process.chdir(originalCwd);
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('writes <orgName>-transformMapping.ts with the placeholder replaced', async () => {
+        nextAnswer = 'acme';
+        await (0, create_1.runCreate)();
+        const outPath = path.join(tempDir, 'acme-transformMapping.ts');
+        expect(fs.existsSync(outPath)).toBe(true);
+        const contents = fs.readFileSync(outPath, 'utf8');
+        expect(contents).toContain("orgName: 'acme'");
+        expect(contents).not.toContain('<ORG_NAME>');
+    });
+    it('trims whitespace around the orgName input', async () => {
+        nextAnswer = '  acme  ';
+        await (0, create_1.runCreate)();
+        expect(fs.existsSync(path.join(tempDir, 'acme-transformMapping.ts'))).toBe(true);
+    });
+    it('throws when orgName is empty', async () => {
+        nextAnswer = '   ';
+        await expect((0, create_1.runCreate)()).rejects.toThrow(/orgName is required/);
+    });
+    it('refuses to overwrite an existing file', async () => {
+        const existing = path.join(tempDir, 'acme-transformMapping.ts');
+        fs.writeFileSync(existing, 'do not clobber', 'utf8');
+        nextAnswer = 'acme';
+        await expect((0, create_1.runCreate)()).rejects.toThrow(/Refusing to overwrite/);
+        expect(fs.readFileSync(existing, 'utf8')).toEqual('do not clobber');
+    });
+});

package/lib/cli/commands/upload.d.ts

@@ -0,0 +1,10 @@
+interface UploadOptions {
+    filePath: string;
+    message?: string;
+    branch?: string;
+    skipGit: boolean;
+}
+export declare function parseUploadArgs(args: string[]): UploadOptions;
+export declare function buildCommitMessage(userMessage: string, fileId: string): string;
+export declare function runUpload(args: string[]): Promise<void>;
+export {};

package/lib/cli/commands/upload.js

@@ -0,0 +1,219 @@
+"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.buildCommitMessage = exports.parseUploadArgs = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const sdk_1 = require("@contrail/sdk");
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+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);
+        });
+    });
+}
+function parseUploadArgs(args) {
+    let filePath;
+    let message;
+    let branch;
+    let skipGit = 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.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 <path.js> argument');
+    }
+    return { filePath, message, branch, skipGit };
+}
+exports.parseUploadArgs = parseUploadArgs;
+function runGit(args, cwd) {
+    return (0, child_process_1.execFileSync)('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+}
+function tryRunGit(args, cwd) {
+    try {
+        const stdout = runGit(args, cwd);
+        return { ok: true, stdout, stderr: '' };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            stdout: err && err.stdout ? err.stdout.toString() : '',
+            stderr: err && err.stderr ? err.stderr.toString() : (err && err.message) || '',
+        };
+    }
+}
+function buildCommitMessage(userMessage, fileId) {
+    const lines = userMessage.split(/\r?\n/);
+    lines[0] = `${lines[0]} [fileId: ${fileId}]`;
+    return lines.join('\n');
+}
+exports.buildCommitMessage = buildCommitMessage;
+async function commitToGit(absPath, fileId, options) {
+    const repoDir = path.dirname(absPath);
+    const versionCheck = tryRunGit(['--version'], repoDir);
+    if (!versionCheck.ok) {
+        console.log('git command not available; skipping git commit.');
+        return;
+    }
+    const insideRepo = tryRunGit(['rev-parse', '--is-inside-work-tree'], repoDir);
+    if (!insideRepo.ok || insideRepo.stdout.trim() !== 'true') {
+        console.log(`Not inside a git working tree (${repoDir}); skipping git commit.`);
+        return;
+    }
+    const tracked = tryRunGit(['ls-files', '--error-unmatch', absPath], repoDir);
+    if (!tracked.ok) {
+        const answer = (await prompt(`File is not tracked by git: ${absPath}\nAdd it to git? (y/N): `)).toLowerCase();
+        if (answer !== 'y' && answer !== 'yes') {
+            console.log('Nothing was done in git.');
+            return;
+        }
+    }
+    if (options.branch) {
+        const branchResult = tryRunGit(['checkout', '-b', options.branch], repoDir);
+        if (!branchResult.ok) {
+            throw new Error(`Failed to create branch "${options.branch}": ${branchResult.stderr.trim()}`);
+        }
+        console.log(`Created and switched to branch "${options.branch}"`);
+    }
+    let message = options.message;
+    if (!message) {
+        message = await prompt('Commit message: ');
+        if (!message) {
+            throw new Error('A commit message is required');
+        }
+    }
+    const finalMessage = buildCommitMessage(message, fileId);
+    const addResult = tryRunGit(['add', '--', absPath], repoDir);
+    if (!addResult.ok) {
+        throw new Error(`git add failed: ${addResult.stderr.trim()}`);
+    }
+    const commitResult = tryRunGit(['commit', '-m', finalMessage, '--', absPath], repoDir);
+    if (!commitResult.ok) {
+        throw new Error(`git commit failed: ${commitResult.stderr.trim() || commitResult.stdout.trim()}`);
+    }
+    console.log(commitResult.stdout.trim());
+}
+async function runUpload(args) {
+    const options = parseUploadArgs(args);
+    const absPath = path.resolve(process.cwd(), options.filePath);
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`File not found: ${absPath}`);
+    }
+    if (!absPath.endsWith('.js')) {
+        throw new Error(`Expected a .js file, got: ${absPath}`);
+    }
+    let email = process.env.CONTRAIL_CLI_EMAIL;
+    let password = process.env.CONTRAIL_CLI_PASSWORD;
+    if (!email) {
+        email = await prompt('Email: ');
+    }
+    if (!password) {
+        password = await promptHidden('Password: ');
+    }
+    if (!email || !password) {
+        throw new Error('Email and password are required');
+    }
+    delete require.cache[absPath];
+    const loaded = require(absPath);
+    const mapping = loaded && loaded.mapping;
+    if (!mapping || !mapping.orgInfo) {
+        throw new Error(`Mapping file is missing "mapping.orgInfo" export: ${absPath}`);
+    }
+    const { orgName, appIdentifier } = mapping.orgInfo;
+    if (!orgName) {
+        throw new Error(`Mapping file is missing "mapping.orgInfo.orgName": ${absPath}`);
+    }
+    if (!appIdentifier) {
+        throw new Error(`Mapping file is missing "mapping.orgInfo.appIdentifier": ${absPath}`);
+    }
+    await (0, sdk_1.login)({ orgSlug: orgName, email, password });
+    console.log(`Logged in to org "${orgName}" as ${email}`);
+    const apps = await new sdk_1.Entities().get({
+        entityName: 'app',
+        criteria: { identifier: appIdentifier },
+    });
+    if (!apps || apps.length !== 1) {
+        throw new Error(`Expected exactly one app with identifier "${appIdentifier}" in org "${orgName}", found ${apps ? apps.length : 0}`);
+    }
+    const app = apps[0];
+    const buffer = fs.readFileSync(absPath);
+    const fileName = path.basename(absPath);
+    const fileOwner = `app:${app.id}`;
+    const uploadedFile = await new sdk_1.Files().createAndUploadFileFromBuffer(buffer, 'application/javascript', fileName, fileOwner);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const responsePath = `${absPath}.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.skipGit) {
+        return;
+    }
+    await commitToGit(absPath, uploadedFile.id, options);
+}
+exports.runUpload = runUpload;

package/lib/cli/commands/upload.spec.d.ts

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

package/lib/cli/commands/upload.spec.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@contrail/sdk', () => ({
+    Entities: jest.fn(),
+    Files: jest.fn(),
+    login: jest.fn(),
+}));
+const upload_1 = require("./upload");
+describe('parseUploadArgs', () => {
+    it('parses a bare file path', () => {
+        const opts = (0, upload_1.parseUploadArgs)(['mapping.js']);
+        expect(opts).toEqual({
+            filePath: 'mapping.js',
+            message: undefined,
+            branch: undefined,
+            skipGit: false,
+        });
+    });
+    it('parses -m commit message option', () => {
+        const opts = (0, upload_1.parseUploadArgs)(['mapping.js', '-m', 'my message']);
+        expect(opts.message).toEqual('my message');
+        expect(opts.skipGit).toBe(false);
+    });
+    it('parses -b branch option', () => {
+        const opts = (0, upload_1.parseUploadArgs)(['mapping.js', '-b', 'feature/x']);
+        expect(opts.branch).toEqual('feature/x');
+    });
+    it('parses --skip-git flag', () => {
+        const opts = (0, upload_1.parseUploadArgs)(['mapping.js', '--skip-git']);
+        expect(opts.skipGit).toBe(true);
+    });
+    it('accepts the legacy --skipGit alias', () => {
+        const opts = (0, upload_1.parseUploadArgs)(['mapping.js', '--skipGit']);
+        expect(opts.skipGit).toBe(true);
+    });
+    it('parses options before the file path', () => {
+        const opts = (0, upload_1.parseUploadArgs)(['-m', 'msg', '-b', 'br', 'mapping.js']);
+        expect(opts).toEqual({
+            filePath: 'mapping.js',
+            message: 'msg',
+            branch: 'br',
+            skipGit: false,
+        });
+    });
+    it('parses all options together', () => {
+        const opts = (0, upload_1.parseUploadArgs)(['mapping.js', '-m', 'msg', '-b', 'br', '--skip-git']);
+        expect(opts).toEqual({
+            filePath: 'mapping.js',
+            message: 'msg',
+            branch: 'br',
+            skipGit: true,
+        });
+    });
+    it('throws when -m is missing its value', () => {
+        expect(() => (0, upload_1.parseUploadArgs)(['mapping.js', '-m'])).toThrow(/-m requires a commit message/);
+    });
+    it('throws when -b is missing its value', () => {
+        expect(() => (0, upload_1.parseUploadArgs)(['mapping.js', '-b'])).toThrow(/-b requires a branch name/);
+    });
+    it('throws on unknown option', () => {
+        expect(() => (0, upload_1.parseUploadArgs)(['mapping.js', '--bogus'])).toThrow(/Unknown option: --bogus/);
+    });
+    it('throws when an extra positional argument is supplied', () => {
+        expect(() => (0, upload_1.parseUploadArgs)(['mapping.js', 'extra.js'])).toThrow(/Unexpected argument: extra\.js/);
+    });
+    it('throws when no file path is provided', () => {
+        expect(() => (0, upload_1.parseUploadArgs)([])).toThrow(/missing <path\.js>/);
+    });
+    it('throws when only options are provided', () => {
+        expect(() => (0, upload_1.parseUploadArgs)(['--skip-git'])).toThrow(/missing <path\.js>/);
+    });
+});
+describe('buildCommitMessage', () => {
+    it('appends fileId to the first line of a single-line message', () => {
+        expect((0, upload_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, upload_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, upload_1.buildCommitMessage)('header\r\nbody', 'fid');
+        expect(result).toEqual('header [fileId: fid]\nbody');
+    });
+    it('handles an empty message', () => {
+        expect((0, upload_1.buildCommitMessage)('', 'fid')).toEqual(' [fileId: fid]');
+    });
+});

package/lib/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(): Promise<void>;