sealkeep 0.5.2 → 0.6.0

package/dist/src/search.js

@@ -10,6 +10,20 @@ import { isV2 } from "./types.js";
 const indexPath = (dataDir) => join(dataDir, "index", "content-index.vlindex");
 const envelopePath = (dataDir) => join(dataDir, "index", "content-index.json");
 const coveragePath = (dataDir) => join(dataDir, "index", "coverage.json");
+/**
+ * The ids THIS machine has indexed, from its own unsealed sidecar. Used to
+ * decide what this machine is entitled to forget: entries it never wrote
+ * belong to another machine of the vault and are not ours to delete.
+ */
+async function ownCoverage(dataDir) {
+    try {
+        const raw = JSON.parse(await readFile(coveragePath(dataDir), "utf8"));
+        return Array.isArray(raw.indexed) ? raw.indexed : [];
+    }
+    catch {
+        return [];
+    }
+}
 const MIN_TOKEN = 3;
 const MAX_TOKENS_PER_ARCHIVE = 4000;
 /**
@@ -201,10 +215,21 @@ export async function buildContentIndex(dataDir, rawPhrase, options = {}) {
     // Drop entries for archives that no longer exist, then index only what is
     // NEW — the difference between "re-decrypt 53 archives" and "decrypt the
     // two sealed since the last build".
+    //
+    // "No longer exists" is a judgement only the machine that sealed it can
+    // make. The index is shared by every machine of the vault, so a laptop that
+    // has never sealed anything must not conclude that the desktop's fifty
+    // archives are gone: it used to delete every entry it had no local record
+    // for and push the emptied index back, which wiped the phonebook for the
+    // whole vault and left the machine that built it unable to search its own
+    // history. A machine may forget only what it itself indexed.
     const liveIds = new Set(records.map((record) => record.id));
+    const mine = new Set(await ownCoverage(dataDir));
     for (const id of Object.keys(index.archives)) {
         if (liveIds.has(id))
             continue;
+        if (!mine.has(id))
+            continue; // another machine's archive
         delete index.archives[id];
         for (const token of Object.keys(index.tokens)) {
             index.tokens[token] = index.tokens[token].filter((entry) => entry !== id && !entry.startsWith(`${id}@`));
@@ -515,6 +540,34 @@ async function remoteOnlyRecord(dataDir, id, phrase) {
         const { pullCiphertext, unframeObject } = await import("./cloud.js");
         const { openIdentity } = await import("./chunk-store.js");
         const { unwrapArchiveKey } = await import("../packages/vaultline-crypto/src/recipients.js");
+        // An ordinary archive pushed to managed storage is ONE object with its
+        // envelope in the frame — no identity sidecar, because nothing was
+        // chunked. That shape used to fall through to null here, so a second
+        // machine could find a streamed archive and not an uploaded one, which
+        // is not a distinction anybody asked for. Try it before the chunk layout.
+        const single = await pullCiphertext(dataDir, id).catch(() => null);
+        if (single) {
+            const { envelope: only } = unframeObject(single.ciphertext);
+            if (only?.manifest) {
+                const bytes = only.manifest.originalBytes ?? only.manifest.plaintextBytes ?? 0;
+                return {
+                    version: 2, id, createdAt: only.manifest.createdAt ?? new Date(0).toISOString(),
+                    source: {
+                        path: only.manifest.sourcePath ?? only.manifest.adapter?.sourcePath ?? `archive ${id.slice(0, 8)}`,
+                        agent: only.manifest.adapter?.agent ?? "unknown",
+                        bytes,
+                        sha256: only.manifest.originalSha256 ?? only.manifest.plaintextSha256
+                    },
+                    cipher: { algorithm: only.suite, ciphertextSha256: "", storedBytes: single.ciphertext.length, chunks: only.chunks?.length ?? 1 },
+                    envelope: only,
+                    objectPath: join(dataDir, "never-materialised", `${id}.vlarchive`),
+                    remote: {
+                        provider: "vaultline", bucket: "vaultline-managed", objectKey: id,
+                        bytes: single.ciphertext.length, checksum: "", verifiedAt: only.manifest.createdAt ?? new Date(0).toISOString()
+                    }
+                };
+            }
+        }
         const { ciphertext: sidecar } = await pullCiphertext(dataDir, `${id}.envelope.vlmeta`);
         const { envelope, ciphertext: identityBlob } = unframeObject(sidecar);
         if (!envelope)

package/dist/src/secrets.d.ts

@@ -29,7 +29,7 @@ export declare class FileSecretBackend implements SecretBackend {
 export declare function secretBackends(dataDir: string): SecretBackend[];
 /**
  * Picks the strongest backend this machine supports. The file fallback always
- * qualifies. `VAULTLINE_SECRET_BACKEND` pins the choice, which is how a test suite
+ * qualifies. `SEALKEEP_SECRET_BACKEND` pins the choice, which is how a test suite
  * or a sandboxed environment stays out of the real OS keystore.
  */
 export declare function chooseBackend(dataDir: string, preferred?: BackendName, env?: NodeJS.ProcessEnv): Promise<SecretBackend>;

