tapline-host 1.6.2 → 1.7.0

package/dist/unlockcmd.d.ts

@@ -0,0 +1,44 @@
+import type { AuditSink } from "./auditlog.js";
+import { type PidLockDeps } from "./pidlock.js";
+/**
+ * AGENT-TOOLS 1.14.2 §22.3 and §19.5: the way out of a stuck lock. The pid-liveness lock never takes over an empty or unreadable
+ * lock (that can only be a holder that crashed mid-write where hard links aren't available), so a person looks and removes it:
+ * `tapline schedule unlock NAME` and `tapline grants unlock --policy FILE`. Both remove a lock (and its `.takeover`) only when no
+ * holder is proven alive, and write an audit line (§23).
+ */
+type Outcome = {
+    text: string;
+    code: number;
+};
+/** A schedule's run lock: `<config>/schedules/<name>.lock`. */
+export declare function scheduleLockPath(configDir: string, name: string): string;
+/** `tapline schedule unlock NAME`. Audit: a `schedule` line (§23). */
+export declare function scheduleUnlock(name: string | undefined, options: {
+    configDir: string;
+    audit: AuditSink;
+    deps: PidLockDeps;
+}): Outcome;
+/**
+ * `tapline grants unlock --policy FILE`. Audit: an `approval` line. It is a person's own decision about the policy file, not a
+ * grant's use and not a revocation of any grant (§23's `revoke` is a grant revoked), so `approval` fits best.
+ */
+export declare function grantsUnlock(policy: string | undefined, options: {
+    audit: AuditSink;
+    deps: PidLockDeps;
+}): Outcome;
+export interface StuckLock {
+    /** The lock file (or `.takeover`) that is stuck. */
+    path: string;
+    /** Why: empty, unreadable, or held by a dead process. */
+    why: string;
+    /** The command that removes it. */
+    command: string;
+}
+export declare const quote: (text: string) => string;
+/** Every stuck lock doctor can see: the schedule run locks always, the policy edit lock when a policy file is given. */
+export declare function findStuckLocks(options: {
+    configDir: string;
+    policyFile?: string;
+    deps: PidLockDeps;
+}): StuckLock[];
+export {};

package/dist/unlockcmd.js

