@triflux/remote 10.27.0 → 10.28.1

package/hub/team/claude-daemon-control.mjs

@@ -1,8 +1,60 @@
+import { execFileSync } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
+import {
+  buildClaudeSessionProjection,
+  removeClaudeSessionProjection,
+  writeClaudeSessionProjection,
+} from "./claude-session-projection.mjs";
+
+export function buildClaudePromptDispatchPayload({
+  short = crypto.randomBytes(4).toString("hex"),
+  sessionId,
+  cwd = process.cwd(),
+  prompt,
+  name = "tfx uds claude prompt",
+  createdAt = Date.now(),
+  cols = 120,
+  rows = 40,
+} = {}) {
+  if (!prompt) throw new Error("prompt is required");
+  const uuid = crypto.randomUUID();
+  const resolvedSessionId = sessionId || `${short}${uuid.slice(8)}`;
+  return {
+    proto: 1,
+    short,
+    sessionId: resolvedSessionId,
+    createdAt,
+    source: "shell",
+    cwd,
+    agent: "claude",
+    launch: {
+      mode: "prompt",
+      args: [
+        "--session-id",
+        resolvedSessionId,
+        "--agent",
+        "claude",
+        "--permission-mode",
+        "auto",
+        "--",
+        prompt,
+      ],
+    },
+    env: {},
+    isolation: "none",
+    respawnFlags: [],
+    seed: {
+      intent: "[redacted uds orchestration prompt]",
+      name,
+    },
+    cols,
+    rows,
+  };
+}
 
 export function resolveClaudeConfigDir(env = process.env) {
   if (env.CLAUDE_CONFIG_DIR) return path.resolve(env.CLAUDE_CONFIG_DIR);
@@ -26,12 +78,23 @@ export function deriveClaudeDaemonPaths({
     hash,
     daemonDir,
     controlSock: path.join(daemonDir, "control.sock"),
+    rendezvousDir: path.join(daemonDir, "rv"),
+    ptyDir: path.join(daemonDir, "pty"),
     rosterPath: path.join(resolvedConfigDir, "daemon", "roster.json"),
     sessionsDir: path.join(resolvedConfigDir, "sessions"),
     jobsDir: path.join(resolvedConfigDir, "jobs"),
   };
 }
 
+export function getProcStart(pid = process.pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    throw new Error(`invalid pid: ${pid}`);
+  return execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+    encoding: "utf8",
+    env: { ...process.env, LC_ALL: "C", TZ: "UTC" },
+  }).trim();
+}
+
 export function readFirstJsonLine(text) {
   const line = String(text)
     .split("\n")
@@ -1128,3 +1191,154 @@ export async function sendKillBySessionId({
     };
   }
 }
