forkoff 1.0.17 → 1.0.19

package/dist/usage-tracker.js

@@ -0,0 +1,243 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageTracker = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+function getConfigDir() {
+    return process.platform === 'win32'
+        ? path.join(process.env.APPDATA || os.homedir(), 'forkoff-cli')
+        : path.join(os.homedir(), '.config', 'forkoff-cli');
+}
+function getTodayKey() {
+    return new Date().toISOString().split('T')[0]; // "YYYY-MM-DD"
+}
+class UsageTracker {
+    constructor() {
+        this.saveTimer = null;
+        this.dirty = false;
+        const configDir = getConfigDir();
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+        }
+        this.filePath = path.join(configDir, 'usage.json');
+        this.data = this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+            }
+        }
+        catch {
+            // Corrupted file — start fresh
+        }
+        return {
+            daily: {},
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalSessionCount: 0,
+            activeDays: [],
+        };
+    }
+    scheduleSave() {
+        this.dirty = true;
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = null;
+            if (this.dirty) {
+                this.saveNow();
+            }
+        }, 2000);
+    }
+    saveNow() {
+        try {
+            const tmpFile = this.filePath + '.tmp.' + process.pid;
+            fs.writeFileSync(tmpFile, JSON.stringify(this.data, null, 2), { encoding: 'utf-8', mode: 0o600 });
+            fs.renameSync(tmpFile, this.filePath);
+            this.dirty = false;
+        }
+        catch (err) {
+            console.error(`[UsageTracker] Failed to save: ${err.message}`);
+        }
+    }
+    ensureDay(dateKey) {
+        if (!this.data.daily[dateKey]) {
+            this.data.daily[dateKey] = { inputTokens: 0, outputTokens: 0, sessionCount: 0 };
+            if (!this.data.activeDays.includes(dateKey)) {
+                this.data.activeDays.push(dateKey);
+                this.data.activeDays.sort();
+            }
+        }
+        return this.data.daily[dateKey];
+    }
+    recordUsage(inputTokens, outputTokens) {
+        const today = getTodayKey();
+        const day = this.ensureDay(today);
+        day.inputTokens += inputTokens;
+        day.outputTokens += outputTokens;
+        this.data.totalInputTokens += inputTokens;
+        this.data.totalOutputTokens += outputTokens;
+        this.scheduleSave();
+    }
+    recordSessionStart() {
+        const today = getTodayKey();
+        const day = this.ensureDay(today);
+        day.sessionCount += 1;
+        this.data.totalSessionCount += 1;
+        this.scheduleSave();
+    }
+    /**
+     * Get usage stats matching the mobile UsageStats type.
+     */
+    getUsageStats(period = 'all') {
+        const now = new Date();
+        let startDate = null;
+        if (period === 'day') {
+            startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        }
+        else if (period === 'week') {
+            startDate = new Date(now);
+            startDate.setDate(startDate.getDate() - 7);
+        }
+        else if (period === 'month') {
+            startDate = new Date(now);
+            startDate.setMonth(startDate.getMonth() - 1);
+        }
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let sessionCount = 0;
+        if (!startDate) {
+            // 'all' — use totals directly
+            inputTokens = this.data.totalInputTokens;
+            outputTokens = this.data.totalOutputTokens;
+            sessionCount = this.data.totalSessionCount;
+        }
+        else {
+            const startKey = startDate.toISOString().split('T')[0];
+            for (const [dateKey, day] of Object.entries(this.data.daily)) {
+                if (dateKey >= startKey) {
+                    inputTokens += day.inputTokens;
+                    outputTokens += day.outputTokens;
+                    sessionCount += day.sessionCount;
+                }
+            }
+        }
+        const totalTokens = inputTokens + outputTokens;
+        // Rough cost estimate: $3/M input, $15/M output (Claude Sonnet pricing)
+        const estimatedCostUsd = (inputTokens * 3 + outputTokens * 15) / 1000000;
+        return {
+            totalInputTokens: String(inputTokens),
+            totalOutputTokens: String(outputTokens),
+            totalTokens: String(totalTokens),
+            totalSessionCount: sessionCount,
+            estimatedCostUsd: Math.round(estimatedCostUsd * 100) / 100,
+            period,
+        };
+    }
+    /**
+     * Get daily usage matching the mobile TokenUsageDaily[] type.
+     */
+    getDailyUsage(startDate, endDate) {
+        const result = [];
+        const sortedDays = Object.keys(this.data.daily).sort();
+        for (const dateKey of sortedDays) {
+            if (startDate && dateKey < startDate)
+                continue;
+            if (endDate && dateKey > endDate)
+                continue;
+            const day = this.data.daily[dateKey];
+            const total = day.inputTokens + day.outputTokens;
+            const cost = (day.inputTokens * 3 + day.outputTokens * 15) / 1000000;
+            result.push({
+                date: dateKey,
+                inputTokens: String(day.inputTokens),
+                outputTokens: String(day.outputTokens),
+                totalTokens: String(total),
+                sessionCount: day.sessionCount,
+                estimatedCostUsd: Math.round(cost * 100) / 100,
+            });
+        }
+        return result;
+    }
+    /**
+     * Get streak info matching the mobile StreakInfo type.
+     */
+    getStreakInfo() {
+        const activeDays = this.data.activeDays;
+        const totalActiveDays = activeDays.length;
+        if (totalActiveDays === 0) {
+            return { currentStreak: 0, totalActiveDays: 0 };
+        }
+        // Calculate current streak from today backwards
+        const today = getTodayKey();
+        let currentStreak = 0;
+        let checkDate = new Date(today + 'T00:00:00');
+        // Allow today or yesterday as the start of the streak
+        const todayInList = activeDays.includes(today);
+        if (!todayInList) {
+            checkDate.setDate(checkDate.getDate() - 1);
+            const yesterday = checkDate.toISOString().split('T')[0];
+            if (!activeDays.includes(yesterday)) {
+                return { currentStreak: 0, totalActiveDays };
+            }
+        }
+        while (true) {
+            const key = checkDate.toISOString().split('T')[0];
+            if (activeDays.includes(key)) {
+                currentStreak++;
+                checkDate.setDate(checkDate.getDate() - 1);
+            }
+            else {
+                break;
+            }
+        }
+        return { currentStreak, totalActiveDays };
+    }
+    /** Flush pending writes immediately (call before exit). */
+    flush() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        if (this.dirty) {
+            this.saveNow();
+        }
+    }
+}
+exports.UsageTracker = UsageTracker;
+//# sourceMappingURL=usage-tracker.js.map

