initial commit

src/main/userscripts.ts

@@ -0,0 +1,99 @@
+import { mkdirSync, promises as fsp } from 'fs';
+import { join, parse } from 'path';
+
+export interface ScriptFile {
+  filename: string;
+  content: string;
+  fullpath: string;
+}
+
+export type ScriptTracker = Record<string, boolean>;
+
+/**
+ * Manages userscript files, tracker state, and per-script preferences.
+ * Scripts live in a `scripts/` subdirectory; tracker.json records enabled/disabled state;
+ * per-script preferences are stored in `scripts/preferences/<name>.json`.
+ */
+export class UserscriptManager {
+  private scriptsDir: string;
+  private prefsDir: string;
+  private trackerPath: string;
+
+  constructor(baseDir: string) {
+    this.scriptsDir = join(baseDir, 'scripts');
+    this.prefsDir = join(this.scriptsDir, 'preferences');
+    this.trackerPath = join(this.scriptsDir, 'tracker.json');
+    mkdirSync(this.scriptsDir, { recursive: true });
+    mkdirSync(this.prefsDir, { recursive: true });
+  }
+
+  get dir(): string {
+    return this.scriptsDir;
+  }
+
+  /** Read all .js files from the scripts directory */
+  async scanScripts(): Promise<ScriptFile[]> {
+    const scripts: ScriptFile[] = [];
+    try {
+      for (const entry of await fsp.readdir(this.scriptsDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith('.js')) continue;
+        const fullpath = join(this.scriptsDir, entry.name);
+        try {
+          const content = await fsp.readFile(fullpath, 'utf-8');
+          scripts.push({ filename: entry.name, content, fullpath });
+        } catch { /* skip unreadable files */ }
+      }
+    } catch { /* directory read failed */ }
+    return scripts;
+  }
+
+  /** Load tracker.json, add new scripts as disabled, prune deleted scripts */
+  async loadTracker(scripts: ScriptFile[]): Promise<ScriptTracker> {
+    let tracker: ScriptTracker;
+    try {
+      tracker = JSON.parse(await fsp.readFile(this.trackerPath, 'utf-8'));
+    } catch { tracker = {}; }
+
+    const filenames = new Set(scripts.map(s => s.filename));
+    let dirty = false;
+
+    // Add new scripts as disabled
+    for (const name of filenames) {
+      if (!(name in tracker)) { tracker[name] = false; dirty = true; }
+    }
+
+    // Prune deleted scripts
+    for (const name of Object.keys(tracker)) {
+      if (!filenames.has(name)) { delete tracker[name]; dirty = true; }
+    }
+
+    if (dirty) await this.saveTracker(tracker);
+    return tracker;
+  }
+
+  /** Write tracker.json */
+  async saveTracker(tracker: ScriptTracker): Promise<void> {
+    try {
+      await fsp.writeFile(this.trackerPath, JSON.stringify(tracker, null, 2), 'utf-8');
+    } catch { /* write failed */ }
+  }
+
+  /** Load per-script preferences from preferences/<name>.json */
+  async loadScriptPrefs(filename: string): Promise<Record<string, unknown>> {
+    const name = parse(filename).name;
+    const prefsPath = join(this.prefsDir, name + '.json');
+    try {
+      return JSON.parse(await fsp.readFile(prefsPath, 'utf-8'));
+    } catch { /* parse failed or file not found */ }
+    return {};
+  }
+
+  /** Save per-script preferences to preferences/<name>.json */
+  async saveScriptPrefs(filename: string, prefs: Record<string, unknown>): Promise<void> {
+    const name = parse(filename).name;
+    const prefsPath = join(this.prefsDir, name + '.json');
+    try {
+      await fsp.writeFile(prefsPath, JSON.stringify(prefs, null, 2), 'utf-8');
+    } catch { /* write failed */ }
+  }
+}