terminalos 0.4.0

package/electron/pty-manager.js

@@ -0,0 +1,188 @@
+"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.PtyManager = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const pty = __importStar(require("node-pty"));
+const uuid_1 = require("uuid");
+const process_detector_1 = require("./process-detector");
+function createZdotdir() {
+    const zdotdir = fs.mkdtempSync(path.join(os.tmpdir(), "aiterm-"));
+    const zprofile = [
+        "# aiTerm: source real .zprofile (restores full PATH in packaged app)",
+        '[ -f "$HOME/.zprofile" ] && source "$HOME/.zprofile"',
+    ].join("\n");
+    fs.writeFileSync(path.join(zdotdir, ".zprofile"), zprofile);
+    const zshrc = [
+        "# aiTerm: source real .zshrc first",
+        "unset ZDOTDIR",
+        '[ -f "$HOME/.zshrc" ] && source "$HOME/.zshrc"',
+        "",
+        "# Add our hook as the LAST precmd so it wins over oh-my-zsh/conda/starship",
+        "_aiterm_precmd() {",
+        '  printf "\\n"',
+        '  PROMPT=" "',
+        '  RPROMPT=""',
+        '  printf "\\033]9001;%s\\007" "${CONDA_DEFAULT_ENV:-}"',
+        "}",
+        "precmd_functions+=(_aiterm_precmd)",
+        "",
+        "# Bold the command line after Enter is pressed",
+        "_aiterm_preexec() {",
+        '  printf "\\x1b[1A\\x1b[2K \\x1b[1m%s\\x1b[22m\\r\\n" "$1"',
+        "}",
+        "preexec_functions+=(_aiterm_preexec)",
+        'PROMPT=" "',
+        'RPROMPT=""',
+    ].join("\n");
+    fs.writeFileSync(path.join(zdotdir, ".zshrc"), zshrc);
+    return zdotdir;
+}
+class PtyManager {
+    sessions = new Map();
+    win;
+    constructor(win) {
+        this.win = win;
+    }
+    create(opts) {
+        const sessionId = (0, uuid_1.v4)();
+        const shell = process.platform === "win32"
+            ? "cmd.exe"
+            : (process.env.SHELL ?? "/bin/bash");
+        const cwd = opts.cwd ?? process.env.HOME ?? "/";
+        const isZsh = shell.endsWith("zsh");
+        const promptEnv = isZsh
+            ? { ZDOTDIR: createZdotdir() }
+            : { PS1: " ", PROMPT: " " };
+        const ptyProcess = pty.spawn(shell, ["-l"], {
+            name: "xterm-256color",
+            cols: 80,
+            rows: 24,
+            cwd,
+            env: {
+                ...process.env,
+                TERM: "xterm-256color",
+                COLORTERM: "truecolor",
+                ...promptEnv,
+                ...opts.env,
+            },
+        });
+        const detector = new process_detector_1.ProcessDetector();
+        const session = {
+            id: sessionId,
+            pty: ptyProcess,
+            buffer: [],
+            flushTimer: null,
+            detector,
+            cwd,
+        };
+        // Buffer data and flush every 12ms (Batching inteligente para evitar IPC slicing)
+        ptyProcess.onData((data) => {
+            session.buffer.push(data);
+            if (!session.flushTimer) {
+                session.flushTimer = setTimeout(() => {
+                    if (session.buffer.length > 0) {
+                        const chunk = session.buffer.join("");
+                        session.buffer = [];
+                        session.flushTimer = null; // Libera o timer para a próxima rodada de dados
+                        if (!this.win.isDestroyed()) {
+                            this.win.webContents.send("pty:data", sessionId, chunk);
+                        }
+                        // Check for AI process signatures
+                        const result = detector.detect(chunk);
+                        if (result === "detected" && !this.win.isDestroyed()) {
+                            const ai = detector.getCurrentAI();
+                            if (ai) {
+                                this.win.webContents.send("pty:ai-detected", sessionId, ai);
+                            }
+                        }
+                        else if (result === "exited" && !this.win.isDestroyed()) {
+                            this.win.webContents.send("pty:ai-exited", sessionId);
+                        }
+                    }
+                }, 1);
+            }
+        });
+        ptyProcess.onExit(({ exitCode }) => {
+            if (session.flushTimer) {
+                clearTimeout(session.flushTimer); // Alterado de clearInterval
+            }
+            if (!this.win.isDestroyed()) {
+                this.win.webContents.send("pty:exit", sessionId, exitCode ?? 0);
+            }
+            this.sessions.delete(sessionId);
+        });
+        this.sessions.set(sessionId, session);
+        return sessionId;
+    }
+    write(sessionId, data) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.pty.write(data);
+        }
+    }
+    resizeTimers = new Map();
+    resize(sessionId, cols, rows) {
+        const existing = this.resizeTimers.get(sessionId);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            const session = this.sessions.get(sessionId);
+            if (session) {
+                session.pty.resize(cols, rows);
+            }
+            this.resizeTimers.delete(sessionId);
+        }, 50);
+        this.resizeTimers.set(sessionId, timer);
+    }
+    async kill(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            if (session.flushTimer) {
+                clearTimeout(session.flushTimer); // Alterado de clearInterval
+            }
+            session.pty.kill();
+            this.sessions.delete(sessionId);
+        }
+    }
+    killAll() {
+        for (const [id] of this.sessions) {
+            this.kill(id);
+        }
+    }
+}
+exports.PtyManager = PtyManager;

