Merge pull request #202 from val-town/avoid-localstorage

Replace localStorage access with a basic JSON file

Author: tmcw

src/cmd/upgrade.ts

@@ -1,12 +1,9 @@
 import { UpgradeCommand } from "@cliffy/command/upgrade";
 import { JsrProvider } from "@cliffy/command/upgrade/provider/jsr";
-import {
-  JSR_ENTRY_NAME,
-  SAW_AS_LATEST_VERSION,
-  VT_MINIMUM_FLAGS,
-} from "~/consts.ts";
+import { JSR_ENTRY_NAME, VT_MINIMUM_FLAGS } from "~/consts.ts";
 import manifest from "../../deno.json" with { type: "json" };
 import { colors } from "@cliffy/ansi/colors";
+import { vtCheckCache } from "~/vt/VTCheckCache.ts";
 
 const provider = new JsrProvider({ package: JSR_ENTRY_NAME });
 
@@ -15,15 +12,19 @@ export async function registerOutdatedWarning() {
   const list = await provider.getVersions(JSR_ENTRY_NAME);
   const currentVersion = manifest.version;
   if (list.latest !== currentVersion) {
-    const lastSawAsLatestVersion = localStorage.getItem(SAW_AS_LATEST_VERSION);
+    const lastSawAsLatestVersion = await vtCheckCache
+      .getLastSawAsLatestVersion();
     if (lastSawAsLatestVersion !== list.latest) {
-      addEventListener("unload", () => { // The last thing logged
+      addEventListener("unload", async () => {
+        // The last thing logged
         if (Deno.args.includes("upgrade")) return; // Don't show when they are upgrading
 
-        localStorage.setItem(SAW_AS_LATEST_VERSION, currentVersion);
+        await vtCheckCache.setLastSawAsLatestVersion(currentVersion);
         console.log(
           `A new version of vt is available: ${
-            colors.bold(list.latest)
+            colors.bold(
+              list.latest,
+            )
           }! Run \`${colors.bold("vt upgrade")}\` to update.`,
         );
       });

src/consts.ts

@@ -8,16 +8,9 @@ export const DEFAULT_BRANCH_NAME = "main";
 export const PROGRAM_NAME = "vt";
 export const API_KEY_KEY = "VAL_TOWN_API_KEY";
 
-export const ALWAYS_IGNORE_PATTERNS: string[] = [
-  ".vt",
-  ".env",
-];
+export const ALWAYS_IGNORE_PATTERNS: string[] = [".vt", ".env"];
 
-export const DEFAULT_IGNORE_PATTERNS: string[] = [
-  "*~",
-  "*.swp",
-  ".env",
-];
+export const DEFAULT_IGNORE_PATTERNS: string[] = ["*~", "*.swp", ".env"];
 
 export const DEFAULT_VAL_PRIVACY = "public";
 export const META_STATE_FILE_NAME = "state.json";
@@ -26,6 +19,13 @@ export const META_FOLDER_NAME = ".vt";
 export const ENTRYPOINT_NAME = "vt.ts";
 export const META_IGNORE_FILE_NAME = ".vtignore";
 export const GLOBAL_VT_CONFIG_PATH = join(xdg.config(), PROGRAM_NAME);
+/** The directory that contains GLOBAL_VT_META_FILE_PATH */
+export const GLOBAL_VT_META_PATH = join(xdg.cache(), PROGRAM_NAME);
+export const GLOBAL_VT_META_FILE_PATH = join(
+  xdg.cache(),
+  PROGRAM_NAME,
+  "upgrade-status.json",
+);
 
 export const DEFAULT_WRAP_WIDTH = 80;
 export const MAX_WALK_UP_LEVELS = 100;
@@ -46,10 +46,10 @@ export const STATUS_STYLES: Record<
 };
 
 export const WARNING_MESSAGES: Record<ItemWarning, string> = {
-  "bad_name": "Invalid file name",
-  "binary": "File has binary content",
-  "empty": "File is empty",
-  "too_large": "File is too large",
+  bad_name: "Invalid file name",
+  binary: "File has binary content",
+  empty: "File is empty",
+  too_large: "File is too large",
 };
 
 export const DEFAULT_VAL_TYPE = "script";
@@ -66,21 +66,21 @@ export const ValItems = [
 export const JSON_INDENT_SPACES = 4;
 
 export const ValItemColors: Record<ValItemType, (s: string) => string> = {
-  "script": (s: string) => colors.rgb24(s, 0x4287f5),
-  "http": (s: string) => colors.rgb24(s, 0x22c55e),
-  "interval": (s: string) => colors.rgb24(s, 0xd946ef),
-  "email": (s: string) => colors.rgb24(s, 0x8b5cf6),
-  "file": (s: string) => colors.dim(s),
-  "directory": (s: string) => colors.dim(s),
+  script: (s: string) => colors.rgb24(s, 0x4287f5),
+  http: (s: string) => colors.rgb24(s, 0x22c55e),
+  interval: (s: string) => colors.rgb24(s, 0xd946ef),
+  email: (s: string) => colors.rgb24(s, 0x8b5cf6),
+  file: (s: string) => colors.dim(s),
+  directory: (s: string) => colors.dim(s),
 };
 
 export const TypeToTypeStr: Record<ValItemType, string> = {
-  "script": "script",
-  "http": "http",
-  "email": "email",
-  "interval": "cron",
-  "file": "file",
-  "directory": "directory",
+  script: "script",
+  http: "http",
+  email: "email",
+  interval: "cron",
+  file: "file",
+  directory: "directory",
 };
 
 export const VAL_TOWN_VAL_URL_REGEX = /val\.town\/x\/([^\/]+)\/([^\/]+)/;
@@ -94,12 +94,12 @@ export const GET_API_KEY_URL = "https://www.val.town/settings/api";
 export const VT_README_URL =
   "https://github.com/val-town/vt/blob/main/README.md";
 export const TYPE_PRIORITY: Record<ValItemType, number> = {
-  "script": 0,
-  "email": 1,
-  "http": 2,
-  "directory": 3,
-  "file": 4,
-  "interval": 5,
+  script: 0,
+  email: 1,
+  http: 2,
+  directory: 3,
+  file: 4,
+  interval: 5,
 };
 
 export const VAL_ITEM_NAME_REGEX = /^[a-zA-Z0-9\-_.]+$/;

src/vt/VTCheckCache.ts

@@ -0,0 +1,53 @@
+import type z from "zod";
+import {
+  AUTH_CACHE_LOCALSTORE_ENTRY,
+  GLOBAL_VT_META_FILE_PATH,
+  GLOBAL_VT_META_PATH,
+  SAW_AS_LATEST_VERSION,
+} from "../consts.ts";
+import { VTCheckCacheFile } from "~/vt/vt/schemas.ts";
+import { ensureDir } from "@std/fs";
+
+/**
+ * Cheap singleton that stores state about authentication and upgrade
+ * checking in a JSON file in the XDG cache directory.
+ */
+class VTCheckCache {
+  async #read() {
+    await ensureDir(GLOBAL_VT_META_PATH);
+    try {
+      const text = await Deno.readTextFile(GLOBAL_VT_META_FILE_PATH);
+      const json = JSON.parse(text);
+      return VTCheckCacheFile.parse(json);
+    } catch {
+      return {};
+    }
+  }
+  async getAuthChecked() {
+    return (await this.#read())[AUTH_CACHE_LOCALSTORE_ENTRY];
+  }
+  async getLastSawAsLatestVersion() {
+    return (await this.#read())[SAW_AS_LATEST_VERSION];
+  }
+  async setAuthCheckedToNow() {
+    return await this.setItem(
+      AUTH_CACHE_LOCALSTORE_ENTRY,
+      new Date().toISOString(),
+    );
+  }
+  async setLastSawAsLatestVersion(version: string) {
+    return await this.setItem(SAW_AS_LATEST_VERSION, version);
+  }
+  async setItem(key: keyof z.infer<typeof VTCheckCacheFile>, value: string) {
+    const before = await this.#read();
+    await Deno.writeTextFile(
+      GLOBAL_VT_META_FILE_PATH,
+      JSON.stringify({
+        ...before,
+        [key]: value,
+      }),
+    );
+  }
+}
+
+export const vtCheckCache = new VTCheckCache();

src/vt/vt/schemas.ts

@@ -1,9 +1,11 @@
 import { join } from "@std/path";
 import { z } from "zod";
 import {
+  AUTH_CACHE_LOCALSTORE_ENTRY,
   DEFAULT_EDITOR_TEMPLATE,
   GLOBAL_VT_CONFIG_PATH,
   META_IGNORE_FILE_NAME,
+  SAW_AS_LATEST_VERSION,
 } from "~/consts.ts";
 
 /**
@@ -12,57 +14,68 @@ import {
  * Contains required metadata for operations that require context about the val
  * town directory you are in, like the Val that it represents.
  */
-export const VTStateSchema = z.object({
-  project: z.object({
-    id: z.string().uuid(),
-  }).optional(),
-  val: z.object({
-    id: z.string().uuid(),
-    // Project -> Val migration: This lets old meta.jsons that have a project.id
-    // still parse, and we transform them below. That means this ID is always
-    // populated.
-  }).catch({ id: "" }),
-  branch: z.object({
-    id: z.string().uuid(),
-    version: z.number().gte(0),
-  }),
-  lastRun: z.object({
-    pid: z.number().gte(0),
-    time: z.string().refine((val) => !isNaN(Date.parse(val)), {}),
-  }),
-}).transform((data) => {
-  const result = { ...data };
-  if (data.project) {
-    result.val = structuredClone(data.project);
-    delete result.project;
-  }
-  return result;
-}); // Silently inject the Val field, to prepare for future migration
+export const VTStateSchema = z
+  .object({
+    project: z
+      .object({
+        id: z.string().uuid(),
+      })
+      .optional(),
+    val: z
+      .object({
+        id: z.string().uuid(),
+        // Project -> Val migration: This lets old meta.jsons that have a project.id
+        // still parse, and we transform them below. That means this ID is always
+        // populated.
+      })
+      .catch({ id: "" }),
+    branch: z.object({
+      id: z.string().uuid(),
+      version: z.number().gte(0),
+    }),
+    lastRun: z.object({
+      pid: z.number().gte(0),
+      time: z.string().refine((val) => !isNaN(Date.parse(val)), {}),
+    }),
+  })
+  .transform((data) => {
+    const result = { ...data };
+    if (data.project) {
+      result.val = structuredClone(data.project);
+      delete result.project;
+    }
+    return result;
+  }); // Silently inject the Val field, to prepare for future migration
 
 /**
  * JSON schema for the config.yaml file for configuration storage.
  */
 export const VTConfigSchema = z.object({
-  apiKey: z.string()
+  apiKey: z
+    .string()
     .refine((val) => val === null || val.length === 32 || val.length === 33, {
       message: "API key must be 32-33 characters long when provided",
     })
     .nullable(),
-  globalIgnoreFiles: z.preprocess(
-    (input) => {
+  globalIgnoreFiles: z
+    .preprocess((input) => {
       if (typeof input === "string") {
-        return input.split(",").map((s) => s.trim()).filter(Boolean);
+        return input
+          .split(",")
+          .map((s) => s.trim())
+          .filter(Boolean);
       }
       return input;
-    },
-    z.array(z.string()),
-  ).optional(),
-  dangerousOperations: z.object({
-    confirmation: z.union([
-      z.boolean(),
-      z.enum(["true", "false"]).transform((val) => val === "true"),
-    ]),
-  }).optional(),
+    }, z.array(z.string()))
+    .optional(),
+  dangerousOperations: z
+    .object({
+      confirmation: z.union([
+        z.boolean(),
+        z.enum(["true", "false"]).transform((val) => val === "true"),
+      ]),
+    })
+    .optional(),
   editorTemplate: z.string().optional(), // a Val URI
 });
 
@@ -74,3 +87,8 @@ export const DefaultVTConfig: z.infer<typeof VTConfigSchema> = {
   },
   editorTemplate: DEFAULT_EDITOR_TEMPLATE,
 };
+
+export const VTCheckCacheFile = z.object({
+  [SAW_AS_LATEST_VERSION]: z.string().optional(),
+  [AUTH_CACHE_LOCALSTORE_ENTRY]: z.coerce.date().optional(),
+});

vt.ts

@@ -2,24 +2,20 @@
 import "@std/dotenv/load";
 import { ensureGlobalVtConfig, globalConfig } from "~/vt/VTConfig.ts";
 import { onboardFlow } from "~/cmd/flows/onboard.ts";
-import {
-  API_KEY_KEY,
-  AUTH_CACHE_LOCALSTORE_ENTRY,
-  AUTH_CACHE_TTL,
-} from "~/consts.ts";
+import { API_KEY_KEY, AUTH_CACHE_TTL } from "~/consts.ts";
 import { colors } from "@cliffy/ansi/colors";
 import sdk from "~/sdk.ts";
 import { registerOutdatedWarning } from "~/cmd/upgrade.ts";
+import { vtCheckCache } from "~/vt/VTCheckCache.ts";
 
 await ensureGlobalVtConfig();
 
 async function isApiKeyValid(): Promise<boolean> {
   // Since we run this on every invocation of vt, it makes sense to only check
   // if the api key is still valid every so often.
-
-  const lastAuthAt = localStorage.getItem(AUTH_CACHE_LOCALSTORE_ENTRY);
+  const lastAuthAt = await vtCheckCache.getAuthChecked();
   const hoursSinceLastAuth = lastAuthAt
-    ? (new Date().getTime() - new Date(lastAuthAt).getTime())
+    ? new Date().getTime() - lastAuthAt.getTime()
     : Infinity;
   if (hoursSinceLastAuth < AUTH_CACHE_TTL) return true;
 
@@ -31,15 +27,15 @@ async function isApiKeyValid(): Promise<boolean> {
   });
 
   if (resp.ok) {
-    localStorage.setItem(AUTH_CACHE_LOCALSTORE_ENTRY, new Date().toISOString());
+    await vtCheckCache.setAuthCheckedToNow();
     return true;
   }
 
   return resp.status !== 401;
 }
 
 async function ensureValidApiKey() {
-  if (Deno.env.has(API_KEY_KEY) && await isApiKeyValid()) return;
+  if (Deno.env.has(API_KEY_KEY) && (await isApiKeyValid())) return;
 
   {
     const { apiKey } = await globalConfig.loadConfig();