terminalos 0.4.0

package/electron/main.ts

@@ -0,0 +1,241 @@
+import { app, BrowserWindow, ipcMain, dialog, shell, protocol, net } from 'electron'
+import path from 'path'
+import { WindowState } from './window-state'
+import { PtyManager } from './pty-manager'
+import { FsWatcher } from './fs-watcher'
+import { VersionsManager } from './versions-manager'
+
+// Must be called before app.ready
+protocol.registerSchemesAsPrivileged([
+  { scheme: 'localfile', privileges: { secure: true, supportFetchAPI: true, stream: true } },
+])
+
+const isDev = process.env.NODE_ENV === 'development' || !app.isPackaged
+
+let mainWindow: BrowserWindow | null = null
+let ptyManager: PtyManager
+let fsWatcher: FsWatcher
+let versionsManager: VersionsManager
+
+function semverGt(a: string, b: string): boolean {
+  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() {
+  protocol.handle('localfile', (request) => {
+    const filePath = new URL(request.url).pathname
+    return net.fetch('file://' + filePath)
+  })
+
+  const windowState = new WindowState()
+  const bounds = windowState.get()
+
+  mainWindow = new 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.join(__dirname, 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false,
+      spellcheck: false,
+      backgroundThrottling: false,
+    },
+  })
+
+  ptyManager = new PtyManager(mainWindow)
+  fsWatcher = new FsWatcher(mainWindow)
+  versionsManager = new VersionsManager()
+
+  if (isDev) {
+    mainWindow.loadURL('http://localhost:5173')
+    mainWindow.webContents.openDevTools()
+  } else {
+    mainWindow.loadFile(path.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
+  ipcMain.handle('pty:create', async (_, opts: { cwd?: string; env?: Record<string, string> }) => {
+    return ptyManager.create(opts)
+  })
+
+  ipcMain.on('pty:write', (_, sessionId: string, data: string) => {
+    ptyManager.write(sessionId, data)
+  })
+
+  ipcMain.on('pty:resize', (_, sessionId: string, cols: number, rows: number) => {
+    ptyManager.resize(sessionId, cols, rows)
+  })
+
+  ipcMain.handle('pty:kill', async (_, sessionId: string) => {
+    return ptyManager.kill(sessionId)
+  })
+
+  // FS handlers
+  ipcMain.handle('fs:openFolder', async () => {
+    const result = await dialog.showOpenDialog(mainWindow!, {
+      properties: ['openDirectory'],
+    })
+    if (result.canceled || result.filePaths.length === 0) return null
+    return result.filePaths[0]
+  })
+
+  ipcMain.handle('fs:readDir', async (_, dirPath: string) => {
+    return fsWatcher.readDir(dirPath)
+  })
+
+  ipcMain.handle('fs:readFile', async (_, filePath: string) => {
+    return fsWatcher.readFile(filePath)
+  })
+
+  ipcMain.handle('fs:writeFile', async (_, filePath: string, content: string) => {
+    return fsWatcher.writeFile(filePath, content)
+  })
+
+  ipcMain.handle('fs:mkdir', async (_, dirPath: string) => {
+    return fsWatcher.mkdir(dirPath)
+  })
+
+  ipcMain.handle('fs:rename', async (_, src: string, dest: string) => {
+    return fsWatcher.rename(src, dest)
+  })
+
+  ipcMain.handle('fs:copyExternal', async (_, srcPath: string, destDir: string) => {
+    return fsWatcher.copyExternal(srcPath, destDir)
+  })
+
+  ipcMain.handle('fs:delete', async (_, targetPath: string) => {
+    return fsWatcher.delete(targetPath)
+  })
+
+  ipcMain.handle('fs:writeBinaryFile', async (_, filePath: string, data: ArrayBuffer) => {
+    const { promises: fs } = await import('fs')
+    await fs.writeFile(filePath, Buffer.from(data))
+  })
+
+  ipcMain.on('fs:setWatchRoot', (_, rootPath: string) => {
+    fsWatcher.setWatchRoot(rootPath)
+  })
+
+  // App handlers
+  ipcMain.handle('app:getVersion', async () => {
+    return app.getVersion()
+  })
+
+  ipcMain.handle('app:getGitBranch', async (_, cwd: string) => {
+    const { execSync } = await import('child_process')
+    try {
+      const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd, encoding: 'utf8' }).trim()
+      return branch
+    } catch {
+      return null
+    }
+  })
+
+  ipcMain.handle('app:checkForUpdates', async () => {
+    try {
+      const res = await 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() as { tag_name: string; html_url: string }
+      const latest = data.tag_name.replace(/^v/, '')
+      const current = app.getVersion()
+      return semverGt(latest, current) ? { version: latest, url: data.html_url } : null
+    } catch {
+      return null
+    }
+  })
+
+  // Window controls
+  ipcMain.on('window:minimize', () => mainWindow?.minimize())
+  ipcMain.on('window:maximize', () => {
+    if (mainWindow?.isMaximized()) {
+      mainWindow.unmaximize()
+    } else {
+      mainWindow?.maximize()
+    }
+  })
+  ipcMain.on('window:close', () => mainWindow?.close())
+
+  // Shell operations
+  ipcMain.on('shell:openPath', (_, filePath: string) => {
+    shell.showItemInFolder(filePath)
+  })
+
+  ipcMain.on('shell:openInFinder', (_, folderPath: string) => {
+    shell.openPath(folderPath)
+  })
+
+  ipcMain.on('shell:openExternal', (_, url: string) => {
+    shell.openExternal(url)
+  })
+
+  // Version history handlers
+  ipcMain.handle('fs:versions:save', async (_, filePath: string, content: string) => {
+    return versionsManager.saveVersion(filePath, content)
+  })
+
+  ipcMain.handle('fs:versions:list', async (_, filePath: string) => {
+    return versionsManager.listVersions(filePath)
+  })
+
+  ipcMain.handle('fs:versions:get', async (_, filePath: string, versionId: string) => {
+    return versionsManager.getVersion(filePath, versionId)
+  })
+}
+
+app.whenReady().then(createWindow)
+
+app.on('before-quit', () => {
+  ptyManager?.killAll()
+  fsWatcher?.close()
+})
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit()
+  }
+})
+
+app.on('activate', () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    createWindow()
+  }
+})

