loadtoagent 1.0.0

package/src/bridgeServer.js

@@ -0,0 +1,246 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const net = require('net');
+const crypto = require('crypto');
+const { AGENT_PROVIDERS } = require('./terminalManager');
+const { runBestEffort } = require('./diagnostics');
+
+const PROTOCOL_VERSION = 1;
+const MAX_FRAME_CHARS = 1024 * 1024;
+const AUTH_TIMEOUT_MS = 10_000;
+
+function bridgeDirectory(home = os.homedir()) {
+  return path.join(home, '.loadtoagent');
+}
+
+function discoveryFile(home = os.homedir()) {
+  return path.join(bridgeDirectory(home), 'bridge.json');
+}
+
+function endpointFor(platform = process.platform, home = os.homedir(), nonce = crypto.randomBytes(8).toString('hex')) {
+  const identity = crypto.createHash('sha256').update(`${home}:${nonce}`).digest('hex').slice(0, 18);
+  if (platform === 'win32') return `\\\\.\\pipe\\loadtoagent-${identity}`;
+  return path.join(os.tmpdir(), `loadtoagent-${typeof process.getuid === 'function' ? process.getuid() : 'user'}-${identity}.sock`);
+}
+
+function safeWriteJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const temporary = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, JSON.stringify(value, null, 2), { encoding: 'utf8', mode: 0o600 });
+  runBestEffort('bridge-temp-permissions', () => fs.chmodSync(temporary, 0o600));
+  fs.renameSync(temporary, file);
+  runBestEffort('bridge-discovery-permissions', () => fs.chmodSync(file, 0o600));
+}
+
+function sendFrame(socket, payload) {
+  if (!socket || socket.destroyed) return;
+  socket.write(`${JSON.stringify(payload)}\n`, 'utf8');
+}
+
+function validProvider(value) {
+  const provider = String(value || '').toLowerCase();
+  return AGENT_PROVIDERS[provider] ? provider : '';
+}
+
+function decodeBase64(value) {
+  const encoded = String(value || '');
+  if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(encoded)) {
+    throw new Error('브리지 입력 인코딩이 올바르지 않습니다.');
+  }
+  return Buffer.from(encoded, 'base64').toString('utf8');
+}
+
+class BridgeServer {
+  constructor(options = {}) {
+    this.terminalManager = options.terminalManager;
+    this.home = options.home || os.homedir();
+    this.platform = options.platform || process.platform;
+    this.endpoint = options.endpoint || endpointFor(this.platform, this.home);
+    this.token = options.token || crypto.randomBytes(32).toString('hex');
+    this.file = options.discoveryFile || discoveryFile(this.home);
+    this.server = null;
+    this.clients = new Map();
+    this.terminalListenersAttached = false;
+    this.onTerminalData = payload => this.forwardData(payload);
+    this.onTerminalState = payload => this.forwardState(payload);
+  }
+
+  start() {
+    if (!this.terminalManager) return Promise.reject(new Error('터미널 관리자가 준비되지 않았습니다.'));
+    if (this.server) return Promise.resolve(this.info());
+    if (this.platform !== 'win32') {
+      if (fs.existsSync(this.endpoint)) runBestEffort('bridge-stale-endpoint', () => fs.unlinkSync(this.endpoint));
+    }
+    this.server = net.createServer(socket => this.accept(socket));
+    return new Promise((resolve, reject) => {
+      const fail = error => {
+        if (this.server) {
+          runBestEffort('bridge-start-close', () => this.server.close());
+        }
+        this.server = null;
+        reject(error);
+      };
+      this.server.once('error', fail);
+      this.server.listen(this.endpoint, () => {
+        this.server.removeListener('error', fail);
+        try {
+          safeWriteJson(this.file, this.info());
+          this.attachTerminalListeners();
+          resolve(this.info());
+        } catch (error) {
+          fail(error);
+        }
+      });
+    });
+  }
+
+  attachTerminalListeners() {
+    if (this.terminalListenersAttached) return;
+    this.terminalManager.on('data', this.onTerminalData);
+    this.terminalManager.on('state', this.onTerminalState);
+    this.terminalListenersAttached = true;
+  }
+
+  detachTerminalListeners() {
+    if (!this.terminalManager || !this.terminalListenersAttached) return;
+    this.terminalManager.removeListener('data', this.onTerminalData);
+    this.terminalManager.removeListener('state', this.onTerminalState);
+    this.terminalListenersAttached = false;
+  }
+
+  info() {
+    return {
+      protocol: PROTOCOL_VERSION,
+      endpoint: this.endpoint,
+      token: this.token,
+      pid: process.pid,
+      platform: this.platform,
+      updatedAt: new Date().toISOString(),
+    };
+  }
+
+  accept(socket) {
+    socket.setNoDelay(true);
+    const client = { socket, buffer: '', authenticated: false, terminalId: '', bridgeId: '', authTimer: null };
+    client.authTimer = setTimeout(() => {
+      if (!client.authenticated) socket.destroy(new Error('브리지 인증 시간이 초과되었습니다.'));
+    }, AUTH_TIMEOUT_MS);
+    this.clients.set(socket, client);
+    socket.on('data', chunk => this.consume(client, chunk));
+    socket.on('error', () => this.detach(client));
+    socket.on('close', () => this.detach(client));
+  }
+
+  consume(client, chunk) {
+    client.buffer += chunk.toString('utf8');
+    if (client.buffer.length > MAX_FRAME_CHARS) return client.socket.destroy(new Error('브리지 입력이 너무 큽니다.'));
+    let newline;
+    while ((newline = client.buffer.indexOf('\n')) >= 0) {
+      const line = client.buffer.slice(0, newline).trim();
+      client.buffer = client.buffer.slice(newline + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch (_invalidBridgeFrame) {
+        return client.socket.destroy(new Error('브리지 메시지가 올바르지 않습니다.'));
+      }
+      try { this.handle(client, message || {}); } catch (error) {
+        sendFrame(client.socket, { type: 'error', message: String(error.message || error) });
+        if (!client.authenticated) client.socket.end();
+      }
+    }
+  }
+
+  handle(client, message) {
+    if (!client.authenticated) {
+      if (message.type !== 'run' || message.token !== this.token) throw new Error('LoadToAgent 브리지 인증에 실패했습니다.');
+      const provider = validProvider(message.provider);
+      if (!provider) throw new Error('지원하지 않는 AI 제공사입니다.');
+      const bridgeId = crypto.randomUUID();
+      const session = this.terminalManager.create({
+        type: 'agent',
+        provider,
+        args: Array.isArray(message.args) ? message.args : [],
+        cwd: message.cwd || this.home,
+        title: `외부 연결 · ${AGENT_PROVIDERS[provider].label}`,
+        bridgeId,
+        cols: message.cols,
+        rows: message.rows,
+      });
+      client.authenticated = true;
+      clearTimeout(client.authTimer);
+      client.authTimer = null;
+      client.terminalId = session.id;
+      client.bridgeId = bridgeId;
+      sendFrame(client.socket, {
+        type: 'started',
+        bridgeId,
+        terminalId: session.id,
+        pid: session.pid,
+        replay: Buffer.from(session.replay || '', 'utf8').toString('base64'),
+      });
+      return;
+    }
+    if (message.type === 'input') {
+      this.terminalManager.write(client.terminalId, decodeBase64(message.data));
+    } else if (message.type === 'resize') {
+      this.terminalManager.resize(client.terminalId, message.cols, message.rows);
+    } else if (message.type === 'signal') {
+      this.terminalManager.signal(client.terminalId, message.signal);
+    } else if (message.type === 'close') {
+      this.terminalManager.close(client.terminalId);
+      client.socket.end();
+    } else throw new Error('지원하지 않는 브리지 메시지입니다.');
+  }
+
+  forwardData(payload) {
+    for (const client of this.clients.values()) {
+      if (client.terminalId === payload.id) sendFrame(client.socket, { type: 'output', data: Buffer.from(String(payload.data || ''), 'utf8').toString('base64') });
+    }
+  }
+
+  forwardState(payload) {
+    const session = payload && payload.session;
+    if (!session) return;
+    for (const client of this.clients.values()) {
+      if (client.terminalId !== session.id) continue;
+      sendFrame(client.socket, { type: 'state', status: session.status, exitCode: session.exitCode, signal: session.signal });
+      if (session.status === 'exited' || session.status === 'failed') client.socket.end();
+    }
+  }
+
+  detach(client) {
+    if (client.authTimer) clearTimeout(client.authTimer);
+    this.clients.delete(client.socket);
+  }
+
+  dispose() {
+    this.detachTerminalListeners();
+    for (const client of this.clients.values()) {
+      runBestEffort('bridge-client-close', () => client.socket.destroy());
+    }
+    this.clients.clear();
+    if (this.server) {
+      runBestEffort('bridge-server-close', () => this.server.close());
+      this.server = null;
+    }
+    if (fs.existsSync(this.file)) runBestEffort('bridge-discovery-cleanup', () => fs.unlinkSync(this.file));
+    if (this.platform !== 'win32') {
+      if (fs.existsSync(this.endpoint)) runBestEffort('bridge-endpoint-cleanup', () => fs.unlinkSync(this.endpoint));
+    }
+  }
+}
+
+module.exports = {
+  BridgeServer,
+  PROTOCOL_VERSION,
+  bridgeDirectory,
+  discoveryFile,
+  endpointFor,
+  safeWriteJson,
+  decodeBase64,
+};

package/src/contracts.js

@@ -0,0 +1,71 @@
+'use strict';
+
+/**
+ * @typedef {Object} TokenUsage
+ * @property {number} input
+ * @property {number} output
+ * @property {number} cached
+ * @property {number} total
+ * @property {number|null} contextWindow
+ * @property {number|null} contextUsed
+ * @property {number|null} contextPercent
+ */
+
+/**
+ * @typedef {Object} CollaborationMetrics
+ * @property {number} spawnedTotal Total child sessions observed in the log.
+ * @property {number} running Number of child sessions that are currently active.
+ * @property {number} completed Number of child sessions with a completion event.
+ * @property {number|null} concurrencyLimit Provider concurrency limit when known.
+ */
+
+/**
+ * @typedef {Object} CollaborationSummary
+ * @property {CollaborationMetrics} metrics
+ * @property {Array<Object>} communications Normalized parent/child messages.
+ */
+
+/**
+ * Canonical provider-neutral session exchanged between the monitor worker,
+ * preload bridge, and renderer. Provider parsers may retain extra fields, but
+ * consumers should depend only on this contract.
+ *
+ * @typedef {Object} AgentSession
+ * @property {string} id
+ * @property {'claude'|'codex'|'gemini'|'grok'} provider
+ * @property {string} title
+ * @property {string} status
+ * @property {string|null} parentId
+ * @property {string} cwd
+ * @property {string} updatedAt
+ * @property {TokenUsage} usage
+ * @property {Array<Object>} messages
+ * @property {Array<Object>} lifecycle
+ * @property {CollaborationSummary|null} collaboration
+ */
+
+/**
+ * @typedef {Object} TerminalSession
+ * @property {string} id
+ * @property {'powershell'|'cmd'|'shell'|'wsl'|'tmux'|'agent'} type
+ * @property {string} title
+ * @property {string} cwd
+ * @property {'starting'|'running'|'exited'|'failed'} status
+ * @property {number|null} pid
+ * @property {string} replay
+ */
+
+/**
+ * Initial renderer payload returned by `app:bootstrap`.
+ * @typedef {Object} BootstrapPayload
+ * @property {Array<Object>} providers
+ * @property {Object<string, boolean|string>} availability
+ * @property {Array<{path:string,name:string}>} workspaces
+ * @property {{sessions: AgentSession[], summary: Object}} snapshot
+ * @property {Array<Object>} activeRuns
+ * @property {{app:string,electron:string,node:string}} versions
+ * @property {Object} platform
+ * @property {Object|null} update
+ */
+
+module.exports = {};

package/src/diagnostics.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * Records a recoverable failure without converting a best-effort operation into
+ * an application crash. Callers must provide an operation name so warnings are
+ * actionable in packaged-app logs.
+ */
+function reportRecoverableError(operation, error) {
+  const message = error && error.message ? error.message : String(error || 'unknown error');
+  console.warn(`[LoadToAgent:${operation}] ${message}`);
+}
+
+/** Runs cleanup code and reports a failure that is safe to continue past. */
+function runBestEffort(operation, action) {
+  try {
+    return action();
+  } catch (error) {
+    reportRecoverableError(operation, error);
+    return undefined;
+  }
+}
+
+module.exports = { reportRecoverableError, runBestEffort };

package/src/ipc/registerAgentIpc.js

@@ -0,0 +1,12 @@
+'use strict';
+
+function registerAgentIpc({ handleTrusted, snapshot, requestDetail, runner, probeProviders }) {
+  handleTrusted('agents:snapshot', snapshot);
+  handleTrusted('agents:detail', requestDetail);
+  handleTrusted('agents:run', options => runner().start(options));
+  handleTrusted('agents:stop', runId => runner().stop(runId));
+  handleTrusted('agents:active-runs', () => runner().listActive());
+  handleTrusted('providers:probe', probeProviders);
+}
+
+module.exports = { registerAgentIpc };

package/src/ipc/registerAppIpc.js

@@ -0,0 +1,20 @@
+'use strict';
+
+function registerAppIpc({ handleTrusted, bootstrap, backgroundState, show, setLocale, updateManager }) {
+  handleTrusted('app:bootstrap', bootstrap);
+  handleTrusted('app:background-state', backgroundState);
+  handleTrusted('app:show', show);
+  handleTrusted('app:set-locale', setLocale);
+  handleTrusted('app:update-check', () => requireUpdateManager(updateManager).check());
+  handleTrusted('app:update-download', () => requireUpdateManager(updateManager).download());
+  handleTrusted('app:update-open', () => requireUpdateManager(updateManager).openDownloaded());
+  handleTrusted('app:update-open-release', () => requireUpdateManager(updateManager).openReleasePage());
+}
+
+function requireUpdateManager(getUpdateManager) {
+  const manager = getUpdateManager();
+  if (!manager) throw new Error('업데이트 관리자가 준비되지 않았습니다.');
+  return manager;
+}
+
+module.exports = { registerAppIpc };

package/src/ipc/registerTerminalIpc.js

@@ -0,0 +1,50 @@
+'use strict';
+
+function registerTerminalIpc({ ipcMain, requireTrustedSender, trustedSender, manager, listWslDistros, sendError }) {
+  ipcMain.handle('terminals:list', event => {
+    requireTrustedSender(event);
+    return manager() ? manager().list() : [];
+  });
+  ipcMain.handle('wsl:list-distros', event => {
+    requireTrustedSender(event);
+    return listWslDistros();
+  });
+  ipcMain.handle('terminals:get', (event, id) => {
+    requireTrustedSender(event);
+    return manager() ? manager().get(id, true) : null;
+  });
+  ipcMain.handle('terminals:create', (event, options) => {
+    requireTrustedSender(event);
+    return requireManager(manager).create(options || {});
+  });
+  ipcMain.on('terminals:write', (event, id, data) => {
+    if (!trustedSender(event) || !manager()) return;
+    try { manager().write(id, data); } catch (error) { sendError({ id: String(id || ''), message: error.message }); }
+  });
+  ipcMain.handle('terminals:command', (event, id, command) => {
+    requireTrustedSender(event);
+    return requireManager(manager).command(id, command);
+  });
+  ipcMain.on('terminals:resize', (event, id, cols, rows) => {
+    if (!trustedSender(event) || !manager()) return;
+    try {
+      manager().resize(id, cols, rows);
+    } catch (error) {
+      sendError({ id: String(id || ''), message: error.message });
+    }
+  });
+  for (const operation of ['signal', 'restart', 'close']) {
+    ipcMain.handle(`terminals:${operation}`, (event, ...args) => {
+      requireTrustedSender(event);
+      return requireManager(manager)[operation](...args);
+    });
+  }
+}
+
+function requireManager(getManager) {
+  const terminalManager = getManager();
+  if (!terminalManager) throw new Error('터미널 관리자가 준비되지 않았습니다.');
+  return terminalManager;
+}
+
+module.exports = { registerTerminalIpc };

package/src/ipc/registerTmuxIpc.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const MUTATING_OPERATIONS = [
+  'new-session',
+  'new-window',
+  'split-pane',
+  'rename-session',
+  'rename-window',
+  'select-layout',
+  'kill-pane',
+  'kill-window',
+  'kill-session',
+];
+
+function registerTmuxIpc({ handleTrusted, controller, refresh }) {
+  handleTrusted('tmux:send-text', options => controller.sendText(options || {}));
+  handleTrusted('tmux:send-key', options => controller.sendKey(options || {}));
+  handleTrusted('tmux:capture', options => controller.capture(options || {}));
+
+  for (const operation of MUTATING_OPERATIONS) {
+    const method = operation.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    handleTrusted(`tmux:${operation}`, async options => {
+      const result = await controller[method](options || {});
+      refresh();
+      return result;
+    });
+  }
+}
+
+module.exports = { registerTmuxIpc };

package/src/ipc/registerWorkspaceIpc.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function registerWorkspaceIpc({ handleTrusted, list, add, remove, pick, openExternal, writeClipboard, bridgeCommand, openOrigin }) {
+  handleTrusted('workspaces:list', list);
+  handleTrusted('workspaces:add', add);
+  handleTrusted('workspaces:remove', remove);
+  handleTrusted('workspaces:pick', pick);
+  handleTrusted('external:open', openExternal);
+  handleTrusted('clipboard:write', writeClipboard);
+  handleTrusted('bridge:command', bridgeCommand);
+  handleTrusted('agents:open-origin', openOrigin);
+}
+
+module.exports = { registerWorkspaceIpc };