killeros 2.1.29 → 2.1.31

package/killeros/runtime.ts

@@ -1,150 +1,150 @@
-export type GoalStatus = "active" | "paused" | "blocked" | "complete";
-
-export type GoalTurnPhase = "ready" | "in-flight" | "authorized";
-
-export interface GoalContinueReport {
-  turn: number;
-  evidence: string;
-  nextAction: string;
-}
-
-export type GoalTurnDecision =
-  | {
-      kind: "continue";
-      turn: number;
-      evidence: string;
-      nextAction: string;
-    }
-  | {
-      kind: "blocker-audit";
-      turn: number;
-      blockerKey: string;
-      streak: number;
-      evidence: string;
-    }
-  | {
-      kind: "blocked";
-      turn: number;
-      blockerKey: string;
-      streak: 3;
-      evidence: string;
-    }
-  | {
-      kind: "complete";
-      turn: number;
-      evidence: string;
-      verification: "file" | "model-reported";
-    };
-
-export type GoalPendingDecision = Extract<GoalTurnDecision, { kind: "continue" | "blocker-audit" }>;
-
-export interface GoalBlockerAudit {
-  key: string;
-  streak: number;
-  lastTurn: number;
-  evidence?: string;
-}
-
-export type GoalFileBaseline =
-  | { exists: false }
-  | { exists: true; size: number; mtimeMs: number; contentHash?: string | null };
-
-export interface GoalFileVerification {
-  kind: "file";
-  path: string;
-  baseline: GoalFileBaseline;
-}
-
-export interface GoalStateCommon {
-  version: 1;
-  revision: number;
-  objective: string;
-  createdAt: number;
-  updatedAt: number;
-  activeMilliseconds: number;
-  turns: number;
-  blockedAuditStartTurn: number;
-  baselineTokens: number;
-  verification?: GoalFileVerification;
-  maxTurns?: number;
-  turnPhase?: GoalTurnPhase;
-  turnDecision?: GoalPendingDecision;
-  lastDecision?: GoalTurnDecision;
-  lastContinueReport?: GoalContinueReport;
-  stopReason?: string;
-}
-
-export type GoalState = GoalStateCommon & (
-  | {
-      status: "active";
-      activeStartedAt: number;
-      result?: string;
-      blockerAudit?: GoalBlockerAudit;
-      resumeAfterManualCompaction?: never;
-    }
-  | {
-      status: "paused";
-      activeStartedAt?: never;
-      result?: string;
-      blockerAudit?: GoalBlockerAudit;
-      resumeAfterManualCompaction?: true;
-    }
-  | {
-      status: "blocked";
-      activeStartedAt?: never;
-      result: string;
-      blockerAudit?: GoalBlockerAudit;
-      resumeAfterManualCompaction?: never;
-    }
-  | {
-      status: "complete";
-      activeStartedAt?: never;
-      result: string;
-      blockerAudit?: never;
-      resumeAfterManualCompaction?: never;
-    }
-);
-
-/** Pi request outcomes for goal recovery: awaiting result, compacted, or rejected as session-too-small. */
-export type AutomaticGoalCompactionOutcome = "pending" | "completed" | "skipped";
-
-export interface AutomaticGoalCompaction {
-  pausedRevision: number;
-  outcome: AutomaticGoalCompactionOutcome;
-  turnSettled: boolean;
-  turn: number;
-  resumeSameTurn: boolean;
-}
-
-export interface GoalTurnExecution {
-  turn: number;
-  revision: number;
-}
-
-export interface GoalRuntime {
-  state?: GoalState;
-  continuationScheduled: boolean;
-  continuationHeld: boolean;
-  goalTurnInFlight: boolean;
-  agentEndObserved: boolean;
-  goalTurn?: GoalTurnExecution;
-  automaticCompaction?: AutomaticGoalCompaction;
-  persistenceRetryNeeded: boolean;
-  lastStopReason?: string;
-  lastError?: string;
-  lifecycleGeneration: number;
-  requestRender?: () => void;
-}
-
-export function createGoalRuntime(): GoalRuntime {
-  return {
-    continuationScheduled: false,
-    continuationHeld: false,
-    goalTurnInFlight: false,
-    agentEndObserved: false,
-    goalTurn: undefined,
-    automaticCompaction: undefined,
-    persistenceRetryNeeded: false,
-    lifecycleGeneration: 0,
-  };
-}
+export type GoalStatus = "active" | "paused" | "blocked" | "complete";
+
+export type GoalTurnPhase = "ready" | "in-flight" | "authorized";
+
+export interface GoalContinueReport {
+  turn: number;
+  evidence: string;
+  nextAction: string;
+}
+
+export type GoalTurnDecision =
+  | {
+      kind: "continue";
+      turn: number;
+      evidence: string;
+      nextAction: string;
+    }
+  | {
+      kind: "blocker-audit";
+      turn: number;
+      blockerKey: string;
+      streak: number;
+      evidence: string;
+    }
+  | {
+      kind: "blocked";
+      turn: number;
+      blockerKey: string;
+      streak: 3;
+      evidence: string;
+    }
+  | {
+      kind: "complete";
+      turn: number;
+      evidence: string;
+      verification: "file" | "model-reported";
+    };
+
+export type GoalPendingDecision = Extract<GoalTurnDecision, { kind: "continue" | "blocker-audit" }>;
+
+export interface GoalBlockerAudit {
+  key: string;
+  streak: number;
+  lastTurn: number;
+  evidence?: string;
+}
+
+export type GoalFileBaseline =
+  | { exists: false }
+  | { exists: true; size: number; mtimeMs: number; contentHash?: string | null };
+
+export interface GoalFileVerification {
+  kind: "file";
+  path: string;
+  baseline: GoalFileBaseline;
+}
+
+export interface GoalStateCommon {
+  version: 1;
+  revision: number;
+  objective: string;
+  createdAt: number;
+  updatedAt: number;
+  activeMilliseconds: number;
+  turns: number;
+  blockedAuditStartTurn: number;
+  baselineTokens: number;
+  verification?: GoalFileVerification;
+  maxTurns?: number;
+  turnPhase?: GoalTurnPhase;
+  turnDecision?: GoalPendingDecision;
+  lastDecision?: GoalTurnDecision;
+  lastContinueReport?: GoalContinueReport;
+  stopReason?: string;
+}
+
+export type GoalState = GoalStateCommon & (
+  | {
+      status: "active";
+      activeStartedAt: number;
+      result?: string;
+      blockerAudit?: GoalBlockerAudit;
+      resumeAfterManualCompaction?: never;
+    }
+  | {
+      status: "paused";
+      activeStartedAt?: never;
+      result?: string;
+      blockerAudit?: GoalBlockerAudit;
+      resumeAfterManualCompaction?: true;
+    }
+  | {
+      status: "blocked";
+      activeStartedAt?: never;
+      result: string;
+      blockerAudit?: GoalBlockerAudit;
+      resumeAfterManualCompaction?: never;
+    }
+  | {
+      status: "complete";
+      activeStartedAt?: never;
+      result: string;
+      blockerAudit?: never;
+      resumeAfterManualCompaction?: never;
+    }
+);
+
+/** Pi request outcomes for goal recovery: awaiting result, compacted, or rejected as session-too-small. */
+export type AutomaticGoalCompactionOutcome = "pending" | "completed" | "skipped";
+
+export interface AutomaticGoalCompaction {
+  pausedRevision: number;
+  outcome: AutomaticGoalCompactionOutcome;
+  turnSettled: boolean;
+  turn: number;
+  resumeSameTurn: boolean;
+}
+
+export interface GoalTurnExecution {
+  turn: number;
+  revision: number;
+}
+
+export interface GoalRuntime {
+  state?: GoalState;
+  continuationScheduled: boolean;
+  continuationHeld: boolean;
+  goalTurnInFlight: boolean;
+  agentEndObserved: boolean;
+  goalTurn?: GoalTurnExecution;
+  automaticCompaction?: AutomaticGoalCompaction;
+  persistenceRetryNeeded: boolean;
+  lastStopReason?: string;
+  lastError?: string;
+  lifecycleGeneration: number;
+  requestRender?: () => void;
+}
+
+export function createGoalRuntime(): GoalRuntime {
+  return {
+    continuationScheduled: false,
+    continuationHeld: false,
+    goalTurnInFlight: false,
+    agentEndObserved: false,
+    goalTurn: undefined,
+    automaticCompaction: undefined,
+    persistenceRetryNeeded: false,
+    lifecycleGeneration: 0,
+  };
+}

