@triflux/remote 10.51.0 → 10.53.0

package/hub/workers/lib/jsonrpc-stdio.mjs

@@ -1,204 +0,0 @@
-// hub/workers/lib/jsonrpc-stdio.mjs
-// Minimal line-delimited JSON-RPC 2.0 client over stdio.
-// Replaces vscode-jsonrpc for the codex app-server transport.
-//
-// Wire format (Issue #95 P1 #1): OpenAI App Server JSONL variant omits the
-// top-level `"jsonrpc": "2.0"` header on outbound frames. Inbound decode is
-// lenient — frames with or without the header are accepted for forward compat.
-//
-// Contract:
-//   new JsonRpcStdioClient({ stdin, stdout, onError, maxLineSize })
-//   request(method, params, timeoutMs=60000) -> Promise<result>
-//   notify(method, params) -> void
-//   onNotification(method, cb) -> unsubscribe()      ('*' = catch-all)
-//   close(reason) -> void (idempotent; optional reason marks closing state)
-//   isOpen() -> boolean
-//
-// Lifecycle (Issue #95 P1 #3):
-//   State machine: running | closing | closed
-//   - `running` is the default. Parse/EOF/max-line errors reject in-flight
-//     requests and transition to `closed`.
-//   - `closing` is entered via `close("closing")` before a graceful shutdown;
-//     EOF in `closing` is a normal termination and does NOT fail-fast.
-//
-// AC18: any single line whose raw-byte length would exceed maxLineSize is
-// rejected at the stream layer (before readline emits it) to defend against
-// OOM/DoS from an unresponsive or malicious peer.
-
-import { createInterface } from "node:readline";
-
-import { JsonRpcDispatchBase } from "./jsonrpc-core.mjs";
-
-export { JsonRpcProtocolError } from "./jsonrpc-core.mjs";
-
-const DEFAULT_MAX_LINE_SIZE = 1024 * 1024; // 1 MiB
-const CLOSED_MESSAGE = "JsonRpcStdioClient closed";
-
-/**
- * Thrown (via onError) when an inbound line would exceed maxLineSize.
- */
-export class MaxLineSizeExceededError extends Error {
-  /**
-   * @param {number} size Bytes observed so far in the offending line.
-   * @param {number} max  Configured max.
-   */
-  constructor(size, max) {
-    super(`JSON-RPC line exceeded max size: ${size} > ${max}`);
-    this.name = "MaxLineSizeExceededError";
-    this.size = size;
-    this.max = max;
-  }
-}
-
-/**
- * Thrown when the underlying stream closes unexpectedly (EOF outside `closing`).
- */
-export class JsonRpcTransportError extends Error {
-  /** @param {string} message @param {{ cause?: unknown }} [options] */
-  constructor(message, options = {}) {
-    super(message, { cause: options.cause });
-    this.name = "JsonRpcTransportError";
-  }
-}
-
-/**
- * Line-delimited JSON-RPC 2.0 client over a pair of Node streams.
- */
-export class JsonRpcStdioClient extends JsonRpcDispatchBase {
-  /**
-   * @param {object} options
-   * @param {NodeJS.ReadableStream} options.stdin Server -> client bytes.
-   * @param {NodeJS.WritableStream} options.stdout Client -> server bytes.
-   * @param {(err: Error) => void} [options.onError] Protocol error sink.
-   * @param {number} [options.maxLineSize] Max bytes per inbound line.
-   */
-  constructor({ stdin, stdout, onError, maxLineSize = DEFAULT_MAX_LINE_SIZE }) {
-    if (!stdin || typeof stdin.on !== "function") {
-      throw new TypeError("JsonRpcStdioClient requires a readable stdin");
-    }
-    if (!stdout || typeof stdout.write !== "function") {
-      throw new TypeError("JsonRpcStdioClient requires a writable stdout");
-    }
-
-    super({ onError, closedMessage: CLOSED_MESSAGE });
-
-    this._stdin = stdin;
-    this._stdout = stdout;
-    this._maxLineSize =
-      Number.isFinite(maxLineSize) && maxLineSize > 0
-        ? maxLineSize
-        : DEFAULT_MAX_LINE_SIZE;
-
-    /** @type {'running'|'closing'|'closed'} */
-    this._state = "running";
-
-    // AC18: track bytes since last newline at the raw stream layer so an
-    // oversized line is rejected *before* readline concatenates it internally.
-    this._pendingLineSize = 0;
-    this._oversized = false;
-
-    this._onStdinData = (chunk) => this._trackRawBytes(chunk);
-    this._stdin.on("data", this._onStdinData);
-
-    // Without these handlers, an EPIPE/ERR_STREAM_DESTROYED on either pipe
-    // would bubble up as an unhandled 'error' and take down the hub process.
-    this._onStdinError = (err) => this._handleStreamError("stdin", err);
-    this._onStdoutError = (err) => this._handleStreamError("stdout", err);
-    if (typeof this._stdin.on === "function") {
-      this._stdin.on("error", this._onStdinError);
-    }
-    if (typeof this._stdout.on === "function") {
-      this._stdout.on("error", this._onStdoutError);
-    }
-
-    this._rl = createInterface({ input: this._stdin, crlfDelay: Infinity });
-    this._rl.on("line", (line) => this._handleInboundMessage(line));
-    // readline re-emits the input stream 'error' on itself; the raw stdin
-    // handler above already converts it into a JsonRpcTransportError, so
-    // suppress the re-emit to avoid an unhandled 'error' on the Interface.
-    this._rl.on("error", () => {});
-    this._rl.on("close", () => {
-      // P1 #3 fail-fast: EOF during `running` is a transport error. Pending
-      // requests are rejected with JsonRpcTransportError. EOF during `closing`
-      // is a normal shutdown — pending requests are rejected with the generic
-      // CLOSED_MESSAGE via close().
-      if (this._state === "running") {
-        const err = new JsonRpcTransportError(
-          "JSON-RPC stream closed unexpectedly (EOF during running state)",
-        );
-        this._emitError(err);
-        this._closeWith("closed", err);
-      } else if (this._state !== "closed") {
-        this._closeWith("closed");
-      }
-    });
-  }
-
-  // --- internals ---------------------------------------------------------
-
-  _encodeAndSend(frame) {
-    if (this._state === "closed") return;
-    const line = `${JSON.stringify(frame)}\n`;
-    try {
-      this._stdout.write(line, (err) => {
-        if (err) this._handleStreamError("stdout-write", err);
-      });
-    } catch (err) {
-      this._handleStreamError("stdout-write", err);
-    }
-  }
-
-  _teardownTransport() {
-    try {
-      this._stdin.off?.("data", this._onStdinData);
-    } catch {
-      /* ignore */
-    }
-    try {
-      this._rl.close();
-    } catch {
-      /* ignore */
-    }
-  }
-
-  /**
-   * Convert a raw stream error into a JsonRpcTransportError, emit it to the
-   * error sink, and close the client so pending requests are rejected.
-   * Idempotent: repeated errors after close are swallowed.
-   * @param {string} which identifier for the originating pipe/operation
-   * @param {unknown} err raw error from the stream
-   */
-  _handleStreamError(which, err) {
-    if (this._state === "closed") return;
-    const base = err instanceof Error ? err : new Error(String(err));
-    const wrapped = new JsonRpcTransportError(
-      `JSON-RPC stream error on ${which}: ${base.message}`,
-    );
-    wrapped.cause = base;
-    this._emitError(wrapped);
-    this._closeWith("closed", wrapped);
-  }
-
-  _trackRawBytes(chunk) {
-    if (this._oversized || this._state === "closed") return;
-    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    for (let i = 0; i < buf.length; i++) {
-      if (buf[i] === 0x0a /* \n */) {
-        this._pendingLineSize = 0;
-        continue;
-      }
-      this._pendingLineSize += 1;
-      if (this._pendingLineSize > this._maxLineSize) {
-        this._oversized = true;
-        const err = new MaxLineSizeExceededError(
-          this._pendingLineSize,
-          this._maxLineSize,
-        );
-        this._emitError(err);
-        // P1 #3 fail-fast: oversized line → reject pending with the actual error
-        this._closeWith("closed", err);
-        return;
-      }
-    }
-  }
-}

