pi-telegram-notifier 0.1.1 → 0.1.3

package/README.md

@@ -41,6 +41,8 @@ Telegram has a message-length limit; long responses are delivered in consecutive
 ## Develop and release
 
 ```sh
+npm ci
+npm run typecheck
 npm test
 npm pack --dry-run --json
 pi --no-extensions -e . --help

package/extensions/index.ts

@@ -2,8 +2,8 @@ import { randomBytes } from 'node:crypto';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import { pairChat, saveChatId } from '../src/telegram.js';
-import { registerNotifications } from '../src/notification.js';
+import { pairChat, saveChatId } from '#src/telegram';
+import { registerNotifications } from '#src/notification';
 
 const agentDir = () => process.env.PI_CODING_AGENT_DIR || join(homedir(), '.pi', 'agent');
 

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "pi-telegram-notifier",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Telegram notifications for final Pi agent responses and provider balances",
   "type": "module",
   "license": "MIT",
   "engines": { "node": ">=22.19.0" },
   "keywords": ["pi-package", "pi", "telegram", "notifications"],
   "files": ["extensions", "src", "README.md", "LICENSE", "docs/providers.md"],
-  "scripts": { "test": "node --test" },
+  "imports": { "#src/*": "./src/*.ts" },
+  "scripts": { "test": "node --test", "typecheck": "tsc --noEmit" },
   "pi": { "extensions": ["./extensions/index.ts"] },
   "peerDependencies": { "@earendil-works/pi-coding-agent": "*" },
+  "devDependencies": { "@types/node": "22.20.4", "typescript": "5.9.3" },
   "repository": { "type": "git", "url": "git+https://github.com/Gybra/pi-telegram-notifier.git" }
 }

package/src/{notification.js → notification.ts}

@@ -1,8 +1,11 @@
 import { hostname } from 'node:os';
-import { loadChatId, sendTelegram } from './telegram.js';
-import { getQuota } from './quota.js';
+import type { ExtensionAPI, SessionEntry } from '@earendil-works/pi-coding-agent';
+import { loadChatId, sendTelegram } from '#src/telegram';
+import { getQuota } from '#src/quota';
 
-export function finalResponse(branch, startLeafId) {
+type FinalResponse = { text: string; provider: string; modelId: string };
+
+export function finalResponse(branch: SessionEntry[], startLeafId: string | null): FinalResponse | undefined {
   const index = startLeafId === null ? -1 : branch.findIndex((entry) => entry.id === startLeafId);
   if (index < 0 && startLeafId !== null) return undefined;
   const latest = branch.slice(index + 1).filter((entry) => entry.type === 'message').at(-1)?.message;
@@ -12,12 +15,12 @@ export function finalResponse(branch, startLeafId) {
   return { text, provider: latest.provider, modelId: latest.model };
 }
 
-export function formatNotification(timestamp, response, quota) {
+export function formatNotification(timestamp: string, response: FinalResponse, quota: string): string {
   return `${timestamp}\nDevice: ${hostname()}\nProvider: ${response.provider}\n${quota}\n\n${response.text}`;
 }
 
-export function registerNotifications(pi, agentDir, token, fetchImpl = fetch) {
-  let startLeafId;
+export function registerNotifications(pi: ExtensionAPI, agentDir: string, token: string | undefined, fetchImpl: typeof fetch = fetch): void {
+  let startLeafId: string | null | undefined;
   pi.on('agent_start', (_event, ctx) => {
     startLeafId = ctx.sessionManager.getLeafId();
   });
@@ -27,9 +30,14 @@ export function registerNotifications(pi, agentDir, token, fetchImpl = fetch) {
     startLeafId = undefined;
     const chatId = loadChatId(agentDir);
     if (!chatId || !response) return;
+    let quota: string;
     try {
       const model = ctx.modelRegistry?.find(response.provider, response.modelId);
-      const quota = await getQuota(model, ctx.modelRegistry, fetchImpl);
+      quota = await getQuota(model, ctx.modelRegistry, fetchImpl);
+    } catch {
+      quota = 'Quota unavailable';
+    }
+    try {
       await sendTelegram(token, chatId,
         formatNotification(new Date().toISOString(), response, quota), fetchImpl);
     } catch {

package/src/{quota.js → quota.ts}

@@ -1,30 +1,34 @@
+import type { ModelRegistry } from '@earendil-works/pi-coding-agent';
+
 const UNAVAILABLE = 'Quota unavailable';
 
-const providers = {
-  openrouter: ['https://openrouter.ai', 'https://openrouter.ai/api/v1/credits'],
-  'openai-codex': ['https://chatgpt.com', 'https://chatgpt.com/backend-api/wham/usage'],
-  deepseek: ['https://api.deepseek.com', 'https://api.deepseek.com/user/balance'],
-  moonshotai: ['https://api.moonshot.ai', 'https://api.moonshot.ai/v1/users/me/balance'],
-  'moonshotai-cn': ['https://api.moonshot.cn', 'https://api.moonshot.cn/v1/users/me/balance'],
-  zai: ['https://api.z.ai', 'https://api.z.ai/api/monitor/usage/quota/limit'],
-  'zai-coding-cn': ['https://open.bigmodel.cn', 'https://open.bigmodel.cn/api/monitor/usage/quota/limit'],
-  anthropic: ['https://api.anthropic.com', 'https://api.anthropic.com/api/oauth/usage'],
-  xai: ['https://api.x.ai', 'https://cli-chat-proxy.grok.com/v1/billing?format=credits'],
+type Model = NonNullable<ReturnType<ModelRegistry['find']>>;
+
+const providers: Record<string, { origin: string; url: string }> = {
+  openrouter: { origin: 'https://openrouter.ai', url: 'https://openrouter.ai/api/v1/credits' },
+  'openai-codex': { origin: 'https://chatgpt.com', url: 'https://chatgpt.com/backend-api/wham/usage' },
+  deepseek: { origin: 'https://api.deepseek.com', url: 'https://api.deepseek.com/user/balance' },
+  moonshotai: { origin: 'https://api.moonshot.ai', url: 'https://api.moonshot.ai/v1/users/me/balance' },
+  'moonshotai-cn': { origin: 'https://api.moonshot.cn', url: 'https://api.moonshot.cn/v1/users/me/balance' },
+  zai: { origin: 'https://api.z.ai', url: 'https://api.z.ai/api/monitor/usage/quota/limit' },
+  'zai-coding-cn': { origin: 'https://open.bigmodel.cn', url: 'https://open.bigmodel.cn/api/monitor/usage/quota/limit' },
+  anthropic: { origin: 'https://api.anthropic.com', url: 'https://api.anthropic.com/api/oauth/usage' },
+  xai: { origin: 'https://api.x.ai', url: 'https://cli-chat-proxy.grok.com/v1/billing?format=credits' },
 };
 
-function remainingPercent(used) {
+function remainingPercent(used: unknown): number | undefined {
   return typeof used === 'number' && Number.isFinite(used) && used >= 0 && used <= 100 ? 100 - used : undefined;
 }
 
-export async function getQuota(model, modelRegistry, fetchImpl = fetch) {
+export async function getQuota(model: Model | undefined, modelRegistry: Pick<ModelRegistry, 'getApiKeyAndHeaders' | 'isUsingOAuth'> | undefined, fetchImpl: typeof fetch = fetch): Promise<string> {
   const provider = model && providers[model.provider];
   if (!provider) return UNAVAILABLE;
   try {
-    if (new URL(model.baseUrl).origin !== provider[0]) return UNAVAILABLE;
-    if (['anthropic', 'xai'].includes(model.provider) && !modelRegistry.isUsingOAuth(model)) return UNAVAILABLE;
-    const auth = await modelRegistry.getApiKeyAndHeaders(model);
-    if (!auth.ok || !auth.apiKey || (auth.baseUrl && new URL(auth.baseUrl).origin !== provider[0])) return UNAVAILABLE;
-    const headers = { Authorization: ['zai', 'zai-coding-cn'].includes(model.provider) ? auth.apiKey : `Bearer ${auth.apiKey}` };
+    if (new URL(model.baseUrl).origin !== provider.origin) return UNAVAILABLE;
+    if (['anthropic', 'xai'].includes(model.provider) && !modelRegistry?.isUsingOAuth(model)) return UNAVAILABLE;
+    const auth = await modelRegistry?.getApiKeyAndHeaders(model);
+    if (!auth?.ok || !auth.apiKey || (auth.baseUrl && new URL(auth.baseUrl).origin !== provider.origin)) return UNAVAILABLE;
+    const headers: Record<string, string> = { Authorization: ['zai', 'zai-coding-cn'].includes(model.provider) ? auth.apiKey : `Bearer ${auth.apiKey}` };
     if (model.provider === 'anthropic') {
       headers['anthropic-beta'] = 'oauth-2025-04-20';
       headers['anthropic-version'] = '2023-06-01';
@@ -35,7 +39,7 @@ export async function getQuota(model, modelRegistry, fetchImpl = fetch) {
       if (typeof accountId !== 'string' || !accountId) return UNAVAILABLE;
       headers['ChatGPT-Account-Id'] = accountId;
     }
-    const response = await fetchImpl(provider[1], {
+    const response = await fetchImpl(provider.url, {
       headers,
       signal: AbortSignal.timeout(10_000),
     });
@@ -43,7 +47,7 @@ export async function getQuota(model, modelRegistry, fetchImpl = fetch) {
     const data = await response.json();
     if (['zai', 'zai-coding-cn'].includes(model.provider)) {
       if (data.success === false || ![undefined, 0, 200].includes(data.code)) return UNAVAILABLE;
-      const used = data.data?.limits?.find((limit) => limit.type === 'TOKENS_LIMIT')?.percentage;
+      const used = data.data?.limits?.find((limit: { type: string; percentage: number }) => limit.type === 'TOKENS_LIMIT')?.percentage;
       const remaining = remainingPercent(used);
       return remaining === undefined ? UNAVAILABLE : `Remaining quota: 5h ${remaining}%`;
     }
@@ -62,7 +66,7 @@ export async function getQuota(model, modelRegistry, fetchImpl = fetch) {
       if (remaining === undefined && config.creditUsagePercent === undefined) {
         const { currentPeriod, productUsage } = config;
         if (Date.parse(currentPeriod.start) < Date.parse(currentPeriod.end) &&
-            (productUsage === undefined || (Array.isArray(productUsage) && productUsage.every((item) => item?.usagePercent === 0)))) remaining = 100;
+            Array.isArray(productUsage) && productUsage.length > 0 && productUsage.every((item) => item?.usagePercent === 0)) remaining = 100;
       }
       return remaining === undefined ? UNAVAILABLE : `Remaining quota: 7d ${remaining}%`;
     }
@@ -85,7 +89,7 @@ export async function getQuota(model, modelRegistry, fetchImpl = fetch) {
     }
     if (model.provider === 'deepseek') {
       if (!Array.isArray(data.balance_infos) || !data.balance_infos.length) return UNAVAILABLE;
-      const balances = data.balance_infos.map(({ currency, total_balance }) => {
+      const balances = data.balance_infos.map(({ currency, total_balance }: { currency: string; total_balance: string }) => {
         if (!['CNY', 'USD'].includes(currency) || typeof total_balance !== 'string' ||
             !/^\d+(?:\.\d+)?$/.test(total_balance)) return undefined;
         return `${total_balance} ${currency}`;

package/src/{telegram.js → telegram.ts}

@@ -2,18 +2,18 @@ import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomBytes } from 'node:crypto';
 
-const stateFile = (agentDir) => join(agentDir, 'pi-telegram-notifier.json');
+const stateFile = (agentDir: string) => join(agentDir, 'pi-telegram-notifier.json');
 
-export function loadChatId(agentDir) {
+export function loadChatId(agentDir: string): number | undefined {
   try {
-    const id = JSON.parse(readFileSync(stateFile(agentDir), 'utf8')).chatId;
-    return Number.isSafeInteger(id) && id > 0 ? id : undefined;
+    const id: unknown = JSON.parse(readFileSync(stateFile(agentDir), 'utf8')).chatId;
+    return typeof id === 'number' && Number.isSafeInteger(id) && id > 0 ? id : undefined;
   } catch {
     return undefined;
   }
 }
 
-export function saveChatId(agentDir, chatId) {
+export function saveChatId(agentDir: string, chatId: number): void {
   if (!Number.isSafeInteger(chatId) || chatId <= 0) throw new Error('Invalid private chat ID');
   mkdirSync(agentDir, { recursive: true, mode: 0o700 });
   const temporary = `${stateFile(agentDir)}.${randomBytes(8).toString('hex')}`;
@@ -21,7 +21,7 @@ export function saveChatId(agentDir, chatId) {
   renameSync(temporary, stateFile(agentDir));
 }
 
-export async function pairChat(token, code, fetchImpl = fetch, now = Date.now) {
+export async function pairChat(token: string, code: string, fetchImpl: typeof fetch = fetch, now: () => number = Date.now): Promise<number> {
   const expires = now() + 300_000;
   let offset = 0;
   while (now() < expires) {
@@ -51,9 +51,9 @@ export async function pairChat(token, code, fetchImpl = fetch, now = Date.now) {
   throw new Error('Telegram pairing code expired');
 }
 
-export async function sendTelegram(token, chatId, text, fetchImpl = fetch) {
+export async function sendTelegram(token: string, chatId: number, text: string, fetchImpl: typeof fetch = fetch): Promise<void> {
   let part = '';
-  const chunks = [];
+  const chunks: string[] = [];
   for (const character of text) {
     if (part.length + character.length > 4096) {
       chunks.push(part);