context-mode 1.0.111 → 1.0.113

package/build/runPool.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Generic in-flight-capped worker pool.
+ *
+ * Used by:
+ *   - runBatchCommands (ctx_batch_execute parallel branch)
+ *   - runBatchFetch    (ctx_fetch_and_index batch path)
+ *
+ * Returns Promise.allSettled-style results so one job's throw cannot
+ * strand siblings. Caller maps fulfilled/rejected per index. Output
+ * order is preserved by input index (not completion order).
+ *
+ * Designed to be the SINGLE concurrency primitive for the project —
+ * all "run N independent operations with at most M in flight" needs
+ * route here. Avoids the worker-pool copy-paste flagged in the
+ * concurrency PRD architectural review (finding G).
+ */
+export interface PoolJob<T> {
+    run(): Promise<T>;
+}
+export interface RunPoolOptions {
+    /** Hard concurrency cap (1-N). Auto-clamped to job count. */
+    concurrency: number;
+    /** Optional: also clamp by `os.cpus().length` (memory-pressure safety). Default false. */
+    capByCpuCount?: boolean;
+    /** Optional: per-settled callback (e.g. for progress reporting / metrics). */
+    onSettled?: (idx: number, result: PromiseSettledResult<unknown>) => void;
+}
+export interface RunPoolResult<T> {
+    /** Per-index settled result, ordered by input index. */
+    settled: PromiseSettledResult<T>[];
+    /** Concurrency actually used after all caps applied. */
+    effectiveConcurrency: number;
+    /** True when effectiveConcurrency < requested concurrency. */
+    capped: boolean;
+}
+export declare function runPool<T>(jobs: PoolJob<T>[], opts: RunPoolOptions): Promise<RunPoolResult<T>>;

package/build/runPool.js

@@ -0,0 +1,51 @@
+/**
+ * Generic in-flight-capped worker pool.
+ *
+ * Used by:
+ *   - runBatchCommands (ctx_batch_execute parallel branch)
+ *   - runBatchFetch    (ctx_fetch_and_index batch path)
+ *
+ * Returns Promise.allSettled-style results so one job's throw cannot
+ * strand siblings. Caller maps fulfilled/rejected per index. Output
+ * order is preserved by input index (not completion order).
+ *
+ * Designed to be the SINGLE concurrency primitive for the project —
+ * all "run N independent operations with at most M in flight" needs
+ * route here. Avoids the worker-pool copy-paste flagged in the
+ * concurrency PRD architectural review (finding G).
+ */
+import { cpus } from "node:os";
+export async function runPool(jobs, opts) {
+    const { concurrency, capByCpuCount = false, onSettled } = opts;
+    if (jobs.length === 0) {
+        return { settled: [], effectiveConcurrency: 0, capped: false };
+    }
+    const requested = Math.max(1, concurrency);
+    const cpuCap = capByCpuCount ? Math.max(1, cpus().length) : requested;
+    const effectiveConcurrency = Math.min(requested, cpuCap, jobs.length);
+    const capped = effectiveConcurrency < requested;
+    const settled = new Array(jobs.length);
+    let nextIdx = 0;
+    async function worker() {
+        while (true) {
+            const idx = nextIdx++;
+            if (idx >= jobs.length)
+                return;
+            try {
+                const value = await jobs[idx].run();
+                settled[idx] = { status: "fulfilled", value };
+            }
+            catch (err) {
+                settled[idx] = { status: "rejected", reason: err };
+            }
+            onSettled?.(idx, settled[idx]);
+        }
+    }
+    const workers = [];
+    for (let w = 0; w < effectiveConcurrency; w++)
+        workers.push(worker());
+    // allSettled defends against any promise rejection escaping a worker
+    // (the worker already swallows its own errors, but this is belt-and-braces).
+    await Promise.allSettled(workers);
+    return { settled, effectiveConcurrency, capped };
+}

package/build/runtime.js

@@ -29,6 +29,48 @@ function commandExists(cmd) {
         return false;
     }
 }
