tokenmaxxing 1.57.0 → 1.58.0

package/src/lib/install.ts

@@ -2,21 +2,14 @@ import { accessSync, appendFileSync, constants, existsSync, mkdirSync, readFileS
 import { basename, dirname, join, resolve } from "node:path";
 import { escape } from "es-toolkit";
 import { z } from "zod";
-import { codexPaths, codexStoreDirFor, HOME, paths } from "./paths.ts";
+import { codexPaths, codexStoreDirFor, HOME, optionalEnv, paths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import { installedBin, installSettings, isOurHookCommand, uninstallSettings } from "./settings.ts";
 import { resolveRealClaude } from "./claudebin.ts";
 import { loadConfig } from "./state.ts";
 import { ErrnoSchema } from "./types.ts";
 
-const InstallOutcomeSchema = z.object({
-  claudeWrapper: z.string(),
-  installedBin: z.string(),
-  pathAhead: z.boolean(),
-  timerLoaded: z.boolean(),
-  checkIntervalS: z.number().int().positive(),
-});
-export type InstallOutcome = z.infer<typeof InstallOutcomeSchema>;
+export type InstallOutcome = { claudeWrapper: string; installedBin: string; pathAhead: boolean; timerLoaded: boolean; checkIntervalS: number };
 
 export function isBinDirAhead(): boolean {
   const dirs = (process.env.PATH ?? "").split(":");
@@ -31,10 +24,10 @@ export function isBinDirAhead(): boolean {
   }
 }
 
-const EnvFlagSchema = z.enum(["1", "true", "yes"]).optional().catch(undefined);
+const envFlag = (name: string): boolean => z.stringbool().optional().parse(optionalEnv(name)) === true;
 
 export function isNixPackaged(): boolean {
-  if (EnvFlagSchema.parse(process.env.TOKENMAXXING_NIX) != null) return true;
+  if (envFlag("TOKENMAXXING_NIX")) return true;
   try {
     return realpathSync(Bun.main).startsWith("/nix/store/");
   } catch {
@@ -43,7 +36,7 @@ export function isNixPackaged(): boolean {
 }
 
 export function skipImperativeTimer(): boolean {
-  return EnvFlagSchema.parse(process.env.TOKENMAXXING_SKIP_TIMER) != null;
+  return envFlag("TOKENMAXXING_SKIP_TIMER");
 }
 
 function isNixStorePath(path: string): boolean {
@@ -51,7 +44,7 @@ function isNixStorePath(path: string): boolean {
 }
 
 function cannotWriteRcTarget(target: string): boolean {
-  if (EnvFlagSchema.parse(process.env.TOKENMAXXING_SKIP_SHELL_RC) != null) return true;
+  if (envFlag("TOKENMAXXING_SKIP_SHELL_RC")) return true;
   if (isNixStorePath(target)) return true;
   if (!existsSync(target)) return false;
   try {
@@ -177,26 +170,21 @@ export function codexStopHookGroupIndex(): number | null {
   return idx >= 0 ? idx : null;
 }
 
+const CodexHookStateSchema = z.looseObject({
+  hooks: z.looseObject({ state: z.record(z.string(), z.looseObject({ trusted_hash: z.unknown().optional() })).optional() }).optional(),
+});
+
 export function codexStoreHookTrust(accountId: string): "trusted" | "untrusted" | "unknown" {
   const group = codexStopHookGroupIndex();
   if (group == null) return "unknown";
   const key = `${join(codexStoreDirFor(accountId), "hooks.json")}:stop:${group}:0`;
-  let text: string;
+  let config: z.infer<typeof CodexHookStateSchema>;
   try {
-    text = readFileSync(join(codexPaths.home, "config.toml"), "utf8");
+    config = CodexHookStateSchema.parse(Bun.TOML.parse(readFileSync(join(codexPaths.home, "config.toml"), "utf8")));
   } catch {
     return "unknown";
   }
-  let inBlock = false;
-  for (const line of text.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("[")) {
-      inBlock = trimmed.startsWith("[hooks.state.") && trimmed.includes(key);
-    } else if (inBlock && trimmed.startsWith("trusted_hash")) {
-      return "trusted";
-    }
-  }
-  return "untrusted";
+  return config.hooks?.state?.[key]?.trusted_hash !== undefined ? "trusted" : "untrusted";
 }
 
 export function codexSupervisorLink(): string {
@@ -375,8 +363,8 @@ function uninstallCheckTimer(live: boolean): TimerOutcome {
 }
 
 export function shellRcPath(): string | null {
-  const override = process.env.TOKENMAXXING_SHELL_RC;
-  if (override && override.length > 0) return override;
+  const override = optionalEnv("TOKENMAXXING_SHELL_RC");
+  if (override != null) return override;
   const shell = basename(process.env.SHELL ?? "");
   if (shell === "zsh") return join(process.env.ZDOTDIR || HOME, ".zshrc");
   if (shell === "bash") return join(HOME, ".bashrc");
@@ -417,12 +405,7 @@ export function ensurePathInRc(rc: string): "added" | "present" | "skipped" {
   return "added";
 }
 
-const ShellShadowerSchema = z.object({
-  kind: z.enum(["shadow", "bypass"]),
-  name: z.string(),
-  line: z.string(),
-});
-export type ShellShadower = z.infer<typeof ShellShadowerSchema>;
+export type ShellShadower = { kind: "shadow" | "bypass"; name: string; line: string };
 
 export function findClaudeShadowers(rcText: string): ShellShadower[] {
   const out: ShellShadower[] = [];
@@ -433,14 +416,14 @@ export function findClaudeShadowers(rcText: string): ShellShadower[] {
     const alias = line.match(/^alias\s+([A-Za-z0-9_-]+)=(.*)$/);
     if (alias) {
       if (alias[1] === "claude") {
-        out.push(ShellShadowerSchema.parse({ kind: "shadow", name: "claude", line }));
+        out.push({ kind: "shadow", name: "claude", line });
       } else if (absClaude.test(alias[2]!)) {
-        out.push(ShellShadowerSchema.parse({ kind: "bypass", name: alias[1]!, line }));
+        out.push({ kind: "bypass", name: alias[1]!, line });
       }
       continue;
     }
     if (/^(?:function\s+)?claude\s*\(\)/.test(line)) {
-      out.push(ShellShadowerSchema.parse({ kind: "shadow", name: "claude", line }));
+      out.push({ kind: "shadow", name: "claude", line });
     }
   }
   return out;
@@ -462,8 +445,7 @@ export function removePathFromRc(rc: string): boolean {
   return true;
 }
 
-const UninstallOutcomeSchema = z.object({ timer: z.enum(["removed", "skipped", "still-loaded"]), pathLineRemoved: z.boolean() });
-export type UninstallOutcome = z.infer<typeof UninstallOutcomeSchema>;
+export type UninstallOutcome = { timer: "removed" | "skipped" | "still-loaded"; pathLineRemoved: boolean };
 
 export function loginHome(): string {
   const cmd = process.platform === "darwin" ? ["id", "-P"] : ["getent", "passwd", String(process.getuid?.() ?? "")];

package/src/lib/keychain.ts

@@ -1,7 +1,4 @@
-import { z } from "zod";
-
-const KeychainTargetSchema = z.object({ service: z.string(), account: z.string() });
-export type KeychainTarget = z.infer<typeof KeychainTargetSchema>;
+export type KeychainTarget = { service: string; account: string };
 
 const SECURITY = "/usr/bin/security";
 const INTERACTIVE_MAX_LINE = 4000;

package/src/lib/log.ts

@@ -1,10 +1,13 @@
 import { appendFileSync, existsSync, mkdirSync, renameSync, statSync } from "node:fs";
 import { dirname } from "node:path";
-import { z } from "zod";
 import { paths } from "./paths.ts";
 
 const LOG_MAX_BYTES = 5_000_000;
 
+export function errorMessage(e: unknown): string {
+  return e instanceof Error ? e.message : String(e);
+}
+
 function redact(s: string): string {
   return s
     .replace(/\b(sk-ant-[A-Za-z0-9._-]{6,})/g, "sk-ant-***")
@@ -22,10 +25,7 @@ export function log(event: string, fields: Record<string, unknown> = {}): void {
   try {
     line = Object.entries(fields)
       .filter(([, v]) => v !== undefined)
-      .map(([k, v]) => {
-        const str = z.string().safeParse(v);
-        return `${k}=${redact(str.success ? str.data : JSON.stringify(v))}`;
-      })
+      .map(([k, v]) => `${k}=${redact(typeof v === "string" ? v : JSON.stringify(v))}`)
       .join(" ");
     mkdirSync(dirname(paths.logFile), { recursive: true });
     if (existsSync(paths.logFile) && statSync(paths.logFile).size > LOG_MAX_BYTES) {

package/src/lib/oauth.ts

@@ -1,6 +1,7 @@
 import { http, safeErrorDetail } from "./http.ts";
 import { env } from "./paths.ts";
-import { JsonTextSchema, ProfileResponseSchema, TokenIdentitySchema, type OAuthCreds, type TokenIdentity } from "./types.ts";
+import { errorMessage } from "./log.ts";
+import { JsonTextSchema, ProfileResponseSchema, type OAuthCreds, type TokenIdentity } from "./types.ts";
 
 const PROFILE_URL = env("TOKENMAXXING_OAUTH_PROFILE_URL", "https://api.anthropic.com/api/oauth/profile");
 
@@ -41,23 +42,23 @@ export async function fetchTokenIdentity(accessToken: string, signal?: AbortSign
       signal,
     });
   } catch (e) {
-    throw new IdentityUnavailableError(null, e instanceof Error ? e.message : String(e));
+    throw new IdentityUnavailableError(null, errorMessage(e));
   }
   let text: string;
   try {
     text = await res.text();
   } catch (e) {
-    throw new IdentityUnavailableError(res.status, `profile response body unreadable: ${e instanceof Error ? e.message : String(e)}`);
+    throw new IdentityUnavailableError(res.status, `profile response body unreadable: ${errorMessage(e)}`);
   }
   if (!res.ok) throw new IdentityUnavailableError(res.status, safeErrorDetail({ text }));
   const parsed = ProfileResponseSchema.safeParse(JsonTextSchema.safeParse(text).data);
   if (!parsed.success) throw new IdentityUnavailableError(res.status, `profile endpoint returned an unrecognized body (${text.length} bytes, withheld)`);
-  return TokenIdentitySchema.parse({
+  return {
     accountUuid: parsed.data.account.uuid,
     email: parsed.data.account.email ?? null,
     organizationUuid: parsed.data.organization.uuid,
     organizationName: parsed.data.organization.name ?? null,
-  });
+  };
 }
 
 export function describeIdentity(id: TokenIdentity): string {

package/src/lib/opencodego.ts

@@ -1,12 +1,12 @@
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { opencodeGoAuthJsonFor, opencodeGoPaths, opencodeGoPool, opencodeGoStoreDirFor } from "./paths.ts";
-import type { Observation, Provider, SampleReport } from "./provider.ts";
-import { loadConfig, pinBinOverride, type Harvest } from "./state.ts";
-import type { Account } from "./types.ts";
+import type { Provider } from "./provider.ts";
+import { type Harvest } from "./state.ts";
+import { statusOnlyProvider, type AuthEntry } from "./statusonly.ts";
 import { c } from "../cli/render.ts";
 
 const OpencodeAuthEntrySchema = z.looseObject({ type: z.string(), key: z.string().optional() });
@@ -20,77 +20,12 @@ function liveAuthPath(): string {
   return join(dataHome(), "opencode", "auth.json");
 }
 
-function parseAuthFile(path: string): { provider: string; key: string } | null {
-  let raw: unknown;
-  try {
-    raw = JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return null;
-  }
-  const map = OpencodeAuthFileSchema.safeParse(raw);
-  if (!map.success) return null;
-  const entry = OpencodeAuthEntrySchema.safeParse(map.data["opencode-go"]);
-  if (!entry.success || entry.data.type !== "api" || !entry.data.key) return null;
-  return { provider: "opencode-go", key: entry.data.key };
-}
-
 function idOfKey(key: string): string {
   const h = new Bun.CryptoHasher("sha256");
   h.update(`opencode-go:${key}`);
   return `opencode-go-${h.digest("hex")}`;
 }
 
-function resolveRealOpencode(): string {
-  const cfg = loadConfig();
-  if (cfg.opencodeBin) {
-    if (!existsSync(cfg.opencodeBin)) throw new Error(`configured opencodeBin does not exist: ${cfg.opencodeBin} - fix config.json`);
-    return cfg.opencodeBin;
-  }
-  for (const d of (process.env.PATH ?? "").split(":")) {
-    if (!d) continue;
-    const cand = join(d, "opencode");
-    try {
-      if (existsSync(cand)) return cand;
-    } catch {
-      continue;
-    }
-  }
-  throw new Error("could not locate the real `opencode` binary (set opencodeBin in config.json)");
-}
-
-function liveId(): string | null {
-  return null;
-}
-
-function presence(): Map<string, number> {
-  return new Map();
-}
-
-async function observeLive(account: Account): Promise<Observation | null> {
-  return account.lastUsageAt != null ? { windows: account.windows, at: account.lastUsageAt } : null;
-}
-
-async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport>> {
-  const reports = new Map<string, SampleReport>();
-  for (const a of accounts) {
-    reports.set(a.id, (await storeUsable(a)) ? { ok: true, source: "probe" } : { ok: false, reason: "no usable credential in this account's store - run `tokenmaxxing auth --opencode-go`" });
-  }
-  return reports;
-}
-
-async function storeUsable(a: Account): Promise<boolean> {
-  try {
-    const found = parseAuthFile(opencodeGoAuthJsonFor(a.id));
-    return found != null && idOfKey(found.key) === a.id;
-  } catch {
-    return false;
-  }
-}
-
-async function removeCredentials(a: Account): Promise<void> {
-  rmSync(opencodeGoStoreDirFor(a.id), { recursive: true, force: true });
-}
-
 function harvestOf(key: string): Harvest {
   const id = idOfKey(key);
   return {
@@ -105,82 +40,38 @@ function harvestOf(key: string): Harvest {
   };
 }
 
-async function login(): Promise<Harvest | null> {
-  const real = resolveRealOpencode();
-  const onboardDir = opencodeGoPaths.onboardDir;
-  rmSync(onboardDir, { recursive: true, force: true });
-  mkdirSync(onboardDir, { recursive: true });
-  const p = Bun.spawn([real, "providers", "login", "-p", "opencode-go"], {
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-    env: { ...process.env, XDG_DATA_HOME: onboardDir, TOKENMAXXING_PROBE: "1" },
-  });
-  await p.exited;
+function readAuth(path: string): AuthEntry[] {
+  let raw: unknown;
   try {
-    if (p.exitCode !== 0) {
-      console.error(c.red("no opencode-go login landed in the isolated home - nothing added."));
-      return null;
-    }
-    const found = parseAuthFile(join(onboardDir, "opencode", "auth.json"));
-    if (!found) {
-      console.error(c.red("no opencode-go login landed in the isolated home - nothing added."));
-      return null;
-    }
-    return harvestOf(found.key);
-  } finally {
-    rmSync(onboardDir, { recursive: true, force: true });
-  }
-}
-
-async function importLive(): Promise<Harvest | null> {
-  console.log(c.cyan("Pooling your opencode-go API key - your existing opencode auth stays as it is."));
-  console.log();
-  const found = parseAuthFile(liveAuthPath());
-  if (found) {
-    console.log(c.dim(`found an opencode-go credential in ${liveAuthPath()} - pooling it; use \`tokenmaxxing add --opencode-go\` for more keys.`));
-    return harvestOf(found.key);
-  }
-  return login();
-}
-
-function preflight(): void {
-  const real = resolveRealOpencode();
-  const p = Bun.spawnSync([real, "--version"], { stdout: "pipe", stderr: "pipe", timeout: 15_000 });
-  const out = (p.stdout?.toString() ?? "").trim();
-  if (p.exitCode !== 0 || out === "") {
-    throw new Error(`opencode binary failed verification: ${real}`);
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return [];
   }
-  pinBinOverride({ key: "opencodeBin", bin: real });
-}
-
-function install(): void {
-  console.log(c.dim("opencode-go pool is status-only: no supervisor or hooks installed. Use `tokenmaxxing status` to view pooled keys."));
+  const map = OpencodeAuthFileSchema.safeParse(raw);
+  if (!map.success) return [];
+  const entry = OpencodeAuthEntrySchema.safeParse(map.data["opencode-go"]);
+  if (!entry.success || entry.data.type !== "api" || !entry.data.key) return [];
+  return [{ id: idOfKey(entry.data.key), usable: true, harvest: harvestOf(entry.data.key) }];
 }
 
-export const opencodeGo: Provider = {
+export const opencodeGo: Provider = statusOnlyProvider({
   name: "opencode-go",
   flag: " --opencode-go",
   pool: opencodeGoPool,
-  seats: "live",
-  waitsWhenDepleted: false,
-  statusOnly: true,
-  liveId,
-  presence,
-  gatedFamilies: () => null,
-  observeLive,
-  samplePool,
-  mergeWindows: (next) => next,
-  swap: async () => {
-    throw new Error("opencode-go moves are not supported yet (status-only pool)");
-  },
-  classifySwapError: () => "fatal",
-  removeCredentials,
-  storeUsable,
-  login,
-  importLive,
-  preflight,
-  install,
+  binName: "opencode",
+  binKey: "opencodeBin",
+  storeDirFor: opencodeGoStoreDirFor,
+  authJsonFor: opencodeGoAuthJsonFor,
+  onboardDir: opencodeGoPaths.onboardDir,
+  homeEnv: "XDG_DATA_HOME",
+  loginArgs: ["providers", "login", "-p", "opencode-go"],
+  onboardAuthRel: join("opencode", "auth.json"),
+  liveAuthPath,
+  readAuth,
+  liveId: () => null,
+  versionOk: (out) => out.trim() !== "",
+  importIntro: "Pooling your opencode-go API key - your existing opencode auth stays as it is.",
+  foundLive: () => `found an opencode-go credential in ${liveAuthPath()} - pooling it; use \`tokenmaxxing add --opencode-go\` for more keys.`,
+  installNotice: "opencode-go pool is status-only: no supervisor or hooks installed. Use `tokenmaxxing status` to view pooled keys.",
   loginStep: () => `Paste the opencode-go API key from ${c.bold("opencode.ai/zen")} when opencode asks for it.`,
-  windowLabel: (name) => name.toLowerCase(),
-};
+});

package/src/lib/paths.ts

@@ -6,8 +6,12 @@ const HOME = homedir();
 
 const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
 
+export function optionalEnv(name: string, source: Record<string, string | undefined> = process.env): string | undefined {
+  return EnvOverrideSchema.parse(source[name]);
+}
+
 export function env(name: string, fallback: string): string {
-  return EnvOverrideSchema.parse(process.env[name]) ?? fallback;
+  return optionalEnv(name) ?? fallback;
 }
 
 const TM_HOME = env("TOKENMAXXING_HOME", join(HOME, ".config", "tokenmaxxing"));
@@ -42,29 +46,25 @@ export const paths = {
 
 export const claudePool = {
   accountsJson: join(TM_HOME, "accounts.json"),
-  lastSwapJson: null,
   lockFile: join(TM_HOME, "lock"),
 } as const;
 
 export const codexPool = {
   accountsJson: join(TM_HOME, "codex-accounts.json"),
-  lastSwapJson: null,
   lockFile: join(TM_HOME, "codex-lock"),
 } as const;
 
 export const grokPool = {
   accountsJson: join(TM_HOME, "grok-accounts.json"),
-  lastSwapJson: null,
   lockFile: join(TM_HOME, "grok-lock"),
 } as const;
 
 export const opencodeGoPool = {
   accountsJson: join(TM_HOME, "opencode-go-accounts.json"),
-  lastSwapJson: null,
   lockFile: join(TM_HOME, "opencode-go-lock"),
 } as const;
 
-export type PoolPaths = { accountsJson: string; lastSwapJson: string | null; lockFile: string };
+export type PoolPaths = { accountsJson: string; lockFile: string };
 
 const CODEX_HOME = env("TOKENMAXXING_CODEX_HOME", env("CODEX_HOME", join(HOME, ".codex")));
 
@@ -159,20 +159,4 @@ export function namespacedCredService(configDirRaw: string): string {
   return `Claude Code-credentials-${h.digest("hex").slice(0, 8)}`;
 }
 
-export function realClaudeBinFromEnv(): string | undefined {
-  return EnvOverrideSchema.parse(process.env.TOKENMAXXING_CLAUDE_BIN);
-}
-
-export function realCodexBinFromEnv(): string | undefined {
-  return EnvOverrideSchema.parse(process.env.TOKENMAXXING_CODEX_BIN);
-}
-
-export function realGrokBinFromEnv(): string | undefined {
-  return EnvOverrideSchema.parse(process.env.TOKENMAXXING_GROK_BIN);
-}
-
-export function realOpencodeBinFromEnv(): string | undefined {
-  return EnvOverrideSchema.parse(process.env.TOKENMAXXING_OPENCODE_BIN);
-}
-
 export { HOME };

package/src/lib/picker.ts

@@ -1,7 +1,6 @@
 import { maxBy, minBy, sortBy } from "es-toolkit";
-import { z } from "zod";
 import { familyTokens } from "./usage.ts";
-import { AccountSchema, ThresholdsSchema, type Account, type Config, type Thresholds, type Window } from "./types.ts";
+import type { Account, Config, Thresholds, Window } from "./types.ts";
 
 export function thresholdBars(cfg: Config): Thresholds {
   return {
@@ -10,14 +9,13 @@ export function thresholdBars(cfg: Config): Thresholds {
   };
 }
 
-const PickCtxSchema = z.object({
-  now: z.number(),
-  thresholds: ThresholdsSchema,
-  currentId: z.string().nullable(),
-  families: z.array(z.string()).nullable(),
-  seats: z.map(z.string(), z.number()).nullable(),
-});
-export type PickCtx = z.infer<typeof PickCtxSchema>;
+export type PickCtx = {
+  now: number;
+  thresholds: Thresholds;
+  currentId: string | null;
+  families: string[] | null;
+  seats: Map<string, number> | null;
+};
 
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const SESSION_WINDOW_MAX_S = 6 * 3600;
@@ -123,21 +121,12 @@ export function pickBest(accounts: Account[], ctx: PickCtx): Account | null {
   return sortBy(usable, swapPreference(ctx))[0] ?? null;
 }
 
-export function currentWins(active: Account | null, accounts: Account[], ctx: PickCtx, margin = 1): boolean {
-  if (!active || active.needsReauth || isExhausted(active, ctx)) return false;
-  const best = pickBest(accounts, { ...ctx, currentId: null });
-  if (best == null || best.id === active.id) return true;
-  if (margin > 1) return pacePressure(best, ctx) <= pacePressure(active, ctx) * margin;
-  return swapPreference(ctx).every((k) => k(active) === k(best));
-}
-
 export function usableAt(a: Account, ctx: PickCtx): number {
   const blocking = blockingUntil(a, ctx).filter((t) => t > ctx.now);
   return blocking.length ? Math.max(...blocking) : ctx.now;
 }
 
-const EarliestResetSchema = z.object({ account: AccountSchema, availableAt: z.number() });
-export type EarliestReset = z.infer<typeof EarliestResetSchema>;
+export type EarliestReset = { account: Account; availableAt: number };
 
 export function pickEarliestReset(accounts: Account[], ctx: PickCtx): EarliestReset | null {
   const mapped = accounts

package/src/lib/presence.ts

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { pidExists, pidStartTime } from "./proc.ts";
+import { ErrnoSchema } from "./types.ts";
 
 const PresenceSchema = z.object({
   accountId: z.string(),
@@ -21,8 +22,7 @@ export function clearPresence(input: { dir: string; id: string }): void {
   rmSync(join(input.dir, input.id), { force: true });
 }
 
-const LivingPresenceSchema = z.object({ id: z.string(), accountId: z.string() });
-export type LivingPresence = z.infer<typeof LivingPresenceSchema>;
+export type LivingPresence = { id: string; accountId: string };
 
 export function livingPresences(dir: string): LivingPresence[] {
   const living: LivingPresence[] = [];
@@ -33,8 +33,7 @@ export function livingPresences(dir: string): LivingPresence[] {
     try {
       raw = readFileSync(file, "utf8");
     } catch (e) {
-      const errno = z.object({ code: z.string() }).safeParse(e);
-      if (errno.success && errno.data.code === "ENOENT") continue;
+      if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") continue;
       throw e;
     }
     const parsed = PresenceSchema.safeParse((() => {
@@ -55,7 +54,7 @@ export function livingPresences(dir: string): LivingPresence[] {
       rmSync(file, { force: true });
       continue;
     }
-    living.push(LivingPresenceSchema.parse({ id: name, accountId: parsed.data.accountId }));
+    living.push({ id: name, accountId: parsed.data.accountId });
   }
   return living;
 }

package/src/lib/proc.ts

@@ -7,6 +7,28 @@ export function pidStartTime(pid: number): string | null {
   return lstart === "" ? null : lstart;
 }
 
+export async function readStdin(): Promise<string> {
+  const chunks: Uint8Array[] = [];
+  for await (const chunk of Bun.stdin.stream()) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+export async function* readLines(stream: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+  const decoder = new TextDecoder();
+  let pending = "";
+  for await (const chunk of stream) {
+    pending += decoder.decode(chunk, { stream: true });
+    let nl = pending.indexOf("\n");
+    while (nl !== -1) {
+      yield pending.slice(0, nl);
+      pending = pending.slice(nl + 1);
+      nl = pending.indexOf("\n");
+    }
+  }
+  pending += decoder.decode();
+  if (pending.length > 0) yield pending;
+}
+
 export function pidExists(pid: number): boolean {
   try {
     process.kill(pid, 0);