@tduyng/pi-session 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tduyng/pi-session",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Session lifecycle: name an unnamed session after its first message, and resume once a provider quota resets.",
   "keywords": [
     "pi",
@@ -31,6 +31,9 @@
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*"
   },
+  "dependencies": {
+    "ata-validator": "^1.62.1"
+  },
   "publishConfig": {
     "access": "public"
   },

package/src/autoresume.ts

@@ -1,6 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
-import { claudeToken, fetchAnthropicUsage } from '../../pi-cost/src/cost/index.js'
-import { exhaustedResetAt } from '../../pi-cost/src/cost/logic.js'
+import { claudeToken, exhaustedResetAt, fetchAnthropicUsage } from './usage.js'
 
 const SAFETY_DELAY_MS = 5_000
 const MAX_DELAY_MS = 24 * 60 * 60 * 1000
@@ -33,6 +32,7 @@ export default function autoResume(pi: ExtensionAPI) {
         pendingError = undefined
 
         if (!enabled || !error || resumeAt) return
+        if (!isQuotaError(error)) return
 
         const reportedTarget = parseReset(error)
         const providerTarget = ctx.model?.provider === 'claude-bridge' ? await usageResetAt(pi, ctx) : undefined
@@ -78,9 +78,9 @@ export default function autoResume(pi: ExtensionAPI) {
     })
 
     pi.on('session_shutdown', async (_event, ctx) => cancel(ctx))
-    pi.on('session_start', () => {
+    pi.on('session_start', (_event, ctx) => {
         pendingError = undefined
-        stopTicker()
+        cancel(ctx)
     })
 }
 
@@ -244,10 +244,14 @@ function parseRetryAfter(input: string, now: number): number | undefined {
     return match ? now + Number(match[1]) * 1000 : undefined
 }
 
+function isQuotaError(input: string): boolean {
+    return /\b(?:usage|quota|limit|rate[- ]?limit|too many requests|429)\b/i.test(input)
+}
+
 function parseClock(input: string, now: number): number | undefined {
     const match = input.match(/\breset(?:s)?(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?(?:\s*\(([^)]+)\))?/i)
 
-    if (!match) return
+    if (!match || (match[2] === undefined && match[3] === undefined)) return
 
     let hour = Number(match[1])
     const minute = Number(match[2] ?? '0')

package/src/usage.ts

@@ -0,0 +1,109 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { Validator } from 'ata-validator'
+import { t } from 'ata-validator/t'
+
+const REQUEST_TIMEOUT_MS = 10_000
+const KEYCHAIN_TIMEOUT_MS = 5_000
+
+const WindowSchema = t.object({
+    utilization: t.optional(t.union([t.number(), t.null()])),
+    resets_at: t.optional(t.union([t.string(), t.number(), t.null()]))
+})
+const UsageSchema = t.object({
+    five_hour: t.optional(t.union([WindowSchema, t.null()])),
+    seven_day: t.optional(t.union([WindowSchema, t.null()])),
+    seven_day_opus: t.optional(t.union([WindowSchema, t.null()])),
+    seven_day_sonnet: t.optional(t.union([WindowSchema, t.null()]))
+})
+const CredentialsSchema = t.object(
+    {
+        claudeAiOauth: t.optional(t.object({ accessToken: t.optional(t.string()) }, { additionalProperties: true }))
+    },
+    { additionalProperties: true }
+)
+
+const isUsage = new Validator(UsageSchema).isValidObject
+const isCredentials = new Validator(CredentialsSchema).isValidObject
+
+export type AnthropicWindow = { utilization?: number | null; resets_at?: string | number | null }
+
+export type AnthropicUsagePayload = {
+    five_hour?: AnthropicWindow | null
+    seven_day?: AnthropicWindow | null
+    seven_day_opus?: AnthropicWindow | null
+    seven_day_sonnet?: AnthropicWindow | null
+}
+
+function finite(value: number | null | undefined): number | undefined {
+    const numeric = value ?? Number.NaN
+    return Number.isFinite(numeric) ? numeric : undefined
+}
+
+export function resetAtMs(value: string | number | null | undefined): number | undefined {
+    if (value === null || value === undefined) return undefined
+    const numeric = Number(value)
+    const parsed = Number.isFinite(numeric) ? numeric : Date.parse(String(value))
+    if (!Number.isFinite(parsed) || parsed <= 0) return undefined
+    return parsed < 1e12 ? parsed * 1000 : parsed
+}
+
+export function exhaustedResetAt(payload: AnthropicUsagePayload): number | undefined {
+    const windows = [payload.five_hour, payload.seven_day, payload.seven_day_opus, payload.seven_day_sonnet]
+    let latest: number | undefined
+    for (const window of windows) {
+        const utilization = finite(window?.utilization)
+        const resetAt = resetAtMs(window?.resets_at)
+        if (utilization === undefined || utilization < 100 || resetAt === undefined) continue
+        latest = latest === undefined ? resetAt : Math.max(latest, resetAt)
+    }
+    return latest
+}
+
+export function claudeAccessToken(raw: string | undefined): string | undefined {
+    if (!raw) return undefined
+    try {
+        const parsed: unknown = JSON.parse(raw)
+        if (!isCredentials(parsed)) return undefined
+        const token = parsed.claudeAiOauth?.accessToken?.trim()
+        return token || undefined
+    } catch {
+        return undefined
+    }
+}
+
+export async function claudeToken(
+    pi: ExtensionAPI,
+    platform: NodeJS.Platform = process.platform
+): Promise<string | undefined> {
+    let raw: string | undefined
+    if (platform === 'darwin') {
+        const result = await pi.exec('security', ['find-generic-password', '-s', 'Claude Code-credentials', '-w'], {
+            cwd: os.homedir(),
+            timeout: KEYCHAIN_TIMEOUT_MS
+        })
+        if (result.code && result.code !== 44) throw new Error(`keychain lookup failed (exit ${result.code})`)
+        raw = result.stdout
+    }
+    if (!raw) {
+        raw = await fs.readFile(path.join(os.homedir(), '.claude', '.credentials.json'), 'utf8').catch(() => undefined)
+    }
+    return claudeAccessToken(raw)
+}
+
+export async function fetchAnthropicUsage(token: string): Promise<AnthropicUsagePayload> {
+    const response = await fetch('https://api.anthropic.com/api/oauth/usage', {
+        headers: {
+            authorization: `Bearer ${token}`,
+            'anthropic-beta': 'oauth-2025-04-20',
+            accept: 'application/json'
+        },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    })
+    if (!response.ok) throw new Error(`HTTP ${response.status}`)
+    const payload: unknown = await response.json()
+    if (!isUsage(payload)) throw new Error('usage response did not match the Anthropic schema')
+    return payload
+}