+
+/**
+ * Claude 데몬 dispatch 한 건의 공통 시퀀스를 캡슐화한다.
+ * dispatch → waitForDaemonJobPid → resolveDaemonBridgeSessionId →
+ * buildClaudeSessionProjection → writeClaudeSessionProjection.
+ *
+ * 호출 측이 reference 로 들고 있는 record 를 헬퍼가 새로 만들지 않도록
+ * plain 필드만 반환한다. caller 는 이 결과를 자기 record 에 Object.assign 한다.
+ *
+ * @returns {Promise<{ok:boolean, short:string, sessionId:string, job:object,
+ *   pid:number, bridgeSessionId:string, sessionProjectionPath:string,
+ *   controlSock:string, paths:object}>}
+ */
+export async function dispatchClaudeDaemonJob({
+  paths,
+  controlSock,
+  payload,
+  agent,
+  name,
+  cwd,
+  projection = "write",
+  dispatchTimeoutMs = 5000,
+  pidTimeoutMs,
+  bridgeTimeoutMs,
+  accessControlSock,
+  _deps = {},
+} = {}) {
+  if (!payload) throw new Error("payload is required");
+  if (!payload.short) throw new Error("payload.short is required");
+  const resolvedControlSock = controlSock || paths?.controlSock;
+  if (!resolvedControlSock) throw new Error("controlSock is required");
+
+  const sendControl =
+    _deps.sendClaudeControlRequest || sendClaudeControlRequest;
+  const waitForPid = _deps.waitForDaemonJobPid || waitForDaemonJobPid;
+  const resolveBridgeSessionId =
+    _deps.resolveDaemonBridgeSessionId || resolveDaemonBridgeSessionId;
+  const buildProjection =
+    _deps.buildClaudeSessionProjection || buildClaudeSessionProjection;
+  const writeProjection =
+    _deps.writeClaudeSessionProjection || writeClaudeSessionProjection;
+  const readProcStart = _deps.getProcStart || getProcStart;
+
+  const short = payload.short;
+  const sessionsDir =
+    paths?.sessionsDir ||
+    (paths?.configDir ? path.join(paths.configDir, "sessions") : "");
+
+  // native-bridge 는 control.sock 존재를 미리 점검한다 (없으면 fast-fail).
+  if (accessControlSock) await accessControlSock(resolvedControlSock);
+
+  const dispatch = await sendControl(
+    resolvedControlSock,
+    {
+      proto: 1,
+      op: "dispatch",
+      d: payload,
+      timeoutMs: dispatchTimeoutMs,
+    },
+    { timeoutMs: dispatchTimeoutMs },
+  );
+  if (dispatch?.ok !== true) {
+    throw new Error(`Claude daemon dispatch failed for ${name || short}`);
+  }
+
+  const pidOpts =
+    pidTimeoutMs === undefined ? undefined : { timeoutMs: pidTimeoutMs };
+  const job = await waitForPid(resolvedControlSock, short, pidOpts);
+  const pid = job.pid;
+  const bridgeSessionId = await resolveBridgeSessionId({
+    daemonPaths: paths,
+    short,
+    job,
+    ...(bridgeTimeoutMs === undefined ? {} : { timeoutMs: bridgeTimeoutMs }),
+  });
+
+  let sessionProjectionPath = "";
+  if (projection !== "skip") {
+    const projectionRecord = buildProjection({
+      pid,
+      procStart: readProcStart(pid),
+      sessionId: payload.sessionId,
+      short,
+      cwd,
+      name,
+      agent,
+      startedAt: job.startedAt || Date.now(),
+      updatedAt: Date.now(),
+      bridgeSessionId,
+    });
+    sessionProjectionPath = await writeProjection(
+      sessionsDir,
+      projectionRecord,
+    );
+  }
+
+  return {
+    ok: true,
+    short,
+    sessionId: payload.sessionId,
+    job,
+    pid,
+    bridgeSessionId,
+    sessionProjectionPath,
+    controlSock: resolvedControlSock,
+    paths,
+  };
+}
+
+/**
+ * dispatchClaudeDaemonJob 의 대칭 정리 경로.
+ * removeProjection + killDaemonJob (+ optional removeClaudeJobState) 를
+ * 모두 시도하며, 각 스텝 오류는 기존 close()/cleanupDaemonDispatches 와
+ * 동일하게 .catch 로 삼킨다.
+ */
+export async function teardownClaudeDaemonJob({
+  controlSock,
+  paths,
+  short,
+  sessionProjectionPath,
+  sessionId,
+  jobsDir,
+  removeJobState = false,
+  _deps = {},
+} = {}) {
+  const removeProjection =
+    _deps.removeClaudeSessionProjection || removeClaudeSessionProjection;
+  const killJob = _deps.killDaemonJob || killDaemonJob;
+  const removeJobStateImpl = _deps.removeClaudeJobState;
+  const resolvedControlSock = controlSock || paths?.controlSock;
+  const resolvedJobsDir =
+    jobsDir ||
+    paths?.jobsDir ||
+    (paths?.configDir ? path.join(paths.configDir, "jobs") : "");
+
+  const steps = [];
+  if (sessionProjectionPath) {
+    steps.push(removeProjection(sessionProjectionPath).catch(() => {}));
+  }
+  if (sessionId && (paths?.controlSock || resolvedControlSock)) {
+    const daemonPaths = paths || { controlSock: resolvedControlSock };
+    steps.push(sendKillBySessionId({ daemonPaths, sessionId }).catch(() => {}));
+  }
+  if (resolvedControlSock && short) {
+    steps.push(killJob(resolvedControlSock, short).catch(() => {}));
+  }
+  if (removeJobState && removeJobStateImpl && resolvedJobsDir && short) {
+    steps.push(removeJobStateImpl(resolvedJobsDir, short).catch(() => {}));
+  }
+  await Promise.all(steps);
+}

