@triflux/remote 10.1.0 → 10.26.0

package/hub/team/synapse-http.mjs

@@ -0,0 +1,60 @@
+const DEFAULT_SYNAPSE_BASE_URL = "http://127.0.0.1:27888";
+
+function resolveSynapseFetch(fetchImpl) {
+  if (fetchImpl === null) return null;
+  if (typeof fetchImpl === "function") return fetchImpl;
+  if (typeof globalThis.fetch === "function") {
+    return globalThis.fetch.bind(globalThis);
+  }
+  return null;
+}
+
+export function buildSynapseTaskSummary(prompt, maxLength = 100) {
+  if (maxLength <= 0) return "";
+  return String(prompt ?? "").slice(0, maxLength);
+}
+
+export function fireAndForgetSynapse(path, payload, opts = {}) {
+  const fetchImpl = resolveSynapseFetch(opts.fetchImpl);
+  if (!fetchImpl) return false;
+
+  try {
+    const url = new URL(
+      path,
+      opts.baseUrl || DEFAULT_SYNAPSE_BASE_URL,
+    ).toString();
+    Promise.resolve(
+      fetchImpl(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload),
+      }),
+    ).catch(() => {});
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function registerSynapseSession(meta, opts = {}) {
+  return fireAndForgetSynapse("/synapse/register", meta, opts);
+}
+
+export function heartbeatSynapseSession(
+  sessionId,
+  partialMeta = {},
+  opts = {},
+) {
+  return fireAndForgetSynapse(
+    "/synapse/heartbeat",
+    {
+      sessionId,
+      ...(partialMeta && typeof partialMeta === "object" ? partialMeta : {}),
+    },
+    opts,
+  );
+}
+
+export function unregisterSynapseSession(sessionId, opts = {}) {
+  return fireAndForgetSynapse("/synapse/unregister", { sessionId }, opts);
+}

package/hub/team/synapse-registry.mjs

