pi-kimi-keepalive 0.3.1 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-kimi-keepalive",
-  "version": "0.3.1",
+  "version": "0.3.4",
   "description": "Prompt-cache keepalive for Kimi (kimi-coding) sessions in the Pi coding agent. Replays the last real provider request while idle so the automatic prefix cache never expires.",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -51,7 +51,10 @@ import {
 
 const STATE_DIR = join(homedir(), ".pi", "cache-keepalive");
 const STATE_FILE = join(STATE_DIR, "state.json");
-const AUTH_FILE = join(process.env.PI_AGENT_DIR ?? join(homedir(), ".pi", "agent"), "auth.json");
+/** Live OAuth state; resolved lazily so tests can redirect it via PI_AGENT_DIR. */
+function authFile(): string {
+  return join(process.env.PI_AGENT_DIR ?? join(homedir(), ".pi", "agent"), "auth.json");
+}
 
 interface PersistedConfig {
   enabled: boolean;
@@ -202,7 +205,7 @@ export default function (pi: ExtensionAPI) {
         maxMissStreak: int(raw.maxMissStreak, DEFAULT_CONFIG.maxMissStreak, 1),
         maxErrorStreak: int(raw.maxErrorStreak, DEFAULT_CONFIG.maxErrorStreak, 1),
         mode: raw.mode === "smart" ? "smart" : "default",
-          initialized: raw.initialized === true,
+        initialized: raw.initialized === true,
       };
     } catch {
       config = { ...DEFAULT_CONFIG };
@@ -233,8 +236,10 @@ export default function (pi: ExtensionAPI) {
     }
 
     const confirmNext = await wizardCtx.ui.confirm(
-      "pi-kimi-keepalive — first-time setup",
-      "Set the keepalive guardrails. Press Esc at any prompt to keep the default. " +
+      opts.firstRun
+        ? "pi-kimi-keepalive — first-time setup"
+        : "pi-kimi-keepalive — reconfigure",
+      "Set the keepalive guardrails. Press Esc at any prompt to keep the current value. " +
         "All values are saved to ~/.pi/cache-keepalive/state.json and can be changed later " +
         "via /keepalive <setting>.",
     );
@@ -471,22 +476,26 @@ export default function (pi: ExtensionAPI) {
    */
   function probeHeaders(): Record<string, string> | null {
     if (!capture) return null;
-    const headers = buildProbeHeaders(capture.headers);
-    if (!headers.authorization) {
-      try {
-        const raw = JSON.parse(readFileSync(AUTH_FILE, "utf8")) as Record<string, unknown>;
-        const entry = (raw["kimi-coding"] ?? null) as { access?: unknown } | null;
-        if (entry && typeof entry.access === "string" && entry.access.length > 0) {
-          headers.authorization = `Bearer ${entry.access}`;
-        } else {
-          debug(`no kimi-coding access token in ${AUTH_FILE}`);
-        }
-      } catch (error) {
-        debug(`auth.json unavailable: ${error instanceof Error ? error.message : String(error)}`);
+    // Prefer the live token from auth.json: pi refreshes it there on real
+    // requests, while captured request headers freeze the token from capture
+    // time — hours later that Bearer can already be expired (HTTP 401).
+    // Fall back to the captured headers when auth.json is unavailable.
+    try {
+      const raw = JSON.parse(readFileSync(authFile(), "utf8")) as Record<string, unknown>;
+      const entry = (raw["kimi-coding"] ?? null) as { access?: unknown } | null;
+      if (entry && typeof entry.access === "string" && entry.access.length > 0) {
+        const headers = buildProbeHeaders(capture.headers);
+        headers.authorization = `Bearer ${entry.access}`;
+        return headers;
       }
+      debug(`no kimi-coding access token in ${authFile()}`);
+    } catch (error) {
+      debug(
+        `auth.json unavailable (${error instanceof Error ? error.message : String(error)}) — falling back to captured headers`,
+      );
     }
-    if (!headers.authorization) return null;
-    return headers;
+    const headers = buildProbeHeaders(capture.headers);
+    return headers.authorization ? headers : null;
   }
 
   async function runProbe(): Promise<boolean> {
@@ -670,6 +679,11 @@ export default function (pi: ExtensionAPI) {
     errorStreak += 1;
     debug("probe failed:", message);
     if (/^HTTP 40[13]\b/.test(message)) {
+      // Credentials are dead regardless of history; clear the streaks so the
+      // automatic recovery after the next real turn starts from a clean slate.
+      missStreak = 0;
+      errorStreak = 0;
+      smartHitStreak = 0;
       pause("captured credentials rejected; will recapture after your next real turn");
       return;
     }
@@ -843,6 +857,7 @@ export default function (pi: ExtensionAPI) {
               notify("usage: /keepalive maxidle=30m (0 disables the cutoff)", "error");
               break;
             }
+            config.maxIdleMs = ms;
             persistConfig();
             notify(ms === 0 ? "maxidle disabled — probing continues while idle" : `maxidle set to ${formatDuration(ms)}`, "info");
             break;
@@ -944,8 +959,23 @@ export default function (pi: ExtensionAPI) {
     const raw = payload as Record<string, unknown>;
     if (!Array.isArray(raw.messages) || raw.messages.length === 0) return;
     if (raw.system !== undefined && !Array.isArray(raw.system) && typeof raw.system !== "string") return;
+    let clonedPayload: Record<string, unknown>;
+    try {
+      clonedPayload = structuredClone(raw);
+    } catch {
+      // DataCloneError: the payload carries non-cloneable values (BigInt,
+      // symbols, functions). Fall back to a JSON round-trip; probing never
+      // mutates the captured payload, so a by-reference capture is the last
+      // resort rather than failing the real request.
+      try {
+        clonedPayload = JSON.parse(JSON.stringify(raw)) as Record<string, unknown>;
+      } catch {
+        debug("payload not cloneable — capturing by reference");
+        clonedPayload = raw;
+      }
+    }
     capture = {
-      payload: structuredClone(raw),
+      payload: clonedPayload,
       headers: capturedHeaders,
       provider: model.provider,
       api: (model as { api?: string }).api,