aegiscode 7.0.11 → 7.0.13

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.
@@ -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
  *
@@ -207,19 +399,21 @@ function updateNotice({
207
399
  *
208
400
  * @param {{current: string, latest: ?string, behind: boolean, channel?: 'npm'|'desktop', pkg?: string}} input
209
401
  */
210
- function updatePlan({ current, latest, behind, channel = 'npm', pkg = PKG } = {}) {
402
+ function updatePlan({ current, latest, behind, channel = 'npm', pkg = PKG, method = 'npm' } = {}) {
211
403
  const currentText = String(current == null ? '' : current);
212
404
  const latestText = latest ? String(latest) : null;
213
405
  const pending = Boolean(behind) && Boolean(latestText);
214
406
  if (!pending) {
215
407
  return {
216
408
  channel,
409
+ method,
217
410
  current: currentText,
218
411
  latest: latestText,
219
412
  behind: false,
220
413
  action: 'none',
221
414
  applier: 'none',
222
415
  instruction: null,
416
+ apply: null,
223
417
  };
224
418
  }
225
419
  if (channel === 'desktop') {
@@ -228,25 +422,101 @@ function updatePlan({ current, latest, behind, channel = 'npm', pkg = PKG } = {}
228
422
  // beside the running app. The applier is the app's own updater.
229
423
  return {
230
424
  channel,
425
+ method,
231
426
  current: currentText,
232
427
  latest: latestText,
233
428
  behind: true,
234
429
  action: 'desktop-update',
235
430
  applier: 'electron-updater',
236
431
  instruction: 'Aegis Desktop → Check for Updates…',
432
+ apply: null,
237
433
  };
238
434
  }
435
+
436
+ // Which installer owns this copy. The command is not cosmetic: `npm i -g`
437
+ // against a pip-installed `aegiscode` writes a second copy beside the one the
438
+ // user actually runs, and the "upgrade" appears to do nothing. Same for an
439
+ // `npx` run, which has nothing installed to upgrade at all.
440
+ const applier = APPLIERS[method] || APPLIERS.npm;
239
441
  return {
240
442
  channel,
443
+ method,
241
444
  current: currentText,
242
445
  latest: latestText,
243
446
  behind: true,
244
- action: 'npm-update',
245
- applier: 'npm',
246
- instruction: `npm i -g ${pkg}@latest`,
447
+ action: applier.action,
448
+ applier: applier.name,
449
+ instruction: applier.instruction(pkg),
450
+ apply: applier.apply ? applier.apply(pkg) : null,
247
451
  };
248
452
  }
249
453
 
454
+ /**
455
+ * The ways this product reaches a machine, and what "update it" means for each.
456
+ *
457
+ * `apply` names argv to run — it is what the window's Update button and the
458
+ * CLI's `/upgrade apply` execute. `null` means there is nothing to install:
459
+ * `npx` fetches `latest` on every launch by definition, and a source checkout
460
+ * belongs to its owner's git remote.
461
+ */
462
+ const APPLIERS = Object.freeze({
463
+ npm: Object.freeze({
464
+ name: 'npm',
465
+ action: 'npm-update',
466
+ instruction: (pkg) => `npm i -g ${pkg}@latest`,
467
+ apply: (pkg) => ({ command: 'npm', args: ['i', '-g', `${pkg}@latest`] }),
468
+ }),
469
+ pip: Object.freeze({
470
+ name: 'pip',
471
+ action: 'pip-update',
472
+ // The published pip package is a launcher for the npm one, so this is
473
+ // genuinely a different command — not an npm call with a different word.
474
+ instruction: (pkg) => `pip install -U ${pkg}`,
475
+ apply: (pkg) => ({ command: process.platform === 'win32' ? 'python' : 'python3',
476
+ args: ['-m', 'pip', 'install', '-U', pkg] }),
477
+ }),
478
+ npx: Object.freeze({
479
+ name: 'none',
480
+ action: 'npx-update',
481
+ instruction: () => 'already fetched fresh on every run — restart to pick up the new version',
482
+ apply: null,
483
+ }),
484
+ source: Object.freeze({
485
+ name: 'git',
486
+ action: 'source-update',
487
+ instruction: () => 'git pull && npm ci (this copy is a source checkout)',
488
+ apply: null,
489
+ }),
490
+ });
491
+
492
+ /**
493
+ * Which installer owns the copy that is running — so the sentence names a
494
+ * command that actually changes THIS binary.
495
+ *
496
+ * Order matters. An explicit declaration wins (the pip launcher sets
497
+ * `AEGIS_INSTALL_METHOD=pip` before exec'ing the real CLI, which is the only
498
+ * way the npm package can know a Python install is driving it). Then npx, which
499
+ * is detectable from the argv it builds. Then a source checkout, then npm.
500
+ *
501
+ * Pure and injectable: `env`, `argv` and a file probe, no `process` reads, so a
502
+ * test can assert every branch without npm or pip being installed.
503
+ */
504
+ function detectInstallMethod({
505
+ env = {}, argv = [], pkg = PKG, fileExists = () => false, entry = '',
506
+ } = {}) {
507
+ const declared = String((env && env.AEGIS_INSTALL_METHOD) || '').trim().toLowerCase();
508
+ if (declared && Object.prototype.hasOwnProperty.call(APPLIERS, declared)) return declared;
509
+
510
+ const joined = argv.map((a) => String(a)).join(' ');
511
+ if (/\bnpx\b/.test(joined) || /_npx[\\/]/.test(joined) || /_npx[\\/]/.test(entry)) return 'npx';
512
+ if (/[\\/]pipx[\\/]venvs[\\/]/.test(entry) || /[\\/]site-packages[\\/]/.test(entry)) return 'pip';
513
+ if (/[\\/]node_modules[\\/]/.test(entry)) return 'npm';
514
+ // A git checkout has the repo's own marker files; a global npm install does
515
+ // not (they are not in the package's `files` list).
516
+ if (fileExists('.git') && fileExists('client/update.js')) return 'source';
517
+ return 'npm';
518
+ }
519
+
250
520
  /**
251
521
  * The same once-a-day check as `updateNotice`, but *awaited* and detailed.
252
522
  *
@@ -326,23 +596,111 @@ async function checkPublished({
326
596
  * Rendered from `updatePlan`, not from a second copy of the sentence: the
327
597
  * command the terminal tells the user to run and the command the window's
328
598
  * banner offers are the same string produced by the same verdict.
599
+ *
600
+ * `method` is the install channel the caller detected (see
601
+ * `detectInstallMethod`). It is threaded through rather than assumed to be npm
602
+ * because the previous version returned `null` — silence — for every channel
603
+ * that was not npm, so a pip install and an npx run were never told a release
604
+ * existed. A host that knows how it was installed should say so.
605
+ */
606
+ function updateLine({ current, latest, behind, pkg = PKG, method = 'npm' }) {
607
+ const plan = updatePlan({ current, latest, behind, channel: 'npm', pkg, method });
608
+ if (!plan.behind) return null;
609
+ const head = `Update available: ${plan.current} → ${plan.latest}`;
610
+ // `apply` is null for the two channels with nothing to install, whose
611
+ // instruction is already a sentence — prefixing those with "run:" would read
612
+ // as a command that does not exist.
613
+ return plan.apply
614
+ ? `${head} run: ${plan.instruction}`
615
+ : `${head} ${plan.instruction}`;
616
+ }
617
+
618
+ /**
619
+ * The server's verdict, from cache. Never waits on the network.
620
+ *
621
+ * Same contract and the same once-a-day rule as `updateNotice`, for the same
622
+ * reason: the welcome box draws from what the last run learned, and the
623
+ * refresh lands for the next one. A first run shows nothing, which is right —
624
+ * it has no verdict yet.
625
+ *
626
+ * Returns `{ behind, latest, required, downloadUrl }`. `behind` is the server's
627
+ * answer, not a comparison this module invented, so the box says "update" only
628
+ * when the server would actually refuse this client.
629
+ */
630
+ function serverNotice({
631
+ current,
632
+ cache,
633
+ save,
634
+ now = Date.now(),
635
+ verdictImpl = serverUpdateVerdict,
636
+ intervalMs = CHECK_INTERVAL_MS,
637
+ } = {}) {
638
+ const c = cache || {};
639
+ const fresh = typeof c.checkedAt === 'number' && now - c.checkedAt < intervalMs;
640
+
641
+ if (!fresh) {
642
+ Promise.resolve()
643
+ .then(() => verdictImpl({ current }))
644
+ .then((v) => {
645
+ if (!v || typeof save !== 'function') return;
646
+ // Persist the verdict even when it is "not behind": that is what tells
647
+ // the next run it already asked today, and stops a check per launch.
648
+ save({
649
+ checkedAt: now,
650
+ behind: Boolean(v.behind),
651
+ required: v.required || null,
652
+ latest: v.latest || null,
653
+ downloadUrl: v.downloadUrl || '',
654
+ reason: v.reason || null,
655
+ });
656
+ })
657
+ .catch(() => {});
658
+ }
659
+
660
+ return {
661
+ behind: Boolean(c.behind),
662
+ latest: c.latest || null,
663
+ required: c.required || null,
664
+ downloadUrl: c.downloadUrl || '',
665
+ };
666
+ }
667
+
668
+ /**
669
+ * The line for the welcome box when the SERVER says this build is too old.
670
+ *
671
+ * Distinct from `updateLine` on purpose: "a newer release exists" and "the
672
+ * server will refuse you" are different urgency, and only the second one means
673
+ * the app is about to stop working. Says where to get it, because a user who
674
+ * is being cut off needs a destination, not a version number.
329
675
  */
330
- function updateLine({ current, latest, behind, pkg = PKG }) {
331
- const plan = updatePlan({ current, latest, behind, channel: 'npm', pkg });
332
- if (plan.action !== 'npm-update') return null;
333
- return `Update available: ${plan.current} → ${plan.latest} run: ${plan.instruction}`;
676
+ function serverUpdateLine({ behind, latest, required, downloadUrl } = {}) {
677
+ if (!behind) return null;
678
+ const target = latest || required || '';
679
+ const head = target
680
+ ? `This build is no longer served — update to v${target}.`
681
+ : 'This build is no longer served — update to the latest release.';
682
+ const where = downloadUrl ? ` ${downloadUrl}` : '';
683
+ return `${head}${where}`;
334
684
  }
335
685
 
336
686
  module.exports = {
337
687
  isNewer,
338
688
  fetchLatest,
339
689
  fetchLatestDetailed,
690
+ fetchServerVersion,
691
+ fetchServerVersionDetailed,
692
+ serverUpdateVerdict,
693
+ serverNotice,
694
+ serverUpdateLine,
340
695
  isTransientReason,
341
696
  updateNotice,
342
697
  checkPublished,
343
698
  updatePlan,
344
699
  updateLine,
700
+ detectInstallMethod,
701
+ APPLIERS,
345
702
  PKG,
346
703
  CHECK_INTERVAL_MS,
347
704
  REASONS,
705
+ DEFAULT_API_BASE,
348
706
  };
@@ -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
- * @returns {{env: object, dropped: Array<{name: string, length: number}>}}
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' || usable(value)) continue;
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 names = list.map((d) => `${d.name} (${d.length} character${d.length === 1 ? '' : 's'})`).join(', ');
187
- return `aegis: not passed to the claude child — ${names}: too short to be a credential, and the CLI would have spent it instead of your subscription`;
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
- /** The shadowing value in `env` that cannot be a credential, if any (see above). */
191
- function shadowingValue(env) {
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 === 'string' && !usable(value)) return { name, length: value.trim().length };
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
- out.shadowed = shadowingValue(env);
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
- const plan = childEnvPlan(baseEnv, token);
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) {