@polderlabs/bizar 4.9.0 → 5.0.1

package/plugins/bizar/src/compaction.d.mts

@@ -0,0 +1,48 @@
+/**
+ * Type declarations for `./compaction.mjs`.
+ *
+ * The runtime module is shipped as plain ESM JavaScript (`.mjs`) per the
+ * brief, but its consumers in `index.ts` and `tests/compaction.test.ts`
+ * are TypeScript. Without this companion declaration file, TypeScript
+ * would type the exports as `any`, which causes cascading `implicitly
+ * has 'any' type` errors at call sites (e.g. the `texts` parameter in
+ * the test's `summarizer` stubs).
+ *
+ * The declarations here mirror the contract documented in
+ * `./compaction.mjs`. They are NOT loaded at runtime — they exist only
+ * for the type-checker.
+ */
+
+export interface CompactionResult {
+    compacted: boolean;
+    reason?: "below_threshold";
+    sessionId?: string;
+    threshold?: number;
+    preservedRecent?: number;
+    atMessages?: number;
+    ratio?: number | null;
+}
+
+export interface MaybeCompactSessionOpts {
+    sessionId: string;
+    messageCount: number;
+    currentUsage: { total?: number } | null | undefined;
+    maxContext: number | null | undefined;
+    summarizer: (texts: string[]) => Promise<string>;
+    preserveRecent?: number;
+}
+
+export function shouldCompact(
+    usage: { total?: number } | null | undefined,
+    maxContext: number | null | undefined,
+): boolean;
+
+export function maybeCompactSession(opts: MaybeCompactSessionOpts): Promise<CompactionResult>;
+
+export function getCompactionThreshold(): number;
+
+export function setCompactionThreshold(value: number): void;
+
+export function resetCompactionDefaults(): void;
+
+export function getDefaultPreserveRecent(): number;

package/plugins/bizar/src/compaction.mjs