package/electron/pty-manager.ts

@@ -0,0 +1,181 @@
+import { BrowserWindow } from "electron";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import * as pty from "node-pty";
+import { v4 as uuidv4 } from "uuid";
+import { ProcessDetector } from "./process-detector";
+
+function createZdotdir(): string {
+  const zdotdir = fs.mkdtempSync(path.join(os.tmpdir(), "aiterm-"));
+  const zprofile = [
+    "# aiTerm: source real .zprofile (restores full PATH in packaged app)",
+    '[ -f "$HOME/.zprofile" ] && source "$HOME/.zprofile"',
+  ].join("\n");
+  fs.writeFileSync(path.join(zdotdir, ".zprofile"), zprofile);
+  const zshrc = [
+    "# aiTerm: source real .zshrc first",
+    "unset ZDOTDIR",
+    '[ -f "$HOME/.zshrc" ] && source "$HOME/.zshrc"',
+    "",
+    "# Add our hook as the LAST precmd so it wins over oh-my-zsh/conda/starship",
+    "_aiterm_precmd() {",
+    '  printf "\\n"',
+    '  PROMPT=" "',
+    '  RPROMPT=""',
+    '  printf "\\033]9001;%s\\007" "${CONDA_DEFAULT_ENV:-}"',
+    "}",
+    "precmd_functions+=(_aiterm_precmd)",
+    "",
+    "# Bold the command line after Enter is pressed",
+    "_aiterm_preexec() {",
+    '  printf "\\x1b[1A\\x1b[2K \\x1b[1m%s\\x1b[22m\\r\\n" "$1"',
+    "}",
+    "preexec_functions+=(_aiterm_preexec)",
+    'PROMPT=" "',
+    'RPROMPT=""',
+  ].join("\n");
+  fs.writeFileSync(path.join(zdotdir, ".zshrc"), zshrc);
+  return zdotdir;
+}
+
+interface Session {
+  id: string;
+  pty: pty.IPty;
+  buffer: string[];
+  flushTimer: ReturnType<typeof setTimeout> | null; // Alterado de setInterval para setTimeout
+  detector: ProcessDetector;
+  cwd: string;
+}
+
+export class PtyManager {
+  private sessions = new Map<string, Session>();
+  private win: BrowserWindow;
+
+  constructor(win: BrowserWindow) {
+    this.win = win;
+  }
+
+  create(opts: { cwd?: string; env?: Record<string, string> }): string {
+    const sessionId = uuidv4();
+    const shell =
+      process.platform === "win32"
+        ? "cmd.exe"
+        : (process.env.SHELL ?? "/bin/bash");
+
+    const cwd = opts.cwd ?? process.env.HOME ?? "/";
+
+    const isZsh = shell.endsWith("zsh");
+    const promptEnv = isZsh
+      ? { ZDOTDIR: createZdotdir() }
+      : { PS1: " ", PROMPT: " " };
+
+    const ptyProcess = pty.spawn(shell, ["-l"], {
+      name: "xterm-256color",
+      cols: 80,
+      rows: 24,
+      cwd,
+      env: {
+        ...process.env,
+        TERM: "xterm-256color",
+        COLORTERM: "truecolor",
+        ...promptEnv,
+        ...opts.env,
+      },
+    });
+
+    const detector = new ProcessDetector();
+    const session: Session = {
+      id: sessionId,
+      pty: ptyProcess,
+      buffer: [],
+      flushTimer: null,
+      detector,
+      cwd,
+    };
+
+    // Buffer data and flush every 12ms (Batching inteligente para evitar IPC slicing)
+    ptyProcess.onData((data) => {
+      session.buffer.push(data);
+
+      if (!session.flushTimer) {
+        session.flushTimer = setTimeout(() => {
+          if (session.buffer.length > 0) {
+            const chunk = session.buffer.join("");
+            session.buffer = [];
+            session.flushTimer = null; // Libera o timer para a próxima rodada de dados
+
+            if (!this.win.isDestroyed()) {
+              this.win.webContents.send("pty:data", sessionId, chunk);
+            }
+
+            // Check for AI process signatures
+            const result = detector.detect(chunk);
+            if (result === "detected" && !this.win.isDestroyed()) {
+              const ai = detector.getCurrentAI();
+              if (ai) {
+                this.win.webContents.send("pty:ai-detected", sessionId, ai);
+              }
+            } else if (result === "exited" && !this.win.isDestroyed()) {
+              this.win.webContents.send("pty:ai-exited", sessionId);
+            }
+          }
+        }, 1);
+      }
+    });
+
+    ptyProcess.onExit(({ exitCode }) => {
+      if (session.flushTimer) {
+        clearTimeout(session.flushTimer); // Alterado de clearInterval
+      }
+      if (!this.win.isDestroyed()) {
+        this.win.webContents.send("pty:exit", sessionId, exitCode ?? 0);
+      }
+      this.sessions.delete(sessionId);
+    });
+
+    this.sessions.set(sessionId, session);
+    return sessionId;
+  }
+
+  write(sessionId: string, data: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.pty.write(data);
+    }
+  }
+
+  private resizeTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+  resize(sessionId: string, cols: number, rows: number): void {
+    const existing = this.resizeTimers.get(sessionId);
+    if (existing) clearTimeout(existing);
+
+    const timer = setTimeout(() => {
+      const session = this.sessions.get(sessionId);
+      if (session) {
+        session.pty.resize(cols, rows);
+      }
+      this.resizeTimers.delete(sessionId);
+    }, 50);
+
+    this.resizeTimers.set(sessionId, timer);
+  }
+
+  async kill(sessionId: string): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      if (session.flushTimer) {
+        clearTimeout(session.flushTimer); // Alterado de clearInterval
+      }
+      session.pty.kill();
+      this.sessions.delete(sessionId);
+    }
+  }
+
+  killAll(): void {
+    for (const [id] of this.sessions) {
+      this.kill(id);
+    }
+  }
+}