@@ -0,0 +1,80 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { policyEditLockPath } from "./grants.js";
+import { inspectPidLock, stuckWords, unlockPidLock } from "./pidlock.js";
+import { SCHEDULE_NAME, schedulesDir } from "./schedule.js";
+/** A schedule's run lock: `<config>/schedules/<name>.lock`. */
+export function scheduleLockPath(configDir, name) {
+    return join(schedulesDir(configDir), `${name}.lock`);
+}
+function describe(what, result) {
+    if (result.status === "none")
+        return { text: `${what} has no lock; nothing to remove.`, code: 0 };
+    if (result.status === "live") {
+        return {
+            text: `${what}'s lock is held by a live process (pid ${result.pid}); nothing was removed. Wait for it to finish, or stop that process first.`,
+            code: 1,
+        };
+    }
+    if (result.status === "failed") {
+        const done = result.removed.map((r) => `Removed ${r.path} (${r.why}).`);
+        return { text: [...done, `Couldn't remove ${result.path ?? "the lock"}: it changed or can't be deleted. Look at it and try again.`].join("\n"), code: 1 };
+    }
+    return { text: result.removed.map((r) => `Removed ${r.path} (${r.why}).`).join("\n"), code: 0 };
+}
+/** `tapline schedule unlock NAME`. Audit: a `schedule` line (§23). */
+export function scheduleUnlock(name, options) {
+    if (name === undefined)
+        return { text: "Usage: tapline schedule unlock NAME", code: 2 };
+    if (!SCHEDULE_NAME.test(name))
+        return { text: `"${name}" isn't a schedule's name.`, code: 2 };
+    const result = unlockPidLock(options.deps, scheduleLockPath(options.configDir, name));
+    if (result.status === "removed" || result.status === "failed") {
+        if (result.removed.length > 0)
+            options.audit.write({ kind: "schedule", name, detail: `unlocked (${result.removed.map((r) => r.why).join("; ")})` });
+    }
+    return describe(`Schedule "${name}"`, result);
+}
+/**
+ * `tapline grants unlock --policy FILE`. Audit: an `approval` line. It is a person's own decision about the policy file, not a
+ * grant's use and not a revocation of any grant (§23's `revoke` is a grant revoked), so `approval` fits best.
+ */
+export function grantsUnlock(policy, options) {
+    if (policy === undefined)
+        return { text: "grants unlock needs the policy file: tapline grants unlock --policy FILE", code: 2 };
+    const result = unlockPidLock(options.deps, policyEditLockPath(policy));
+    if (result.removed.length > 0)
+        options.audit.write({ kind: "approval", name: "policy edit lock", detail: `unlocked (${result.removed.map((r) => r.why).join("; ")})` });
+    return describe("The policy file", result);
+}
+export const quote = (text) => (/^[\w./\\:@=+-]+$/.test(text) ? text : `"${text.replace(/"/g, '\\"')}"`);
+/** Every stuck lock doctor can see: the schedule run locks always, the policy edit lock when a policy file is given. */
+export function findStuckLocks(options) {
+    const found = [];
+    let files = [];
+    try {
+        files = readdirSync(schedulesDir(options.configDir)).sort();
+    }
+    catch {
+        // no schedules folder: no run locks
+    }
+    for (const file of files) {
+        const match = /^(.+)\.lock(\.takeover)?$/.exec(file);
+        const name = match?.[1];
+        if (name === undefined || !SCHEDULE_NAME.test(name))
+            continue;
+        const path = join(schedulesDir(options.configDir), file);
+        const state = inspectPidLock(options.deps, path);
+        if (state.state === "stuck")
+            found.push({ path, why: stuckWords(state), command: `tapline schedule unlock ${name}` });
+    }
+    if (options.policyFile !== undefined) {
+        for (const path of [policyEditLockPath(options.policyFile), `${policyEditLockPath(options.policyFile)}.takeover`]) {
+            const state = inspectPidLock(options.deps, path);
+            if (state.state === "stuck")
+                found.push({ path, why: stuckWords(state), command: `tapline grants unlock --policy ${quote(options.policyFile)}` });
+        }
+    }
+    return found;
+}
+//# sourceMappingURL=unlockcmd.js.map

package/dist/unlockcmd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unlockcmd.js","sourceRoot":"","sources":["../src/unlockcmd.ts"],"names":[],"mappings":"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"}

package/dist/uxcheck.d.ts

