@wrongstack/core 0.296.4 → 0.298.0

package/dist/chronicle/index.js

@@ -675,6 +675,9 @@ import * as fs3 from "node:fs/promises";
 import * as path6 from "node:path";
 import { createInterface } from "node:readline";
 
+// src/security/file-permissions.ts
+var SECRET_FILE_MODE = 384;
+
 // src/utils/atomic-write.ts
 import {
   createPersistencePrimitives
@@ -853,7 +856,16 @@ var ChronicleJournal = class {
   drainPromise;
   drainScheduled = false;
   drainTimer;
-  counters = { acceptedEvents: 0, persistedEvents: 0, rejectedEvents: 0, failedEvents: 0, batches: 0, maxObservedPending: 0, largestBatch: 0, partitionRolls: 0 };
+  counters = {
+    acceptedEvents: 0,
+    persistedEvents: 0,
+    rejectedEvents: 0,
+    failedEvents: 0,
+    batches: 0,
+    maxObservedPending: 0,
+    largestBatch: 0,
+    partitionRolls: 0
+  };
   lastBatchDurationMs;
   partitionIndex = 0;
   partitionStartedAt;
@@ -879,18 +891,27 @@ var ChronicleJournal = class {
     return this.partitionIndex === 0 ? this.basePath : rotatedPath(this.basePath, this.partitionIndex);
   }
   stats() {
-    return { ...this.counters, pendingEvents: this.pending.length, ...this.lastBatchDurationMs !== void 0 ? { lastBatchDurationMs: this.lastBatchDurationMs } : {} };
+    return {
+      ...this.counters,
+      pendingEvents: this.pending.length,
+      ...this.lastBatchDurationMs !== void 0 ? { lastBatchDurationMs: this.lastBatchDurationMs } : {}
+    };
   }
   append(input) {
     if (this.pending.length >= this.maxPending) {
       this.counters.rejectedEvents++;
-      return Promise.reject(new Error(`Chronicle backpressure limit reached (${this.maxPending} pending events)`));
+      return Promise.reject(
+        new Error(`Chronicle backpressure limit reached (${this.maxPending} pending events)`)
+      );
     }
     const promise = new Promise((resolve12, reject) => {
       this.pending.push({ input, resolve: resolve12, reject });
     });
     this.counters.acceptedEvents++;
-    this.counters.maxObservedPending = Math.max(this.counters.maxObservedPending, this.pending.length);
+    this.counters.maxObservedPending = Math.max(
+      this.counters.maxObservedPending,
+      this.pending.length
+    );
     this.scheduleDrain();
     return promise;
   }
@@ -916,7 +937,8 @@ var ChronicleJournal = class {
     await this.flush();
     const files = await collectPartitions(this.basePath);
     const checkpointResult = await readRetentionCheckpoint(this.basePath);
-    if (checkpointResult.error) return { ok: false, entries: 0, brokenAt: 0, reason: checkpointResult.error };
+    if (checkpointResult.error)
+      return { ok: false, entries: 0, brokenAt: 0, reason: checkpointResult.error };
     return verifyPartitionFiles(files, checkpointResult.checkpoint);
   }
   async purge(options) {
@@ -934,7 +956,10 @@ var ChronicleJournal = class {
     for (const suppliedPath of new Set(suppliedFiles)) {
       const file = path6.resolve(suppliedPath);
       if (!isJournalPartition(file, path6.dirname(this.basePath), this.basePath)) {
-        errors.push({ file: suppliedPath, reason: "not a Chronicle journal partition in this journal directory" });
+        errors.push({
+          file: suppliedPath,
+          reason: "not a Chronicle journal partition in this journal directory"
+        });
         sc++;
         continue;
       }
@@ -983,8 +1008,12 @@ var ChronicleJournal = class {
             const checkpointResult = await readRetentionCheckpoint(familyBase);
             if (checkpointResult.error) throw new Error(checkpointResult.error);
             const checkpoint = checkpointResult.checkpoint;
-            const nextCheckpoint = await verifyRetainedPrefix(streamEntriesStrict(file), checkpoint);
-            if (!nextCheckpoint) throw new Error("partition does not extend the trusted Chronicle chain");
+            const nextCheckpoint = await verifyRetainedPrefix(
+              streamEntriesStrict(file),
+              checkpoint
+            );
+            if (!nextCheckpoint)
+              throw new Error("partition does not extend the trusted Chronicle chain");
             if (nextCheckpoint.sequence > (checkpoint?.sequence ?? 0)) {
               await writeRetentionCheckpoint(familyBase, nextCheckpoint);
             }
@@ -1004,7 +1033,13 @@ var ChronicleJournal = class {
         }
       }
     }
-    return { deletedCount: dc, deletedBytes: db, skippedCount: sc, errors, ...options.dryRun ? { candidates } : {} };
+    return {
+      deletedCount: dc,
+      deletedBytes: db,
+      skippedCount: sc,
+      errors,
+      ...options.dryRun ? { candidates } : {}
+    };
   }
   async maybeAutoPurge() {
     if (this.retentionDays <= 0) return;
@@ -1080,7 +1115,8 @@ var ChronicleJournal = class {
       this.rotate();
       return;
     }
-    if (Number.isFinite(this.maxPartitionSizeBytes) && this.partitionSizeBytes >= this.maxPartitionSizeBytes) this.rotate();
+    if (Number.isFinite(this.maxPartitionSizeBytes) && this.partitionSizeBytes >= this.maxPartitionSizeBytes)
+      this.rotate();
   }
   rotate() {
     this.partitionIndex++;
@@ -1101,13 +1137,23 @@ var ChronicleJournal = class {
         let prev = this.lastSequence > 0 ? { sequence: this.lastSequence, hash: this.lastHash } : void 0;
         recorded = batch.map(({ input }) => {
           const instant = this.now().toISOString();
-          const uh = { ...input, occurredAt: input.occurredAt ?? instant, monotonicNs: input.monotonicNs ?? this.monotonicNow().toString(), schemaVersion: CHRONICLE_SCHEMA_VERSION, eventId: this.idFactory(), observedAt: instant, persistedAt: instant, sequence: (prev?.sequence ?? 0) + 1, previousHash: prev?.hash ?? GENESIS_HASH };
+          const uh = {
+            ...input,
+            occurredAt: input.occurredAt ?? instant,
+            monotonicNs: input.monotonicNs ?? this.monotonicNow().toString(),
+            schemaVersion: CHRONICLE_SCHEMA_VERSION,
+            eventId: this.idFactory(),
+            observedAt: instant,
+            persistedAt: instant,
+            sequence: (prev?.sequence ?? 0) + 1,
+            previousHash: prev?.hash ?? GENESIS_HASH
+          };
           const event = { ...uh, hash: hashValue(uh) };
           prev = event;
           return event;
         });
         const serialized = recorded.map((e) => JSON.stringify(e)).join("\n") + "\n";
-        await fs3.appendFile(cp, serialized, "utf8");
+        await fs3.appendFile(cp, serialized, { encoding: "utf8", mode: SECRET_FILE_MODE });
         this.partitionSizeBytes += Buffer.byteLength(serialized);
       });
       const last = recorded[recorded.length - 1];
@@ -1143,7 +1189,8 @@ async function collectPartitions(basePath) {
   const result = [];
   try {
     const entries = await fs3.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) if (entry.isFile() && pattern.test(entry.name)) result.push(path6.join(dir, entry.name));
+    for (const entry of entries)
+      if (entry.isFile() && pattern.test(entry.name)) result.push(path6.join(dir, entry.name));
   } catch {
   }
   const baseFile = path6.join(dir, base + ext);
@@ -1218,23 +1265,42 @@ async function verifyPartitionFiles(files, checkpoint) {
       for await (const entry of streamEntriesStrict(file)) {
         const { hash: recordedHash, ...content } = entry;
         if (entry.sequence <= checkpointSequence) {
-          if (hashValue(content) !== recordedHash) return { ok: false, entries, brokenAt: entries, reason: "entry hash mismatch" };
+          if (hashValue(content) !== recordedHash)
+            return { ok: false, entries, brokenAt: entries, reason: "entry hash mismatch" };
           if (coveredPrevious && entry.sequence !== coveredPrevious.sequence + 1) {
-            return { ok: false, entries, brokenAt: entries, reason: `sequence ${entry.sequence} is not ${coveredPrevious.sequence + 1}` };
+            return {
+              ok: false,
+              entries,
+              brokenAt: entries,
+              reason: `sequence ${entry.sequence} is not ${coveredPrevious.sequence + 1}`
+            };
           }
           if (coveredPrevious && entry.previousHash !== coveredPrevious.hash) {
             return { ok: false, entries, brokenAt: entries, reason: "previous hash mismatch" };
           }
           if (entry.sequence === checkpointSequence && recordedHash !== checkpoint?.hash) {
-            return { ok: false, entries, brokenAt: entries, reason: "retention checkpoint hash mismatch" };
+            return {
+              ok: false,
+              entries,
+              brokenAt: entries,
+              reason: "retention checkpoint hash mismatch"
+            };
           }
           coveredPrevious = entry;
           continue;
         }
         const index = entries++;
-        if (entry.sequence !== lastSequence + 1) return { ok: false, entries, brokenAt: index, reason: `sequence ${entry.sequence} is not ${lastSequence + 1}` };
-        if (entry.previousHash !== previousHash) return { ok: false, entries, brokenAt: index, reason: "previous hash mismatch" };
-        if (hashValue(content) !== recordedHash) return { ok: false, entries, brokenAt: index, reason: "entry hash mismatch" };
+        if (entry.sequence !== lastSequence + 1)
+          return {
+            ok: false,
+            entries,
+            brokenAt: index,
+            reason: `sequence ${entry.sequence} is not ${lastSequence + 1}`
+          };
+        if (entry.previousHash !== previousHash)
+          return { ok: false, entries, brokenAt: index, reason: "previous hash mismatch" };
+        if (hashValue(content) !== recordedHash)
+          return { ok: false, entries, brokenAt: index, reason: "entry hash mismatch" };
         previousHash = recordedHash;
         lastSequence = entry.sequence;
       }
@@ -1267,7 +1333,9 @@ async function readRetentionCheckpoint(basePath) {
 }
 async function writeRetentionCheckpoint(basePath, checkpoint) {
   await atomicWrite(retentionCheckpointPath(basePath), `${JSON.stringify(checkpoint)}
-`, { mode: 384 });
+`, {
+    mode: 384
+  });
 }
 function isHash(value) {
   return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
@@ -1307,7 +1375,11 @@ async function readLastEntryState(filePath) {
         const trimmed = lines[i].trim();
         if (!trimmed) continue;
         try {
-          return { entry: JSON.parse(trimmed), size, birthtimeMs: stat4.birthtimeMs };
+          return {
+            entry: JSON.parse(trimmed),
+            size,
+            birthtimeMs: stat4.birthtimeMs
+          };
         } catch {
         }
       }
@@ -3850,6 +3922,8 @@ var ChronicleProjectServerClient = class {
   connectResolve = null;
   connectReject = null;
   nextId = 1;
+  /** WS-027: read from the owner-only metadata file — see currentAuthToken. */
+  authToken;
   pending = /* @__PURE__ */ new Map();
   async call(op, args, options = {}) {
     await this.ensureConnected(true);
@@ -3932,6 +4006,7 @@ var ChronicleProjectServerClient = class {
   connectOnce() {
     this.socket?.destroy();
     this.socket = null;
+    this.authToken = void 0;
     this.info = null;
     this.buffer = "";
     return new Promise((resolve12, reject) => {
@@ -3962,13 +4037,42 @@ var ChronicleProjectServerClient = class {
       socket.on("close", () => this.onClose(socket));
     });
   }
+  /**
+   * WS-027: the per-process token, read from the daemon's owner-only metadata
+   * file — never from the `hello` frame, which the daemon sends to every
+   * socket that connects (the mistake WS-028 found in the SAGE daemon).
+   *
+   * Read lazily and re-read while unknown: the daemon starts listening before
+   * it writes metadata (endpoint ownership has to be won first), and a
+   * respawned daemon mints a new token, so a cached wrong one would be sticky.
+   */
+  currentAuthToken() {
+    if (this.authToken === void 0) {
+      try {
+        const raw = fs8.readFileSync(
+          chronicleProjectServerMetadataPath(this.options.projectDir),
+          "utf8"
+        );
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.authToken === "string" && parsed.authToken.length > 0) {
+          this.authToken = parsed.authToken;
+        }
+      } catch {
+      }
+    }
+    return this.authToken;
+  }
   request(message, timeoutMs) {
     const socket = this.socket;
     if (!socket || socket.destroyed) {
       return Promise.reject(new Error("Chronicle project server connection is unavailable"));
     }
     const id = this.nextId++;
-    const encoded = encodeChronicleProjectServerMessage({ ...message, id });
+    const encoded = encodeChronicleProjectServerMessage({
+      ...message,
+      id,
+      authToken: this.currentAuthToken()
+    });
     if (encoded.length > CHRONICLE_PROJECT_SERVER_MAX_FRAME_CHARS) {
       return Promise.reject(new Error("Chronicle project server request exceeded frame limit"));
     }

package/dist/chronicle/project-server-client.d.ts

@@ -57,6 +57,8 @@ export declare class ChronicleProjectServerClient {
     private connectResolve;
     private connectReject;
     private nextId;
+    /** WS-027: read from the owner-only metadata file — see currentAuthToken. */
+    private authToken;
     private readonly pending;
     constructor(options: ChronicleProjectServerClientOptions);
     call<O extends ChronicleServerOperationName>(op: O, args: ChronicleServerOperations[O]['args'], options?: ChronicleProjectServerCallOptions): Promise<ChronicleServerOperations[O]['result']>;
@@ -77,6 +79,16 @@ export declare class ChronicleProjectServerClient {
     private ensureConnected;
     private connectWithElection;
     private connectOnce;
+    /**
+     * WS-027: the per-process token, read from the daemon's owner-only metadata
+     * file — never from the `hello` frame, which the daemon sends to every
+     * socket that connects (the mistake WS-028 found in the SAGE daemon).
+     *
+     * Read lazily and re-read while unknown: the daemon starts listening before
+     * it writes metadata (endpoint ownership has to be won first), and a
+     * respawned daemon mints a new token, so a cached wrong one would be sticky.
+     */
+    private currentAuthToken;
     private request;
     private onData;
     private onMessage;

package/dist/chronicle/project-server-protocol.d.ts

@@ -4,6 +4,10 @@ import type { ChronicleFacet, ChronicleFacetResults, ChronicleFacetValue, Chroni
 import type { ChronicleEvent, ChronicleEventInput } from './types.js';
 export declare const CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION = 2;
 export declare const CHRONICLE_PROJECT_SERVER_MAX_FRAME_CHARS: number;
+/**
+ * What the daemon tells a connecting client about itself. Carries NO secret —
+ * see {@link ChronicleProjectServerMetadata}.
+ */
 export interface ChronicleProjectServerInfo {
     protocolVersion: number;
     pid: number;
@@ -148,15 +152,33 @@ export interface ChronicleServerOperations {
     };
 }
 export type ChronicleServerOperationName = keyof ChronicleServerOperations;
+/**
+ * The daemon's on-disk metadata file, written 0600. The auth token exists here
+ * and nowhere else — never in the `hello` frame, which the daemon sends to
+ * every socket that connects (the mistake WS-028 found in the SAGE daemon).
+ */
+export interface ChronicleProjectServerMetadata extends ChronicleProjectServerInfo {
+    authToken: string;
+}
 export type ChronicleProjectServerClientMessage = {
     type: 'request';
     id: number;
     op: ChronicleServerOperationName;
     args: unknown;
+    /**
+     * WS-027: this daemon owns the project's chronicle — the durable record
+     * of what every agent did — and it had no handshake credential at all.
+     * Any process that could open the socket could read that history or
+     * append to it. The token comes from the daemon's owner-only metadata
+     * file, so a caller must prove same-user access before it may act.
+     */
+    authToken?: string | undefined;
 } | {
     type: 'shutdown';
     id: number;
     reason?: string | undefined;
+    /** Gated for the same reason — this stops the daemon for every client. */
+    authToken?: string | undefined;
 };
 export type ChronicleProjectServerMessage = ({
     type: 'hello';