package/electron/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": ".",
+    "rootDir": "."
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/electron/versions-manager.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionsManager = void 0;
+const electron_1 = require("electron");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const MAX_VERSIONS = 50;
+class VersionsManager {
+    getVersionsDir() {
+        return path_1.default.join(electron_1.app.getPath('userData'), 'md-versions');
+    }
+    getKey(filePath) {
+        return crypto_1.default.createHash('sha256').update(filePath).digest('hex');
+    }
+    async load(filePath) {
+        const dir = this.getVersionsDir();
+        const key = this.getKey(filePath);
+        const vFile = path_1.default.join(dir, `${key}.json`);
+        try {
+            const data = await promises_1.default.readFile(vFile, 'utf8');
+            const parsed = JSON.parse(data);
+            return parsed.versions ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    async persist(filePath, versions) {
+        const dir = this.getVersionsDir();
+        await promises_1.default.mkdir(dir, { recursive: true });
+        const key = this.getKey(filePath);
+        const vFile = path_1.default.join(dir, `${key}.json`);
+        const data = { filePath, versions };
+        await promises_1.default.writeFile(vFile, JSON.stringify(data), 'utf8');
+    }
+    async saveVersion(filePath, content) {
+        const versions = await this.load(filePath);
+        // Skip if content is identical to last version
+        if (versions.length > 0 && versions[versions.length - 1].content === content) {
+            return null;
+        }
+        const nextVersion = versions.length > 0 ? versions[versions.length - 1].version + 1 : 1;
+        const now = Date.now();
+        const newVersion = {
+            id: new Date(now).toISOString(),
+            version: nextVersion,
+            timestamp: now,
+            content,
+        };
+        versions.push(newVersion);
+        // Prune to MAX_VERSIONS (keep most recent)
+        const pruned = versions.length > MAX_VERSIONS
+            ? versions.slice(versions.length - MAX_VERSIONS)
+            : versions;
+        await this.persist(filePath, pruned);
+        return { id: newVersion.id, version: newVersion.version, timestamp: newVersion.timestamp };
+    }
+    async listVersions(filePath) {
+        const versions = await this.load(filePath);
+        return versions
+            .map(({ id, version, timestamp }) => ({ id, version, timestamp }))
+            .reverse(); // newest first
+    }
+    async getVersion(filePath, versionId) {
+        const versions = await this.load(filePath);
+        const found = versions.find(v => v.id === versionId);
+        return found?.content ?? null;
+    }
+}
+exports.VersionsManager = VersionsManager;

package/electron/versions-manager.ts

@@ -0,0 +1,98 @@
+import { app } from 'electron'
+import fs from 'fs/promises'
+import path from 'path'
+import crypto from 'crypto'
+
+const MAX_VERSIONS = 50
+
+export interface FileVersion {
+  id: string
+  version: number
+  timestamp: number
+  content: string
+}
+
+export interface VersionMeta {
+  id: string
+  version: number
+  timestamp: number
+}
+
+interface VersionsFile {
+  filePath: string
+  versions: FileVersion[]
+}
+
+export class VersionsManager {
+  private getVersionsDir(): string {
+    return path.join(app.getPath('userData'), 'md-versions')
+  }
+
+  private getKey(filePath: string): string {
+    return crypto.createHash('sha256').update(filePath).digest('hex')
+  }
+
+  private async load(filePath: string): Promise<FileVersion[]> {
+    const dir = this.getVersionsDir()
+    const key = this.getKey(filePath)
+    const vFile = path.join(dir, `${key}.json`)
+    try {
+      const data = await fs.readFile(vFile, 'utf8')
+      const parsed: VersionsFile = JSON.parse(data)
+      return parsed.versions ?? []
+    } catch {
+      return []
+    }
+  }
+
+  private async persist(filePath: string, versions: FileVersion[]): Promise<void> {
+    const dir = this.getVersionsDir()
+    await fs.mkdir(dir, { recursive: true })
+    const key = this.getKey(filePath)
+    const vFile = path.join(dir, `${key}.json`)
+    const data: VersionsFile = { filePath, versions }
+    await fs.writeFile(vFile, JSON.stringify(data), 'utf8')
+  }
+
+  async saveVersion(filePath: string, content: string): Promise<VersionMeta | null> {
+    const versions = await this.load(filePath)
+
+    // Skip if content is identical to last version
+    if (versions.length > 0 && versions[versions.length - 1].content === content) {
+      return null
+    }
+
+    const nextVersion = versions.length > 0 ? versions[versions.length - 1].version + 1 : 1
+    const now = Date.now()
+    const newVersion: FileVersion = {
+      id: new Date(now).toISOString(),
+      version: nextVersion,
+      timestamp: now,
+      content,
+    }
+
+    versions.push(newVersion)
+
+    // Prune to MAX_VERSIONS (keep most recent)
+    const pruned = versions.length > MAX_VERSIONS
+      ? versions.slice(versions.length - MAX_VERSIONS)
+      : versions
+
+    await this.persist(filePath, pruned)
+
+    return { id: newVersion.id, version: newVersion.version, timestamp: newVersion.timestamp }
+  }
+
+  async listVersions(filePath: string): Promise<VersionMeta[]> {
+    const versions = await this.load(filePath)
+    return versions
+      .map(({ id, version, timestamp }) => ({ id, version, timestamp }))
+      .reverse() // newest first
+  }
+
+  async getVersion(filePath: string, versionId: string): Promise<string | null> {
+    const versions = await this.load(filePath)
+    const found = versions.find(v => v.id === versionId)
+    return found?.content ?? null
+  }
+}

package/electron/window-state.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowState = void 0;
+const electron_1 = require("electron");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class WindowState {
+    filePath;
+    bounds = { width: 1280, height: 800 };
+    constructor() {
+        this.filePath = path_1.default.join(electron_1.app.getPath('userData'), 'window-state.json');
+        this.load();
+    }
+    load() {
+        try {
+            if (fs_1.default.existsSync(this.filePath)) {
+                const data = fs_1.default.readFileSync(this.filePath, 'utf8');
+                this.bounds = JSON.parse(data);
+            }
+        }
+        catch {
+            // Use defaults
+        }
+    }
+    get() {
+        return this.bounds;
+    }
+    save(win) {
+        if (!win.isMaximized() && !win.isMinimized()) {
+            const bounds = win.getBounds();
+            this.bounds = {
+                x: bounds.x,
+                y: bounds.y,
+                width: bounds.width,
+                height: bounds.height,
+            };
+            try {
+                fs_1.default.writeFileSync(this.filePath, JSON.stringify(this.bounds), 'utf8');
+            }
+            catch {
+                // Ignore write errors
+            }
+        }
+    }
+}
+exports.WindowState = WindowState;

package/electron/window-state.ts

@@ -0,0 +1,52 @@
+import { BrowserWindow, app } from 'electron'
+import fs from 'fs'
+import path from 'path'
+
+interface WindowBounds {
+  x?: number
+  y?: number
+  width: number
+  height: number
+}
+
+export class WindowState {
+  private filePath: string
+  private bounds: WindowBounds = { width: 1280, height: 800 }
+
+  constructor() {
+    this.filePath = path.join(app.getPath('userData'), 'window-state.json')
+    this.load()
+  }
+
+  private load(): void {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        const data = fs.readFileSync(this.filePath, 'utf8')
+        this.bounds = JSON.parse(data)
+      }
+    } catch {
+      // Use defaults
+    }
+  }
+
+  get(): WindowBounds {
+    return this.bounds
+  }
+
+  save(win: BrowserWindow): void {
+    if (!win.isMaximized() && !win.isMinimized()) {
+      const bounds = win.getBounds()
+      this.bounds = {
+        x: bounds.x,
+        y: bounds.y,
+        width: bounds.width,
+        height: bounds.height,
+      }
+      try {
+        fs.writeFileSync(this.filePath, JSON.stringify(this.bounds), 'utf8')
+      } catch {
+        // Ignore write errors
+      }
+    }
+  }
+}