npm - terminalos - Versions diffs - 0.4.0 - Mend

terminalos 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/README.md +324 -0
package/bin/cli.js +28 -0
package/build/assets/html2pdf-S6WA7sS3.js +240 -0
package/build/assets/index-CfXPiaFw.css +32 -0
package/build/assets/index-DfoqUTmD.js +141 -0
package/build/index.html +17 -0
package/electron/fs-watcher.js +181 -0
package/electron/fs-watcher.ts +183 -0
package/electron/main.js +245 -0
package/electron/main.ts +241 -0
package/electron/preload.js +77 -0
package/electron/preload.ts +105 -0
package/electron/process-detector.js +63 -0
package/electron/process-detector.ts +70 -0
package/electron/pty-manager.js +188 -0
package/electron/pty-manager.ts +181 -0
package/electron/tsconfig.json +14 -0
package/electron/versions-manager.js +74 -0
package/electron/versions-manager.ts +98 -0
package/electron/window-state.js +49 -0
package/electron/window-state.ts +52 -0
package/package.json +104 -0
package/runtime-dist/server.js +626 -0

package/build/index.html ADDED Viewed

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; font-src 'self' data:; img-src 'self' data: https: http: file:; frame-src localfile:; connect-src 'self' ws://localhost:*"
+    />
+    <title>terminalOS</title>
+    <script type="module" crossorigin src="./assets/index-DfoqUTmD.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-CfXPiaFw.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/electron/fs-watcher.js ADDED Viewed

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsWatcher = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+// Polyfill DOMMatrix for pdfjs-dist (pdf-parse dep) in Node.js/Electron main process
+if (typeof globalThis.DOMMatrix === 'undefined') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;
+    globalThis.DOMMatrix = class DOMMatrix {
+        a = 1;
+        b = 0;
+        c = 0;
+        d = 1;
+        e = 0;
+        f = 0;
+        m11 = 1;
+        m12 = 0;
+        m13 = 0;
+        m14 = 0;
+        m21 = 0;
+        m22 = 1;
+        m23 = 0;
+        m24 = 0;
+        m31 = 0;
+        m32 = 0;
+        m33 = 1;
+        m34 = 0;
+        m41 = 0;
+        m42 = 0;
+        m43 = 0;
+        m44 = 1;
+        is2D = true;
+        isIdentity = true;
+        constructor(_init) { }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        static fromFloat32Array() { return new globalThis.DOMMatrix(); }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        static fromFloat64Array() { return new globalThis.DOMMatrix(); }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        static fromMatrix() { return new globalThis.DOMMatrix(); }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        multiply() { return new globalThis.DOMMatrix(); }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        translate() { return new globalThis.DOMMatrix(); }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        scale() { return new globalThis.DOMMatrix(); }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        rotate() { return new globalThis.DOMMatrix(); }
+        toFloat32Array() { return new Float32Array(16); }
+        toFloat64Array() { return new Float64Array(16); }
+        toString() { return 'matrix(1, 0, 0, 1, 0, 0)'; }
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const pdfParse = require('pdf-parse');
+const mammoth_1 = __importDefault(require("mammoth"));
+async function getContentSize(entryPath, ext) {
+    try {
+        if (ext === 'pdf') {
+            const buffer = await promises_1.default.readFile(entryPath);
+            const result = await pdfParse(buffer);
+            return result.text.length;
+        }
+        if (ext === 'docx') {
+            const buffer = await promises_1.default.readFile(entryPath);
+            const result = await mammoth_1.default.extractRawText({ buffer });
+            return result.value.length;
+        }
+    }
+    catch {
+        // fallback: no contentSize, frontend will use size
+    }
+    return undefined;
+}
+class FsWatcher {
+    win;
+    watcher = null;
+    watchRoot = null;
+    constructor(win) {
+        this.win = win;
+    }
+    async readDir(dirPath) {
+        // Validate path to prevent traversal
+        const resolved = path_1.default.resolve(dirPath);
+        const entries = await promises_1.default.readdir(resolved, { withFileTypes: true });
+        const result = [];
+        await Promise.all(entries.map(async (entry) => {
+            const entryPath = path_1.default.join(resolved, entry.name);
+            const isDirectory = entry.isDirectory();
+            const ext = isDirectory ? '' : path_1.default.extname(entry.name).slice(1).toLowerCase();
+            const stat = isDirectory ? null : await promises_1.default.stat(entryPath).catch(() => null);
+            const contentSize = isDirectory ? undefined : await getContentSize(entryPath, ext);
+            result.push({
+                name: entry.name,
+                path: entryPath,
+                isDirectory,
+                ext,
+                size: stat?.size,
+                contentSize,
+            });
+        }));
+        // Sort: directories first, then files, both alphabetically
+        result.sort((a, b) => {
+            if (a.isDirectory && !b.isDirectory)
+                return -1;
+            if (!a.isDirectory && b.isDirectory)
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        return result;
+    }
+    async readFile(filePath) {
+        const resolved = path_1.default.resolve(filePath);
+        return promises_1.default.readFile(resolved, 'utf8');
+    }
+    async writeFile(filePath, content) {
+        const resolved = path_1.default.resolve(filePath);
+        await promises_1.default.writeFile(resolved, content, 'utf8');
+    }
+    async mkdir(dirPath) {
+        const resolved = path_1.default.resolve(dirPath);
+        await promises_1.default.mkdir(resolved, { recursive: true });
+    }
+    async rename(srcPath, destPath) {
+        const src = path_1.default.resolve(srcPath);
+        const dest = path_1.default.resolve(destPath);
+        await promises_1.default.rename(src, dest);
+    }
+    async copyExternal(srcPath, destDir) {
+        const src = path_1.default.resolve(srcPath);
+        const dest = path_1.default.join(path_1.default.resolve(destDir), path_1.default.basename(src));
+        await promises_1.default.cp(src, dest, { recursive: true });
+    }
+    async delete(targetPath) {
+        const resolved = path_1.default.resolve(targetPath);
+        await promises_1.default.rm(resolved, { recursive: true, force: true });
+    }
+    setWatchRoot(rootPath) {
+        const resolved = path_1.default.resolve(rootPath);
+        if (this.watchRoot === resolved)
+            return;
+        this.watcher?.close();
+        this.watchRoot = resolved;
+        this.watcher = chokidar_1.default.watch(resolved, {
+            ignoreInitial: true,
+            ignored: [
+                /(^|[\/\\])\../, // hidden files
+                /node_modules/,
+                /\.git/,
+                /dist/,
+                /build/,
+            ],
+            depth: 5,
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 100,
+            },
+        });
+        const emit = (type, filePath) => {
+            if (!this.win.isDestroyed()) {
+                this.win.webContents.send('fs:watch', { type, path: filePath });
+            }
+        };
+        this.watcher
+            .on('add', (p) => emit('add', p))
+            .on('addDir', (p) => emit('addDir', p))
+            .on('change', (p) => emit('change', p))
+            .on('unlink', (p) => emit('unlink', p))
+            .on('unlinkDir', (p) => emit('unlinkDir', p));
+    }
+    close() {
+        this.watcher?.close();
+        this.watcher = null;
+    }
+}
+exports.FsWatcher = FsWatcher;

package/electron/fs-watcher.ts ADDED Viewed

@@ -0,0 +1,183 @@
+import { BrowserWindow } from 'electron'
+import fs from 'fs/promises'
+import path from 'path'
+import chokidar, { FSWatcher } from 'chokidar'
+// Polyfill DOMMatrix for pdfjs-dist (pdf-parse dep) in Node.js/Electron main process
+if (typeof globalThis.DOMMatrix === 'undefined') {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ;(globalThis as any).DOMMatrix = class DOMMatrix {
+    a = 1; b = 0; c = 0; d = 1; e = 0; f = 0
+    m11 = 1; m12 = 0; m13 = 0; m14 = 0
+    m21 = 0; m22 = 1; m23 = 0; m24 = 0
+    m31 = 0; m32 = 0; m33 = 1; m34 = 0
+    m41 = 0; m42 = 0; m43 = 0; m44 = 1
+    is2D = true; isIdentity = true
+    constructor(_init?: number[] | string) {}
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromFloat32Array() { return new (globalThis as any).DOMMatrix() }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromFloat64Array() { return new (globalThis as any).DOMMatrix() }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromMatrix() { return new (globalThis as any).DOMMatrix() }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    multiply() { return new (globalThis as any).DOMMatrix() }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    translate() { return new (globalThis as any).DOMMatrix() }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    scale() { return new (globalThis as any).DOMMatrix() }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rotate() { return new (globalThis as any).DOMMatrix() }
+    toFloat32Array() { return new Float32Array(16) }
+    toFloat64Array() { return new Float64Array(16) }
+    toString() { return 'matrix(1, 0, 0, 1, 0, 0)' }
+  }
+}
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const pdfParse = require('pdf-parse') as (buf: Buffer) => Promise<{ text: string }>
+import mammoth from 'mammoth'
+interface FsEntry {
+  name: string
+  path: string
+  isDirectory: boolean
+  ext: string
+  size?: number
+  contentSize?: number
+}
+async function getContentSize(entryPath: string, ext: string): Promise<number | undefined> {
+  try {
+    if (ext === 'pdf') {
+      const buffer = await fs.readFile(entryPath)
+      const result = await pdfParse(buffer)
+      return result.text.length
+    }
+    if (ext === 'docx') {
+      const buffer = await fs.readFile(entryPath)
+      const result = await mammoth.extractRawText({ buffer })
+      return result.value.length
+    }
+  } catch {
+    // fallback: no contentSize, frontend will use size
+  }
+  return undefined
+}
+export class FsWatcher {
+  private win: BrowserWindow
+  private watcher: FSWatcher | null = null
+  private watchRoot: string | null = null
+  constructor(win: BrowserWindow) {
+    this.win = win
+  }
+  async readDir(dirPath: string): Promise<FsEntry[]> {
+    // Validate path to prevent traversal
+    const resolved = path.resolve(dirPath)
+    const entries = await fs.readdir(resolved, { withFileTypes: true })
+    const result: FsEntry[] = []
+    await Promise.all(entries.map(async (entry) => {
+      const entryPath = path.join(resolved, entry.name)
+      const isDirectory = entry.isDirectory()
+      const ext = isDirectory ? '' : path.extname(entry.name).slice(1).toLowerCase()
+      const stat = isDirectory ? null : await fs.stat(entryPath).catch(() => null)
+      const contentSize = isDirectory ? undefined : await getContentSize(entryPath, ext)
+      result.push({
+        name: entry.name,
+        path: entryPath,
+        isDirectory,
+        ext,
+        size: stat?.size,
+        contentSize,
+      })
+    }))
+    // Sort: directories first, then files, both alphabetically
+    result.sort((a, b) => {
+      if (a.isDirectory && !b.isDirectory) return -1
+      if (!a.isDirectory && b.isDirectory) return 1
+      return a.name.localeCompare(b.name)
+    })
+    return result
+  }
+  async readFile(filePath: string): Promise<string> {
+    const resolved = path.resolve(filePath)
+    return fs.readFile(resolved, 'utf8')
+  }
+  async writeFile(filePath: string, content: string): Promise<void> {
+    const resolved = path.resolve(filePath)
+    await fs.writeFile(resolved, content, 'utf8')
+  }
+  async mkdir(dirPath: string): Promise<void> {
+    const resolved = path.resolve(dirPath)
+    await fs.mkdir(resolved, { recursive: true })
+  }
+  async rename(srcPath: string, destPath: string): Promise<void> {
+    const src = path.resolve(srcPath)
+    const dest = path.resolve(destPath)
+    await fs.rename(src, dest)
+  }
+  async copyExternal(srcPath: string, destDir: string): Promise<void> {
+    const src = path.resolve(srcPath)
+    const dest = path.join(path.resolve(destDir), path.basename(src))
+    await fs.cp(src, dest, { recursive: true })
+  }
+  async delete(targetPath: string): Promise<void> {
+    const resolved = path.resolve(targetPath)
+    await fs.rm(resolved, { recursive: true, force: true })
+  }
+  setWatchRoot(rootPath: string): void {
+    const resolved = path.resolve(rootPath)
+    if (this.watchRoot === resolved) return
+    this.watcher?.close()
+    this.watchRoot = resolved
+    this.watcher = chokidar.watch(resolved, {
+      ignoreInitial: true,
+      ignored: [
+        /(^|[\/\\])\../,      // hidden files
+        /node_modules/,
+        /\.git/,
+        /dist/,
+        /build/,
+      ],
+      depth: 5,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 100,
+      },
+    })
+    const emit = (type: string, filePath: string) => {
+      if (!this.win.isDestroyed()) {
+        this.win.webContents.send('fs:watch', { type, path: filePath })
+      }
+    }
+    this.watcher
+      .on('add', (p) => emit('add', p))
+      .on('addDir', (p) => emit('addDir', p))
+      .on('change', (p) => emit('change', p))
+      .on('unlink', (p) => emit('unlink', p))
+      .on('unlinkDir', (p) => emit('unlinkDir', p))
+  }
+  close(): void {
+    this.watcher?.close()
+    this.watcher = null
+  }
+}

package/electron/main.js ADDED Viewed

@@ -0,0 +1,245 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const path_1 = __importDefault(require("path"));
+const window_state_1 = require("./window-state");
+const pty_manager_1 = require("./pty-manager");
+const fs_watcher_1 = require("./fs-watcher");
+const versions_manager_1 = require("./versions-manager");
+// Must be called before app.ready
+electron_1.protocol.registerSchemesAsPrivileged([
+    { scheme: 'localfile', privileges: { secure: true, supportFetchAPI: true, stream: true } },
+]);
+const isDev = process.env.NODE_ENV === 'development' || !electron_1.app.isPackaged;
+let mainWindow = null;
+let ptyManager;
+let fsWatcher;
+let versionsManager;
+function semverGt(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] ?? 0) > (pb[i] ?? 0))
+            return true;
+        if ((pa[i] ?? 0) < (pb[i] ?? 0))
+            return false;
+    }
+    return false;
+}
+function createWindow() {
+    electron_1.protocol.handle('localfile', (request) => {
+        const filePath = new URL(request.url).pathname;
+        return electron_1.net.fetch('file://' + filePath);
+    });
+    const windowState = new window_state_1.WindowState();
+    const bounds = windowState.get();
+    mainWindow = new electron_1.BrowserWindow({
+        x: bounds.x,
+        y: bounds.y,
+        width: bounds.width,
+        height: bounds.height,
+        minWidth: 640,
+        minHeight: 400,
+        frame: false,
+        titleBarStyle: 'hidden',
+        titleBarOverlay: false,
+        trafficLightPosition: { x: 12, y: 9 },
+        backgroundColor: '#090909',
+        show: false,
+        webPreferences: {
+            preload: path_1.default.join(__dirname, 'preload.js'),
+            contextIsolation: true,
+            nodeIntegration: false,
+            sandbox: false,
+            spellcheck: false,
+            backgroundThrottling: false,
+        },
+    });
+    ptyManager = new pty_manager_1.PtyManager(mainWindow);
+    fsWatcher = new fs_watcher_1.FsWatcher(mainWindow);
+    versionsManager = new versions_manager_1.VersionsManager();
+    if (isDev) {
+        mainWindow.loadURL('http://localhost:5173');
+        mainWindow.webContents.openDevTools();
+    }
+    else {
+        mainWindow.loadFile(path_1.default.join(__dirname, '../build/index.html'));
+    }
+    mainWindow.once('ready-to-show', () => {
+        mainWindow?.show();
+    });
+    mainWindow.on('resize', () => {
+        windowState.save(mainWindow);
+    });
+    mainWindow.on('move', () => {
+        windowState.save(mainWindow);
+    });
+    mainWindow.on('closed', () => {
+        mainWindow = null;
+    });
+    setupIpcHandlers();
+}
+function setupIpcHandlers() {
+    // PTY handlers
+    electron_1.ipcMain.handle('pty:create', async (_, opts) => {
+        return ptyManager.create(opts);
+    });
+    electron_1.ipcMain.on('pty:write', (_, sessionId, data) => {
+        ptyManager.write(sessionId, data);
+    });
+    electron_1.ipcMain.on('pty:resize', (_, sessionId, cols, rows) => {
+        ptyManager.resize(sessionId, cols, rows);
+    });
+    electron_1.ipcMain.handle('pty:kill', async (_, sessionId) => {
+        return ptyManager.kill(sessionId);
+    });
+    // FS handlers
+    electron_1.ipcMain.handle('fs:openFolder', async () => {
+        const result = await electron_1.dialog.showOpenDialog(mainWindow, {
+            properties: ['openDirectory'],
+        });
+        if (result.canceled || result.filePaths.length === 0)
+            return null;
+        return result.filePaths[0];
+    });
+    electron_1.ipcMain.handle('fs:readDir', async (_, dirPath) => {
+        return fsWatcher.readDir(dirPath);
+    });
+    electron_1.ipcMain.handle('fs:readFile', async (_, filePath) => {
+        return fsWatcher.readFile(filePath);
+    });
+    electron_1.ipcMain.handle('fs:writeFile', async (_, filePath, content) => {
+        return fsWatcher.writeFile(filePath, content);
+    });
+    electron_1.ipcMain.handle('fs:mkdir', async (_, dirPath) => {
+        return fsWatcher.mkdir(dirPath);
+    });
+    electron_1.ipcMain.handle('fs:rename', async (_, src, dest) => {
+        return fsWatcher.rename(src, dest);
+    });
+    electron_1.ipcMain.handle('fs:copyExternal', async (_, srcPath, destDir) => {
+        return fsWatcher.copyExternal(srcPath, destDir);
+    });
+    electron_1.ipcMain.handle('fs:delete', async (_, targetPath) => {
+        return fsWatcher.delete(targetPath);
+    });
+    electron_1.ipcMain.handle('fs:writeBinaryFile', async (_, filePath, data) => {
+        const { promises: fs } = await Promise.resolve().then(() => __importStar(require('fs')));
+        await fs.writeFile(filePath, Buffer.from(data));
+    });
+    electron_1.ipcMain.on('fs:setWatchRoot', (_, rootPath) => {
+        fsWatcher.setWatchRoot(rootPath);
+    });
+    // App handlers
+    electron_1.ipcMain.handle('app:getVersion', async () => {
+        return electron_1.app.getVersion();
+    });
+    electron_1.ipcMain.handle('app:getGitBranch', async (_, cwd) => {
+        const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        try {
+            const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd, encoding: 'utf8' }).trim();
+            return branch;
+        }
+        catch {
+            return null;
+        }
+    });
+    electron_1.ipcMain.handle('app:checkForUpdates', async () => {
+        try {
+            const res = await electron_1.net.fetch('https://api.github.com/repos/vbfs/terminalOS/releases/latest', {
+                headers: { 'User-Agent': 'aiTerm-updater' },
+            });
+            if (!res.ok)
+                return null;
+            const data = await res.json();
+            const latest = data.tag_name.replace(/^v/, '');
+            const current = electron_1.app.getVersion();
+            return semverGt(latest, current) ? { version: latest, url: data.html_url } : null;
+        }
+        catch {
+            return null;
+        }
+    });
+    // Window controls
+    electron_1.ipcMain.on('window:minimize', () => mainWindow?.minimize());
+    electron_1.ipcMain.on('window:maximize', () => {
+        if (mainWindow?.isMaximized()) {
+            mainWindow.unmaximize();
+        }
+        else {
+            mainWindow?.maximize();
+        }
+    });
+    electron_1.ipcMain.on('window:close', () => mainWindow?.close());
+    // Shell operations
+    electron_1.ipcMain.on('shell:openPath', (_, filePath) => {
+        electron_1.shell.showItemInFolder(filePath);
+    });
+    electron_1.ipcMain.on('shell:openInFinder', (_, folderPath) => {
+        electron_1.shell.openPath(folderPath);
+    });
+    electron_1.ipcMain.on('shell:openExternal', (_, url) => {
+        electron_1.shell.openExternal(url);
+    });
+    // Version history handlers
+    electron_1.ipcMain.handle('fs:versions:save', async (_, filePath, content) => {
+        return versionsManager.saveVersion(filePath, content);
+    });
+    electron_1.ipcMain.handle('fs:versions:list', async (_, filePath) => {
+        return versionsManager.listVersions(filePath);
+    });
+    electron_1.ipcMain.handle('fs:versions:get', async (_, filePath, versionId) => {
+        return versionsManager.getVersion(filePath, versionId);
+    });
+}
+electron_1.app.whenReady().then(createWindow);
+electron_1.app.on('before-quit', () => {
+    ptyManager?.killAll();
+    fsWatcher?.close();
+});
+electron_1.app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin') {
+        electron_1.app.quit();
+    }
+});
+electron_1.app.on('activate', () => {
+    if (electron_1.BrowserWindow.getAllWindows().length === 0) {
+        createWindow();
+    }
+});