@contrail/cli 3.6.0-alpha-8-alpha.6d0c626 → 3.6.0-alpha-8-alpha.e4ae6bd

package/dist/commands/entities/get.js

@@ -6,6 +6,7 @@ const core_1 = require("@oclif/core");
 const basecommand_1 = require("../../basecommand");
 const sdk_1 = require("@contrail/sdk");
 const login_1 = require("../../auth/login");
+const common_1 = require("../../common");
 const types_1 = require("../../api/types");
 const propertySpecifications_1 = require("../../helpers/propertySpecifications/propertySpecifications");
 const batchFetch_1 = require("../../helpers/entities/batchFetch");
@@ -14,6 +15,8 @@ let MAX_NUMBER_OF_ENTITIES_TO_FETCH = undefined;
 class GetEntity extends basecommand_1.BaseCommand {
     static description = '(BETA) Get an entity';
     static examples = [
+        'contrail entities get color 123',
+        'contrail entities get color id1 id2 id3',
         'contrail entities get color -- id=123',
         'contrail entities get loader-processes -- createdOn=2025-09-15..2025-09-16',
         'contrail entities get orders -- updatedAt=2025-09-15T04:00:00Z..',
@@ -65,10 +68,15 @@ class GetEntity extends basecommand_1.BaseCommand {
             description: 'The name of the entity type to fetch',
             required: true,
         }),
+        ids: core_1.Args.string({
+            description: 'One or more entity ids; shorthand for the id/ids criteria',
+            required: false,
+        }),
     };
     static strict = false;
     async run() {
-        this.log('🚨 This command is in BETA and may change or be removed at any time.');
+        (0, common_1.routeConsoleLogToStderr)();
+        console.error('🚨 This command is in BETA and may change or be removed at any time.');
         await (0, login_1.authUser)();
         const { args, flags, argv } = await this.parse(GetEntity);
         const { typePath } = args;
@@ -76,11 +84,23 @@ class GetEntity extends basecommand_1.BaseCommand {
         SHOULD_USE_PAGINATED_FIND = shouldUsePaginatedFind;
         MAX_NUMBER_OF_ENTITIES_TO_FETCH = take;
         if (MAX_NUMBER_OF_ENTITIES_TO_FETCH)
-            console.log(`Will limit output to ${MAX_NUMBER_OF_ENTITIES_TO_FETCH} entities.`);
-        const propertySpecificationArgs = argv
-            .slice(1, argv.length)
-            .filter(propertySpecifications_1.isValidPropertySpecification);
-        const propertySpecBySlug = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(propertySpecificationArgs);
+            console.error(`Will limit output to ${MAX_NUMBER_OF_ENTITIES_TO_FETCH} entities.`);
+        const { ids: positionalIds, specs } = (0, propertySpecifications_1.partitionIdsAndSpecs)(argv.slice(1));
+        const propertySpecBySlug = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+        if (positionalIds.length > 0) {
+            if (propertySpecBySlug.has('id') || propertySpecBySlug.has('ids')) {
+                this.error('Pass ids positionally or as -- id=/ids= criteria, not both.');
+            }
+            if (propertySpecBySlug.size > 0) {
+                this.error('Positional ids cannot be combined with other -- criteria. Use -- ids= alongside the other criteria instead.');
+            }
+            if (positionalIds.length === 1) {
+                propertySpecBySlug.set('id', positionalIds[0]);
+            }
+            else {
+                propertySpecBySlug.set('ids', positionalIds);
+            }
+        }
         const relations = relationString
             ? relationString
                 .split(',')
@@ -115,7 +135,7 @@ class GetEntity extends basecommand_1.BaseCommand {
                 }
                 writer.write('\n]\n');
                 if (outputFile)
-                    this.log(`Output saved to ${outputFile}`);
+                    console.error(`Output saved to ${outputFile}`);
             }
             else {
                 const response = await getEntityByTypePath(typePath, propertySpecBySlug, {
@@ -127,7 +147,7 @@ class GetEntity extends basecommand_1.BaseCommand {
                 });
                 if (outputFile) {
                     fs_1.default.writeFileSync(outputFile, JSON.stringify(response, null, 2));
-                    this.log(`Output saved to ${outputFile}`);
+                    console.error(`Output saved to ${outputFile}`);
                 }
                 else {
                     this.log(JSON.stringify(response, null, 2));
@@ -212,7 +232,7 @@ async function* streamPaginatedFind(typePath, options = {}) {
             if (MAX_NUMBER_OF_ENTITIES_TO_FETCH && count >= MAX_NUMBER_OF_ENTITIES_TO_FETCH)
                 return;
         }
-        console.log(`Fetched ${count} entities`);
+        console.error(`Fetched ${count} entities`);
         if (!nextPageKey || results.length === 0)
             return;
     }

package/dist/commands/entities/grammar.spec.d.ts

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

package/dist/commands/entities/grammar.spec.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const create_1 = tslib_1.__importDefault(require("./create"));
+const get_1 = tslib_1.__importDefault(require("./get"));
+const update_1 = tslib_1.__importDefault(require("./update"));
+const delete_1 = tslib_1.__importDefault(require("./delete"));
+const propertySpecifications_1 = require("../../helpers/propertySpecifications/propertySpecifications");
+describe('entities command grammar: entities <verb> <typePath> [ID...]', () => {
+    describe('partitionIdsAndSpecs', () => {
+        it('should treat tokens without an equals sign as ids', () => {
+            const { ids, specs } = (0, propertySpecifications_1.partitionIdsAndSpecs)(['id1', 'id2', 'id3']);
+            expect(ids).toEqual(['id1', 'id2', 'id3']);
+            expect(specs).toEqual([]);
+        });
+        it('should treat slug=value tokens as property specifications', () => {
+            const { ids, specs } = (0, propertySpecifications_1.partitionIdsAndSpecs)(['name=jet', 'hex=000000']);
+            expect(ids).toEqual([]);
+            expect(specs).toEqual(['name=jet', 'hex=000000']);
+        });
+        it('should split mixed tokens preserving order within each group', () => {
+            const { ids, specs } = (0, propertySpecifications_1.partitionIdsAndSpecs)(['id1', 'name=jet', 'id2', 'status=archived']);
+            expect(ids).toEqual(['id1', 'id2']);
+            expect(specs).toEqual(['name=jet', 'status=archived']);
+        });
+        it('should not classify malformed specs as ids', () => {
+            const { ids, specs } = (0, propertySpecifications_1.partitionIdsAndSpecs)(['=value']);
+            expect(ids).toEqual([]);
+            expect(specs).toEqual([]);
+        });
+        it('should handle empty input', () => {
+            const { ids, specs } = (0, propertySpecifications_1.partitionIdsAndSpecs)([]);
+            expect(ids).toEqual([]);
+            expect(specs).toEqual([]);
+        });
+    });
+    describe('positional id arguments', () => {
+        it('get accepts variadic positional ids', () => {
+            expect(get_1.default.strict).toBe(false);
+            expect(get_1.default.args.ids).toBeDefined();
+        });
+        it('update accepts variadic positional ids and has no single id arg', () => {
+            expect(update_1.default.strict).toBe(false);
+            expect(update_1.default.args.ids).toBeDefined();
+            expect(update_1.default.args.id).toBeUndefined();
+        });
+        it('delete accepts variadic positional ids and has no --id flag', () => {
+            expect(delete_1.default.strict).toBe(false);
+            expect(delete_1.default.args.ids).toBeDefined();
+            expect(delete_1.default.flags.id).toBeUndefined();
+        });
+    });
+    describe('flag alignment across verbs', () => {
+        it('the input file is -i, --inputFile on every verb that accepts one', () => {
+            expect(create_1.default.flags.inputFile.char).toBe('i');
+            expect(update_1.default.flags.inputFile.char).toBe('i');
+            expect(delete_1.default.flags.inputFile.char).toBe('i');
+            expect(delete_1.default.flags.input).toBeUndefined();
+        });
+        it('skipHydrateRelationships is -S on every verb', () => {
+            expect(create_1.default.flags.skipHydrateRelationships.char).toBe('S');
+            expect(get_1.default.flags.skipHydrateRelationships.char).toBe('S');
+            expect(update_1.default.flags.skipHydrateRelationships.char).toBe('S');
+        });
+        it('get keeps -s for --skip', () => {
+            expect(get_1.default.flags.skip.char).toBe('s');
+        });
+    });
+});

package/dist/commands/entities/output.spec.d.ts

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

package/dist/commands/entities/output.spec.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const create_1 = require("./create");
+const update_1 = require("./update");
+const fulfilled = (value) => ({ status: 'fulfilled', value });
+const rejected = (message) => ({
+    status: 'rejected',
+    reason: new Error(message),
+});
+describe('mutation output summaries', () => {
+    describe('summarizeSettledCreates', () => {
+        it('should put every fulfilled result under created', () => {
+            const inputs = [{ name: 'a' }, { name: 'b' }];
+            const summary = (0, create_1.summarizeSettledCreates)(inputs, [
+                fulfilled({ id: '1', name: 'a' }),
+                fulfilled({ id: '2', name: 'b' }),
+            ]);
+            expect(summary.created).toEqual([
+                { id: '1', name: 'a' },
+                { id: '2', name: 'b' },
+            ]);
+            expect(summary.failed).toEqual([]);
+        });
+        it('should pair each failed input with its error so it can be retried as-is', () => {
+            const inputs = [{ itemId: 'itm-1' }, { itemId: 'itm-41x' }, { itemId: 'itm-3' }];
+            const summary = (0, create_1.summarizeSettledCreates)(inputs, [
+                fulfilled({ id: 'ai-1' }),
+                rejected('Item with ID itm-41x does not exist'),
+                fulfilled({ id: 'ai-3' }),
+            ]);
+            expect(summary.created).toEqual([{ id: 'ai-1' }, { id: 'ai-3' }]);
+            expect(summary.failed).toEqual([
+                { input: { itemId: 'itm-41x' }, error: 'Item with ID itm-41x does not exist' },
+            ]);
+        });
+        it('should fall back to details when the SDK error message is empty', () => {
+            const sdkError = Object.assign(new Error(''), {
+                details: '{"message":"Assortment not found.","statusCode":404}',
+            });
+            const summary = (0, create_1.summarizeSettledCreates)([{ assortmentId: 'bogus' }], [{ status: 'rejected', reason: sdkError }]);
+            expect(summary.failed[0].error).toBe('{"message":"Assortment not found.","statusCode":404}');
+        });
+        it('should stringify reasons that are not Errors', () => {
+            const summary = (0, create_1.summarizeSettledCreates)([{ name: 'a' }], [{ status: 'rejected', reason: 'boom' }]);
+            expect(summary.failed).toEqual([{ input: { name: 'a' }, error: 'boom' }]);
+        });
+        it('should handle empty input', () => {
+            expect((0, create_1.summarizeSettledCreates)([], [])).toEqual({ created: [], failed: [] });
+        });
+    });
+    describe('summarizeSettledUpdates', () => {
+        it('should report updated, failed, and skipped without stopping on failures', () => {
+            const inputs = [{ id: 'id1' }, { id: 'id2' }, { id: 'id3' }];
+            const summary = (0, update_1.summarizeSettledUpdates)(inputs, [
+                fulfilled({ id: 'id1', status: 'archived' }),
+                rejected('Entity not found.'),
+                fulfilled({ id: 'id3', status: 'archived' }),
+            ], 2);
+            expect(summary.updated).toEqual([
+                { id: 'id1', status: 'archived' },
+                { id: 'id3', status: 'archived' },
+            ]);
+            expect(summary.failed).toEqual([{ id: 'id2', error: 'Entity not found.' }]);
+            expect(summary.skipped).toBe(2);
+        });
+        it('should not report a failed id as updated', () => {
+            const summary = (0, update_1.summarizeSettledUpdates)([{ id: 'id1' }], [rejected('boom')], 0);
+            expect(summary.updated).toEqual([]);
+            expect(summary.failed).toEqual([{ id: 'id1', error: 'boom' }]);
+        });
+    });
+});

package/dist/commands/entities/update.d.ts

@@ -12,8 +12,19 @@ export default class UpdateEntity extends BaseCommand {
     };
     static args: {
         entityName: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
-        id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        ids: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
     };
     static strict: boolean;
     run(): Promise<void>;
 }
+export type UpdateSummary = {
+    updated: any[];
+    failed: {
+        id: string;
+        error: string;
+    }[];
+    skipped: number;
+};
+export declare function summarizeSettledUpdates(inputs: {
+    id: string;
+}[], settled: PromiseSettledResult<any>[], skipped: number): UpdateSummary;

package/dist/commands/entities/update.js

@@ -1,23 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeSettledUpdates = void 0;
 const tslib_1 = require("tslib");
 const p_limit_1 = tslib_1.__importDefault(require("p-limit"));
 const core_1 = require("@oclif/core");
 const basecommand_1 = require("../../basecommand");
 const sdk_1 = require("@contrail/sdk");
 const login_1 = require("../../auth/login");
+const common_1 = require("../../common");
 const propertySpecifications_1 = require("../../helpers/propertySpecifications/propertySpecifications");
 const file_helpers_1 = require("../../helpers/file-helpers");
 class UpdateEntity extends basecommand_1.BaseCommand {
     static description = '(BETA) Update an entity';
     static examples = [
         'contrail entities update color 123 -- name=obsidian hex=000000',
+        'contrail entities update item id1 id2 id3 -- status=archived # apply the same change to several entities',
         'contrail entities update color 123 -- description= notes=\'""\' # Unset description, set notes to empty string',
     ];
     static flags = {
         ...basecommand_1.BaseCommand.baseFlags,
         skipHydrateRelationships: core_1.Flags.boolean({
-            char: 's',
+            char: 'S',
             description: 'Skip hydrating relationships when updating the entity',
             required: false,
             default: false,
@@ -44,33 +47,38 @@ class UpdateEntity extends basecommand_1.BaseCommand {
             description: 'The name of the entity type to update',
             required: true,
         }),
-        id: core_1.Args.string({
-            description: 'The unique identifier of the entity',
+        ids: core_1.Args.string({
+            description: 'One or more entity ids to update',
             required: false,
         }),
     };
     static strict = false;
     async run() {
-        this.log('🚨 This command is in BETA and may change or be removed at any time.');
+        (0, common_1.routeConsoleLogToStderr)();
+        console.error('🚨 This command is in BETA and may change or be removed at any time.');
         await (0, login_1.authUser)();
         const { args, argv } = await this.parse(UpdateEntity);
-        const { id: specifiedId, entityName } = args;
+        const { entityName } = args;
         const { dryRun: isDryRun, inputFile: inputFilename, skipHydrateRelationships, force, } = this.flags;
-        const propertySpecArgs = argv.slice(1, argv.length).filter(propertySpecifications_1.isValidPropertySpecification);
-        const propertySpec = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(propertySpecArgs);
-        if (inputFilename && specifiedId) {
-            throw new Error('You cannot use --input and --id together. Please specify one or the other.');
+        const { ids: positionalIds, specs } = (0, propertySpecifications_1.partitionIdsAndSpecs)(argv.slice(1));
+        const propertySpec = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+        if (propertySpec.has('id') || propertySpec.has('ids')) {
+            this.error('The -- payload is values to write. Pass ids positionally: contrail entities update <typePath> <ID...> -- slug=value');
+        }
+        if (inputFilename && positionalIds.length > 0) {
+            this.error('You cannot use --inputFile and positional ids together. Please specify one or the other.');
+        }
+        if (!inputFilename && positionalIds.length === 0) {
+            this.error('You must provide one or more ids or an input file (-i) of entities to update.');
+        }
+        if (positionalIds.length > 0 && propertySpec.size === 0) {
+            this.error('Nothing to update: pass values to write after --, e.g. -- name=jet');
         }
         const entitiesToUpdate = inputFilename
             ? (0, file_helpers_1.parseFileAsJsonArray)(inputFilename)
-            : [{ id: specifiedId }];
-        const results = {
-            idsSuccessfullyUpdated: new Set(),
-            idsFailedToUpdate: new Set(),
-            numEntriesSkipped: entitiesToUpdate.filter(({ id }) => !id).length,
-        };
+            : positionalIds.map((id) => ({ id }));
+        const skipped = entitiesToUpdate.filter(({ id }) => !id).length;
         const entitiesWithId = entitiesToUpdate.filter(({ id }) => id);
-        propertySpec.delete('id'); // Remove 'id' from the property spec if it exists
         // will be applied to all entities
         const fixedValues = [...propertySpec.entries()].reduce((acc, [key, value]) => {
             acc[key] = value;
@@ -79,35 +87,48 @@ class UpdateEntity extends basecommand_1.BaseCommand {
         async function updateEntity(entity) {
             const newEntityState = { ...entity, ...fixedValues };
             const id = entity.id;
-            const promise = isDryRun
+            return isDryRun
                 ? mockUpdateById(entityName, id, newEntityState, { skipHydrateRelationships })
                 : updateEntityById(entityName, id, newEntityState, { skipHydrateRelationships, force });
-            promise
-                .catch(() => {
-                results.idsFailedToUpdate.add(id);
-            })
-                .then(() => {
-                results.idsSuccessfullyUpdated.add(id);
-            });
-            return promise;
         }
         try {
             const limit = (0, p_limit_1.default)(20);
-            const responses = await Promise.all(entitiesWithId.map((entity) => limit(() => updateEntity(entity))));
-            const messagePrefix = isDryRun
-                ? 'Dry run. Update skipped. Changes would be:'
-                : 'Entity updated successfully:';
-            this.log(`${messagePrefix}\n\n${JSON.stringify(responses, null, 2)}`);
-            this.log(`\nIDs successfully updated: ${Array.from(results.idsSuccessfullyUpdated).join(', ')}`);
-            this.log(`IDs failed to update: ${Array.from(results.idsFailedToUpdate).join(', ')}`);
-            this.log(`Number of entries skipped due to missing IDs: ${results.numEntriesSkipped}`);
+            const settled = await Promise.allSettled(entitiesWithId.map((entity) => limit(() => updateEntity(entity))));
+            const summary = summarizeSettledUpdates(entitiesWithId, settled, skipped);
+            if (isDryRun) {
+                console.error('Dry run. Update skipped. Changes would be:');
+            }
+            this.log(JSON.stringify(summary, null, 2));
+            if (summary.failed.length > 0) {
+                console.error(`${summary.failed.length} of ${entitiesWithId.length} updates failed.`);
+                process.exitCode = 1;
+            }
         }
         catch (e) {
-            this.error(`Error fetching entity: ${e.message}`);
+            this.error(`Error updating entities: ${e.message}`);
         }
     }
 }
 exports.default = UpdateEntity;
+// Every row is attempted; a failed row never stops the run. The summary pairs
+// each failed id with its error so the failed rows can be retried.
+function summarizeSettledUpdates(inputs, settled, skipped) {
+    const updated = [];
+    const failed = [];
+    settled.forEach((result, index) => {
+        if (result.status === 'fulfilled') {
+            updated.push(result.value);
+        }
+        else {
+            failed.push({
+                id: inputs[index].id,
+                error: (0, common_1.sdkErrorMessage)(result.reason),
+            });
+        }
+    });
+    return { updated, failed, skipped };
+}
+exports.summarizeSettledUpdates = summarizeSettledUpdates;
 async function updateEntityById(entityName, id, changes, options = {}) {
     const client = new sdk_1.Entities();
     const { skipHydrateRelationships, force } = options;

package/dist/common.d.ts

@@ -2,3 +2,5 @@
 export declare function getSeparatorByPlatform(): string;
 export declare function delay(ms: number): Promise<NodeJS.Timeout>;
 export declare function removeSlash(string: string): string;
+export declare function routeConsoleLogToStderr(): void;
+export declare function sdkErrorMessage(reason: any): string;

package/dist/common.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeSlash = exports.delay = exports.getSeparatorByPlatform = void 0;
+exports.sdkErrorMessage = exports.routeConsoleLogToStderr = exports.removeSlash = exports.delay = exports.getSeparatorByPlatform = void 0;
 function getSeparatorByPlatform() {
     const isWin = process.platform === 'win32';
     const separator = isWin ? '\\' : '/';
@@ -16,3 +16,15 @@ function removeSlash(string) {
     return string.replace(re, '-');
 }
 exports.removeSlash = removeSlash;
+// The SDK and auth flow print request logs and token messages via bare
+// console.log. A command whose stdout is a data contract must route those to
+// stderr before any of that code runs.
+function routeConsoleLogToStderr() {
+    console.log = (...args) => console.error(...args);
+}
+exports.routeConsoleLogToStderr = routeConsoleLogToStderr;
+// SDK errors can carry an empty message with the response body in details
+function sdkErrorMessage(reason) {
+    return reason?.message || reason?.details || String(reason);
+}
+exports.sdkErrorMessage = sdkErrorMessage;

package/dist/helpers/propertySpecifications/propertySpecifications.d.ts

@@ -29,4 +29,13 @@ export type PropertySpecificationBySlug = Map<string, string | number | string[]
 export type PropertySpecificationString = `${string}=${string}`;
 export declare function parsePropertySpecification(spec: PropertySpecificationString): PropertySpecification;
 export declare function parsePropertySpecificationsIntoMap(propertySpecifications: PropertySpecificationString[]): PropertySpecificationBySlug;
+/**
+ * Splits command argv tokens (after the typePath) into positional ids and
+ * property specifications. A token containing '=' is a property specification
+ * candidate; every other token is an id.
+ */
+export declare function partitionIdsAndSpecs(tokens: string[]): {
+    ids: string[];
+    specs: PropertySpecificationString[];
+};
 export declare function isValidPropertySpecification(maybeSpec: string): maybeSpec is PropertySpecificationString;

package/dist/helpers/propertySpecifications/propertySpecifications.js

@@ -23,7 +23,7 @@
  * contrail entities get loader-processes -- createdOn=2025-09-15..2025-09-16
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidPropertySpecification = exports.parsePropertySpecificationsIntoMap = exports.parsePropertySpecification = void 0;
+exports.isValidPropertySpecification = exports.partitionIdsAndSpecs = exports.parsePropertySpecificationsIntoMap = exports.parsePropertySpecification = void 0;
 const dateRanges_1 = require("./dateRanges");
 // Special tokens for empty strings
 const DOUBLE_QUOTED_EMPTY = '""';
@@ -64,23 +64,37 @@ function parsePropertySpecificationsIntoMap(propertySpecifications) {
             continue;
         }
         const { slug, value } = parsePropertySpecification(spec);
-        if (slug === 'roles' && value !== undefined) {
-            // Special handling for roles, which can be an array (only if value is not undefined)
-            const rolesArray = value.split(',').map((role) => role.trim());
-            propertySpecBySlug.set(slug, rolesArray);
-            continue;
-        }
         if (slug === 'ids' && value !== undefined) {
-            // Special handling for ids, which can be an array (only if value is not undefined)
+            // ids is the one comma-split exception: it is a list of ids by definition
+            // and ids never contain commas.
             const idsArray = value.split(',').map((id) => id.trim());
             propertySpecBySlug.set(slug, idsArray);
             continue;
         }
+        // Repeating a key accumulates values into an array; commas in every other
+        // value are literal.
+        const existing = propertySpecBySlug.get(slug);
+        if (propertySpecBySlug.has(slug) && existing !== undefined && value !== undefined) {
+            propertySpecBySlug.set(slug, Array.isArray(existing) ? [...existing, value] : [existing, value]);
+            continue;
+        }
         propertySpecBySlug.set(slug, value);
     }
     return propertySpecBySlug;
 }
 exports.parsePropertySpecificationsIntoMap = parsePropertySpecificationsIntoMap;
+/**
+ * Splits command argv tokens (after the typePath) into positional ids and
+ * property specifications. A token containing '=' is a property specification
+ * candidate; every other token is an id.
+ */
+function partitionIdsAndSpecs(tokens) {
+    return {
+        ids: tokens.filter((token) => !token.includes('=')),
+        specs: tokens.filter(isValidPropertySpecification),
+    };
+}
+exports.partitionIdsAndSpecs = partitionIdsAndSpecs;
 function isValidPropertySpecification(maybeSpec) {
     try {
         if ((0, dateRanges_1.isDateRangeSpecification)(maybeSpec)) {

package/dist/helpers/propertySpecifications/propertySpecifications.spec.js

@@ -142,12 +142,17 @@ describe('parsePropertySpecificationsIntoMap', () => {
         expect(result.get('url')).toBe('https://example.com');
         expect(result.size).toBe(3);
     });
-    it('should handle duplicate slugs by overwriting with last value', () => {
+    it('should accumulate repeated keys into an array', () => {
         const specs = ['name=first', 'name=second', 'name=third'];
         const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
-        expect(result.get('name')).toBe('third');
+        expect(result.get('name')).toEqual(['first', 'second', 'third']);
         expect(result.size).toBe(1);
     });
+    it('should keep a single value scalar', () => {
+        const specs = ['status=archived'];
+        const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
+        expect(result.get('status')).toBe('archived');
+    });
     it('should handle property specifications with empty values', () => {
         const specs = ['name=john', 'description=', 'notes=""'];
         const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
@@ -163,21 +168,21 @@ describe('parsePropertySpecificationsIntoMap', () => {
         ];
         expect(() => (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs)).toThrow('Invalid property specification: invalid');
     });
-    it('should handle roles as comma-separated array', () => {
-        const specs = ['roles=option,family', 'name=Test'];
+    it('should build roles arrays from repeated keys, with commas literal', () => {
+        const specs = ['roles=option', 'roles=family', 'name=Test'];
         const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
         expect(result.get('roles')).toEqual(['option', 'family']);
         expect(result.get('name')).toBe('Test');
     });
-    it('should handle roles as single value', () => {
-        const specs = ['roles=option'];
+    it('should treat a comma in a roles value as literal', () => {
+        const specs = ['roles=option,family'];
         const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
-        expect(result.get('roles')).toEqual(['option']);
+        expect(result.get('roles')).toBe('option,family');
     });
-    it('should trim whitespace in roles array', () => {
-        const specs = ['roles=option, family, variant'];
+    it('should keep commas literal in ordinary values', () => {
+        const specs = ['name=my,name'];
         const result = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(specs);
-        expect(result.get('roles')).toEqual(['option', 'family', 'variant']);
+        expect(result.get('name')).toBe('my,name');
     });
     it('should handle ids as comma-separated array', () => {
         const specs = ['ids=1,2,3', 'name=Test'];

package/dist/logger.js

@@ -12,7 +12,10 @@ class Logger {
         debug: 'blue',
     };
     constructor() {
-        const transport = new winston_1.transports.Console();
+        // All log output goes to stderr so stdout carries only command output (JSON)
+        const transport = new winston_1.transports.Console({
+            stderrLevels: ['error', 'warn', 'info', 'debug'],
+        });
         winston_1.default.addColors(this.colors);
         this.logger = (0, winston_1.createLogger)({
             level: 'info',

package/dist/logger.spec.d.ts

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

package/dist/logger.spec.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const logger_1 = tslib_1.__importDefault(require("./logger"));
+describe('logger', () => {
+    it('writes every level to stderr so stdout carries only command output', () => {
+        const consoleTransport = logger_1.default.transports[0];
+        for (const level of ['error', 'warn', 'info', 'debug']) {
+            expect(consoleTransport.stderrLevels[level]).toBe(true);
+        }
+    });
+});