@cspeach/cli 1.1.32 → 1.1.34

package/dist/agent/risk-gate.js

@@ -0,0 +1,202 @@
+/**
+ * Security batch item 4 — a risk gate of its own, in tool-dispatch.ts. Plan
+ * approval, batch approval and auto-approve never skip it: it does not read
+ * any of them. Headless runs (one-shot, CI) decline, and say so (via
+ * presentSafetyConfirmation).
+ *
+ * Ruling F16: network tools (curl, wget, Invoke-WebRequest, nc …) get the card
+ * whether or not they are on the shell allow-list. The gate runs before the
+ * tool's own allow-list check, so a network tool a user has added asks first,
+ * and one that is not on the list asks first and is then refused by the tool.
+ *
+ * Fix round 1: background_run is gated like shell_exec (F1); npm/pnpm
+ * run-anything subcommands and npx are flagged as wrappers (F3); node's
+ * `--import data:` (F4) and git's command-running subcommands (F5) are
+ * flagged; git is left out of the deploy/publish word rule (F6); node's
+ * options end at the script (F7). grep and glob skip credential files
+ * instead of asking (F2) — stricter than a card, a deliberate choice.
+ *
+ * Fix round 2: the npm/pnpm subcommand is found cautiously, past any word
+ * that could be an option's value (N1); git's long-option prefixes and short
+ * bundles (`--exe`, `-ix`) are read (N2); a git subcommand named deploy or
+ * publish is flagged again (L1).
+ *
+ * Honest limit: these are argv rules. `npm run <script>`, `npx` and
+ * `node <file>` running model-written code can get past them. Site copy says
+ * "known risky patterns".
+ */
+import path from 'node:path';
+import { BLOCKED_BASENAME_RE } from '../tools/_filesystem-shared.js';
+const NETWORK_TOOLS = new Set(['curl', 'wget', 'invoke-webrequest', 'iwr', 'nc', 'ncat', 'netcat']);
+const NODE_EVAL_FLAGS = new Set(['-e', '--eval', '-p', '--print']);
+/** git global options that take a separate value (skipped when finding the subcommand). */
+const GIT_VALUE_OPTIONS = new Set(['-C', '--git-dir', '--work-tree', '--namespace']);
+/** npm / pnpm subcommands that run any program, or download and run a package (F3). */
+const RUN_ANY_SUBCOMMANDS = new Set(['exec', 'x', 'dlx', 'explore']);
+const CREDENTIAL_BASENAMES = new Set(['.git-credentials', '.npmrc']);
+const CREDENTIAL_EXTS = new Set(['.pem', '.key']);
+export const FILE_READ_TOOLS = new Set(['file_read', 'read_document']);
+/**
+ * The bare program name, as Windows would resolve it: surrounding whitespace
+ * and quotes dropped, any folder dropped (either slash), lower-cased, and a
+ * Windows program extension dropped. Display uses the command as given.
+ */
+const commandName = (cmd) => path.basename(cmd.trim().replace(/^["']+|["']+$/g, '').trim().replace(/\\/g, '/'))
+    .toLowerCase()
+    .replace(/\.(exe|cmd|bat|ps1)$/, '');
+/** Show an arg with whitespace (or an empty arg) quoted, so the card reads as the argv it is (fix round 1, F9). Never redacted. */
+const showArg = (a) => (a.length === 0 || /\s/.test(a) ? JSON.stringify(a) : a);
+/**
+ * node runs inline code: `-e`/`--eval`/`-p`/`--print` (any spelling), or an
+ * `--import`/`--loader`/`--experimental-loader` whose value is a `data:` URL.
+ * Only node's own options count: scanning stops at `--` and at the script
+ * (the first positional that cannot be the value of the option before it),
+ * so the script's own args (`node build.js -prod`) are not read (F7, F4).
+ */
+function nodeRunsInlineCode(args) {
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--')
+            return false;
+        if (!a.startsWith('-') || a === '-') {
+            const prev = i > 0 ? args[i - 1] : undefined;
+            // The script — unless it may be the value of a dash option before it.
+            if (prev === undefined || !prev.startsWith('-') || prev.includes('='))
+                return false;
+            continue;
+        }
+        if (NODE_EVAL_FLAGS.has(a) || /^--(eval|print)=/.test(a) || /^-[a-z]*[ep][a-z]*$/i.test(a))
+            return true;
+        const m = /^--(import|loader|experimental-loader)(?:=(.*))?$/.exec(a);
+        if (m) {
+            const v = m[2] ?? args[i + 1];
+            if (typeof v === 'string' && /^\s*data:/i.test(v))
+                return true;
+        }
+    }
+    return false;
+}
+/** git subcommands (after the global options) that run a command string (F5). */
+function gitRunsCommand(sub, rest) {
+    switch (sub) {
+        // Fix round 2 (N2): git takes any unambiguous prefix of a long option
+        // (`--ex`, `--exe`) and bundled short options (`-ix`). A lowercase x in a
+        // short bundle is --exec; capital -X is the merge-strategy option.
+        case 'rebase':
+            return rest.some((a) => /^-[a-z]*x/.test(a) || /^--ex(e(c)?)?(=|$)/.test(a));
+        case 'bisect':
+            return rest[0] === 'run';
+        case 'submodule':
+            return rest.includes('foreach');
+        case 'filter-branch':
+            return true;
+        case 'difftool':
+        case 'mergetool':
+            // difftool has no other long option starting with `e`, so `--e` is enough.
+            return rest.some((a) => /^-[a-z]*x/.test(a) || /^--e(x(t(c(m(d)?)?)?)?)?(=|$)/.test(a));
+        default:
+            return false;
+    }
+}
+/**
+ * Fix round 2 (N1) — npm / pnpm's subcommand, read cautiously. Any option
+ * that is not a boolean takes the next word as its value (`--loglevel
+ * silent`, `--cache c`, `--reporter silent` …), and no hand-kept list can
+ * name them all. So every positional that could be the value of the dash
+ * option before it is a candidate, and the walk stops at the first positional
+ * that cannot be a value: the definite subcommand. Returns every candidate up
+ * to and including it (and the word after `--`). Extra card, never a miss:
+ * a value literally named `exec`/`x`/`dlx`/`explore` is flagged too.
+ */
+function packageManagerSubcommands(args) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--') {
+            if (args[i + 1] !== undefined)
+                out.push(args[i + 1]);
+            break;
+        }
+        if (a.startsWith('-'))
+            continue;
+        out.push(a);
+        const prev = i > 0 ? args[i - 1] : undefined;
+        if (prev === undefined || !prev.startsWith('-') || prev.includes('='))
+            break;
+    }
+    return out.map((s) => s.toLowerCase());
+}
+export function shellRisk(command, args) {
+    const cmd = commandName(command);
+    const subject = [command, ...args].map(showArg).join(' ');
+    const flag = (reason) => ({ kind: 'command', subject, reason });
+    if (cmd === 'node' && nodeRunsInlineCode(args)) {
+        return flag('runs code given on the command line');
+    }
+    if (cmd === 'git') {
+        let i = 0;
+        for (; i < args.length && args[i].startsWith('-'); i++) {
+            const a = args[i];
+            if (a === '-c' || /^-c./.test(a) || a.startsWith('--config-env'))
+                return flag('overrides git settings for this command');
+            if (GIT_VALUE_OPTIONS.has(a))
+                i++;
+        }
+        if (args[i] === 'config')
+            return flag('changes git settings');
+        if (gitRunsCommand(args[i], args.slice(i + 1)))
+            return flag('runs a command through git');
+        // Fix round 2 (L1) — a git subcommand named deploy / publish (a user's
+        // alias or a git-publish program). Only the subcommand position: file
+        // names, messages and branch names stay quiet (F6).
+        if (/deploy|publish/i.test(args[i] ?? ''))
+            return flag('deploys or publishes');
+    }
+    // F3 — the wrapper itself is flagged; the wrapped command is not parsed
+    // (`npm exec -c "<shell string>"` cannot be read reliably).
+    if (cmd === 'npx' || ((cmd === 'npm' || cmd === 'pnpm') && packageManagerSubcommands(args).some((s) => RUN_ANY_SUBCOMMANDS.has(s)))) {
+        return flag('runs a program through npm/pnpm');
+    }
+    if (NETWORK_TOOLS.has(cmd))
+        return flag('can send data to or fetch from the network');
+    // F6 — not git: `git add ui5-deploy.yaml` or a branch named for a publish
+    // cannot deploy anything (git's upload is `push`, an honest limit).
+    if (cmd !== 'git' && [command, ...args].some((a) => /deploy|publish/i.test(a)))
+        return flag('deploys or publishes');
+    return null;
+}
+export function credentialFileRisk(p) {
+    if (typeof p !== 'string' || p.length === 0)
+        return null;
+    // Windows spellings that open the same file: `.npmrc.`, `.npmrc `, `.npmrc::$DATA`.
+    const base = path.posix.basename(p.replace(/\\/g, '/')).split(':')[0].replace(/[. ]+$/, '').toLowerCase();
+    const flag = (reason) => ({ kind: 'credential-file', subject: p, reason });
+    if (CREDENTIAL_BASENAMES.has(base))
+        return flag('this file usually holds a password or token');
+    if (base.startsWith('.env') && !BLOCKED_BASENAME_RE.test(base))
+        return flag('environment files often hold passwords or keys');
+    if (CREDENTIAL_EXTS.has(path.posix.extname(base)))
+        return flag('certificate and key files can hold private keys');
+    return null;
+}
+/**
+ * grep and glob skip credential files (fix round 1, F2): a card cannot be
+ * shown mid-walk for a file the model did not name, so they are left out and
+ * this one line says so. file_read still reads one, with the card.
+ */
+export function credentialSkipNote(n) {
+    return `... (${n} credential file${n === 1 ? '' : 's'} skipped: .npmrc, .git-credentials, .env*, *.pem, *.key — use file_read, which asks the user first)`;
+}
+export function riskOf(tool, args) {
+    // background_run (category 'subagent') runs the same allow-listed commands
+    // with the same {command, args} — fix round 1, F1.
+    if (tool.category === 'shell' || tool.name === 'background_run') {
+        if (typeof args?.command !== 'string')
+            return null;
+        const argv = Array.isArray(args?.args) ? args.args.filter((a) => typeof a === 'string') : [];
+        return shellRisk(args.command, argv);
+    }
+    if (FILE_READ_TOOLS.has(tool.name))
+        return credentialFileRisk(args?.path);
+    return null;
+}