package/dist/src/secrets.js

@@ -4,6 +4,7 @@ import { platform } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import { fail } from "./errors.js";
+import { envVar } from "./env.js";
 const run = promisify(execFile);
 async function commandExists(command) {
     try {
@@ -130,11 +131,11 @@ export function secretBackends(dataDir) {
 }
 /**
  * Picks the strongest backend this machine supports. The file fallback always
- * qualifies. `VAULTLINE_SECRET_BACKEND` pins the choice, which is how a test suite
+ * qualifies. `SEALKEEP_SECRET_BACKEND` pins the choice, which is how a test suite
  * or a sandboxed environment stays out of the real OS keystore.
  */
 export async function chooseBackend(dataDir, preferred, env = process.env) {
-    preferred = preferred ?? env.VAULTLINE_SECRET_BACKEND;
+    preferred = preferred ?? envVar("SECRET_BACKEND", env);
     const backends = secretBackends(dataDir);
     if (preferred) {
         const chosen = backends.find((backend) => backend.name === preferred);
@@ -190,7 +191,7 @@ export async function forgetRecoveryPhrase(dataDir, vaultId, preferred) {
  * everything, without the keystore's opt-in or its stated trade-off.
  */
 export async function resolveRecoveryPhrase(dataDir, vaultId, explicit, env = process.env, preferred) {
-    return explicit ?? env.VAULTLINE_RECOVERY_PHRASE ?? (await recallRecoveryPhrase(dataDir, vaultId, preferred).catch(() => null));
+    return explicit ?? envVar("RECOVERY_PHRASE", env) ?? (await recallRecoveryPhrase(dataDir, vaultId, preferred).catch(() => null));
 }
 /**
  * Provider credentials are addressed by storage config id, never by bucket name,

package/dist/src/service.d.ts

@@ -11,7 +11,7 @@ export type ServiceOptions = {
      *
      * A service manager starts the daemon with a bare environment — it does not
      * inherit the shell that installed it. The upload pass is gated on
-     * `VAULTLINE_ENABLE_SIGNER`, so a service definition that carries no
+     * `SEALKEEP_ENABLE_SIGNER`, so a service definition that carries no
      * environment produces a daemon that seals sessions, uploads nothing, and
      * therefore reclaims nothing, logging one line to `daemon.log` that nobody
      * reads. Whatever the installer decides uploads need, it has to be written
@@ -58,7 +58,7 @@ export declare function serviceStatus(options: ServiceOptions): Promise<{
  * The environment a service unit needs beyond its flags. A service manager
  * starts the daemon bare, so anything the installing session was told about
  * where secrets live has to ride along in the unit — a vault set up with
- * VAULTLINE_SECRET_BACKEND=file kept its phrase in a keystore the daemon then
+ * SEALKEEP_SECRET_BACKEND=file kept its phrase in a keystore the daemon then
  * never looked in, and every tick died on "No recovery phrase available".
  */
 export declare function serviceUnitEnvironment(base?: Record<string, string>, env?: NodeJS.ProcessEnv): Record<string, string>;

package/dist/src/service.js

@@ -5,6 +5,7 @@ import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 import { fail } from "./errors.js";
+import { envVar } from "./env.js";
 const run = promisify(execFile);
 export const SERVICE_LABEL = "ai.vaultline.agent";
 function kindFor(target) {
@@ -165,11 +166,12 @@ export async function serviceStatus(options) {
  * The environment a service unit needs beyond its flags. A service manager
  * starts the daemon bare, so anything the installing session was told about
  * where secrets live has to ride along in the unit — a vault set up with
- * VAULTLINE_SECRET_BACKEND=file kept its phrase in a keystore the daemon then
+ * SEALKEEP_SECRET_BACKEND=file kept its phrase in a keystore the daemon then
  * never looked in, and every tick died on "No recovery phrase available".
  */
 export function serviceUnitEnvironment(base = {}, env = process.env) {
-    return { ...(env.VAULTLINE_SECRET_BACKEND ? { VAULTLINE_SECRET_BACKEND: env.VAULTLINE_SECRET_BACKEND } : {}), ...base };
+    const backend = envVar("SECRET_BACKEND", env);
+    return { ...(backend ? { SEALKEEP_SECRET_BACKEND: backend } : {}), ...base };
 }
 /** The argv the service should run: this package's CLI, with the daemon subcommand. */
 export function daemonInvocation(dataDir, options = {}) {

package/dist/src/storage-setup.js

@@ -64,7 +64,7 @@ function s3Plan(input) {
         finish: [
             `sealkeep storage configure --provider s3 --bucket ${bucket} --prefix ${prefix} --region ${region}`,
             `echo '{"accessKeyId":"AKIA…","secretAccessKey":"…"}' | sealkeep storage credentials set`,
-            `VAULTLINE_ENABLE_SIGNER=1 sealkeep upload --all`
+            `SEALKEEP_ENABLE_SIGNER=1 sealkeep upload --all`
         ],
         notes: [
             "Enable versioning on the bucket if you want protection against an accidental overwrite.",
@@ -100,7 +100,7 @@ function r2Plan(input) {
         finish: [
             `sealkeep storage configure --provider r2 --bucket ${bucket} --prefix ${prefix} --region auto`,
             `echo '{"accessKeyId":"<R2 access key id>","secretAccessKey":"<R2 secret>"}' | sealkeep storage credentials set`,
-            `VAULTLINE_ENABLE_SIGNER=1 sealkeep upload --all --endpoint https://${accountId}.r2.cloudflarestorage.com`
+            `SEALKEEP_ENABLE_SIGNER=1 sealkeep upload --all --endpoint https://${accountId}.r2.cloudflarestorage.com`
         ],
         notes: [
             "R2 tokens are scoped per bucket in the dashboard, so the prefix restriction is Sealkeep's own object-key discipline rather than an IAM condition.",
@@ -151,7 +151,7 @@ function gcsPlan(input) {
             `sealkeep storage configure --provider gcs --bucket ${bucket} --prefix ${prefix}`,
             `node -e 'const k=require("./vaultline-key.json");process.stdout.write(JSON.stringify({clientEmail:k.client_email,privateKey:k.private_key}))' \\\n  | sealkeep storage credentials set`,
             `rm vaultline-key.json   # the key now lives in your keychain`,
-            `VAULTLINE_ENABLE_SIGNER=1 sealkeep upload --all`
+            `SEALKEEP_ENABLE_SIGNER=1 sealkeep upload --all`
         ],
         notes: [
             "Delete the downloaded key file once it is in your keychain. A key on disk is the usual way these leak.",
@@ -188,7 +188,7 @@ function gdrivePlan(input) {
                 title: "Connect your Google account",
                 why: `Sealkeep asks for drive.file only: it can see files it created — a "${folder}" folder of ciphertext — and nothing else in the Drive.`,
                 commands: [
-                    `export VAULTLINE_GDRIVE_CLIENT_ID="<your-client-id>.apps.googleusercontent.com"`,
+                    `export SEALKEEP_GDRIVE_CLIENT_ID="<your-client-id>.apps.googleusercontent.com"`,
                     `sealkeep storage connect gdrive`
                 ]
             }
@@ -196,7 +196,7 @@ function gdrivePlan(input) {
         finish: [
             `# once the provider registry accepts gdrive targets:`,
             `sealkeep storage configure --provider gdrive --bucket ${folder} --prefix ${prefix}`,
-            `VAULTLINE_ENABLE_SIGNER=1 sealkeep upload --all`
+            `SEALKEEP_ENABLE_SIGNER=1 sealkeep upload --all`
         ],
         notes: [
             `Archives land in a "${folder}" folder as sealed ciphertext; a prefix of "appdata" uses Drive's hidden per-app area instead.`,

package/dist/src/storage-targets.d.ts

@@ -19,6 +19,9 @@ export type StorageTarget = StorageTargetConfig;
  */
 export declare function resolveTargets(dataDir: string): Promise<StorageTarget[]>;
 /** Pushes the rules to the account so every other machine syncs them. Advisory: offline edits still apply locally. */
+/** Re-pushes the current rules with fresh usage stamps — machines are the only
+ * ones who can see Drive and BYO bytes, so the account learns them from here. */
+export declare function pushTargetUsage(dataDir: string): Promise<void>;
 export declare function pushTargetsToCloud(dataDir: string, targets: StorageTarget[]): Promise<boolean>;
 /** Bytes each target currently holds, from the records: targetId when stamped, provider+bucket for older records. */
 export declare function targetUsage(dataDir: string, targets: StorageTarget[]): Promise<Map<string, number>>;

package/dist/src/storage-targets.js

@@ -1,6 +1,7 @@
 import { fail } from "./errors.js";
 import { readConfig, listArchives } from "./vault.js";
 import { isV2 } from "./types.js";
+import { envVar } from "./env.js";
 const defaultPriority = (target) => target.priority ?? (target.provider === "vaultline" ? 0 : 10);
 /**
  * The effective target list. Explicit `storageTargets` in config wins;
@@ -43,7 +44,7 @@ async function pullTargetsFromCloud(dataDir) {
     if (!token)
         return null;
     const { DEFAULT_CLOUD_URL } = await import("./cloud.js");
-    const base = (process.env.VAULTLINE_CLOUD_URL ?? DEFAULT_CLOUD_URL).replace(/\/+$/, "");
+    const base = (envVar("CLOUD_URL") ?? DEFAULT_CLOUD_URL).replace(/\/+$/, "");
     const response = await fetch(`${base}/v1/cloud/storage-targets`, { headers: { authorization: `Bearer ${token}` } });
     if (!response.ok)
         return null;
@@ -59,11 +60,30 @@ async function pullTargetsFromCloud(dataDir) {
     }
 }
 /** Pushes the rules to the account so every other machine syncs them. Advisory: offline edits still apply locally. */
+/** Re-pushes the current rules with fresh usage stamps — machines are the only
+ * ones who can see Drive and BYO bytes, so the account learns them from here. */
+export async function pushTargetUsage(dataDir) {
+    try {
+        const targets = await resolveTargets(dataDir);
+        if (!targets.length)
+            return;
+        await pushTargetsToCloud(dataDir, targets);
+    }
+    catch { /* advisory */ }
+}
 export async function pushTargetsToCloud(dataDir, targets) {
     try {
+        const usage = await targetUsage(dataDir, targets).catch(() => null);
+        if (usage) {
+            const now = new Date().toISOString();
+            targets = targets.map((t) => {
+                const used = usage.get(t.id);
+                return used && used > 0 ? { ...t, usedBytes: used, usedAt: now } : t;
+            });
+        }
         const { cloudToken, DEFAULT_CLOUD_URL } = await import("./cloud.js");
         const token = await cloudToken(dataDir);
-        const base = (process.env.VAULTLINE_CLOUD_URL ?? DEFAULT_CLOUD_URL).replace(/\/+$/, "");
+        const base = (envVar("CLOUD_URL") ?? DEFAULT_CLOUD_URL).replace(/\/+$/, "");
         const response = await fetch(`${base}/v1/cloud/storage-targets`, {
             method: "PUT",
             headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },

package/dist/src/types.d.ts

@@ -133,6 +133,9 @@ export type StorageTargetConfig = {
     maxGb?: number;
     projects?: string[];
     priority?: number;
+    /** Stamped by machines when they push: bytes this target holds, per their records. */
+    usedBytes?: number;
+    usedAt?: string;
 };
 export declare function isV2(record: ArchiveRecord): record is ArchiveRecordV2;
 export type VaultConfig = {

package/dist/src/upload.js

@@ -59,6 +59,10 @@ export async function uploadArchive(dataDir, archiveId, options = {}) {
     const next = { ...record, remote };
     await writeRecord(config.storage.root, next);
     await recordAudit(dataDir, "upload.verify", "allowed", { archiveId, objectKey: lease.objectKey, bytes: ciphertext.length, provider: lease.provider });
+    {
+        const { pushTargetUsage } = await import("./storage-targets.js");
+        void pushTargetUsage(dataDir);
+    }
     return { archiveId, objectKey: lease.objectKey, bytes: ciphertext.length, checksum: localChecksum, verified: true, provider: lease.provider };
 }
 /** Uploads every archive that has no verified remote object yet. */

package/dist/src/vault.js

@@ -10,6 +10,7 @@ import { decryptArchive as openEnvelope, hashFilePrefixes, hashFileRange, keyRec
 import { fail, VaultlineError } from "./errors.js";
 import { recordAudit } from "./audit.js";
 import { isV2 } from "./types.js";
+import { envVar } from "./env.js";
 /** Bumped when the adapter's preservation behaviour changes, recorded in every envelope. */
 /**
  * Writes one archive record atomically.
@@ -130,14 +131,14 @@ export async function initialize(dataDir, providedPhrase, opts = {}) {
  * sessions on a 16 GB machine were simply refused. Archiving now streams a
  * chunk at a time, so a transcript's size no longer predicts what it costs to
  * archive and a machine-derived refusal would only turn away sessions this
- * build can handle. Only an explicit VAULTLINE_MAX_ARCHIVE_BYTES still refuses.
+ * build can handle. Only an explicit SEALKEEP_MAX_ARCHIVE_BYTES still refuses.
  */
 function assertArchivable(absolute, size) {
-    const ceiling = Number(process.env.VAULTLINE_MAX_ARCHIVE_BYTES ?? "");
+    const ceiling = Number(envVar("MAX_ARCHIVE_BYTES") ?? "");
     if (!Number.isFinite(ceiling) || ceiling <= 0 || size <= ceiling)
         return;
     const gb = (value) => `${(value / 1024 ** 3).toFixed(1)} GB`;
-    fail("source_unreadable", `${absolute} is ${gb(size)}, above the VAULTLINE_MAX_ARCHIVE_BYTES ceiling of ${gb(ceiling)}. Raise or unset VAULTLINE_MAX_ARCHIVE_BYTES to archive it.`, { sourcePath: absolute, bytes: size, ceiling });
+    fail("source_unreadable", `${absolute} is ${gb(size)}, above the SEALKEEP_MAX_ARCHIVE_BYTES ceiling of ${gb(ceiling)}. Raise or unset SEALKEEP_MAX_ARCHIVE_BYTES to archive it.`, { sourcePath: absolute, bytes: size, ceiling });
 }
 /**
  * The archive whose bytes are still a prefix of this source, and how many.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sealkeep",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "type": "module",
   "description": "Sealkeep by SPALA AI \u2014 your AI coding-agent history, sealed, searchable, and shared across your machines.",
   "license": "SEE LICENSE IN LICENSE",
@@ -39,7 +39,9 @@
     "control-plane": "tsx src/control-plane-cli.ts",
     "dashboard": "tsx src/dashboard-cli.ts",
     "build:site": "node tools/build-site.mjs",
-    "bundle:site": "node tools/build-site.mjs && cd dist/site && zip -q -X ../site.zip index.html && cd - >/dev/null && echo \"dist/site.zip ready ($(wc -c < dist/site.zip) bytes)\""
+    "bundle:site": "node tools/build-site.mjs && cd dist/site && zip -q -X ../site.zip index.html && cd - >/dev/null && echo \"dist/site.zip ready ($(wc -c < dist/site.zip) bytes)\"",
+    "acceptance": "node scripts/acceptance.mjs",
+    "acceptance:managed": "node scripts/acceptance.mjs --managed"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",