tokentracker-cli 0.76.2 → 0.77.1

package/src/lib/install-resolver.js

@@ -7,7 +7,7 @@ function resolveInstallPaths({ nativeValue, wslDir, wslValue } = {}, env = proce
   }
 
   const wslCandidate = wslValue !== undefined
-    ? (wsl.shouldProbeWsl(env) ? wslValue : null)
+    ? (wsl.shouldProbeWsl(env) && pathExists(wslValue, deps.existsSync) ? wslValue : null)
     : (wslDir && wsl.shouldProbeWsl(env) ? wsl.discoverWslHome(wslDir, { ...deps, env }) : null);
   const nativeCandidate = wsl.shouldProbeNative(env) && nativeValue
     ? pathExists(nativeValue, deps.existsSync) : null;

package/src/lib/local-api.js

@@ -525,6 +525,26 @@ function readJsonBody(req) {
   });
 }
 
+function readBodyLimited(req, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    let failed = false;
+    req.on("data", (chunk) => {
+      if (failed) return;
+      total += chunk.length;
+      if (total > maxBytes) {
+        failed = true;
+        reject(new Error(`Request body exceeds ${Math.ceil(maxBytes / 1024 / 1024)} MB`));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => { if (!failed) resolve(Buffer.concat(chunks)); });
+    req.on("error", (error) => { if (!failed) reject(error); });
+  });
+}
+
 function runSyncCommand(extraEnv = {}, opts = {}) {
   return new Promise((resolve, reject) => {
     const args = [TRACKER_BIN, "sync"];
@@ -1137,6 +1157,50 @@ function createLocalApiHandler({ queuePath }) {
       return true;
     }
 
+    // --- local Codex-compatible pet assets and package import ---
+    const localPetAssetMatch = p.match(/^\/api\/pets\/local\/([a-z0-9-]+)\/spritesheet\.webp$/);
+    if (localPetAssetMatch) {
+      const method = String(req.method || "GET").toUpperCase();
+      if (method !== "GET" && method !== "HEAD") {
+        json(res, { error: "Method Not Allowed" }, 405);
+        return true;
+      }
+      const pet = require("./pet-packages").resolvePetAsset(localPetAssetMatch[1]);
+      if (!pet) {
+        json(res, { error: "Pet not found" }, 404);
+        return true;
+      }
+      const stat = fs.statSync(pet.spritesheetPath);
+      res.writeHead(200, {
+        "Content-Type": "image/webp",
+        "Content-Length": stat.size,
+        "Cache-Control": "no-cache",
+        "X-Content-Type-Options": "nosniff",
+      });
+      if (method === "HEAD") res.end();
+      else fs.createReadStream(pet.spritesheetPath).pipe(res);
+      return true;
+    }
+
+    if (p === "/api/pets/import") {
+      if (String(req.method || "GET").toUpperCase() !== "POST") {
+        json(res, { ok: false, error: "Method Not Allowed" }, 405);
+        return true;
+      }
+      if (!isAuthorizedLocalMutation(req)) {
+        json(res, { ok: false, error: "Unauthorized" }, 401);
+        return true;
+      }
+      const pets = require("./pet-packages");
+      try {
+        const body = await readBodyLimited(req, pets.MAX_PACKAGE_BYTES);
+        json(res, { ok: true, pet: await pets.importPetZip(body) });
+      } catch (error) {
+        if (!res.headersSent) json(res, { ok: false, error: error?.message || "Pet import failed" }, 400);
+      }
+      return true;
+    }
+
     // --- Auth bridge: native OAuth flag (WebView ↔ system browser) ---
     if (p === "/api/auth-bridge/verifier") {
       const method = String(req.method || "GET").toUpperCase();
@@ -2044,6 +2108,39 @@ function createLocalApiHandler({ queuePath }) {
       return true;
     }
 
+    // --- Codex-compatible pet manager ---
+    if (p === "/functions/tokentracker-pets") {
+      const method = String(req.method || "GET").toUpperCase();
+      const pets = require("./pet-packages");
+      try {
+        if (method === "GET") {
+          json(res, { pets: pets.listInstalledPets() });
+          return true;
+        }
+        if (method === "POST") {
+          if (!isAuthorizedLocalMutation(req)) {
+            json(res, { ok: false, error: "Unauthorized" }, 401);
+            return true;
+          }
+          const body = await readJsonBody(req);
+          if (body?.action === "install_url") {
+            json(res, { ok: true, pet: await pets.installFromCodexPets(body.url || body.id) });
+            return true;
+          }
+          if (body?.action === "remove") {
+            json(res, { ok: true, ...pets.removeInstalledPet(body.id) });
+            return true;
+          }
+          json(res, { ok: false, error: "Unknown pets action" }, 400);
+          return true;
+        }
+        json(res, { ok: false, error: "Method Not Allowed" }, 405);
+      } catch (error) {
+        json(res, { ok: false, error: error?.message || "Pet operation failed" }, 400);
+      }
+      return true;
+    }
+
     // --- skills manager ---
     if (p === "/functions/tokentracker-skills") {
       const method = String(req.method || "GET").toUpperCase();

package/src/lib/pet-packages.js

@@ -0,0 +1,373 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const yauzl = require("yauzl");
+
+const PET_MANIFEST = "pet.json";
+const PET_SPRITESHEET = "spritesheet.webp";
+const MAX_PACKAGE_BYTES = 12 * 1024 * 1024;
+const MAX_MANIFEST_BYTES = 16 * 1024;
+const MAX_SPRITESHEET_BYTES = 10 * 1024 * 1024;
+const BUILTIN_IDS = new Set(["clawd", "sprout", "byte", "ember"]);
+// codex-pets.net added `kind` to pet.json long after launch, and its enum may keep
+// growing — packages published before that (and future kinds) must stay importable,
+// so kind is optional metadata validated only as a short slug.
+const KIND_RE = /^[a-z][a-z0-9-]{0,39}$/;
+const PET_ID_RE = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+const petDirectoryCache = new Map();
+
+function resolvePetsDir() {
+  return path.resolve(
+    process.env.TOKENTRACKER_PETS_DIR || path.join(os.homedir(), ".codex", "pets"),
+  );
+}
+
+function readUInt24LE(buffer, offset) {
+  return buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16);
+}
+
+function readWebpDimensions(buffer) {
+  if (
+    !Buffer.isBuffer(buffer)
+    || buffer.length < 30
+    || buffer.subarray(0, 4).toString("ascii") !== "RIFF"
+    || buffer.subarray(8, 12).toString("ascii") !== "WEBP"
+  ) {
+    throw new Error("spritesheet.webp is not a valid WebP file");
+  }
+  if (buffer.readUInt32LE(4) + 8 !== buffer.length) {
+    throw new Error("spritesheet.webp has an invalid RIFF size");
+  }
+
+  let offset = 12;
+  while (offset + 8 <= buffer.length) {
+    const type = buffer.subarray(offset, offset + 4).toString("ascii");
+    const size = buffer.readUInt32LE(offset + 4);
+    const data = offset + 8;
+    if (data + size > buffer.length) throw new Error("spritesheet.webp is truncated");
+    if (type === "VP8X" && size >= 10) {
+      return {
+        width: readUInt24LE(buffer, data + 4) + 1,
+        height: readUInt24LE(buffer, data + 7) + 1,
+      };
+    }
+    if (type === "VP8 " && size >= 10) {
+      if (buffer[data + 3] !== 0x9d || buffer[data + 4] !== 0x01 || buffer[data + 5] !== 0x2a) {
+        throw new Error("spritesheet.webp has an invalid VP8 frame header");
+      }
+      return {
+        width: buffer.readUInt16LE(data + 6) & 0x3fff,
+        height: buffer.readUInt16LE(data + 8) & 0x3fff,
+      };
+    }
+    if (type === "VP8L" && size >= 5) {
+      if (buffer[data] !== 0x2f) throw new Error("spritesheet.webp has an invalid VP8L header");
+      const bits = buffer.readUInt32LE(data + 1);
+      return { width: (bits & 0x3fff) + 1, height: ((bits >>> 14) & 0x3fff) + 1 };
+    }
+    offset = data + size + (size % 2);
+  }
+  throw new Error("spritesheet.webp has no decodable image frame");
+}
+
+function normalizeManifest(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("pet.json must contain a JSON object");
+  }
+  const id = String(value.id || "").trim().toLowerCase();
+  const displayName = String(value.displayName || "").trim();
+  const description = String(value.description || "").trim();
+  const spritesheetPath = String(value.spritesheetPath || "").trim();
+  const kind = String(value.kind || "").trim().toLowerCase();
+  const versionProvided = value.spriteVersionNumber !== undefined;
+  const spriteVersionNumber = versionProvided ? value.spriteVersionNumber : 1;
+
+  if (!PET_ID_RE.test(id)) throw new Error("pet.json id must be a lowercase URL-safe slug");
+  if (BUILTIN_IDS.has(id)) throw new Error(`${id} is reserved by a built-in TokenTracker pet`);
+  if (!displayName || displayName.length > 80) throw new Error("pet.json displayName is required and must be at most 80 characters");
+  if (!description || description.length > 280) throw new Error("pet.json description is required and must be at most 280 characters");
+  if (spritesheetPath !== PET_SPRITESHEET) throw new Error("pet.json spritesheetPath must be spritesheet.webp");
+  if (kind && !KIND_RE.test(kind)) throw new Error("pet.json kind must be a short lowercase label when provided");
+  if (versionProvided && spriteVersionNumber !== 2) {
+    throw new Error("pet.json spriteVersionNumber must be 2 when provided");
+  }
+
+  return {
+    id,
+    displayName,
+    description,
+    spritesheetPath: PET_SPRITESHEET,
+    spriteVersionNumber,
+    ...(kind ? { kind } : {}),
+  };
+}
+
+function validatePackageFiles(manifestBuffer, spritesheetBuffer) {
+  if (!Buffer.isBuffer(manifestBuffer) || manifestBuffer.length === 0 || manifestBuffer.length > MAX_MANIFEST_BYTES) {
+    throw new Error("pet.json is missing or too large");
+  }
+  if (!Buffer.isBuffer(spritesheetBuffer) || spritesheetBuffer.length === 0 || spritesheetBuffer.length > MAX_SPRITESHEET_BYTES) {
+    throw new Error("spritesheet.webp is missing or too large");
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(manifestBuffer.toString("utf8"));
+  } catch {
+    throw new Error("pet.json is not valid JSON");
+  }
+  const manifest = normalizeManifest(parsed);
+  const dimensions = readWebpDimensions(spritesheetBuffer);
+  const expectedHeight = manifest.spriteVersionNumber === 2 ? 2288 : 1872;
+  if (dimensions.width !== 1536 || dimensions.height !== expectedHeight) {
+    throw new Error(
+      `spritesheet.webp must be 1536x${expectedHeight} for a v${manifest.spriteVersionNumber} pet`,
+    );
+  }
+  return { manifest, dimensions };
+}
+
+function readZipEntries(zipBuffer) {
+  if (!Buffer.isBuffer(zipBuffer) || zipBuffer.length === 0 || zipBuffer.length > MAX_PACKAGE_BYTES) {
+    return Promise.reject(new Error("Pet package is empty or exceeds 12 MB"));
+  }
+  return new Promise((resolve, reject) => {
+    yauzl.fromBuffer(zipBuffer, { lazyEntries: true, validateEntrySizes: true }, (openError, zipfile) => {
+      if (openError) return reject(new Error(`Invalid pet package: ${openError.message}`));
+      const entries = new Map();
+      let settled = false;
+      const fail = (error) => {
+        if (settled) return;
+        settled = true;
+        try { zipfile.close(); } catch {}
+        reject(error);
+      };
+      zipfile.on("error", (error) => fail(new Error(`Invalid pet package: ${error.message}`)));
+      zipfile.on("entry", (entry) => {
+        const name = String(entry.fileName || "");
+        const unixMode = (entry.externalFileAttributes >>> 16) & 0xffff;
+        if ((unixMode & 0xf000) === 0xa000) {
+          fail(new Error("Pet package entries must not be symbolic links"));
+          return;
+        }
+        if (name !== PET_MANIFEST && name !== PET_SPRITESHEET) {
+          fail(new Error("A standard pet package must contain only pet.json and spritesheet.webp at its root"));
+          return;
+        }
+        if (entries.has(name)) {
+          fail(new Error(`Pet package contains duplicate ${name}`));
+          return;
+        }
+        const limit = name === PET_MANIFEST ? MAX_MANIFEST_BYTES : MAX_SPRITESHEET_BYTES;
+        if (entry.uncompressedSize <= 0 || entry.uncompressedSize > limit) {
+          fail(new Error(`${name} is empty or too large`));
+          return;
+        }
+        zipfile.openReadStream(entry, (streamError, stream) => {
+          if (streamError) return fail(new Error(`Could not read ${name}: ${streamError.message}`));
+          const chunks = [];
+          let total = 0;
+          stream.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > limit) {
+              stream.destroy(new Error(`${name} is too large`));
+              return;
+            }
+            chunks.push(chunk);
+          });
+          stream.on("error", (error) => fail(error));
+          stream.on("end", () => {
+            if (settled) return;
+            entries.set(name, Buffer.concat(chunks));
+            zipfile.readEntry();
+          });
+        });
+      });
+      zipfile.on("end", () => {
+        if (settled) return;
+        settled = true;
+        if (entries.size !== 2 || !entries.has(PET_MANIFEST) || !entries.has(PET_SPRITESHEET)) {
+          reject(new Error("Pet package must contain pet.json and spritesheet.webp"));
+          return;
+        }
+        resolve(entries);
+      });
+      zipfile.readEntry();
+    });
+  });
+}
+
+function publicPet(manifest, extra = {}) {
+  const assetVersion = extra.assetVersion || "";
+  return {
+    ...manifest,
+    custom: true,
+    assetUrl: `/api/pets/local/${encodeURIComponent(manifest.id)}/${PET_SPRITESHEET}${assetVersion ? `?v=${encodeURIComponent(assetVersion)}` : ""}`,
+    ...extra,
+  };
+}
+
+function loadPetDirectory(directory, expectedId = null) {
+  const stat = fs.lstatSync(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("Pet path is not a directory");
+  const manifestPath = path.join(directory, PET_MANIFEST);
+  const spritesheetPath = path.join(directory, PET_SPRITESHEET);
+  const manifestStat = fs.lstatSync(manifestPath);
+  const spriteStat = fs.lstatSync(spritesheetPath);
+  if (!manifestStat.isFile() || manifestStat.isSymbolicLink() || !spriteStat.isFile() || spriteStat.isSymbolicLink()) {
+    throw new Error("Pet assets must be regular files");
+  }
+  const cacheKey = [
+    manifestStat.mtimeMs,
+    manifestStat.size,
+    spriteStat.mtimeMs,
+    spriteStat.size,
+  ].join(":");
+  const cacheId = directory;
+  const cached = petDirectoryCache.get(cacheId);
+  if (cached?.cacheKey === cacheKey) return cached.value;
+  const result = validatePackageFiles(fs.readFileSync(manifestPath), fs.readFileSync(spritesheetPath));
+  if (expectedId && result.manifest.id !== expectedId) throw new Error("Pet directory and manifest id do not match");
+  const value = {
+    ...result,
+    directory,
+    spritesheetPath,
+    assetVersion: `${Math.trunc(spriteStat.mtimeMs)}-${spriteStat.size}`,
+  };
+  petDirectoryCache.set(cacheId, { cacheKey, value });
+  return value;
+}
+
+function listInstalledPets() {
+  const root = resolvePetsDir();
+  let names = [];
+  try { names = fs.readdirSync(root); } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+  const pets = [];
+  for (const name of names) {
+    if (!PET_ID_RE.test(name) || BUILTIN_IDS.has(name)) continue;
+    try {
+      const loaded = loadPetDirectory(path.join(root, name), name);
+      pets.push(publicPet(loaded.manifest, { assetVersion: loaded.assetVersion }));
+    } catch {
+      // Invalid or partially copied directories are ignored until they become valid.
+    }
+  }
+  return pets.sort((a, b) => a.displayName.localeCompare(b.displayName));
+}
+
+function installValidatedPackage(manifestBuffer, spritesheetBuffer) {
+  const { manifest } = validatePackageFiles(manifestBuffer, spritesheetBuffer);
+  const root = resolvePetsDir();
+  fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+  const stage = path.join(root, `.tokentracker-pet-${process.pid}-${crypto.randomBytes(6).toString("hex")}`);
+  const destination = path.join(root, manifest.id);
+  const backup = `${stage}-backup`;
+  fs.mkdirSync(stage, { mode: 0o700 });
+  try {
+    fs.writeFileSync(path.join(stage, PET_MANIFEST), `${JSON.stringify({
+      id: manifest.id,
+      displayName: manifest.displayName,
+      description: manifest.description,
+      spritesheetPath: PET_SPRITESHEET,
+      ...(manifest.spriteVersionNumber === 2 ? { spriteVersionNumber: 2 } : {}),
+      kind: manifest.kind,
+    }, null, 2)}\n`, { mode: 0o600 });
+    fs.writeFileSync(path.join(stage, PET_SPRITESHEET), spritesheetBuffer, { mode: 0o600 });
+    loadPetDirectory(stage, manifest.id);
+    petDirectoryCache.delete(destination);
+    if (fs.existsSync(destination)) fs.renameSync(destination, backup);
+    fs.renameSync(stage, destination);
+    petDirectoryCache.delete(stage);
+  } catch (error) {
+    petDirectoryCache.delete(stage);
+    fs.rmSync(stage, { recursive: true, force: true });
+    if (!fs.existsSync(destination) && fs.existsSync(backup)) fs.renameSync(backup, destination);
+    throw error;
+  }
+  try { fs.rmSync(backup, { recursive: true, force: true }); } catch {}
+  const installed = loadPetDirectory(destination, manifest.id);
+  return publicPet(manifest, { assetVersion: installed.assetVersion });
+}
+
+async function importPetZip(zipBuffer) {
+  const entries = await readZipEntries(zipBuffer);
+  return installValidatedPackage(entries.get(PET_MANIFEST), entries.get(PET_SPRITESHEET));
+}
+
+function petIdFromCodexPetsUrl(input) {
+  const raw = String(input || "").trim();
+  if (PET_ID_RE.test(raw)) return raw;
+  let parsed;
+  try { parsed = new URL(raw); } catch { throw new Error("Enter a Codex Pets URL or pet id"); }
+  if (parsed.protocol !== "https:" || parsed.hostname !== "codex-pets.net") {
+    throw new Error("Only https://codex-pets.net pet URLs are supported");
+  }
+  const hashMatch = parsed.hash.match(/^#\/pets\/([a-z0-9-]+)\/?$/i);
+  const pathMatch = parsed.pathname.match(/^\/api\/pets\/([a-z0-9-]+)(?:\/download)?\/?$/i);
+  const id = String(hashMatch?.[1] || pathMatch?.[1] || "").toLowerCase();
+  if (!PET_ID_RE.test(id)) throw new Error("The Codex Pets URL does not contain a valid pet id");
+  return id;
+}
+
+async function installFromCodexPets(input, fetchImpl = fetch) {
+  const id = petIdFromCodexPetsUrl(input);
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 30_000);
+  timeout.unref?.();
+  try {
+    const response = await fetchImpl(`https://codex-pets.net/api/pets/${encodeURIComponent(id)}/download`, {
+      redirect: "follow",
+      signal: controller.signal,
+      headers: { accept: "application/zip", "user-agent": "TokenTracker Pet Importer" },
+    });
+    if (!response.ok) throw new Error(`Codex Pets download failed with HTTP ${response.status}`);
+    const length = Number(response.headers.get("content-length") || 0);
+    if (length > MAX_PACKAGE_BYTES) throw new Error("Pet package exceeds 12 MB");
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of response.body || []) {
+      total += chunk.length;
+      if (total > MAX_PACKAGE_BYTES) throw new Error("Pet package exceeds 12 MB");
+      chunks.push(Buffer.from(chunk));
+    }
+    const body = Buffer.concat(chunks);
+    return await importPetZip(body);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function removeInstalledPet(id) {
+  const normalized = String(id || "").trim().toLowerCase();
+  if (!PET_ID_RE.test(normalized) || BUILTIN_IDS.has(normalized)) throw new Error("Invalid custom pet id");
+  const root = resolvePetsDir();
+  const destination = path.join(root, normalized);
+  if (!destination.startsWith(`${root}${path.sep}`)) throw new Error("Invalid custom pet path");
+  fs.rmSync(destination, { recursive: true, force: true });
+  petDirectoryCache.delete(destination);
+  return { id: normalized };
+}
+
+function resolvePetAsset(id) {
+  const normalized = String(id || "").trim().toLowerCase();
+  if (!PET_ID_RE.test(normalized) || BUILTIN_IDS.has(normalized)) return null;
+  try { return loadPetDirectory(path.join(resolvePetsDir(), normalized), normalized); } catch { return null; }
+}
+
+module.exports = {
+  MAX_PACKAGE_BYTES,
+  importPetZip,
+  installFromCodexPets,
+  listInstalledPets,
+  normalizeManifest,
+  petIdFromCodexPetsUrl,
+  readWebpDimensions,
+  removeInstalledPet,
+  resolvePetAsset,
+  resolvePetsDir,
+  validatePackageFiles,
+};