+/**
+ * Stricter probe than commandExists() — also verifies the resolved binary
+ * actually runs. On Windows, `where python3` matches the Microsoft Store
+ * App Execution Alias stub at C:\Users\<u>\AppData\Local\Microsoft\WindowsApps\
+ * even when no real Python is installed; the stub exits non-zero (9009) and
+ * pops the Store. Filter those entries out and require `<cmd> --version` to
+ * exit 0 before declaring the runtime available (#455).
+ */
+function runnableExists(cmd) {
+    if (isWindows) {
+        // Reject if every `where` hit lives under Microsoft\WindowsApps (Store stubs).
+        try {
+            const out = execSync(`where ${cmd}`, { encoding: "utf-8", stdio: "pipe" });
+            const hits = out.trim().split(/\r?\n/).map(p => p.trim()).filter(Boolean);
+            if (hits.length === 0)
+                return false;
+            const realHits = hits.filter(p => !/\\Microsoft\\WindowsApps\\/i.test(p));
+            if (realHits.length === 0)
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    else if (!commandExists(cmd)) {
+        return false;
+    }
+    // Probe with --version. On Windows, allow 5s for cold-start (MS Store stub
+    // fallthrough can be slow). On POSIX, 1500ms is plenty for a real binary
+    // and keeps cold detection of python3 → python → py under ~5s total (#454).
+    try {
+        execFileSync(cmd, ["--version"], {
+            shell: isWindows,
+            stdio: "pipe",
+            timeout: isWindows ? 5000 : 1500,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function bunExists() {
     if (commandExists("bun"))
         return true;
@@ -39,12 +81,19 @@ function bunExists() {
     return false;
 }
 function bunCommand() {
-    if (commandExists("bun"))
-        return "bun";
+    // Prefer absolute .exe paths so spawn() can run with shell:false on Windows.
+    // `where bun` may resolve to a `bun.cmd` npm shim (#506) which CreateProcess
+    // cannot execute directly — return the real .exe wherever we can find one.
     for (const p of bunFallbackPaths()) {
         if (existsSync(p))
             return p;
     }
+    // Bare name only if PATH resolution confirms it. On Windows this is
+    // typically a .cmd shim — the executor's needsShell list (which now
+    // includes "bun" — see #506) ensures shell:true so cmd.exe can resolve it.
+    if (commandExists("bun"))
+        return "bun";
+    // Synthetic last-resort path for diagnostics/error messages.
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
     return isWindows ? `${home}\\.bun\\bin\\bun.exe` : `${home}/.bun/bin/bun`;
 }
@@ -53,9 +102,17 @@ function bunFallbackPaths() {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
     if (isWindows) {
         const localAppData = process.env.LOCALAPPDATA ?? "";
+        const appData = process.env.APPDATA ?? "";
         return [
+            // Native bun installer locations (irm bun.sh/install.ps1).
             ...(home ? [`${home}\\.bun\\bin\\bun.exe`] : []),
             ...(localAppData ? [`${localAppData}\\bun\\bin\\bun.exe`] : []),
+            // npm i -g bun installs bun.exe under the npm prefix (typically
+            // %APPDATA%\npm\node_modules\bun\bin\bun.exe). Without this, npm
+            // installs were "found" via bun.cmd shim on PATH and the bare "bun"
+            // string was returned — spawn() then ENOENT'd because CreateProcess
+            // can't execute .cmd files (#506).
+            ...(appData ? [`${appData}\\npm\\node_modules\\bun\\bin\\bun.exe`] : []),
         ];
     }
     return home ? [`${home}/.bun/bin/bun`] : [];
@@ -133,11 +190,13 @@ export function detectRuntimes() {
                 : commandExists("ts-node")
                     ? "ts-node"
                     : null,
-        python: commandExists("python3")
+        python: runnableExists("python3")
             ? "python3"
-            : commandExists("python")
+            : runnableExists("python")
                 ? "python"
-                : null,
+                : runnableExists("py")
+                    ? "py"
+                    : null,
         shell: shellOverride ?? (isWin
             ? (resolveWindowsBash() ?? (commandExists("sh") ? "sh" : commandExists("powershell") ? "powershell" : "cmd.exe"))
             : commandExists("bash") ? "bash" : "sh"),

package/build/search/auto-memory.js

@@ -7,7 +7,7 @@
  */
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join, isAbsolute } from "node:path";
-import { homedir } from "node:os";
+import { resolveClaudeConfigDir } from "../util/claude-config.js";
 const DEBUG = process.env.DEBUG?.includes("context-mode");
 /**
  * Search auto-memory files for content matching any of the given queries.
@@ -33,9 +33,11 @@ export function searchAutoMemory(queries, limit = 5, projectDir, configDir, adap
     // over the historical Claude defaults.
     const instructionFiles = adapter?.getInstructionFiles() ?? ["CLAUDE.md"];
     const adapterConfigDir = adapter?.getConfigDir();
-    const effectiveConfigDir = adapterConfigDir
-        ? resolveAgainst(projectDir, adapterConfigDir)
-        : (configDir || join(homedir(), ".claude"));
+    // Issue #460 round-3: legacy fallback honors $CLAUDE_CONFIG_DIR via the
+    // canonical util so callers without an adapter still respect relocated
+    // CC config trees (and empty/whitespace env doesn't poison the path).
+    const adapterRelative = adapterConfigDir ? resolveAgainst(projectDir, adapterConfigDir) : null;
+    const effectiveConfigDir = adapterRelative ?? configDir ?? resolveClaudeConfigDir();
     const adapterMemoryDir = adapter?.getMemoryDir();
     const memoryDir = adapterMemoryDir
         ? resolveAgainst(projectDir, adapterMemoryDir)

package/build/security.js

@@ -1,6 +1,6 @@
 import { readFileSync, realpathSync } from "node:fs";
 import { resolve } from "node:path";
-import { homedir } from "node:os";
+import { resolveAdapterGlobalSettingsPaths } from "./util/claude-config.js";
 // ==============================================================================
 // Pattern Parsing
 // ==============================================================================
@@ -238,10 +238,18 @@ export function readBashPolicies(projectDir, globalSettingsPath) {
         if (sharedPolicy)
             policies.push(sharedPolicy);
     }
-    const globalPath = globalSettingsPath ?? resolve(homedir(), ".claude", "settings.json");
-    const globalPolicy = readSingleSettings(globalPath);
-    if (globalPolicy)
-        policies.push(globalPolicy);
+    // Issue #451 round-3: read settings from EVERY adapter-specific global path
+    // PLUS the claude global (defense in depth). When the caller passes an
+    // explicit globalSettingsPath we honor it verbatim (back-compat with tests
+    // and callers that already know which file to read).
+    const globalPaths = globalSettingsPath !== undefined
+        ? [globalSettingsPath]
+        : resolveAdapterGlobalSettingsPaths();
+    for (const globalPath of globalPaths) {
+        const globalPolicy = readSingleSettings(globalPath);
+        if (globalPolicy)
+            policies.push(globalPolicy);
+    }
     return policies;
 }
 /**
@@ -293,10 +301,18 @@ export function readToolDenyPatterns(toolName, projectDir, globalSettingsPath) {
         if (sharedGlobs !== null)
             result.push(sharedGlobs);
     }
-    const globalPath = globalSettingsPath ?? resolve(homedir(), ".claude", "settings.json");
-    const globalGlobs = extractGlobs(globalPath);
-    if (globalGlobs !== null)
-        result.push(globalGlobs);
+    // Issue #451 round-3: union over every adapter-specific global path PLUS
+    // claude global. Each settings file contributes its own globs array entry
+    // so the precedence ordering downstream remains per-file rather than
+    // collapsed.
+    const globalPaths = globalSettingsPath !== undefined
+        ? [globalSettingsPath]
+        : resolveAdapterGlobalSettingsPaths();
+    for (const globalPath of globalPaths) {
+        const globalGlobs = extractGlobs(globalPath);
+        if (globalGlobs !== null)
+            result.push(globalGlobs);
+    }
     return result;
 }
 /**
@@ -395,7 +411,11 @@ export function evaluateFilePath(filePath, denyGlobs, caseInsensitive = process.
     }
     for (const globs of denyGlobs) {
         for (const glob of globs) {
-            const regex = fileGlobToRegex(glob, caseInsensitive);
+            // Normalize the glob's path separators the same way candidates were
+            // normalized — otherwise a Windows absolute deny rule like
+            // `Read(C:\Users\...\secret.env)` parses with literal backslashes that
+            // never match a forward-slash candidate.
+            const regex = fileGlobToRegex(toForward(glob), caseInsensitive);
             for (const candidate of candidates) {
                 if (regex.test(candidate)) {
                     return { denied: true, matchedPattern: glob };

package/build/server.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { type SpawnSyncOptions, type SpawnSyncReturns } from "node:child_process";
 import { ContentStore } from "./store.js";
 /**
  * Parse FTS5 highlight markers to find match positions in the
@@ -46,6 +47,7 @@ export declare function buildBatchNodeOptionsPrefix(shellPath: string, preloadPa
  * record `(timed out)` blocks without skipping siblings.
  */
 export declare function runBatchCommands(commands: BatchCommand[], opts: BatchRunOptions, executor: BatchExecutor): Promise<BatchRunResult>;
+export declare function buildFetchCode(url: string, outputPath: string): string;
 /**
  * Classify an IP address.
  *   - "block":    always blocked (link-local/IMDS/multicast/reserved/malformed)
@@ -54,5 +56,25 @@ export declare function runBatchCommands(commands: BatchCommand[], opts: BatchRu
  *
  * Exported (via the function name) so SSRF tests can exercise the matcher directly.
  */
-export declare function classifyIp(ip: string): "block" | "private" | "public";
+export declare function classifyIp(rawIp: string): "block" | "private" | "public";
+export type SpawnSyncFn = (cmd: string, args: readonly string[], opts?: SpawnSyncOptions) => SpawnSyncReturns<string | Buffer>;
+export type BrowserOpenResult = {
+    ok: true;
+    method: string;
+} | {
+    ok: false;
+    method: "none";
+    reason: string;
+};
+export type KillResult = {
+    killedPids: string[];
+    attemptedPids: string[];
+    errors: string[];
+};
+export declare function browserOpenArgv(url: string, platform: NodeJS.Platform): readonly {
+    cmd: string;
+    args: readonly string[];
+}[];
+export declare function openBrowserSync(url: string, platform?: NodeJS.Platform, runner?: SpawnSyncFn): BrowserOpenResult;
+export declare function killProcessOnPort(port: number, platform?: NodeJS.Platform, runner?: SpawnSyncFn): KillResult;
 export {};