aegiscode 7.0.10 → 7.0.12
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/bin/aegiscode.js +29 -0
- package/package.json +1 -1
- package/src/app.js +335 -24
- package/src/autonomous.js +19 -2
- package/src/chatflow.js +77 -4
- package/src/commands.js +175 -5
- package/src/config.js +21 -0
- package/src/connect.js +351 -0
- package/src/deps.js +97 -1
- package/src/engine.js +98 -8
- package/src/fingerprint.js +46 -16
- package/src/limits.js +1 -1
- package/src/overlays.js +54 -0
- package/src/provenance.lock.json +3 -3
- package/src/screens.js +14 -1
- package/vendor/client/credentials.js +9 -2
- package/vendor/client/google-signin.js +127 -0
- package/vendor/client/record-vault.js +431 -113
- package/vendor/client/update.js +266 -0
- package/vendor/desktop/lib/local/claude-pro.js +134 -11
- package/vendor/desktop/lib/local/engine.js +47 -25
- package/vendor/desktop/lib/settings.js +65 -24
package/vendor/client/update.js
CHANGED
|
@@ -158,6 +158,198 @@ function fetchLatest(opts = {}) {
|
|
|
158
158
|
return fetchLatestDetailed(opts).then((r) => (r.ok ? r.latest : null));
|
|
159
159
|
}
|
|
160
160
|
|
|
161
|
+
//: Where the AEGIS server answers "am I still allowed to talk to you".
|
|
162
|
+
const DEFAULT_API_BASE = 'https://aegiscloud.org';
|
|
163
|
+
/** /api/v1/version is a tiny JSON document; anything bigger is a proxy page. */
|
|
164
|
+
const VERSION_BODY_CAP = 64 * 1024;
|
|
165
|
+
|
|
166
|
+
/**
|
|
167
|
+
* Ask the SERVER whether this client is still serviceable.
|
|
168
|
+
*
|
|
169
|
+
* Why this exists next to the npm check: they answer different questions.
|
|
170
|
+
* The registry says what was *published*; the server says what it will
|
|
171
|
+
* *accept*. aegis1 refuses every request from a client below
|
|
172
|
+
* `MIN_CLIENT_VERSION` with a 426, so a client that only asks npm learns it is
|
|
173
|
+
* unservicable by being refused mid-task — an outage, not a notice. Asking
|
|
174
|
+
* `/api/v1/version` first turns the same fact into a sentence the user reads
|
|
175
|
+
* before they hit the wall.
|
|
176
|
+
*
|
|
177
|
+
* `/api/v1/version` is informational: it never refuses anyone, and it echoes
|
|
178
|
+
* the verdict for the version header we send (`upgrade_required`).
|
|
179
|
+
*
|
|
180
|
+
* Resolves `{ ok, minClient, latestCli, latestDesktop, upgradeRequired,
|
|
181
|
+
* downloadUrl, reason, status }` and never rejects — same contract as
|
|
182
|
+
* `fetchLatestDetailed`, so a host can render "registry unreachable" and
|
|
183
|
+
* "server unreachable" differently instead of inventing a third story.
|
|
184
|
+
*/
|
|
185
|
+
function fetchServerVersionDetailed({
|
|
186
|
+
base = DEFAULT_API_BASE,
|
|
187
|
+
clientVersion = null,
|
|
188
|
+
timeoutMs = TIMEOUT_MS,
|
|
189
|
+
getImpl = null,
|
|
190
|
+
} = {}) {
|
|
191
|
+
return new Promise((resolve) => {
|
|
192
|
+
let settled = false;
|
|
193
|
+
const done = (v) => {
|
|
194
|
+
if (!settled) {
|
|
195
|
+
settled = true;
|
|
196
|
+
resolve(v);
|
|
197
|
+
}
|
|
198
|
+
};
|
|
199
|
+
const fail = (reason, status = null) =>
|
|
200
|
+
done({
|
|
201
|
+
ok: false, minClient: null, latestCli: null, latestDesktop: null,
|
|
202
|
+
upgradeRequired: null, downloadUrl: '', reason, status,
|
|
203
|
+
});
|
|
204
|
+
const succeed = (body, status) => {
|
|
205
|
+
const minClient = body && typeof body.min_client === 'string' ? body.min_client : null;
|
|
206
|
+
// A 200 without `min_client` is malformed, not a slow network: do not
|
|
207
|
+
// invite a retry ladder for a document that will parse the same way.
|
|
208
|
+
if (!minClient) return fail(REASONS.MALFORMED, status);
|
|
209
|
+
done({
|
|
210
|
+
ok: true,
|
|
211
|
+
minClient,
|
|
212
|
+
latestCli: typeof body.latest_cli === 'string' ? body.latest_cli : '',
|
|
213
|
+
latestDesktop: typeof body.latest_desktop === 'string' ? body.latest_desktop : '',
|
|
214
|
+
// Trust the header echo only when we actually sent a version: without
|
|
215
|
+
// one the server answers for `require_header=False` and the answer is
|
|
216
|
+
// about nothing in particular. `null` here means "the server did not
|
|
217
|
+
// say", which is different from "the server said no" — the caller must
|
|
218
|
+
// be able to fall back without overriding an answer it was given.
|
|
219
|
+
upgradeRequired:
|
|
220
|
+
clientVersion && typeof body.upgrade_required === 'boolean'
|
|
221
|
+
? body.upgrade_required
|
|
222
|
+
: null,
|
|
223
|
+
downloadUrl: typeof body.download_url === 'string' ? body.download_url : '',
|
|
224
|
+
reason: null,
|
|
225
|
+
status,
|
|
226
|
+
});
|
|
227
|
+
};
|
|
228
|
+
|
|
229
|
+
try {
|
|
230
|
+
const url = `${String(base || DEFAULT_API_BASE).replace(/\/+$/, '')}/api/v1/version`;
|
|
231
|
+
const headers = { accept: 'application/json' };
|
|
232
|
+
if (clientVersion) headers['X-AEGIS-Version'] = String(clientVersion);
|
|
233
|
+
|
|
234
|
+
const onResponse = (res) => {
|
|
235
|
+
const status = res.statusCode;
|
|
236
|
+
if (status !== 200) {
|
|
237
|
+
res.resume();
|
|
238
|
+
if (status === 404) return fail(REASONS.NOT_FOUND, status);
|
|
239
|
+
if (status === 401 || status === 403) return fail(REASONS.FORBIDDEN, status);
|
|
240
|
+
// 426 here would mean the endpoint itself were gated; treat it as a
|
|
241
|
+
// real answer rather than a transport failure if it ever happens.
|
|
242
|
+
if (status === 426) return fail(REASONS.HTTP, status);
|
|
243
|
+
return fail(REASONS.HTTP, status);
|
|
244
|
+
}
|
|
245
|
+
let body = '';
|
|
246
|
+
res.setEncoding('utf8');
|
|
247
|
+
res.on('data', (c) => {
|
|
248
|
+
body += c;
|
|
249
|
+
if (body.length > VERSION_BODY_CAP) {
|
|
250
|
+
res.destroy();
|
|
251
|
+
fail(REASONS.TOO_LARGE, status);
|
|
252
|
+
}
|
|
253
|
+
});
|
|
254
|
+
res.on('end', () => {
|
|
255
|
+
if (settled) return;
|
|
256
|
+
try {
|
|
257
|
+
succeed(JSON.parse(body), status);
|
|
258
|
+
} catch {
|
|
259
|
+
fail(REASONS.MALFORMED, status);
|
|
260
|
+
}
|
|
261
|
+
});
|
|
262
|
+
};
|
|
263
|
+
|
|
264
|
+
if (typeof getImpl === 'function') {
|
|
265
|
+
// Injected transport for tests and hosts that already own a fetch:
|
|
266
|
+
// `getImpl({url, headers, timeoutMs})` resolves `{status, text}`.
|
|
267
|
+
Promise.resolve(getImpl({ url, headers, timeoutMs }))
|
|
268
|
+
.then((r) => {
|
|
269
|
+
const status = r && r.status != null ? r.status : 0;
|
|
270
|
+
if (!status) return fail(REASONS.NETWORK);
|
|
271
|
+
if (status !== 200) {
|
|
272
|
+
if (status === 404) return fail(REASONS.NOT_FOUND, status);
|
|
273
|
+
if (status === 401 || status === 403) return fail(REASONS.FORBIDDEN, status);
|
|
274
|
+
return fail(REASONS.HTTP, status);
|
|
275
|
+
}
|
|
276
|
+
const text = r && typeof r.text === 'string' ? r.text : '';
|
|
277
|
+
if (text.length > VERSION_BODY_CAP) return fail(REASONS.TOO_LARGE, status);
|
|
278
|
+
try {
|
|
279
|
+
succeed(JSON.parse(text), status);
|
|
280
|
+
} catch {
|
|
281
|
+
fail(REASONS.MALFORMED, status);
|
|
282
|
+
}
|
|
283
|
+
})
|
|
284
|
+
.catch(() => fail(REASONS.NETWORK));
|
|
285
|
+
return;
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
const req = require(/^http:\/\//i.test(url) ? 'node:http' : 'node:https')
|
|
289
|
+
.get(url, { headers, timeout: timeoutMs }, onResponse);
|
|
290
|
+
req.on('timeout', () => {
|
|
291
|
+
req.destroy();
|
|
292
|
+
fail(REASONS.TIMEOUT);
|
|
293
|
+
});
|
|
294
|
+
req.on('error', () => fail(REASONS.NETWORK));
|
|
295
|
+
} catch {
|
|
296
|
+
fail(REASONS.NETWORK);
|
|
297
|
+
}
|
|
298
|
+
});
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
/** The server's minimum client version, or null. */
|
|
302
|
+
function fetchServerVersion(opts = {}) {
|
|
303
|
+
return fetchServerVersionDetailed(opts).then((r) => (r.ok ? r.minClient : null));
|
|
304
|
+
}
|
|
305
|
+
|
|
306
|
+
/**
|
|
307
|
+
* The server's verdict, expressed in the shape the notice/plan code already
|
|
308
|
+
* speaks: `{ behind, latest, required, downloadUrl, ok, reason, status }`.
|
|
309
|
+
*
|
|
310
|
+
* `behind` is true when the SERVER says this client is below its minimum —
|
|
311
|
+
* regardless of whether npm happens to have something newer. That ordering is
|
|
312
|
+
* deliberate: being refused is actionable now, being merely superseded is not.
|
|
313
|
+
*/
|
|
314
|
+
async function serverUpdateVerdict({
|
|
315
|
+
current,
|
|
316
|
+
base = DEFAULT_API_BASE,
|
|
317
|
+
timeoutMs = TIMEOUT_MS,
|
|
318
|
+
getImpl = null,
|
|
319
|
+
} = {}) {
|
|
320
|
+
const res = await fetchServerVersionDetailed({ base, clientVersion: current, timeoutMs, getImpl });
|
|
321
|
+
if (!res.ok) {
|
|
322
|
+
return { ok: false, behind: false, latest: null, required: null, downloadUrl: '', reason: res.reason, status: res.status };
|
|
323
|
+
}
|
|
324
|
+
const required = res.minClient || null;
|
|
325
|
+
// The server's echo decides. Falling back to local arithmetic only when it
|
|
326
|
+
// said nothing (`null`) — OR'ing the two would let our own comparison
|
|
327
|
+
// override the very authority we asked, which is the bug this line exists to
|
|
328
|
+
// not have.
|
|
329
|
+
const behind =
|
|
330
|
+
res.upgradeRequired === true
|
|
331
|
+
? true
|
|
332
|
+
: res.upgradeRequired === false
|
|
333
|
+
? false
|
|
334
|
+
: required
|
|
335
|
+
? isNewer(required, current)
|
|
336
|
+
: false;
|
|
337
|
+
return {
|
|
338
|
+
ok: true,
|
|
339
|
+
behind,
|
|
340
|
+
// The server's own minimum is the target when it is the thing refusing us;
|
|
341
|
+
// a published version is preferred when it names one, because that is what
|
|
342
|
+
// the user should actually install.
|
|
343
|
+
latest: (behind && (res.latestCli || res.latestDesktop)) || required,
|
|
344
|
+
latestCli: res.latestCli,
|
|
345
|
+
latestDesktop: res.latestDesktop,
|
|
346
|
+
required,
|
|
347
|
+
downloadUrl: res.downloadUrl,
|
|
348
|
+
reason: null,
|
|
349
|
+
status: res.status,
|
|
350
|
+
};
|
|
351
|
+
}
|
|
352
|
+
|
|
161
353
|
/**
|
|
162
354
|
* The notice to show, from cache. Never waits on the network.
|
|
163
355
|
*
|
|
@@ -333,10 +525,83 @@ function updateLine({ current, latest, behind, pkg = PKG }) {
|
|
|
333
525
|
return `Update available: ${plan.current} → ${plan.latest} run: ${plan.instruction}`;
|
|
334
526
|
}
|
|
335
527
|
|
|
528
|
+
/**
|
|
529
|
+
* The server's verdict, from cache. Never waits on the network.
|
|
530
|
+
*
|
|
531
|
+
* Same contract and the same once-a-day rule as `updateNotice`, for the same
|
|
532
|
+
* reason: the welcome box draws from what the last run learned, and the
|
|
533
|
+
* refresh lands for the next one. A first run shows nothing, which is right —
|
|
534
|
+
* it has no verdict yet.
|
|
535
|
+
*
|
|
536
|
+
* Returns `{ behind, latest, required, downloadUrl }`. `behind` is the server's
|
|
537
|
+
* answer, not a comparison this module invented, so the box says "update" only
|
|
538
|
+
* when the server would actually refuse this client.
|
|
539
|
+
*/
|
|
540
|
+
function serverNotice({
|
|
541
|
+
current,
|
|
542
|
+
cache,
|
|
543
|
+
save,
|
|
544
|
+
now = Date.now(),
|
|
545
|
+
verdictImpl = serverUpdateVerdict,
|
|
546
|
+
intervalMs = CHECK_INTERVAL_MS,
|
|
547
|
+
} = {}) {
|
|
548
|
+
const c = cache || {};
|
|
549
|
+
const fresh = typeof c.checkedAt === 'number' && now - c.checkedAt < intervalMs;
|
|
550
|
+
|
|
551
|
+
if (!fresh) {
|
|
552
|
+
Promise.resolve()
|
|
553
|
+
.then(() => verdictImpl({ current }))
|
|
554
|
+
.then((v) => {
|
|
555
|
+
if (!v || typeof save !== 'function') return;
|
|
556
|
+
// Persist the verdict even when it is "not behind": that is what tells
|
|
557
|
+
// the next run it already asked today, and stops a check per launch.
|
|
558
|
+
save({
|
|
559
|
+
checkedAt: now,
|
|
560
|
+
behind: Boolean(v.behind),
|
|
561
|
+
required: v.required || null,
|
|
562
|
+
latest: v.latest || null,
|
|
563
|
+
downloadUrl: v.downloadUrl || '',
|
|
564
|
+
reason: v.reason || null,
|
|
565
|
+
});
|
|
566
|
+
})
|
|
567
|
+
.catch(() => {});
|
|
568
|
+
}
|
|
569
|
+
|
|
570
|
+
return {
|
|
571
|
+
behind: Boolean(c.behind),
|
|
572
|
+
latest: c.latest || null,
|
|
573
|
+
required: c.required || null,
|
|
574
|
+
downloadUrl: c.downloadUrl || '',
|
|
575
|
+
};
|
|
576
|
+
}
|
|
577
|
+
|
|
578
|
+
/**
|
|
579
|
+
* The line for the welcome box when the SERVER says this build is too old.
|
|
580
|
+
*
|
|
581
|
+
* Distinct from `updateLine` on purpose: "a newer release exists" and "the
|
|
582
|
+
* server will refuse you" are different urgency, and only the second one means
|
|
583
|
+
* the app is about to stop working. Says where to get it, because a user who
|
|
584
|
+
* is being cut off needs a destination, not a version number.
|
|
585
|
+
*/
|
|
586
|
+
function serverUpdateLine({ behind, latest, required, downloadUrl } = {}) {
|
|
587
|
+
if (!behind) return null;
|
|
588
|
+
const target = latest || required || '';
|
|
589
|
+
const head = target
|
|
590
|
+
? `This build is no longer served — update to v${target}.`
|
|
591
|
+
: 'This build is no longer served — update to the latest release.';
|
|
592
|
+
const where = downloadUrl ? ` ${downloadUrl}` : '';
|
|
593
|
+
return `${head}${where}`;
|
|
594
|
+
}
|
|
595
|
+
|
|
336
596
|
module.exports = {
|
|
337
597
|
isNewer,
|
|
338
598
|
fetchLatest,
|
|
339
599
|
fetchLatestDetailed,
|
|
600
|
+
fetchServerVersion,
|
|
601
|
+
fetchServerVersionDetailed,
|
|
602
|
+
serverUpdateVerdict,
|
|
603
|
+
serverNotice,
|
|
604
|
+
serverUpdateLine,
|
|
340
605
|
isTransientReason,
|
|
341
606
|
updateNotice,
|
|
342
607
|
checkPublished,
|
|
@@ -345,4 +610,5 @@ module.exports = {
|
|
|
345
610
|
PKG,
|
|
346
611
|
CHECK_INTERVAL_MS,
|
|
347
612
|
REASONS,
|
|
613
|
+
DEFAULT_API_BASE,
|
|
348
614
|
};
|
|
@@ -116,6 +116,23 @@ function claudeOAuthToken(env) {
|
|
|
116
116
|
*/
|
|
117
117
|
const SHADOWING_ENV_VARS = Object.freeze(['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN']);
|
|
118
118
|
|
|
119
|
+
/**
|
|
120
|
+
* Whether `value` is shaped like an Anthropic console API key.
|
|
121
|
+
*
|
|
122
|
+
* Deliberately a SHAPE test, not a validity test. This process cannot know
|
|
123
|
+
* whether a key is live without spending it, so it does not try: it answers
|
|
124
|
+
* only "could this possibly be the console credential that is allowed to
|
|
125
|
+
* outrank a subscription". Anthropic console keys are `sk-ant-`-prefixed. The
|
|
126
|
+
* check is case-sensitive and anchored, because that is the literal the vendor
|
|
127
|
+
* uses — a case-insensitive match would accept `SK-ANT-` junk.
|
|
128
|
+
*
|
|
129
|
+
* @param {string} value
|
|
130
|
+
* @returns {boolean}
|
|
131
|
+
*/
|
|
132
|
+
function isAnthropicConsoleKey(value) {
|
|
133
|
+
return typeof value === 'string' && /^sk-ant-[A-Za-z0-9_-]{8,}$/.test(value.trim());
|
|
134
|
+
}
|
|
135
|
+
|
|
119
136
|
/**
|
|
120
137
|
* The env for one `claude` child, with a shadowing value that cannot be a
|
|
121
138
|
* credential removed.
|
|
@@ -151,28 +168,69 @@ const SHADOWING_ENV_VARS = Object.freeze(['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_T
|
|
|
151
168
|
* value that provably cannot be a key is dropped, and the drop is REPORTED
|
|
152
169
|
* rather than silent (see `envDroppedLine`).
|
|
153
170
|
*
|
|
171
|
+
* ── the second rule: a length floor is not a shape (measured, 2026-10-21) ───
|
|
172
|
+
*
|
|
173
|
+
* The floor above answers "is this too short to be anything?" and nothing more.
|
|
174
|
+
* A 35-character value that is NOT an Anthropic console key clears it, still
|
|
175
|
+
* wins the CLI's precedence, and still takes the plan down — so the floor alone
|
|
176
|
+
* reproduced the original bug one paste later. Measured state that produced it:
|
|
177
|
+
*
|
|
178
|
+
* ~/.aegiscode/.env held ANTHROPIC_API_KEY=<35 chars, not sk-ant-*>
|
|
179
|
+
* ~/.claude/.credentials.json held a valid `claudeAiOauth` for plan `pro`
|
|
180
|
+
* `aegiscode -p "say hi" --json`
|
|
181
|
+
* → {"text":"Invalid API key · Fix external API key","model":"sonnet",
|
|
182
|
+
* "tokens":0,"balance_eur":1.54} exit 0, in 2.3 s
|
|
183
|
+
*
|
|
184
|
+
* and the child was spawned with the stale value present (`ANTHROPIC_LEN=35`,
|
|
185
|
+
* observed by a fake `claude` on PATH). Unsetting the variable in the SHELL did
|
|
186
|
+
* not help either: this host loads `~/.aegiscode/.env` into `process.env`
|
|
187
|
+
* itself, so the file is an input no caller can undo.
|
|
188
|
+
*
|
|
189
|
+
* So when a subscription IS present, only a value shaped like an Anthropic
|
|
190
|
+
* console key may shadow it. That is the narrowest rule that keeps the promise
|
|
191
|
+
* the old comment made — "a user who set one deliberately is asking for the
|
|
192
|
+
* pay-per-token path" — while refusing a value that provably is not one. With
|
|
193
|
+
* no subscription there is nothing to shadow and no opinion is taken: any value
|
|
194
|
+
* clearing the floor passes, exactly as before.
|
|
195
|
+
*
|
|
154
196
|
* @param {object} [baseEnv] the caller's env bag
|
|
155
197
|
* @param {string} [token] a `CLAUDE_CODE_OAUTH_TOKEN` to hand the child
|
|
156
|
-
* @
|
|
198
|
+
* @param {{hasSubscription?: boolean}} [opts] whether a subscription is present
|
|
199
|
+
* (see the second rule above); absent means "assume not", which keeps every
|
|
200
|
+
* pre-existing caller and test on the old behaviour.
|
|
201
|
+
* @returns {{env: object, dropped: Array<{name: string, length: number, reason: string}>}}
|
|
157
202
|
*/
|
|
158
|
-
function childEnvPlan(baseEnv, token) {
|
|
203
|
+
function childEnvPlan(baseEnv, token, opts) {
|
|
159
204
|
const env = { ...(baseEnv || {}) };
|
|
160
205
|
const dropped = [];
|
|
161
206
|
const usable = envFileLib && typeof envFileLib.credentialLooksUsable === 'function'
|
|
162
207
|
? envFileLib.credentialLooksUsable
|
|
163
208
|
: null;
|
|
209
|
+
// Only a present subscription can be shadowed, so it is the only case that
|
|
210
|
+
// earns the stricter shape rule (see the docstring's second section).
|
|
211
|
+
const hasSubscription = !!(opts && opts.hasSubscription);
|
|
164
212
|
// A host whose env module predates the floor keeps today's behaviour (the
|
|
165
213
|
// variable passes through): a second copy of the floor here is the drift
|
|
166
214
|
// client/env-file.js exists to prevent.
|
|
167
215
|
if (usable) {
|
|
168
216
|
for (const name of SHADOWING_ENV_VARS) {
|
|
169
217
|
const value = env[name];
|
|
170
|
-
if (typeof value !== 'string'
|
|
218
|
+
if (typeof value !== 'string') continue;
|
|
219
|
+
// Two independent reasons to refuse, and they are reported apart because
|
|
220
|
+
// they mean different things to the user: too short is junk, while a
|
|
221
|
+
// well-formed value that is not a console key is a key for something
|
|
222
|
+
// else that would silently outrank the plan they are paying for.
|
|
223
|
+
let reason = null;
|
|
224
|
+
if (!usable(value)) reason = 'too-short';
|
|
225
|
+
else if (hasSubscription && name === 'ANTHROPIC_API_KEY' && !isAnthropicConsoleKey(value)) {
|
|
226
|
+
reason = 'not-a-console-key';
|
|
227
|
+
}
|
|
228
|
+
if (!reason) continue;
|
|
171
229
|
delete env[name];
|
|
172
230
|
// A variable set to '' shadows nothing worth reporting — it is removed
|
|
173
231
|
// (harmless) but the user is not told about a value they never gave.
|
|
174
232
|
const length = value.trim().length;
|
|
175
|
-
if (length > 0) dropped.push({ name, length });
|
|
233
|
+
if (length > 0) dropped.push({ name, length, reason });
|
|
176
234
|
}
|
|
177
235
|
}
|
|
178
236
|
if (token) env.CLAUDE_CODE_OAUTH_TOKEN = token;
|
|
@@ -183,20 +241,51 @@ function childEnvPlan(baseEnv, token) {
|
|
|
183
241
|
function envDroppedLine(dropped) {
|
|
184
242
|
const list = Array.isArray(dropped) ? dropped : [];
|
|
185
243
|
if (!list.length) return null;
|
|
186
|
-
const
|
|
187
|
-
|
|
244
|
+
const shaped = list.filter((d) => d && d.reason === 'not-a-console-key');
|
|
245
|
+
const short = list.filter((d) => !d || d.reason !== 'not-a-console-key');
|
|
246
|
+
const parts = [];
|
|
247
|
+
if (short.length) {
|
|
248
|
+
const names = short.map((d) => `${d.name} (${d.length} character${d.length === 1 ? '' : 's'})`).join(', ');
|
|
249
|
+
parts.push(`${names}: too short to be a credential, and the CLI would have spent it instead of your subscription`);
|
|
250
|
+
}
|
|
251
|
+
if (shaped.length) {
|
|
252
|
+
const names = shaped.map((d) => `${d.name} (${d.length} characters)`).join(', ');
|
|
253
|
+
parts.push(
|
|
254
|
+
`${names}: not an Anthropic console key (\`sk-ant-\`), and the CLI would have spent it instead of your subscription`
|
|
255
|
+
);
|
|
256
|
+
}
|
|
257
|
+
return `aegis: not passed to the claude child — ${parts.join('; ')}`;
|
|
188
258
|
}
|
|
189
259
|
|
|
190
|
-
/**
|
|
191
|
-
|
|
260
|
+
/**
|
|
261
|
+
* The shadowing value in `env` that cannot be spent as the credential the CLI
|
|
262
|
+
* would take it for, if any (see the two rules in `childEnvPlan`).
|
|
263
|
+
*
|
|
264
|
+
* This must agree with `childEnvPlan` exactly: a status surface that says "no
|
|
265
|
+
* shadowing value" while the child is in fact being handed one is worse than no
|
|
266
|
+
* report at all. Both reasons are therefore reported, and each carries the same
|
|
267
|
+
* `reason` tag the drop report uses so the two lines cannot drift apart.
|
|
268
|
+
*
|
|
269
|
+
* @param {object} env
|
|
270
|
+
* @param {{hasSubscription?: boolean}} [opts]
|
|
271
|
+
* @returns {{name: string, length: number, reason: string}|null}
|
|
272
|
+
*/
|
|
273
|
+
function shadowingValue(env, opts) {
|
|
192
274
|
const bag = env || {};
|
|
193
275
|
const usable = envFileLib && typeof envFileLib.credentialLooksUsable === 'function'
|
|
194
276
|
? envFileLib.credentialLooksUsable
|
|
195
277
|
: null;
|
|
196
278
|
if (!usable) return null;
|
|
279
|
+
const hasSubscription = !!(opts && opts.hasSubscription);
|
|
197
280
|
for (const name of SHADOWING_ENV_VARS) {
|
|
198
281
|
const value = bag[name];
|
|
199
|
-
if (typeof value
|
|
282
|
+
if (typeof value !== 'string') continue;
|
|
283
|
+
let reason = null;
|
|
284
|
+
if (!usable(value)) reason = 'too-short';
|
|
285
|
+
else if (hasSubscription && name === 'ANTHROPIC_API_KEY' && !isAnthropicConsoleKey(value)) {
|
|
286
|
+
reason = 'not-a-console-key';
|
|
287
|
+
}
|
|
288
|
+
if (reason) return { name, length: value.trim().length, reason };
|
|
200
289
|
}
|
|
201
290
|
return null;
|
|
202
291
|
}
|
|
@@ -264,7 +353,30 @@ function claudeProStatus(opts) {
|
|
|
264
353
|
// child is fixed regardless (childEnvPlan); this reports it so a status
|
|
265
354
|
// surface can say why, rather than leaving `apiKeySource: ANTHROPIC_API_KEY`
|
|
266
355
|
// to be discovered from `claude auth status` by hand.
|
|
267
|
-
|
|
356
|
+
// A SUBSCRIPTION — the thing a stray `ANTHROPIC_API_KEY` would outrank — is an
|
|
357
|
+
// `oauth` plan or a `CLAUDE_CODE_OAUTH_TOKEN` handed to the child. A
|
|
358
|
+
// `credentials.json` holding a plain API key is not: there is no plan there to
|
|
359
|
+
// shadow, so the strict shape rule must not fire and drop the user's own key.
|
|
360
|
+
// This is computed once and published, so the report and the child env read
|
|
361
|
+
// ONE answer instead of each deciding for itself.
|
|
362
|
+
out.subscriptionPresent = out.loggedIn && out.kind !== 'apikey';
|
|
363
|
+
// The stricter rule only applies when a subscription is present, so the
|
|
364
|
+
// subscription this function just resolved is the same input the child env
|
|
365
|
+
// gets. Passing it here is what keeps `shadowed` and the drop report agreeing.
|
|
366
|
+
out.shadowed = shadowingValue(env, { hasSubscription: out.subscriptionPresent });
|
|
367
|
+
// "Can this host serve a `pro` turn at all?" is NOT the same question as
|
|
368
|
+
// "is there a subscription to shadow?" (above). A pin is phantom only when
|
|
369
|
+
// nothing usable survives to the child, and a bare API key in
|
|
370
|
+
// `credentials.json` (`kind: 'apikey'`) is a route with no plan behind it —
|
|
371
|
+
// so `subscriptionPresent` excludes it deliberately, while callability must
|
|
372
|
+
// count it. Answered by running the SAME planner the child env comes from, so
|
|
373
|
+
// this cannot disagree with what `claude` is actually handed: a variable the
|
|
374
|
+
// planner drops is not a credential, whatever it looks like in `env`.
|
|
375
|
+
const plan = childEnvPlan(env, null, { hasSubscription: out.subscriptionPresent });
|
|
376
|
+
out.credentialPresent = out.loggedIn
|
|
377
|
+
|| typeof plan.env.ANTHROPIC_API_KEY === 'string'
|
|
378
|
+
|| typeof plan.env.ANTHROPIC_AUTH_TOKEN === 'string'
|
|
379
|
+
|| typeof plan.env.CLAUDE_CODE_OAUTH_TOKEN === 'string';
|
|
268
380
|
return out;
|
|
269
381
|
}
|
|
270
382
|
|
|
@@ -633,7 +745,18 @@ function runClaudePro(opts, deps) {
|
|
|
633
745
|
// "API key: he" and the subscription is unreachable — see childEnvPlan.
|
|
634
746
|
const baseEnv = o.env || process.env;
|
|
635
747
|
const token = claudeOAuthToken(baseEnv);
|
|
636
|
-
|
|
748
|
+
// Whether a subscription is present decides whether a non-console
|
|
749
|
+
// `ANTHROPIC_API_KEY` may shadow it (childEnvPlan's second rule). It is read
|
|
750
|
+
// from the same credential file `claudeProStatus` reports on, and a failure
|
|
751
|
+
// to read it must NOT weaken the child's env: an unreadable file means "no
|
|
752
|
+
// subscription proven", which is the old behaviour, not a crash mid-turn.
|
|
753
|
+
let hasSubscription = false;
|
|
754
|
+
try {
|
|
755
|
+
hasSubscription = !!claudeProStatus({ env: baseEnv }).subscriptionPresent;
|
|
756
|
+
} catch {
|
|
757
|
+
/* unprovable subscription → the floor-only rule, exactly as before */
|
|
758
|
+
}
|
|
759
|
+
const plan = childEnvPlan(baseEnv, token, { hasSubscription });
|
|
637
760
|
const childEnv = plan.env;
|
|
638
761
|
const droppedLine = envDroppedLine(plan.dropped);
|
|
639
762
|
if (droppedLine && o.onDelta) {
|
|
@@ -524,27 +524,43 @@ const EFFORT_TOKEN_BUDGET = { low: 8192, medium: 16384, high: 32768 };
|
|
|
524
524
|
/**
|
|
525
525
|
* DeepSeek native reasoning level per config rung.
|
|
526
526
|
*
|
|
527
|
-
* The field is `
|
|
528
|
-
*
|
|
529
|
-
* `
|
|
530
|
-
*
|
|
531
|
-
* `reasoning_effort:"none"` produced 0 reasoning_content chars and `"max"`
|
|
532
|
-
* produced 138, whereas `effort:"none"` still produced 112 — thinking stayed
|
|
533
|
-
* on. So the old field was inert on every turn, and inertness is the worst
|
|
534
|
-
* failure here: it 200s, nothing surfaces, and the model merely thinks at the
|
|
535
|
-
* wrong depth.
|
|
527
|
+
* The field is `effort`, NOT `reasoning_effort`. Verified live 2026-10-21
|
|
528
|
+
* against the surface this client actually reaches — the relay's
|
|
529
|
+
* `https://api.deepseek.com/anthropic` transport — by measuring output tokens
|
|
530
|
+
* over interleaved paired samples (n=12) against an absent-field baseline:
|
|
536
531
|
*
|
|
537
|
-
*
|
|
538
|
-
* than the earlier (low|max, no medium) fold, which rested on the mistaken
|
|
539
|
-
* belief that DeepSeek had no `medium`. `max_tokens` (EFFORT_TOKEN_BUDGET)
|
|
540
|
-
* still scales as the output ceiling, since hidden chain-of-thought shares that
|
|
541
|
-
* budget on DeepSeek.
|
|
532
|
+
* absent 818 · low 772 · medium 836 · high 818 · max 1494
|
|
542
533
|
*
|
|
543
|
-
*
|
|
544
|
-
*
|
|
545
|
-
*
|
|
534
|
+
* Only `max` separates from sending nothing. `GET /models` reports
|
|
535
|
+
* `supported_levels: ["low","high","max"]`, default `high`, on both live ids
|
|
536
|
+
* (`deepseek-flash`, `deepseek-v4-pro`) — so `medium` is not a level these
|
|
537
|
+
* models have. It passes the deserializer (unknown values *do* 422 with the
|
|
538
|
+
* enum, so validation is real) and is then absorbed into the default, which is
|
|
539
|
+
* this codebase's worst failure mode: a 200, nothing surfaced, and the model
|
|
540
|
+
* thinking at a depth nobody chose.
|
|
541
|
+
*
|
|
542
|
+
* What the earlier version of this comment asserted — that `reasoning_effort`
|
|
543
|
+
* binds and `effort` is ignored — was measured on the vendor's OpenAI-shaped
|
|
544
|
+
* `/chat/completions`, a surface this client never reaches, and it led to the
|
|
545
|
+
* knob being dead end-to-end: aegis1 forwards `reasoning_effort` only for
|
|
546
|
+
* BYOK_REASONING_EFFORT_PROVIDERS (openai/groq/gemini/grok — deepseek is
|
|
547
|
+
* absent), so the field was dropped at the relay. The `effort` channel is the
|
|
548
|
+
* one aegis1 gates on `provider_id == "deepseek"` (app.py) and that the
|
|
549
|
+
* Anthropic adapter nests as `output_config.effort`; it is the only channel
|
|
550
|
+
* that reaches the vendor, and the only one that measurably binds.
|
|
551
|
+
*
|
|
552
|
+
* The map folds `medium` upward for the same reason the Gemini row does: the
|
|
553
|
+
* vendor has no such level, and a rung that 200s while doing nothing is worse
|
|
554
|
+
* than one that says what it does. `max` is deliberately NOT reachable — it is
|
|
555
|
+
* not a rung of this knob, and mapping the default rung onto it would silently
|
|
556
|
+
* multiply reasoning spend on every turn nobody asked to deepen.
|
|
557
|
+
* `max_tokens` (EFFORT_TOKEN_BUDGET) still scales as the output ceiling, since
|
|
558
|
+
* hidden chain-of-thought shares that budget on DeepSeek.
|
|
559
|
+
*
|
|
560
|
+
* desktop/renderer/budget.js carries the renderer's copy; test/budget.test.mjs
|
|
561
|
+
* compares the two tables, so the mirror cannot drift silently.
|
|
546
562
|
*/
|
|
547
|
-
const DEEPSEEK_EFFORT = { low: 'low', medium: '
|
|
563
|
+
const DEEPSEEK_EFFORT = { low: 'low', medium: 'high', high: 'high' };
|
|
548
564
|
|
|
549
565
|
/**
|
|
550
566
|
* Per-family effort translation, mirroring the upstream engine's
|
|
@@ -565,7 +581,7 @@ const DEEPSEEK_EFFORT = { low: 'low', medium: 'medium', high: 'high' };
|
|
|
565
581
|
const EFFORT_IDENTITY = { low: 'low', medium: 'medium', high: 'high' };
|
|
566
582
|
const EFFORT_INERT_RE = /non-reasoning/i;
|
|
567
583
|
const EFFORT_DIALECTS = [
|
|
568
|
-
{ provider: 'deepseek', re: DEEPSEEK_REASONING_MODEL_RE, field: '
|
|
584
|
+
{ provider: 'deepseek', re: DEEPSEEK_REASONING_MODEL_RE, field: 'effort', map: DEEPSEEK_EFFORT },
|
|
569
585
|
{ provider: 'openai', re: /^(gpt-5|o[0-9])/i, field: 'reasoning_effort', map: EFFORT_IDENTITY },
|
|
570
586
|
{ provider: 'groq', re: /^(openai\/gpt-oss|qwen\/qwen3)/i, field: 'reasoning_effort', map: EFFORT_IDENTITY },
|
|
571
587
|
{ provider: 'xai', re: /^grok-(4\.[5-9]|[5-9])/, field: 'reasoning_effort', map: EFFORT_IDENTITY },
|
|
@@ -1967,8 +1983,8 @@ function createLocalEngine({
|
|
|
1967
1983
|
const { provider, model: bareModel } = splitByokModel(opts.model);
|
|
1968
1984
|
// Translate the rung for THIS vendor once, and carry the verdict rather
|
|
1969
1985
|
// than a bare level: the relay validates strictly upstream and the field
|
|
1970
|
-
// name is not portable (DeepSeek's
|
|
1971
|
-
//
|
|
1986
|
+
// name is not portable (DeepSeek's `/anthropic` transport takes `effort`,
|
|
1987
|
+
// OpenAI-shaped vendors take `reasoning_effort`). Undefined for a family
|
|
1972
1988
|
// with no dialect, which the transport then omits entirely.
|
|
1973
1989
|
const effort = nativeEffort(provider, bareModel, opts.effort);
|
|
1974
1990
|
try {
|
|
@@ -1999,10 +2015,16 @@ function createLocalEngine({
|
|
|
1999
2015
|
toolChoice: opts.toolChoice,
|
|
2000
2016
|
// Native effort knob, field and level both from the dialect table.
|
|
2001
2017
|
// `bareModel` is already provider-less, so it matches the dialect
|
|
2002
|
-
// regexes without further stripping.
|
|
2003
|
-
//
|
|
2004
|
-
// `
|
|
2005
|
-
//
|
|
2018
|
+
// regexes without further stripping. Both wire channels are live, and
|
|
2019
|
+
// which one is used is the dialect's decision, not this call site's:
|
|
2020
|
+
// DeepSeek's `/anthropic` transport takes `effort` (aegis1 gates it on
|
|
2021
|
+
// provider_id == "deepseek" and the adapter nests it as
|
|
2022
|
+
// `output_config.effort`), while the OpenAI-shaped vendors take
|
|
2023
|
+
// `reasoning_effort`. Routing on the field name is what keeps a
|
|
2024
|
+
// dialect from being silently dropped here — the previous form
|
|
2025
|
+
// forwarded only `reasoning_effort`, so turning DeepSeek's dialect
|
|
2026
|
+
// over to `effort` would have died at this line.
|
|
2027
|
+
effort: effort && effort.field === 'effort' ? effort.level : undefined,
|
|
2006
2028
|
reasoningEffort: effort && effort.field === 'reasoning_effort' ? effort.level : undefined,
|
|
2007
2029
|
stream: true,
|
|
2008
2030
|
onStream: opts.onDelta,
|