sealkeep 0.11.5 → 0.11.7

package/dist/src/control-plane/store.d.ts

@@ -66,6 +66,31 @@ export type AuditEvent = {
     outcome: "allowed" | "denied";
     detail?: Record<string, string | number>;
 };
+export type SecretScanCount = {
+    kind: string;
+    severity: "high" | "medium";
+    count: number;
+};
+export type SecretScanRollup = {
+    id: string;
+    accountId: string;
+    deviceId: string;
+    archiveId: string;
+    scannedAt: string;
+    receivedAt: string;
+    counts: SecretScanCount[];
+};
+export type SecretScanPolicy = {
+    accountId: string;
+    updatedAt: string;
+    mode: "off" | "record" | "block-high";
+    failClosed: boolean;
+    patterns: Array<{
+        kind: string;
+        severity: "high" | "medium";
+        source: string;
+    }>;
+};
 export declare class ControlPlaneStore {
     private readonly path?;
     private document;
@@ -98,4 +123,11 @@ export declare class ControlPlaneStore {
         at?: string;
     }): AuditEvent;
     usedBytes(accountId: string): number;
+    /** 90 days. Rollups are counts only. Reads and writes both drop expired rows. */
+    static readonly ROLLUP_RETENTION_MS: number;
+    private freshRollups;
+    secretScanPolicy(accountId: string): SecretScanPolicy | undefined;
+    setSecretScanPolicy(policy: SecretScanPolicy): SecretScanPolicy;
+    addSecretScanRollup(rollup: SecretScanRollup, now?: number): SecretScanRollup;
+    secretScanRollups(accountId: string, now?: number): SecretScanRollup[];
 }

package/dist/src/control-plane/store.js

@@ -79,4 +79,37 @@ export class ControlPlaneStore {
         return entry;
     }
     usedBytes(accountId) { return this.archivesFor(accountId).filter((item) => item.durableAt).reduce((total, item) => total + item.bytes, 0); }
+    /** 90 days. Rollups are counts only. Reads and writes both drop expired rows. */
+    static ROLLUP_RETENTION_MS = 90 * 24 * 60 * 60 * 1000;
+    freshRollups(now = Date.now()) {
+        const all = this.document.secretScanRollups ?? [];
+        const fresh = all.filter((item) => now - Date.parse(item.receivedAt) <= ControlPlaneStore.ROLLUP_RETENTION_MS);
+        if (fresh.length !== all.length) {
+            this.document.secretScanRollups = fresh;
+            this.persist();
+        }
+        return fresh;
+    }
+    secretScanPolicy(accountId) { return (this.document.secretScanPolicies ?? []).find((item) => item.accountId === accountId); }
+    setSecretScanPolicy(policy) {
+        const policies = this.document.secretScanPolicies ?? [];
+        const index = policies.findIndex((item) => item.accountId === policy.accountId);
+        if (index >= 0)
+            policies[index] = policy;
+        else
+            policies.push(policy);
+        this.document.secretScanPolicies = policies;
+        this.persist();
+        return policy;
+    }
+    addSecretScanRollup(rollup, now = Date.now()) {
+        const kept = this.freshRollups(now);
+        kept.push(rollup);
+        this.document.secretScanRollups = kept;
+        this.persist();
+        return rollup;
+    }
+    secretScanRollups(accountId, now = Date.now()) {
+        return this.freshRollups(now).filter((item) => item.accountId === accountId);
+    }
 }

package/dist/src/daemon.js