package/electron/preload.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const api = {
+    pty: {
+        create: (opts) => electron_1.ipcRenderer.invoke('pty:create', opts),
+        write: (sessionId, data) => electron_1.ipcRenderer.send('pty:write', sessionId, data),
+        resize: (sessionId, cols, rows) => electron_1.ipcRenderer.send('pty:resize', sessionId, cols, rows),
+        kill: (sessionId) => electron_1.ipcRenderer.invoke('pty:kill', sessionId),
+        onData: (cb) => {
+            const handler = (_, sessionId, data) => cb(sessionId, data);
+            electron_1.ipcRenderer.on('pty:data', handler);
+            return () => electron_1.ipcRenderer.removeListener('pty:data', handler);
+        },
+        onExit: (cb) => {
+            const handler = (_, sessionId, code) => cb(sessionId, code);
+            electron_1.ipcRenderer.on('pty:exit', handler);
+            return () => electron_1.ipcRenderer.removeListener('pty:exit', handler);
+        },
+        onAiDetected: (cb) => {
+            const handler = (_, sessionId, aiProcess) => cb(sessionId, aiProcess);
+            electron_1.ipcRenderer.on('pty:ai-detected', handler);
+            return () => electron_1.ipcRenderer.removeListener('pty:ai-detected', handler);
+        },
+        onAiExited: (cb) => {
+            const handler = (_, sessionId) => cb(sessionId);
+            electron_1.ipcRenderer.on('pty:ai-exited', handler);
+            return () => electron_1.ipcRenderer.removeListener('pty:ai-exited', handler);
+        },
+    },
+    fs: {
+        openFolder: () => electron_1.ipcRenderer.invoke('fs:openFolder'),
+        readDir: (dirPath) => electron_1.ipcRenderer.invoke('fs:readDir', dirPath),
+        readFile: (filePath) => electron_1.ipcRenderer.invoke('fs:readFile', filePath),
+        writeFile: (filePath, content) => electron_1.ipcRenderer.invoke('fs:writeFile', filePath, content),
+        writeBinaryFile: (filePath, data) => electron_1.ipcRenderer.invoke('fs:writeBinaryFile', filePath, data),
+        mkdir: (dirPath) => electron_1.ipcRenderer.invoke('fs:mkdir', dirPath),
+        rename: (src, dest) => electron_1.ipcRenderer.invoke('fs:rename', src, dest),
+        copyExternal: (srcPath, destDir) => electron_1.ipcRenderer.invoke('fs:copyExternal', srcPath, destDir),
+        delete: (targetPath) => electron_1.ipcRenderer.invoke('fs:delete', targetPath),
+        setWatchRoot: (rootPath) => electron_1.ipcRenderer.send('fs:setWatchRoot', rootPath),
+        onWatch: (cb) => {
+            const handler = (_, event) => cb(event);
+            electron_1.ipcRenderer.on('fs:watch', handler);
+            return () => electron_1.ipcRenderer.removeListener('fs:watch', handler);
+        },
+        versions: {
+            save: (filePath, content) => electron_1.ipcRenderer.invoke('fs:versions:save', filePath, content),
+            list: (filePath) => electron_1.ipcRenderer.invoke('fs:versions:list', filePath),
+            get: (filePath, versionId) => electron_1.ipcRenderer.invoke('fs:versions:get', filePath, versionId),
+        },
+    },
+    app: {
+        getVersion: () => electron_1.ipcRenderer.invoke('app:getVersion'),
+        getGitBranch: (cwd) => electron_1.ipcRenderer.invoke('app:getGitBranch', cwd),
+        checkForUpdates: () => electron_1.ipcRenderer.invoke('app:checkForUpdates'),
+        onFocus: (cb) => {
+            electron_1.ipcRenderer.on('app:focus', cb);
+            return () => electron_1.ipcRenderer.removeListener('app:focus', cb);
+        },
+        onBlur: (cb) => {
+            electron_1.ipcRenderer.on('app:blur', cb);
+            return () => electron_1.ipcRenderer.removeListener('app:blur', cb);
+        },
+    },
+    window: {
+        minimize: () => electron_1.ipcRenderer.send('window:minimize'),
+        maximize: () => electron_1.ipcRenderer.send('window:maximize'),
+        close: () => electron_1.ipcRenderer.send('window:close'),
+    },
+    shell: {
+        openPath: (filePath) => electron_1.ipcRenderer.send('shell:openPath', filePath),
+        openInFinder: (folderPath) => electron_1.ipcRenderer.send('shell:openInFinder', folderPath),
+        openExternal: (url) => electron_1.ipcRenderer.send('shell:openExternal', url),
+    },
+};
+electron_1.contextBridge.exposeInMainWorld('api', api);