package/hub/team/claude-native-bridge.mjs

@@ -1,4 +1,4 @@
-import { execFileSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import net from "node:net";
@@ -6,9 +6,13 @@ import os from "node:os";
 import path from "node:path";
 import {
   buildDaemonExecDispatchPayload,
+  deriveClaudeDaemonPaths,
+  dispatchClaudeDaemonJob,
+  getProcStart,
   killDaemonJob,
   resolveDaemonBridgeSessionId,
   sendClaudeControlRequest,
+  teardownClaudeDaemonJob,
   waitForDaemonJobPid,
 } from "./claude-daemon-control.mjs";
 import {
@@ -18,6 +22,10 @@ import {
 } from "./claude-session-projection.mjs";
 import { createInteractiveTuiTransport } from "./interactive-tui-transport.mjs";
 
+// daemon-control 이 deriveClaudeDaemonPaths / getProcStart 의 단일 owner 다.
+// 기존 native-bridge import 경로 (headless 포함) 호환을 위해 re-export 한다.
+export { deriveClaudeDaemonPaths, getProcStart };
+
 const DEFAULT_ROWS = 40;
 const DEFAULT_COLS = 120;
 const MAX_TRANSCRIPT_BYTES = 64 * 1024;
@@ -30,39 +38,6 @@ export function resolveClaudeConfigDir(env = process.env) {
   return path.join(os.homedir(), ".claude");
 }
 
-export function deriveClaudeDaemonPaths({
-  configDir = resolveClaudeConfigDir(),
-  uid = typeof process.getuid === "function" ? process.getuid() : 0,
-  tmpRoot = "/tmp",
-} = {}) {
-  const resolvedConfigDir = path.resolve(configDir);
-  const hash = crypto
-    .createHash("sha256")
-    .update(resolvedConfigDir)
-    .digest("hex")
-    .slice(0, 8);
-  const daemonDir = path.join(tmpRoot, `cc-daemon-${uid}`, hash);
-  return {
-    configDir: resolvedConfigDir,
-    daemonDir,
-    controlSock: path.join(daemonDir, "control.sock"),
-    rendezvousDir: path.join(daemonDir, "rv"),
-    ptyDir: path.join(daemonDir, "pty"),
-    rosterPath: path.join(resolvedConfigDir, "daemon", "roster.json"),
-    sessionsDir: path.join(resolvedConfigDir, "sessions"),
-    jobsDir: path.join(resolvedConfigDir, "jobs"),
-  };
-}
-
-export function getProcStart(pid = process.pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    throw new Error(`invalid pid: ${pid}`);
-  return execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
-    encoding: "utf8",
-    env: { ...process.env, LC_ALL: "C", TZ: "UTC" },
-  }).trim();
-}
-
 export function buildPtyDataFrame(value) {
   const payload = Buffer.isBuffer(value) ? value : Buffer.from(value, "utf8");
   const frame = Buffer.allocUnsafe(5 + payload.length);
@@ -379,6 +354,8 @@ export async function registerSwarmShard({
   const removeJobStateImpl = _deps.removeClaudeJobState || removeClaudeJobState;
   const killJob = _deps.killDaemonJob || killDaemonJob;
   const accessControlSock = _deps.accessControlSock || fs.access;
+  const dispatchJob = _deps.dispatchClaudeDaemonJob || dispatchClaudeDaemonJob;
+  const teardownJob = _deps.teardownClaudeDaemonJob || teardownClaudeDaemonJob;
 
   const paths = derivePaths({ configDir, tmpRoot });
   const sessionsDir =
@@ -487,44 +464,30 @@ export async function registerSwarmShard({
     name: displayName,
   });
 
-  await accessControlSock(paths.controlSock);
-  const dispatch = await sendControl(
-    paths.controlSock,
-    {
-      proto: 1,
-      op: "dispatch",
-      d: payload,
-      timeoutMs: 1000,
-    },
-    { timeoutMs: 1000 },
-  );
-  if (dispatch?.ok !== true) {
-    throw new Error(
-      `Claude daemon dispatch failed for swarm shard ${shardName}`,
-    );
-  }
-
-  const job = await waitForPid(paths.controlSock, short, { timeoutMs: 1000 });
-  const pid = job.pid;
-  const bridgeSessionId = await resolveBridgeSessionId({
-    daemonPaths: paths,
-    short,
-    job,
-    timeoutMs: 1000,
-  });
-  const projection = buildProjection({
-    pid,
-    procStart: readProcStart(pid),
-    sessionId: payload.sessionId,
-    short,
-    cwd,
-    name: displayName,
+  // native-bridge 는 데몬이 없으면 빠르게 실패해야 하므로 1000ms 로 고정한다
+  // (headless 의 5000ms 와 다르므로 명시 전달).
+  const dispatched = await dispatchJob({
+    paths,
+    controlSock: paths.controlSock,
+    payload,
     agent: cli,
-    startedAt: job.startedAt || Date.now(),
-    updatedAt: Date.now(),
-    bridgeSessionId,
+    name: displayName,
+    cwd,
+    dispatchTimeoutMs: 1000,
+    pidTimeoutMs: 1000,
+    bridgeTimeoutMs: 1000,
+    accessControlSock,
+    _deps: {
+      sendClaudeControlRequest: sendControl,
+      waitForDaemonJobPid: waitForPid,
+      resolveDaemonBridgeSessionId: resolveBridgeSessionId,
+      buildClaudeSessionProjection: buildProjection,
+      writeClaudeSessionProjection: writeProjection,
+      getProcStart: readProcStart,
+    },
   });
-  const sessionProjectionPath = await writeProjection(sessionsDir, projection);
+  const sessionProjectionPath = dispatched.sessionProjectionPath;
+  void sessionsDir;
   let closed = false;
 
   return {
@@ -543,9 +506,18 @@ export async function registerSwarmShard({
     async close() {
       if (closed) return;
       closed = true;
-      await removeProjection(sessionProjectionPath).catch(() => {});
-      await killJob(paths.controlSock, short).catch(() => {});
-      await removeJobStateImpl(jobsDir, short).catch(() => {});
+      await teardownJob({
+        controlSock: paths.controlSock,
+        short,
+        sessionProjectionPath,
+        jobsDir,
+        removeJobState: true,
+        _deps: {
+          removeClaudeSessionProjection: removeProjection,
+          killDaemonJob: killJob,
+          removeClaudeJobState: removeJobStateImpl,
+        },
+      });
     },
   };
 }

package/hub/team/daemon-pty-tmux-bridge.mjs

@@ -0,0 +1,146 @@
+import { pathToFileURL } from "node:url";
+
+import { createInteractiveTuiTransport } from "./interactive-tui-transport.mjs";
+
+const DEFAULT_COLS = 120;
+const DEFAULT_ROWS = 40;
+const SIGNAL_EXIT_CODES = new Map([
+  ["SIGHUP", 129],
+  ["SIGINT", 130],
+  ["SIGTERM", 143],
+]);
+
+export function encodeBridgeConfig(config) {
+  return Buffer.from(JSON.stringify(config), "utf8").toString("base64");
+}
+
+export function parseBridgeConfig(argv = []) {
+  const index = argv.indexOf("--config");
+  if (index < 0 || !argv[index + 1]) {
+    throw new Error("--config <base64-json> is required");
+  }
+  return JSON.parse(Buffer.from(argv[index + 1], "base64").toString("utf8"));
+}
+
+export async function runBridge({
+  config,
+  stdin,
+  stdout,
+  signals,
+  createTransport = createInteractiveTuiTransport,
+} = {}) {
+  if (!config?.sessionName) throw new Error("config.sessionName is required");
+  if (!stdin) throw new Error("stdin is required");
+  if (!stdout) throw new Error("stdout is required");
+  if (!signals) throw new Error("signals is required");
+
+  const transport = createTransport({
+    sessionName: config.sessionName,
+    cwd: config.cwd,
+    launchCmd: config.launchCmd,
+    env: config.env || {},
+    onData: (chunk) => stdout.write(chunk),
+  });
+  let shutdownPromise = null;
+
+  const currentSize = () => ({
+    cols: stdout.columns || config.cols || DEFAULT_COLS,
+    rows: stdout.rows || config.rows || DEFAULT_ROWS,
+  });
+
+  const shutdown = async ({ exitCode, exitProcess = false } = {}) => {
+    if (!shutdownPromise) {
+      shutdownPromise = (async () => {
+        unregister();
+        await transport.stop();
+      })();
+    }
+    await shutdownPromise;
+    if (exitProcess && typeof signals.exit === "function") {
+      signals.exit(exitCode ?? 0);
+    }
+  };
+
+  const writeInput = (chunk) => {
+    void transport.writeInput(chunk).catch(() => {
+      void shutdown({ exitCode: 1, exitProcess: true });
+    });
+  };
+  const resize = () => {
+    void transport.resize(currentSize()).catch(() => {
+      void shutdown({ exitCode: 1, exitProcess: true });
+    });
+  };
+  const stdinEnd = () => {
+    void shutdown({ exitCode: 0, exitProcess: true });
+  };
+  const signalHandlers = new Map(
+    [...SIGNAL_EXIT_CODES].map(([signal, exitCode]) => [
+      signal,
+      () => {
+        void shutdown({ exitCode, exitProcess: true });
+      },
+    ]),
+  );
+  const uncaughtException = () => {
+    void shutdown({ exitCode: 1, exitProcess: true });
+  };
+  const beforeExit = () => {
+    void shutdown();
+  };
+  const exit = () => {
+    void shutdown();
+  };
+
+  function unregister() {
+    stdin.off?.("data", writeInput);
+    stdin.off?.("end", stdinEnd);
+    stdout.off?.("resize", resize);
+    signals.off?.("uncaughtException", uncaughtException);
+    signals.off?.("beforeExit", beforeExit);
+    signals.off?.("exit", exit);
+    for (const [signal, handler] of signalHandlers) {
+      signals.off?.(signal, handler);
+    }
+  }
+
+  stdin.on("data", writeInput);
+  stdin.on("end", stdinEnd);
+  stdout.on?.("resize", resize);
+  signals.on?.("uncaughtException", uncaughtException);
+  signals.on?.("beforeExit", beforeExit);
+  signals.on?.("exit", exit);
+  for (const [signal, handler] of signalHandlers) {
+    signals.on?.(signal, handler);
+  }
+
+  try {
+    await transport.start();
+    await transport.resize(currentSize());
+  } catch (error) {
+    await shutdown().catch(() => {});
+    throw error;
+  }
+
+  return { shutdown };
+}
+
+async function main() {
+  const config = parseBridgeConfig(process.argv.slice(2));
+  await runBridge({
+    config,
+    stdin: process.stdin,
+    stdout: process.stdout,
+    signals: process,
+  });
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  main().catch((error) => {
+    console.error(error?.stack || error?.message || String(error));
+    process.exit(1);
+  });
+}

package/hub/team/headless.mjs

@@ -28,21 +28,12 @@ import { getBackend } from "./backend.mjs";
 import {
   buildDaemonExecDispatchPayload,
   deriveClaudeDaemonPaths as deriveClaudeControlPaths,
+  dispatchClaudeDaemonJob,
   killDaemonJob,
-  resolveDaemonBridgeSessionId,
-  sendClaudeControlRequest,
   sendKillBySessionId,
-  waitForDaemonJobPid,
 } from "./claude-daemon-control.mjs";
-import {
-  getProcStart,
-  startClaudeNativeBridge,
-} from "./claude-native-bridge.mjs";
-import {
-  buildClaudeSessionProjection,
-  removeClaudeSessionProjection,
-  writeClaudeSessionProjection,
-} from "./claude-session-projection.mjs";
+import { startClaudeNativeBridge } from "./claude-native-bridge.mjs";
+import { removeClaudeSessionProjection } from "./claude-session-projection.mjs";
 import { resolveDashboardLayout } from "./dashboard-layout.mjs";
 import {
   formatHandoffForLead,
@@ -1016,40 +1007,30 @@ async function dispatchDaemonBatch(sessionName, assignments, opts = {}) {
         name,
       });
       record.sessionId = payload.sessionId;
-      const dispatch = await sendClaudeControlRequest(paths.controlSock, {
-        proto: 1,
-        op: "dispatch",
-        d: payload,
-        timeoutMs: 5000,
-      });
-      if (dispatch?.ok !== true) {
+      // buildDaemonWrappedCommand + token completion 시맨틱은 헬퍼 밖(headless 전용)에
+      // 남기고, dispatch→pid→bridge→projection 시퀀스만 공유 헬퍼로 위임한다.
+      // CRITICAL: waitForDaemonCompletion 이 나중에 record.daemonCompletionMatched 를
+      // 변경하고 cleanupDaemonDispatches 가 같은 record 를 읽으므로, 헬퍼가 새 객체를
+      // 반환해도 record 를 교체하지 말고 plain 필드를 Object.assign 한다.
+      const dispatched = await dispatchClaudeDaemonJob({
+        paths,
+        controlSock: paths.controlSock,
+        payload,
+        agent: resolvedCli || "codex",
+        name,
+        cwd: assignment.cwd || assignment.workdir || process.cwd(),
+        dispatchTimeoutMs: 5000,
+      }).catch((error) => {
         throw new Error(
-          `[headless] Claude daemon dispatch failed for ${paneName}`,
+          `[headless] Claude daemon dispatch failed for ${paneName}: ${
+            error?.message || error
+          }`,
         );
-      }
-
-      const job = await waitForDaemonJobPid(paths.controlSock, short);
-      const bridgeSessionId = await resolveDaemonBridgeSessionId({
-        daemonPaths: paths,
-        short,
-        job,
       });
-      const projection = buildClaudeSessionProjection({
-        pid: job.pid,
-        procStart: getProcStart(job.pid),
-        sessionId: payload.sessionId,
-        short,
-        cwd: assignment.cwd || assignment.workdir || process.cwd(),
-        name,
-        agent: resolvedCli || "codex",
-        startedAt: job.startedAt || Date.now(),
-        updatedAt: Date.now(),
-        bridgeSessionId,
+      Object.assign(record, {
+        sessionId: dispatched.sessionId,
+        sessionProjectionPath: dispatched.sessionProjectionPath,
       });
-      record.sessionProjectionPath = await writeClaudeSessionProjection(
-        paths.sessionsDir,
-        projection,
-      );
       await registerHeadlessWorker(sessionName, i, resolvedCli);
       registerHeadlessSynapseWorker(workerId, assignment.prompt);
       if (safeProgress) {