forkoff 1.0.17 → 1.0.19

package/dist/tools/permission-hook.js

@@ -92,6 +92,32 @@ const DEFAULT_SAFE_TOOLS = new Set([
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+function safeReadFile(filePath) {
+    try {
+        const stat = fs.lstatSync(filePath);
+        if (stat.isSymbolicLink()) {
+            console.error(`[Security] Symlink detected, refusing to read: ${filePath}`);
+            return null;
+        }
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function safeWriteFile(filePath, content) {
+    try {
+        // SECURITY: Atomic write via temp file + rename to prevent TOCTOU symlink attacks
+        const tmpPath = filePath + '.tmp.' + process.pid;
+        fs.writeFileSync(tmpPath, content, { encoding: 'utf-8', mode: 0o600 });
+        fs.renameSync(tmpPath, filePath);
+        return true;
+    }
+    catch (err) {
+        console.error(`[Security] Failed to write file safely`, err.message);
+        return false;
+    }
+}
 /** Write the decision JSON to stdout synchronously and exit immediately. */
 function respond(decision, reason) {
     const output = {
@@ -106,29 +132,38 @@ function respond(decision, reason) {
     fs.writeSync(1, JSON.stringify(output) + '\n');
     process.exit(decision === 'allow' ? 0 : 2);
 }
-/** Ensure the temp directory exists. */
+/** Ensure the temp directory exists and has safe permissions. */
 function ensureTempDir() {
     if (!fs.existsSync(TEMP_DIR)) {
-        fs.mkdirSync(TEMP_DIR, { recursive: true });
+        fs.mkdirSync(TEMP_DIR, { recursive: true, mode: 0o700 });
+    }
+    else {
+        // SECURITY: Validate existing dir isn't world/group-writable (attacker pre-creation)
+        // Skip on Windows — Unix permission bits aren't enforced and produce false positives
+        if (process.platform !== 'win32') {
+            const stat = fs.statSync(TEMP_DIR);
+            const mode = stat.mode & 0o777;
+            if (mode & 0o022) { // group or other writable
+                console.error(`[Security] Temp dir has unsafe permissions (${mode.toString(8)}), aborting`);
+                respond('deny', 'Permission temp directory has unsafe permissions');
+            }
+        }
     }
 }
-/** Cleanup request and response temp files. */
+/** Cleanup request and response temp files (with symlink protection). */
 function cleanup(promptId) {
     const requestFile = path.join(TEMP_DIR, `${promptId}.request.json`);
     const responseFile = path.join(TEMP_DIR, `${promptId}.response.json`);
-    try {
-        if (fs.existsSync(requestFile))
-            fs.unlinkSync(requestFile);
-    }
-    catch {
-        // Best effort — ignore errors during cleanup.
-    }
-    try {
-        if (fs.existsSync(responseFile))
-            fs.unlinkSync(responseFile);
-    }
-    catch {
-        // Best effort.
+    for (const filePath of [requestFile, responseFile]) {
+        try {
+            const stat = fs.lstatSync(filePath);
+            if (stat.isFile() && !stat.isSymbolicLink()) {
+                fs.unlinkSync(filePath);
+            }
+        }
+        catch {
+            // Best effort — file may not exist or already deleted.
+        }
     }
 }
 /**
@@ -137,7 +172,10 @@ function cleanup(promptId) {
  */
 function loadRules() {
     try {
-        const raw = fs.readFileSync(RULES_FILE, 'utf-8');
+        const raw = safeReadFile(RULES_FILE);
+        if (raw === null) {
+            return { safeTools: new Set(DEFAULT_SAFE_TOOLS), bashPatterns: [] };
+        }
         const rules = JSON.parse(raw);
         if (!Array.isArray(rules)) {
             return { safeTools: new Set(DEFAULT_SAFE_TOOLS), bashPatterns: [] };
@@ -176,13 +214,38 @@ function matchesAnyPattern(command, patterns) {
 /**
  * Simple glob matching: `*` matches any sequence of characters.
  * The entire command must match (not just a prefix).
+ * Uses iterative matching to avoid ReDoS from regex catastrophic backtracking.
  */
 function globMatch(str, pattern) {
-    // Escape regex special chars except *, then replace * with .*
-    const regexStr = '^' + pattern
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*/g, '.*') + '$';
-    return new RegExp(regexStr).test(str);
+    // SECURITY: Reject overly long or complex patterns to prevent DoS
+    if (pattern.length > 200)
+        return false;
+    // Iterative glob matcher (no regex — immune to ReDoS)
+    let si = 0, pi = 0;
+    let starSi = -1, starPi = -1;
+    while (si < str.length) {
+        if (pi < pattern.length && (pattern[pi] === str[si] || pattern[pi] === '?')) {
+            si++;
+            pi++;
+        }
+        else if (pi < pattern.length && pattern[pi] === '*') {
+            starPi = pi;
+            starSi = si;
+            pi++;
+        }
+        else if (starPi !== -1) {
+            pi = starPi + 1;
+            starSi++;
+            si = starSi;
+        }
+        else {
+            return false;
+        }
+    }
+    while (pi < pattern.length && pattern[pi] === '*') {
+        pi++;
+    }
+    return pi === pattern.length;
 }
 /**
  * Poll for the response file until it appears or the timeout elapses.
@@ -199,10 +262,12 @@ function pollForResponse(promptId) {
             }
             try {
                 if (fs.existsSync(responseFile)) {
-                    const raw = fs.readFileSync(responseFile, 'utf-8');
-                    const response = JSON.parse(raw);
-                    resolve(response);
-                    return;
+                    const raw = safeReadFile(responseFile);
+                    if (raw !== null) {
+                        const response = JSON.parse(raw);
+                        resolve(response);
+                        return;
+                    }
                 }
             }
             catch {
@@ -270,7 +335,9 @@ async function main() {
             timestamp: Date.now(),
         };
         const requestFile = path.join(TEMP_DIR, `${promptId}.request.json`);
-        fs.writeFileSync(requestFile, JSON.stringify(request, null, 2), 'utf-8');
+        if (!safeWriteFile(requestFile, JSON.stringify(request, null, 2))) {
+            respond('deny', 'Failed to write permission request file');
+        }
         console.error(`[forkoff-hook] Permission requested for ${toolName} (promptId=${promptId}), polling...`);
         const response = await pollForResponse(promptId);
         if (!response) {

package/dist/tools/permission-ipc.d.ts

@@ -46,6 +46,7 @@ declare class PermissionIpcManager extends EventEmitter {
     private readonly POLL_INTERVAL_MS;
     private readonly TEMP_DIR;
     private processedFiles;
+    private static readonly MAX_PROCESSED_FILES;
     /** Currently tracked terminal session ID */
     private terminalSessionId;
     /** Currently tracked session key */

package/dist/tools/permission-ipc.js

@@ -57,6 +57,32 @@ const events_1 = require("events");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+function safeReadFile(filePath) {
+    try {
+        const stat = fs.lstatSync(filePath);
+        if (stat.isSymbolicLink()) {
+            console.error(`[Security] Symlink detected, refusing to read: ${filePath}`);
+            return null;
+        }
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function safeWriteFile(filePath, content) {
+    try {
+        // SECURITY: Atomic write via temp file + rename to prevent TOCTOU symlink attacks
+        const tmpPath = filePath + '.tmp.' + process.pid;
+        fs.writeFileSync(tmpPath, content, { encoding: 'utf-8', mode: 0o600 });
+        fs.renameSync(tmpPath, filePath);
+        return true;
+    }
+    catch (err) {
+        console.error(`[Security] Failed to write file safely`, err.message);
+        return false;
+    }
+}
 class PermissionIpcManager extends events_1.EventEmitter {
     constructor() {
         super(...arguments);
@@ -89,7 +115,7 @@ class PermissionIpcManager extends events_1.EventEmitter {
         this.sessionKey = sessionKey;
         // Ensure temp directory exists
         try {
-            fs.mkdirSync(this.TEMP_DIR, { recursive: true });
+            fs.mkdirSync(this.TEMP_DIR, { recursive: true, mode: 0o700 });
         }
         catch (err) {
             console.log(`[Permission IPC] Failed to create temp dir ${this.TEMP_DIR}: ${err.message}`);
@@ -143,12 +169,11 @@ class PermissionIpcManager extends events_1.EventEmitter {
         if (reason) {
             responseData.reason = reason;
         }
-        try {
-            fs.writeFileSync(responseFile, JSON.stringify(responseData), 'utf-8');
+        if (safeWriteFile(responseFile, JSON.stringify(responseData))) {
             console.log(`[Permission IPC] Wrote response for ${promptId}: ${decision}${reason ? ` (${reason})` : ''}`);
         }
-        catch (err) {
-            console.log(`[Permission IPC] Failed to write response file ${responseFile}: ${err.message}`);
+        else {
+            console.log(`[Permission IPC] Failed to write response file ${responseFile}`);
         }
     }
     /**
@@ -170,9 +195,19 @@ class PermissionIpcManager extends events_1.EventEmitter {
         for (const file of requestFiles) {
             const filePath = path.join(this.TEMP_DIR, file);
             try {
-                const content = fs.readFileSync(filePath, 'utf-8');
+                const content = safeReadFile(filePath);
+                if (content === null) {
+                    this.processedFiles.add(file);
+                    console.log(`[Permission IPC] Skipped unreadable request file ${file}`);
+                    continue;
+                }
                 const request = JSON.parse(content);
-                // Mark as processed to avoid duplicate handling
+                // Mark as processed to avoid duplicate handling (evict oldest if at cap)
+                if (this.processedFiles.size >= PermissionIpcManager.MAX_PROCESSED_FILES) {
+                    const oldest = this.processedFiles.values().next().value;
+                    if (oldest)
+                        this.processedFiles.delete(oldest);
+                }
                 this.processedFiles.add(file);
                 const promptId = request.promptId || file.replace('.request.json', '');
                 const toolName = request.toolName || 'unknown';
@@ -205,6 +240,11 @@ class PermissionIpcManager extends events_1.EventEmitter {
             catch (err) {
                 // File might be partially written or malformed — skip it for now
                 // but add to processed so we don't retry every poll cycle
+                if (this.processedFiles.size >= PermissionIpcManager.MAX_PROCESSED_FILES) {
+                    const oldest = this.processedFiles.values().next().value;
+                    if (oldest)
+                        this.processedFiles.delete(oldest);
+                }
                 this.processedFiles.add(file);
                 console.log(`[Permission IPC] Failed to read request file ${file}: ${err.message}`);
             }
@@ -240,18 +280,23 @@ class PermissionIpcManager extends events_1.EventEmitter {
      */
     cleanup() {
         this.stop();
-        // Try to clean up remaining temp files in the directory
+        // Try to clean up remaining request/response temp files in the directory
         try {
             const files = fs.readdirSync(this.TEMP_DIR);
-            for (const file of files) {
+            const ipcFiles = files.filter((f) => f.endsWith('.request.json') || f.endsWith('.response.json'));
+            for (const file of ipcFiles) {
                 try {
-                    fs.unlinkSync(path.join(this.TEMP_DIR, file));
+                    const filePath = path.join(this.TEMP_DIR, file);
+                    const stat = fs.lstatSync(filePath);
+                    if (stat.isFile() && !stat.isSymbolicLink()) {
+                        fs.unlinkSync(filePath);
+                    }
                 }
                 catch (err) {
                     // File may already be deleted by the hook script — ignore
                 }
             }
-            console.log(`[Permission IPC] Cleaned up ${files.length} temp file(s)`);
+            console.log(`[Permission IPC] Cleaned up ${ipcFiles.length} temp file(s)`);
         }
         catch (err) {
             // Directory might not exist — that's fine
@@ -272,12 +317,13 @@ class PermissionIpcManager extends events_1.EventEmitter {
             // Directory doesn't exist — nothing to clean
             return;
         }
+        const ipcFiles = files.filter((f) => f.endsWith('.request.json') || f.endsWith('.response.json'));
         let cleaned = 0;
-        for (const file of files) {
+        for (const file of ipcFiles) {
             const filePath = path.join(tempDir, file);
             try {
-                const stat = fs.statSync(filePath);
-                if (stat.isFile()) {
+                const stat = fs.lstatSync(filePath);
+                if (stat.isFile() && !stat.isSymbolicLink()) {
                     fs.unlinkSync(filePath);
                     cleaned++;
                 }
@@ -292,4 +338,5 @@ class PermissionIpcManager extends events_1.EventEmitter {
     }
 }
 exports.PermissionIpcManager = PermissionIpcManager;
+PermissionIpcManager.MAX_PROCESSED_FILES = 500; // Cap to prevent memory DoS
 //# sourceMappingURL=permission-ipc.js.map

package/dist/transcript-streamer.d.ts

@@ -32,6 +32,7 @@ declare class TranscriptStreamer extends EventEmitter {
     private fileSizes;
     private lastLineNumbers;
     private processingLock;
+    private sessionPaths;
     /**
      * Fetch transcript history from a JSONL file
      * Supports reverse pagination: offset 0 = most recent entries

package/dist/transcript-streamer.js

@@ -38,6 +38,7 @@ const fs = __importStar(require("fs"));
 const readline = __importStar(require("readline"));
 const events_1 = require("events");
 const chokidar = __importStar(require("chokidar"));
+const MAX_WATCHERS = 50;
 class TranscriptStreamer extends events_1.EventEmitter {
     constructor() {
         super(...arguments);
@@ -45,6 +46,7 @@ class TranscriptStreamer extends events_1.EventEmitter {
         this.fileSizes = new Map();
         this.lastLineNumbers = new Map();
         this.processingLock = new Map(); // Prevent concurrent reads
+        this.sessionPaths = new Map(); // sessionKey -> transcriptPath
     }
     /**
      * Fetch transcript history from a JSONL file
@@ -107,9 +109,14 @@ class TranscriptStreamer extends events_1.EventEmitter {
     subscribeToUpdates(sessionKey, transcriptPath) {
         // Unsubscribe if already subscribed
         this.unsubscribeFromUpdates(sessionKey);
-        console.log(`[Transcript] subscribeToUpdates: sessionKey=${sessionKey}, path=${transcriptPath}`);
+        // Guard against unbounded watcher growth
+        if (this.watchers.size >= MAX_WATCHERS) {
+            console.warn(`[Transcript] MAX_WATCHERS (${MAX_WATCHERS}) reached, refusing to subscribe: ${sessionKey}`);
+            return;
+        }
+        console.log(`[Transcript] subscribeToUpdates: sessionKey=${sessionKey}`);
         if (!fs.existsSync(transcriptPath)) {
-            console.log(`[Transcript] File does not exist: ${transcriptPath}`);
+            console.log(`[Transcript] Transcript file does not exist`);
             return;
         }
         // Get initial file size
@@ -167,6 +174,7 @@ class TranscriptStreamer extends events_1.EventEmitter {
             }
         });
         this.watchers.set(sessionKey, watcher);
+        this.sessionPaths.set(sessionKey, transcriptPath);
     }
     /**
      * Unsubscribe from transcript updates
@@ -178,6 +186,11 @@ class TranscriptStreamer extends events_1.EventEmitter {
             this.watchers.delete(sessionKey);
             this.fileSizes.delete(sessionKey);
             this.processingLock.delete(sessionKey);
+            const transcriptPath = this.sessionPaths.get(sessionKey);
+            if (transcriptPath) {
+                this.lastLineNumbers.delete(transcriptPath);
+                this.sessionPaths.delete(sessionKey);
+            }
         }
     }
     /**
@@ -189,7 +202,7 @@ class TranscriptStreamer extends events_1.EventEmitter {
             const entries = [];
             let lineNumber = 0;
             let newLinesFound = 0;
-            console.log(`[Transcript] readNewLines: lastLineNumber=${lastLineNumber}, path=${transcriptPath}`);
+            console.log(`[Transcript] readNewLines: lastLineNumber=${lastLineNumber}`);
             const fileStream = fs.createReadStream(transcriptPath, { encoding: 'utf8' });
             const rl = readline.createInterface({
                 input: fileStream,
@@ -207,7 +220,7 @@ class TranscriptStreamer extends events_1.EventEmitter {
                     }
                     else {
                         // Log first 100 chars of skipped line to understand what's being skipped
-                        console.log(`[Transcript] Line ${lineNumber} skipped (no entry), preview: ${line.substring(0, 100)}`);
+                        console.log(`[Transcript] Line ${lineNumber} skipped (no entry)`);
                     }
                 }
             });
@@ -453,6 +466,7 @@ class TranscriptStreamer extends events_1.EventEmitter {
         this.fileSizes.clear();
         this.lastLineNumbers.clear();
         this.processingLock.clear();
+        this.sessionPaths.clear();
     }
 }
 exports.transcriptStreamer = new TranscriptStreamer();

package/dist/usage-tracker.d.ts

@@ -0,0 +1,45 @@
+export declare class UsageTracker {
+    private filePath;
+    private data;
+    private saveTimer;
+    private dirty;
+    constructor();
+    private load;
+    private scheduleSave;
+    private saveNow;
+    private ensureDay;
+    recordUsage(inputTokens: number, outputTokens: number): void;
+    recordSessionStart(): void;
+    /**
+     * Get usage stats matching the mobile UsageStats type.
+     */
+    getUsageStats(period?: 'day' | 'week' | 'month' | 'all'): {
+        totalInputTokens: string;
+        totalOutputTokens: string;
+        totalTokens: string;
+        totalSessionCount: number;
+        estimatedCostUsd: number;
+        period: string;
+    };
+    /**
+     * Get daily usage matching the mobile TokenUsageDaily[] type.
+     */
+    getDailyUsage(startDate?: string, endDate?: string): Array<{
+        date: string;
+        inputTokens: string;
+        outputTokens: string;
+        totalTokens: string;
+        sessionCount: number;
+        estimatedCostUsd: number | null;
+    }>;
+    /**
+     * Get streak info matching the mobile StreakInfo type.
+     */
+    getStreakInfo(): {
+        currentStreak: number;
+        totalActiveDays: number;
+    };
+    /** Flush pending writes immediately (call before exit). */
+    flush(): void;
+}
+//# sourceMappingURL=usage-tracker.d.ts.map