@bnbagent/deploy-provider-bnb 0.3.0

package/src/session.ts

@@ -0,0 +1,94 @@
+/**
+ * Session storage for the trial platform: short-lived access token + single-use
+ * refresh token, persisted at ~/.bnbagent-deploy/bnb/session.json (mode 0600).
+ *
+ * ★ Refresh tokens are SINGLE-USE (the platform rotates them and revokes the
+ *   whole session family on reuse) — always persist the newest pair atomically.
+ */
+import { existsSync } from "node:fs";
+import { chmod, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export interface Session {
+  /** The API base URL this session was minted against. */
+  apiUrl: string;
+  access_token: string;
+  refresh_token: string;
+}
+
+function sessionPath(): string {
+  const home = process.env.BNBAGENT_DEPLOY_HOME || join(homedir(), ".bnbagent-deploy");
+  return join(home, "bnb", "session.json");
+}
+
+export async function withSessionLock<T>(
+  fn: () => Promise<T>,
+  opts: { timeoutMs?: number; staleMs?: number; retryMs?: number } = {},
+): Promise<T> {
+  const p = `${sessionPath()}.lock`;
+  const timeoutMs = opts.timeoutMs ?? 60_000;
+  const staleMs = opts.staleMs ?? 5 * 60_000;
+  const retryMs = opts.retryMs ?? 50;
+  const deadline = Date.now() + timeoutMs;
+  await mkdir(dirname(p), { recursive: true });
+
+  for (;;) {
+    try {
+      const handle = await open(p, "wx", 0o600);
+      try {
+        await handle.writeFile(JSON.stringify({ pid: process.pid, acquiredAt: new Date().toISOString() }));
+        return await fn();
+      } finally {
+        await handle.close().catch(() => {});
+        await rm(p, { force: true }).catch(() => {});
+      }
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException).code !== "EEXIST") throw e;
+      try {
+        const lock = await stat(p);
+        if (Date.now() - lock.mtimeMs > staleMs) {
+          await rm(p, { force: true });
+          continue;
+        }
+      } catch (statError) {
+        if ((statError as NodeJS.ErrnoException).code === "ENOENT") continue;
+        throw statError;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for the BNB session lock (${p}).`);
+      }
+      await Bun.sleep(retryMs);
+    }
+  }
+}
+
+export async function loadSession(): Promise<Session | undefined> {
+  const p = sessionPath();
+  if (!existsSync(p)) return undefined;
+  try {
+    const s = JSON.parse(await readFile(p, "utf8")) as Session;
+    return s.access_token && s.refresh_token ? s : undefined;
+  } catch {
+    return undefined; // corrupt file → treat as signed out
+  }
+}
+
+export async function saveSession(s: Session): Promise<void> {
+  const p = sessionPath();
+  await mkdir(dirname(p), { recursive: true });
+  // Atomic + never world-readable: write to a 0600 temp file, then rename over
+  // the target (rename is atomic on the same filesystem). Avoids both the torn-
+  // write and the create-0644-then-chmod window that would briefly expose the token.
+  const tmp = `${p}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  await writeFile(tmp, JSON.stringify(s, null, 2) + "\n", { mode: 0o600 });
+  await chmod(tmp, 0o600); // umask can mask the create mode; enforce it explicitly
+  await rename(tmp, p);
+}
+
+export async function clearSession(): Promise<boolean> {
+  const p = sessionPath();
+  if (!existsSync(p)) return false;
+  await rm(p, { force: true });
+  return true;
+}