honeytree 1.2.7 → 1.3.0

package/bin/honeydew.js

@@ -64,15 +64,12 @@ if (command === "init") {
   console.log("  Done.");
 } else if (command === "rewards") {
   const { isLoggedIn } = await import("../src/auth.js");
-  const { syncRewards, printRewardsStatus } = await import("../src/rewards.js");
-  const { readForest } = await import("../src/state.js");
+  const { syncRewards, printRewardsStatus, getRewards } = await import("../src/rewards.js");
   if (isLoggedIn()) {
     console.log("  Fetching rewards...");
     await syncRewards();
   }
-  const forest = readForest();
-  const realTrees = 0; // local doesn't know real trees; printRewardsStatus uses cached data
-  printRewardsStatus(realTrees);
+  printRewardsStatus(getRewards().realTrees || 0);
 } else if (command === "status") {
   const { getAuth } = await import("../src/auth.js");
   const auth = getAuth();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honeytree",
-  "version": "1.2.7",
+  "version": "1.3.0",
   "description": "code with claude, and watch your forest grow! ",
   "type": "module",
   "bin": {

package/src/auth.js

@@ -29,6 +29,51 @@ export function isLoggedIn() {
   return !!(auth && auth.access_token);
 }
 
+// Supabase access tokens live ~1 hour. Trade the stored refresh token for a
+// fresh pair so syncs keep working between logins.
+export async function refreshAuth(apiUrl) {
+  apiUrl = apiUrl || process.env.HONEYTREE_API_URL || "https://www.tryhoney.xyz";
+  const auth = getAuth();
+  if (!auth || !auth.refresh_token) return null;
+  try {
+    const res = await fetch(`${apiUrl}/api/auth/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refresh_token: auth.refresh_token }),
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data.access_token) return null;
+    const next = {
+      ...auth,
+      access_token: data.access_token,
+      refresh_token: data.refresh_token || auth.refresh_token,
+    };
+    saveAuth(next);
+    return next;
+  } catch {
+    return null;
+  }
+}
+
+// Bearer fetch that retries once through a token refresh on 401.
+// Returns null when not logged in.
+export async function authedFetch(url, options = {}) {
+  const auth = getAuth();
+  if (!auth || !auth.access_token) return null;
+  const doFetch = (token) =>
+    fetch(url, {
+      ...options,
+      headers: { ...(options.headers || {}), Authorization: `Bearer ${token}` },
+    });
+  let res = await doFetch(auth.access_token);
+  if (res.status === 401) {
+    const refreshed = await refreshAuth();
+    if (refreshed) res = await doFetch(refreshed.access_token);
+  }
+  return res;
+}
+
 export async function loginWithDevice(apiUrl = process.env.HONEYTREE_API_URL || "https://www.tryhoney.xyz") {
   const res = await fetch(`${apiUrl}/api/auth/device`, { method: "POST" });
   const contentType = res.headers.get("content-type") || "";
@@ -74,6 +119,7 @@ export async function loginWithDevice(apiUrl = process.env.HONEYTREE_API_URL ||
       if (data.status === "complete") {
         saveAuth({
           access_token: data.access_token,
+          refresh_token: data.refresh_token || null,
           user_id: data.user.id,
           username: data.user.username,
         });

package/src/plant.js

@@ -1,6 +1,6 @@
 import { getSprite } from "./sprites.js";
 import { getUnlockedVarietyKeys } from "./rewards.js";
-import { unlockedPool, pickSpecies } from "./varieties.js";
+import { eraSpecies, pickSpecies } from "./varieties.js";
 import { createEmptyForest, readForest, writeForest } from "./state.js";
 import { findBadgeFile, writeBadgeSVG } from "./badge.js";
 import { migrateLayout } from "./migrate.js";
@@ -107,7 +107,7 @@ export async function tick(shape = null) {
   let type = shape?.type;
   let variant = shape?.variant ?? null;
   if (!type) {
-    const species = pickSpecies(unlockedPool(getUnlockedVarietyKeys()));
+    const species = pickSpecies(eraSpecies(getUnlockedVarietyKeys()));
     type = species.type;
     variant = species.variant ?? null;
   }

package/src/rewards.js

@@ -46,16 +46,19 @@ export async function syncRewards(apiUrl) {
   if (!auth || !auth.access_token) return null;
 
   try {
-    const res = await fetch(`${apiUrl}/api/rewards`, {
-      headers: { Authorization: `Bearer ${auth.access_token}` },
-    });
+    const { authedFetch } = await import("./auth.js");
+    // authedFetch refreshes the 1-hour access token and retries once on 401.
+    const res = await authedFetch(`${apiUrl}/api/rewards`);
+    if (!res || !res.ok) return null;
 
-    if (!res.ok) return null;
-
-    const { rewards } = await res.json();
+    const { rewards, real_trees_planted } = await res.json();
     const unlocked = rewards.filter((r) => r.unlocked);
     const slugs = unlocked.map((r) => r.slug);
 
+    const prev = getRewards();
+    const prevReal = typeof prev.realTrees === "number" ? prev.realTrees : null;
+    const serverReal = typeof real_trees_planted === "number" ? real_trees_planted : 0;
+
     const data = {
       badges: unlocked.map((r) => ({ slug: r.slug, label: r.label, description: r.description })),
       cherry: slugs.includes("cherry"),
@@ -63,17 +66,41 @@ export async function syncRewards(apiUrl) {
       oak: slugs.includes("oak"),
       ancient: slugs.includes("ancient"),
       mythic: slugs.includes("mythic"),
-      celebrated: getRewards().celebrated,
+      celebrated: prev.celebrated,
+      realTrees: serverReal,
       username: auth.username || "",
     };
 
     saveRewards(data);
+
+    // A real tree was paid for since we last looked: the old forest is cleared
+    // and a fresh era begins (all new trees take the latest unlocked variety).
+    // The cumulative prompt counter survives, so "virtual trees grown" on the
+    // site keeps its total. First sync after upgrade only sets the baseline.
+    if (prevReal !== null && serverReal > prevReal) {
+      await wipeForestForNewEra();
+    }
+
     return data;
   } catch {
     return null;
   }
 }
 
+// Clear all trees locally and push the empty forest up so the dashboard
+// mirrors the reset. totalPrompts/streak are kept.
+async function wipeForestForNewEra() {
+  const { readForest, writeForest } = await import("./state.js");
+  const forest = readForest();
+  if (!forest) return;
+  forest.trees = [];
+  writeForest(forest);
+  try {
+    const { syncToCloud } = await import("./sync.js");
+    await syncToCloud(forest);
+  } catch {}
+}
+
 // Print rewards status to console
 export function printRewardsStatus(realTreesPlanted = 0) {
   const rewards = getRewards();

package/src/sync.js

@@ -1,4 +1,4 @@
-import { getAuth, saveAuth } from "./auth.js";
+import { getAuth, saveAuth, authedFetch } from "./auth.js";
 import { readForest } from "./state.js";
 
 const API_URL = process.env.HONEYTREE_API_URL || "https://www.tryhoney.xyz";
@@ -18,12 +18,10 @@ export async function syncToCloud(forest) {
   }));
 
   try {
-    const res = await fetch(`${API_URL}/api/sync`, {
+    // authedFetch refreshes the access token and retries once on 401.
+    const res = await authedFetch(`${API_URL}/api/sync`, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${auth.access_token}`,
-      },
+      headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         count: forest.totalPrompts,
         streak: forest.streak || 0,
@@ -31,9 +29,10 @@ export async function syncToCloud(forest) {
       }),
     });
 
-    if (res.ok) {
-      auth.lastSyncedPrompts = forest.totalPrompts;
-      saveAuth(auth);
+    if (res && res.ok) {
+      const fresh = getAuth() || auth;
+      fresh.lastSyncedPrompts = forest.totalPrompts;
+      saveAuth(fresh);
     }
   } catch {
     // Silently fail — sync is best-effort

package/src/turn.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import { readForest, createEmptyForest } from "./state.js";
 import { getUnlockedVarietyKeys } from "./rewards.js";
-import { unlockedPool, pickSpecies } from "./varieties.js";
+import { eraSpecies, pickSpecies } from "./varieties.js";
 import { getPlantWidth, findOpenX } from "./plant.js";
 import { writeActiveSession, readActiveSession, clearActiveSession } from "./session.js";
 import { readTurnTokens } from "./transcript.js";
@@ -22,7 +22,7 @@ export function startTurn(payload) {
   if (!transcript_path) return;
 
   const forest = readForest() ?? createEmptyForest();
-  const species = pickSpecies(unlockedPool(getUnlockedVarietyKeys()));
+  const species = pickSpecies(eraSpecies(getUnlockedVarietyKeys()));
   const type = species.type;
   const variant = species.variant ?? null;
   const width = getPlantWidth(forest);

package/src/varieties.js

@@ -11,6 +11,17 @@ export const VARIETIES = [
   { key: "mythic",   threshold: 10, label: "Mythic",         species: [{ type: "mythic" }] },
 ];
 
+// The forest grows one variety at a time: each real-tree payment wipes the
+// forest and starts a new era where every tree takes the LATEST unlocked
+// variety. Standard (birch/willow) before any unlock.
+export function eraSpecies(unlockedKeys = []) {
+  const keys = new Set(unlockedKeys);
+  for (let i = VARIETIES.length - 1; i >= 1; i--) {
+    if (keys.has(VARIETIES[i].key)) return VARIETIES[i].species;
+  }
+  return VARIETIES[0].species;
+}
+
 // Build the species pool from the set of unlocked variety keys.
 // `standard` is always included.
 export function unlockedPool(unlockedKeys = []) {