package/dist/agent/summarise-via-provider.js

@@ -13,6 +13,8 @@
  * NOT for tool-using calls. NOT for thinking-enabled calls. Pure text-in /
  * text-out.
  */
+import { profileOf } from './connection-profile.js';
+import { familyOf } from '../models/model-identity.js';
 /**
  * Run a single non-streaming summarisation call.
  *
@@ -37,20 +39,65 @@ export async function summariseViaProvider(provider, system, user, opts) {
             : opts.headers,
         signal: opts.signal,
     });
+    // Final fix wave B — in azure mode a compaction call is counted like any
+    // other azure call (usage record + local limit count). Every other mode
+    // reports nothing from here, as before.
+    const azure = profileOf(provider).modelIdentity === 'deployment';
+    const usage = { started: false, id: undefined, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
     let accumulated = '';
-    for await (const event of stream) {
-        const type = event?.type;
-        if (type === 'content_block_delta') {
-            const delta = event.delta;
-            if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
-                accumulated += delta.text;
+    try {
+        for await (const event of stream) {
+            const type = event?.type;
+            if (type === 'content_block_delta') {
+                const delta = event.delta;
+                if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
+                    accumulated += delta.text;
+                }
             }
+            else if (azure && type === 'message_start') {
+                const u = event.message?.usage ?? {};
+                usage.started = true;
+                if (typeof event.message?.id === 'string' && event.message.id)
+                    usage.id = event.message.id;
+                usage.input = num(u.input_tokens);
+                usage.cacheRead = num(u.cache_read_input_tokens);
+                usage.cacheWrite = num(u.cache_creation_input_tokens);
+                usage.output = num(u.output_tokens);
+            }
+            else if (azure && type === 'message_delta') {
+                // output_tokens on message_delta is the running total for the message.
+                usage.output = Math.max(usage.output, num(event.usage?.output_tokens));
+            }
+            // Ignore everything else — message_stop etc.
         }
-        // Ignore everything else — message_start/stop, usage events, etc.
-        // For one-shot text summarisation only content_block_delta matters.
+    }
+    finally {
+        if (azure && usage.started)
+            await reportCompactionUsage(provider, opts, usage);
     }
     if (!accumulated || accumulated.trim().length === 0) {
         throw new Error('Summariser returned empty output.');
     }
     return accumulated;
 }
+/** Fire-and-forget, never throws: usage counts are best effort. */
+async function reportCompactionUsage(provider, opts, u) {
+    try {
+        const { reportCallUsage } = await import('../usage/usage-reporter.js');
+        void reportCallUsage({
+            mode: 'azure',
+            requestId: u.id,
+            skill: opts.headers?.['X-CSForge-Skill'] ?? 'compact',
+            // The family of the deployment the call went to (the small one for compaction).
+            model: familyOf(opts.model, provider),
+            input: u.input,
+            output: u.output,
+            cacheRead: u.cacheRead,
+            cacheWrite: u.cacheWrite,
+            sessionId: opts.sessionId ?? '',
+            started: true,
+        }).catch(() => { });
+    }
+    catch { /* best effort */ }
+}

