@chrysb/alphaclaw 0.4.3 → 0.4.5

package/lib/server/db/usage/summary.js

@@ -0,0 +1,280 @@
+const {
+  kDefaultDays,
+  kDayMs,
+  kUtcTimeZone,
+  coerceInt,
+  toDayKey,
+  toTimeZoneDayKey,
+  getPeriodRange,
+  getUsageMetricsFromEventRow,
+  parseAgentAndSourceFromSessionRef,
+} = require("./shared");
+
+const getAgentCostDistribution = ({
+  eventsRows = [],
+  startDay = "",
+  timeZone = kUtcTimeZone,
+}) => {
+  const byAgent = new Map();
+  const ensureAgentBucket = (agent) => {
+    if (byAgent.has(agent)) return byAgent.get(agent);
+    const bucket = {
+      agent,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      totalTokens: 0,
+      totalCost: 0,
+      turnCount: 0,
+      sourceBreakdown: {
+        chat: {
+          source: "chat",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+        hooks: {
+          source: "hooks",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+        cron: {
+          source: "cron",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+      },
+    };
+    byAgent.set(agent, bucket);
+    return bucket;
+  };
+
+  for (const eventRow of eventsRows) {
+    const timestamp = coerceInt(eventRow.timestamp);
+    const dayKey = timeZone === kUtcTimeZone
+      ? toDayKey(timestamp)
+      : toTimeZoneDayKey(timestamp, timeZone);
+    if (dayKey < startDay) continue;
+
+    const metrics = getUsageMetricsFromEventRow(eventRow);
+    const sessionRef = String(eventRow.session_key || eventRow.session_id || "");
+    const { agent, source } = parseAgentAndSourceFromSessionRef(sessionRef);
+    const agentBucket = ensureAgentBucket(agent);
+    const sourceBucket = agentBucket.sourceBreakdown[source];
+
+    agentBucket.inputTokens += metrics.inputTokens;
+    agentBucket.outputTokens += metrics.outputTokens;
+    agentBucket.cacheReadTokens += metrics.cacheReadTokens;
+    agentBucket.cacheWriteTokens += metrics.cacheWriteTokens;
+    agentBucket.totalTokens += metrics.totalTokens;
+    agentBucket.totalCost += metrics.totalCost;
+    agentBucket.turnCount += 1;
+
+    sourceBucket.inputTokens += metrics.inputTokens;
+    sourceBucket.outputTokens += metrics.outputTokens;
+    sourceBucket.cacheReadTokens += metrics.cacheReadTokens;
+    sourceBucket.cacheWriteTokens += metrics.cacheWriteTokens;
+    sourceBucket.totalTokens += metrics.totalTokens;
+    sourceBucket.totalCost += metrics.totalCost;
+    sourceBucket.turnCount += 1;
+  }
+
+  const agents = Array.from(byAgent.values())
+    .map((bucket) => ({
+      agent: bucket.agent,
+      inputTokens: bucket.inputTokens,
+      outputTokens: bucket.outputTokens,
+      cacheReadTokens: bucket.cacheReadTokens,
+      cacheWriteTokens: bucket.cacheWriteTokens,
+      totalTokens: bucket.totalTokens,
+      totalCost: bucket.totalCost,
+      turnCount: bucket.turnCount,
+      sourceBreakdown: ["chat", "hooks", "cron"].map(
+        (source) => bucket.sourceBreakdown[source],
+      ),
+    }))
+    .sort((a, b) => b.totalCost - a.totalCost);
+
+  return {
+    agents,
+    totals: agents.reduce(
+      (acc, agentBucket) => {
+        acc.totalCost += Number(agentBucket.totalCost || 0);
+        acc.totalTokens += Number(agentBucket.totalTokens || 0);
+        acc.turnCount += Number(agentBucket.turnCount || 0);
+        return acc;
+      },
+      { totalCost: 0, totalTokens: 0, turnCount: 0 },
+    ),
+  };
+};
+
+const getDailySummary = ({ database, days = kDefaultDays, timeZone = kUtcTimeZone } = {}) => {
+  const { now, safeDays, startDay, timeZone: normalizedTimeZone } = getPeriodRange(
+    days,
+    timeZone,
+  );
+  const lookbackMs = now - (safeDays + 2) * kDayMs;
+  const eventsRows = database
+    .prepare(`
+      SELECT
+        timestamp,
+        session_id,
+        session_key,
+        provider,
+        model,
+        input_tokens,
+        output_tokens,
+        cache_read_tokens,
+        cache_write_tokens,
+        total_tokens
+      FROM usage_events
+      WHERE timestamp >= $lookbackMs
+      ORDER BY timestamp ASC
+    `)
+    .all({ $lookbackMs: lookbackMs });
+  const byDateModel = new Map();
+  for (const eventRow of eventsRows) {
+    const timestamp = coerceInt(eventRow.timestamp);
+    const dayKey = normalizedTimeZone === kUtcTimeZone
+      ? toDayKey(timestamp)
+      : toTimeZoneDayKey(timestamp, normalizedTimeZone);
+    if (dayKey < startDay) continue;
+    const model = String(eventRow.model || "unknown");
+    const mapKey = `${dayKey}\u0000${model}`;
+    if (!byDateModel.has(mapKey)) {
+      byDateModel.set(mapKey, {
+        date: dayKey,
+        model,
+        provider: String(eventRow.provider || "unknown"),
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        turnCount: 0,
+        totalCost: 0,
+        inputCost: 0,
+        outputCost: 0,
+        cacheReadCost: 0,
+        cacheWriteCost: 0,
+        pricingFound: false,
+      });
+    }
+    const aggregate = byDateModel.get(mapKey);
+    const metrics = getUsageMetricsFromEventRow(eventRow);
+    aggregate.inputTokens += metrics.inputTokens;
+    aggregate.outputTokens += metrics.outputTokens;
+    aggregate.cacheReadTokens += metrics.cacheReadTokens;
+    aggregate.cacheWriteTokens += metrics.cacheWriteTokens;
+    aggregate.totalTokens += metrics.totalTokens;
+    aggregate.turnCount += 1;
+    aggregate.totalCost += metrics.totalCost;
+    aggregate.inputCost += metrics.inputCost;
+    aggregate.outputCost += metrics.outputCost;
+    aggregate.cacheReadCost += metrics.cacheReadCost;
+    aggregate.cacheWriteCost += metrics.cacheWriteCost;
+    aggregate.pricingFound = aggregate.pricingFound || metrics.pricingFound;
+    if (!aggregate.provider && eventRow.provider) {
+      aggregate.provider = String(eventRow.provider || "unknown");
+    }
+  }
+  const enriched = Array.from(byDateModel.values()).sort((a, b) => {
+    if (a.date === b.date) return b.totalTokens - a.totalTokens;
+    return a.date.localeCompare(b.date);
+  });
+  const costByAgent = getAgentCostDistribution({
+    eventsRows,
+    startDay,
+    timeZone: normalizedTimeZone,
+  });
+  const byDate = new Map();
+  for (const row of enriched) {
+    if (!byDate.has(row.date)) byDate.set(row.date, []);
+    byDate.get(row.date).push({
+      model: row.model,
+      provider: row.provider,
+      inputTokens: row.inputTokens,
+      outputTokens: row.outputTokens,
+      cacheReadTokens: row.cacheReadTokens,
+      cacheWriteTokens: row.cacheWriteTokens,
+      totalTokens: row.totalTokens,
+      turnCount: row.turnCount,
+      totalCost: row.totalCost,
+      inputCost: row.inputCost,
+      outputCost: row.outputCost,
+      cacheReadCost: row.cacheReadCost,
+      cacheWriteCost: row.cacheWriteCost,
+      pricingFound: row.pricingFound,
+    });
+  }
+  const daily = [];
+  const totals = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+    totalCost: 0,
+    turnCount: 0,
+    modelCount: 0,
+  };
+  for (const [date, modelRows] of byDate.entries()) {
+    const aggregate = modelRows.reduce(
+      (acc, row) => ({
+        inputTokens: acc.inputTokens + row.inputTokens,
+        outputTokens: acc.outputTokens + row.outputTokens,
+        cacheReadTokens: acc.cacheReadTokens + row.cacheReadTokens,
+        cacheWriteTokens: acc.cacheWriteTokens + row.cacheWriteTokens,
+        totalTokens: acc.totalTokens + row.totalTokens,
+        totalCost: acc.totalCost + row.totalCost,
+        turnCount: acc.turnCount + row.turnCount,
+      }),
+      {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        turnCount: 0,
+      },
+    );
+    daily.push({ date, ...aggregate, models: modelRows });
+    totals.inputTokens += aggregate.inputTokens;
+    totals.outputTokens += aggregate.outputTokens;
+    totals.cacheReadTokens += aggregate.cacheReadTokens;
+    totals.cacheWriteTokens += aggregate.cacheWriteTokens;
+    totals.totalTokens += aggregate.totalTokens;
+    totals.totalCost += aggregate.totalCost;
+    totals.turnCount += aggregate.turnCount;
+    totals.modelCount += modelRows.length;
+  }
+  return {
+    updatedAt: Date.now(),
+    days: safeDays,
+    timeZone: normalizedTimeZone,
+    daily,
+    totals,
+    costByAgent,
+  };
+};
+
+module.exports = {
+  getDailySummary,
+};

package/lib/server/db/usage/timeseries.js

@@ -0,0 +1,64 @@
+const {
+  kDefaultMaxPoints,
+  kMaxMaxPoints,
+  coerceInt,
+  clampInt,
+  getUsageMetricsFromEventRow,
+  downsamplePoints,
+} = require("./shared");
+
+const getSessionTimeSeries = ({
+  database,
+  sessionId,
+  maxPoints = kDefaultMaxPoints,
+}) => {
+  const safeSessionRef = String(sessionId || "").trim();
+  if (!safeSessionRef) return { sessionId: safeSessionRef, points: [] };
+  const rows = database
+    .prepare(`
+      SELECT
+        timestamp,
+        session_key,
+        session_id,
+        model,
+        input_tokens,
+        output_tokens,
+        cache_read_tokens,
+        cache_write_tokens,
+        total_tokens
+      FROM usage_events
+      WHERE COALESCE(NULLIF(session_key, ''), NULLIF(session_id, '')) = $sessionRef
+      ORDER BY timestamp ASC
+    `)
+    .all({ $sessionRef: safeSessionRef });
+  let cumulativeTokens = 0;
+  let cumulativeCost = 0;
+  const points = rows.map((row) => {
+    const metrics = getUsageMetricsFromEventRow(row);
+    cumulativeTokens += metrics.totalTokens;
+    cumulativeCost += metrics.totalCost;
+    return {
+      timestamp: coerceInt(row.timestamp),
+      sessionKey: String(row.session_key || ""),
+      rawSessionId: String(row.session_id || ""),
+      model: String(row.model || ""),
+      inputTokens: metrics.inputTokens,
+      outputTokens: metrics.outputTokens,
+      cacheReadTokens: metrics.cacheReadTokens,
+      cacheWriteTokens: metrics.cacheWriteTokens,
+      totalTokens: metrics.totalTokens,
+      cost: metrics.totalCost,
+      cumulativeTokens,
+      cumulativeCost,
+    };
+  });
+  const safeMaxPoints = clampInt(maxPoints, 10, kMaxMaxPoints, kDefaultMaxPoints);
+  return {
+    sessionId: safeSessionRef,
+    points: downsamplePoints(points, safeMaxPoints),
+  };
+};
+
+module.exports = {
+  getSessionTimeSeries,
+};

package/lib/server/{watchdog-db.js → db/watchdog/index.js}

@@ -1,6 +1,7 @@
 const fs = require("fs");
 const path = require("path");
 const { DatabaseSync } = require("node:sqlite");
+const { createSchema } = require("./schema");
 
 let db = null;
 let pruneTimer = null;
@@ -14,24 +15,6 @@ const ensureDb = () => {
   return db;
 };
 
-const createSchema = (database) => {
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS watchdog_events (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      event_type TEXT NOT NULL,
-      source TEXT NOT NULL,
-      status TEXT NOT NULL,
-      details TEXT,
-      correlation_id TEXT,
-      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
-    );
-  `);
-  database.exec(`
-    CREATE INDEX IF NOT EXISTS idx_watchdog_events_ts
-    ON watchdog_events(created_at DESC);
-  `);
-};
-
 const initWatchdogDb = ({ rootDir, pruneDays = 30 }) => {
   const dbDir = path.join(rootDir, "db");
   fs.mkdirSync(dbDir, { recursive: true });

package/lib/server/db/watchdog/schema.js

@@ -0,0 +1,21 @@
+const createSchema = (database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS watchdog_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      event_type TEXT NOT NULL,
+      source TEXT NOT NULL,
+      status TEXT NOT NULL,
+      details TEXT,
+      correlation_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_watchdog_events_ts
+    ON watchdog_events(created_at DESC);
+  `);
+};
+
+module.exports = {
+  createSchema,
+};

package/lib/server/{webhooks-db.js → db/webhooks/index.js}

@@ -1,6 +1,7 @@
 const fs = require("fs");
 const path = require("path");
 const { DatabaseSync } = require("node:sqlite");
+const { createSchema } = require("./schema");
 
 let db = null;
 let pruneTimer = null;
@@ -14,28 +15,6 @@ const ensureDb = () => {
   return db;
 };
 
-const createSchema = (database) => {
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS webhook_requests (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      hook_name TEXT NOT NULL,
-      method TEXT,
-      headers TEXT,
-      payload TEXT,
-      payload_truncated INTEGER DEFAULT 0,
-      payload_size INTEGER,
-      source_ip TEXT,
-      gateway_status INTEGER,
-      gateway_body TEXT,
-      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
-    );
-  `);
-  database.exec(`
-    CREATE INDEX IF NOT EXISTS idx_webhook_requests_hook_ts
-    ON webhook_requests(hook_name, created_at DESC);
-  `);
-};
-
 const initWebhooksDb = ({ rootDir, pruneDays = 30 }) => {
   const dbDir = path.join(rootDir, "db");
   fs.mkdirSync(dbDir, { recursive: true });

package/lib/server/db/webhooks/schema.js

@@ -0,0 +1,25 @@
+const createSchema = (database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS webhook_requests (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      hook_name TEXT NOT NULL,
+      method TEXT,
+      headers TEXT,
+      payload TEXT,
+      payload_truncated INTEGER DEFAULT 0,
+      payload_size INTEGER,
+      source_ip TEXT,
+      gateway_status INTEGER,
+      gateway_body TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_webhook_requests_hook_ts
+    ON webhook_requests(hook_name, created_at DESC);
+  `);
+};
+
+module.exports = {
+  createSchema,
+};