package/electron/preload.ts

@@ -0,0 +1,105 @@
+import { contextBridge, ipcRenderer } from 'electron'
+
+type Unsubscribe = () => void
+
+const api = {
+  pty: {
+    create: (opts: { cwd?: string; env?: Record<string, string> }): Promise<string> =>
+      ipcRenderer.invoke('pty:create', opts),
+    write: (sessionId: string, data: string): void =>
+      ipcRenderer.send('pty:write', sessionId, data),
+    resize: (sessionId: string, cols: number, rows: number): void =>
+      ipcRenderer.send('pty:resize', sessionId, cols, rows),
+    kill: (sessionId: string): Promise<void> =>
+      ipcRenderer.invoke('pty:kill', sessionId),
+    onData: (cb: (sessionId: string, data: string) => void): Unsubscribe => {
+      const handler = (_: Electron.IpcRendererEvent, sessionId: string, data: string) =>
+        cb(sessionId, data)
+      ipcRenderer.on('pty:data', handler)
+      return () => ipcRenderer.removeListener('pty:data', handler)
+    },
+    onExit: (cb: (sessionId: string, code: number) => void): Unsubscribe => {
+      const handler = (_: Electron.IpcRendererEvent, sessionId: string, code: number) =>
+        cb(sessionId, code)
+      ipcRenderer.on('pty:exit', handler)
+      return () => ipcRenderer.removeListener('pty:exit', handler)
+    },
+    onAiDetected: (cb: (sessionId: string, aiProcess: { name: string; color: string }) => void): Unsubscribe => {
+      const handler = (_: Electron.IpcRendererEvent, sessionId: string, aiProcess: { name: string; color: string }) =>
+        cb(sessionId, aiProcess)
+      ipcRenderer.on('pty:ai-detected', handler)
+      return () => ipcRenderer.removeListener('pty:ai-detected', handler)
+    },
+    onAiExited: (cb: (sessionId: string) => void): Unsubscribe => {
+      const handler = (_: Electron.IpcRendererEvent, sessionId: string) => cb(sessionId)
+      ipcRenderer.on('pty:ai-exited', handler)
+      return () => ipcRenderer.removeListener('pty:ai-exited', handler)
+    },
+  },
+  fs: {
+    openFolder: (): Promise<string | null> =>
+      ipcRenderer.invoke('fs:openFolder'),
+    readDir: (dirPath: string): Promise<Array<{ name: string; path: string; isDirectory: boolean; ext: string; size?: number }>> =>
+      ipcRenderer.invoke('fs:readDir', dirPath),
+    readFile: (filePath: string): Promise<string> =>
+      ipcRenderer.invoke('fs:readFile', filePath),
+    writeFile: (filePath: string, content: string): Promise<void> =>
+      ipcRenderer.invoke('fs:writeFile', filePath, content),
+    writeBinaryFile: (filePath: string, data: ArrayBuffer): Promise<void> =>
+      ipcRenderer.invoke('fs:writeBinaryFile', filePath, data),
+    mkdir: (dirPath: string): Promise<void> =>
+      ipcRenderer.invoke('fs:mkdir', dirPath),
+    rename: (src: string, dest: string): Promise<void> =>
+      ipcRenderer.invoke('fs:rename', src, dest),
+    copyExternal: (srcPath: string, destDir: string): Promise<void> =>
+      ipcRenderer.invoke('fs:copyExternal', srcPath, destDir),
+    delete: (targetPath: string): Promise<void> =>
+      ipcRenderer.invoke('fs:delete', targetPath),
+    setWatchRoot: (rootPath: string): void =>
+      ipcRenderer.send('fs:setWatchRoot', rootPath),
+    onWatch: (cb: (event: { type: string; path: string }) => void): Unsubscribe => {
+      const handler = (_: Electron.IpcRendererEvent, event: { type: string; path: string }) =>
+        cb(event)
+      ipcRenderer.on('fs:watch', handler)
+      return () => ipcRenderer.removeListener('fs:watch', handler)
+    },
+    versions: {
+      save: (filePath: string, content: string) =>
+        ipcRenderer.invoke('fs:versions:save', filePath, content),
+      list: (filePath: string) =>
+        ipcRenderer.invoke('fs:versions:list', filePath),
+      get: (filePath: string, versionId: string) =>
+        ipcRenderer.invoke('fs:versions:get', filePath, versionId),
+    },
+  },
+  app: {
+    getVersion: (): Promise<string> =>
+      ipcRenderer.invoke('app:getVersion'),
+    getGitBranch: (cwd: string): Promise<string | null> =>
+      ipcRenderer.invoke('app:getGitBranch', cwd),
+    checkForUpdates: (): Promise<{ version: string; url: string } | null> =>
+      ipcRenderer.invoke('app:checkForUpdates'),
+    onFocus: (cb: () => void): Unsubscribe => {
+      ipcRenderer.on('app:focus', cb)
+      return () => ipcRenderer.removeListener('app:focus', cb)
+    },
+    onBlur: (cb: () => void): Unsubscribe => {
+      ipcRenderer.on('app:blur', cb)
+      return () => ipcRenderer.removeListener('app:blur', cb)
+    },
+  },
+  window: {
+    minimize: (): void => ipcRenderer.send('window:minimize'),
+    maximize: (): void => ipcRenderer.send('window:maximize'),
+    close: (): void => ipcRenderer.send('window:close'),
+  },
+  shell: {
+    openPath: (filePath: string): void => ipcRenderer.send('shell:openPath', filePath),
+    openInFinder: (folderPath: string): void => ipcRenderer.send('shell:openInFinder', folderPath),
+    openExternal: (url: string): void => ipcRenderer.send('shell:openExternal', url),
+  },
+}
+
+contextBridge.exposeInMainWorld('api', api)
+
+export type ApiType = typeof api