package/scripts/lib/claudemd-scanner.mjs

@@ -1,26 +0,0 @@
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-
-export function findAllClaudeMdPaths(options = {}) {
-  const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
-  const homeDir = options.homeDir ? resolve(options.homeDir) : homedir();
-  const includeGlobal = options.includeGlobal !== false;
-  const includeProject = options.includeProject !== false;
-
-  const candidates = [];
-  if (includeGlobal) candidates.push(join(homeDir, ".claude", "CLAUDE.md"));
-  if (includeProject) candidates.push(join(cwd, "CLAUDE.md"));
-
-  const seen = new Set();
-  const paths = [];
-  for (const candidate of candidates) {
-    const normalized = resolve(candidate);
-    if (seen.has(normalized)) continue;
-    seen.add(normalized);
-    if (existsSync(normalized)) {
-      paths.push(normalized);
-    }
-  }
-  return paths;
-}

package/scripts/lib/context.mjs

@@ -1,51 +0,0 @@
-/**
- * 요청별 로그 컨텍스트 전파 (AsyncLocalStorage 기반).
- *
- * Hub HTTP 서버의 요청마다 correlationId를 자동 할당하여,
- * 하나의 요청에서 발생한 모든 로그를 추적할 수 있다.
- *
- * 사용법:
- *   import { getCorrelationId, withRequestContext } from './lib/context.mjs';
- *
- *   // 미들웨어에서 컨텍스트 생성
- *   withRequestContext({ method: 'POST', path: '/bridge/result' }, () => {
- *     const correlationId = getCorrelationId();
- *   });
- *
- */
-import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
-
-import { logger } from "./logger.mjs";
-
-/** @type {AsyncLocalStorage<{logger: import('pino').Logger, correlationId: string}>} */
-const asyncLocalStorage = new AsyncLocalStorage();
-
-/**
- * 현재 요청의 상관 ID를 반환한다.
- *
- * @returns {string|undefined}
- */
-export function getCorrelationId() {
-  return asyncLocalStorage.getStore()?.correlationId;
-}
-
-/**
- * 요청 컨텍스트를 생성하고 콜백을 실행한다.
- *
- * @param {object} context — 컨텍스트 필드 (method, path 등)
- * @param {string} [context.correlationId] — 외부에서 전달된 상관 ID (없으면 자동 생성)
- * @param {function} callback — 컨텍스트 내에서 실행할 함수
- * @returns {*}
- */
-export function withRequestContext(context, callback) {
-  const correlationId = context.correlationId || randomUUID();
-  const { correlationId: _, ...rest } = context;
-
-  const store = {
-    correlationId,
-    logger: logger.child({ correlationId, ...rest }),
-  };
-
-  return asyncLocalStorage.run(store, callback);
-}