package/killeros/secret-detector.ts

@@ -1,19 +1,19 @@
-const SECRET_PATTERNS = [
-  /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----/u,
-  /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/u,
-  /\bAIza[0-9A-Za-z_-]{35}\b/u,
-  /\bgh(?:p|o|u|s|r)_[A-Za-z0-9]{36,255}\b/u,
-  /\bgithub_pat_[A-Za-z0-9_]{20,255}\b/u,
-  /\bglpat-[A-Za-z0-9_-]{20,255}\b/u,
-  /\bnpm_[A-Za-z0-9]{20,255}\b/u,
-  /\bsk-(?:ant-|proj-|svcacct-)?[A-Za-z0-9_-]{20,255}\b/u,
-  /\bsk_live_[A-Za-z0-9]{16,255}\b/u,
-  /\bxox[baprs]-[A-Za-z0-9-]{10,255}\b/u,
-  /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]+:[^/\s@]+@/iu,
-  /^[\t ]*["']?[\w.-]*(?:api_key|apikey|password|passwd|secret|token)[\w.-]*["']?[\t ]*(?:=|:)[\t ]*(?:"[^"\r\n]+"|'[^'\r\n]+'|[^\s#][^\r\n]*)/imu,
-] as const;
-
-/** Detects high-confidence credential material without returning the matched value. */
-export function containsLikelySecret(text: string): boolean {
-  return SECRET_PATTERNS.some((pattern) => pattern.test(text));
-}
+const SECRET_PATTERNS = [
+  /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----/u,
+  /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/u,
+  /\bAIza[0-9A-Za-z_-]{35}\b/u,
+  /\bgh(?:p|o|u|s|r)_[A-Za-z0-9]{36,255}\b/u,
+  /\bgithub_pat_[A-Za-z0-9_]{20,255}\b/u,
+  /\bglpat-[A-Za-z0-9_-]{20,255}\b/u,
+  /\bnpm_[A-Za-z0-9]{20,255}\b/u,
+  /\bsk-(?:ant-|proj-|svcacct-)?[A-Za-z0-9_-]{20,255}\b/u,
+  /\bsk_live_[A-Za-z0-9]{16,255}\b/u,
+  /\bxox[baprs]-[A-Za-z0-9-]{10,255}\b/u,
+  /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]+:[^/\s@]+@/iu,
+  /^[\t ]*["']?[\w.-]*(?:api_key|apikey|password|passwd|secret|token)[\w.-]*["']?[\t ]*(?:=|:)[\t ]*(?:"[^"\r\n]+"|'[^'\r\n]+'|[^\s#][^\r\n]*)/imu,
+] as const;
+
+/** Detects high-confidence credential material without returning the matched value. */
+export function containsLikelySecret(text: string): boolean {
+  return SECRET_PATTERNS.some((pattern) => pattern.test(text));
+}

package/killeros/settings.ts

@@ -1,50 +1,141 @@
-import { randomUUID } from "node:crypto";
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { hasErrorCode } from "./errors.ts";
-
-export type KillerosSettings = Record<string, unknown>;
-
-export interface KillerosSettingsStore {
-  load(): KillerosSettings;
-  update(patch: Readonly<Record<string, unknown>>): void;
-}
-
-function isSettings(value: unknown): value is KillerosSettings {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function readStoredSettings(settingsPath: string): KillerosSettings {
-  try {
-    const parsed: unknown = JSON.parse(readFileSync(settingsPath, "utf8"));
-    if (!isSettings(parsed)) throw new Error("KillerOS settings must contain a JSON object");
-    return parsed;
-  } catch (error) {
-    if (hasErrorCode(error, "ENOENT")) return {};
-    throw error;
-  }
-}
-
-export function createKillerosSettingsStore(
-  settingsPath = join(getAgentDir(), "killeros.json"),
-): KillerosSettingsStore {
-  return {
-    load: () => readStoredSettings(settingsPath),
-    update: (patch) => {
-      const current = readStoredSettings(settingsPath);
-      mkdirSync(dirname(settingsPath), { recursive: true });
-      const temporaryPath = `${settingsPath}.${process.pid}.${randomUUID()}.tmp`;
-      try {
-        writeFileSync(
-          temporaryPath,
-          `${JSON.stringify({ ...current, ...patch }, null, 2)}\n`,
-          { encoding: "utf8", mode: 0o600 },
-        );
-        renameSync(temporaryPath, settingsPath);
-      } finally {
-        rmSync(temporaryPath, { force: true });
-      }
-    },
-  };
-}
+import { randomUUID } from "node:crypto";
+import { linkSync, mkdirSync, readFileSync, renameSync, rmdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { hasErrorCode } from "./errors.ts";
+
+export type KillerosSettings = Record<string, unknown>;
+
+export interface KillerosSettingsStore {
+  load(): KillerosSettings;
+  update(patch: Readonly<Record<string, unknown>>): void;
+}
+
+function isSettings(value: unknown): value is KillerosSettings {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readStoredSettings(settingsPath: string): KillerosSettings {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(settingsPath, "utf8"));
+    if (!isSettings(parsed)) throw new Error("KillerOS settings must contain a JSON object");
+    return parsed;
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) return {};
+    throw error;
+  }
+}
+
+const LOCK_RETRY_MILLISECONDS = 10;
+const LOCK_TIMEOUT_MILLISECONDS = 10_000;
+
+function readLockOwnerPid(lockPath: string): number | undefined {
+  try {
+    const value: unknown = JSON.parse(readFileSync(lockPath, "utf8"));
+    if (!isSettings(value) || typeof value.pid !== "number" || !Number.isSafeInteger(value.pid) || value.pid <= 0) return undefined;
+    return value.pid;
+  } catch {
+    return undefined;
+  }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !hasErrorCode(error, "ESRCH");
+  }
+}
+
+function moveLockAside(lockPath: string): boolean {
+  const stalePath = `${lockPath}.${process.pid}.${randomUUID()}.stale`;
+  const deadline = Date.now() + LOCK_TIMEOUT_MILLISECONDS;
+  while (true) {
+    try {
+      renameSync(lockPath, stalePath);
+      break;
+    } catch (error) {
+      if (hasErrorCode(error, "ENOENT")) return false;
+      if (
+        Date.now() >= deadline
+        || !["EACCES", "EBUSY", "EPERM"].some((code) => hasErrorCode(error, code))
+      ) throw error;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_RETRY_MILLISECONDS);
+    }
+  }
+  rmSync(stalePath, { force: true });
+  return true;
+}
+
+function recoverSettingsLock(lockPath: string, expectedPid: number): boolean {
+  const recoveryPath = `${lockPath}.recovery`;
+  try {
+    mkdirSync(recoveryPath);
+  } catch (error) {
+    if (hasErrorCode(error, "EEXIST")) return false;
+    throw error;
+  }
+  try {
+    // Recheck under exclusive recovery ownership; another waiter may have replaced the lock.
+    return readLockOwnerPid(lockPath) === expectedPid && !isProcessRunning(expectedPid) && moveLockAside(lockPath);
+  } finally {
+    // ponytail: a crash during recovery leaves .recovery for manual removal; never steal it and risk lost writes.
+    rmdirSync(recoveryPath);
+  }
+}
+
+function acquireSettingsLock(settingsPath: string): () => void {
+  const lockPath = `${settingsPath}.lock`;
+  const ownerPath = `${lockPath}.${process.pid}.${randomUUID()}.tmp`;
+  const deadline = Date.now() + LOCK_TIMEOUT_MILLISECONDS;
+  writeFileSync(ownerPath, JSON.stringify({ pid: process.pid }), { encoding: "utf8", mode: 0o600, flag: "wx" });
+  try {
+    while (true) {
+      try {
+        linkSync(ownerPath, lockPath);
+        break;
+      } catch (error) {
+        if (!hasErrorCode(error, "EEXIST")) throw error;
+        const currentOwnerPid = readLockOwnerPid(lockPath);
+        if (currentOwnerPid && !isProcessRunning(currentOwnerPid) && recoverSettingsLock(lockPath, currentOwnerPid)) continue;
+        if (Date.now() >= deadline) throw new Error(`Timed out waiting for KillerOS settings lock: ${lockPath}`);
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_RETRY_MILLISECONDS);
+      }
+    }
+  } finally {
+    rmSync(ownerPath, { force: true });
+  }
+
+  return () => {
+    moveLockAside(lockPath);
+  };
+}
+
+export function createKillerosSettingsStore(
+  settingsPath = join(getAgentDir(), "killeros.json"),
+): KillerosSettingsStore {
+  return {
+    load: () => readStoredSettings(settingsPath),
+    update: (patch) => {
+      mkdirSync(dirname(settingsPath), { recursive: true });
+      const releaseLock = acquireSettingsLock(settingsPath);
+      const temporaryPath = `${settingsPath}.${process.pid}.${randomUUID()}.tmp`;
+      try {
+        const current = readStoredSettings(settingsPath);
+        writeFileSync(
+          temporaryPath,
+          `${JSON.stringify({ ...current, ...patch }, null, 2)}\n`,
+          { encoding: "utf8", mode: 0o600 },
+        );
+        renameSync(temporaryPath, settingsPath);
+      } finally {
+        try {
+          rmSync(temporaryPath, { force: true });
+        } finally {
+          releaseLock();
+        }
+      }
+    },
+  };
+}