package/electron/process-detector.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessDetector = void 0;
+const AI_SIGNATURES = [
+    { pattern: /claude\s+code/i, name: 'claude code', color: '#D4A27F' },
+    { pattern: /opencode/i, name: 'opencode', color: '#7FB5D4' },
+    { pattern: /aider/i, name: 'aider', color: '#A27FD4' },
+    { pattern: /continue/i, name: 'continue', color: '#7FD4A2' },
+    { pattern: /\$\s*claude\b/, name: 'claude code', color: '#D4A27F' },
+];
+// Strip ANSI escape sequences before testing for shell prompt
+const ANSI_RE = /\x1b\[[0-9;]*[mGKHFABCDJsu]|\x1b\][^\x07]*\x07|\x1b[()][AB012]/g;
+// Prompt character must be at the start of a line (with only optional surrounding whitespace).
+// This prevents false positives from `>` in code examples, `$` in cost strings, etc.
+const SHELL_PROMPT_PATTERN = /(?:^|\n)\s{0,6}[$%❯>]\s{0,2}$/;
+class ProcessDetector {
+    slidingWindow = '';
+    windowSize = 2048;
+    currentAI = null;
+    hasAI = false;
+    detectedAt = 0;
+    // Grace period after detection before checking for exit. Prevents AI TUI input
+    // prompts (e.g. opencode's "> " or "❯ ") from being misread as shell prompts.
+    gracePeriodMs = 3000;
+    detect(data) {
+        this.slidingWindow = (this.slidingWindow + data).slice(-this.windowSize);
+        if (!this.hasAI) {
+            for (const sig of AI_SIGNATURES) {
+                if (sig.pattern.test(this.slidingWindow)) {
+                    this.currentAI = { name: sig.name, color: sig.color };
+                    this.hasAI = true;
+                    this.detectedAt = Date.now();
+                    return 'detected';
+                }
+            }
+        }
+        else {
+            // Don't check for exit too soon after detection — AI TUI apps render their
+            // own input prompts ("> ", "❯ ") immediately on startup, which would otherwise
+            // trigger a false exit and cause a re-detect → token reset cycle.
+            if (Date.now() - this.detectedAt < this.gracePeriodMs)
+                return null;
+            // Check if returned to shell prompt — strip ANSI first to avoid false matches
+            const plain = this.slidingWindow.replace(ANSI_RE, '');
+            const lastLines = plain.split('\n').slice(-3).join('\n');
+            if (SHELL_PROMPT_PATTERN.test(lastLines)) {
+                this.currentAI = null;
+                this.hasAI = false;
+                return 'exited';
+            }
+        }
+        return null;
+    }
+    getCurrentAI() {
+        return this.currentAI;
+    }
+    reset() {
+        this.slidingWindow = '';
+        this.currentAI = null;
+        this.hasAI = false;
+    }
+}
+exports.ProcessDetector = ProcessDetector;

