@airctrl/cli 0.0.0-stage → 0.4.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.
- package/README.md +2080 -2
- package/dist/cli-error.js +29 -0
- package/dist/cli.js +502 -0
- package/dist/config.js +102 -0
- package/dist/deadline.js +13 -0
- package/dist/gateway-commands.js +487 -0
- package/dist/group-commands.js +92 -0
- package/dist/identity-rotation.js +550 -0
- package/dist/index.js +21 -0
- package/dist/migrate.js +232 -0
- package/dist/parser.js +120 -0
- package/dist/pat-expired.js +31 -0
- package/dist/project-commands.js +121 -0
- package/dist/prompt.js +45 -0
- package/dist/record-commands.js +330 -0
- package/dist/resolve-client.js +160 -0
- package/dist/resolve-status-principal.js +69 -0
- package/dist/sa-commands.js +1485 -0
- package/dist/service-account-read-commands.js +38 -0
- package/dist/store/atomic-write.js +344 -0
- package/dist/store/base-url.js +71 -0
- package/dist/store/canonical.js +45 -0
- package/dist/store/durable-delete.js +86 -0
- package/dist/store/errors.js +25 -0
- package/dist/store/fsops.js +94 -0
- package/dist/store/handoff-store.js +183 -0
- package/dist/store/identity-rotation-journal.js +396 -0
- package/dist/store/index.js +20 -0
- package/dist/store/lock.js +294 -0
- package/dist/store/names.js +52 -0
- package/dist/store/paths.js +219 -0
- package/dist/store/profile-store.js +262 -0
- package/dist/store/receipt-store.js +75 -0
- package/dist/store/resolve-principal.js +125 -0
- package/dist/store/rotation-store.js +66 -0
- package/dist/store/schema.js +554 -0
- package/package.json +42 -4
|
@@ -0,0 +1,487 @@
|
|
|
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', 'cursor', 'limit', 'offset', ...profile],
|
|
85
|
+
},
|
|
86
|
+
log: { positionals: ['gatewayId', 'logId'], flags: profile },
|
|
87
|
+
'key-access': {
|
|
88
|
+
positionals: ['gatewayId'],
|
|
89
|
+
flags: ['outcome', 'since', 'cursor', 'limit', 'offset', ...profile],
|
|
90
|
+
},
|
|
91
|
+
'usage-logs': {
|
|
92
|
+
positionals: [],
|
|
93
|
+
flags: ['project', 'since', 'provider', 'model', 'status', 'gateway', 'cursor', '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', 'bodies', '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
|
+
cursor: parsed.flags.cursor,
|
|
393
|
+
limit: numberFlag(parsed.flags.limit, true, 1, 200),
|
|
394
|
+
offset: numberFlag(parsed.flags.offset, true),
|
|
395
|
+
});
|
|
396
|
+
break;
|
|
397
|
+
case 'log':
|
|
398
|
+
result = await client.getGatewayLogDetail(id, childId);
|
|
399
|
+
break;
|
|
400
|
+
case 'key-access':
|
|
401
|
+
result = await client.listGatewayKeyAccess(id, {
|
|
402
|
+
outcome: enumFlag(parsed.flags.outcome, ['granted', 'denied', 'error']),
|
|
403
|
+
since: parsed.flags.since,
|
|
404
|
+
cursor: parsed.flags.cursor,
|
|
405
|
+
limit: numberFlag(parsed.flags.limit, true, 1, 200),
|
|
406
|
+
offset: numberFlag(parsed.flags.offset, true),
|
|
407
|
+
});
|
|
408
|
+
break;
|
|
409
|
+
case 'usage-logs':
|
|
410
|
+
result = await client.listUsageLogs({
|
|
411
|
+
projectId: parsed.flags.project,
|
|
412
|
+
since: parsed.flags.since,
|
|
413
|
+
provider: parsed.flags.provider,
|
|
414
|
+
model: parsed.flags.model,
|
|
415
|
+
status: numberFlag(parsed.flags.status, true, 100, 599),
|
|
416
|
+
gatewayId: parsed.flags.gateway,
|
|
417
|
+
cursor: parsed.flags.cursor,
|
|
418
|
+
limit: numberFlag(parsed.flags.limit, true, 1, 200),
|
|
419
|
+
offset: numberFlag(parsed.flags.offset, true),
|
|
420
|
+
});
|
|
421
|
+
break;
|
|
422
|
+
case 'usage-log':
|
|
423
|
+
result = await client.getUsageLogDetail(parsed.flags.project, id);
|
|
424
|
+
break;
|
|
425
|
+
case 'usage-spend':
|
|
426
|
+
result = await client.getUsageSpend(parsed.flags.project);
|
|
427
|
+
break;
|
|
428
|
+
case 'usage-metrics':
|
|
429
|
+
result = await client.getUsageMetrics(parsed.flags.project, {
|
|
430
|
+
since: parsed.flags.since,
|
|
431
|
+
bucket: enumFlag(parsed.flags.bucket, ['hour', 'day']),
|
|
432
|
+
});
|
|
433
|
+
break;
|
|
434
|
+
case 'otel':
|
|
435
|
+
result = await client.getGatewayOtelExport(id, { accountId: account });
|
|
436
|
+
break;
|
|
437
|
+
case 'otel-update': {
|
|
438
|
+
const patch = {};
|
|
439
|
+
if (parsed.flags.enabled !== undefined)
|
|
440
|
+
patch.enabled = booleanFlag(parsed.flags.enabled);
|
|
441
|
+
if (parsed.flags.endpoint !== undefined)
|
|
442
|
+
patch.endpoint = nullable(parsed.flags.endpoint);
|
|
443
|
+
if (parsed.flags.metrics !== undefined)
|
|
444
|
+
patch.exportMetrics = booleanFlag(parsed.flags.metrics);
|
|
445
|
+
if (parsed.flags.traces !== undefined)
|
|
446
|
+
patch.exportTraces = booleanFlag(parsed.flags.traces);
|
|
447
|
+
if (parsed.flags.bodies !== undefined)
|
|
448
|
+
patch.exportBodies = booleanFlag(parsed.flags.bodies);
|
|
449
|
+
const headers = headersFromEnv(parsed.flags['headers-env'], booleanFlag(parsed.flags['clear-headers']), deps.env ?? process.env);
|
|
450
|
+
if (headers !== undefined)
|
|
451
|
+
patch.headers = headers;
|
|
452
|
+
requirePatch(patch);
|
|
453
|
+
result = await client.updateGatewayOtelExport(id, patch, { accountId: account });
|
|
454
|
+
break;
|
|
455
|
+
}
|
|
456
|
+
case 'provider-credentials':
|
|
457
|
+
result = await client.listProviderCredentials(account);
|
|
458
|
+
break;
|
|
459
|
+
case 'provider-credential-create':
|
|
460
|
+
result = await client.createProviderCredential({
|
|
461
|
+
accountId: account,
|
|
462
|
+
providerId: parsed.flags.provider,
|
|
463
|
+
label: parsed.flags.label,
|
|
464
|
+
apiKey: apiKeyFromEnv(parsed.flags['api-key-env'], deps.env ?? process.env),
|
|
465
|
+
baseUrlOverride: nullable(parsed.flags['base-url']),
|
|
466
|
+
credentialKind: enumFlag(parsed.flags.kind, ['api_key', 'oauth', 'aws_sigv4', 'gcp_sa']),
|
|
467
|
+
});
|
|
468
|
+
break;
|
|
469
|
+
case 'provider-models':
|
|
470
|
+
result = await client.listProviderCredentialModels(id, { accountId: account });
|
|
471
|
+
break;
|
|
472
|
+
case 'provider-credential-rotate':
|
|
473
|
+
result = await client.rotateProviderCredential(id, apiKeyFromEnv(parsed.flags['api-key-env'], deps.env ?? process.env), { accountId: account });
|
|
474
|
+
break;
|
|
475
|
+
case 'provider-credential-update':
|
|
476
|
+
result = await client.updateProviderCredentialLabel(id, parsed.flags.label, { accountId: account });
|
|
477
|
+
break;
|
|
478
|
+
case 'provider-credential-revoke':
|
|
479
|
+
await client.revokeProviderCredential(id, { accountId: account });
|
|
480
|
+
result = undefined;
|
|
481
|
+
break;
|
|
482
|
+
default:
|
|
483
|
+
throw new ParseError('cli_unknown_command');
|
|
484
|
+
}
|
|
485
|
+
writeResult(result, deps);
|
|
486
|
+
return 0;
|
|
487
|
+
}
|
|
@@ -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
|
+
}
|