@@ -53,6 +53,7 @@ export declare const uxResultSchema: z.ZodObject<{
             selected: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
             checked: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>>;
             row: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            fromOthers: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
         }, z.core.$strip>>>;
         where: z.ZodOptional<z.ZodObject<{
             frame: z.ZodOptional<z.ZodObject<{

package/dist/vault.d.ts

@@ -0,0 +1,75 @@
+/**
+ * AGENT-TOOLS 1.14 §20.2: where the vault is kept. One format for both tools:
+ * - Windows: `{"version": 2, "protected": "dpapi-user", "data": <base64 of CryptProtectData(UTF-8 JSON)>}`, current-user scope,
+ *   with the fixed entropy below. Tapline calls DPAPI through PowerShell, Tapwright through ctypes; the blob is the same.
+ * - macOS: a keychain generic password (service below, account = the file's real path), the same UTF-8 JSON as its data;
+ *   the file holds `{"version": 2, "protected": "keychain"}`.
+ * - Plain: `{"version": 2, "vault": {...}}`, for test data only.
+ * Nothing here ever quotes a value: a failure says why in words.
+ */
+/** The optional entropy of the DPAPI blob (§20.2). */
+export declare const DPAPI_ENTROPY: Buffer<ArrayBuffer>;
+/** The keychain service (§20.2). */
+export declare const KEYCHAIN_SERVICE = "tapline-tapwright-vault";
+export type Protection = "dpapi-user" | "keychain";
+/** What the person is told at every start while the vault is a plain file (§20.2). */
+export declare function plainWarning(path: string): string;
+export interface ProcResult {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}
+/** Runs a program with text on its stdin. The text may hold a secret: it never goes on the command line. */
+export type ProcRunner = (command: string, args: string[], input: string, signal?: AbortSignal) => Promise<ProcResult>;
+export declare const spawnRunner: ProcRunner;
+/** CryptProtectData and CryptUnprotectData, current-user scope, with the entropy given. */
+export interface Dpapi {
+    protect(data: Buffer, entropy: Buffer, signal?: AbortSignal): Promise<Buffer>;
+    unprotect(blob: Buffer, entropy: Buffer, signal?: AbortSignal): Promise<Buffer>;
+}
+export declare function powershellDpapi(run?: ProcRunner): Dpapi;
+/** The macOS keychain's generic passwords under the vault's service. */
+export interface Keychain {
+    /** The stored UTF-8 JSON, or null when there is no entry for this account. */
+    read(account: string, signal?: AbortSignal): Promise<string | null>;
+    write(account: string, json: string, signal?: AbortSignal): Promise<void>;
+}
+/** A chunked vault that can't be put back together: a chunk is missing or the checksum differs. Never a partial vault. */
+export declare class VaultIncompleteError extends Error {
+}
+/** Through the `security` CLI. The data goes in on stdin (`security -i`), so it is never in the process list. */
+export declare function securityKeychain(run?: ProcRunner): Keychain;
+export interface VaultDeps {
+    platform: NodeJS.Platform;
+    dpapi: Dpapi;
+    keychain: Keychain;
+}
+export declare function realVaultDeps(): VaultDeps;
+/** The protection this system has, if any. */
+export declare function protectionOf(platform: NodeJS.Platform): Protection | null;
+export declare function realPathOf(path: string): string;
+/** A file's top level, read for how it is kept (protected or plain). `null` when it isn't an object. */
+export declare function peekFile(text: string): {
+    protected?: string;
+    data?: string;
+} | null;
+export declare class VaultOpenError extends Error {
+}
+/** The decrypted JSON text of a protected file. Throws `VaultOpenError` with the reason (never a value). */
+export declare function openProtected(path: string, file: {
+    protected?: string;
+    data?: string;
+}, deps: VaultDeps, signal?: AbortSignal): Promise<string>;
+/**
+ * `tapline vault protect FILE` (§20.2): reads a plain vault file and writes it in this system's protected form. A version 1
+ * file becomes version 2. Other top-level keys (Tapwright's `otp`) travel inside the protected data untouched.
+ */
+export declare function protectVaultFile(path: string, deps?: VaultDeps): Promise<{
+    ok: true;
+    how: Protection;
+} | {
+    ok: false;
+    message: string;
+}>;
+/** The words `tapline vault protect` answers. */
+export declare function protectedLine(path: string, how: Protection): string;

package/dist/vault.js

@@ -0,0 +1,395 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { vaultFileSchema } from "./accounts.js";
+/**
+ * AGENT-TOOLS 1.14 §20.2: where the vault is kept. One format for both tools:
+ * - Windows: `{"version": 2, "protected": "dpapi-user", "data": <base64 of CryptProtectData(UTF-8 JSON)>}`, current-user scope,
+ *   with the fixed entropy below. Tapline calls DPAPI through PowerShell, Tapwright through ctypes; the blob is the same.
+ * - macOS: a keychain generic password (service below, account = the file's real path), the same UTF-8 JSON as its data;
+ *   the file holds `{"version": 2, "protected": "keychain"}`.
+ * - Plain: `{"version": 2, "vault": {...}}`, for test data only.
+ * Nothing here ever quotes a value: a failure says why in words.
+ */
+/** The optional entropy of the DPAPI blob (§20.2). */
+export const DPAPI_ENTROPY = Buffer.from("tapline-tapwright-vault-v2", "utf8");
+/** The keychain service (§20.2). */
+export const KEYCHAIN_SERVICE = "tapline-tapwright-vault";
+/** What the person is told at every start while the vault is a plain file (§20.2). */
+export function plainWarning(path) {
+    return `Note: the vault file ${path} is not encrypted; keep test data in it only.`;
+}
+export const spawnRunner = (command, args, input, signal) => new Promise((done) => {
+    let out = "";
+    let err = "";
+    let child;
+    if (signal?.aborted === true) {
+        done({ code: null, stdout: "", stderr: "aborted" });
+        return;
+    }
+    try {
+        child = spawn(command, args, { windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
+    }
+    catch {
+        done({ code: null, stdout: "", stderr: "couldn't start" });
+        return;
+    }
+    // An abort (the caller's time ran out) kills the program: a stalled keychain or PowerShell call never outlives its wait.
+    const onAbort = () => {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch {
+            // already gone
+        }
+        done({ code: null, stdout: "", stderr: "aborted" });
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout?.setEncoding("utf8").on("data", (chunk) => (out += chunk));
+    child.stderr?.setEncoding("utf8").on("data", (chunk) => (err += chunk));
+    child.on("error", () => done({ code: null, stdout: out, stderr: "couldn't start" }));
+    child.on("close", (code) => {
+        signal?.removeEventListener("abort", onAbort);
+        done({ code, stdout: out, stderr: err });
+    });
+    child.stdin?.on("error", () => undefined);
+    child.stdin?.end(input);
+});
+/**
+ * The script only ever sees its input on stdin: the mode, the data and the entropy, one base64 line each. Nothing secret is
+ * in the command line.
+ */
+const DPAPI_SCRIPT = [
+    "$ErrorActionPreference = 'Stop'",
+    "Add-Type -AssemblyName System.Security",
+    "$l = [Console]::In.ReadToEnd() -split '\\r?\\n'",
+    "$d = [Convert]::FromBase64String($l[1])",
+    "$e = [Convert]::FromBase64String($l[2])",
+    "$s = [System.Security.Cryptography.DataProtectionScope]::CurrentUser",
+    "if ($l[0] -eq 'protect') { $o = [System.Security.Cryptography.ProtectedData]::Protect($d, $e, $s) } else { $o = [System.Security.Cryptography.ProtectedData]::Unprotect($d, $e, $s) }",
+    "[Convert]::ToBase64String($o)",
+].join("; ");
+export function powershellDpapi(run = spawnRunner) {
+    const call = async (mode, data, entropy, signal) => {
+        const out = await run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", DPAPI_SCRIPT], `${mode}\n${data.toString("base64")}\n${entropy.toString("base64")}\n`, signal);
+        if (out.code !== 0 || out.stdout.trim() === "") {
+            throw new Error(mode === "protect" ? "Windows couldn't protect the data" : "Windows couldn't decrypt it (it was protected for another user or another computer)");
+        }
+        return Buffer.from(out.stdout.trim(), "base64");
+    };
+    return { protect: (data, entropy, signal) => call("protect", data, entropy, signal), unprotect: (blob, entropy, signal) => call("unprotect", blob, entropy, signal) };
+}
+function securityQuote(text) {
+    return `"${text.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+/**
+ * `security -i` reads at most 4095 bytes per input line, and a line is the whole command with its hex data: about 1.9 KB of vault
+ * JSON at most. A vault that fits is ONE item holding the plain vault JSON (§20.2, single form). A larger one is the chunked form
+ * (AGENT-TOOLS 1.14.1): chunk items at account `<realpath>#1`, `#2`, … hold consecutive pieces of the JSON, and the main item
+ * (account = the realpath) holds the manifest `{"chunks": n, "sha256": "<hex of the whole JSON>"}`. A reader tells the forms apart
+ * by the `chunks` key. The chunk size is the writer's own choice; the reader joins whatever is there.
+ */
+const LINE_BUDGET = 3900;
+const MIN_CHUNK = 64;
+/**
+ * Chunks that could be read as hex or as text. Each chunk's reading is decided on its own where it can be (one whose hex isn't valid
+ * UTF-8 is raw), and only the truly ambiguous ones are searched, with the manifest's sha256 as the oracle: up to 2^12 combinations.
+ * More than this many fails closed with the doctor message. The writer never stores an ambiguous chunk (see `write`).
+ */
+const MAX_AMBIGUOUS = 12;
+/** A chunked vault that can't be put back together: a chunk is missing or the checksum differs. Never a partial vault. */
+export class VaultIncompleteError extends Error {
+}
+/** The chunk count of a manifest, or null when the text is a plain vault (no `chunks` key) or not JSON. */
+function manifestOf(text) {
+    if (text === null || !text.startsWith("{"))
+        return null;
+    try {
+        const top = JSON.parse(text);
+        if (typeof top !== "object" || top === null || Array.isArray(top) || !("chunks" in top))
+            return null;
+        const { chunks, sha256 } = top;
+        return { chunks: typeof chunks === "number" && Number.isInteger(chunks) && chunks >= 1 && chunks <= 100_000 ? chunks : 0, sha256: typeof sha256 === "string" ? sha256 : null };
+    }
+    catch {
+        return null;
+    }
+}
+const chunkAccount = (account, index) => `${account}#${index}`;
+/** Through the `security` CLI. The data goes in on stdin (`security -i`), so it is never in the process list. */
+export function securityKeychain(run = spawnRunner) {
+    /**
+     * The stored text of one entry as `security -w` printed it, and the other reading when it could be hex. `security -w` prints
+     * data that isn't plain text as hex, but plain text made only of hex digits (a chunk such as "41" repeated) looks the same: both
+     * readings are kept, and the caller (the manifest's checksum, or the writer's own piece) says which one is right.
+     */
+    const readBoth = async (account, signal) => {
+        const out = await run("security", ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-a", account, "-w"], "", signal);
+        if (out.code !== 0)
+            return null;
+        const text = out.stdout.replace(/\r?\n$/, "");
+        if (text === "")
+            return null;
+        if (text.startsWith("{") || !/^[0-9a-fA-F]+$/.test(text) || text.length % 2 !== 0)
+            return { raw: text, decoded: null };
+        try {
+            const decoded = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.from(text, "hex"));
+            return { raw: text, decoded: decoded === text ? null : decoded };
+        }
+        catch {
+            return { raw: text, decoded: null };
+        }
+    };
+    /** The stored text of one entry, or null when there is none (real hex decodes to UTF-8; for a lone item the decoded reading is the one). */
+    const readText = async (account, signal) => {
+        const both = await readBoth(account, signal);
+        return both === null ? null : (both.decoded ?? both.raw);
+    };
+    const read = async (account, signal) => {
+        const text = await readText(account, signal);
+        const manifest = manifestOf(text);
+        if (manifest === null)
+            return text;
+        if (manifest.chunks === 0 || manifest.sha256 === null)
+            throw new VaultIncompleteError("the vault in the keychain is incomplete (its chunk list is unreadable)");
+        const readings = [];
+        for (let i = 1; i <= manifest.chunks; i++) {
+            signal?.throwIfAborted();
+            const chunk = await readBoth(chunkAccount(account, i), signal);
+            if (chunk === null)
+                throw new VaultIncompleteError(`the vault in the keychain is incomplete (chunk ${i} of ${manifest.chunks} is missing)`);
+            readings.push({ raw: Buffer.from(chunk.raw, "utf8"), decoded: chunk.decoded === null ? null : Buffer.from(chunk.decoded, "utf8") });
+        }
+        const wanted = manifest.sha256.toLowerCase();
+        const matches = (pieces) => {
+            const whole = Buffer.concat(pieces);
+            return createHash("sha256").update(whole).digest("hex") === wanted ? whole : null;
+        };
+        const ambiguous = readings.flatMap((r, i) => (r.decoded === null ? [] : [i]));
+        // The reading of each ambiguous chunk is whatever makes the checksum come out; the search is bounded.
+        let found = null;
+        // The two plain readings first (a long text of many non-ASCII chunks is all-decoded however many chunks there are), then the search.
+        found = matches(readings.map((r) => r.raw)) ?? matches(readings.map((r) => r.decoded ?? r.raw));
+        if (found === null && ambiguous.length <= MAX_AMBIGUOUS) {
+            for (let mask = 0; mask < 2 ** ambiguous.length && found === null; mask++) {
+                found = matches(readings.map((r, i) => {
+                    const at = ambiguous.indexOf(i);
+                    return at >= 0 && (mask >> at) & 1 ? r.decoded : r.raw;
+                }));
+            }
+        }
+        if (found === null)
+            throw new VaultIncompleteError("the vault in the keychain is incomplete (its chunks don't match their checksum)");
+        return found.toString("utf8");
+    };
+    const addLine = (account, data) => `add-generic-password -U -s ${securityQuote(KEYCHAIN_SERVICE)} -a ${securityQuote(account)} -X ${data.toString("hex")}`;
+    /** Stores one entry. The interactive mode doesn't always set the exit code, so the caller reads back what mattered. */
+    const store = async (account, data) => {
+        await run("security", ["-i"], `${addLine(account, data)}\n`);
+    };
+    /** Deletes the chunk items `from` to `to` (stale ones of an earlier, longer vault). */
+    const dropChunks = async (account, from, to) => {
+        for (let i = from; i <= to; i++)
+            await run("security", ["delete-generic-password", "-s", KEYCHAIN_SERVICE, "-a", chunkAccount(account, i)], "").catch(() => undefined);
+    };
+    return {
+        read,
+        async write(account, json) {
+            const previous = manifestOf(await readText(account))?.chunks ?? 0;
+            const data = Buffer.from(json, "utf8");
+            if (Buffer.byteLength(addLine(account, data)) <= LINE_BUDGET) {
+                await store(account, data);
+                if ((await read(account)) !== json)
+                    throw new Error("the keychain didn't keep the entry");
+                await dropChunks(account, 1, previous);
+                return;
+            }
+            const size = Math.floor((LINE_BUDGET - Buffer.byteLength(addLine(chunkAccount(account, 999_999), Buffer.alloc(0)))) / 2) - 3;
+            if (size < MIN_CHUNK)
+                throw new Error("the vault file's path is too long to store in the macOS keychain");
+            // pieces are cut at character boundaries, so every chunk is valid UTF-8 text on its own
+            const pieces = [];
+            for (let at = 0; at < data.length;) {
+                let end = Math.min(at + size, data.length);
+                while (end < data.length && end > at && ((data[end] ?? 0) & 0xc0) === 0x80)
+                    end--;
+                // A piece of only hex digits, in an even number, reads two ways (`security -w` prints data that isn't text as hex): cut it one
+                // byte short so no stored chunk is ambiguous. The reader still takes the frozen form (§20.2), so older vaults read as before.
+                if (end < data.length && end - at > 1 && (end - at) % 2 === 0 && /^[0-9a-fA-F]+$/.test(data.subarray(at, end).toString("latin1")))
+                    end--;
+                pieces.push(data.subarray(at, end));
+                at = end;
+            }
+            // chunks #1…#n first, then the manifest, then the stale chunks of an earlier, longer vault
+            for (const [i, piece] of pieces.entries()) {
+                await store(chunkAccount(account, i + 1), piece);
+                const back = await readBoth(chunkAccount(account, i + 1));
+                if (back === null || (back.raw !== piece.toString("utf8") && back.decoded !== piece.toString("utf8")))
+                    throw new Error("the keychain didn't keep the entry");
+            }
+            await store(account, Buffer.from(JSON.stringify({ chunks: pieces.length, sha256: createHash("sha256").update(data).digest("hex") }), "utf8"));
+            if ((await read(account)) !== json)
+                throw new Error("the keychain didn't keep the entry");
+            await dropChunks(account, pieces.length + 1, previous);
+        },
+    };
+}
+export function realVaultDeps() {
+    return { platform: process.platform, dpapi: powershellDpapi(), keychain: securityKeychain() };
+}
+/** The protection this system has, if any. */
+export function protectionOf(platform) {
+    return platform === "win32" ? "dpapi-user" : platform === "darwin" ? "keychain" : null;
+}
+export function realPathOf(path) {
+    try {
+        return realpathSync(resolve(path));
+    }
+    catch {
+        return resolve(path);
+    }
+}
+/** A file's top level, read for how it is kept (protected or plain). `null` when it isn't an object. */
+export function peekFile(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+            return null;
+        const top = parsed;
+        return { ...(typeof top.protected === "string" ? { protected: top.protected } : {}), ...(typeof top.data === "string" ? { data: top.data } : {}) };
+    }
+    catch {
+        return null;
+    }
+}
+export class VaultOpenError extends Error {
+}
+/** The decrypted JSON text of a protected file. Throws `VaultOpenError` with the reason (never a value). */
+export async function openProtected(path, file, deps, signal) {
+    if (file.protected === "dpapi-user") {
+        if (deps.platform !== "win32")
+            throw new VaultOpenError("the file is protected with Windows DPAPI and can only be opened on Windows");
+        if (file.data === undefined || file.data === "")
+            throw new VaultOpenError("the protected file holds no data");
+        try {
+            return (await deps.dpapi.unprotect(Buffer.from(file.data, "base64"), DPAPI_ENTROPY, signal)).toString("utf8");
+        }
+        catch (error) {
+            throw new VaultOpenError(error instanceof Error ? error.message : "Windows couldn't decrypt it");
+        }
+    }
+    if (file.protected === "keychain") {
+        if (deps.platform !== "darwin")
+            throw new VaultOpenError("the file is protected with the macOS keychain and can only be opened on a Mac");
+        let found;
+        try {
+            found = await deps.keychain.read(realPathOf(path), signal);
+        }
+        catch (error) {
+            // a chunked vault with a missing chunk or a wrong checksum: fail closed, and say why (§20.2)
+            if (error instanceof VaultIncompleteError)
+                throw new VaultOpenError(error.message);
+            found = null;
+        }
+        if (found === null)
+            throw new VaultOpenError("the keychain has no entry for this file's path (the file was moved, or it was protected by another user)");
+        return found;
+    }
+    throw new VaultOpenError(`the file says it is protected as "${file.protected ?? ""}", which this Tapline doesn't know`);
+}
+/**
+ * `tapline vault protect FILE` (§20.2): reads a plain vault file and writes it in this system's protected form. A version 1
+ * file becomes version 2. Other top-level keys (Tapwright's `otp`) travel inside the protected data untouched.
+ */
+export async function protectVaultFile(path, deps = realVaultDeps()) {
+    const file = resolve(path);
+    if (!existsSync(file))
+        return { ok: false, message: `the vault file ${file} doesn't exist.` };
+    const how = protectionOf(deps.platform);
+    if (how === null)
+        return { ok: false, message: "this system has no protection for the vault (Windows DPAPI or the macOS keychain); the file stays plain, for test data only." };
+    const real = realPathOf(file);
+    let text;
+    try {
+        text = readFileSync(real, "utf8");
+    }
+    catch {
+        return { ok: false, message: `couldn't read ${file}.` };
+    }
+    const peek = peekFile(text);
+    if (peek?.protected !== undefined)
+        return { ok: false, message: `the vault file ${file} is already protected.` };
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return { ok: false, message: `the vault file ${file} isn't valid JSON.` };
+    }
+    const top = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+    if (top === null)
+        return { ok: false, message: `the vault file ${file} isn't a vault.` };
+    let payload;
+    if (top["version"] === 2 && typeof top["vault"] === "object" && top["vault"] !== null) {
+        payload = top;
+    }
+    else if (top["version"] === 1 && typeof top["accounts"] === "object" && top["accounts"] !== null) {
+        const { accounts, version: _version, ...rest } = top;
+        const vault = {};
+        for (const [name, entry] of Object.entries(accounts)) {
+            const fields = typeof entry === "object" && entry !== null ? entry : {};
+            const { passcode, ...others } = fields;
+            const onlyPasscode = passcode !== undefined && fields["username"] === undefined && fields["password"] === undefined;
+            if (onlyPasscode) {
+                vault[name] = { kind: "phone", ...fields };
+                continue;
+            }
+            vault[name] = { kind: "account", ...others };
+            // A version 2 account has no passcode field: it moves into a phone entry of its own, so it stays stored and scrubbed.
+            if (passcode !== undefined) {
+                let phone = `${name.slice(0, 52)}_phone`;
+                for (let n = 2; Object.prototype.hasOwnProperty.call(accounts, phone) || Object.prototype.hasOwnProperty.call(vault, phone); n++)
+                    phone = `${name.slice(0, 50)}_phone${n}`;
+                vault[phone] = { kind: "phone", passcode };
+            }
+        }
+        payload = { version: 2, vault, ...rest };
+    }
+    else {
+        return { ok: false, message: `the vault file ${file} isn't a version 1 or 2 vault.` };
+    }
+    // What will be written must load: a file that doesn't would replace the plain one and leave the vault unusable (there is no unprotect).
+    const valid = vaultFileSchema.safeParse(payload);
+    if (!valid.success) {
+        const why = valid.error.issues.map((issue) => `${issue.path.join(".") || "file"}: ${issue.message}`).join("; ");
+        return { ok: false, message: `the vault file ${file} can't be protected as it is (${why}); fix it first. The file stays plain.` };
+    }
+    const json = JSON.stringify(payload);
+    try {
+        let out;
+        if (how === "dpapi-user") {
+            const blob = await deps.dpapi.protect(Buffer.from(json, "utf8"), DPAPI_ENTROPY);
+            out = JSON.stringify({ version: 2, protected: "dpapi-user", data: blob.toString("base64") });
+        }
+        else {
+            await deps.keychain.write(real, json);
+            out = JSON.stringify({ version: 2, protected: "keychain" });
+        }
+        // Written beside the file and moved in, so a failure never leaves half a file.
+        const temp = join(dirname(real), `.${Date.now().toString(36)}.vault.tmp`);
+        writeFileSync(temp, `${out}\n`, { mode: 0o600 });
+        renameSync(temp, real);
+    }
+    catch (error) {
+        return { ok: false, message: `couldn't protect the file: ${error instanceof Error ? error.message : "an error"}.` };
+    }
+    return { ok: true, how };
+}
+/** The words `tapline vault protect` answers. */
+export function protectedLine(path, how) {
+    return how === "dpapi-user"
+        ? `Protected ${resolve(path)} with Windows DPAPI (current user). Tapwright reads it too.`
+        : `Protected ${resolve(path)} in the macOS keychain (service ${KEYCHAIN_SERVICE}; the entry belongs to this path, so a moved file needs protecting again).`;
+}
+//# sourceMappingURL=vault.js.map