@triflux/remote 10.0.0-alpha.1 → 10.0.0

package/hub/team/notify.mjs

@@ -0,0 +1,293 @@
+// hub/team/notify.mjs — team notifier (bell / Windows toast / webhook)
+
+import { execFile } from 'node:child_process';
+import os from 'node:os';
+
+export const NOTIFY_EVENT_TYPES = Object.freeze(['completed', 'failed', 'inputWait']);
+export const NOTIFY_CHANNELS = Object.freeze(['bell', 'toast', 'webhook']);
+
+function freezeRecord(record) {
+  return Object.freeze({ ...record });
+}
+
+function escapePowerShellSingleQuoted(value) {
+  return String(value ?? '').replaceAll("'", "''");
+}
+
+function normalizeTimestamp(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (value == null || value === '') return new Date().toISOString();
+  return String(value);
+}
+
+function normalizeEvent(event, defaults = {}) {
+  if (!event || typeof event !== 'object') {
+    throw new TypeError('notify(event) requires an event object');
+  }
+
+  const type = String(event.type || '').trim();
+  if (!NOTIFY_EVENT_TYPES.includes(type)) {
+    throw new TypeError(`Unsupported notify event type: ${type || '<empty>'}`);
+  }
+
+  return freezeRecord({
+    type,
+    sessionId: event.sessionId == null ? '' : String(event.sessionId),
+    host: event.host == null || event.host === '' ? String(defaults.host || os.hostname()) : String(event.host),
+    summary: event.summary == null ? '' : String(event.summary),
+    timestamp: normalizeTimestamp(event.timestamp),
+  });
+}
+
+function defaultChannelConfig(name, env) {
+  switch (name) {
+    case 'bell':
+      return { enabled: true };
+    case 'toast':
+      return { enabled: true };
+    case 'webhook': {
+      const url = String(env?.TRIFLUX_NOTIFY_WEBHOOK || '');
+      return { enabled: Boolean(url), url };
+    }
+    default:
+      throw new TypeError(`Unknown notify channel: ${name}`);
+  }
+}
+
+function normalizeChannelConfig(name, value, env) {
+  const base = defaultChannelConfig(name, env);
+  const patch = typeof value === 'boolean'
+    ? { enabled: value }
+    : (value && typeof value === 'object' ? value : {});
+
+  const next = {
+    ...base,
+    ...patch,
+  };
+
+  if ('enabled' in next) {
+    next.enabled = Boolean(next.enabled);
+  }
+
+  if (name === 'webhook') {
+    next.url = String(next.url || env?.TRIFLUX_NOTIFY_WEBHOOK || '');
+  }
+
+  if (name === 'toast') {
+    if (next.command != null) next.command = String(next.command);
+    if (next.timeoutMs != null) next.timeoutMs = Math.max(1, Number.parseInt(String(next.timeoutMs), 10) || 5000);
+  }
+
+  return freezeRecord(next);
+}
+
+function normalizeChannels(channels, env) {
+  const source = channels && typeof channels === 'object' ? channels : {};
+  const normalized = {};
+  for (const name of NOTIFY_CHANNELS) {
+    normalized[name] = normalizeChannelConfig(name, source[name], env);
+  }
+  return Object.freeze(normalized);
+}
+
+function updateChannelConfig(channels, channel, config, env) {
+  if (!NOTIFY_CHANNELS.includes(channel)) {
+    throw new TypeError(`Unknown notify channel: ${channel}`);
+  }
+
+  return Object.freeze({
+    ...channels,
+    [channel]: normalizeChannelConfig(channel, { ...channels[channel], ...(typeof config === 'boolean' ? { enabled: config } : (config || {})) }, env),
+  });
+}
+
+function formatEventTitle(event) {
+  switch (event.type) {
+    case 'completed':
+      return 'Triflux completed';
+    case 'failed':
+      return 'Triflux failed';
+    case 'inputWait':
+      return 'Triflux waiting for input';
+    default:
+      return 'Triflux notification';
+  }
+}
+
+function formatEventBody(event) {
+  const parts = [];
+  if (event.summary) parts.push(event.summary);
+
+  const meta = [event.sessionId ? `session ${event.sessionId}` : '', event.host ? `host ${event.host}` : '']
+    .filter(Boolean)
+    .join(' · ');
+  if (meta) parts.push(meta);
+
+  return parts.join('\n') || event.timestamp;
+}
+
+function createResult(channel, status, extra = {}) {
+  return freezeRecord({ channel, status, ...extra });
+}
+
+function execFileAsync(command, args, options, execFileFn) {
+  return new Promise((resolve, reject) => {
+    execFileFn(command, args, options, (error, stdout, stderr) => {
+      if (error) {
+        error.stdout = stdout;
+        error.stderr = stderr;
+        reject(error);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+async function sendBell(config, deps) {
+  if (!config.enabled) return createResult('bell', 'skipped', { reason: 'disabled' });
+  const stream = deps.stdout;
+  if (!stream || typeof stream.write !== 'function') {
+    return createResult('bell', 'skipped', { reason: 'stdout-unavailable' });
+  }
+
+  try {
+    stream.write('\u0007');
+    return createResult('bell', 'sent');
+  } catch (error) {
+    return createResult('bell', 'failed', { error: error.message });
+  }
+}
+
+function buildToastScript(title, body) {
+  const safeTitle = escapePowerShellSingleQuoted(title);
+  const safeBody = escapePowerShellSingleQuoted(body);
+  return [
+    "$ErrorActionPreference = 'Stop'",
+    `$Title = '${safeTitle}'`,
+    `$Body = '${safeBody}'`,
+    "if (Get-Command New-BurntToastNotification -ErrorAction SilentlyContinue) {",
+    '  New-BurntToastNotification -Text @($Title, $Body) | Out-Null',
+    '  return',
+    '}',
+    '[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null',
+    '[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] > $null',
+    '$escapedTitle = [System.Security.SecurityElement]::Escape($Title)',
+    '$escapedBody = [System.Security.SecurityElement]::Escape($Body)',
+    '$xml = New-Object Windows.Data.Xml.Dom.XmlDocument',
+    '$xml.LoadXml("<toast><visual><binding template=\'ToastGeneric\'><text>$escapedTitle</text><text>$escapedBody</text></binding></visual></toast>")',
+    '$toast = [Windows.UI.Notifications.ToastNotification]::new($xml)',
+    "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('Triflux').Show($toast)",
+  ].join('; ');
+}
+
+async function sendToast(event, config, deps) {
+  if (!config.enabled) return createResult('toast', 'skipped', { reason: 'disabled' });
+  if ((deps.platform || process.platform) !== 'win32') {
+    return createResult('toast', 'skipped', { reason: 'unsupported-platform' });
+  }
+
+  const execFileFn = deps.execFile || execFile;
+  const candidates = config.command
+    ? [config.command]
+    : Array.isArray(deps.powerShellCandidates) && deps.powerShellCandidates.length > 0
+      ? deps.powerShellCandidates
+      : ['pwsh', 'powershell.exe'];
+
+  const title = formatEventTitle(event);
+  const body = formatEventBody(event);
+  const script = buildToastScript(title, body);
+  const failures = [];
+
+  for (const command of candidates) {
+    try {
+      await execFileAsync(command, ['-NoLogo', '-NoProfile', '-Command', script], {
+        windowsHide: true,
+        timeout: config.timeoutMs || 5000,
+      }, execFileFn);
+      return createResult('toast', 'sent', { command });
+    } catch (error) {
+      failures.push(`${command}: ${error.message}`);
+    }
+  }
+
+  return createResult('toast', 'failed', { error: failures.join(' | ') || 'toast-send-failed' });
+}
+
+async function sendWebhook(event, config, deps) {
+  if (!config.enabled) return createResult('webhook', 'skipped', { reason: 'disabled' });
+  if (!config.url) return createResult('webhook', 'skipped', { reason: 'missing-url' });
+  if (typeof deps.fetch !== 'function') {
+    return createResult('webhook', 'failed', { error: 'fetch-unavailable' });
+  }
+
+  try {
+    const response = await deps.fetch(config.url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(event),
+    });
+
+    if (!response?.ok) {
+      return createResult('webhook', 'failed', { error: `HTTP ${response?.status ?? 'unknown'}` });
+    }
+
+    return createResult('webhook', 'sent', { statusCode: response.status });
+  } catch (error) {
+    return createResult('webhook', 'failed', { error: error.message });
+  }
+}
+
+function createNotifierInstance(channels, deps) {
+  async function notify(event) {
+    const normalizedEvent = normalizeEvent(event, { host: deps.hostname });
+    const results = {
+      bell: await sendBell(channels.bell, deps),
+      toast: await sendToast(normalizedEvent, channels.toast, deps),
+      webhook: await sendWebhook(normalizedEvent, channels.webhook, deps),
+    };
+
+    return freezeRecord({
+      event: normalizedEvent,
+      results: Object.freeze(results),
+    });
+  }
+
+  function setChannel(channel, config) {
+    return createNotifierInstance(updateChannelConfig(channels, channel, config, deps.env), deps);
+  }
+
+  return Object.freeze({ notify, setChannel });
+}
+
+/**
+ * 팀 세션 알림기 팩토리.
+ * - bell: 터미널 BEL 문자
+ * - toast: Windows PowerShell 기반 toast (BurntToast 우선, WinRT fallback)
+ * - webhook: TRIFLUX_NOTIFY_WEBHOOK JSON POST
+ *
+ * Immutable pattern: setChannel()은 기존 notifier를 수정하지 않고 새 notifier를 반환한다.
+ *
+ * @param {object} [opts]
+ * @param {object} [opts.channels] — 채널별 초기 설정
+ * @param {object} [opts.env=process.env] — 환경 변수 소스
+ * @param {NodeJS.WriteStream|{write:function}} [opts.stdout=process.stdout] — bell 출력 대상
+ * @param {string} [opts.platform=process.platform] — 플랫폼 override (test 용)
+ * @param {string} [opts.hostname=os.hostname()] — 기본 host override
+ * @param {object} [opts.deps] — 테스트용 의존성 주입
+ * @returns {{ notify(event: object): Promise<object>, setChannel(channel: string, config: object|boolean): object }}
+ */
+export function createNotifier(opts = {}) {
+  const env = opts.env || process.env;
+  const deps = Object.freeze({
+    env,
+    stdout: opts.stdout || process.stdout,
+    execFile: opts.deps?.execFile || execFile,
+    fetch: opts.deps?.fetch || globalThis.fetch?.bind(globalThis),
+    platform: opts.platform || process.platform,
+    hostname: opts.hostname || os.hostname(),
+    powerShellCandidates: Object.freeze(opts.deps?.powerShellCandidates || ['pwsh', 'powershell.exe']),
+  });
+
+  return createNotifierInstance(normalizeChannels(opts.channels, env), deps);
+}

package/hub/team/pane.mjs

@@ -6,7 +6,7 @@ import { tmpdir } from "node:os";
 import { detectMultiplexer, tmuxExec } from "./session.mjs";
 import { psmuxExec } from "./psmux.mjs";
 
-import { buildExecArgs } from "../codex-adapter.mjs";
+import { buildExecArgs } from "@triflux/core/hub/codex-adapter.mjs";
 
 function quoteArg(value) {
   return `"${String(value).replace(/"/g, '\\"')}"`;

package/hub/team/process-cleanup.mjs

@@ -0,0 +1,342 @@
+// hub/team/process-cleanup.mjs — 고아 node/python 프로세스 감지 및 정리
+// Windows: Get-CimInstance Win32_Process로 parent PID + cmdLine 접근
+// Unix: ps aux 파싱
+import { execFile as nodeExecFile } from "node:child_process";
+import { promisify } from "node:util";
+import { IS_WINDOWS } from "@triflux/core/hub/platform.mjs";
+
+const execFileAsync = promisify(nodeExecFile);
+
+// ── 상수 ────────────────────────────────────────────────────────────────────
+
+const TARGET_PROCESS_NAMES = ["node", "python", "python3"];
+const SIGTERM_GRACE_MS = 5000;
+
+// cmdLine 패턴 기반 화이트리스트 (고아 후보에서 제외)
+const WHITELIST_CMDLINE = [
+  /oh-my-claudecode/i,
+  /triflux[\\/]hub[\\/]s/i,
+];
+
+// 프로세스명 기반 화이트리스트
+const WHITELIST_NAMES = ["claude", "CCXProcess"];
+
+// ── PowerShell / ps 파싱 ─────────────────────────────────────────────────────
+
+/**
+ * Windows: Get-CimInstance Win32_Process로 프로세스 목록 조회
+ * @param {Function} execFileFn - DI용 execFile 구현
+ * @returns {Promise<Array<{pid,name,parentPid,cmdLine,ramMB}>>}
+ */
+async function queryWindowsProcesses(execFileFn) {
+  const script = [
+    "Get-CimInstance Win32_Process |",
+    "  Select-Object ProcessId,Name,ParentProcessId,CommandLine,WorkingSetSize |",
+    "  ConvertTo-Json -Compress",
+  ].join(" ");
+
+  const { stdout } = await execFileFn(
+    "pwsh",
+    ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script],
+    { encoding: "utf8", timeout: 15_000, windowsHide: true },
+  );
+
+  const raw = JSON.parse(stdout.trim());
+  const items = Array.isArray(raw) ? raw : [raw];
+
+  return items
+    .filter(Boolean)
+    .map((p) => ({
+      pid: Number(p.ProcessId),
+      name: String(p.Name || "").replace(/\.exe$/i, ""),
+      parentPid: Number(p.ParentProcessId) || 0,
+      cmdLine: String(p.CommandLine || ""),
+      ramMB: Math.round((Number(p.WorkingSetSize) || 0) / 1024 / 1024),
+    }));
+}
+
+/**
+ * Unix: ps aux 파싱
+ * @param {Function} execFileFn - DI용 execFile 구현
+ * @returns {Promise<Array<{pid,name,parentPid,cmdLine,ramMB}>>}
+ */
+async function queryUnixProcesses(execFileFn) {
+  const { stdout } = await execFileFn(
+    "ps",
+    ["-eo", "pid,ppid,rss,comm,args", "--no-headers"],
+    { encoding: "utf8", timeout: 10_000 },
+  );
+
+  return stdout
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const parts = line.trim().split(/\s+/);
+      const pid = Number(parts[0]);
+      const parentPid = Number(parts[1]);
+      const ramMB = Math.round((Number(parts[2]) || 0) / 1024);
+      const name = String(parts[3] || "");
+      const cmdLine = parts.slice(4).join(" ");
+      return { pid, name, parentPid, cmdLine, ramMB };
+    });
+}
+
+/**
+ * 프로세스 시작 시각을 Unix 기준 ms로 조회 (Windows 전용, best-effort)
+ * @param {number} pid
+ * @param {Function} execFileFn
+ * @returns {Promise<number>} epoch ms, 실패 시 0
+ */
+async function getWindowsProcessStartMs(pid, execFileFn) {
+  try {
+    const script = `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CreationDate | Get-Date -Format 'o'`;
+    const { stdout } = await execFileFn(
+      "pwsh",
+      ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script],
+      { encoding: "utf8", timeout: 5_000, windowsHide: true },
+    );
+    const ts = Date.parse(stdout.trim());
+    return Number.isNaN(ts) ? 0 : ts;
+  } catch {
+    return 0;
+  }
+}
+
+// ── 화이트리스트 판정 ──────────────────────────────────────────────────────
+
+/**
+ * 프로세스가 화이트리스트에 해당하는지 판정
+ * @param {{name:string, cmdLine:string}} proc
+ * @param {Set<number>} parentPids - 화이트리스트 부모 PID 집합
+ * @returns {boolean}
+ */
+function isWhitelisted(proc, parentPids) {
+  const nameLower = proc.name.toLowerCase();
+
+  // 프로세스명 기반
+  if (WHITELIST_NAMES.some((n) => nameLower.includes(n.toLowerCase()))) {
+    return true;
+  }
+
+  // cmdLine 패턴 기반
+  if (WHITELIST_CMDLINE.some((re) => re.test(proc.cmdLine))) {
+    return true;
+  }
+
+  // CCXProcess 자식 (Adobe Creative Cloud)
+  if (parentPids.has(proc.parentPid)) {
+    return true;
+  }
+
+  return false;
+}
+
+// ── psmux 교차검증 ──────────────────────────────────────────────────────────
+
+/**
+ * psmux list-sessions 결과에서 활성 세션 pane PID 집합을 수집
+ * @param {Function} execFileFn
+ * @returns {Promise<Set<number>>}
+ */
+async function getActivePsmuxPids(execFileFn) {
+  try {
+    const { stdout: sessOut } = await execFileFn(
+      "psmux",
+      ["list-sessions", "-F", "#{session_name}"],
+      { encoding: "utf8", timeout: 5_000, windowsHide: true },
+    );
+
+    const sessions = sessOut.trim().split(/\r?\n/).filter(Boolean);
+    if (sessions.length === 0) return new Set();
+
+    const pids = new Set();
+
+    await Promise.all(
+      sessions.map(async (session) => {
+        try {
+          const { stdout: paneOut } = await execFileFn(
+            "psmux",
+            ["list-panes", "-t", session, "-a", "-F", "#{pane_pid}"],
+            { encoding: "utf8", timeout: 5_000, windowsHide: true },
+          );
+          paneOut
+            .trim()
+            .split(/\r?\n/)
+            .filter(Boolean)
+            .forEach((p) => {
+              const n = Number(p.trim());
+              if (n > 0) pids.add(n);
+            });
+        } catch {
+          // 세션 쿼리 실패 시 해당 세션만 건너뜀
+        }
+      }),
+    );
+
+    return pids;
+  } catch {
+    // psmux 미설치 또는 실패 시 빈 집합 반환
+    return new Set();
+  }
+}
+
+// ── 공개 API ────────────────────────────────────────────────────────────────
+
+/**
+ * 고아 프로세스 목록을 반환한다.
+ *
+ * @param {object} [opts]
+ * @param {Function} [opts.execFileFn] - DI용 execFile (기본: node:child_process.execFile의 promisify 버전)
+ * @param {boolean} [opts.skipPsmuxCheck] - psmux 교차검증 생략 (테스트용)
+ * @returns {Promise<Array<{pid,name,ramMB,parentPid,cmdLine,age}>>}
+ */
+export async function findOrphanProcesses(opts = {}) {
+  const execFileFn = opts.execFileFn ?? execFileAsync;
+
+  let allProcs;
+  try {
+    allProcs = IS_WINDOWS
+      ? await queryWindowsProcesses(execFileFn)
+      : await queryUnixProcesses(execFileFn);
+  } catch {
+    return [];
+  }
+
+  if (allProcs.length === 0) return [];
+
+  const pidSet = new Set(allProcs.map((p) => p.pid));
+
+  // CCXProcess 부모 PID 집합 구성
+  const ccxParentPids = new Set(
+    allProcs
+      .filter((p) => p.name.toLowerCase() === "ccxprocess")
+      .map((p) => p.pid),
+  );
+
+  // 활성 psmux PID 교차검증
+  const activePsmuxPids = opts.skipPsmuxCheck
+    ? new Set()
+    : await getActivePsmuxPids(execFileFn);
+
+  const now = Date.now();
+
+  const candidates = allProcs.filter((p) => {
+    const nameLower = p.name.toLowerCase();
+
+    // 대상 프로세스만
+    if (!TARGET_PROCESS_NAMES.some((t) => nameLower === t || nameLower === `${t}.exe`)) {
+      return false;
+    }
+
+    // 화이트리스트
+    if (isWhitelisted(p, ccxParentPids)) return false;
+
+    // 활성 psmux 세션 소속 PID 제외
+    if (activePsmuxPids.has(p.pid)) return false;
+
+    // 부모가 없거나(0, 1 제외 시 존재하지 않는 PID) 고아
+    const parentAlive = p.parentPid <= 1 || pidSet.has(p.parentPid);
+    if (parentAlive) return false;
+
+    return true;
+  });
+
+  // age 계산 (Windows만 best-effort, Unix는 0)
+  const results = await Promise.all(
+    candidates.map(async (p) => {
+      let startMs = 0;
+      if (IS_WINDOWS) {
+        startMs = await getWindowsProcessStartMs(p.pid, execFileFn);
+      }
+      return {
+        pid: p.pid,
+        name: p.name,
+        ramMB: p.ramMB,
+        parentPid: p.parentPid,
+        cmdLine: p.cmdLine,
+        age: startMs > 0 ? now - startMs : 0,
+      };
+    }),
+  );
+
+  return results;
+}
+
+/**
+ * createProcessCleanup — scan/kill/getOrphans 인터페이스를 반환한다.
+ *
+ * @param {object} [opts]
+ * @param {Function} [opts.execFileFn] - DI용 execFile (promisify된 버전)
+ * @param {boolean} [opts.dryRun] - true이면 kill 없이 목록만 반환
+ * @param {boolean} [opts.skipPsmuxCheck] - psmux 교차검증 생략 (테스트용)
+ * @returns {{ scan: Function, kill: Function, getOrphans: Function }}
+ */
+export function createProcessCleanup(opts = {}) {
+  const execFileFn = opts.execFileFn ?? execFileAsync;
+  const dryRun = opts.dryRun ?? false;
+
+  let lastOrphans = [];
+
+  /**
+   * 고아 프로세스를 스캔하여 내부 상태에 저장하고 목록을 반환한다.
+   * @returns {Promise<Array<{pid,name,ramMB,parentPid,cmdLine,age}>>}
+   */
+  async function scan() {
+    const found = await findOrphanProcesses({
+      execFileFn,
+      skipPsmuxCheck: opts.skipPsmuxCheck,
+    });
+    lastOrphans = found;
+    return found;
+  }
+
+  /**
+   * 마지막 scan 결과의 프로세스를 kill한다.
+   * dryRun=true이면 kill 없이 목록만 반환한다.
+   * SIGTERM → 5s 대기 → SIGKILL 순서.
+   * @returns {Promise<Array<{pid,name,killed,error}>>}
+   */
+  async function kill() {
+    if (dryRun) {
+      return lastOrphans.map((p) => ({ pid: p.pid, name: p.name, killed: false, dryRun: true }));
+    }
+
+    const results = await Promise.all(
+      lastOrphans.map(async (p) => {
+        try {
+          // SIGTERM
+          process.kill(p.pid, "SIGTERM");
+
+          // 5초 대기 후 살아있으면 SIGKILL
+          await new Promise((resolve) => setTimeout(resolve, SIGTERM_GRACE_MS));
+
+          try {
+            // 프로세스가 아직 살아있는지 확인 (signal 0)
+            process.kill(p.pid, 0);
+            // 여전히 살아있음 → SIGKILL
+            process.kill(p.pid, "SIGKILL");
+          } catch {
+            // ESRCH: 이미 종료됨 — 정상
+          }
+
+          return { pid: p.pid, name: p.name, killed: true };
+        } catch (err) {
+          return { pid: p.pid, name: p.name, killed: false, error: String(err.message || err) };
+        }
+      }),
+    );
+
+    return results;
+  }
+
+  /**
+   * 마지막 scan 결과를 반환한다 (재스캔 없음).
+   * @returns {Array<{pid,name,ramMB,parentPid,cmdLine,age}>}
+   */
+  function getOrphans() {
+    return lastOrphans;
+  }
+
+  return { scan, kill, getOrphans };
+}

package/hub/team/psmux.mjs

@@ -5,7 +5,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir, homedir } from "node:os";
 import { join } from "node:path";
 import { formatPsmuxInstallGuidance } from "../../scripts/lib/psmux-info.mjs";
-import { IS_WINDOWS } from "../platform.mjs";
+import { IS_WINDOWS } from "@triflux/core/hub/platform.mjs";
 
 const PSMUX_BIN = (() => {
   if (process.env.PSMUX_BIN) return process.env.PSMUX_BIN;