@cspeach/cli 1.1.33 → 1.1.35

package/dist/skills/source-authed.js

@@ -0,0 +1,276 @@
+/**
+ * Security batch item 2 — skill text only for signed-in seats (byok, ai-hub,
+ * local). The manifest stays public and signed (older CLIs verify it, and the
+ * routing list comes from it). Bodies come from GET /v1/skills/:name with the
+ * CSPeach bearer, and each body's sha256 is checked against the SIGNED
+ * manifest entry — the server-claimed hash is never trusted.
+ *
+ * Public bodies (manifest.cspeach.dev/v1/skills-public/…) are read only with
+ * CSPEACH_SKILLS_PUBLIC_FALLBACK=1, for one release; the route returns 410 in
+ * the next. Honest limit: any licensed seat can read the skill text — this is
+ * licence compliance, not secrecy.
+ */
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+import { ManifestClient, DEFAULT_MANIFEST_URL, SkillIntegrityError, ManifestUnavailableError, } from './manifest-client.js';
+import { fileSkillsCache } from './skills-cache.js';
+// Defined next to the client that throws it (Task 8 (a): typed, never string-matched).
+export { SkillIntegrityError };
+export class SkillNotInPlanError extends Error {
+    constructor(name) {
+        super(`The skill /${name} is not in your CSPeach plan. Ask your admin to add it.`);
+        this.name = 'SkillNotInPlanError';
+    }
+}
+export class SkillsUnavailableError extends Error {
+    constructor(detail) {
+        super(`Skills can't be loaded right now (${detail}). Try again in a few minutes.`);
+        this.name = 'SkillsUnavailableError';
+    }
+}
+/**
+ * The server answered, but not with a usable skill: a 4xx other than 401/403
+ * (404, 429, …) or a 200 without skill text. Deliberately NOT a
+ * SkillsUnavailableError: only network failures and 5xx may open the disk
+ * cache or the public fallback.
+ */
+export class SkillFetchError extends Error {
+    constructor(detail) {
+        super(`Skills can't be loaded right now (${detail}). Try again in a few minutes.`);
+        this.name = 'SkillFetchError';
+    }
+}
+export class SkillSignInError extends Error {
+    constructor() {
+        super('CSPeach did not accept your sign-in for skills. Run cspeach login.');
+        this.name = 'SkillSignInError';
+    }
+}
+export function publicFallbackEnabled(env = process.env) {
+    return env.CSPEACH_SKILLS_PUBLIC_FALLBACK === '1';
+}
+/** The one resolver's key (Task 4), for providers built without a bearer. */
+export async function defaultBearer() {
+    const { getStore } = await import('../auth/api-key.js');
+    return (await (await getStore()).get()) ?? '';
+}
+const FETCH_TIMEOUT_MS = 10_000;
+/** GET /v1/skills/:name with the CSPeach bearer; the body is hashed against the SIGNED manifest entry. */
+async function fetchSignedInBody(baseUrl, name, expectedSha, getBearer, doFetch) {
+    // A missing key is a sign-in problem, settled before any network call.
+    let bearer;
+    try {
+        bearer = await getBearer();
+    }
+    catch {
+        throw new SkillSignInError();
+    }
+    if (typeof bearer !== 'string' || bearer.trim() === '')
+        throw new SkillSignInError();
+    let r;
+    try {
+        r = await doFetch(`${baseUrl}/v1/skills/${encodeURIComponent(name)}`, {
+            headers: { Authorization: `Bearer ${bearer}` },
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        });
+    }
+    catch {
+        throw new SkillsUnavailableError('could not reach CSPeach');
+    }
+    if (r.status === 403)
+        throw new SkillNotInPlanError(name);
+    if (r.status === 401)
+        throw new SkillSignInError();
+    if (r.status >= 500)
+        throw new SkillsUnavailableError(`the server answered ${r.status}`);
+    if (!r.ok)
+        throw new SkillFetchError(`the server answered ${r.status}`);
+    const j = await r.json().catch(() => null);
+    if (!j || typeof j.body !== 'string')
+        throw new SkillFetchError('the answer had no skill text');
+    const actual = bytesToHex(sha256(new TextEncoder().encode(j.body)));
+    if (actual !== expectedSha) {
+        throw new SkillIntegrityError(`skill ${name}: sha256 mismatch with the signed manifest (manifest=${expectedSha}, computed=${actual})`);
+    }
+    return { name, body: j.body, sha256: actual, signature: '', signedAt: typeof j.signedAt === 'string' ? j.signedAt : '' };
+}
+export function createAuthedSkillSource(cfg, getBearer, deps = {}) {
+    const manifestUrl = deps.manifestUrl ?? DEFAULT_MANIFEST_URL;
+    const client = deps.client ?? new ManifestClient(manifestUrl);
+    const doFetch = deps.fetchImpl ?? fetch;
+    const env = deps.env ?? process.env;
+    const cache = deps.cache === undefined ? fileSkillsCache : deps.cache;
+    const baseUrl = cfg.proxy_url.replace(/\/$/, '');
+    let manifest = null;
+    const memory = new Map();
+    // The existing debug channel (CSPEACH_DEBUG=1 → stderr). Never user output.
+    function debugIntegrity(err) {
+        if (env.CSPEACH_DEBUG !== '1')
+            return;
+        process.stderr.write(`[skills] ${err.debug}\n`);
+    }
+    async function getManifest() {
+        if (manifest)
+            return manifest;
+        try {
+            manifest = await client.fetchAndVerifyManifest();
+            if (cache) {
+                await cache.saveManifest(manifest);
+                await cache.prune(manifest);
+            }
+        }
+        catch (err) {
+            // Only "could not reach it" (network / 5xx) may use the disk copy. A bad
+            // signature, a 4xx or bad JSON never does.
+            if (!(err instanceof ManifestUnavailableError))
+                throw err;
+            const fromDisk = cache ? await cache.loadManifest((m) => client.verifyManifest(m)) : null;
+            if (!fromDisk)
+                throw err;
+            manifest = fromDisk; // offline: the signed copy on disk, re-verified just now
+        }
+        return manifest;
+    }
+    const fetchSignedIn = (name, expectedSha) => fetchSignedInBody(baseUrl, name, expectedSha, getBearer, doFetch);
+    async function fetchPublic(name, entry) {
+        try {
+            return await client.fetchSkillBody(name, entry.body_url, { expectedSha256: entry.sha256 });
+        }
+        catch (err) {
+            if (err instanceof SkillIntegrityError)
+                throw err;
+            if (/HTTP 410\b/.test(String(err?.message))) {
+                throw new SkillsUnavailableError('the public skill route is retired; run cspeach login and unset CSPEACH_SKILLS_PUBLIC_FALLBACK');
+            }
+            throw new SkillsUnavailableError('the public skill source did not answer');
+        }
+    }
+    return {
+        async getSkillBody(name) {
+            const m = await getManifest();
+            const entry = m.skills.find((s) => s.name === name);
+            if (!entry)
+                throw new Error(`skill '${name}' not found in manifest (available: ${m.skills.map((s) => s.name).join(', ')})`);
+            const inMemory = memory.get(name);
+            if (inMemory && inMemory.sha256 === entry.sha256)
+                return inMemory;
+            let body;
+            try {
+                try {
+                    body = await fetchSignedIn(name, entry.sha256);
+                    if (cache)
+                        await cache.saveBody(entry, body);
+                }
+                catch (err) {
+                    // No longer in the plan: drop the cached copy so a later outage
+                    // cannot serve it.
+                    if (err instanceof SkillNotInPlanError && cache)
+                        await cache.removeBody(name);
+                    // Network / 5xx: a valid cached copy first (hash-checked against the
+                    // signed manifest), then — only with the switch — the public body.
+                    // 401 / 403 / a hash mismatch never fall back.
+                    if (!(err instanceof SkillsUnavailableError))
+                        throw err;
+                    const fromDisk = cache ? await cache.loadBody(entry) : null;
+                    if (fromDisk)
+                        body = fromDisk;
+                    else if (publicFallbackEnabled(env))
+                        body = await fetchPublic(name, entry);
+                    else
+                        throw err;
+                }
+            }
+            catch (err) {
+                if (err instanceof SkillIntegrityError)
+                    debugIntegrity(err);
+                throw err;
+            }
+            memory.set(name, body);
+            return body;
+        },
+        async listAvailableSkills() {
+            return (await getManifest()).skills.map((s) => s.name);
+        },
+        describe() {
+            return `signed manifest at ${manifestUrl}; bodies from ${baseUrl} for signed-in seats`;
+        },
+    };
+}
+// ── Skills cache warm-up (final review finding 1) ─────────────────────────
+// "Sign in once, then work offline": after an ok licence verdict in byok /
+// ai-hub / local, fill the disk cache with every skill body that is missing or
+// out of date — through the same signed-in, hash-checked fetch and the same
+// cache as getSkillBody. Fire-and-forget: never awaited on the start-up or
+// turn path, every error swallowed, at most once per process. Managed does no
+// work at all (its skills come from the proxy on every request).
+const WARM_CONCURRENCY = 4;
+export async function warmSkillsCache(cfg, getBearer, deps = {}, opts = {}) {
+    const result = { fetched: 0, skipped: 0, stopped: null };
+    const cache = deps.cache === undefined ? fileSkillsCache : deps.cache;
+    if (!cache)
+        return result;
+    const client = deps.client ?? new ManifestClient(deps.manifestUrl ?? DEFAULT_MANIFEST_URL);
+    const doFetch = deps.fetchImpl ?? fetch;
+    const baseUrl = cfg.proxy_url.replace(/\/$/, '');
+    let m;
+    try {
+        m = await client.fetchAndVerifyManifest();
+        await cache.saveManifest(m);
+        await cache.prune(m);
+    }
+    catch {
+        return result; // offline or a bad manifest: nothing to warm
+    }
+    // One key read for the whole warm-up, not one per skill.
+    let bearerP = null;
+    const bearerOnce = () => (bearerP ??= getBearer());
+    const queue = [...m.skills];
+    const worker = async () => {
+        for (let entry = queue.shift(); entry && !result.stopped; entry = queue.shift()) {
+            try {
+                if (await cache.loadBody(entry)) {
+                    result.skipped++;
+                    continue;
+                }
+                const body = await fetchSignedInBody(baseUrl, entry.name, entry.sha256, bearerOnce, doFetch);
+                await cache.saveBody(entry, body);
+                result.fetched++;
+            }
+            catch (err) {
+                // Coordinator ruling: only a 401 / sign-in failure stops the warm-up.
+                if (err instanceof SkillSignInError)
+                    result.stopped = 'sign-in';
+                // 403: this one skill is not in the plan — drop any cached copy (as
+                // getSkillBody does) and carry on with the rest.
+                else if (err instanceof SkillNotInPlanError)
+                    await cache.removeBody(entry.name).catch(() => { });
+                // 5xx / network, a hash mismatch or another 4xx: skip this body, carry
+                // on, never retry; nothing is cached for it.
+            }
+        }
+    };
+    const n = Math.max(1, Math.min(opts.concurrency ?? WARM_CONCURRENCY, queue.length));
+    await Promise.all(Array.from({ length: n }, worker));
+    return result;
+}
+let warmStarted = false;
+/** Test hook: forget that this process already warmed. */
+export function _resetSkillsWarmupForTests() {
+    warmStarted = false;
+}
+/**
+ * Start the warm-up when the mode is not managed and the licence verdict is
+ * ok. Returns at once: null when nothing was started, else a promise that
+ * never rejects (callers drop it; tests await it).
+ */
+export function startSkillsCacheWarmup(cfg, verdict, opts = {}) {
+    if (cfg.llm.mode === 'managed' || verdict !== 'ok' || warmStarted)
+        return null;
+    warmStarted = true;
+    try {
+        return warmSkillsCache(cfg, opts.getBearer ?? defaultBearer, opts.deps).then(() => undefined, () => undefined);
+    }
+    catch {
+        return Promise.resolve();
+    }
+}

