@airctrl/cli 0.5.0 → 0.6.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 +310 -607
- package/dist/cli.js +8 -0
- package/dist/gateway-commands.js +8 -4
- package/dist/mcp-gateway-commands.js +185 -0
- package/dist/sa-commands.js +20 -3
- package/package.json +2 -2
package/dist/cli.js
CHANGED
|
@@ -15,6 +15,7 @@ import { resolveClient, resolveHumanClient } from './resolve-client.js';
|
|
|
15
15
|
import { CliError, ReconcileError } from './cli-error.js';
|
|
16
16
|
import { runSaCommand, buildSaDeps } from './sa-commands.js';
|
|
17
17
|
import { runGatewayCommand } from './gateway-commands.js';
|
|
18
|
+
import { runMcpGatewayCommand } from './mcp-gateway-commands.js';
|
|
18
19
|
import { runRecordCommand } from './record-commands.js';
|
|
19
20
|
import { runProjectCommand } from './project-commands.js';
|
|
20
21
|
import { runGroupCommand } from './group-commands.js';
|
|
@@ -125,6 +126,7 @@ export const USAGE = `airctrl — inject AIRCTRL secrets into your process (clie
|
|
|
125
126
|
airctrl new <format> --name <n> [--project <id>] [--opt value …] [--env development|staging|production] [--profile <name>]
|
|
126
127
|
airctrl import env <file> --name <n> [--project <id>] [--target-env <e>] [--env development|staging|production] [--profile <name>]
|
|
127
128
|
airctrl gateway <command> [args] [--profile <name>] (run: airctrl gateway help)
|
|
129
|
+
airctrl mcp-gateway <command> [args] [--profile <name>] (run: airctrl mcp-gateway help)
|
|
128
130
|
airctrl record <command> [args] [--profile <name>] (run: airctrl record help)
|
|
129
131
|
airctrl project <command> [args] [--profile <name>] (run: airctrl project help)
|
|
130
132
|
airctrl group <command> [args] [--profile <name>] (run: airctrl group help)
|
|
@@ -446,6 +448,12 @@ export async function runCli(argv, deps = {}) {
|
|
|
446
448
|
env: deps.env,
|
|
447
449
|
stdout: deps.stdout,
|
|
448
450
|
});
|
|
451
|
+
case 'mcp-gateway':
|
|
452
|
+
return runMcpGatewayCommand(rest, {
|
|
453
|
+
resolve: resolveClientDeps(deps),
|
|
454
|
+
env: deps.env,
|
|
455
|
+
stdout: deps.stdout,
|
|
456
|
+
});
|
|
449
457
|
case 'record':
|
|
450
458
|
return runRecordCommand(rest, {
|
|
451
459
|
resolve: resolveClientDeps(deps),
|
package/dist/gateway-commands.js
CHANGED
|
@@ -81,16 +81,16 @@ export const GATEWAY_SPECS = {
|
|
|
81
81
|
},
|
|
82
82
|
logs: {
|
|
83
83
|
positionals: ['gatewayId'],
|
|
84
|
-
flags: ['since', 'provider', 'model', 'status', 'status-class', 'search', 'cursor', 'limit', 'offset', ...profile],
|
|
84
|
+
flags: ['since', 'until', 'provider', 'model', 'status', 'status-class', 'search', 'cursor', 'limit', 'offset', ...profile],
|
|
85
85
|
},
|
|
86
86
|
log: { positionals: ['gatewayId', 'logId'], flags: profile },
|
|
87
87
|
'key-access': {
|
|
88
88
|
positionals: ['gatewayId'],
|
|
89
|
-
flags: ['outcome', 'since', 'cursor', 'limit', 'offset', ...profile],
|
|
89
|
+
flags: ['outcome', 'since', 'until', 'cursor', 'limit', 'offset', ...profile],
|
|
90
90
|
},
|
|
91
91
|
'usage-logs': {
|
|
92
92
|
positionals: [],
|
|
93
|
-
flags: ['project', 'since', 'provider', 'model', 'status', 'gateway', 'cursor', 'limit', 'offset', ...profile],
|
|
93
|
+
flags: ['project', 'since', 'until', 'provider', 'model', 'status', 'gateway', 'cursor', 'limit', 'offset', ...profile],
|
|
94
94
|
requiredFlags: ['project'],
|
|
95
95
|
},
|
|
96
96
|
'usage-log': {
|
|
@@ -105,7 +105,7 @@ export const GATEWAY_SPECS = {
|
|
|
105
105
|
},
|
|
106
106
|
'usage-metrics': {
|
|
107
107
|
positionals: [],
|
|
108
|
-
flags: ['project', 'since', 'bucket', 'gateway', 'provider', 'model', 'status-class', 'search', ...profile],
|
|
108
|
+
flags: ['project', 'since', 'until', 'bucket', 'gateway', 'provider', 'model', 'status-class', 'search', ...profile],
|
|
109
109
|
requiredFlags: ['project'],
|
|
110
110
|
},
|
|
111
111
|
otel: {
|
|
@@ -386,6 +386,7 @@ export async function runGatewayCommand(argv, deps) {
|
|
|
386
386
|
case 'logs':
|
|
387
387
|
result = await client.listGatewayLogs(id, {
|
|
388
388
|
since: parsed.flags.since,
|
|
389
|
+
until: parsed.flags.until,
|
|
389
390
|
provider: parsed.flags.provider,
|
|
390
391
|
model: parsed.flags.model,
|
|
391
392
|
status: numberFlag(parsed.flags.status, true, 100, 599),
|
|
@@ -403,6 +404,7 @@ export async function runGatewayCommand(argv, deps) {
|
|
|
403
404
|
result = await client.listGatewayKeyAccess(id, {
|
|
404
405
|
outcome: enumFlag(parsed.flags.outcome, ['granted', 'denied', 'error']),
|
|
405
406
|
since: parsed.flags.since,
|
|
407
|
+
until: parsed.flags.until,
|
|
406
408
|
cursor: parsed.flags.cursor,
|
|
407
409
|
limit: numberFlag(parsed.flags.limit, true, 1, 200),
|
|
408
410
|
offset: numberFlag(parsed.flags.offset, true),
|
|
@@ -412,6 +414,7 @@ export async function runGatewayCommand(argv, deps) {
|
|
|
412
414
|
result = await client.listUsageLogs({
|
|
413
415
|
projectId: parsed.flags.project,
|
|
414
416
|
since: parsed.flags.since,
|
|
417
|
+
until: parsed.flags.until,
|
|
415
418
|
provider: parsed.flags.provider,
|
|
416
419
|
model: parsed.flags.model,
|
|
417
420
|
status: numberFlag(parsed.flags.status, true, 100, 599),
|
|
@@ -432,6 +435,7 @@ export async function runGatewayCommand(argv, deps) {
|
|
|
432
435
|
case 'usage-metrics':
|
|
433
436
|
result = await client.getUsageMetrics(parsed.flags.project, {
|
|
434
437
|
since: parsed.flags.since,
|
|
438
|
+
until: parsed.flags.until,
|
|
435
439
|
bucket: enumFlag(parsed.flags.bucket, ['hour', 'day']),
|
|
436
440
|
gatewayId: parsed.flags.gateway,
|
|
437
441
|
provider: parsed.flags.provider,
|
|
@@ -0,0 +1,185 @@
|
|
|
1
|
+
import { readFileSync } from 'node:fs';
|
|
2
|
+
import { parseArgv, ParseError } from './parser.js';
|
|
3
|
+
import { resolveClient, resolveHumanClient } from './resolve-client.js';
|
|
4
|
+
const profile = ['profile'];
|
|
5
|
+
export const MCP_GATEWAY_SPECS = {
|
|
6
|
+
list: { positionals: [], flags: ['project', ...profile], requiredFlags: ['project'] },
|
|
7
|
+
get: { positionals: ['gatewayId'], flags: profile },
|
|
8
|
+
catalog: { positionals: [], flags: profile },
|
|
9
|
+
create: { positionals: [], flags: ['project', 'name', 'slug', ...profile], requiredFlags: ['project', 'name'] },
|
|
10
|
+
update: { positionals: ['gatewayId'], flags: ['name', 'active', ...profile] },
|
|
11
|
+
runtime: { positionals: ['gatewayId'], flags: ['timeout-ms', 'max-result-bytes', 'max-concurrent', 'rate-limit-per-min', 'ip-allowlist', 'discovery-mode', ...profile] },
|
|
12
|
+
delete: { positionals: ['gatewayId'], flags: profile },
|
|
13
|
+
servers: { positionals: ['gatewayId'], flags: profile },
|
|
14
|
+
'server-create': { positionals: ['gatewayId'], flags: ['name', 'namespace', 'transport', 'endpoint', 'connector', 'auth', 'auth-secret-env', 'catalog', ...profile], requiredFlags: ['name', 'namespace', 'transport', 'auth'] },
|
|
15
|
+
'server-update': { positionals: ['gatewayId', 'serverId'], flags: ['name', 'endpoint', 'enabled', ...profile] },
|
|
16
|
+
'server-delete': { positionals: ['gatewayId', 'serverId'], flags: profile },
|
|
17
|
+
'server-sync': { positionals: ['gatewayId', 'serverId'], flags: profile },
|
|
18
|
+
'server-health': { positionals: ['gatewayId', 'serverId'], flags: profile },
|
|
19
|
+
tools: { positionals: ['gatewayId'], flags: profile },
|
|
20
|
+
clients: { positionals: ['gatewayId'], flags: profile },
|
|
21
|
+
'client-create': { positionals: ['gatewayId'], flags: ['name', 'type', ...profile], requiredFlags: ['name', 'type'] },
|
|
22
|
+
'client-update': { positionals: ['gatewayId', 'clientId'], flags: ['name', ...profile], requiredFlags: ['name'] },
|
|
23
|
+
'client-revoke': { positionals: ['gatewayId', 'clientId'], flags: profile },
|
|
24
|
+
keys: { positionals: ['gatewayId', 'clientId'], flags: profile },
|
|
25
|
+
'key-create': { positionals: ['gatewayId', 'clientId'], flags: ['scopes', 'servers', ...profile] },
|
|
26
|
+
'key-revoke': { positionals: ['gatewayId', 'clientId', 'keyId'], flags: profile },
|
|
27
|
+
policies: { positionals: ['gatewayId'], flags: profile },
|
|
28
|
+
'policy-create': { positionals: ['gatewayId'], flags: ['name', 'server', 'pattern', 'effect', 'access', 'priority', ...profile], requiredFlags: ['name', 'pattern', 'effect', 'access'] },
|
|
29
|
+
'policy-delete': { positionals: ['gatewayId', 'policyId'], flags: profile },
|
|
30
|
+
'policy-export': { positionals: ['gatewayId'], flags: profile },
|
|
31
|
+
'policy-apply': { positionals: ['gatewayId', 'file'], flags: ['prune', ...profile] },
|
|
32
|
+
calls: { positionals: ['gatewayId'], flags: ['since', 'until', 'server', 'tool', 'outcome', 'limit', ...profile] },
|
|
33
|
+
metrics: { positionals: ['gatewayId'], flags: profile },
|
|
34
|
+
payload: { positionals: ['gatewayId', 'callId'], flags: profile },
|
|
35
|
+
'calls-export': { positionals: ['gatewayId'], flags: ['since', 'until', 'server', 'tool', 'outcome', ...profile] },
|
|
36
|
+
grants: { positionals: ['gatewayId'], flags: profile },
|
|
37
|
+
'grant-create': { positionals: ['gatewayId'], flags: ['subject-type', 'subject-id', 'access', ...profile], requiredFlags: ['subject-type', 'subject-id', 'access'] },
|
|
38
|
+
'grant-revoke': { positionals: ['gatewayId', 'grantId'], flags: profile },
|
|
39
|
+
};
|
|
40
|
+
export const SERVICE_ACCOUNT_MCP_GATEWAY_COMMANDS = ['list', 'get', 'catalog', 'servers', 'server-health', 'tools', 'clients', 'keys', 'policies', 'calls', 'metrics', 'calls-export', 'grants'];
|
|
41
|
+
const READS = new Set(SERVICE_ACCOUNT_MCP_GATEWAY_COMMANDS);
|
|
42
|
+
export const MCP_GATEWAY_USAGE = `airctrl mcp-gateway commands
|
|
43
|
+
|
|
44
|
+
list --project <id> | get <gatewayId> | catalog | create --project <id> --name <name>
|
|
45
|
+
update|delete <gatewayId>
|
|
46
|
+
servers <gatewayId> | server-create|server-update|server-delete|server-sync|server-health …
|
|
47
|
+
tools <gatewayId> | clients|client-create|client-update|client-revoke|keys|key-create|key-revoke …
|
|
48
|
+
policies|policy-create|policy-delete|policy-export|policy-apply … | grants|grant-create|grant-revoke …
|
|
49
|
+
calls|metrics|payload|calls-export <gatewayId> …
|
|
50
|
+
`;
|
|
51
|
+
function csv(value) { return value?.split(',').map((item) => item.trim()).filter(Boolean); }
|
|
52
|
+
function bool(value) { if (value === undefined)
|
|
53
|
+
return false; if (value === 'true')
|
|
54
|
+
return true; if (value === 'false')
|
|
55
|
+
return false; throw new ParseError('cli_flag_invalid_value'); }
|
|
56
|
+
function integer(value) { if (value === undefined)
|
|
57
|
+
return undefined; const parsed = Number(value); if (!Number.isInteger(parsed) || parsed < 1)
|
|
58
|
+
throw new ParseError('cli_flag_invalid_value'); return parsed; }
|
|
59
|
+
function optionalLimit(value) { return value === 'none' ? null : integer(value); }
|
|
60
|
+
function apiKeyClientType(value) { if (value !== 'api_key')
|
|
61
|
+
throw new ParseError('cli_flag_invalid_value'); return value; }
|
|
62
|
+
function secretFromEnv(name, env) { if (!name)
|
|
63
|
+
return undefined; if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || !env[name])
|
|
64
|
+
throw new ParseError('cli_env_value_required'); return env[name]; }
|
|
65
|
+
function output(value, deps) { (deps.stdout ?? ((text) => process.stdout.write(text)))(`${typeof value === 'string' ? value : JSON.stringify(value ?? { ok: true }, null, 2)}\n`); }
|
|
66
|
+
function sdk(command, profileFlag, deps) {
|
|
67
|
+
return (READS.has(command) ? resolveClient : resolveHumanClient)({ ...deps.resolve, profileFlag }).client;
|
|
68
|
+
}
|
|
69
|
+
export async function runMcpGatewayCommand(argv, deps) {
|
|
70
|
+
const [command, ...rest] = argv;
|
|
71
|
+
if (!command || command === 'help' || command === '--help') {
|
|
72
|
+
output(MCP_GATEWAY_USAGE.trimEnd(), deps);
|
|
73
|
+
return 0;
|
|
74
|
+
}
|
|
75
|
+
if (!Object.hasOwn(MCP_GATEWAY_SPECS, command))
|
|
76
|
+
throw new ParseError('cli_unknown_command');
|
|
77
|
+
const parsed = parseArgv(rest, MCP_GATEWAY_SPECS[command]);
|
|
78
|
+
const api = sdk(command, parsed.flags.profile, deps).mcpGateways();
|
|
79
|
+
const [gatewayId, childId, thirdId] = parsed.positionals;
|
|
80
|
+
let result;
|
|
81
|
+
switch (command) {
|
|
82
|
+
case 'list':
|
|
83
|
+
result = await api.list(parsed.flags.project);
|
|
84
|
+
break;
|
|
85
|
+
case 'get':
|
|
86
|
+
result = await api.get(gatewayId);
|
|
87
|
+
break;
|
|
88
|
+
case 'catalog':
|
|
89
|
+
result = await api.catalog();
|
|
90
|
+
break;
|
|
91
|
+
case 'create':
|
|
92
|
+
result = await api.create({ projectId: parsed.flags.project, name: parsed.flags.name, slug: parsed.flags.slug });
|
|
93
|
+
break;
|
|
94
|
+
case 'update':
|
|
95
|
+
result = await api.update(gatewayId, { name: parsed.flags.name, isActive: parsed.flags.active === undefined ? undefined : bool(parsed.flags.active) });
|
|
96
|
+
break;
|
|
97
|
+
case 'runtime':
|
|
98
|
+
result = await api.updateRuntime(gatewayId, { requestTimeoutMs: integer(parsed.flags['timeout-ms']), maxResultBytes: integer(parsed.flags['max-result-bytes']), maxConcurrentCalls: integer(parsed.flags['max-concurrent']), rateLimitPerMin: optionalLimit(parsed.flags['rate-limit-per-min']), ipAllowlist: csv(parsed.flags['ip-allowlist']), toolDiscoveryMode: parsed.flags['discovery-mode'] });
|
|
99
|
+
break;
|
|
100
|
+
case 'delete':
|
|
101
|
+
result = await api.remove(gatewayId);
|
|
102
|
+
break;
|
|
103
|
+
case 'servers':
|
|
104
|
+
result = await api.listServers(gatewayId);
|
|
105
|
+
break;
|
|
106
|
+
case 'server-create':
|
|
107
|
+
result = await api.createServer(gatewayId, { name: parsed.flags.name, namespace: parsed.flags.namespace, transport: parsed.flags.transport, endpointUrl: parsed.flags.endpoint, connectorId: parsed.flags.connector, authMode: parsed.flags.auth, authSecret: secretFromEnv(parsed.flags['auth-secret-env'], deps.env ?? process.env), catalogSlug: parsed.flags.catalog });
|
|
108
|
+
break;
|
|
109
|
+
case 'server-update':
|
|
110
|
+
result = await api.updateServer(gatewayId, childId, { name: parsed.flags.name, endpointUrl: parsed.flags.endpoint, enabled: parsed.flags.enabled === undefined ? undefined : bool(parsed.flags.enabled) });
|
|
111
|
+
break;
|
|
112
|
+
case 'server-delete':
|
|
113
|
+
result = await api.removeServer(gatewayId, childId);
|
|
114
|
+
break;
|
|
115
|
+
case 'server-sync':
|
|
116
|
+
result = await api.syncServer(gatewayId, childId);
|
|
117
|
+
break;
|
|
118
|
+
case 'server-health':
|
|
119
|
+
result = await api.serverHealth(gatewayId, childId);
|
|
120
|
+
break;
|
|
121
|
+
case 'tools':
|
|
122
|
+
result = await api.listTools(gatewayId);
|
|
123
|
+
break;
|
|
124
|
+
case 'clients':
|
|
125
|
+
result = await api.listClients(gatewayId);
|
|
126
|
+
break;
|
|
127
|
+
case 'client-create':
|
|
128
|
+
result = await api.createClient(gatewayId, { name: parsed.flags.name, clientType: apiKeyClientType(parsed.flags.type) });
|
|
129
|
+
break;
|
|
130
|
+
case 'client-update':
|
|
131
|
+
result = await api.updateClient(gatewayId, childId, { name: parsed.flags.name });
|
|
132
|
+
break;
|
|
133
|
+
case 'client-revoke':
|
|
134
|
+
result = await api.revokeClient(gatewayId, childId);
|
|
135
|
+
break;
|
|
136
|
+
case 'keys':
|
|
137
|
+
result = await api.listKeys(gatewayId, childId);
|
|
138
|
+
break;
|
|
139
|
+
case 'key-create':
|
|
140
|
+
result = await api.createKey(gatewayId, childId, { scopes: csv(parsed.flags.scopes), serverIds: csv(parsed.flags.servers) });
|
|
141
|
+
break;
|
|
142
|
+
case 'key-revoke':
|
|
143
|
+
result = await api.revokeKey(gatewayId, childId, thirdId);
|
|
144
|
+
break;
|
|
145
|
+
case 'policies':
|
|
146
|
+
result = await api.listPolicies(gatewayId);
|
|
147
|
+
break;
|
|
148
|
+
case 'policy-create':
|
|
149
|
+
result = await api.createPolicy(gatewayId, { name: parsed.flags.name, serverId: parsed.flags.server, toolPattern: parsed.flags.pattern, effect: parsed.flags.effect, accessMode: parsed.flags.access, priority: integer(parsed.flags.priority) });
|
|
150
|
+
break;
|
|
151
|
+
case 'policy-delete':
|
|
152
|
+
result = await api.removePolicy(gatewayId, childId);
|
|
153
|
+
break;
|
|
154
|
+
case 'policy-export':
|
|
155
|
+
result = (await api.exportPolicy(gatewayId)).yaml;
|
|
156
|
+
break;
|
|
157
|
+
case 'policy-apply':
|
|
158
|
+
result = await api.importPolicy(gatewayId, { yaml: readFileSync(childId, 'utf8'), apply: true, prune: bool(parsed.flags.prune), confirmed: true });
|
|
159
|
+
break;
|
|
160
|
+
case 'calls':
|
|
161
|
+
result = await api.listCalls(gatewayId, { since: parsed.flags.since, until: parsed.flags.until, serverId: parsed.flags.server, tool: parsed.flags.tool, outcome: parsed.flags.outcome, limit: integer(parsed.flags.limit) });
|
|
162
|
+
break;
|
|
163
|
+
case 'metrics':
|
|
164
|
+
result = await api.callMetrics(gatewayId);
|
|
165
|
+
break;
|
|
166
|
+
case 'payload':
|
|
167
|
+
result = await api.callPayload(gatewayId, childId);
|
|
168
|
+
break;
|
|
169
|
+
case 'calls-export':
|
|
170
|
+
result = (await api.callsCsv(gatewayId, { since: parsed.flags.since, until: parsed.flags.until, serverId: parsed.flags.server, tool: parsed.flags.tool, outcome: parsed.flags.outcome })).csv;
|
|
171
|
+
break;
|
|
172
|
+
case 'grants':
|
|
173
|
+
result = await api.listGrants(gatewayId);
|
|
174
|
+
break;
|
|
175
|
+
case 'grant-create':
|
|
176
|
+
result = await api.createGrant(gatewayId, { subjectType: parsed.flags['subject-type'], subjectId: parsed.flags['subject-id'], accessMode: parsed.flags.access });
|
|
177
|
+
break;
|
|
178
|
+
case 'grant-revoke':
|
|
179
|
+
result = await api.revokeGrant(gatewayId, childId);
|
|
180
|
+
break;
|
|
181
|
+
default: throw new ParseError('cli_unknown_command');
|
|
182
|
+
}
|
|
183
|
+
output(result, deps);
|
|
184
|
+
return 0;
|
|
185
|
+
}
|
package/dist/sa-commands.js
CHANGED
|
@@ -13,7 +13,7 @@
|
|
|
13
13
|
* lease-holding paths, not to that fast path.
|
|
14
14
|
*/
|
|
15
15
|
import { homedir } from 'node:os';
|
|
16
|
-
import { generateSaClaimTicketPlaintext, BootstrapContext, createBootstrapClaimClient, createClient, prepareCapability, runCredentialLifecycle, isSaCoordinatorError, SaCoordinatorError, } from '@airctrl/sdk';
|
|
16
|
+
import { generateSaClaimTicketPlaintext, BootstrapContext, createBootstrapClaimClient, createClient, prepareCapability, AirctrlError, runCredentialLifecycle, isSaCoordinatorError, SaCoordinatorError, } from '@airctrl/sdk';
|
|
17
17
|
import { join } from 'node:path';
|
|
18
18
|
import { acquireHandoffLease, createProvisionalHandoff, createRotationArtifact, loadRotationArtifact, deleteRotationArtifact, createReceipt, loadReceipt, createProfile, loadProfile, replaceProfile, deleteProfileUnderLock, canonicalJson, acquireProfileLock, evidenceSecure, deleteEvidenceSecure, confirmDurableAbsence, assertBaseUrlMatch, assertRegularFile, assertHandoffChain, assertHandoffId, normalizeBaseUrl, handoffDir, handoffFile, StoreError, REAL_FS, } from './store/index.js';
|
|
19
19
|
import { resolveHumanClient, resolveClient, resolveHolderProfile } from './resolve-client.js';
|
|
@@ -198,12 +198,29 @@ function commitRotation(lease, ctx, meta, deps) {
|
|
|
198
198
|
}
|
|
199
199
|
/** Run the durable authorize HTTP under the lease, persist by mode, gate expiry, and return the output. */
|
|
200
200
|
async function authorizeAndPersist(lease, human, ctx, deps) {
|
|
201
|
-
const
|
|
201
|
+
const durableInput = {
|
|
202
202
|
accountId: ctx.accountId,
|
|
203
203
|
operationId: ctx.operationId,
|
|
204
204
|
bootstrapClaimTicketCandidate: ctx.claimTicket,
|
|
205
205
|
idempotencyKey: ctx.operationId, // stable per logical op → server dedup consistent across retries
|
|
206
|
-
}
|
|
206
|
+
};
|
|
207
|
+
let meta;
|
|
208
|
+
try {
|
|
209
|
+
meta = await human.client.saAuthorizeCredential(ctx.serviceAccountId, durableInput);
|
|
210
|
+
}
|
|
211
|
+
catch (error) {
|
|
212
|
+
// The server is the authoritative classifier for bootstrap vs rotation. A bootstrap must select at least
|
|
213
|
+
// one environment scope, while a rotation must inherit the active credential and therefore rejects an
|
|
214
|
+
// explicit selection. Retry the same durable operation exactly once with the least-privileged legacy
|
|
215
|
+
// scope only when the server proves this is a bootstrap. The first request fails before any DB write, and
|
|
216
|
+
// the stable operation/idempotency UUID keeps the retry crash-safe.
|
|
217
|
+
if (!(error instanceof AirctrlError) || error.message !== 'secret_access_scopes_required')
|
|
218
|
+
throw error;
|
|
219
|
+
meta = await human.client.saAuthorizeCredential(ctx.serviceAccountId, {
|
|
220
|
+
...durableInput,
|
|
221
|
+
secretAccessScopes: ['general'],
|
|
222
|
+
});
|
|
223
|
+
}
|
|
207
224
|
if (meta.mode === 'bootstrap')
|
|
208
225
|
finalizeBootstrap(lease, ctx, meta, deps);
|
|
209
226
|
else
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@airctrl/cli",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.6.0",
|
|
4
4
|
"type": "module",
|
|
5
5
|
"description": "AIRCTRL CLI for encrypted records, process injection, projects, gateways and Service Accounts.",
|
|
6
6
|
"license": "UNLICENSED",
|
|
@@ -39,6 +39,6 @@
|
|
|
39
39
|
"dev": "tsx src/index.ts"
|
|
40
40
|
},
|
|
41
41
|
"dependencies": {
|
|
42
|
-
"@airctrl/sdk": "0.
|
|
42
|
+
"@airctrl/sdk": "0.6.0"
|
|
43
43
|
}
|
|
44
44
|
}
|