package/dist/agent/tool-dispatch.js

@@ -8,6 +8,7 @@ import { presentSafetyConfirmation } from '../repl/safety-confirm.js';
 import { shouldGateRule8, recordWriteOp, renderPlanSummary, getWriteOpsThisTurn, } from '../repl/rule8-detector.js';
 import { isCredentialHandoverApproved, markCredentialHandoverApproved, } from '../repl/credential-handover-gate.js';
 import { READER_TOOLS } from '../tools/subagent/reader-prompt.js';
+import { riskOf } from './risk-gate.js';
 const READER_TOOL_SET = new Set(READER_TOOLS);
 export async function dispatchTool(name, args, ctx) {
     const tool = getTool(name);
@@ -68,6 +69,24 @@ export async function dispatchTool(name, args, ctx) {
             return declined(r);
         markCredentialHandoverApproved(sessionId, handover.alias, handover.scope);
     }
+    // Security batch item 4 — the risk gate. Its own check, on every call:
+    // plan approval, batch approval and auto-approve do not skip it. Known risky
+    // shell patterns and reads of credential files ask every time; headless runs
+    // decline (presentSafetyConfirmation) and the refusal goes back to the model.
+    const risk = riskOf(tool, args);
+    if (risk) {
+        const r = await presentSafetyConfirmation({
+            rule: risk.kind === 'command' ? 'RISKY_COMMAND' : 'CREDENTIAL_FILE_READ',
+            op: tool.name,
+            object: { type: risk.kind === 'command' ? 'command' : 'file', name: risk.subject },
+            what_will_happen: `Flagged: ${risk.reason}`,
+            rollback_available: false,
+            transport: '',
+            args,
+        });
+        if (!r.confirmed)
+            return declined(r);
+    }
     // Rule 8 — no batch without plan. 2nd+ mutating call this turn requires
     // explicit confirmation. Fires regardless of /safety-mode toggle (batch
     // detection is unconditional per Plan 3 §6.6).

package/dist/agent/turn-error-ux.js

@@ -21,6 +21,8 @@ import { promises as fs } from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { TurnStreamWriter } from './turn-stream.js';
+import { azureSignInTurnLine } from '../connection/azure-turn-error.js';
+import { azureErrorNotice, azureErrorContext } from '../connection/azure-errors.js';
 export function logsRoot() {
     return path.join(os.homedir(), '.cspeach', 'logs');
 }
@@ -204,6 +206,26 @@ export async function renderTurnError(input) {
         print('');
         return;
     }
+    // Azure tenant mode (Task 6b) — the Microsoft sign-in ended (or the key is
+    // gone) mid-turn: the plain line and the command that fixes it, never a
+    // browser or a question here.
+    const azure = azureSignInTurnLine(input.err);
+    if (azure) {
+        printBlock(print, formatFailure(azure));
+        print('');
+        return;
+    }
+    // Azure tenant mode (Task 7) — the plain messages for the customer's own
+    // Azure (null unless azure settings are active or the error is an azure
+    // refusal, so every other mode is unchanged). A refusal the SDK wrapped as
+    // "Connection error." is unwrapped here (ruling 4).
+    const az = azureErrorNotice(input.err, azureErrorContext());
+    if (az) {
+        await writeErrorLog(id, input.err);
+        printBlock(print, 'preformatted' in az ? az.preformatted : formatFailure({ what: az.what, detail: [`Session: ${id}`], next: az.next }));
+        print('');
+        return;
+    }
     const reason = describeError(input.err);
     const logPath = await writeErrorLog(id, input.err);
     const detail = [reason, `Session: ${id}`];

package/dist/auth/api-key.js

@@ -1,12 +1,16 @@
 import keychain, { newProbeAccount } from './keychain.js';
+import { resolveApiKey, keychainAccountForHome, recordStoreWrite } from './key-resolver.js';
 const SERVICE = 'cspeach';
-const ACCOUNT = 'api-key';
 class KeychainStore {
     /** One probe per store: repeat checks (repl.tsx) reuse the first answer. */
     available;
-    async get() { return keychain.getPassword(SERVICE, ACCOUNT); }
-    async set(key) { await keychain.setPassword(SERVICE, ACCOUNT, key); }
-    async delete() { await keychain.deletePassword(SERVICE, ACCOUNT); }
+    /** Security batch item 6 — the one resolver: this home's account first, then auth.json. */
+    async get() { return (await resolveApiKey()).key; }
+    async set(key) {
+        await keychain.setPassword(SERVICE, keychainAccountForHome(), key);
+        await recordStoreWrite().catch(() => { });
+    }
+    async delete() { await keychain.deletePassword(SERVICE, keychainAccountForHome()); }
     isKeychainAvailable() {
         this.available ??= this.probe();
         return this.available;
@@ -32,7 +36,8 @@ class KeychainStore {
 }
 class EphemeralStore {
     cached = null;
-    async get() { return this.cached; }
+    /** No credential store: a key typed this session, else auth.json (the fallback). */
+    async get() { return this.cached ?? (await resolveApiKey()).key; }
     async set(key) { this.cached = key; }
     async delete() { this.cached = null; }
     async isKeychainAvailable() { return false; }

package/dist/auth/auth-file.js

@@ -19,6 +19,7 @@
  */
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
+import { randomBytes } from 'node:crypto';
 import { cspeachRoot } from '../config/paths.js';
 let pathOverride = null;
 /** Test-only override; pass null to reset. */
@@ -32,9 +33,14 @@ export async function readAuthFile() {
     try {
         const raw = await fs.readFile(authFilePath(), 'utf-8');
         const parsed = JSON.parse(raw);
-        if (typeof parsed.apiKey !== 'string' || typeof parsed.customerId !== 'string')
+        if (typeof parsed.customerId !== 'string')
             return null;
-        return { apiKey: parsed.apiKey, customerId: parsed.customerId };
+        const out = { customerId: parsed.customerId };
+        if (typeof parsed.apiKey === 'string' && parsed.apiKey.trim() !== '')
+            out.apiKey = parsed.apiKey;
+        if (typeof parsed.savedAt === 'string')
+            out.savedAt = parsed.savedAt;
+        return out;
     }
     catch {
         return null;
@@ -43,10 +49,27 @@ export async function readAuthFile() {
 export async function writeAuthFile(auth) {
     const p = authFilePath();
     await fs.mkdir(path.dirname(p), { recursive: true });
-    // Only the two known fields — never a secret a caller passes along by mistake.
-    const body = { apiKey: auth.apiKey, customerId: auth.customerId };
+    // Only the known fields — never a secret a caller passes along by mistake.
+    const body = {
+        ...(auth.apiKey !== undefined ? { apiKey: auth.apiKey } : {}),
+        customerId: auth.customerId,
+        ...(auth.savedAt !== undefined ? { savedAt: auth.savedAt } : {}),
+    };
     await writeAtomic0600(p, JSON.stringify(body, null, 2));
 }
+/** auth.json's modification time, or null when there is no file. */
+export async function authFileMtimeMs() {
+    try {
+        return (await fs.stat(authFilePath())).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+/** The folder auth.json lives in (the CSPeach home, or a test override's folder). */
+export function authFileDir() {
+    return path.dirname(authFilePath());
+}
 /** Rename errors that mean "the target is open elsewhere" (Windows), worth retrying. */
 const LOCK_CODES = new Set(['EPERM', 'EACCES', 'EBUSY']);
 /** Backoff between rename attempts (5 tries in all). */
@@ -63,7 +86,9 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
  * The temp file holds the API key, so it is always removed.
  */
 async function writeAtomic0600(p, text) {
-    const tmp = `${p}.${process.pid}.tmp`;
+    // Unique per write (security batch fix round 1): two writes in one process
+    // never share a temp file. Still matches cleanStaleAuthTemps' auth.json.*.tmp.
+    const tmp = `${p}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
     try {
         await fs.writeFile(tmp, text, { encoding: 'utf-8', mode: 0o600 });
         // Defensive: re-chmod in case the create-time mode was ignored (e.g., umask 022).
@@ -129,11 +154,15 @@ export async function cleanStaleAuthTemps() {
     }
     catch { /* no ~/.cspeach yet */ }
 }
+/** Remove auth.json. True when it is gone (or was never there); false when the unlink failed. */
 export async function deleteAuthFile() {
     try {
         await fs.unlink(authFilePath());
+        return true;
+    }
+    catch (err) {
+        return err.code === 'ENOENT';
     }
-    catch { /* ignore */ }
 }
 /** The BYOK key's keychain entry — the same one byok-provider.ts reads and login writes. */
 const BYOK_KEYCHAIN_SERVICE = 'cspeach.anthropic';

package/dist/auth/azure/azure-key.js

@@ -0,0 +1,21 @@
+/**
+ * Azure tenant mode — the admin-issued Azure key fallback, in the OS
+ * credential store: service cspeach.azure, account api-key[:<home hash>]
+ * (the same per-home rule as the CSPeach key, key-resolver.ts). Allowed only
+ * when the company's settings list `key` as a sign-in method.
+ */
+import keychain from '../keychain.js';
+import { keychainAccountForHome } from '../key-resolver.js';
+export const AZURE_SERVICE = 'cspeach.azure';
+export function azureAccountForHome(prefix, home, defaultHome) {
+    return keychainAccountForHome(home, defaultHome).replace(/^api-key/, prefix);
+}
+export async function getAzureKey() {
+    return keychain.getPassword(AZURE_SERVICE, azureAccountForHome('api-key'));
+}
+export async function setAzureKey(key) {
+    await keychain.setPassword(AZURE_SERVICE, azureAccountForHome('api-key'), key);
+}
+export async function deleteAzureKey() {
+    return keychain.deletePassword(AZURE_SERVICE, azureAccountForHome('api-key'));
+}

package/dist/auth/azure/azure-log.js

@@ -0,0 +1,45 @@
+/**
+ * Azure tenant mode — MSAL and sign-in diagnostics go to
+ * <CSPEACH_HOME>/logs/azure-signin.log, never the screen, always redacted:
+ * JWTs, Bearer values, refresh tokens, authorization codes, PKCE verifiers,
+ * states and long hex keys are replaced. Callers still log fixed lines only;
+ * this is the second fence, not the first.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { cspeachRoot } from '../../config/paths.js';
+const JWT = /eyJ[A-Za-z0-9_-]{8,}(?:\.[A-Za-z0-9_-]*){1,2}/g;
+const BEARER = /(Bearer\s+)\S+/gi;
+const PARAMS = /(?<![A-Za-z_])((?:refresh_token|access_token|id_token|client_secret|code_verifier|code|state|session_state|client_info)=)[^&\s]+/gi;
+const HEADERS = /((?:x-api-key|api-key)\s*[:=]\s*)\S+/gi;
+const LONG_HEX = /\b[0-9a-f]{32,}\b/gi;
+export function redactSecrets(line) {
+    return line
+        .replace(JWT, '<redacted>')
+        .replace(BEARER, '$1<redacted>')
+        .replace(PARAMS, '$1<redacted>')
+        .replace(HEADERS, '$1<redacted>')
+        .replace(LONG_HEX, '<redacted>');
+}
+/** The log never grows past this; when it does, the oldest whole lines are dropped. */
+export const AZURE_LOG_MAX_BYTES = 256 * 1024;
+function trim(file) {
+    if (fs.statSync(file).size <= AZURE_LOG_MAX_BYTES)
+        return;
+    const buf = fs.readFileSync(file);
+    let tail = buf.subarray(buf.length - Math.floor(AZURE_LOG_MAX_BYTES / 2));
+    const nl = tail.indexOf(0x0a);
+    if (nl >= 0)
+        tail = tail.subarray(nl + 1);
+    fs.writeFileSync(file, tail);
+}
+export function azureLog(line) {
+    try {
+        const dir = path.join(cspeachRoot(), 'logs');
+        fs.mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, 'azure-signin.log');
+        fs.appendFileSync(file, `${new Date().toISOString()} ${redactSecrets(line).replace(/\s+/g, ' ').slice(0, 2000)}\n`);
+        trim(file);
+    }
+    catch { /* logging never breaks sign-in */ }
+}