@airctrl/cli 0.0.0-stage → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,482 @@
1
+ import { CliError } from './cli-error.js';
2
+ import { parseArgv, ParseError } from './parser.js';
3
+ import { resolveClient, resolveHumanClient } from './resolve-client.js';
4
+ const profile = ['profile'];
5
+ const accountProfile = ['account', 'profile'];
6
+ export const GATEWAY_SPECS = {
7
+ providers: { positionals: [], flags: profile },
8
+ list: { positionals: [], flags: ['project', ...profile], requiredFlags: ['project'] },
9
+ get: { positionals: ['gatewayId'], flags: profile },
10
+ create: {
11
+ positionals: [],
12
+ flags: ['account', 'project', 'name', 'slug', ...profile],
13
+ requiredFlags: ['account', 'project', 'name'],
14
+ repeatable: ['credential-binding'],
15
+ keyValue: ['credential-binding'],
16
+ },
17
+ update: {
18
+ positionals: ['gatewayId'],
19
+ flags: ['account', 'name', 'active', ...profile],
20
+ requiredFlags: ['account'],
21
+ },
22
+ delete: { positionals: ['gatewayId'], flags: accountProfile, requiredFlags: ['account'] },
23
+ tokens: { positionals: ['gatewayId'], flags: profile },
24
+ 'token-create': {
25
+ positionals: ['gatewayId'],
26
+ flags: [
27
+ 'account',
28
+ 'name',
29
+ 'expires-days',
30
+ 'scopes',
31
+ 'principal-type',
32
+ 'principal-id',
33
+ 'allowed-models',
34
+ 'spend-limit',
35
+ 'spend-window',
36
+ 'rate-limit',
37
+ ...profile,
38
+ ],
39
+ requiredFlags: ['account', 'name'],
40
+ },
41
+ 'token-revoke': {
42
+ positionals: ['gatewayId', 'tokenId'],
43
+ flags: accountProfile,
44
+ requiredFlags: ['account'],
45
+ },
46
+ 'token-rename': {
47
+ positionals: ['gatewayId', 'tokenId'],
48
+ flags: ['account', 'name', ...profile],
49
+ requiredFlags: ['account', 'name'],
50
+ },
51
+ 'token-delete': {
52
+ positionals: ['gatewayId', 'tokenId'],
53
+ flags: accountProfile,
54
+ requiredFlags: ['account'],
55
+ },
56
+ settings: {
57
+ positionals: ['gatewayId'],
58
+ flags: [
59
+ 'account',
60
+ 'spend-limit',
61
+ 'spend-window',
62
+ 'rate-limit',
63
+ 'logging',
64
+ 'log-bodies',
65
+ 'guardrail',
66
+ 'allowed-models',
67
+ ...profile,
68
+ ],
69
+ requiredFlags: ['account'],
70
+ },
71
+ 'credential-attach': {
72
+ positionals: ['gatewayId', 'credentialId'],
73
+ flags: ['account', ...profile],
74
+ repeatable: ['model'],
75
+ requiredFlags: ['account'],
76
+ },
77
+ 'credential-detach': {
78
+ positionals: ['gatewayId', 'credentialId'],
79
+ flags: ['account', 'model', ...profile],
80
+ requiredFlags: ['account'],
81
+ },
82
+ logs: {
83
+ positionals: ['gatewayId'],
84
+ flags: ['since', 'provider', 'model', 'status', 'limit', 'offset', ...profile],
85
+ },
86
+ log: { positionals: ['gatewayId', 'logId'], flags: profile },
87
+ 'key-access': {
88
+ positionals: ['gatewayId'],
89
+ flags: ['outcome', 'since', 'limit', 'offset', ...profile],
90
+ },
91
+ 'usage-logs': {
92
+ positionals: [],
93
+ flags: ['project', 'since', 'provider', 'model', 'status', 'gateway', 'limit', 'offset', ...profile],
94
+ requiredFlags: ['project'],
95
+ },
96
+ 'usage-log': {
97
+ positionals: ['logId'],
98
+ flags: ['project', ...profile],
99
+ requiredFlags: ['project'],
100
+ },
101
+ 'usage-spend': {
102
+ positionals: [],
103
+ flags: ['project', ...profile],
104
+ requiredFlags: ['project'],
105
+ },
106
+ 'usage-metrics': {
107
+ positionals: [],
108
+ flags: ['project', 'since', 'bucket', ...profile],
109
+ requiredFlags: ['project'],
110
+ },
111
+ otel: {
112
+ positionals: ['gatewayId'],
113
+ flags: accountProfile,
114
+ requiredFlags: ['account'],
115
+ },
116
+ 'otel-update': {
117
+ positionals: ['gatewayId'],
118
+ flags: ['account', 'enabled', 'endpoint', 'metrics', 'traces', 'headers-env', 'clear-headers', ...profile],
119
+ requiredFlags: ['account'],
120
+ },
121
+ 'provider-credentials': {
122
+ positionals: [],
123
+ flags: accountProfile,
124
+ requiredFlags: ['account'],
125
+ },
126
+ 'provider-credential-create': {
127
+ positionals: [],
128
+ flags: ['account', 'provider', 'label', 'api-key-env', 'base-url', 'kind', ...profile],
129
+ requiredFlags: ['account', 'provider', 'label', 'api-key-env'],
130
+ },
131
+ 'provider-models': {
132
+ positionals: ['credentialId'],
133
+ flags: accountProfile,
134
+ requiredFlags: ['account'],
135
+ },
136
+ 'provider-credential-rotate': {
137
+ positionals: ['credentialId'],
138
+ flags: ['account', 'api-key-env', ...profile],
139
+ requiredFlags: ['account', 'api-key-env'],
140
+ },
141
+ 'provider-credential-update': {
142
+ positionals: ['credentialId'],
143
+ flags: ['account', 'label', ...profile],
144
+ requiredFlags: ['account', 'label'],
145
+ },
146
+ 'provider-credential-revoke': {
147
+ positionals: ['credentialId'],
148
+ flags: accountProfile,
149
+ requiredFlags: ['account'],
150
+ },
151
+ };
152
+ /** Commands whose API operations explicitly accept a Service Account token. */
153
+ export const SERVICE_ACCOUNT_GATEWAY_COMMANDS = [
154
+ 'providers', 'get', 'tokens', 'logs', 'log', 'key-access',
155
+ ];
156
+ export const GATEWAY_USAGE = `airctrl gateway commands
157
+
158
+ providers | list | get | create | update | delete
159
+ tokens | token-create | token-revoke | token-rename | token-delete
160
+ settings | credential-attach | credential-detach
161
+ logs | log | key-access
162
+ usage-logs | usage-log | usage-spend | usage-metrics
163
+ otel | otel-update
164
+ provider-credentials | provider-credential-create | provider-models
165
+ provider-credential-rotate | provider-credential-update | provider-credential-revoke
166
+ `;
167
+ const DECIMAL_RE = /^\d+(?:\.\d+)?$/;
168
+ function numberFlag(value, integer = false, minimum = 0, maximum = Number.POSITIVE_INFINITY) {
169
+ if (value === undefined)
170
+ return undefined;
171
+ // nosemgrep: nodejs_scan.javascript-dos-rule-regex_dos -- CLI flag input is bounded and DECIMAL_RE is anchored without nested repetition.
172
+ if (!DECIMAL_RE.test(value))
173
+ throw new ParseError('cli_flag_invalid_value');
174
+ const parsed = Number(value);
175
+ if (!Number.isFinite(parsed) ||
176
+ (integer && !Number.isInteger(parsed)) ||
177
+ parsed < minimum ||
178
+ parsed > maximum) {
179
+ throw new ParseError('cli_flag_invalid_value');
180
+ }
181
+ return parsed;
182
+ }
183
+ function booleanFlag(value) {
184
+ if (value === undefined)
185
+ return undefined;
186
+ if (value === 'true')
187
+ return true;
188
+ if (value === 'false')
189
+ return false;
190
+ throw new ParseError('cli_flag_invalid_value');
191
+ }
192
+ function csv(value) {
193
+ if (value === undefined)
194
+ return undefined;
195
+ if (value === 'none')
196
+ return [];
197
+ const values = value.split(',').map((item) => item.trim()).filter(Boolean);
198
+ if (values.length === 0)
199
+ throw new ParseError('cli_flag_invalid_value');
200
+ return values;
201
+ }
202
+ function enumFlag(value, allowed) {
203
+ if (value === undefined)
204
+ return undefined;
205
+ if (!allowed.includes(value))
206
+ throw new ParseError('cli_flag_invalid_value');
207
+ return value;
208
+ }
209
+ function nullable(value) {
210
+ return value === 'null' ? null : value;
211
+ }
212
+ function requirePatch(patch) {
213
+ if (Object.keys(patch).length === 0)
214
+ throw new ParseError('cli_flag_missing_value');
215
+ }
216
+ function apiKeyFromEnv(name, env) {
217
+ // nosemgrep: nodejs_scan.javascript-dos-rule-regex_dos -- anchored environment-variable validation is linear.
218
+ if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
219
+ throw new ParseError('cli_flag_invalid_value');
220
+ const value = env[name];
221
+ if (typeof value !== 'string' || value.length === 0)
222
+ throw new CliError('cli_env_value_required');
223
+ return value;
224
+ }
225
+ function headersFromEnv(name, clear, env) {
226
+ if (name !== undefined && clear !== undefined)
227
+ throw new ParseError('cli_flag_invalid_value');
228
+ if (clear !== undefined)
229
+ return clear ? null : undefined;
230
+ if (name === undefined)
231
+ return undefined;
232
+ const json = apiKeyFromEnv(name, env);
233
+ let parsed;
234
+ try {
235
+ parsed = JSON.parse(json);
236
+ }
237
+ catch {
238
+ throw new CliError('cli_env_value_invalid');
239
+ }
240
+ if (parsed === null ||
241
+ typeof parsed !== 'object' ||
242
+ Array.isArray(parsed) ||
243
+ Object.values(parsed).some((value) => typeof value !== 'string')) {
244
+ throw new CliError('cli_env_value_invalid');
245
+ }
246
+ return parsed;
247
+ }
248
+ function clientFor(parsed, deps, command) {
249
+ const resolve = SERVICE_ACCOUNT_GATEWAY_COMMANDS.includes(command) ? resolveClient : resolveHumanClient;
250
+ return resolve({ ...deps.resolve, profileFlag: parsed.flags.profile }).client;
251
+ }
252
+ function writeResult(value, deps) {
253
+ const out = deps.stdout ?? ((text) => process.stdout.write(text));
254
+ out(`${JSON.stringify(value ?? { ok: true }, null, 2)}\n`);
255
+ }
256
+ export async function runGatewayCommand(argv, deps) {
257
+ const [command, ...rest] = argv;
258
+ if (command === undefined || command === 'help' || command === '--help') {
259
+ ;
260
+ (deps.stdout ?? ((text) => process.stdout.write(text)))(GATEWAY_USAGE);
261
+ return 0;
262
+ }
263
+ if (!command || !Object.hasOwn(GATEWAY_SPECS, command))
264
+ throw new ParseError('cli_unknown_command');
265
+ const parsed = parseArgv(rest, GATEWAY_SPECS[command]);
266
+ const client = clientFor(parsed, deps, command);
267
+ const account = parsed.flags.account;
268
+ const [id, childId] = parsed.positionals;
269
+ let result;
270
+ switch (command) {
271
+ case 'providers':
272
+ result = await client.listProviders();
273
+ break;
274
+ case 'list':
275
+ result = await client.listGateways(parsed.flags.project);
276
+ break;
277
+ case 'get':
278
+ result = await client.getGateway(id);
279
+ break;
280
+ case 'create':
281
+ {
282
+ const explicitBindings = (parsed.repeated['credential-binding'] ?? []).map((binding) => {
283
+ const separator = binding.indexOf('=');
284
+ return {
285
+ credentialId: binding.slice(0, separator),
286
+ modelId: binding.slice(separator + 1),
287
+ };
288
+ });
289
+ result = await client.createGateway({
290
+ accountId: account,
291
+ projectId: parsed.flags.project,
292
+ name: parsed.flags.name,
293
+ slug: parsed.flags.slug,
294
+ credentialBindings: explicitBindings,
295
+ });
296
+ }
297
+ break;
298
+ case 'update': {
299
+ const patch = {};
300
+ if (parsed.flags.name !== undefined)
301
+ patch.name = parsed.flags.name;
302
+ if (parsed.flags.active !== undefined)
303
+ patch.isActive = booleanFlag(parsed.flags.active);
304
+ requirePatch(patch);
305
+ result = await client.updateGateway(id, patch, { accountId: account });
306
+ break;
307
+ }
308
+ case 'delete':
309
+ await client.deleteGateway(id, { accountId: account });
310
+ result = undefined;
311
+ break;
312
+ case 'tokens':
313
+ result = await client.listGatewayTokens(id);
314
+ break;
315
+ case 'token-create': {
316
+ const principalType = enumFlag(parsed.flags['principal-type'], ['user', 'service_account']);
317
+ const principalId = parsed.flags['principal-id'];
318
+ if ((principalType === undefined) !== (principalId === undefined)) {
319
+ throw new ParseError('cli_flag_invalid_value');
320
+ }
321
+ const input = {
322
+ name: parsed.flags.name,
323
+ expiresInDays: numberFlag(parsed.flags['expires-days'], true, 1),
324
+ scopes: csv(parsed.flags.scopes),
325
+ principal: principalType && principalId ? { type: principalType, id: principalId } : undefined,
326
+ allowedModels: csv(parsed.flags['allowed-models']),
327
+ spendLimit: numberFlag(parsed.flags['spend-limit']),
328
+ spendWindow: enumFlag(parsed.flags['spend-window'], ['daily', 'weekly', 'monthly']),
329
+ rateLimitPerMin: numberFlag(parsed.flags['rate-limit'], true, 1),
330
+ };
331
+ result = await client.createGatewayToken(id, input, { accountId: account });
332
+ break;
333
+ }
334
+ case 'token-revoke':
335
+ await client.revokeGatewayToken(id, childId, { accountId: account });
336
+ result = undefined;
337
+ break;
338
+ case 'token-rename':
339
+ result = await client.renameGatewayToken(id, childId, parsed.flags.name, { accountId: account });
340
+ break;
341
+ case 'token-delete':
342
+ await client.deleteGatewayToken(id, childId, { accountId: account });
343
+ result = undefined;
344
+ break;
345
+ case 'settings': {
346
+ const patch = {};
347
+ if (parsed.flags['spend-limit'] !== undefined) {
348
+ patch.spendLimit = parsed.flags['spend-limit'] === 'null'
349
+ ? null
350
+ : numberFlag(parsed.flags['spend-limit']);
351
+ }
352
+ if (parsed.flags['spend-window'] !== undefined) {
353
+ patch.spendWindow = enumFlag(parsed.flags['spend-window'], ['daily', 'weekly', 'monthly']);
354
+ }
355
+ if (parsed.flags['rate-limit'] !== undefined) {
356
+ patch.rateLimitPerMin = parsed.flags['rate-limit'] === 'null'
357
+ ? null
358
+ : numberFlag(parsed.flags['rate-limit'], true, 1);
359
+ }
360
+ if (parsed.flags.logging !== undefined)
361
+ patch.loggingEnabled = booleanFlag(parsed.flags.logging);
362
+ if (parsed.flags['log-bodies'] !== undefined)
363
+ patch.logBodies = booleanFlag(parsed.flags['log-bodies']);
364
+ if (parsed.flags.guardrail !== undefined) {
365
+ patch.guardrailMode = enumFlag(parsed.flags.guardrail, ['off', 'flag', 'redact', 'block']);
366
+ }
367
+ if (parsed.flags['allowed-models'] !== undefined) {
368
+ patch.allowedModels = csv(parsed.flags['allowed-models']);
369
+ }
370
+ requirePatch(patch);
371
+ result = await client.updateGatewaySettings(id, patch, { accountId: account });
372
+ break;
373
+ }
374
+ case 'credential-attach': {
375
+ const models = parsed.repeated.model ?? [];
376
+ if (models.length === 0)
377
+ throw new ParseError('cli_flag_missing_value');
378
+ result = await client.attachGatewayCredential(id, childId, models, { accountId: account });
379
+ break;
380
+ }
381
+ case 'credential-detach':
382
+ result = parsed.flags.model
383
+ ? await client.detachGatewayCredentialModel(id, childId, parsed.flags.model, { accountId: account })
384
+ : await client.detachGatewayCredential(id, childId, { accountId: account });
385
+ break;
386
+ case 'logs':
387
+ result = await client.listGatewayLogs(id, {
388
+ since: parsed.flags.since,
389
+ provider: parsed.flags.provider,
390
+ model: parsed.flags.model,
391
+ status: numberFlag(parsed.flags.status, true, 100, 599),
392
+ limit: numberFlag(parsed.flags.limit, true, 1, 200),
393
+ offset: numberFlag(parsed.flags.offset, true),
394
+ });
395
+ break;
396
+ case 'log':
397
+ result = await client.getGatewayLogDetail(id, childId);
398
+ break;
399
+ case 'key-access':
400
+ result = await client.listGatewayKeyAccess(id, {
401
+ outcome: enumFlag(parsed.flags.outcome, ['granted', 'denied', 'error']),
402
+ since: parsed.flags.since,
403
+ limit: numberFlag(parsed.flags.limit, true, 1, 200),
404
+ offset: numberFlag(parsed.flags.offset, true),
405
+ });
406
+ break;
407
+ case 'usage-logs':
408
+ result = await client.listUsageLogs({
409
+ projectId: parsed.flags.project,
410
+ since: parsed.flags.since,
411
+ provider: parsed.flags.provider,
412
+ model: parsed.flags.model,
413
+ status: numberFlag(parsed.flags.status, true, 100, 599),
414
+ gatewayId: parsed.flags.gateway,
415
+ limit: numberFlag(parsed.flags.limit, true, 1, 200),
416
+ offset: numberFlag(parsed.flags.offset, true),
417
+ });
418
+ break;
419
+ case 'usage-log':
420
+ result = await client.getUsageLogDetail(parsed.flags.project, id);
421
+ break;
422
+ case 'usage-spend':
423
+ result = await client.getUsageSpend(parsed.flags.project);
424
+ break;
425
+ case 'usage-metrics':
426
+ result = await client.getUsageMetrics(parsed.flags.project, {
427
+ since: parsed.flags.since,
428
+ bucket: enumFlag(parsed.flags.bucket, ['hour', 'day']),
429
+ });
430
+ break;
431
+ case 'otel':
432
+ result = await client.getGatewayOtelExport(id, { accountId: account });
433
+ break;
434
+ case 'otel-update': {
435
+ const patch = {};
436
+ if (parsed.flags.enabled !== undefined)
437
+ patch.enabled = booleanFlag(parsed.flags.enabled);
438
+ if (parsed.flags.endpoint !== undefined)
439
+ patch.endpoint = nullable(parsed.flags.endpoint);
440
+ if (parsed.flags.metrics !== undefined)
441
+ patch.exportMetrics = booleanFlag(parsed.flags.metrics);
442
+ if (parsed.flags.traces !== undefined)
443
+ patch.exportTraces = booleanFlag(parsed.flags.traces);
444
+ const headers = headersFromEnv(parsed.flags['headers-env'], booleanFlag(parsed.flags['clear-headers']), deps.env ?? process.env);
445
+ if (headers !== undefined)
446
+ patch.headers = headers;
447
+ requirePatch(patch);
448
+ result = await client.updateGatewayOtelExport(id, patch, { accountId: account });
449
+ break;
450
+ }
451
+ case 'provider-credentials':
452
+ result = await client.listProviderCredentials(account);
453
+ break;
454
+ case 'provider-credential-create':
455
+ result = await client.createProviderCredential({
456
+ accountId: account,
457
+ providerId: parsed.flags.provider,
458
+ label: parsed.flags.label,
459
+ apiKey: apiKeyFromEnv(parsed.flags['api-key-env'], deps.env ?? process.env),
460
+ baseUrlOverride: nullable(parsed.flags['base-url']),
461
+ credentialKind: enumFlag(parsed.flags.kind, ['api_key', 'oauth', 'aws_sigv4', 'gcp_sa']),
462
+ });
463
+ break;
464
+ case 'provider-models':
465
+ result = await client.listProviderCredentialModels(id, { accountId: account });
466
+ break;
467
+ case 'provider-credential-rotate':
468
+ result = await client.rotateProviderCredential(id, apiKeyFromEnv(parsed.flags['api-key-env'], deps.env ?? process.env), { accountId: account });
469
+ break;
470
+ case 'provider-credential-update':
471
+ result = await client.updateProviderCredentialLabel(id, parsed.flags.label, { accountId: account });
472
+ break;
473
+ case 'provider-credential-revoke':
474
+ await client.revokeProviderCredential(id, { accountId: account });
475
+ result = undefined;
476
+ break;
477
+ default:
478
+ throw new ParseError('cli_unknown_command');
479
+ }
480
+ writeResult(result, deps);
481
+ return 0;
482
+ }
@@ -0,0 +1,92 @@
1
+ import { parseArgv, ParseError } from './parser.js';
2
+ import { resolveHumanClient } from './resolve-client.js';
3
+ const scoped = (positionals, flags = [], required = []) => ({
4
+ positionals, flags: ['account', 'profile', ...flags], requiredFlags: ['account', ...required],
5
+ });
6
+ export const GROUP_SPECS = {
7
+ list: scoped(['projectId']),
8
+ 'record-grants': scoped(['recordId']),
9
+ create: scoped(['projectId'], ['name', 'description'], ['name']),
10
+ update: scoped(['groupId'], ['name', 'description'], ['name']),
11
+ delete: scoped(['groupId']),
12
+ members: scoped(['groupId']),
13
+ 'add-member': scoped(['groupId', 'userId']),
14
+ 'remove-member': scoped(['groupId', 'userId']),
15
+ 'grant-project': scoped(['projectId', 'groupId', 'roleId']),
16
+ 'revoke-project': scoped(['projectId', 'groupId', 'roleId']),
17
+ reconcile: scoped([], ['project']),
18
+ };
19
+ export const GROUP_USAGE = `airctrl group commands (all require --account <id>)
20
+
21
+ list <projectId>
22
+ record-grants <recordId>
23
+ create <projectId> --name <name> [--description <text>]
24
+ update <groupId> --name <name> [--description <text>]
25
+ delete|members <groupId>
26
+ add-member|remove-member <groupId> <userId>
27
+ grant-project|revoke-project <projectId> <groupId> <roleId>
28
+ reconcile [--project <id>]
29
+
30
+ Mutations return the server's material-pending snapshot. Run reconcile with an
31
+ authorized holder's vault unlocked to attempt sealing/re-key; it never grants access.
32
+ Omitting --project reconciles readable projects in the selected account. Direct
33
+ group-record shares in that account are repaired in either mode. Unavailable
34
+ holder material may remain pending. Revocations do not require a vault password.
35
+ `;
36
+ export async function runGroupCommand(argv, deps) {
37
+ const [command, ...rest] = argv;
38
+ const out = deps.stdout ?? ((value) => process.stdout.write(value));
39
+ if (command === undefined || command === 'help' || command === '--help') {
40
+ out(GROUP_USAGE);
41
+ return 0;
42
+ }
43
+ if (!Object.hasOwn(GROUP_SPECS, command))
44
+ throw new ParseError('cli_unknown_command');
45
+ const parsed = parseArgv(rest, GROUP_SPECS[command]);
46
+ const { client } = resolveHumanClient({ ...deps.resolve, profileFlag: parsed.flags.profile });
47
+ const [id, second, third] = parsed.positionals;
48
+ const options = { accountId: parsed.flags.account };
49
+ const input = { name: parsed.flags.name, description: parsed.flags.description };
50
+ let result;
51
+ switch (command) {
52
+ case 'list':
53
+ result = await client.listGroups(id, options);
54
+ break;
55
+ case 'record-grants':
56
+ result = await client.getRecordGroupCatalog(id, options);
57
+ break;
58
+ case 'create':
59
+ result = await client.createGroup(id, input, options);
60
+ break;
61
+ case 'update':
62
+ result = await client.updateGroup(id, input, options);
63
+ break;
64
+ case 'delete':
65
+ result = await client.deleteGroup(id, options);
66
+ break;
67
+ case 'members':
68
+ result = await client.listGroupMembers(id, options);
69
+ break;
70
+ case 'add-member':
71
+ result = await client.addGroupMember(id, second, options);
72
+ break;
73
+ case 'remove-member':
74
+ result = await client.removeGroupMember(id, second, options);
75
+ break;
76
+ case 'grant-project':
77
+ result = await client.grantProjectGroup(id, second, third, options);
78
+ break;
79
+ case 'revoke-project':
80
+ result = await client.revokeProjectGroup(id, second, third, options);
81
+ break;
82
+ case 'reconcile':
83
+ result = await client.reconcileGroupAccess({ ...options,
84
+ ...(parsed.flags.project ? { projectIds: [parsed.flags.project] } : {}),
85
+ vaultPassword: await deps.resolveVaultPassword(),
86
+ });
87
+ break;
88
+ default: throw new ParseError('cli_unknown_command');
89
+ }
90
+ out(`${JSON.stringify(result ?? { ok: true }, null, 2)}\n`);
91
+ return 0;
92
+ }