context-mode 1.0.146 → 1.0.147

package/build/session/db.d.ts

@@ -8,6 +8,42 @@
 import { SQLiteBase } from "../db-base.js";
 import type { SessionEvent } from "../types.js";
 import type { ProjectAttribution } from "./project-attribution.js";
+declare const STORAGE_ROOT_ENV: "CONTEXT_MODE_DIR";
+export type StorageDirectoryKind = "session" | "content" | "stats";
+export type StorageOverrideEnvVar = typeof STORAGE_ROOT_ENV;
+export type StorageDirectorySource = "default" | "override";
+export type IgnoredStorageOverrideReason = "empty";
+export interface ResolvedStorageDir {
+    kind: StorageDirectoryKind;
+    path: string;
+    envVar: StorageOverrideEnvVar | null;
+    source: StorageDirectorySource;
+    ignoredEnvVar?: StorageOverrideEnvVar;
+    ignoredReason?: IgnoredStorageOverrideReason;
+}
+export declare class StorageDirectoryError extends Error {
+    readonly kind: StorageDirectoryKind;
+    readonly path: string;
+    readonly overrideEnvVar: StorageOverrideEnvVar;
+    readonly ignoredEnvVar?: StorageOverrideEnvVar;
+    readonly ignoredReason?: IgnoredStorageOverrideReason;
+    constructor(kind: StorageDirectoryKind, path: string, overrideEnvVar?: StorageOverrideEnvVar, cause?: unknown, message?: string, metadata?: Pick<ResolvedStorageDir, "ignoredEnvVar" | "ignoredReason">);
+}
+export interface DefaultSessionDirOptions {
+    configDir: string;
+    configDirEnv?: string;
+    legacySessionDirEnv?: string;
+    onLegacySessionDir?: (envVar: string, dir: string) => void;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function resolveDefaultSessionDir(opts: DefaultSessionDirOptions): string;
+export declare function resolveSessionStorageDir(getDefaultDir: () => string): ResolvedStorageDir;
+export declare function resolveContentStorageDir(getSessionDir: () => string): ResolvedStorageDir;
+export declare function resolveStatsStorageDir(getDefaultSessionDir: () => string): ResolvedStorageDir;
+export declare function formatStorageDirectoryError(err: StorageDirectoryError): string;
+export declare function describeStorageDirectorySource(dir: ResolvedStorageDir): string;
+export declare function clearStorageDirectoryCheckCacheForTests(): void;
+export declare function ensureWritableStorageDir(dir: ResolvedStorageDir): string;
 export declare function normalizeWorktreePath(path: string): string;
 export declare function getWorktreeSuffix(projectDir?: string): string;
 export declare function _resetWorktreeSuffixCacheForTests(): void;
@@ -314,3 +350,4 @@ export declare class SessionDB extends SQLiteBase {
      */
     cleanupOldSessions(maxAgeDays?: number): number;
 }
+export {};

package/build/session/db.js

@@ -8,8 +8,203 @@
 import { SQLiteBase, defaultDBPath } from "../db-base.js";
 import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
-import { existsSync, realpathSync, renameSync } from "node:fs";
-import { join } from "node:path";
+import { accessSync, constants, existsSync, mkdirSync, realpathSync, renameSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+// ─────────────────────────────────────────────────────────
+// Storage root resolution
+// ─────────────────────────────────────────────────────────
+//
+// This lives beside the session DB path helpers because packaged hooks and the
+// statusline already consume `hooks/session-db.bundle.mjs` as their no-build
+// runtime bridge. Keeping the storage resolver here avoids adding a second
+// generated hook bundle just to share CONTEXT_MODE_DIR behavior.
+const STORAGE_ROOT_ENV = "CONTEXT_MODE_DIR";
+const STORAGE_SESSIONS_SUBDIR = "sessions";
+const STORAGE_CONTENT_SUBDIR = "content";
+export class StorageDirectoryError extends Error {
+    kind;
+    path;
+    overrideEnvVar;
+    ignoredEnvVar;
+    ignoredReason;
+    constructor(kind, path, overrideEnvVar = STORAGE_ROOT_ENV, cause, message, metadata = {}) {
+        super(message ?? storageDirectoryErrorMessage(kind, path, metadata), { cause });
+        this.name = "StorageDirectoryError";
+        this.kind = kind;
+        this.path = path;
+        this.overrideEnvVar = overrideEnvVar;
+        this.ignoredEnvVar = metadata.ignoredEnvVar;
+        this.ignoredReason = metadata.ignoredReason;
+    }
+}
+const writableStorageCache = new Map();
+export function resolveDefaultSessionDir(opts) {
+    const env = opts.env ?? process.env;
+    const legacyEnvVar = opts.legacySessionDirEnv;
+    const legacy = legacyEnvVar ? env[legacyEnvVar]?.trim() : undefined;
+    if (legacy && legacyEnvVar) {
+        opts.onLegacySessionDir?.(legacyEnvVar, legacy);
+        return legacy;
+    }
+    return join(resolveConfigDirForDefaultSession(opts.configDir, opts.configDirEnv, env), "context-mode", "sessions");
+}
+function resolveConfigDirForDefaultSession(configDir, configDirEnv, env) {
+    const envValue = configDirEnv ? env[configDirEnv] : undefined;
+    if (envValue && envValue.trim() !== "") {
+        return resolveConfigDirValue(envValue.trim());
+    }
+    return resolveConfigDirValue(configDir, homedir());
+}
+function resolveConfigDirValue(value, baseDir) {
+    if (value.startsWith("~"))
+        return resolve(homedir(), value.replace(/^~[/\\]?/, ""));
+    if (isAbsolute(value))
+        return resolve(value);
+    return baseDir ? resolve(baseDir, value) : resolve(value);
+}
+function invalidStorageOverride(kind, path, detail) {
+    return new StorageDirectoryError(kind, path, STORAGE_ROOT_ENV, undefined, [`Invalid ${STORAGE_ROOT_ENV} for context-mode ${kind} directory: ${detail}`, storageDirectoryHint()].join("\n"));
+}
+function storageOverrideRoot(kind) {
+    const raw = process.env[STORAGE_ROOT_ENV];
+    if (raw === undefined)
+        return { kind: "unset" };
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return { kind: "ignored-empty", ignoredEnvVar: STORAGE_ROOT_ENV, ignoredReason: "empty" };
+    }
+    if (!isAbsolute(trimmed)) {
+        throw invalidStorageOverride(kind, trimmed, `${STORAGE_ROOT_ENV} must be an absolute path.`);
+    }
+    return { kind: "override", root: resolve(trimmed) };
+}
+function ignoredStorageMetadata(root) {
+    return root.kind === "ignored-empty"
+        ? { ignoredEnvVar: root.ignoredEnvVar, ignoredReason: root.ignoredReason }
+        : {};
+}
+function overrideStorageDir(kind, subdir) {
+    const root = storageOverrideRoot(kind);
+    if (root.kind !== "override")
+        return null;
+    return {
+        kind,
+        path: join(root.root, subdir),
+        envVar: STORAGE_ROOT_ENV,
+        source: "override",
+    };
+}
+function defaultStorageDir(kind, getDefaultDir, metadata) {
+    return {
+        kind,
+        path: resolve(getDefaultDir()),
+        envVar: null,
+        source: "default",
+        ...metadata,
+    };
+}
+export function resolveSessionStorageDir(getDefaultDir) {
+    const root = storageOverrideRoot("session");
+    if (root.kind === "override") {
+        return {
+            kind: "session",
+            path: join(root.root, STORAGE_SESSIONS_SUBDIR),
+            envVar: STORAGE_ROOT_ENV,
+            source: "override",
+        };
+    }
+    return defaultStorageDir("session", getDefaultDir, ignoredStorageMetadata(root));
+}
+export function resolveContentStorageDir(getSessionDir) {
+    const override = overrideStorageDir("content", STORAGE_CONTENT_SUBDIR);
+    if (override)
+        return override;
+    const session = resolveSessionStorageDir(getSessionDir);
+    return {
+        kind: "content",
+        path: join(dirname(session.path), STORAGE_CONTENT_SUBDIR),
+        envVar: session.envVar,
+        source: session.source,
+        ignoredEnvVar: session.ignoredEnvVar,
+        ignoredReason: session.ignoredReason,
+    };
+}
+export function resolveStatsStorageDir(getDefaultSessionDir) {
+    const override = overrideStorageDir("stats", STORAGE_SESSIONS_SUBDIR);
+    if (override)
+        return override;
+    const session = resolveSessionStorageDir(getDefaultSessionDir);
+    return {
+        kind: "stats",
+        path: session.path,
+        envVar: session.envVar,
+        source: session.source,
+        ignoredEnvVar: session.ignoredEnvVar,
+        ignoredReason: session.ignoredReason,
+    };
+}
+export function formatStorageDirectoryError(err) {
+    return err.message;
+}
+export function describeStorageDirectorySource(dir) {
+    if (dir.source === "override" && dir.envVar)
+        return `via ${dir.envVar}`;
+    if (dir.ignoredEnvVar && dir.ignoredReason === "empty")
+        return `default; ignored empty ${dir.ignoredEnvVar}`;
+    return "default";
+}
+export function clearStorageDirectoryCheckCacheForTests() {
+    writableStorageCache.clear();
+}
+export function ensureWritableStorageDir(dir) {
+    const key = [
+        dir.kind,
+        dir.path,
+        dir.source,
+        dir.envVar ?? "",
+        dir.ignoredEnvVar ?? "",
+        dir.ignoredReason ?? "",
+    ].join("\0");
+    const cached = writableStorageCache.get(key);
+    if (cached instanceof StorageDirectoryError)
+        throw cached;
+    if (cached === dir.path)
+        return cached;
+    try {
+        mkdirSync(dir.path, { recursive: true });
+        accessSync(dir.path, constants.W_OK);
+        writableStorageCache.set(key, dir.path);
+        return dir.path;
+    }
+    catch (err) {
+        const storageErr = new StorageDirectoryError(dir.kind, pathFromStorageError(err) ?? dir.path, STORAGE_ROOT_ENV, err, undefined, { ignoredEnvVar: dir.ignoredEnvVar, ignoredReason: dir.ignoredReason });
+        writableStorageCache.set(key, storageErr);
+        throw storageErr;
+    }
+}
+function storageDirectoryErrorMessage(kind, path, metadata = {}) {
+    return [
+        `context-mode ${kind} directory is not writable: ${path}`,
+        ignoredStorageOverrideHint(metadata),
+        storageDirectoryHint(),
+    ].filter(Boolean).join("\n");
+}
+function ignoredStorageOverrideHint(metadata) {
+    if (metadata.ignoredEnvVar && metadata.ignoredReason === "empty") {
+        return `Ignored empty ${metadata.ignoredEnvVar}; using adapter default.`;
+    }
+    return null;
+}
+function storageDirectoryHint() {
+    return `Set ${STORAGE_ROOT_ENV} to a writable absolute path.`;
+}
+function pathFromStorageError(err) {
+    if (!err || typeof err !== "object")
+        return null;
+    const path = err.path;
+    return typeof path === "string" && path.length > 0 ? path : null;
+}
 // ─────────────────────────────────────────────────────────
 // Worktree isolation
 // ─────────────────────────────────────────────────────────

package/build/session/extract.js

@@ -19,6 +19,22 @@ function safeStringAny(value) {
 }
 function isToolError(input) {
     const response = String(input.tool_response ?? "");
+    // PreToolUse rewrites curl/wget/inline-HTTP/WebFetch commands into
+    //   echo "context-mode: <guidance text including 'retry', 'fails', 'error'>"
+    // The user-facing copy legitimately mentions failure modes ("retry if it
+    // fails with a transient DNS error"), but those words must NOT classify
+    // our OWN guidance message as a tool error or it gets captured into
+    // session_resume and surfaces as a fake error in the next chat.
+    // We check BOTH sides because:
+    //   - real shell run → response starts with `context-mode:` (echo stdout)
+    //   - test/captured-output path → response is the raw command itself
+    //     (`echo "context-mode: …"`), so we also match the command shape
+    const command = String(input.tool_input?.command ?? "");
+    if (response.startsWith("context-mode:") ||
+        command.startsWith('echo "context-mode:') ||
+        command.startsWith("echo 'context-mode:")) {
+        return false;
+    }
     const isErrorFlag = input.tool_output?.isError === true || input.tool_output?.is_error === true;
     const isBashError = input.tool_name === "Bash" &&
         /exit code [1-9]|error:|Error:|FAIL|failed/i.test(response);

package/build/truncate.d.ts

@@ -5,6 +5,21 @@
  * SessionDB (snapshot building). They are extracted here so any
  * consumer can import them without pulling in the full store or executor.
  */
+/**
+ * Return a prefix of `str` no longer than `maxChars` UTF-16 code units, with
+ * the cut backed off by one unit if it would split a surrogate pair. Mirrors
+ * the surrogate-safety semantics of the internal `byteSafePrefix`, but uses
+ * a character budget rather than a byte budget.
+ *
+ * Use this instead of bare `str.slice(0, n)` whenever the result is later
+ * JSON-encoded for an RFC 8259-strict consumer (e.g. tool_result payloads
+ * sent back to the host LLM API). `JSON.stringify` will emit a lone high
+ * surrogate as a literal `\uD8xx` escape, which is invalid JSON.
+ *
+ * @param str      - Input string.
+ * @param maxChars - Hard cap in UTF-16 code units.
+ */
+export declare function charSafePrefix(str: string, maxChars: number): string;
 /**
  * Serialize a value to JSON, then truncate the result to `maxBytes` bytes.
  * If truncation occurs, the string is cut at a UTF-8-safe boundary and

package/build/truncate.js

@@ -43,6 +43,34 @@ function byteSafePrefix(str, maxBytes) {
     return str.slice(0, lo);
 }
 // ─────────────────────────────────────────────────────────
+// Char-count prefix (UTF-16 surrogate-safe)
+// ─────────────────────────────────────────────────────────
+/**
+ * Return a prefix of `str` no longer than `maxChars` UTF-16 code units, with
+ * the cut backed off by one unit if it would split a surrogate pair. Mirrors
+ * the surrogate-safety semantics of the internal `byteSafePrefix`, but uses
+ * a character budget rather than a byte budget.
+ *
+ * Use this instead of bare `str.slice(0, n)` whenever the result is later
+ * JSON-encoded for an RFC 8259-strict consumer (e.g. tool_result payloads
+ * sent back to the host LLM API). `JSON.stringify` will emit a lone high
+ * surrogate as a literal `\uD8xx` escape, which is invalid JSON.
+ *
+ * @param str      - Input string.
+ * @param maxChars - Hard cap in UTF-16 code units.
+ */
+export function charSafePrefix(str, maxChars) {
+    if (maxChars <= 0)
+        return "";
+    if (str.length <= maxChars)
+        return str;
+    let end = maxChars;
+    const code = str.charCodeAt(end - 1);
+    if (code >= 0xd800 && code <= 0xdbff)
+        end -= 1;
+    return str.slice(0, end);
+}
+// ─────────────────────────────────────────────────────────
 // JSON truncation
 // ─────────────────────────────────────────────────────────
 /**