package/lib/server/gmail-push.js

@@ -1,4 +1,14 @@
 const http = require("http");
+const { parsePositiveInt } = require("./utils/number");
+
+const kGmailPushDedupeWindowMs = parsePositiveInt(
+  process.env.GMAIL_PUSH_DEDUPE_WINDOW_MS,
+  24 * 60 * 60 * 1000,
+);
+const kGmailPushDedupeMaxEntries = parsePositiveInt(
+  process.env.GMAIL_PUSH_DEDUPE_MAX_ENTRIES,
+  50000,
+);
 
 const extractBodyBuffer = (body) => {
   if (Buffer.isBuffer(body)) return body;
@@ -21,6 +31,68 @@ const parsePushEnvelope = (bodyBuffer) => {
   };
 };
 
+const createPushEventDedupeKey = ({ envelope, payload }) => {
+  const messageId = String(
+    envelope?.message?.messageId || envelope?.message?.message_id || "",
+  ).trim();
+  if (messageId) return `msg:${messageId}`;
+  const email = String(payload?.emailAddress || "")
+    .trim()
+    .toLowerCase();
+  const historyId = String(payload?.historyId || "").trim();
+  if (email && historyId) return `hist:${email}:${historyId}`;
+  if (historyId) return `hist:${historyId}`;
+  return "";
+};
+
+const createGmailPushEventDeduper = ({
+  ttlMs = kGmailPushDedupeWindowMs,
+  maxEntries = kGmailPushDedupeMaxEntries,
+} = {}) => {
+  const seenEvents = new Map();
+
+  const pruneExpiredEntries = (receivedAt) => {
+    const cutoff = receivedAt - ttlMs;
+    for (const [eventKey, seenAt] of seenEvents.entries()) {
+      if (seenAt > cutoff) break;
+      seenEvents.delete(eventKey);
+    }
+    while (seenEvents.size > maxEntries) {
+      const oldestKey = seenEvents.keys().next().value;
+      if (!oldestKey) break;
+      seenEvents.delete(oldestKey);
+    }
+  };
+
+  const shouldProcessPushEvent = ({ envelope, payload, receivedAt = Date.now() }) => {
+    const timestamp = Number.isFinite(receivedAt) ? receivedAt : Date.now();
+    pruneExpiredEntries(timestamp);
+    const eventKey = createPushEventDedupeKey({ envelope, payload });
+    if (!eventKey) return true;
+    return !seenEvents.has(eventKey);
+  };
+
+  shouldProcessPushEvent.markProcessed = ({
+    envelope,
+    payload,
+    receivedAt = Date.now(),
+  }) => {
+    const timestamp = Number.isFinite(receivedAt) ? receivedAt : Date.now();
+    pruneExpiredEntries(timestamp);
+    const eventKey = createPushEventDedupeKey({ envelope, payload });
+    if (!eventKey) return true;
+    seenEvents.set(eventKey, timestamp);
+    return true;
+  };
+
+  return shouldProcessPushEvent;
+};
+
+const isSuccessfulProxyStatus = (statusCode) => {
+  const numericStatus = Number.parseInt(String(statusCode || 0), 10);
+  return numericStatus >= 200 && numericStatus < 300;
+};
+
 const proxyPushToServe = async ({
   port,
   bodyBuffer,
@@ -58,6 +130,8 @@ const createGmailPushHandler = ({
   resolvePushToken,
   resolveTargetByEmail,
   markPushReceived,
+  shouldProcessPushEvent = createGmailPushEventDeduper(),
+  proxyPushToServeImpl = proxyPushToServe,
 }) =>
   async (req, res) => {
     try {
@@ -68,11 +142,24 @@ const createGmailPushHandler = ({
       }
 
       const bodyBuffer = extractBodyBuffer(req.body);
-      const { payload } = parsePushEnvelope(bodyBuffer);
+      const { envelope, payload } = parsePushEnvelope(bodyBuffer);
       const email = String(payload?.emailAddress || "").trim().toLowerCase();
       if (!email) {
         return res.status(200).json({ ok: true, ignored: true, reason: "missing_email" });
       }
+      if (
+        !shouldProcessPushEvent({
+          envelope,
+          payload,
+          receivedAt: Date.now(),
+        })
+      ) {
+        return res.status(200).json({
+          ok: true,
+          ignored: true,
+          reason: "duplicate_event",
+        });
+      }
 
       const target = resolveTargetByEmail?.(email);
       if (!target?.port) {
@@ -80,15 +167,22 @@ const createGmailPushHandler = ({
       }
 
       try {
-        const proxied = await proxyPushToServe({
+        const proxied = await proxyPushToServeImpl({
           port: target.port,
           bodyBuffer,
           headers: req.headers || {},
         });
-        await markPushReceived?.({
-          accountId: target.accountId,
-          at: Date.now(),
-        });
+        if (isSuccessfulProxyStatus(proxied.statusCode)) {
+          shouldProcessPushEvent.markProcessed?.({
+            envelope,
+            payload,
+            receivedAt: Date.now(),
+          });
+          await markPushReceived?.({
+            accountId: target.accountId,
+            at: Date.now(),
+          });
+        }
         return res
           .status(proxied.statusCode)
           .send(proxied.body || "");
@@ -106,4 +200,6 @@ const createGmailPushHandler = ({
 
 module.exports = {
   createGmailPushHandler,
+  createGmailPushEventDeduper,
+  createPushEventDedupeKey,
 };

package/lib/server/gmail-watch.js

@@ -14,29 +14,14 @@ const {
   allocateServePort,
 } = require("./google-state");
 const { createGmailServeManager } = require("./gmail-serve");
+const { parseJsonObjectFromNoisyOutput, parseJsonSafe } = require("./utils/json");
 const { createWebhook } = require("./webhooks");
-
-const quoteShellArg = (value) =>
-  `"${String(value || "").replace(/(["\\$`])/g, "\\$1")}"`;
-
-const parseJsonMaybe = (raw) => {
-  const text = String(raw || "").trim();
-  if (!text) return null;
-  try {
-    return JSON.parse(text);
-  } catch {}
-  const firstBrace = text.indexOf("{");
-  const lastBrace = text.lastIndexOf("}");
-  if (firstBrace >= 0 && lastBrace > firstBrace) {
-    try {
-      return JSON.parse(text.slice(firstBrace, lastBrace + 1));
-    } catch {}
-  }
-  return null;
-};
+const { quoteShellArg } = require("./utils/shell");
 
 const parseExpirationFromOutput = (raw) => {
-  const parsed = parseJsonMaybe(raw);
+  const parsed =
+    parseJsonSafe(raw, null, { trim: true }) ||
+    parseJsonObjectFromNoisyOutput(raw);
   if (parsed?.expiration) {
     const numeric = Number.parseInt(String(parsed.expiration), 10);
     if (Number.isFinite(numeric) && numeric > 0) return numeric;

package/lib/server/helpers.js

@@ -5,6 +5,9 @@ const {
   kOnboardingModelProviders,
   gogClientCredentialsPath,
 } = require("./constants");
+const { isTruthyFlag } = require("./utils/boolean");
+const { parseJsonObjectFromNoisyOutput } = require("./utils/json");
+const { normalizeIp } = require("./utils/network");
 
 const normalizeOpenclawVersion = (rawVersion) => {
   if (!rawVersion) return null;
@@ -32,19 +35,7 @@ const compareVersionParts = (a, b) => {
   return 0;
 };
 
-const parseJsonFromNoisyOutput = (raw) => {
-  const text = String(raw || "");
-  const firstBrace = text.indexOf("{");
-  const lastBrace = text.lastIndexOf("}");
-  if (firstBrace === -1 || lastBrace === -1 || lastBrace <= firstBrace) {
-    return null;
-  }
-  try {
-    return JSON.parse(text.slice(firstBrace, lastBrace + 1));
-  } catch {
-    return null;
-  }
-};
+const parseJsonFromNoisyOutput = (raw) => parseJsonObjectFromNoisyOutput(raw);
 
 const parseJwtPayload = (token) => {
   try {
@@ -63,14 +54,7 @@ const getCodexAccountId = (accessToken) => {
   return typeof accountId === "string" && accountId ? accountId : null;
 };
 
-const normalizeIp = (ip) => String(ip || "").replace(/^::ffff:/, "");
-
-const isTruthyEnvFlag = (value) =>
-  ["1", "true", "yes", "on"].includes(
-    String(value || "")
-      .trim()
-      .toLowerCase(),
-  );
+const isTruthyEnvFlag = (value) => isTruthyFlag(value);
 const isDebugEnabled = () =>
   isTruthyEnvFlag(process.env.ALPHACLAW_DEBUG) ||
   isTruthyEnvFlag(process.env.DEBUG);