@nodiusxyz/solana-agent-kit 0.0.0-stage → 0.1.1

package/dist/internal/app.js

@@ -0,0 +1,422 @@
+import { PublicKey, VersionedTransaction } from "@solana/web3.js";
+import { required, integer, rawAmount, solLamports } from "./config.js";
+import { Transport, estimateBuy, finite, sendFee } from "./transport.js";
+import { admitBuy } from "./admission.js";
+import { monitor } from "./monitor.js";
+import { Journal, fingerprint, outcome } from "./journal.js";
+import { decodeBase64, verifyUnsigned, checkSignature, inspectEnvelope, decodeBuilderUnsigned, } from "./safety.js";
+function safeLamports(n) {
+    if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 0)
+        throw new Error("Unsafe response lamports");
+    return BigInt(n);
+}
+function requireAuth(env) {
+    if (!env.NODIUS_API_KEY)
+        throw new Error("Set NODIUS_API_KEY in environment (not CLI)");
+}
+async function identity(t, wallet) {
+    const account = await t.sdk.getBillingAccount();
+    if (account.pubkey !== wallet.toBase58())
+        throw new Error("API key billing identity does not match wallet");
+    return account;
+}
+async function submit(t, j, id, tx, emit) {
+    const signature = checkSignature(tx);
+    await j.reserveSignature(signature);
+    await j.event(id, {
+        state: "unknown",
+        phase: "submission-intent",
+        signature,
+    });
+    emit({ state: "unknown", phase: "submission-intent", signature });
+    let state = "unknown";
+    try {
+        // Exactly one SDK call. maxRetries:0 disables upstream retries, NOT the
+        // server's intentional bounded same-byte multi-leg resends.
+        const result = await t.sdk.call("sendAndConfirm", [
+            Buffer.from(tx.serialize()).toString("base64"),
+            {
+                encoding: "base64",
+                maxRetries: 0,
+                skipPreflight: false,
+                preflightCommitment: "confirmed",
+            },
+        ]);
+        if (result?.signature === signature) {
+            const chainError = result.transaction_error ?? result.chain_err ?? result.chain_error;
+            const landedError = Number.isSafeInteger(result.slot) &&
+                result.slot >= 0 &&
+                typeof result.landing_time_ms === "number" &&
+                Number.isFinite(result.landing_time_ms) &&
+                result.landing_time_ms >= 0 &&
+                typeof result.error === "string" &&
+                result.error.length > 0 &&
+                !/timed?\s*out|timeout|without confirmation/i.test(result.error);
+            const definitive = result.status === "failed" ||
+                chainError != null ||
+                result.definitive_error === true ||
+                landedError ||
+                (typeof result.error === "string" &&
+                    /^(Transaction failed on-chain:|Transaction failed:)/.test(result.error));
+            state =
+                result.status === "unknown"
+                    ? "unknown"
+                    : definitive
+                        ? "failed"
+                        : result.status !== "unknown" && result.confirmed === true
+                            ? "confirmed"
+                            : "unknown";
+        }
+    }
+    catch (error) {
+        // A signature-bound server rejection is definitive even when carried by
+        // HTTP 502. Never infer failure from a timeout/message alone, and never
+        // persist the SDK error body (it may contain transport details).
+        if (error && typeof error === "object" && "details" in error) {
+            const details = error.details;
+            const rejection = details?.error?.data ?? details;
+            if (rejection?.signature === signature && rejection?.status === "failed")
+                state = "failed";
+        }
+    }
+    await j.event(id, {
+        state,
+        phase: state === "unknown" ? "submission-uncertain" : "submission-result",
+        signature,
+    });
+    return {
+        state,
+        operation_id: id,
+        signature,
+        note: state === "unknown"
+            ? "Do not rebuild/rebroadcast. Read status and account ledger; no automatic retry."
+            : undefined,
+    };
+}
+export async function run(a, env = process.env, emit = () => { }, bridge) {
+    const origin = typeof a.endpoint === "string"
+        ? a.endpoint
+        : (env.NODIUS_ENDPOINT ?? "https://rpc.nodius.xyz");
+    if (a.command === "help")
+        return {
+            commands: [
+                "recent",
+                "monitor",
+                "inspect",
+                "migrate",
+                "buy",
+                "sell",
+                "send",
+                "status",
+            ],
+            note: "See README. Trading defaults to a read-only plan; monitoring is a paid stream.",
+        };
+    const t = new Transport(origin, env.NODIUS_API_KEY);
+    if (a.command === "monitor") {
+        requireAuth(env);
+        const filters = {};
+        if (a.mint)
+            filters.mint = new PublicKey(required(a, "mint")).toBase58();
+        if (a.kinds) {
+            const kinds = required(a, "kinds").split(",");
+            if (kinds.some((k) => !["newPair", "graduation", "walletActivity", "largeSwap"].includes(k)) ||
+                new Set(kinds).size !== kinds.length)
+                throw new Error("Unsupported/duplicate signal kinds");
+            filters.kinds = kinds;
+        }
+        return monitor(t.origin, env.NODIUS_API_KEY, {
+            seconds: integer(String(a.seconds ?? "30"), 300),
+            maxEvents: integer(String(a["max-events"] ?? "100"), 1000),
+            maxFeeCredits: a["max-fee-credits"] === undefined
+                ? undefined
+                : integer(required(a, "max-fee-credits")),
+            filters,
+        }, emit);
+    }
+    if (a.command === "recent") {
+        const limit = integer(String(a.limit ?? "20"), 50);
+        if (!limit)
+            throw new Error("Positive limit required");
+        const result = await t.sdk.signalsRecent(limit);
+        // Some server versions return a fixed preview window despite the query.
+        if (Array.isArray(result))
+            return result.slice(0, limit);
+        if (Array.isArray(result?.events)) {
+            const events = result.events.slice(0, limit);
+            return {
+                ...result,
+                events,
+                ...(typeof result.count === "number" ? { count: events.length } : {}),
+            };
+        }
+        return result;
+    }
+    if (a.command === "inspect" || a.command === "migrate") {
+        requireAuth(env);
+        const wallet = new PublicKey(required(a, "wallet"));
+        const [account, balance, onchain, version] = await Promise.all([
+            t.sdk.getBillingAccount(),
+            t.connection.getBalance(wallet),
+            t.connection.getAccountInfo(wallet),
+            t.connection.getVersion(),
+        ]);
+        return {
+            state: "read-only",
+            wallet: wallet.toBase58(),
+            billing_identity_matches: account.pubkey === wallet.toBase58(),
+            billing_account: account,
+            balance_lamports: balance,
+            onchain_account: onchain,
+            version,
+            migration: "new Connection(origin + /rpc, {httpHeaders: {X-Api-Key: process.env.NODIUS_API_KEY}, disableRetryOnRateLimit: true})",
+        };
+    }
+    const j = new Journal(typeof a.journal === "string"
+        ? a.journal
+        : (env.NODIUS_JOURNAL ?? ".nodius-journal"), env.NODIUS_API_KEY);
+    if (a.command === "status") {
+        requireAuth(env);
+        const record = await j.read(required(a, "operation-id"));
+        if (!record.signature)
+            return {
+                ...record,
+                state: record.state === "built" ? "built" : "unknown",
+                note: "No known signature: check account ledger. No rebuild/resume performed.",
+            };
+        let chain = null;
+        try {
+            const status = (await t.sdk.getSignatureStatuses([
+                record.signature,
+            ]));
+            chain = status?.value?.[0] ?? null;
+        }
+        catch {
+            /* Read failure does not authorize another send. */
+        }
+        const observed = outcome(chain);
+        const state = ["confirmed", "failed"].includes(record.state)
+            ? record.state
+            : observed;
+        await j.event(record.id, {
+            state,
+            phase: "status-reconciled",
+            signature: record.signature,
+        });
+        return { ...record, state, chain_status: chain };
+    }
+    if (a.command === "send") {
+        const bytes = decodeBase64(required(a, "signed-tx-base64"));
+        if (bytes.length > 1232)
+            throw new Error("Signed transaction exceeds packet limit");
+        let tx;
+        try {
+            tx = VersionedTransaction.deserialize(bytes);
+        }
+        catch {
+            throw new Error("Malformed signed transaction");
+        }
+        if (!Buffer.from(tx.serialize()).equals(bytes))
+            throw new Error("Noncanonical signed transaction");
+        const signature = checkSignature(tx);
+        const wallet = new PublicKey(required(a, "wallet"));
+        if (tx.message.header.numRequiredSignatures !== 1 ||
+            !tx.message.staticAccountKeys[0].equals(wallet))
+            throw new Error("Signed transaction payer/signer mismatch");
+        const maxFee = integer(required(a, "max-fee-credits"));
+        const p = await t.pricing(), fee = sendFee(p);
+        if (fee > maxFee)
+            throw new Error("Send fee exceeds cap");
+        if (!a.execute)
+            return {
+                state: "plan",
+                signature,
+                send_fee_credits: fee,
+                note: "Existing signed transaction must be independently reviewed; this command does not validate trade instructions.",
+            };
+        requireAuth(env);
+        await identity(t, wallet);
+        const id = required(a, "operation-id");
+        await j.begin(id, fingerprint({ origin, signature }), {
+            command: "send",
+            wallet: wallet.toBase58(),
+        });
+        return submit(t, j, id, tx, emit);
+    }
+    if (a.command !== "buy" && a.command !== "sell")
+        throw new Error("Unsupported command");
+    if (a["build-only"] && !a.execute)
+        throw new Error("--build-only requires --execute");
+    const side = a.command;
+    const mint = new PublicKey(required(a, "mint")), wallet = new PublicKey(required(a, "wallet"));
+    const maxSol = solLamports(required(a, "max-sol"));
+    if (maxSol <= 0n || maxSol > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new Error("Max SOL must be positive and safely representable in lamports");
+    const amount = side === "buy"
+        ? solLamports(required(a, "amount-sol"))
+        : rawAmount(required(a, "amount-raw"));
+    if (amount <= 0n ||
+        (side === "buy" &&
+            (amount > maxSol || amount > BigInt(Number.MAX_SAFE_INTEGER))))
+        throw new Error("Amount outside SOL budget");
+    const maxFee = integer(required(a, "max-fee-credits")), slippage = integer(required(a, "slippage-bps"), 9999), priority = integer(required(a, "priority-fee")), priorityCap = integer(required(a, "max-priority-fee"));
+    if (priority > priorityCap)
+        throw new Error("Priority exceeds cap");
+    if (priority > 0 && a["max-priority-lamports"] === undefined)
+        throw new Error("Nonzero priority requires --max-priority-lamports");
+    const maxPriorityLamports = BigInt(integer(String(a["max-priority-lamports"] ?? "0")));
+    const p = await t.pricing();
+    const sendCredits = sendFee(p);
+    const estimate = side === "buy" ? estimateBuy(p, amount) : null;
+    const plan = {
+        state: "plan",
+        side,
+        wallet: wallet.toBase58(),
+        mint: mint.toBase58(),
+        amount_raw: side === "sell" ? amount.toString() : undefined,
+        amount_lamports: side === "buy" ? amount.toString() : undefined,
+        max_sol_lamports: maxSol.toString(),
+        estimated_build_fee_credits: estimate,
+        send_fee_credits: sendCredits,
+        live_pricing: p,
+        limits: {
+            max_fee_credits: maxFee,
+            slippage_bps: slippage,
+            priority_fee_micro_lamports: priority,
+            max_priority_fee_micro_lamports: priorityCap,
+        },
+        warning: "Builder is charged BEFORE returning. Buy estimate is not a server-side billing cap. Sell build is unquoted; post-build cap cannot undo its charge. Send failure does not automatically refund a successful builder.",
+    };
+    if (!a.execute)
+        return plan;
+    if (side === "sell" && !a["accept-unquoted-build-charge"])
+        throw new Error("Sell charge unquoted: explicit --accept-unquoted-build-charge required BEFORE builder");
+    if (estimate !== null &&
+        estimate + (a["build-only"] ? 0 : sendCredits) > maxFee)
+        throw new Error("Estimated builder/send credits exceed cap");
+    if (!a["build-only"] && !a["ack-incomplete-policy"])
+        throw new Error("Partial instruction policy: --ack-incomplete-policy required before signing");
+    requireAuth(env);
+    if (!a["build-only"] && (!bridge || !bridge.publicKey.equals(wallet)))
+        throw new Error("Framework wallet mismatch or missing bridge");
+    const account = await identity(t, wallet);
+    if (finite(account.balance) <
+        (estimate ?? 0) + (a["build-only"] ? 0 : sendCredits))
+        throw new Error("Insufficient billing balance");
+    const admission = side === "buy"
+        ? await admitBuy(t, wallet, mint, amount, slippage, maxSol, maxPriorityLamports)
+        : undefined;
+    const id = required(a, "operation-id");
+    const intent = {
+        origin,
+        side,
+        mint: mint.toBase58(),
+        wallet: wallet.toBase58(),
+        amount: amount.toString(),
+        slippage,
+        priority,
+    };
+    await j.begin(id, fingerprint({
+        origin,
+        side,
+        mint: mint.toBase58(),
+        wallet: wallet.toBase58(),
+        amount: amount.toString(),
+    }), intent);
+    await j.event(id, { state: "unknown", phase: "builder-intent" });
+    let result;
+    try {
+        result =
+            side === "buy"
+                ? await t.sdk.executeSnipe(mint.toBase58(), Number(amount) / 1e9, slippage, { priority_fee_micro_lamports: priority })
+                : await t.sell(mint.toBase58(), amount.toString(), slippage, priority);
+    }
+    catch {
+        await j.event(id, { state: "unknown", phase: "builder-uncertain" });
+        return {
+            state: "unknown",
+            operation_id: id,
+            note: "Builder response failed. Check ledger for debit/refund; never auto-rebuild. No transaction signed/submitted.",
+        };
+    }
+    await j.event(id, {
+        state: "built",
+        phase: "builder-returned",
+        build_result: {
+            mint: new PublicKey(result.mint).toBase58(),
+            fee_credits: finite(result.fee_credits),
+            ...(side === "buy"
+                ? {
+                    tokens_out: safeLamports(result.tokens_out).toString(),
+                    max_sol_cost_lamports: safeLamports(result.max_sol_cost_lamports).toString(),
+                }
+                : {
+                    min_sol_output_lamports: safeLamports(result.min_sol_output_lamports).toString(),
+                }),
+        },
+    });
+    const charged = finite(result.fee_credits);
+    if (charged + (a["build-only"] ? 0 : sendCredits) > maxFee)
+        throw new Error("Already-charged builder plus send exceeds max credits; NOT signing/submitting (no automatic builder refund)");
+    if (result.mint !== mint.toBase58())
+        throw new Error("Builder mint mismatch");
+    const cost = safeLamports(side === "buy"
+        ? result.max_sol_cost_lamports
+        : result.min_sol_output_lamports);
+    if (side === "buy" && cost > maxSol)
+        throw new Error("Already-charged build exceeds returned SOL cap; NOT signing/submitting");
+    const tx = decodeBuilderUnsigned(result.unsigned_tx_base64);
+    if (a["build-only"]) {
+        const envelope = inspectEnvelope(tx, wallet);
+        emit({
+            state: "built",
+            operation_id: id,
+            fee_credits: charged,
+            policy: envelope,
+        });
+        return {
+            state: "built",
+            operation_id: id,
+            fee_credits: charged,
+            unsigned_tx_base64: result.unsigned_tx_base64,
+            admission,
+            policy: envelope,
+            note: "Charged unsigned construction only. No signing/submission; instruction semantics are not authorized. No automatic resume/rebuild.",
+        };
+    }
+    const inspected = verifyUnsigned(tx, wallet, {
+        side,
+        mint,
+        maxSol,
+        amountRaw: side === "sell" ? amount : undefined,
+        maxPriority: BigInt(priorityCap),
+        maxPriorityLamports,
+        requestedPriority: BigInt(priority),
+        tokensOut: side === "buy" ? safeLamports(result.tokens_out) : undefined,
+        reportedCost: cost,
+    });
+    emit({
+        state: "built",
+        operation_id: id,
+        fee_credits: charged,
+        policy: inspected,
+    });
+    // Network fees are queried against this exact message; rent is conservatively
+    // reserved for a new token ATA. Pump-side CPI rent remains outside this partial policy.
+    const fee = await t.connection.getFeeForMessage(tx.message);
+    if (fee.value === null)
+        throw new Error("Message fee unavailable/expired");
+    let overhead = safeLamports(fee.value);
+    if (inspected.ataCount)
+        overhead +=
+            BigInt(inspected.ataCount) *
+                safeLamports(await t.connection.getMinimumBalanceForRentExemption(165));
+    if (inspected.tradeCost + overhead > maxSol)
+        throw new Error("Trade + known network/ATA rent exceeds max SOL; NOT signing");
+    const originalMessage = Buffer.from(tx.message.serialize());
+    const signed = await bridge.signTransaction(tx);
+    if (!signed ||
+        !Buffer.from(signed.message.serialize()).equals(originalMessage))
+        throw new Error("Wallet mutated approved transaction message");
+    checkSignature(signed);
+    return submit(t, j, id, signed, emit);
+}

package/dist/internal/config.d.ts

@@ -0,0 +1,10 @@
+export type Args = {
+    command: string;
+    [key: string]: string | boolean;
+};
+export declare function parseArgs(argv: string[]): Args;
+export declare function required(a: Args, k: string): string;
+export declare function integer(s: string, max?: number): number;
+export declare function rawAmount(s: string): bigint;
+export declare function solLamports(s: string): bigint;
+export declare function endpoint(s: string): string;

package/dist/internal/config.js

@@ -0,0 +1,106 @@
+const common = ["endpoint"];
+const trade = [
+    "mint",
+    "wallet",
+    "keypair",
+    "max-sol",
+    "max-fee-credits",
+    "slippage-bps",
+    "priority-fee",
+    "max-priority-fee",
+    "max-priority-lamports",
+    "journal",
+    "operation-id",
+    "execute",
+    "build-only",
+    "accept-unquoted-build-charge",
+    "ack-incomplete-policy",
+];
+const flags = {
+    buy: [...trade, "amount-sol"],
+    sell: [...trade, "amount-raw"],
+    send: [
+        "tx-file",
+        "wallet",
+        "max-fee-credits",
+        "journal",
+        "operation-id",
+        "execute",
+    ],
+    inspect: ["wallet"],
+    migrate: ["wallet"],
+    recent: ["limit"],
+    monitor: ["seconds", "max-events", "mint", "kinds"],
+    status: ["journal", "operation-id"],
+    help: [],
+};
+const booleans = new Set([
+    "execute",
+    "build-only",
+    "accept-unquoted-build-charge",
+    "ack-incomplete-policy",
+]);
+export function parseArgs(argv) {
+    const command = argv[0] ?? "help";
+    if (!(command in flags))
+        throw new Error("Unknown command");
+    const out = { command };
+    for (let i = 1; i < argv.length; i++) {
+        const flag = argv[i];
+        if (!flag.startsWith("--"))
+            throw new Error("Unexpected positional argument");
+        const k = flag.slice(2);
+        if (![...common, ...flags[command]].includes(k) || k in out)
+            throw new Error("Unknown or duplicate flag: " + flag);
+        if (booleans.has(k))
+            out[k] = true;
+        else {
+            const v = argv[++i];
+            if (!v || v.startsWith("--"))
+                throw new Error("Missing value: " + flag);
+            out[k] = v;
+        }
+    }
+    return out;
+}
+export function required(a, k) {
+    const v = a[k];
+    if (typeof v !== "string" || !v)
+        throw new Error("Required --" + k);
+    return v;
+}
+export function integer(s, max = Number.MAX_SAFE_INTEGER) {
+    if (!/^(0|[1-9]\d*)$/.test(s))
+        throw new Error("Invalid integer");
+    const n = Number(s);
+    if (!Number.isSafeInteger(n) || n > max)
+        throw new Error("Integer exceeds cap");
+    return n;
+}
+export function rawAmount(s) {
+    if (!/^[1-9]\d*$/.test(s))
+        throw new Error("Amount must be a positive raw integer");
+    const n = BigInt(s);
+    if (n > 18446744073709551615n)
+        throw new Error("Amount exceeds u64");
+    return n;
+}
+export function solLamports(s) {
+    if (!/^(0|[1-9]\d*)(\.\d{1,9})?$/.test(s))
+        throw new Error("SOL requires plain decimal with <=9 places");
+    const [w, f = ""] = s.split(".");
+    return BigInt(w) * 1000000000n + BigInt(f.padEnd(9, "0"));
+}
+export function endpoint(s) {
+    const u = new URL(s);
+    if (u.username ||
+        u.password ||
+        u.search ||
+        u.hash ||
+        !["", "/"].includes(u.pathname) ||
+        !(u.protocol === "https:" ||
+            (u.protocol === "http:" &&
+                ["127.0.0.1", "localhost", "[::1]"].includes(u.hostname))))
+        throw new Error("Use HTTPS origin (HTTP only for loopback), no URL credentials or path");
+    return u.origin;
+}

package/dist/internal/journal.d.ts

@@ -0,0 +1,13 @@
+export declare function fingerprint(value: unknown): string;
+export declare function outcome(status: any): "confirmed" | "failed" | "unknown";
+export declare class Journal {
+    readonly directory: string;
+    private readonly credential?;
+    constructor(directory: string, credential?: string | undefined);
+    private encode;
+    private reserve;
+    begin(id: string, hash: string, metadata: unknown): Promise<void>;
+    reserveSignature(signature: string): Promise<void>;
+    event(id: string, event: Record<string, unknown>): Promise<void>;
+    read(id: string): Promise<any>;
+}

package/dist/internal/journal.js

@@ -0,0 +1,135 @@
+import { mkdir, open, readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+export function fingerprint(value) {
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+export function outcome(status) {
+    if (status?.err != null)
+        return "failed";
+    if (status?.confirmationStatus === "confirmed" ||
+        status?.confirmationStatus === "finalized")
+        return "confirmed";
+    return "unknown";
+}
+export class Journal {
+    directory;
+    credential;
+    constructor(directory, credential) {
+        this.directory = directory;
+        this.credential = credential;
+    }
+    encode(value) {
+        const scrub = (v) => {
+            const text = (s) => this.credential ? s.split(this.credential).join("[REDACTED]") : s;
+            if (typeof v === "string")
+                return text(v);
+            if (Array.isArray(v))
+                return v.map(scrub);
+            if (v && typeof v === "object")
+                return Object.fromEntries(Object.entries(v).map(([k, item]) => [text(k), scrub(item)]));
+            return v;
+        };
+        return JSON.stringify(scrub(value));
+    }
+    async reserve(kind, key, value) {
+        await mkdir(this.directory, { recursive: true, mode: 0o700 });
+        const path = join(this.directory, kind + "-" + fingerprint(key) + ".json");
+        const file = await open(path, "wx", 0o600);
+        try {
+            await file.writeFile(this.encode(value) + "\n");
+            await file.sync();
+        }
+        finally {
+            await file.close();
+        }
+        const dir = await open(this.directory, "r");
+        try {
+            await dir.sync();
+        }
+        finally {
+            await dir.close();
+        }
+    }
+    async begin(id, hash, metadata) {
+        if (!/^[A-Za-z0-9_-]{1,80}$/.test(id))
+            throw new Error("Invalid operation id");
+        await this.reserve("operation", id, {
+            id,
+            metadata,
+            state: "unknown",
+            phase: "reserved",
+        });
+        const lockPath = join(this.directory, "intent-lock-" + fingerprint(hash));
+        const lock = await open(lockPath, "wx", 0o600);
+        try {
+            const path = join(this.directory, "fingerprint-" + fingerprint(hash) + ".json");
+            let existing;
+            try {
+                existing = JSON.parse(await readFile(path, "utf8"));
+            }
+            catch (e) {
+                if (e.code !== "ENOENT")
+                    throw e;
+            }
+            if (existing) {
+                const previous = await this.read(existing.id);
+                if (!["confirmed", "failed"].includes(previous.state) ||
+                    !previous.signature)
+                    throw new Error("Previous identical intent is unresolved; use status, never force/rebuild");
+            }
+            const f = await open(path, "w", 0o600);
+            try {
+                await f.writeFile(this.encode({ id }) + "\n");
+                await f.sync();
+            }
+            finally {
+                await f.close();
+            }
+        }
+        finally {
+            await lock.close();
+            await unlink(lockPath);
+        }
+    }
+    async reserveSignature(signature) {
+        await this.reserve("signature", signature, { signature });
+    }
+    async event(id, event) {
+        const f = await open(join(this.directory, "events-" + fingerprint(id) + ".jsonl"), "a", 0o600);
+        try {
+            await f.writeFile(this.encode({ ...event, at: new Date().toISOString() }) + "\n");
+            await f.sync();
+        }
+        finally {
+            await f.close();
+        }
+    }
+    async read(id) {
+        let start;
+        try {
+            start = JSON.parse(await readFile(join(this.directory, "operation-" + fingerprint(id) + ".json"), "utf8"));
+        }
+        catch {
+            throw new Error("Operation not found");
+        }
+        let text = "";
+        try {
+            text = await readFile(join(this.directory, "events-" + fingerprint(id) + ".jsonl"), "utf8");
+        }
+        catch (e) {
+            if (e.code !== "ENOENT")
+                throw e;
+        }
+        for (const line of text.split("\n").filter(Boolean)) {
+            try {
+                Object.assign(start, JSON.parse(line));
+            }
+            catch {
+                start.state = "unknown";
+                start.phase = "corrupt-journal";
+            }
+        }
+        return start;
+    }
+}