loadtoagent 1.1.0 → 1.3.1

package/src/terminalManager.js

@@ -11,6 +11,9 @@ const { runBestEffort } = require('./diagnostics');
 const MAX_SESSIONS = 24;
 const MAX_INPUT_CHARS = 128 * 1024;
 const MAX_REPLAY_CHARS = 2 * 1024 * 1024;
+const MAX_STORE_BYTES = 64 * 1024 * 1024;
+const STORE_VERSION = 1;
+const PERSIST_DELAY_MS = 150;
 const TERMINAL_TYPES = new Set(['powershell', 'cmd', 'shell', 'wsl', 'tmux', 'agent']);
 const AGENT_PROVIDERS = Object.freeze({
   claude: { command: 'claude', label: 'Claude' },
@@ -218,6 +221,46 @@ function publicSession(session, includeReplay = false) {
   return value;
 }
 
+function validTimestamp(value, fallback) {
+  const text = cleanText(value, 50);
+  return text && Number.isFinite(Date.parse(text)) ? new Date(text).toISOString() : fallback;
+}
+
+function restoredOptions(value = {}, platform = process.platform) {
+  const fallbackType = platform === 'win32' ? 'powershell' : 'shell';
+  const type = TERMINAL_TYPES.has(value.type) ? value.type : fallbackType;
+  const provider = cleanText(value.provider, 30).toLowerCase();
+  if (type === 'agent' && !AGENT_PROVIDERS[provider]) return null;
+  return {
+    type,
+    cwd: cleanText(value.cwd, 2_000) || os.homedir(),
+    distro: cleanText(value.distro, 100),
+    tmuxSession: cleanText(value.tmuxSession, 100),
+    tmuxPane: cleanText(value.tmuxPane, 100),
+    provider,
+    args: Array.isArray(value.args) ? value.args.slice(0, 80).map(item => cleanText(item, 2_000)) : [],
+    bridgeId: cleanText(value.bridgeId, 100),
+    title: cleanText(value.title, 100),
+    cols: numericDimension(value.cols, 120, 20, 500),
+    rows: numericDimension(value.rows, 32, 5, 200),
+  };
+}
+
+function persistedSession(session) {
+  return {
+    id: session.id,
+    options: { ...session.options, cols: session.cols, rows: session.rows },
+    title: session.title,
+    shell: session.shell,
+    status: session.status,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    exitCode: session.exitCode,
+    signal: session.signal,
+    replay: session.replay,
+  };
+}
+
 class TerminalManager extends EventEmitter {
   constructor(options = {}) {
     super();
@@ -225,7 +268,89 @@ class TerminalManager extends EventEmitter {
     this.killTree = options.killTree || killPtyTree;
     this.platform = options.platform || process.platform;
     this.agentProviders = options.agentProviders || AGENT_PROVIDERS;
+    this.fileSystem = options.fileSystem || fs;
+    this.storeFile = typeof options.storeFile === 'string' && options.storeFile.trim()
+      ? path.resolve(options.storeFile)
+      : '';
+    this.onPersistenceError = typeof options.onPersistenceError === 'function'
+      ? options.onPersistenceError
+      : () => {};
+    this.persistTimer = null;
     this.sessions = new Map();
+    this.loadPersistedSessions();
+  }
+
+  persistenceError(operation, error) {
+    runBestEffort(`terminal-persistence:${operation}`, () => this.onPersistenceError(operation, error));
+  }
+
+  loadPersistedSessions() {
+    if (!this.storeFile) return;
+    try {
+      const stat = this.fileSystem.statSync(this.storeFile);
+      if (!stat.isFile() || stat.size > MAX_STORE_BYTES) throw new Error('터미널 기록 파일의 크기가 허용 범위를 초과했습니다.');
+      const parsed = JSON.parse(this.fileSystem.readFileSync(this.storeFile, 'utf8'));
+      if (parsed?.version !== STORE_VERSION || !Array.isArray(parsed.sessions)) throw new Error('지원하지 않는 터미널 기록 형식입니다.');
+      for (const value of parsed.sessions.slice(0, MAX_SESSIONS)) {
+        const id = cleanText(value?.id, 200);
+        const options = restoredOptions(value?.options, this.platform);
+        if (!id || !options || this.sessions.has(id)) continue;
+        const now = new Date().toISOString();
+        const createdAt = validTimestamp(value.createdAt, now);
+        const updatedAt = validTimestamp(value.updatedAt, createdAt);
+        const status = value.status === 'failed' ? 'failed' : 'exited';
+        this.sessions.set(id, {
+          id,
+          options,
+          spec: null,
+          title: cleanText(value.title, 100) || options.title || options.tmuxSession || options.provider || options.type,
+          shell: cleanText(value.shell, 2_000),
+          pid: null,
+          status,
+          createdAt,
+          updatedAt,
+          exitCode: Number.isFinite(value.exitCode) ? value.exitCode : null,
+          signal: Number.isFinite(value.signal) ? value.signal : null,
+          cols: options.cols,
+          rows: options.rows,
+          replay: String(value.replay || '').slice(-MAX_REPLAY_CHARS),
+          process: null,
+          generation: 0,
+        });
+      }
+    } catch (error) {
+      if (error?.code !== 'ENOENT') this.persistenceError('load', error);
+    }
+  }
+
+  schedulePersist() {
+    if (!this.storeFile || this.persistTimer) return;
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      this.persistNow();
+    }, PERSIST_DELAY_MS);
+    if (typeof this.persistTimer.unref === 'function') this.persistTimer.unref();
+  }
+
+  persistNow() {
+    if (!this.storeFile) return;
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+    const temporary = `${this.storeFile}.${process.pid}.tmp`;
+    try {
+      this.fileSystem.mkdirSync(path.dirname(this.storeFile), { recursive: true });
+      const payload = {
+        version: STORE_VERSION,
+        sessions: [...this.sessions.values()].map(persistedSession),
+      };
+      this.fileSystem.writeFileSync(temporary, JSON.stringify(payload), 'utf8');
+      this.fileSystem.renameSync(temporary, this.storeFile);
+    } catch (error) {
+      runBestEffort('terminal-persistence-temp-cleanup', () => this.fileSystem.unlinkSync(temporary));
+      this.persistenceError('save', error);
+    }
   }
 
   pty() {
@@ -261,14 +386,22 @@ class TerminalManager extends EventEmitter {
     try {
       this.spawn(session);
     } catch (error) {
-      this.sessions.delete(id);
-      this.emit('state', { change: 'removed', session: publicSession(session, false), sessions: this.list() });
+      // Keep failed launches visible until the user explicitly closes them.
+      // The failed session contains the startup error in replay and can be
+      // inspected, restarted, or removed from the session terminal.
+      this.persistNow();
       throw error;
     }
+    this.persistNow();
     return publicSession(session, true);
   }
 
   spawn(session) {
+    if (!session.spec) {
+      session.options = normalizeLaunchOptions(session.options, this.platform);
+      session.spec = launchSpec(session.options, this.platform, this.agentProviders);
+      session.shell = session.spec.file;
+    }
     const generation = ++session.generation;
     session.status = 'starting';
     session.exitCode = null;
@@ -296,6 +429,7 @@ class TerminalManager extends EventEmitter {
         session.replay = `${session.replay}${text}`.slice(-MAX_REPLAY_CHARS);
         session.updatedAt = new Date().toISOString();
         this.emit('data', { id: session.id, data: text });
+        this.schedulePersist();
       });
       processHandle.onExit(event => {
         processHandle.__loadtoagentExited = true;
@@ -322,6 +456,7 @@ class TerminalManager extends EventEmitter {
 
   emitState(change, session) {
     this.emit('state', { change, session: session ? publicSession(session, false) : null, sessions: this.list() });
+    this.schedulePersist();
   }
 
   list() {
@@ -360,6 +495,7 @@ class TerminalManager extends EventEmitter {
     session.cols = numericDimension(cols, session.cols, 20, 500);
     session.rows = numericDimension(rows, session.rows, 5, 200);
     if (session.process && session.status === 'running') session.process.resize(session.cols, session.rows);
+    this.schedulePersist();
     return { ok: true, cols: session.cols, rows: session.rows };
   }
 
@@ -387,6 +523,7 @@ class TerminalManager extends EventEmitter {
     session.status = 'exited';
     session.updatedAt = new Date().toISOString();
     this.emitState('updated', session);
+    this.persistNow();
     return { ok: true };
   }
 
@@ -415,13 +552,31 @@ class TerminalManager extends EventEmitter {
     session.updatedAt = new Date().toISOString();
     this.sessions.delete(session.id);
     this.emit('state', { change: 'removed', session: publicSession(session, false), sessions: this.list() });
+    this.persistNow();
     return { ok: true };
   }
 
-  dispose() {
+  dispose({ preserveSessions = false } = {}) {
+    if (preserveSessions) {
+      const now = new Date().toISOString();
+      for (const session of this.sessions.values()) {
+        if (session.process) {
+          const handle = session.process;
+          session.process = null;
+          session.generation += 1;
+          this.killTree(handle, session.pid);
+        }
+        if (session.status === 'running' || session.status === 'starting') session.status = 'exited';
+        session.pid = null;
+        session.updatedAt = now;
+      }
+      this.persistNow();
+      return;
+    }
     for (const id of [...this.sessions.keys()]) {
       runBestEffort(`terminal-dispose:${id}`, () => this.close(id));
     }
+    this.persistNow();
   }
 }
 

package/src/updateInstaller.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn: spawnProcess } = require('child_process');
+
+const MAC_UPDATE_HELPER_SOURCE = path.join(__dirname, 'macUpdateHelper.js');
+
+const WINDOWS_UPDATE_HELPER = `param(
+  [Parameter(Mandatory = $true)][string]$InstallerPath,
+  [Parameter(Mandatory = $true)][int]$ParentPid,
+  [Parameter(Mandatory = $true)][string]$AppPath,
+  [Parameter(Mandatory = $true)][string]$LogPath
+)
+
+$ErrorActionPreference = 'Stop'
+$exitCode = -1
+try {
+  Wait-Process -Id $ParentPid -ErrorAction SilentlyContinue
+  $installer = Start-Process -FilePath $InstallerPath -ArgumentList '/S' -PassThru -Wait -WindowStyle Hidden
+  $exitCode = $installer.ExitCode
+} catch {
+  $_ | Out-String | Set-Content -LiteralPath $LogPath -Encoding UTF8
+} finally {
+  try { "exitCode=$exitCode" | Add-Content -LiteralPath $LogPath -Encoding UTF8 } catch {}
+  if ($exitCode -ne 0) {
+    try { "updateFailed=true" | Add-Content -LiteralPath $LogPath -Encoding UTF8 } catch {}
+  }
+  if (Test-Path -LiteralPath $AppPath) {
+    Remove-Item Env:ELECTRON_RUN_AS_NODE -ErrorAction SilentlyContinue
+    try { Start-Process -FilePath $AppPath } catch {}
+  }
+  Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue
+}
+`;
+
+function isWithinDirectory(file, directory) {
+  if (!file || !directory) return false;
+  const relative = path.relative(path.resolve(directory), path.resolve(file));
+  return relative !== '' && !relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative);
+}
+
+function macAppBundlePath(executablePath) {
+  const normalized = path.posix.normalize(String(executablePath || '').replace(/\\/g, '/'));
+  const match = normalized.match(/^((?:\/|[A-Za-z]:\/).+?\.app)\/Contents\/MacOS\/[^/]+$/i);
+  return match ? match[1] : '';
+}
+
+function automaticInstallPlatform({ platform, installType, installerPath, downloadsDir, appPath }) {
+  if (installType !== 'desktop' || !isWithinDirectory(installerPath, downloadsDir)) return '';
+  const fileName = path.basename(installerPath);
+  if (platform === 'win32' && /^LoadToAgent-Setup-[0-9A-Za-z.-]+\.exe$/i.test(fileName)) return 'win32';
+  if (platform === 'darwin' && /^LoadToAgent-[0-9A-Za-z.-]+-(?:arm64|x64)\.dmg$/i.test(fileName)) {
+    const appBundle = macAppBundlePath(appPath);
+    if (appBundle && appBundle !== '/Volumes' && !appBundle.startsWith('/Volumes/')) return 'darwin';
+  }
+  return '';
+}
+
+function canInstallSilently(options) {
+  return Boolean(automaticInstallPlatform(options || {}));
+}
+
+function windowsPowerShell(environment = process.env) {
+  const systemRoot = String(environment.SystemRoot || environment.WINDIR || 'C:\\Windows');
+  return path.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+}
+
+function waitForProcessSpawn(child, timeoutMs = 5000) {
+  if (!child || typeof child.once !== 'function' || typeof child.unref !== 'function') {
+    return Promise.reject(new Error('업데이트 설치 프로세스를 시작하지 못했습니다.'));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = error => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) reject(error);
+      else resolve();
+    };
+    const timer = setTimeout(() => finish(new Error('업데이트 설치 프로세스 시작 확인 시간이 초과되었습니다.')), timeoutMs);
+    child.once('spawn', () => finish());
+    child.once('error', error => finish(error));
+  });
+}
+
+async function launchDownloadedUpdate(options = {}) {
+  const installerPath = String(options.installerPath || '');
+  const downloadsDir = String(options.downloadsDir || '');
+  if (!installerPath || !fs.existsSync(installerPath)) throw new Error('내려받은 설치 파일을 찾지 못했습니다. 다시 다운로드해 주세요.');
+
+  const platform = String(options.platform || process.platform);
+  const automaticPlatform = automaticInstallPlatform({
+    platform,
+    installType: String(options.installType || ''),
+    installerPath,
+    downloadsDir,
+    appPath: String(options.appPath || ''),
+  });
+  if (!automaticPlatform) {
+    if (!options.shell || typeof options.shell.openPath !== 'function') throw new Error('설치 파일을 열 수 없습니다.');
+    const openError = await options.shell.openPath(installerPath);
+    if (openError) throw new Error(openError);
+    return { mode: 'manual' };
+  }
+
+  const appPath = String(options.appPath || '');
+  const parentPid = Number(options.parentPid);
+  if (!appPath || !fs.existsSync(appPath) || !Number.isSafeInteger(parentPid) || parentPid <= 0) {
+    throw new Error('업데이트 후 앱을 다시 시작할 정보를 준비하지 못했습니다.');
+  }
+
+  const spawn = options.spawn || spawnProcess;
+  if (automaticPlatform === 'darwin') {
+    const targetApp = macAppBundlePath(appPath);
+    if (!targetApp || !fs.existsSync(targetApp)) throw new Error('현재 설치된 macOS 앱을 찾지 못했습니다.');
+    const helperPath = path.join(downloadsDir, 'install-update-macos.js');
+    const logPath = path.join(downloadsDir, 'install-update.log');
+    const helperSource = await fs.promises.readFile(MAC_UPDATE_HELPER_SOURCE, 'utf8');
+    await fs.promises.writeFile(helperPath, helperSource, { encoding: 'utf8', mode: 0o700 });
+    const environment = { ...process.env, ...(options.environment || {}), ELECTRON_RUN_AS_NODE: '1' };
+    const child = spawn(appPath, [
+      helperPath,
+      '--dmg', installerPath,
+      '--target', targetApp,
+      '--parent-pid', String(parentPid),
+      '--log', logPath,
+    ], {
+      detached: true,
+      stdio: 'ignore',
+      env: environment,
+    });
+    await waitForProcessSpawn(child, Number(options.spawnTimeoutMs) || 5000);
+    if (!Number.isSafeInteger(child.pid) || child.pid <= 0) throw new Error('업데이트 설치 프로세스를 시작하지 못했습니다.');
+    child.unref();
+    return { mode: 'automatic', helperPath, logPath, targetApp };
+  }
+
+  const helperPath = path.join(downloadsDir, 'install-update.ps1');
+  const logPath = path.join(downloadsDir, 'install-update.log');
+  await fs.promises.writeFile(helperPath, WINDOWS_UPDATE_HELPER, { encoding: 'utf8', mode: 0o600 });
+  const child = spawn(windowsPowerShell(options.environment), [
+    '-NoLogo',
+    '-NoProfile',
+    '-NonInteractive',
+    '-WindowStyle', 'Hidden',
+    '-ExecutionPolicy', 'Bypass',
+    '-File', helperPath,
+    '-InstallerPath', installerPath,
+    '-ParentPid', String(parentPid),
+    '-AppPath', appPath,
+    '-LogPath', logPath,
+  ], {
+    detached: true,
+    windowsHide: true,
+    stdio: 'ignore',
+  });
+  await waitForProcessSpawn(child, Number(options.spawnTimeoutMs) || 5000);
+  if (!Number.isSafeInteger(child.pid) || child.pid <= 0) throw new Error('업데이트 설치 프로세스를 시작하지 못했습니다.');
+  child.unref();
+  return { mode: 'automatic', helperPath, logPath };
+}
+
+module.exports = {
+  MAC_UPDATE_HELPER_SOURCE,
+  WINDOWS_UPDATE_HELPER,
+  automaticInstallPlatform,
+  canInstallSilently,
+  isWithinDirectory,
+  launchDownloadedUpdate,
+  macAppBundlePath,
+  waitForProcessSpawn,
+  windowsPowerShell,
+};