package/electron/process-detector.ts

@@ -0,0 +1,70 @@
+interface AIProcess {
+  name: string
+  color: string
+}
+
+const AI_SIGNATURES: Array<{ pattern: RegExp; name: string; color: string }> = [
+  { pattern: /claude\s+code/i,   name: 'claude code',  color: '#D4A27F' },
+  { pattern: /opencode/i,        name: 'opencode',     color: '#7FB5D4' },
+  { pattern: /aider/i,           name: 'aider',        color: '#A27FD4' },
+  { pattern: /continue/i,        name: 'continue',     color: '#7FD4A2' },
+  { pattern: /\$\s*claude\b/,    name: 'claude code',  color: '#D4A27F' },
+]
+
+// Strip ANSI escape sequences before testing for shell prompt
+const ANSI_RE = /\x1b\[[0-9;]*[mGKHFABCDJsu]|\x1b\][^\x07]*\x07|\x1b[()][AB012]/g
+
+// Prompt character must be at the start of a line (with only optional surrounding whitespace).
+// This prevents false positives from `>` in code examples, `$` in cost strings, etc.
+const SHELL_PROMPT_PATTERN = /(?:^|\n)\s{0,6}[$%❯>]\s{0,2}$/
+
+export class ProcessDetector {
+  private slidingWindow = ''
+  private readonly windowSize = 2048
+  private currentAI: AIProcess | null = null
+  private hasAI = false
+  private detectedAt: number = 0
+  // Grace period after detection before checking for exit. Prevents AI TUI input
+  // prompts (e.g. opencode's "> " or "❯ ") from being misread as shell prompts.
+  private readonly gracePeriodMs = 3000
+
+  detect(data: string): 'detected' | 'exited' | null {
+    this.slidingWindow = (this.slidingWindow + data).slice(-this.windowSize)
+
+    if (!this.hasAI) {
+      for (const sig of AI_SIGNATURES) {
+        if (sig.pattern.test(this.slidingWindow)) {
+          this.currentAI = { name: sig.name, color: sig.color }
+          this.hasAI = true
+          this.detectedAt = Date.now()
+          return 'detected'
+        }
+      }
+    } else {
+      // Don't check for exit too soon after detection — AI TUI apps render their
+      // own input prompts ("> ", "❯ ") immediately on startup, which would otherwise
+      // trigger a false exit and cause a re-detect → token reset cycle.
+      if (Date.now() - this.detectedAt < this.gracePeriodMs) return null
+      // Check if returned to shell prompt — strip ANSI first to avoid false matches
+      const plain = this.slidingWindow.replace(ANSI_RE, '')
+      const lastLines = plain.split('\n').slice(-3).join('\n')
+      if (SHELL_PROMPT_PATTERN.test(lastLines)) {
+        this.currentAI = null
+        this.hasAI = false
+        return 'exited'
+      }
+    }
+
+    return null
+  }
+
+  getCurrentAI(): AIProcess | null {
+    return this.currentAI
+  }
+
+  reset(): void {
+    this.slidingWindow = ''
+    this.currentAI = null
+    this.hasAI = false
+  }
+}