@@ -16,6 +16,7 @@ import { automaticTranscriptIsEnabled, backgroundUploadBytesPerSecond, readLocal
 import { hasDueAutomaticAgentContextRequest, recoverAutomaticAgentContextClaims, } from "./agent-context.js";
 import { reconcileTeamHistoryBackfill } from "./team-backfill.js";
 import { acquireDaemonWorkerLease } from "./daemon-lease.js";
+import { sweepStaleScanSnapshots } from "./leakscan.js";
 import { createProgressDeadline } from "./progress-deadline.js";
 import { recoverBackgroundBandwidthLockAtDaemonStartup } from "./background-bandwidth.js";
 // One definition, shared with the worker's per-job check in src/disk.ts. Two
@@ -29,6 +30,7 @@ import { recoverBackgroundBandwidthLockAtDaemonStartup } from "./background-band
  * exposed directly so behaviour can be tested without waiting on timers.
  */
 export async function startDaemon(dataDir, options) {
+    await sweepStaleScanSnapshots(dataDir);
     // The service manager is not a lock: an in-place upgrade or manager crash
     // can orphan its child, then launch a replacement. Elect one complete vault
     // worker before any heartbeat, watcher, queue, index, upload, retention or

package/dist/src/errors.d.ts

@@ -3,7 +3,7 @@
  * between releases; these codes are a contract for the CLI, local API, and MCP.
  * Details are operational only: never place plaintext, phrases, or keys here.
  */
-export type SealkeepErrorCode = "invalid_argument" | "vault_not_initialized" | "vault_already_initialized" | "config_unsupported_version" | "recovery_phrase_missing" | "recovery_phrase_mismatch" | "recipient_key_mismatch" | "payment_required" | "archive_not_found" | "source_unreadable" | "destination_exists" | "destination_unwritable" | "insufficient_disk_space" | "scratch_space_busy" | "path_not_permitted" | "native_restore_unavailable" | "ciphertext_integrity_failed" | "plaintext_integrity_failed" | "hook_payload_invalid" | "queue_job_not_found" | "queue_lease_invalid" | "queue_lease_expired" | "queue_job_exhausted" | "daemon_already_running" | "storage_not_configured" | "storage_read_timeout" | "operation_timeout" | "cloud_account_unavailable" | "provider_unsupported" | "signer_not_configured" | "lease_expired" | "upload_incomplete" | "team_state_changed" | "team_membership_revoked" | "rate_limited" | "unauthorized" | "forbidden" | "internal";
+export type SealkeepErrorCode = "invalid_argument" | "vault_not_initialized" | "vault_already_initialized" | "config_unsupported_version" | "recovery_phrase_missing" | "recovery_phrase_mismatch" | "recipient_key_mismatch" | "payment_required" | "archive_not_found" | "source_unreadable" | "secret_scan_blocked" | "secret_scan_failed" | "destination_exists" | "destination_unwritable" | "insufficient_disk_space" | "scratch_space_busy" | "path_not_permitted" | "native_restore_unavailable" | "ciphertext_integrity_failed" | "plaintext_integrity_failed" | "hook_payload_invalid" | "queue_job_not_found" | "queue_lease_invalid" | "queue_lease_expired" | "queue_job_exhausted" | "daemon_already_running" | "storage_not_configured" | "storage_read_timeout" | "operation_timeout" | "cloud_account_unavailable" | "provider_unsupported" | "signer_not_configured" | "lease_expired" | "upload_incomplete" | "team_state_changed" | "team_membership_revoked" | "rate_limited" | "unauthorized" | "forbidden" | "internal";
 export declare class SealkeepError extends Error {
     readonly code: SealkeepErrorCode;
     readonly details: Record<string, unknown>;

package/dist/src/leakscan.d.ts

@@ -1,3 +1,90 @@
+import { type LocalSettings } from "./machine-settings.js";
+import type { ArchiveSecretScan } from "./types.js";
+export type CustomScanPattern = {
+    kind: string;
+    severity: "high" | "medium";
+    source: string;
+};
+/** Aggregate sent to the control plane. No lines, paths, or matched text. */
+export type OrgSecretRollup = {
+    version: 1;
+    archiveId: string;
+    scannedAt: string;
+    counts: Array<{
+        kind: string;
+        severity: "high" | "medium";
+        count: number;
+    }>;
+};
+/** Reject patterns that match everything, fail to compile, or can backtrack without bound. */
+export declare function validateCustomPattern(input: CustomScanPattern): CustomScanPattern;
+type CustomHit = {
+    kind: string;
+    severity: "high" | "medium";
+    start: number;
+    end: number;
+};
+/** Runs custom detectors off the seal thread and stops them if one line runs long. */
+export declare function matchCustomLine(line: string, patterns: readonly CustomScanPattern[], timeoutMs?: number): Promise<CustomHit[]>;
+export declare function findingsMetadata(findings: readonly Finding[], policy: "record" | "block-high"): ArchiveSecretScan;
+export declare function orgRollupBody(archiveId: string, scan: ArchiveSecretScan): OrgSecretRollup;
+/**
+ * The scan result is only valid for the bytes whose SHA-256 it names.
+ * `snapshotPath`, when present, is an immutable copy of those bytes. Streamed
+ * seals read it instead of the live transcript, so a later edit cannot be
+ * uploaded. The caller deletes it when the seal finishes.
+ */
+export type SealScan = {
+    metadata: ArchiveSecretScan;
+    sha256: string;
+    snapshotPath?: string;
+};
+/** Removes a scanned snapshot. Safe to call when the scan did not take one. */
+export declare function discardScanSnapshot(scan: SealScan | undefined): Promise<void>;
+/**
+ * A crash after the snapshot is written leaves plaintext in scan-snapshots.
+ * The name records the creating pid. Startup and the next scanned seal remove
+ * a file only when that process is gone, so a live seal keeps its copy.
+ */
+export declare function sweepStaleScanSnapshots(dataDir: string): Promise<void>;
+/**
+ * Set by tests to change the file after the scan has accepted it and before
+ * the seal reads it again. Production leaves this unset.
+ */
+export declare const sealScanTestHooks: {
+    afterAccepted?: (path: string) => Promise<void>;
+};
+/**
+ * Scan before encryption or upload. Returns metadata and the digest of the
+ * exact byte range the seal will read, or undefined when the policy is off
+ * or a fail-open scanner error skipped it. Throws before any archive exists
+ * when the seal must not proceed.
+ */
+export declare function scanBeforeSeal(dataDir: string, path: string, signal?: AbortSignal, hooks?: {
+    afterRead?: () => Promise<void>;
+}, byteLength?: number, options?: {
+    snapshot?: boolean;
+}): Promise<SealScan | undefined>;
+/** Refuse to publish a seal whose plaintext digest is not the digest that was scanned. */
+export declare function assertScanCoversSeal(scan: SealScan | undefined, sealedSha256: string, sourcePath: string): void;
+/** @deprecated Use scanBeforeSeal. Kept so older call sites keep blocking. */
+export declare function assertSecretScanPasses(dataDir: string, path: string, signal?: AbortSignal): Promise<void>;
+export type ControlPlaneDevice = {
+    deviceId: string;
+    privateKeyPem: string;
+};
+export declare function readControlPlaneDevice(dataDir: string): Promise<ControlPlaneDevice | null>;
+export declare function writeControlPlaneDevice(dataDir: string, device: ControlPlaneDevice): Promise<void>;
+/** Best-effort delivery after a durable seal. A network failure never rolls the archive back. */
+export declare function deliverOrgRollup(dataDir: string, archiveId: string, scan: ArchiveSecretScan | undefined): Promise<void>;
+export type SharedScanPolicy = {
+    version: 1;
+    secretScanPolicy: LocalSettings["secretScanPolicy"];
+    secretScanFailClosed: boolean;
+    secretScanPatterns: CustomScanPattern[];
+};
+/** What may move between machines. Consent and the control-plane URL stay local. */
+export declare function sharedScanPolicy(settings: LocalSettings): SharedScanPolicy;
 export type Finding = {
     kind: string;
     /** 1-based, matching what editors and `sed -n` call a line. */
@@ -28,21 +115,26 @@ export type ScanReport = {
 export declare function maskSecret(secret: string): string;
 /** Character-frequency Shannon entropy, in bits per character. */
 export declare function shannonEntropy(value: string): number;
+type Detector = {
+    kind: string;
+    /** `dg` flags, so matchAll yields index pairs for the secret group. */
+    pattern: RegExp;
+    /** Capture group holding the secret itself; whole match when omitted. */
+    group?: number;
+    /** Post-regex gate for shapes a regex alone over-matches. */
+    validate?: (candidate: string) => boolean;
+    severity?: "high" | "medium";
+};
 /** Tests derive their vectors from these rather than restating the numbers. */
 export declare const GENERIC_MIN_LENGTH = 24;
 export declare const GENERIC_ENTROPY_THRESHOLD = 4.2;
-export declare function scanText(text: string): Finding[];
-/**
- * Line-by-line over a read stream: memory is bounded by the longest single
- * line, never by the file, so a multi-GB jsonl scans in the same footprint as
- * a small one. An unreadable input rejects — a scanner that swallows a read
- * error would be reporting "clean" about bytes it never saw.
- */
-export declare function scanFileStreaming(path: string, onFinding?: (finding: Finding) => void): Promise<Finding[]>;
+export declare function scanText(text: string, patterns?: readonly CustomScanPattern[]): Finding[];
+export declare function scanFileStreaming(path: string, onFinding?: (finding: Finding) => void, extra?: readonly Detector[]): Promise<Finding[]>;
 /**
  * A file is scanned as pointed at, whatever its name; a directory means every
  * *.jsonl beneath it. Only high findings set the exit code — failing a script
  * over a "medium" suspicion is exactly the cry-wolf behaviour the severity
  * split exists to avoid.
  */
-export declare function scanPath(target: string, onFinding?: (finding: FileFinding) => void): Promise<ScanReport>;
+export declare function scanPath(target: string, onFinding?: (finding: FileFinding) => void, patterns?: readonly CustomScanPattern[]): Promise<ScanReport>;
+export {};