package/dist/tools/ask-question.js

@@ -251,7 +251,7 @@ registerTool({
                         },
                         multiSelect: {
                             type: 'boolean',
-                            description: 'true = the user may pick several options; false/omitted = pick exactly one.',
+                            description: 'true = the user may pick several options; false/omitted = pick exactly one. When the user ticks options and also types an answer, it comes back as free text (custom: true): the ticked labels, then the typed text, comma-separated.',
                         },
                         options: {
                             type: 'array',

package/dist/tools/filesystem/glob.js

@@ -20,6 +20,7 @@ import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { registerTool } from '../index.js';
 import { resolveSafePath, assertRealPathContained, PathOutsideRootError, isDenylistedPath, isReadOnlyProjectFile, isSeatReadOnlyFile, DENYLIST_DESCRIPTION, } from '../_filesystem-shared.js';
+import { credentialFileRisk, credentialSkipNote } from '../../agent/risk-gate.js';
 import { isReadOnlyRel, isWorkRel, teamWorkRoot, teamWorkTarget } from '../_team-work-path.js';
 const MAX_RESULTS = 500;
 const MAX_FILES_TRAVERSED = 10_000;
@@ -120,6 +121,7 @@ export async function globHandler(args, ctx) {
     const wantsCspeach = isCspeachPattern(args.pattern);
     const collected = [];
     let budget = MAX_FILES_TRAVERSED;
+    let credentialSkipped = 0;
     async function walk(dir, relPrefix, denyRoot = root) {
         if (budget <= 0 || collected.length >= MAX_RESULTS * 4)
             return;
@@ -162,6 +164,12 @@ export async function globHandler(args, ctx) {
                 const denylist = isDenylistedPath(abs, denyRoot);
                 if (denylist.blocked && !isReadOnlyProjectFile(abs, denyRoot))
                     continue;
+                // Security batch item 4, fix round 1 (F2) — credential files are not
+                // listed (same rule as the risk gate); one line says how many.
+                if (credentialFileRisk(ent.name)) {
+                    credentialSkipped++;
+                    continue;
+                }
                 let mtime = 0;
                 try {
                     const s = await fs.stat(abs);
@@ -221,17 +229,18 @@ export async function globHandler(args, ctx) {
     // Sort by mtime descending, cap at MAX_RESULTS
     collected.sort((a, b) => b.mtime - a.mtime);
     const sample = collected.slice(0, MAX_RESULTS).map((f) => f.relPath);
+    const skipNote = credentialSkipped > 0 ? `\n${credentialSkipNote(credentialSkipped)}` : '';
     if (sample.length === 0) {
         // A search for saved results that did not name `.cspeach/` gets the hint.
         const hint = !wantsCspeach && /\.json$/i.test(args.pattern)
             ? ' (saved CSPeach results live in .cspeach/ — search there with pattern ".cspeach/*.cspeach.json")'
             : '';
-        return { content: `no files match "${args.pattern}"${hint}` };
+        return { content: `no files match "${args.pattern}"${hint}${skipNote}` };
     }
     const truncated = collected.length > MAX_RESULTS;
-    const trailer = truncated
+    const trailer = (truncated
         ? `\n... (${collected.length - MAX_RESULTS} more matches — narrow the pattern)`
-        : '';
+        : '') + skipNote;
     return { content: sample.join('\n') + trailer };
 }
 registerTool({

package/dist/tools/filesystem/grep.js

@@ -23,6 +23,7 @@ import { registerTool } from '../index.js';
 import { resolveSafePath, assertRealPathContained, PathOutsideRootError, isDenylistedPath, DENYLIST_DESCRIPTION, } from '../_filesystem-shared.js';
 import { globToRegex } from './glob.js';
 import { teamWorkTarget } from '../_team-work-path.js';
+import { credentialFileRisk, credentialSkipNote } from '../../agent/risk-gate.js';
 const MAX_MATCHES = 250;
 const MAX_FILES_TRAVERSED = 10_000;
 const MAX_FILE_BYTES = 2_000_000;
@@ -69,6 +70,11 @@ export async function grepHandler(args, ctx) {
     const matches = [];
     const fileMatchCounts = new Map();
     let budget = MAX_FILES_TRAVERSED;
+    // Security batch item 4, fix round 1 (F2) — credential files (.npmrc,
+    // .git-credentials, .env* outside the denylist, *.pem, *.key) are never
+    // searched: grep would return their text with no card. Counted, and one
+    // line says so. Same rule as the risk gate, so the lists cannot drift.
+    let credentialSkipped = 0;
     async function walk(dir, relPrefix) {
         if (budget <= 0 || matches.length >= MAX_MATCHES)
             return;
@@ -106,6 +112,10 @@ export async function grepHandler(args, ctx) {
                 const denylist = isDenylistedPath(abs, root);
                 if (denylist.blocked)
                     continue;
+                if (credentialFileRisk(ent.name)) {
+                    credentialSkipped++;
+                    continue;
+                }
                 let stat;
                 try {
                     stat = await fs.stat(abs);
@@ -158,13 +168,14 @@ export async function grepHandler(args, ctx) {
         }
     }
     await walk(realRoot, '');
+    const skipNote = credentialSkipped > 0 ? `\n${credentialSkipNote(credentialSkipped)}` : '';
     if (matches.length === 0) {
-        return { content: `no matches for /${args.pattern}/${args.case_insensitive ? 'i' : ''}` };
+        return { content: `no matches for /${args.pattern}/${args.case_insensitive ? 'i' : ''}${skipNote}` };
     }
     const truncated = matches.length >= MAX_MATCHES;
-    const trailer = truncated
+    const trailer = (truncated
         ? `\n... (cap of ${MAX_MATCHES} matches reached — narrow the pattern or use a glob filter)`
-        : '';
+        : '') + skipNote;
     if (outputMode === 'files_with_matches') {
         const files = [...new Set(matches.map((m) => m.file))];
         return { content: files.join('\n') + trailer };

package/dist/tools/sap-read.js

@@ -644,29 +644,29 @@ registerTool({
     handler: async (args, ctx) => {
         // runUnitTest(type, name) — type first
         const result = await ctx.adt.runUnitTest(args.type, args.name);
-        // B2 false-green guard (project_aunit_run_gap): the ADT AUnit-run endpoint
-        // returns HTTP 200 with an EMPTY runResult (total:0, no programs) even for a
-        // class that is active + syntax-clean with a valid FOR TESTING local class —
-        // a known environmental gap, exhaustively probed (sap-client buildUnitTestXml
-        // comment). The raw {total:0} shape reads to a caller like "0 tests, nothing
-        // failed → green", so an unguarded pass-through risks a false-green test gate.
-        // When we detect that empty signature, wrap the (still-carried) raw result in
-        // an explicit UNVERIFIED envelope that names Eclipse "Run As → ABAP Unit" as
-        // the authoritative check. A genuine run (total > 0) passes through unchanged.
-        const summary = result?.summary;
-        const programs = result?.programs;
-        const noTestsRun = summary?.total === 0 && (!Array.isArray(programs) || programs.length === 0);
-        if (noTestsRun) {
+        // B2 false-green guard: a run in which no test actually ran reads to a
+        // caller like "nothing failed → green". Wrap the (still-carried) raw result
+        // in an explicit UNVERIFIED envelope when:
+        //   - total is 0, missing or not a number — even when programs are present
+        //     (a class with no methods, or only tolerable class alerts; review I1);
+        //   - every test was skipped (total > 0, passed 0, failed 0; review M1).
+        // It is no longer blamed on an ADT gap: the 2026-10-12 sap-client fix sends
+        // the request shape Eclipse sends. A run with a pass or a failure passes
+        // through unchanged.
+        const summary = result
+            ?.summary;
+        const total = summary?.total;
+        const noTestsRun = typeof total !== 'number' || !Number.isFinite(total) || total === 0;
+        const allSkipped = !noTestsRun && summary?.passed === 0 && summary?.failed === 0;
+        if (noTestsRun || allSkipped) {
+            const n = total;
+            const warning = noTestsRun
+                ? '0 tests ran — this is not a pass. Check that the object has an active test ' +
+                    'class (FOR TESTING) with active test methods, then run it again.'
+                : `${n === 1 ? '1 test was' : `${n} tests were`} skipped and none ran — this is not ` +
+                    'a pass. Check the risk level and duration of the test classes, then run it again.';
             return {
-                content: JSON.stringify({
-                    verification: 'UNVERIFIED',
-                    warning: 'ABAP Unit run enumerated 0 tests (empty runResult). This does NOT mean the tests ' +
-                        'passed — it means none executed. A FOR TESTING class that is active + syntax-clean ' +
-                        'still returning 0 is a known ADT AUnit-run gap (project_aunit_run_gap): the ' +
-                        'authoritative check is Eclipse "Run As → ABAP Unit" (Ctrl+Shift+F10). Do NOT treat ' +
-                        'this as a green test gate.',
-                    result,
-                }, null, 2),
+                content: JSON.stringify({ verification: 'UNVERIFIED', warning, result }, null, 2),
             };
         }
         return { content: JSON.stringify(result, null, 2) };