package/dist/websocket.d.ts

@@ -1,8 +1,11 @@
 import { EventEmitter } from 'events';
+import { E2EEManager } from './crypto/e2eeManager';
+import type { UsageTracker } from './usage-tracker';
 type DeviceStatus = 'online' | 'offline' | 'busy' | 'syncing';
 interface ClaudeSessionUpdate {
     sessionKey: string;
     directory: string;
+    name?: string;
     state: 'active' | 'inactive';
     lastUsedAt: string;
     transcriptPath?: string;
@@ -28,20 +31,52 @@ interface ClaudeApprovalRequest {
     context: string[];
     options: string[];
     promptText: string;
+    toolName?: string;
+    toolInput?: any;
 }
 export declare class WebSocketClient extends EventEmitter {
-    private socket;
-    private reconnectAttempts;
+    private server;
     private heartbeatInterval;
     private _sessionId;
+    private e2eeManager;
+    private e2eeInitialized;
+    private e2eePeerDeviceId;
+    private pendingSensitiveMessages;
+    private static readonly SENSITIVE_QUEUE_TTL_MS;
+    private static readonly MAX_PENDING_SENSITIVE;
+    private usageTracker;
     get sessionId(): string;
-    connect(): Promise<void>;
+    /** Start the embedded relay server and wire up event forwarding */
+    startServer(port: number): Promise<void>;
+    /** Set pairing code on the embedded server for in-process validation */
+    setPairingCode(code: string): void;
+    /**
+     * Initialize E2EE manager: generate/load keys.
+     * Called automatically on startServer. Non-blocking.
+     */
+    private initE2EE;
+    /**
+     * Send a sensitive event: encrypt if E2EE session exists with the target device.
+     * For events in ENFORCED_SENSITIVE_EVENTS, plaintext fallback is REFUSED — messages
+     * are queued until E2EE session establishes, or dropped after timeout.
+     */
+    emitSensitive(event: string, data: any, targetDeviceId?: string): void;
+    /**
+     * Flush queued sensitive messages now that E2EE session is established.
+     * Drops messages older than SENSITIVE_QUEUE_TTL_MS.
+     */
+    private flushSensitiveQueue;
+    /** Get the E2EE manager (for external key exchange initiation) */
+    getE2EEManager(): E2EEManager | null;
+    /** Check if E2EE session is active with a device */
+    isE2EEActive(deviceId: string): boolean;
+    /** SECURITY: Check if plaintext inbound events should be dropped (E2EE active with peer) */
+    private shouldDropPlaintextInbound;
     disconnect(): void;
     private startHeartbeat;
     private stopHeartbeat;
     sendHeartbeat(status?: DeviceStatus): void;
     updateStatus(status: DeviceStatus): void;
-    setSyncing(syncing: boolean): void;
     sendClaudeSessionUpdate(session: ClaudeSessionUpdate): void;
     sendClaudeSessions(sessions: ClaudeSessionUpdate[]): void;
     sendToolStatusUpdate(toolType: string, status: 'active' | 'inactive' | 'error'): void;
@@ -95,14 +130,6 @@ export declare class WebSocketClient extends EventEmitter {
         sessionKey: string;
         entry: TranscriptEntry;
     }): void;
-    sendRpcResponse(data: {
-        requestId: string;
-        result?: any;
-        error?: {
-            code: number;
-            message: string;
-        };
-    }): void;
     sendClaudeApprovalRequest(data: ClaudeApprovalRequest): void;
     sendToolActivity(data: {
         terminalSessionId: string;
@@ -164,6 +191,10 @@ export declare class WebSocketClient extends EventEmitter {
         ephemeralPublicKey: string;
     }): void;
     emitEncryptedMessage(data: any): void;
+    /** Set the usage tracker instance (called from index.ts after instantiation) */
+    setUsageTracker(tracker: UsageTracker): void;
+    /** Send all usage stats to mobile (called after E2EE established and on request) */
+    sendAllUsageStats(): void;
     sendClaudeSessionEvent(data: {
         sessionKey: string;
         event: {