package/scripts/lib/handoff.mjs

@@ -1,187 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import { findAllClaudeMdPaths } from "./claudemd-scanner.mjs";
-
-function runCommand(command, cwd, executor = execSync) {
-  try {
-    const output = executor(command, {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-      windowsHide: true,
-    });
-    return String(output || "").trimEnd();
-  } catch {
-    return "";
-  }
-}
-
-function parseStatusLines(statusText) {
-  const lines = String(statusText || "")
-    .split(/\r?\n/u)
-    .filter(Boolean);
-  const changedFiles = [];
-  const status = [];
-
-  for (const line of lines) {
-    const normalized = line.trimEnd();
-    if (!normalized) continue;
-
-    const rawStatus = normalized.slice(0, 2).trim() || "??";
-    const rawPath = normalized.slice(3).trim();
-    const filePath = rawPath.includes(" -> ")
-      ? rawPath.split(" -> ").at(-1)?.trim()
-      : rawPath;
-    if (!filePath) continue;
-
-    changedFiles.push(filePath);
-    status.push({ path: filePath, status: rawStatus });
-  }
-
-  return {
-    changedFiles: Array.from(new Set(changedFiles)),
-    status,
-  };
-}
-
-function normalizeDecisionLine(line) {
-  return String(line || "")
-    .trim()
-    .replace(/^[-*]\s+/u, "")
-    .trim();
-}
-
-function parseDecisionFile(decisionFile) {
-  if (!decisionFile) return [];
-  const absolute = resolve(decisionFile);
-  if (!existsSync(absolute)) return [];
-
-  const raw = readFileSync(absolute, "utf8");
-  return raw
-    .split(/\r?\n/u)
-    .map(normalizeDecisionLine)
-    .filter((line) => line.length > 0);
-}
-
-function normalizeDecisions(decisions, decisionFile) {
-  const merged = [
-    ...(Array.isArray(decisions) ? decisions : []),
-    ...parseDecisionFile(decisionFile),
-  ]
-    .map(normalizeDecisionLine)
-    .filter(Boolean);
-
-  return Array.from(new Set(merged));
-}
-
-function formatAheadBehind(value) {
-  if (!value) return null;
-  const [behindRaw, aheadRaw] = value.split(/\s+/u);
-  const behind = Number.parseInt(behindRaw, 10);
-  const ahead = Number.parseInt(aheadRaw, 10);
-  if (!Number.isFinite(behind) || !Number.isFinite(ahead)) return null;
-  return { ahead, behind };
-}
-
-export function collectHandoffContext(options = {}) {
-  const cwd = resolve(options.cwd || process.cwd());
-  const executor =
-    typeof options.commandRunner === "function"
-      ? options.commandRunner
-      : execSync;
-  const target = options.target === "local" ? "local" : "remote";
-  const decisions = normalizeDecisions(options.decisions, options.decisionFile);
-  const generatedAt = options.generatedAt || new Date().toISOString();
-  const claudeMdPaths = Array.isArray(options.claudeMdPaths)
-    ? options.claudeMdPaths
-    : findAllClaudeMdPaths({
-        cwd,
-        homeDir: options.homeDir,
-      });
-
-  const gitRoot = runCommand("git rev-parse --show-toplevel", cwd, executor);
-  const branch =
-    runCommand("git rev-parse --abbrev-ref HEAD", cwd, executor) || null;
-  const shortStatus = runCommand("git status --short", cwd, executor);
-  const diffStat = runCommand("git diff --stat --no-color", cwd, executor);
-  const upstreamRaw = runCommand(
-    "git rev-list --left-right --count @{upstream}...HEAD",
-    cwd,
-    executor,
-  );
-  const parsedStatus = parseStatusLines(shortStatus);
-
-  return {
-    generatedAt,
-    target,
-    cwd,
-    gitRoot: gitRoot || null,
-    repository: gitRoot ? basename(gitRoot) : basename(cwd),
-    branch,
-    upstream: formatAheadBehind(upstreamRaw),
-    changedFiles: parsedStatus.changedFiles,
-    fileStatus: parsedStatus.status,
-    diffStat,
-    decisions,
-    claudeMdPaths,
-  };
-}
-
-export function buildHandoffPrompt(context) {
-  const safeContext = context || collectHandoffContext();
-  const branch = safeContext.branch || "unknown";
-  const upstream = safeContext.upstream
-    ? `ahead ${safeContext.upstream.ahead}, behind ${safeContext.upstream.behind}`
-    : "unknown";
-  const changedFiles =
-    safeContext.changedFiles.length > 0
-      ? safeContext.changedFiles.map((file) => `- ${file}`).join("\n")
-      : "- 변경 파일 없음";
-  const decisions =
-    safeContext.decisions.length > 0
-      ? safeContext.decisions.map((decision) => `- ${decision}`).join("\n")
-      : "- 명시된 결정사항 없음";
-  const claudeMdList =
-    Array.isArray(safeContext.claudeMdPaths) &&
-    safeContext.claudeMdPaths.length > 0
-      ? safeContext.claudeMdPaths.map((path) => `- ${path}`).join("\n")
-      : "- 자동 탐지된 CLAUDE.md 없음";
-  const diffStat = safeContext.diffStat || "(diff stat 없음)";
-
-  return [
-    "## TFX Remote Handoff",
-    `- generated_at: ${safeContext.generatedAt}`,
-    `- target: ${safeContext.target}`,
-    `- repository: ${safeContext.repository}`,
-    `- branch: ${branch} (${upstream})`,
-    `- cwd: ${safeContext.cwd}`,
-    "",
-    "### 변경 파일",
-    changedFiles,
-    "",
-    "### 변경 요약 (git diff --stat)",
-    "```",
-    diffStat,
-    "```",
-    "",
-    "### 결정사항",
-    decisions,
-    "",
-    "### CLAUDE.md 참조",
-    claudeMdList,
-    "",
-    "### 다음 세션 지시",
-    "- 위 변경사항을 먼저 검토하고 누락된 테스트를 확인하세요.",
-    "- 필요 시 CLAUDE.md 지침을 재확인한 뒤 작업을 이어가세요.",
-    "- 작업 완료 후 변경 파일과 검증 결과를 요약하세요.",
-  ].join("\n");
-}
-
-export function serializeHandoff(options = {}) {
-  const context = collectHandoffContext(options);
-  return {
-    ...context,
-    prompt: buildHandoffPrompt(context),
-  };
-}

