triflux 10.0.0 → 10.0.2

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/orchestrator.mjs

@@ -0,0 +1,161 @@
+// hub/team/orchestrator.mjs — 작업 분배 + 프롬프트 구성
+// 의존성: pane.mjs만 사용
+import { injectPrompt } from "./pane.mjs";
+
+/**
+ * 작업 분해 (LLM 없이 구분자 기반)
+ * @param {string} taskDescription — 전체 작업 설명
+ * @param {number} agentCount — 에이전트 수
+ * @returns {string[]} 각 에이전트의 서브태스크
+ */
+export function decomposeTask(taskDescription, agentCount) {
+  if (agentCount <= 0) return [];
+  if (agentCount === 1) return [taskDescription];
+
+  // '+', ',', '\n' 기준으로 분리
+  const parts = taskDescription
+    .split(/[+,\n]+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  if (parts.length === 0) return [taskDescription];
+
+  // 에이전트보다 서브태스크가 적으면 마지막 에이전트에 전체 태스크 부여
+  if (parts.length < agentCount) {
+    const result = [...parts];
+    while (result.length < agentCount) {
+      result.push(taskDescription);
+    }
+    return result;
+  }
+
+  // 에이전트보다 서브태스크가 많으면 앞에서부터 N개, 나머지는 마지막에 합침
+  if (parts.length > agentCount) {
+    const result = parts.slice(0, agentCount - 1);
+    result.push(parts.slice(agentCount - 1).join(" + "));
+    return result;
+  }
+
+  return parts;
+}
+
+/**
+ * 리드(보통 claude) 초기 프롬프트 생성
+ * @param {string} taskDescription
+ * @param {object} config
+ * @param {string} config.agentId
+ * @param {string} config.hubUrl
+ * @param {string} config.teammateMode
+ * @param {Array<{agentId:string, cli:string, subtask:string}>} config.workers
+ * @returns {string}
+ */
+export function buildLeadPrompt(taskDescription, config) {
+  const { agentId, hubUrl, teammateMode = "tmux", workers = [] } = config;
+
+  const roster = workers
+    .map((w, i) => `${i + 1}. ${w.agentId} (${w.cli}) — ${w.subtask}`)
+    .join("\n") || "- (워커 없음)";
+
+  const workerIds = workers.map((w) => w.agentId).join(", ");
+
+  const bridgePath = "node hub/bridge.mjs";
+
+  return `리드 에이전트: ${agentId}
+
+목표: ${taskDescription}
+모드: ${teammateMode}
+
+워커:
+${roster}
+
+규칙:
+- 가능한 짧고 핵심만 지시/요약(토큰 절약)
+- 워커 제어:
+  ${bridgePath} result --agent ${agentId} --topic lead.control
+- 워커 결과 수집:
+  ${bridgePath} context --agent ${agentId} --max 20
+- 최종 결과는 topic="task.result"를 모아 통합
+
+워커 ID: ${workerIds || "(없음)"}
+지금 즉시 워커를 배정하고 병렬 진행을 관리하라.`;
+}
+
+/**
+ * 워커 초기 프롬프트 생성
+ * @param {string} subtask — 이 에이전트의 서브태스크
+ * @param {object} config
+ * @param {string} config.cli — codex/gemini/claude
+ * @param {string} config.agentId — 에이전트 식별자
+ * @param {string} config.hubUrl — Hub URL
+ * @returns {string}
+ */
+export function buildPrompt(subtask, config) {
+  const { cli, agentId, hubUrl } = config;
+
+  const hubBase = hubUrl.replace("/mcp", "");
+
+  const bridgePath = "node hub/bridge.mjs";
+
+  return `워커: ${agentId} (${cli})
+작업: ${subtask}
+
+필수 규칙:
+1) 간결하게 작업(불필요한 장문 설명 금지)
+2) 시작 즉시 등록:
+   ${bridgePath} register --agent ${agentId} --cli ${cli} --topics lead.control,task.result
+3) 주기적으로 수신함 확인:
+   ${bridgePath} context --agent ${agentId} --max 10
+4) lead.control 수신 시 즉시 반응 (interrupt/stop/pause/resume)
+5) 완료 시 결과 발행:
+   ${bridgePath} result --agent ${agentId} --topic task.result --file <출력파일>
+
+지금 작업을 시작하라.`;
+}
+
+/**
+ * 팀 오케스트레이션 실행 — 각 pane에 프롬프트 주입
+ * @param {string} sessionName — tmux 세션 이름
+ * @param {Array<{target: string, cli: string, subtask: string}>} assignments
+ * @param {object} opts
+ * @param {string} opts.hubUrl — Hub URL
+ * @param {{target:string, cli:string, task:string}|null} opts.lead
+ * @param {string} opts.teammateMode
+ * @returns {Promise<void>}
+ */
+export async function orchestrate(sessionName, assignments, opts = {}) {
+  const {
+    hubUrl = "http://127.0.0.1:27888/mcp",
+    lead = null,
+    teammateMode = "tmux",
+  } = opts;
+
+  const workers = assignments.map(({ target, cli, subtask }) => ({
+    target,
+    cli,
+    subtask,
+    agentId: `${cli}-${target.split(".").pop()}`,
+  }));
+
+  if (lead?.target) {
+    const leadAgentId = `${lead.cli || "claude"}-${lead.target.split(".").pop()}`;
+    const leadPrompt = buildLeadPrompt(lead.task || "팀 작업 조율", {
+      agentId: leadAgentId,
+      hubUrl,
+      teammateMode,
+      workers: workers.map((w) => ({ agentId: w.agentId, cli: w.cli, subtask: w.subtask })),
+    });
+    injectPrompt(lead.target, leadPrompt, { useFileRef: true });
+    await new Promise((r) => setTimeout(r, 100));
+  }
+
+  for (const worker of workers) {
+    const prompt = buildPrompt(worker.subtask, {
+      cli: worker.cli,
+      agentId: worker.agentId,
+      hubUrl,
+      sessionName,
+    });
+    injectPrompt(worker.target, prompt, { useFileRef: true });
+    await new Promise((r) => setTimeout(r, 100));
+  }
+}

package/hub/team/pane.mjs

@@ -0,0 +1,153 @@
+// hub/team/pane.mjs — pane별 CLI 실행 + stdin 주입
+// 의존성: child_process, fs, os, path (Node.js 내장)만 사용
+import { writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { detectMultiplexer, tmuxExec } from "./session.mjs";
+import { psmuxExec } from "./psmux.mjs";
+
+import { buildExecArgs } from "../codex-adapter.mjs";
+
+function quoteArg(value) {
+  return `"${String(value).replace(/"/g, '\\"')}"`;
+}
+
+function getPsmuxSessionName(target) {
+  return String(target).split(":")[0]?.trim() || "";
+}
+
+/** Windows 경로를 멀티플렉서용 경로로 변환 */
+function toMuxPath(p) {
+  if (process.platform !== "win32") return p;
+
+  const mux = detectMultiplexer();
+
+  // psmux는 Windows 네이티브 경로 그대로 사용
+  if (mux === "psmux") return p;
+
+  const normalized = p.replace(/\\/g, "/");
+  const m = normalized.match(/^([A-Za-z]):\/(.*)$/);
+  if (!m) return normalized;
+
+  const drive = m[1].toLowerCase();
+  const rest = m[2];
+
+  // wsl tmux는 /mnt/c/... 경로를 사용
+  if (mux === "wsl-tmux") {
+    return `/mnt/${drive}/${rest}`;
+  }
+
+  // Git Bash/MSYS tmux는 /c/... 경로를 사용
+  return `/${drive}/${rest}`;
+}
+
+/** 멀티플렉서 커맨드 실행 (session.mjs와 동일 패턴) */
+function muxExec(args, opts = {}) {
+  const exec = detectMultiplexer() === "psmux" ? psmuxExec : tmuxExec;
+  return exec(args, {
+    encoding: "utf8",
+    timeout: 10000,
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+    ...opts,
+  });
+}
+
+/**
+ * CLI 에이전트 시작 커맨드 생성
+ * @param {'codex'|'gemini'|'claude'} cli
+ * @param {{ trustMode?: boolean }} [options]
+ * @returns {string} 실행할 셸 커맨드
+ */
+export function buildCliCommand(cli, options = {}) {
+  const { trustMode = false } = options;
+
+  switch (cli) {
+    case "codex":
+      // trust 모드에서는 exec 서브커맨드 기반 명령을 사용
+      if (trustMode) {
+        return buildExecArgs({});
+      }
+      return "codex";
+    case "gemini":
+      // interactive 모드 — MCP는 ~/.gemini/settings.json에 사전 등록
+      return "gemini";
+    case "claude":
+      // interactive 모드
+      return "claude";
+    default:
+      return cli; // 커스텀 CLI 허용
+  }
+}
+
+/**
+ * pane에 CLI 시작
+ * @param {string} target — 예: tfx-multi-abc:0.1
+ * @param {string} command — 실행할 커맨드
+ */
+export function startCliInPane(target, command) {
+  // CLI 시작도 buffer paste를 재사용해 셸/플랫폼별 quoting 차이를 제거한다.
+  injectPrompt(target, command);
+}
+
+/**
+ * pane에 프롬프트 주입 (load-buffer + paste-buffer 방식)
+ * 멀티라인 + 특수문자 안전, 크기 제한 없음
+ * @param {string} target — 예: tfx-multi-abc:0.1
+ * @param {string} prompt — 주입할 텍스트
+ */
+/**
+ * pane에 프롬프트 주입
+ * @param {string} target — 예: tfx-multi-abc:0.1
+ * @param {string} prompt — 주입할 텍스트
+ * @param {object} [opts]
+ * @param {boolean} [opts.useFileRef] — true면 TUI용 @file 참조 방식 (psmux 전용)
+ */
+export function injectPrompt(target, prompt, { useFileRef = false } = {}) {
+  const tmpDir = join(tmpdir(), "tfx-multi");
+  mkdirSync(tmpDir, { recursive: true });
+
+  const safeTarget = target.replace(/[:.]/g, "-");
+  const tmpFile = join(tmpDir, `prompt-${safeTarget}-${Date.now()}.txt`);
+
+  // psmux + TUI 앱: @file 참조로 주입 (paste-buffer는 TUI와 호환 안 됨)
+  if (detectMultiplexer() === "psmux" && useFileRef) {
+    writeFileSync(tmpFile, prompt, "utf8");
+    const filePath = tmpFile.replace(/\\/g, "/");
+    psmuxExec(["select-pane", "-t", target]);
+    psmuxExec(["send-keys", "-t", target, "-l", `@${filePath}`]);
+    psmuxExec(["send-keys", "-t", target, "Enter"]);
+    // TUI가 파일을 읽을 시간을 주고 정리
+    setTimeout(() => { try { unlinkSync(tmpFile); } catch {} }, 10000);
+    return;
+  }
+
+  try {
+    writeFileSync(tmpFile, prompt, "utf8");
+
+    if (detectMultiplexer() === "psmux") {
+      const sessionName = getPsmuxSessionName(target);
+      psmuxExec(["load-buffer", "-t", sessionName, toMuxPath(tmpFile)]);
+      psmuxExec(["select-pane", "-t", target]);
+      psmuxExec(["paste-buffer", "-t", target]);
+      psmuxExec(["send-keys", "-t", target, "Enter"]);
+      return;
+    }
+
+    // tmux load-buffer → paste-buffer → Enter
+    muxExec(`load-buffer ${quoteArg(toMuxPath(tmpFile))}`);
+    muxExec(`paste-buffer -t ${target}`);
+    muxExec(`send-keys -t ${target} Enter`);
+  } finally {
+    try { unlinkSync(tmpFile); } catch {}
+  }
+}
+
+/**
+ * pane에 키 입력 전송
+ * @param {string} target — 예: tfx-multi-abc:0.1
+ * @param {string} keys — tmux 키 표현 (예: 'C-c', 'Enter')
+ */
+export function sendKeys(target, keys) {
+  muxExec(`send-keys -t ${target} ${keys}`);
+}