@@ -0,0 +1,192 @@
+/**
+ * compaction.mjs
+ *
+ * Context-window compaction gate.
+ *
+ * Monitors a chat session's context-usage ratio and reports whether the
+ * session has reached the compaction threshold (default 50% of the model's
+ * max-context window). When the ratio crosses the threshold, callers can
+ * trigger summarization of the older message history while preserving a
+ * configurable recent tail so the model retains short-term continuity.
+ *
+ * Spec contract:
+ *   - The threshold is the *ratio* `usage.total / maxContext`, NOT an
+ *     absolute token count. This makes the gate model-agnostic — it works
+ *     whether the model has a 32k, 128k, or 1M context window.
+ *   - `shouldCompact` is a pure function: same inputs → same output, no I/O.
+ *   - `maybeCompactSession` is async to match the real summarizer signature
+ *     but performs no I/O itself when below threshold — it short-circuits.
+ *   - Threshold is mutable via `setCompactionThreshold` and is validated
+ *     against the range [0.1, 1.0]. A throw is the right signal here —
+ *     misconfiguration should fail loudly at startup, not silently use a
+ *     bad value at runtime.
+ *   - Threshold uses `let` (not `const`) so the setter can mutate it.
+ *     The reference spec used `const` and would throw a TypeError on
+ *     assignment; this implementation keeps the API but fixes the bug.
+ */
+
+const PRESERVE_RECENT_MESSAGES_DEFAULT = 10;
+const MIN_THRESHOLD = 0.1;
+const MAX_THRESHOLD = 1.0;
+
+// Module-level threshold. Exposed via get/set for tunability.
+// Exported as a number via getCompactionThreshold(); the underlying binding
+// is private (not exported) so callers cannot bypass validation by writing
+// to it directly.
+let compactionThreshold = 0.5;
+
+/**
+ * Returns `true` when `usage.total / maxContext` meets or exceeds the
+ * compaction threshold. `false` when below, or when either input is
+ * missing/invalid (defensive default).
+ *
+ * @param {{ total?: number } | null | undefined} usage
+ *   Object with a `total` token count, or null/undefined.
+ * @param {number | null | undefined} maxContext
+ *   Maximum context window size in tokens.
+ * @returns {boolean}
+ */
+export function shouldCompact(usage, maxContext) {
+  if (!usage || typeof usage.total !== "number") return false;
+  if (typeof maxContext !== "number" || maxContext <= 0) return false;
+  const ratio = usage.total / maxContext;
+  return ratio >= compactionThreshold;
+}
+
+/**
+ * Decision-shaped result returned by `maybeCompactSession`.
+ *
+ * - When below threshold: `{ compacted: false, reason: "below_threshold", ratio }`.
+ * - When at/over threshold: `{ compacted: true, sessionId, threshold,
+ *   preservedRecent, atMessages, ratio }`.
+ *
+ * @typedef {Object} CompactionResult
+ * @property {boolean} compacted
+ * @property {"below_threshold"} [reason]              when compacted=false
+ * @property {string} [sessionId]
+ * @property {number} [threshold]                     the threshold at decision time
+ * @property {number} [preservedRecent]               how many recent messages to keep verbatim
+ * @property {number} [atMessages]                    message count at decision time
+ * @property {number} [ratio]                         usage.total / maxContext
+ */
+
+/**
+ * Decide whether to compact and, if so, record the decision. The summarizer
+ * is NOT invoked here — that is the caller's responsibility. This function
+ * is the decision gate, not the executor. (The summarizer receives an
+ * `Array<string>` of older messages and returns a single summary string.)
+ *
+ * @param {Object}   opts
+ * @param {string}   opts.sessionId
+ * @param {number}   opts.messageCount                total messages in the session
+ * @param {{ total?: number } | null | undefined} opts.currentUsage
+ * @param {number | null | undefined} opts.maxContext
+ * @param {(texts: string[]) => Promise<string>} opts.summarizer
+ *   Async summarizer used by the caller when `compacted === true`. Not invoked
+ *   here. Accepting it as a parameter documents the contract for downstream
+ *   callers without forcing this function to do I/O.
+ * @param {number}   [opts.preserveRecent=10]         how many recent messages to keep verbatim
+ * @returns {Promise<CompactionResult>}
+ */
+export async function maybeCompactSession({
+  sessionId,
+  messageCount,
+  currentUsage,
+  maxContext,
+  // summarizer is accepted for API symmetry with downstream callers; we do
+  // not invoke it here because compaction execution lives in the plugin
+  // hook layer, not in this pure decision gate.
+  summarizer, // eslint-disable-line no-unused-vars
+  preserveRecent = PRESERVE_RECENT_MESSAGES_DEFAULT,
+}) {
+  if (typeof sessionId !== "string" || sessionId === "") {
+    // Misuse — caller forgot a sessionId. Refuse rather than silently
+    // returning below_threshold, which would mask a real bug upstream.
+    throw new Error("maybeCompactSession: sessionId is required");
+  }
+
+  if (!shouldCompact(currentUsage, maxContext)) {
+    const ratio = computeRatio(currentUsage, maxContext);
+    return { compacted: false, reason: "below_threshold", ratio };
+  }
+
+  const ratio = computeRatio(currentUsage, maxContext);
+  return {
+    compacted: true,
+    sessionId,
+    threshold: compactionThreshold,
+    preservedRecent: preserveRecent,
+    atMessages: messageCount,
+    ratio,
+  };
+}
+
+/**
+ * Return the current compaction threshold (0.0–1.0).
+ *
+ * @returns {number}
+ */
+export function getCompactionThreshold() {
+  return compactionThreshold;
+}
+
+/**
+ * Set the compaction threshold. Validates the new value is in the range
+ * `[0.1, 1.0]` and is a finite number. Throws on invalid input.
+ *
+ * The minimum of 0.1 prevents pathological "compact at 10%" configurations
+ * that would shred the conversation on the first reply. The maximum of 1.0
+ * means "compact only when the context is full" — anything above 1.0 would
+ * mean "never compact", which `shouldCompact` already handles correctly, so
+ * we reject it for clarity.
+ *
+ * @param {number} value
+ * @returns {void}
+ */
+export function setCompactionThreshold(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Invalid compaction threshold: ${value} (must be a finite number)`);
+  }
+  if (value < MIN_THRESHOLD || value > MAX_THRESHOLD) {
+    throw new Error(
+      `Invalid compaction threshold: ${value} (must be in [${MIN_THRESHOLD}, ${MAX_THRESHOLD}])`,
+    );
+  }
+  compactionThreshold = value;
+}
+
+/**
+ * Reset the threshold and preserve-count to their defaults. Exposed for
+ * tests and for plugin re-init (so a hot-reload doesn't carry stale state).
+ *
+ * @returns {void}
+ */
+export function resetCompactionDefaults() {
+  compactionThreshold = 0.5;
+}
+
+/**
+ * Return the number of recent messages that the default policy preserves
+ * verbatim when compacting.
+ *
+ * @returns {number}
+ */
+export function getDefaultPreserveRecent() {
+  return PRESERVE_RECENT_MESSAGES_DEFAULT;
+}
+
+// --- Internal helpers -----------------------------------------------------
+
+/**
+ * Compute `usage.total / maxContext`, or `null` when either input is
+ * missing/invalid. Returns a number in `[0, +Infinity)` for valid inputs.
+ *
+ * @param {{ total?: number } | null | undefined} usage
+ * @param {number | null | undefined} maxContext
+ * @returns {number | null}
+ */
+function computeRatio(usage, maxContext) {
+  if (!usage || typeof usage.total !== "number") return null;
+  if (typeof maxContext !== "number" || maxContext <= 0) return null;
+  return usage.total / maxContext;
+}

package/plugins/bizar/tests/compaction.test.ts

@@ -0,0 +1,264 @@
+/**
+ * compaction.test.ts
+ *
+ * Spec contract for the compaction gate (see src/compaction.mjs):
+ *   - `shouldCompact` returns false below 50%, true at and above 50%.
+ *   - `shouldCompact` is defensive: null usage, undefined usage.total, and
+ *     non-positive maxContext all return false (no false positives).
+ *   - `maybeCompactSession` returns `{ compacted: false, reason: "below_threshold" }`
+ *     when below the gate.
+ *   - `maybeCompactSession` returns `{ compacted: true, sessionId, threshold, … }`
+ *     when at/over the gate.
+ *   - The default threshold is 0.5.
+ *   - `setCompactionThreshold` rejects out-of-range values with a throw;
+ *     accepts in-range values silently.
+ *   - State leaks between tests are not allowed — every test that mutates
+ *     the threshold calls `resetCompactionDefaults()` in its teardown
+ *     (bun:test does not have a global afterEach, so we use try/finally).
+ *
+ * Tests use `bun:test` to match the rest of the plugin suite (see
+ * `tests/loop.test.ts`, `tests/options.test.ts`, etc.).
+ */
+
+import {
+  describe,
+  test,
+  expect,
+  beforeEach,
+  afterEach,
+} from "bun:test";
+
+import {
+  shouldCompact,
+  maybeCompactSession,
+  getCompactionThreshold,
+  setCompactionThreshold,
+  resetCompactionDefaults,
+} from "../src/compaction.mjs";
+
+/**
+ * Bun:test does not expose a global `afterEach`/`beforeEach` reset hook
+ * that runs across describe blocks, so we wire per-block setup/teardown
+ * via the standard `beforeEach`/`afterEach` imports. We also reset on
+ * entry to each test as a belt-and-braces guarantee that no leak from a
+ * prior test (run in the same process by `bun test`) can poison state.
+ */
+beforeEach(() => {
+  resetCompactionDefaults();
+});
+
+afterEach(() => {
+  resetCompactionDefaults();
+});
+
+describe("shouldCompact", () => {
+  test("does not compact below 50%", () => {
+    expect(shouldCompact({ total: 40000 }, 100000)).toBe(false);
+  });
+
+  test("does not compact at 49.99%", () => {
+    expect(shouldCompact({ total: 49999 }, 100000)).toBe(false);
+  });
+
+  test("compacts at exactly 50%", () => {
+    expect(shouldCompact({ total: 50000 }, 100000)).toBe(true);
+  });
+
+  test("compacts above 50%", () => {
+    expect(shouldCompact({ total: 80000 }, 100000)).toBe(true);
+  });
+
+  test("compacts at 100% (full context)", () => {
+    expect(shouldCompact({ total: 100000 }, 100000)).toBe(true);
+  });
+
+  test("does not compact with null usage", () => {
+    expect(shouldCompact(null, 100000)).toBe(false);
+  });
+
+  test("does not compact with undefined usage", () => {
+    expect(shouldCompact(undefined, 100000)).toBe(false);
+  });
+
+  test("does not compact when usage.total is missing", () => {
+    expect(shouldCompact({}, 100000)).toBe(false);
+  });
+
+  test("does not compact with non-positive maxContext", () => {
+    expect(shouldCompact({ total: 50000 }, 0)).toBe(false);
+    expect(shouldCompact({ total: 50000 }, -1)).toBe(false);
+  });
+
+  test("respects a non-default threshold (0.7)", () => {
+    setCompactionThreshold(0.7);
+    expect(shouldCompact({ total: 60000 }, 100000)).toBe(false);
+    expect(shouldCompact({ total: 70000 }, 100000)).toBe(true);
+    expect(shouldCompact({ total: 80000 }, 100000)).toBe(true);
+  });
+});
+
+describe("getCompactionThreshold / setCompactionThreshold", () => {
+  test("default threshold is 0.5", () => {
+    expect(getCompactionThreshold()).toBe(0.5);
+  });
+
+  test("setCompactionThreshold rejects 0 (below minimum)", () => {
+    expect(() => setCompactionThreshold(0)).toThrow(/Invalid compaction threshold/);
+  });
+
+  test("setCompactionThreshold rejects 0.05 (below minimum 0.1)", () => {
+    expect(() => setCompactionThreshold(0.05)).toThrow(/Invalid compaction threshold/);
+  });
+
+  test("setCompactionThreshold rejects 1.5 (above maximum)", () => {
+    expect(() => setCompactionThreshold(1.5)).toThrow(/Invalid compaction threshold/);
+  });
+
+  test("setCompactionThreshold rejects NaN", () => {
+    expect(() => setCompactionThreshold(Number.NaN)).toThrow(/Invalid compaction threshold/);
+  });
+
+  test("setCompactionThreshold rejects Infinity", () => {
+    expect(() => setCompactionThreshold(Number.POSITIVE_INFINITY)).toThrow(
+      /Invalid compaction threshold/,
+    );
+  });
+
+  test("setCompactionThreshold rejects non-number values", () => {
+    expect(() => setCompactionThreshold("0.5" as unknown as number)).toThrow(
+      /Invalid compaction threshold/,
+    );
+    expect(() => setCompactionThreshold(null as unknown as number)).toThrow(
+      /Invalid compaction threshold/,
+    );
+  });
+
+  test("setCompactionThreshold accepts 0.1 (lower bound)", () => {
+    expect(() => setCompactionThreshold(0.1)).not.toThrow();
+    expect(getCompactionThreshold()).toBe(0.1);
+  });
+
+  test("setCompactionThreshold accepts 1.0 (upper bound)", () => {
+    expect(() => setCompactionThreshold(1.0)).not.toThrow();
+    expect(getCompactionThreshold()).toBe(1.0);
+  });
+
+  test("setCompactionThreshold accepts 0.7 (in-range)", () => {
+    expect(() => setCompactionThreshold(0.7)).not.toThrow();
+    expect(getCompactionThreshold()).toBe(0.7);
+  });
+});
+
+describe("maybeCompactSession", () => {
+  test("returns below_threshold when under limit", async () => {
+    const r = await maybeCompactSession({
+      sessionId: "s1",
+      messageCount: 5,
+      currentUsage: { total: 30000 },
+      maxContext: 100000,
+      summarizer: async (texts) => texts.join(" "),
+    });
+    expect(r.compacted).toBe(false);
+    expect(r.reason).toBe("below_threshold");
+    expect(r.ratio).toBeCloseTo(0.3);
+  });
+
+  test("triggers when over limit", async () => {
+    const r = await maybeCompactSession({
+      sessionId: "s1",
+      messageCount: 100,
+      currentUsage: { total: 60000 },
+      maxContext: 100000,
+      summarizer: async () => "summary",
+    });
+    expect(r.compacted).toBe(true);
+    expect(r.sessionId).toBe("s1");
+    expect(r.atMessages).toBe(100);
+    expect(r.threshold).toBe(0.5);
+    expect(r.preservedRecent).toBe(10);
+    expect(r.ratio).toBeCloseTo(0.6);
+  });
+
+  test("triggers at exactly the threshold (50000/100000 = 0.5)", async () => {
+    const r = await maybeCompactSession({
+      sessionId: "edge",
+      messageCount: 42,
+      currentUsage: { total: 50000 },
+      maxContext: 100000,
+      summarizer: async () => "",
+    });
+    expect(r.compacted).toBe(true);
+    expect(r.atMessages).toBe(42);
+  });
+
+  test("respects a custom preserveRecent override", async () => {
+    const r = await maybeCompactSession({
+      sessionId: "s2",
+      messageCount: 200,
+      currentUsage: { total: 90000 },
+      maxContext: 100000,
+      summarizer: async () => "",
+      preserveRecent: 25,
+    });
+    expect(r.compacted).toBe(true);
+    expect(r.preservedRecent).toBe(25);
+  });
+
+  test("respects a non-default threshold", async () => {
+    setCompactionThreshold(0.8);
+    const r1 = await maybeCompactSession({
+      sessionId: "s3",
+      messageCount: 50,
+      currentUsage: { total: 70000 },
+      maxContext: 100000,
+      summarizer: async () => "",
+    });
+    expect(r1.compacted).toBe(false);
+
+    const r2 = await maybeCompactSession({
+      sessionId: "s3",
+      messageCount: 50,
+      currentUsage: { total: 85000 },
+      maxContext: 100000,
+      summarizer: async () => "",
+    });
+    expect(r2.compacted).toBe(true);
+    expect(r2.threshold).toBe(0.8);
+  });
+
+  test("does not invoke the summarizer when below threshold", async () => {
+    let called = false;
+    await maybeCompactSession({
+      sessionId: "s4",
+      messageCount: 10,
+      currentUsage: { total: 1000 },
+      maxContext: 100000,
+      summarizer: async () => {
+        called = true;
+        return "should-not-run";
+      },
+    });
+    expect(called).toBe(false);
+  });
+
+  test("throws when sessionId is missing", async () => {
+    await expect(
+      maybeCompactSession({
+        sessionId: "",
+        messageCount: 1,
+        currentUsage: { total: 999999 },
+        maxContext: 100000,
+        summarizer: async () => "",
+      }),
+    ).rejects.toThrow(/sessionId is required/);
+  });
+});
+
+describe("resetCompactionDefaults", () => {
+  test("restores the threshold to 0.5 after a custom set", () => {
+    setCompactionThreshold(0.9);
+    expect(getCompactionThreshold()).toBe(0.9);
+    resetCompactionDefaults();
+    expect(getCompactionThreshold()).toBe(0.5);
+  });
+});

package/templates/deploy/cloudflare/README.md

@@ -0,0 +1,32 @@
+# Cloudflare Deployment
+
+This directory contains the scaffold files for deploying the Bizar dashboard
+to Cloudflare Pages + Workers. Generated by `bizar deploy --to cloudflare`.
+
+## Files
+
+- `wrangler.toml` — Cloudflare Pages project configuration
+- `functions/index.js` — Workers function entry (handles SPA routing)
+- `public/` — Static dashboard bundle (built from `npm run build`)
+
+## How it works
+
+1. The dashboard is built with `npm run build` → `dist/`
+2. Built assets are copied to `public/`
+3. `wrangler.toml` configures the Pages project
+4. `functions/index.js` handles SPA routing for non-asset paths
+5. The deployment is pushed to Cloudflare via wrangler CLI or REST API
+
+## Manual deployment
+
+```bash
+# Install wrangler
+npm i -g wrangler
+
+# Login to Cloudflare
+wrangler login
+
+# Deploy from the scaffold directory
+cd bizar-deploy/cloudflare
+npx wrangler pages deploy . --project-name bizar-dash
+```

package/templates/deploy/cloudflare/functions-index.template.js

@@ -0,0 +1,15 @@
+// Cloudflare Workers entry — Bizar dashboard
+// This file becomes functions/index.js in the deployment.
+
+export async function onRequest(context) {
+  const { request, env } = context;
+  const url = new URL(request.url);
+
+  // Serve static assets from Pages KV
+  if (url.pathname.startsWith("/assets/")) {
+    return env.ASSETS.fetch(request);
+  }
+
+  // SPA fallback — serve index.html for all non-asset routes
+  return env.ASSETS.fetch(new Request(url.origin + "/index.html", request));
+}

package/templates/deploy/cloudflare/wrangler.toml.template

@@ -0,0 +1,9 @@
+name = "bizar-dash"
+main = "functions/index.js"
+compatibility_date = "2025-01-01"
+
+[site]
+  bucket = "./public"
+
+[env.production]
+  routes = ["bizar-dash.*.pages.dev/*"]

package/templates/deploy/docker/.env.template

@@ -0,0 +1,16 @@
+# Bizar dashboard environment variables
+# Copy this file to .env and fill in your values.
+
+# Dashboard
+# BIZAR_DASHBOARD_PORT=4097
+# BIZAR_DASHBOARD_HOST=0.0.0.0
+
+# OpenTelemetry (optional)
+# BIZAR_OTEL=1
+# OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318
+
+# Tailscale (optional)
+# TAILSCALE_AUTHKEY=tskey-auth-xxxxxxxxxxxxxxxxxxxx
+
+# Headroom context compression (optional)
+# HEADROOM_ENABLED=1

package/templates/deploy/docker/README.md

@@ -0,0 +1,58 @@
+# Docker Deployment
+
+This directory contains the scaffold files for deploying the Bizar dashboard
+as a Docker container. Generated by `bizar deploy --to docker`.
+
+## Files
+
+- `docker-compose.yml` — Docker Compose configuration for self-hosting
+- `.env.template` — Environment variable template
+
+## Prerequisites
+
+- Docker Engine 24+ (or Docker Desktop)
+- Docker Compose v2 (`docker compose` plugin)
+- A container registry account (GitHub Container Registry, Docker Hub, etc.)
+
+## How it works
+
+The `bizar deploy --to docker` command:
+
+1. Builds the Docker image using the project's `Dockerfile`
+2. Tags it with `<registry>/<image-name>:<version>` and `:latest`
+3. Pushes both tags to the registry
+4. With `--compose`: generates `docker-compose.yml` + `.env.template`
+
+## Self-hosting with Docker Compose
+
+```bash
+# Generate compose files
+bizar deploy --to docker --compose
+
+# Edit .env with your settings
+cp .env.template .env
+$EDITOR .env
+
+# Start the dashboard
+cd bizar-deploy/docker
+docker compose up -d
+
+# Check logs
+docker compose logs -f
+
+# Stop
+docker compose down
+```
+
+## Manual build & push
+
+```bash
+# Build
+docker build -t ghcr.io/my-org/bizar-dash:latest .
+
+# Push
+docker push ghcr.io/my-org/bizar-dash:latest
+
+# Run
+docker run -d -p 4097:4097 ghcr.io/my-org/bizar-dash:latest
+```

package/templates/deploy/docker/docker-compose.template.yml

@@ -0,0 +1,23 @@
+version: "3.8"
+
+services:
+  bizar-dash:
+    image: ghcr.io/your-org/bizar-dash:latest
+    container_name: bizar-dash
+    restart: unless-stopped
+    ports:
+      - "4097:4097"
+      - "4098:4098"
+    environment:
+      - BIZAR_DASHBOARD_PORT=4097
+      - BIZAR_DASHBOARD_HOST=0.0.0.0
+      - NODE_ENV=production
+    env_file:
+      - .env
+    volumes:
+      - bizar-config:/home/bizar/.config/bizar
+      - bizar-memory:/home/bizar/.local/share/bizar/memory
+
+volumes:
+  bizar-config:
+  bizar-memory:

package/templates/deploy/fly/README.md

@@ -0,0 +1,35 @@
+# Fly.io Deployment
+
+This directory contains the scaffold file for deploying the Bizar dashboard
+to Fly.io. Generated by `bizar deploy --to fly`.
+
+## Files
+
+- `fly.toml` — Fly.io application configuration
+
+## Prerequisites
+
+- [flyctl](https://fly.io/docs/getting-started/installing-flyctl/) installed
+- A Fly.io account (sign up: `flyctl auth signup`)
+- Dockerfile at the project root (already present in BizarHarness)
+
+## How it works
+
+1. `fly.toml` references the project's `Dockerfile` for building
+2. The app is launched on Fly.io (if not already created)
+3. `flyctl deploy` builds and deploys the container
+4. The dashboard is served at `https://<app-name>.fly.dev`
+
+## Manual deployment
+
+```bash
+# Login
+flyctl auth login
+
+# Launch (first time)
+cd bizar-deploy/fly
+flyctl launch --name bizar-dash --region iad --now
+
+# Deploy (subsequent times)
+flyctl deploy --app bizar-dash
+```