package/scripts/lib/logger.mjs

@@ -1,122 +0,0 @@
-/**
- * Logify — triflux 구조화 로깅 설정
- *
- * 사용법:
- *   import { logger, createModuleLogger } from './lib/logger.mjs';
- *
- *   // 기본 로거
- *   logger.info({ taskId: 'abc' }, 'task.started');
- *
- *   // 모듈별 로거
- *   const log = createModuleLogger('hub');
- *   log.info({ port: 27888 }, 'server.started');
- *   log.error({ err }, 'server.error');
- *
- * 이벤트 네이밍: {도메인}.{액션} 형식
- *   hub.started, hub.stopped, route.started, route.completed,
- *   worker.spawned, worker.completed, worker.timeout,
- *   mcp.connected, mcp.disconnected, mcp.error,
- *   team.created, team.deleted, task.claimed, task.completed,
- *   pipe.connected, pipe.message, pipe.error,
- *   http.request, http.response, http.error
- *
- * 로그 레벨 가이드:
- *   debug  — 개발/트러블슈팅용 (변수 값, MCP 메시지, 캐시 키)
- *   info   — 정상 흐름 상태 변경 (서버 시작, 워커 완료, 팀 생성)
- *   warn   — 위험 신호 (재시도 발생, 쿼타 임박, 느린 워커)
- *   error  — 작업 실패 (CLI 실행 실패, MCP 연결 끊김)
- *   fatal  — 프로세스 위협 (DB 연결 불가, 포트 충돌)
- */
-import pino from "pino";
-
-const isDev = process.env.NODE_ENV !== "production";
-
-// 로그는 항상 stderr(fd 2)로 보낸다.
-//
-// Claude Code 훅은 stdout 을 훅의 JSON 페이로드로 파싱한다. 로그가 stdout 으로
-// 나가면 페이로드와 한 스트림에 섞여, 훅이 돌려준 hookSpecificOutput 이 JSON 으로
-// 해석되지 않고 그냥 본문 텍스트가 된다. Claude Code 2.1.257 부터는 stdout 이
-// "{" 로 시작하는데 유효한 JSON 이 아니면 훅 오류로 보고하므로, 로그가 먼저 나가느냐
-// 페이로드가 먼저 나가느냐에 따라 훅 전체가 실패로 뒤집힌다.
-//
-// stderr 로 보내면 Claude Code 가 verbose/transcript 에서 그대로 보여주고 stdout 은
-// 페이로드만 남는다. CLI 관례상으로도 구조화 로그는 stderr 가 맞다.
-const LOG_FD = 2;
-
-export const logger = pino(
-  {
-    level: process.env.LOG_LEVEL || (isDev ? "debug" : "info"),
-
-    // 모든 로그에 포함되는 기본 필드
-    base: {
-      service: process.env.SERVICE_NAME || "triflux",
-      env: process.env.NODE_ENV || "development",
-    },
-
-    // 레벨을 대문자로 출력 (AI 파싱 용이)
-    formatters: {
-      level: (label) => ({ level: label.toUpperCase() }),
-    },
-
-    // ISO 8601 타임스탬프
-    timestamp: pino.stdTimeFunctions.isoTime,
-
-    // 민감정보 자동 필터링
-    redact: {
-      paths: [
-        "password",
-        "token",
-        "apiKey",
-        "secret",
-        "authorization",
-        "*.password",
-        "*.token",
-        "*.apiKey",
-        "*.secret",
-        "req.headers.authorization",
-        "req.headers.cookie",
-        "hubToken",
-      ],
-      remove: true,
-    },
-
-    // 개발 환경: 컬러 콘솔 출력 (stderr)
-    transport: isDev
-      ? {
-          target: "pino-pretty",
-          options: {
-            colorize: true,
-            translateTime: "yyyy-mm-dd HH:MM:ss",
-            ignore: "pid,hostname",
-            destination: LOG_FD,
-          },
-        }
-      : undefined,
-  },
-  // 운영 환경(transport 미사용)에서도 stdout 이 아니라 stderr 로 쓴다.
-  isDev ? undefined : pino.destination({ dest: LOG_FD, sync: false }),
-);
-
-/**
- * 모듈별 Child Logger 생성.
- * 모듈 이름이 모든 로그에 자동 포함된다.
- *
- * @param {string} module — 모듈 이름 (hub, route, worker, mcp, team 등)
- * @returns {import('pino').Logger}
- */
-export function createModuleLogger(module) {
-  return logger.child({ module });
-}
-
-// 정상 종료 시 버퍼 flush 보장
-process.on("uncaughtException", (err) => {
-  logger.fatal({ err }, "process.uncaught_exception");
-  logger.flush();
-  process.exit(1);
-});
-
-process.on("unhandledRejection", (reason) => {
-  logger.fatal({ reason: String(reason) }, "process.unhandled_rejection");
-  logger.flush();
-  process.exit(1);
-});