@@ -0,0 +1,329 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+const DEFAULT_LOCAL_HEARTBEAT_INTERVAL_MS = 5_000;
+const DEFAULT_LOCAL_TIMEOUT_MS = 30_000;
+const DEFAULT_REMOTE_HEARTBEAT_INTERVAL_MS = 15_000;
+const DEFAULT_REMOTE_TIMEOUT_MS = 90_000;
+
+function normalizeSessionId(sessionId) {
+  if (sessionId == null) return "";
+  return String(sessionId).trim();
+}
+
+function cloneSession(session) {
+  return {
+    ...session,
+    dirtyFiles: Array.isArray(session.dirtyFiles)
+      ? [...session.dirtyFiles]
+      : [],
+  };
+}
+
+function sanitizeSession(raw, fallbackSessionId = "") {
+  const sessionId = normalizeSessionId(raw?.sessionId ?? fallbackSessionId);
+  if (!sessionId) return null;
+
+  return {
+    sessionId,
+    host: typeof raw?.host === "string" ? raw.host : "local",
+    worktreePath: typeof raw?.worktreePath === "string" ? raw.worktreePath : "",
+    branch: typeof raw?.branch === "string" ? raw.branch : "",
+    dirtyFiles: Array.isArray(raw?.dirtyFiles) ? [...raw.dirtyFiles] : [],
+    taskSummary: typeof raw?.taskSummary === "string" ? raw.taskSummary : "",
+    lastHeartbeat:
+      typeof raw?.lastHeartbeat === "number" ? raw.lastHeartbeat : Date.now(),
+    status:
+      raw?.status === "stale" || raw?.status === "expired"
+        ? raw.status
+        : "active",
+    isRemote: Boolean(raw?.isRemote),
+  };
+}
+
+export function createSynapseRegistry(opts = {}) {
+  const {
+    persistPath,
+    emitter = null,
+    localHeartbeatIntervalMs = DEFAULT_LOCAL_HEARTBEAT_INTERVAL_MS,
+    localTimeoutMs = DEFAULT_LOCAL_TIMEOUT_MS,
+    remoteHeartbeatIntervalMs = DEFAULT_REMOTE_HEARTBEAT_INTERVAL_MS,
+    remoteTimeoutMs = DEFAULT_REMOTE_TIMEOUT_MS,
+  } = opts;
+
+  const sessions = new Map();
+  const monitors = new Map();
+  const staleCallbacks = new Set();
+  const removedCallbacks = new Set();
+
+  function now() {
+    return Date.now();
+  }
+
+  function intervalFor(session) {
+    return session.isRemote
+      ? remoteHeartbeatIntervalMs
+      : localHeartbeatIntervalMs;
+  }
+
+  function timeoutFor(session) {
+    return session.isRemote ? remoteTimeoutMs : localTimeoutMs;
+  }
+
+  let persistTimer = null;
+  let destroyed = false;
+
+  function persist() {
+    if (!persistPath) return;
+    try {
+      mkdirSync(dirname(persistPath), { recursive: true });
+      const data = Object.fromEntries(
+        [...sessions].map(([k, v]) => [k, cloneSession(v)]),
+      );
+      writeFileSync(persistPath, JSON.stringify(data, null, 2), "utf8");
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  function schedulePersist() {
+    if (destroyed || persistTimer) return;
+    persistTimer = setTimeout(() => {
+      persistTimer = null;
+      if (!destroyed) persist();
+    }, 200);
+    if (typeof persistTimer.unref === "function") persistTimer.unref();
+  }
+
+  function restore() {
+    if (!persistPath || !existsSync(persistPath)) return;
+    try {
+      const data = JSON.parse(readFileSync(persistPath, "utf8"));
+      for (const [sessionId, session] of Object.entries(data)) {
+        const sanitized = sanitizeSession(session, sessionId);
+        if (sanitized) sessions.set(sanitized.sessionId, sanitized);
+      }
+    } catch {
+      /* corrupted file — start fresh */
+    }
+  }
+
+  function stopMonitor(sessionId) {
+    const timer = monitors.get(sessionId);
+    if (!timer) return;
+    clearInterval(timer);
+    monitors.delete(sessionId);
+  }
+
+  function notifyStale(session) {
+    const clone = cloneSession(session);
+    emitter?.emit("synapse.session.stale", {
+      sessionId: session.sessionId,
+      session: clone,
+    });
+    for (const callback of staleCallbacks) {
+      try {
+        callback(clone);
+      } catch {
+        /* no-op */
+      }
+    }
+  }
+
+  function notifyRemoved(session) {
+    const clone = cloneSession(session);
+    emitter?.emit("synapse.session.removed", {
+      sessionId: session.sessionId,
+      session: clone,
+    });
+    for (const callback of removedCallbacks) {
+      try {
+        callback(clone);
+      } catch {
+        /* no-op */
+      }
+    }
+  }
+
+  function startMonitor(sessionId) {
+    stopMonitor(sessionId);
+
+    const session = sessions.get(sessionId);
+    if (!session) return;
+
+    const timer = setInterval(() => {
+      const current = sessions.get(sessionId);
+      if (!current) return;
+
+      const elapsedMs = now() - current.lastHeartbeat;
+      if (elapsedMs > timeoutFor(current) && current.status !== "stale") {
+        const staled = { ...current, status: "stale" };
+        sessions.set(sessionId, staled);
+        schedulePersist();
+        setImmediate(() => {
+          if (!destroyed) notifyStale(staled);
+        });
+      }
+    }, intervalFor(session));
+
+    if (typeof timer.unref === "function") timer.unref();
+    monitors.set(sessionId, timer);
+  }
+
+  restore();
+  for (const sessionId of sessions.keys()) {
+    startMonitor(sessionId);
+  }
+
+  function register(sessionIdOrMeta, meta = null) {
+    const normalizedMeta =
+      meta && typeof meta === "object"
+        ? { ...meta, sessionId: sessionIdOrMeta }
+        : sessionIdOrMeta;
+    const sessionId = normalizeSessionId(normalizedMeta?.sessionId);
+    if (!sessionId) {
+      return { ok: false, sessionId, reason: "invalid_id" };
+    }
+
+    if (sessions.has(sessionId)) {
+      console.warn(
+        "[synapse-registry] duplicate registration rejected:",
+        sessionId,
+      );
+      return { ok: false, sessionId, reason: "duplicate" };
+    }
+
+    const session = sanitizeSession(
+      {
+        ...normalizedMeta,
+        sessionId,
+        status: "active",
+        lastHeartbeat: now(),
+      },
+      sessionId,
+    );
+
+    sessions.set(sessionId, session);
+    startMonitor(sessionId);
+    persist();
+
+    emitter?.emit("synapse.session.started", {
+      sessionId,
+      session: cloneSession(session),
+    });
+    return { ok: true, sessionId };
+  }
+
+  function unregister(sessionId) {
+    const normalized = normalizeSessionId(sessionId);
+    const session = sessions.get(normalized);
+    if (!session) return false;
+
+    stopMonitor(normalized);
+    sessions.delete(normalized);
+    persist();
+    notifyRemoved(session);
+    return true;
+  }
+
+  function heartbeat(sessionId, partialMeta = null) {
+    const normalized = normalizeSessionId(sessionId);
+    const session = sessions.get(normalized);
+    if (!session) return false;
+
+    const wasRemote = session.isRemote;
+    const updated = { ...session, lastHeartbeat: now(), status: "active" };
+
+    if (partialMeta && typeof partialMeta === "object") {
+      if (typeof partialMeta.host === "string") updated.host = partialMeta.host;
+      if (typeof partialMeta.worktreePath === "string") {
+        updated.worktreePath = partialMeta.worktreePath;
+      }
+      if (typeof partialMeta.branch === "string")
+        updated.branch = partialMeta.branch;
+      if (Array.isArray(partialMeta.dirtyFiles)) {
+        updated.dirtyFiles = partialMeta.dirtyFiles.filter(
+          (f) => typeof f === "string" && f.length > 0,
+        );
+      }
+      if (typeof partialMeta.taskSummary === "string") {
+        updated.taskSummary = partialMeta.taskSummary;
+      }
+      if (typeof partialMeta.isRemote === "boolean") {
+        updated.isRemote = partialMeta.isRemote;
+      }
+    }
+
+    sessions.set(normalized, updated);
+
+    if (updated.isRemote !== wasRemote) {
+      startMonitor(normalized);
+    }
+
+    schedulePersist();
+    emitter?.emit("synapse.session.heartbeat", {
+      sessionId: normalized,
+      session: cloneSession(updated),
+      partial: partialMeta,
+    });
+    return true;
+  }
+
+  function getActive() {
+    return [...sessions.values()]
+      .filter((session) => session.status === "active")
+      .map((session) => cloneSession(session));
+  }
+
+  function getAll() {
+    return [...sessions.values()].map((session) => cloneSession(session));
+  }
+
+  function getSession(sessionId) {
+    const normalized = normalizeSessionId(sessionId);
+    if (!normalized) return null;
+    const session = sessions.get(normalized);
+    return session ? cloneSession(session) : null;
+  }
+
+  function onStale(callback) {
+    if (typeof callback !== "function") return;
+    staleCallbacks.add(callback);
+  }
+
+  function onRemoved(callback) {
+    if (typeof callback !== "function") return;
+    removedCallbacks.add(callback);
+  }
+
+  function snapshot() {
+    return {
+      sessions: getAll(),
+    };
+  }
+
+  function destroy() {
+    destroyed = true;
+    for (const sessionId of monitors.keys()) {
+      stopMonitor(sessionId);
+    }
+    if (persistTimer) {
+      clearTimeout(persistTimer);
+      persistTimer = null;
+    }
+    persist();
+  }
+
+  return Object.freeze({
+    register,
+    unregister,
+    heartbeat,
+    getActive,
+    getAll,
+    getSession,
+    onStale,
+    onRemoved,
+    snapshot,
+    destroy,
+  });
+}

package/hub/team/terminal-opener.mjs

@@ -0,0 +1,216 @@
+import { exec as defaultExec, spawnSync } from "node:child_process";
+import { platform as osPlatform } from "node:os";
+import { psmuxExec as defaultPsmuxExec } from "./psmux.mjs";
+import { tmuxExec as defaultTmuxExec, detectMultiplexer } from "./session.mjs";
+import { createWtManager as defaultCreateWtManager } from "./wt-manager.mjs";
+
+const TMUX_LIKE_MUXES = new Set(["tmux", "git-bash-tmux"]);
+
+export function sanitizeTerminalTitle(value, fallback = "triflux") {
+  const title = String(value ?? "")
+    .replace(/\s+/gu, " ")
+    .trim();
+  return title || fallback;
+}
+
+export function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+export function powershellSingleQuote(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+export function buildCommandString({ cwd, command }) {
+  const commandString = String(command ?? "");
+  if (!cwd) return commandString;
+  return `cd ${shellQuote(cwd)} && ${commandString}`;
+}
+
+function resolvePlatform(deps) {
+  if (typeof deps.platform === "function") return deps.platform();
+  return deps.platform || osPlatform();
+}
+
+function resolveMux(deps) {
+  if (Object.hasOwn(deps, "mux")) return deps.mux;
+  if (typeof deps.detectMultiplexer === "function")
+    return deps.detectMultiplexer();
+  return detectMultiplexer();
+}
+
+function createTabSpec(spec, title) {
+  return {
+    title,
+    command: String(spec.command ?? ""),
+    cwd: spec.cwd,
+    profile: spec.profile ?? "triflux",
+  };
+}
+
+function execOpenTerminal(execFn) {
+  return new Promise((resolve) => {
+    execFn("open -a Terminal", { timeout: 5000 }, (error) => {
+      resolve(!error);
+    });
+  });
+}
+
+// psmux는 Windows에서 wt-manager 경유 (createTab/splitPane 등) — tmux 호환 unix 명령군과 다른 표면.
+// 비-Windows(macOS/Linux) 환경에서는 psmux가 tmux-compatible new-window/select-pane 명령을 받아주므로
+// tmux 어댑터와 동일하게 취급한다.
+function isTmuxLikeMux(mux, platform) {
+  return TMUX_LIKE_MUXES.has(mux) || (platform !== "win32" && mux === "psmux");
+}
+
+function shellCommandName(value) {
+  const command = String(value);
+  return /^[A-Za-z0-9_./:-]+$/u.test(command) ? command : shellQuote(command);
+}
+
+function powershellCommandName(value) {
+  const command = String(value);
+  return /^[A-Za-z0-9_.:-]+$/u.test(command)
+    ? command
+    : `& ${powershellSingleQuote(command)}`;
+}
+
+function getCommandVersion(command) {
+  const r = spawnSync(command, ["-V"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 3000,
+    windowsHide: true,
+  });
+  if ((r.status ?? 1) !== 0) return null;
+  return `${r.stdout || ""}${r.stderr || ""}`.trim();
+}
+
+function defaultPsmuxBinaryExists(command) {
+  try {
+    return /\bpsmux\b/i.test(getCommandVersion(command) || "");
+  } catch {
+    return false;
+  }
+}
+
+function buildAttachCommand(mux, sessionName, deps = {}) {
+  if (mux === "psmux") {
+    const command = process.env.PSMUX_BIN || "psmux";
+    const psmuxBinaryExists =
+      deps.psmuxBinaryExists || defaultPsmuxBinaryExists;
+    if (!psmuxBinaryExists(command)) return null;
+    return `${shellCommandName(command)} attach-session -t ${shellQuote(sessionName)}`;
+  }
+  return `tmux attach-session -t ${shellQuote(sessionName)}`;
+}
+
+// wt-manager.createTab은 (a) undefined/void 반환 — legacy success 의미 (b) {success:true|false, ...} 객체 반환의 두 형태가 공존.
+// `result?.success !== false`는 undefined/null/{}을 모두 success로 취급하고 명시적 {success:false}만 실패로 본다.
+function wtResultSucceeded(result) {
+  return result?.success !== false;
+}
+
+export function createTerminalOpener(deps = {}) {
+  const platform = resolvePlatform(deps);
+  const tmuxExec = deps.tmuxExec || defaultTmuxExec;
+  const psmuxExec = deps.psmuxExec || defaultPsmuxExec;
+  const exec = deps.exec || defaultExec;
+  const createWtManager = deps.createWtManager || defaultCreateWtManager;
+
+  async function openCommand(spec = {}) {
+    const title = sanitizeTerminalTitle(spec.title);
+
+    if (platform === "win32") {
+      const wt = createWtManager();
+      try {
+        return wtResultSucceeded(
+          await wt.createTab(createTabSpec(spec, title)),
+        );
+      } catch {
+        return false;
+      }
+    }
+
+    const mux = resolveMux(deps);
+    if (isTmuxLikeMux(mux, platform)) {
+      tmuxExec(
+        `new-window -n ${shellQuote(title)} ${shellQuote(
+          buildCommandString(spec),
+        )}`,
+      );
+      return true;
+    }
+
+    if (platform === "darwin") {
+      return execOpenTerminal(exec);
+    }
+
+    return false;
+  }
+
+  async function openSession(sessionName, opts = {}) {
+    if (platform === "win32") {
+      const command = process.env.PSMUX_BIN || "psmux";
+      const psmuxBinaryExists =
+        deps.psmuxBinaryExists || defaultPsmuxBinaryExists;
+      if (!psmuxBinaryExists(command)) return false;
+      const wt = createWtManager();
+      try {
+        return wtResultSucceeded(
+          await wt.createTab({
+            title: sanitizeTerminalTitle(opts.title ?? sessionName),
+            command: `${powershellCommandName(
+              command,
+            )} attach-session -t ${powershellSingleQuote(sessionName)}`,
+            cwd: opts.cwd,
+            profile: opts.profile ?? "triflux",
+          }),
+        );
+      } catch {
+        return false;
+      }
+    }
+
+    const mux = resolveMux(deps);
+    if (isTmuxLikeMux(mux, platform)) {
+      const attachCommand = buildAttachCommand(mux, sessionName, deps);
+      if (!attachCommand) return false;
+      tmuxExec(
+        `new-window -n ${shellQuote(opts.title ?? sessionName)} ${shellQuote(
+          attachCommand,
+        )}`,
+      );
+      return true;
+    }
+
+    return false;
+  }
+
+  function focusPane(sessionName, workerNumber) {
+    const target = `${sessionName}:0.${workerNumber}`;
+    const mux = resolveMux(deps);
+
+    if (mux === "psmux") {
+      psmuxExec(["select-pane", "-t", target]);
+      return true;
+    }
+
+    if (isTmuxLikeMux(mux, platform)) {
+      tmuxExec(`select-pane -t ${shellQuote(target)}`);
+      return true;
+    }
+
+    return false;
+  }
+
+  return { openCommand, openSession, focusPane };
+}
+
+export function openSessionTarget(sessionName, opts = {}) {
+  return createTerminalOpener(opts._deps).openSession(sessionName, opts);
+}
+
+export function focusSessionPane(sessionName, workerNumber, opts = {}) {
+  return createTerminalOpener(opts._deps).focusPane(sessionName, workerNumber);
+}