loadtoagent 1.0.0 → 1.3.1

package/src/automationMonitor.js

@@ -0,0 +1,258 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PUBLIC_KEYS = new Set([
+  'version',
+  'id',
+  'kind',
+  'name',
+  'status',
+  'rrule',
+  'model',
+  'reasoning_effort',
+  'execution_environment',
+  'target_thread_id',
+  'cwds',
+  'created_at',
+  'updated_at',
+]);
+
+const WEEKDAYS = Object.freeze({ SU: 0, MO: 1, TU: 2, WE: 3, TH: 4, FR: 5, SA: 6 });
+
+function parseQuoted(value) {
+  try {
+    return JSON.parse(value);
+  } catch (_invalidQuotedValue) {
+    return value.slice(1, -1);
+  }
+}
+
+function parseTomlValue(raw) {
+  const value = String(raw || '').trim();
+  if (value.startsWith('"') && value.endsWith('"')) return parseQuoted(value);
+  if (value.startsWith('[') && value.endsWith(']')) {
+    const strings = [...value.matchAll(/"(?:\\.|[^"\\])*"/g)].map(match => parseQuoted(match[0]));
+    return strings;
+  }
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) return Number(value);
+  if (/^(?:true|false)$/i.test(value)) return value.toLowerCase() === 'true';
+  return value;
+}
+
+/** Parse only non-sensitive fields used by the dashboard. Prompt text is intentionally discarded. */
+function parseAutomationToml(source) {
+  const parsed = {};
+  let multilineDelimiter = '';
+  for (const line of String(source || '').split(/\r?\n/)) {
+    if (multilineDelimiter) {
+      if (line.includes(multilineDelimiter)) multilineDelimiter = '';
+      continue;
+    }
+    const match = line.match(/^\s*([a-zA-Z][\w]*)\s*=\s*(.*?)\s*$/);
+    if (!match) continue;
+    const triple = match[2].startsWith('"""') ? '"""' : (match[2].startsWith("'''") ? "'''" : '');
+    if (triple) {
+      if (!match[2].slice(3).includes(triple)) multilineDelimiter = triple;
+      continue;
+    }
+    if (!PUBLIC_KEYS.has(match[1])) continue;
+    parsed[match[1]] = parseTomlValue(match[2]);
+  }
+  return parsed;
+}
+
+function parseRRule(value) {
+  const output = {};
+  for (const pair of String(value || '').split(';')) {
+    const [key, raw] = pair.split('=', 2);
+    if (key && raw != null) output[key.trim().toUpperCase()] = raw.trim();
+  }
+  return output;
+}
+
+function localCandidate(base, dayOffset, hour, minute, second = 0) {
+  const candidate = new Date(base);
+  candidate.setHours(hour, minute, second, 0);
+  candidate.setDate(candidate.getDate() + dayOffset);
+  return candidate;
+}
+
+function nextDaily(rule, now, anchor) {
+  const hours = String(rule.BYHOUR || '0').split(',').map(Number).filter(Number.isFinite).sort((a, b) => a - b);
+  const minutes = String(rule.BYMINUTE || '0').split(',').map(Number).filter(Number.isFinite).sort((a, b) => a - b);
+  const interval = Math.max(1, Number(rule.INTERVAL || 1));
+  const anchorDay = new Date(anchor || now);
+  anchorDay.setHours(0, 0, 0, 0);
+  for (let offset = 0; offset <= interval + 2; offset += 1) {
+    const day = localCandidate(now, offset, 0, 0);
+    day.setHours(0, 0, 0, 0);
+    const elapsedDays = Math.round((day.getTime() - anchorDay.getTime()) / 86_400_000);
+    if (elapsedDays >= 0 && elapsedDays % interval !== 0) continue;
+    for (const hour of hours) for (const minute of minutes) {
+      const candidate = localCandidate(now, offset, hour, minute);
+      if (candidate > now) return candidate;
+    }
+  }
+  return null;
+}
+
+function nextHourly(rule, now, anchorValue) {
+  const interval = Math.max(1, Number(rule.INTERVAL || 1));
+  const minutes = String(rule.BYMINUTE || String(now.getMinutes())).split(',').map(Number).filter(Number.isFinite).sort((a, b) => a - b);
+  const anchor = new Date(anchorValue || now);
+  anchor.setMinutes(0, 0, 0);
+  for (let offset = 0; offset <= interval * 2 + 2; offset += 1) {
+    for (const minute of minutes) {
+      const candidate = new Date(now);
+      candidate.setMinutes(minute, 0, 0);
+      candidate.setHours(candidate.getHours() + offset);
+      const candidateHour = new Date(candidate);
+      candidateHour.setMinutes(0, 0, 0);
+      const elapsedHours = Math.round((candidateHour.getTime() - anchor.getTime()) / 3_600_000);
+      if (candidate > now && elapsedHours >= 0 && elapsedHours % interval === 0) return candidate;
+    }
+  }
+  return null;
+}
+
+function nextWeekly(rule, now, anchorValue) {
+  const days = String(rule.BYDAY || Object.keys(WEEKDAYS)[now.getDay()]).split(',')
+    .map(value => WEEKDAYS[value.slice(-2).toUpperCase()])
+    .filter(Number.isFinite);
+  const interval = Math.max(1, Number(rule.INTERVAL || 1));
+  const hour = Number(String(rule.BYHOUR || '0').split(',')[0]);
+  const minute = Number(String(rule.BYMINUTE || '0').split(',')[0]);
+  const anchorWeek = new Date(anchorValue || now);
+  anchorWeek.setHours(0, 0, 0, 0);
+  anchorWeek.setDate(anchorWeek.getDate() - anchorWeek.getDay());
+  for (let offset = 0; offset <= interval * 14 + 7; offset += 1) {
+    const candidate = localCandidate(now, offset, hour, minute);
+    const candidateWeek = new Date(candidate);
+    candidateWeek.setHours(0, 0, 0, 0);
+    candidateWeek.setDate(candidateWeek.getDate() - candidateWeek.getDay());
+    const elapsedWeeks = Math.round((candidateWeek.getTime() - anchorWeek.getTime()) / (7 * 86_400_000));
+    if (days.includes(candidate.getDay()) && candidate > now && elapsedWeeks >= 0 && elapsedWeeks % interval === 0) return candidate;
+  }
+  return null;
+}
+
+function nextMinutely(rule, now, anchorValue) {
+  const interval = Math.max(1, Number(rule.INTERVAL || 1));
+  const anchor = new Date(anchorValue || now);
+  anchor.setSeconds(0, 0);
+  for (let offset = 1; offset <= interval * 2 + 1; offset += 1) {
+    const candidate = new Date(now);
+    candidate.setSeconds(0, 0);
+    candidate.setMinutes(candidate.getMinutes() + offset);
+    const elapsedMinutes = Math.round((candidate.getTime() - anchor.getTime()) / 60_000);
+    if (elapsedMinutes >= 0 && elapsedMinutes % interval === 0) return candidate;
+  }
+  return null;
+}
+
+function nextOccurrence(rrule, nowValue = new Date(), anchorValue = null) {
+  const now = nowValue instanceof Date ? new Date(nowValue) : new Date(nowValue);
+  if (Number.isNaN(now.getTime())) return null;
+  const rule = parseRRule(rrule);
+  let candidate = null;
+  if (rule.FREQ === 'DAILY') candidate = nextDaily(rule, now, anchorValue);
+  else if (rule.FREQ === 'HOURLY') candidate = nextHourly(rule, now, anchorValue);
+  else if (rule.FREQ === 'WEEKLY') candidate = nextWeekly(rule, now, anchorValue);
+  else if (rule.FREQ === 'MINUTELY') candidate = nextMinutely(rule, now, anchorValue);
+  if (!candidate) return null;
+  if (rule.UNTIL) {
+    const until = new Date(rule.UNTIL);
+    if (!Number.isNaN(until.getTime()) && candidate > until) return null;
+  }
+  return candidate.toISOString();
+}
+
+function isoTimestamp(value) {
+  const number = Number(value || 0);
+  if (!Number.isFinite(number) || number <= 0) return null;
+  const millis = number > 10_000_000_000 ? number : number * 1000;
+  const date = new Date(millis);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+function normalizeAutomation(config, file, now) {
+  const createdAt = isoTimestamp(config.created_at);
+  const status = String(config.status || 'INACTIVE').toUpperCase();
+  return {
+    id: String(config.id || path.basename(path.dirname(file))),
+    kind: String(config.kind || 'automation'),
+    name: String(config.name || config.id || 'Codex automation'),
+    status,
+    enabled: status === 'ACTIVE',
+    rrule: String(config.rrule || ''),
+    nextRunAt: status === 'ACTIVE' ? nextOccurrence(config.rrule, now, createdAt) : null,
+    provider: 'codex',
+    model: String(config.model || ''),
+    reasoningEffort: String(config.reasoning_effort || ''),
+    executionEnvironment: String(config.execution_environment || ''),
+    targetThreadId: String(config.target_thread_id || ''),
+    cwds: Array.isArray(config.cwds) ? config.cwds.slice(0, 8).map(String) : [],
+    createdAt,
+    updatedAt: isoTimestamp(config.updated_at),
+  };
+}
+
+function scanCodexAutomations(options = {}) {
+  const home = options.home || '';
+  const now = options.now instanceof Date ? options.now : new Date(options.now || Date.now());
+  const root = options.root || path.join(home, '.codex', 'automations');
+  if (!root || !fs.existsSync(root)) return [];
+  let entries = [];
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch (_unreadableAutomationDirectory) {
+    return [];
+  }
+  const automations = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const file = path.join(root, entry.name, 'automation.toml');
+    try {
+      const source = fs.readFileSync(file, 'utf8');
+      automations.push(normalizeAutomation(parseAutomationToml(source), file, now));
+    } catch (_unreadableAutomationFile) {
+      // One malformed automation must not hide the other schedules.
+    }
+  }
+  return automations.sort((a, b) => {
+    if (a.enabled !== b.enabled) return a.enabled ? -1 : 1;
+    return Date.parse(a.nextRunAt || 0) - Date.parse(b.nextRunAt || 0) || a.name.localeCompare(b.name);
+  });
+}
+
+function scanCodexAutomationHomes(options = {}) {
+  const now = options.now instanceof Date ? options.now : new Date(options.now || Date.now());
+  const seen = new Set();
+  const homes = (options.homes || []).filter((entry) => {
+    const key = String(entry && entry.home || '').toLowerCase();
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  return homes.flatMap((entry) => scanCodexAutomations({ home: entry.home, now }).map((automation) => ({
+    ...automation,
+    environment: {
+      kind: String(entry.kind || 'external'),
+      distro: String(entry.distro || ''),
+    },
+    sourceLabel: String(entry.label || entry.distro || entry.kind || ''),
+  }))).sort((a, b) => {
+    if (a.enabled !== b.enabled) return a.enabled ? -1 : 1;
+    return Date.parse(a.nextRunAt || 0) - Date.parse(b.nextRunAt || 0) || a.name.localeCompare(b.name);
+  });
+}
+
+module.exports = {
+  nextOccurrence,
+  parseAutomationToml,
+  parseRRule,
+  scanCodexAutomationHomes,
+  scanCodexAutomations,
+};

package/src/contracts.js

@@ -37,11 +37,20 @@
  * @property {string} status
  * @property {string|null} parentId
  * @property {string} cwd
+ * @property {string} originCwd Immutable workspace path where the session began.
  * @property {string} updatedAt
  * @property {TokenUsage} usage
  * @property {Array<Object>} messages
  * @property {Array<Object>} lifecycle
+ * @property {Array<{id:string,kind:'shell'|'background',mode:'foreground'|'background',tool:string,runtime:string,label:string,command:string,cwd:string,status:'running'|'completed'|'failed',statusDetail:string,output:string,backgroundId:string,exitCode:number|null,startedAt:string|null,updatedAt:string|null,completedAt:string|null}>} executions Observed shell and background execution units owned by this AI session.
  * @property {CollaborationSummary|null} collaboration
+ * @property {{kind:string,iteration:number,phase?:string}|boolean|null} loop Safe execution-loop metadata; internal goal text is never included.
+ * @property {{required:boolean,kind:string,summary:string,requestedAt:string|null,source:string,confidence:string}} attention Actionable reason why the session needs the user.
+ * @property {{stage:string,percent:number,completedSteps:number,failedSteps:number,totalSteps:number,currentStep:string,blocker:string,lastActivityAt:string|null,source:string,checkpoints:Array<Object>}} progress Structured progress reconstructed from lifecycle events.
+ * @property {{level:string,score:number,signals:Array<Object>,lastActivityAt:string|null,ageSeconds:number|null}} health Stalls, failures, context pressure, and hierarchy anomalies.
+ * @property {{managed:boolean,respond:boolean,approve:boolean,deny:boolean,sendInstruction:boolean,stop:boolean,pause:boolean,resume:boolean,retry:boolean,reassign:boolean,openOrigin:boolean}} controlCapabilities Safe provider-aware actions available for this session.
+ * @property {{confidence:string,status:string,hierarchy:string,completion:string,sources:Array<string>}} evidence Observation provenance and confidence.
+ * @property {{status:string,summary:string,verified:boolean,verification:string,completedAt:string|null,artifacts:Array<Object>,checks:Array<Object>}} outcome Completion summary, artifacts, and verification evidence.
  */
 
 /**
@@ -61,7 +70,7 @@
  * @property {Array<Object>} providers
  * @property {Object<string, boolean|string>} availability
  * @property {Array<{path:string,name:string}>} workspaces
- * @property {{sessions: AgentSession[], summary: Object}} snapshot
+ * @property {{sessions: AgentSession[], automations: Array<Object>, summary: Object}} snapshot Safe local/WSL automation metadata excludes prompt text.
  * @property {Array<Object>} activeRuns
  * @property {{app:string,electron:string,node:string}} versions
  * @property {Object} platform

package/src/ipc/registerAgentIpc.js

@@ -1,11 +1,17 @@
 'use strict';
 
-function registerAgentIpc({ handleTrusted, snapshot, requestDetail, runner, probeProviders }) {
+function registerAgentIpc({ handleTrusted, snapshot, requestDetail, runner, isProviderVisible = () => true, probeProviders }) {
   handleTrusted('agents:snapshot', snapshot);
   handleTrusted('agents:detail', requestDetail);
-  handleTrusted('agents:run', options => runner().start(options));
+  handleTrusted('agents:run', options => {
+    if (!isProviderVisible(options && options.provider)) throw new Error('설정에서 숨긴 AI는 실행할 수 없습니다.');
+    return runner().start(options);
+  });
   handleTrusted('agents:stop', runId => runner().stop(runId));
-  handleTrusted('agents:active-runs', () => runner().listActive());
+  handleTrusted('agents:pause', runId => runner().pause(runId));
+  handleTrusted('agents:resume-run', runId => runner().resume(runId));
+  handleTrusted('agents:retry', runId => runner().retry(runId));
+  handleTrusted('agents:active-runs', () => runner().listActive().filter(run => isProviderVisible(run.provider)));
   handleTrusted('providers:probe', probeProviders);
 }
 

package/src/ipc/registerAppIpc.js

@@ -1,13 +1,16 @@
 'use strict';
 
-function registerAppIpc({ handleTrusted, bootstrap, backgroundState, show, setLocale, updateManager }) {
+function registerAppIpc({ handleTrusted, bootstrap, rendererReady, backgroundState, show, setLocale, setProviderVisibility, updateManager, installUpdate }) {
   handleTrusted('app:bootstrap', bootstrap);
+  handleTrusted('app:renderer-ready', rendererReady);
   handleTrusted('app:background-state', backgroundState);
   handleTrusted('app:show', show);
   handleTrusted('app:set-locale', setLocale);
+  handleTrusted('app:set-provider-visibility', setProviderVisibility);
   handleTrusted('app:update-check', () => requireUpdateManager(updateManager).check());
   handleTrusted('app:update-download', () => requireUpdateManager(updateManager).download());
   handleTrusted('app:update-open', () => requireUpdateManager(updateManager).openDownloaded());
+  handleTrusted('app:update-install', installUpdate);
   handleTrusted('app:update-open-release', () => requireUpdateManager(updateManager).openReleasePage());
 }
 

package/src/ipc/registerTerminalIpc.js

@@ -1,25 +1,31 @@
 'use strict';
 
-function registerTerminalIpc({ ipcMain, requireTrustedSender, trustedSender, manager, listWslDistros, sendError }) {
+function registerTerminalIpc({ ipcMain, requireTrustedSender, trustedSender, manager, isProviderVisible = () => true, listWslDistros, sendError }) {
   ipcMain.handle('terminals:list', event => {
     requireTrustedSender(event);
-    return manager() ? manager().list() : [];
+    return manager() ? manager().list().filter(session => session.type !== 'agent' || isProviderVisible(session.provider)) : [];
   });
   ipcMain.handle('wsl:list-distros', event => {
     requireTrustedSender(event);
     return listWslDistros();
   });
-  ipcMain.handle('terminals:get', (event, id) => {
+  ipcMain.handle('terminals:get', async (event, id) => {
     requireTrustedSender(event);
-    return manager() ? manager().get(id, true) : null;
+    const session = manager() ? await manager().get(id, true) : null;
+    return session && session.type === 'agent' && !isProviderVisible(session.provider) ? null : session;
   });
   ipcMain.handle('terminals:create', (event, options) => {
     requireTrustedSender(event);
+    if (options && options.type === 'agent' && !isProviderVisible(options.provider)) throw new Error('설정에서 숨긴 AI는 실행할 수 없습니다.');
     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 }); }
+    try {
+      Promise.resolve(manager().write(id, data)).catch(error => sendError({ id: String(id || ''), message: error.message }));
+    } catch (error) {
+      sendError({ id: String(id || ''), message: error.message });
+    }
   });
   ipcMain.handle('terminals:command', (event, id, command) => {
     requireTrustedSender(event);
@@ -28,7 +34,7 @@ function registerTerminalIpc({ ipcMain, requireTrustedSender, trustedSender, man
   ipcMain.on('terminals:resize', (event, id, cols, rows) => {
     if (!trustedSender(event) || !manager()) return;
     try {
-      manager().resize(id, cols, rows);
+      Promise.resolve(manager().resize(id, cols, rows)).catch(error => sendError({ id: String(id || ''), message: error.message }));
     } catch (error) {
       sendError({ id: String(id || ''), message: error.message });
     }

package/src/macUpdateHelper.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawn } = require('child_process');
+
+const DEFAULT_COMMANDS = Object.freeze({
+  hdiutil: '/usr/bin/hdiutil',
+  ditto: '/usr/bin/ditto',
+  open: '/usr/bin/open',
+});
+
+function delay(milliseconds) {
+  return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+
+function runCommand(command, args = []) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: 'ignore' });
+    child.once('error', reject);
+    child.once('exit', (code, signal) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${path.basename(command)} 종료 코드: ${code == null ? signal : code}`));
+    });
+  });
+}
+
+async function waitForParentExit(parentPid, options = {}) {
+  const pid = Number(parentPid);
+  if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error('종료를 기다릴 앱 프로세스 정보가 올바르지 않습니다.');
+  const processExists = options.processExists || (candidate => {
+    try {
+      process.kill(candidate, 0);
+      return true;
+    } catch (error) {
+      if (error && error.code === 'ESRCH') return false;
+      if (error && error.code === 'EPERM') return true;
+      throw error;
+    }
+  });
+  const pause = options.delay || delay;
+  const timeoutMs = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : 60_000;
+  const pollMs = Number(options.pollMs) > 0 ? Number(options.pollMs) : 250;
+  const startedAt = Date.now();
+  while (processExists(pid)) {
+    if (Date.now() - startedAt >= timeoutMs) throw new Error('기존 앱이 제한 시간 안에 종료되지 않았습니다.');
+    await pause(pollMs);
+  }
+}
+
+async function appendLog(logPath, message, fileSystem = fs.promises) {
+  if (!logPath) return;
+  try {
+    await fileSystem.appendFile(logPath, `[${new Date().toISOString()}] ${message}\n`, 'utf8');
+  } catch (_logError) {
+    // Logging must never prevent rollback or relaunch.
+  }
+}
+
+async function pathIsDirectory(targetPath, fileSystem = fs.promises) {
+  try {
+    const stat = await fileSystem.lstat(targetPath);
+    return stat.isDirectory() && !stat.isSymbolicLink();
+  } catch (_missingPath) {
+    return false;
+  }
+}
+
+async function removePath(targetPath, fileSystem = fs.promises) {
+  if (!targetPath) return;
+  await fileSystem.rm(targetPath, { recursive: true, force: true });
+}
+
+async function installMacUpdate(options = {}) {
+  const dmgPath = String(options.dmgPath || '');
+  const targetApp = String(options.targetApp || '');
+  const logPath = String(options.logPath || '');
+  const fileSystem = options.fileSystem || fs.promises;
+  const run = options.run || runCommand;
+  const wait = options.waitForParentExit || waitForParentExit;
+  const commands = { ...DEFAULT_COMMANDS, ...(options.commands || {}) };
+  const operationId = String(options.operationId || `${process.pid}-${crypto.randomBytes(6).toString('hex')}`)
+    .replace(/[^0-9A-Za-z-]/g, '') || String(process.pid);
+  const targetParent = path.dirname(targetApp);
+  const targetName = path.basename(targetApp);
+  let mountPath = String(options.mountPath || '');
+  if (!dmgPath || !targetApp || !logPath) throw new Error('macOS 업데이트에 필요한 경로가 비어 있습니다.');
+  if (!await pathIsDirectory(targetApp, fileSystem)) throw new Error('현재 설치된 앱 번들을 찾지 못했습니다.');
+  if (!mountPath) mountPath = await fileSystem.mkdtemp(path.join(os.tmpdir(), 'loadtoagent-update-'));
+  const stagedApp = path.join(targetParent, `.${targetName}.update-${operationId}`);
+  const backupApp = path.join(targetParent, `.${targetName}.backup-${operationId}`);
+  let mounted = false;
+  let parentExited = false;
+  let oldAppMoved = false;
+  let newAppMoved = false;
+
+  await appendLog(logPath, `waiting parentPid=${Number(options.parentPid)}`, fileSystem);
+  try {
+    await wait(Number(options.parentPid));
+    parentExited = true;
+    await appendLog(logPath, 'parent exited', fileSystem);
+
+    await removePath(stagedApp, fileSystem);
+    await removePath(backupApp, fileSystem);
+    await run(commands.hdiutil, ['attach', dmgPath, '-nobrowse', '-readonly', '-mountpoint', mountPath]);
+    mounted = true;
+
+    const sourceApp = path.join(mountPath, 'LoadToAgent.app');
+    if (!await pathIsDirectory(sourceApp, fileSystem)) throw new Error('DMG에서 LoadToAgent.app을 찾지 못했습니다.');
+    await run(commands.ditto, [sourceApp, stagedApp]);
+    if (!await pathIsDirectory(stagedApp, fileSystem)) throw new Error('새 앱을 설치 위치에 복사하지 못했습니다.');
+
+    try {
+      await run(commands.hdiutil, ['detach', mountPath]);
+      mounted = false;
+    } catch (error) {
+      await appendLog(logPath, `detach warning: ${error && error.message || error}`, fileSystem);
+    }
+
+    await fileSystem.rename(targetApp, backupApp);
+    oldAppMoved = true;
+    await fileSystem.rename(stagedApp, targetApp);
+    newAppMoved = true;
+    await run(commands.open, ['-n', targetApp]);
+    await appendLog(logPath, 'update installed and relaunched', fileSystem);
+
+    try {
+      await removePath(backupApp, fileSystem);
+    } catch (error) {
+      await appendLog(logPath, `backup cleanup warning: ${error && error.message || error}`, fileSystem);
+    }
+    return { targetApp };
+  } catch (error) {
+    await appendLog(logPath, `update failed: ${error && error.stack || error}`, fileSystem);
+    if (oldAppMoved) {
+      try {
+        if (newAppMoved) await removePath(targetApp, fileSystem);
+        if (await pathIsDirectory(backupApp, fileSystem)) await fileSystem.rename(backupApp, targetApp);
+        await appendLog(logPath, 'original app restored', fileSystem);
+      } catch (rollbackError) {
+        await appendLog(logPath, `rollback failed: ${rollbackError && rollbackError.stack || rollbackError}`, fileSystem);
+      }
+    }
+    if (parentExited && await pathIsDirectory(targetApp, fileSystem)) {
+      try {
+        await run(commands.open, ['-n', targetApp]);
+        await appendLog(logPath, 'original app relaunched', fileSystem);
+      } catch (relaunchError) {
+        await appendLog(logPath, `relaunch failed: ${relaunchError && relaunchError.stack || relaunchError}`, fileSystem);
+      }
+    }
+    throw error;
+  } finally {
+    if (mounted) {
+      try {
+        await run(commands.hdiutil, ['detach', mountPath, '-force']);
+      } catch (error) {
+        await appendLog(logPath, `forced detach failed: ${error && error.message || error}`, fileSystem);
+      }
+    }
+    try { await removePath(stagedApp, fileSystem); } catch (_cleanupError) {}
+    try { await removePath(mountPath, fileSystem); } catch (_cleanupError) {}
+  }
+}
+
+function parseArguments(argv) {
+  const values = {};
+  for (let index = 0; index < argv.length; index += 2) {
+    const flag = argv[index];
+    const value = argv[index + 1];
+    if (!/^--(?:dmg|target|parent-pid|log)$/.test(String(flag || '')) || value == null) {
+      throw new Error('macOS 업데이트 헬퍼 인자가 올바르지 않습니다.');
+    }
+    values[flag.slice(2)] = value;
+  }
+  return {
+    dmgPath: values.dmg,
+    targetApp: values.target,
+    parentPid: Number(values['parent-pid']),
+    logPath: values.log,
+  };
+}
+
+async function runCli(argv = process.argv.slice(2)) {
+  const options = parseArguments(argv);
+  delete process.env.ELECTRON_RUN_AS_NODE;
+  try {
+    await installMacUpdate(options);
+  } catch (error) {
+    await appendLog(options.logPath, `helper stopped: ${error && error.stack || error}`);
+    throw error;
+  }
+}
+
+if (require.main === module) {
+  runCli().catch(() => { process.exitCode = 1; });
+}
+
+module.exports = {
+  DEFAULT_COMMANDS,
+  appendLog,
+  installMacUpdate,
+  parseArguments,
+  pathIsDirectory,
+  runCommand,
+  runCli,
+  waitForParentExit,
+};