@triflux/remote 10.50.2 → 10.52.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,223 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-export const TFX_START = "<!-- TFX:START -->";
-export const TFX_END = "<!-- TFX:END -->";
-export const OMC_END = "<!-- OMC:END -->";
-const TFX_VERSION_RE = /<!-- TFX:VERSION:([\d.]+) -->/u;
-
-const LEGACY_PATTERNS = [
-  /<user_cli_routing>/u,
-  /Codex Pro 무료 기간/u,
-  /codex exec --dangerously-bypass.*skip-git-repo-check/u,
-  /OMC 에이전트 → CLI 매핑/u,
-  /Spark 가드레일/u,
-];
-
-const DEFAULT_TFX_TEMPLATE = [
-  "### triflux CLI routing (managed)",
-  "- 이 블록은 triflux setup에서 자동으로 관리됩니다.",
-  "- 직접 수정이 필요하면 블록 바깥에 사용자 섹션을 추가하세요.",
-].join("\n");
-
-const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
-const DEFAULT_TEMPLATE_PATH = join(
-  SCRIPT_DIR,
-  "..",
-  "templates",
-  "claudemd-tfx-section.md",
-);
-
-function resolveVersion(version) {
-  if (version) return version;
-  try {
-    const pkgPath = join(SCRIPT_DIR, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-    return pkg.version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
-function resolveTemplate(template, templatePath = DEFAULT_TEMPLATE_PATH) {
-  if (typeof template === "string" && template.trim()) {
-    return template.trim();
-  }
-  if (existsSync(templatePath)) {
-    const raw = readFileSync(templatePath, "utf8").trim();
-    if (raw) return raw;
-  }
-  return DEFAULT_TFX_TEMPLATE;
-}
-
-function findManagedSection(rawText) {
-  const raw = String(rawText || "");
-  const startIdx = raw.indexOf(TFX_START);
-  const endMarkerIdx = raw.indexOf(TFX_END);
-  if (startIdx === -1 || endMarkerIdx === -1 || endMarkerIdx <= startIdx) {
-    return {
-      found: false,
-      content: null,
-      version: null,
-      startIdx: -1,
-      endIdx: -1,
-    };
-  }
-
-  const endIdx = endMarkerIdx + TFX_END.length;
-  const content = raw.slice(startIdx, endIdx);
-  const versionMatch = content.match(TFX_VERSION_RE);
-
-  return {
-    found: true,
-    content,
-    version: versionMatch ? versionMatch[1] : null,
-    startIdx,
-    endIdx,
-  };
-}
-
-function detectLegacyRange(rawText) {
-  const raw = String(rawText || "");
-  const matches = LEGACY_PATTERNS.some((pattern) => pattern.test(raw));
-  if (!matches) {
-    return { found: false, startIdx: -1, endIdx: -1 };
-  }
-
-  const startTag = raw.indexOf("<user_cli_routing>");
-  const endTag = raw.indexOf("</user_cli_routing>");
-  if (startTag === -1 || endTag === -1 || endTag <= startTag) {
-    return { found: true, startIdx: -1, endIdx: -1 };
-  }
-
-  let removeStart = startTag;
-  const userOverridesComment = "<!-- USER OVERRIDES";
-  const commentIdx = raw.lastIndexOf(userOverridesComment, startTag);
-  if (commentIdx !== -1 && startTag - commentIdx < 200) {
-    removeStart = commentIdx;
-  }
-
-  return {
-    found: true,
-    startIdx: removeStart,
-    endIdx: endTag + "</user_cli_routing>".length,
-  };
-}
-
-function normalizeSpacing(text) {
-  return String(text || "").replace(/\n{3,}/gu, "\n\n");
-}
-
-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;
-}
-
-export function writeSection(filePath, options = {}) {
-  const absolutePath = resolve(filePath);
-  const version = resolveVersion(options.version);
-  const template = resolveTemplate(options.template, options.templatePath);
-  const block = [
-    TFX_START,
-    `<!-- TFX:VERSION:${version} -->`,
-    template,
-    TFX_END,
-  ].join("\n");
-
-  if (!existsSync(absolutePath)) {
-    writeFileSync(absolutePath, `${block}\n`, "utf8");
-    return { action: "created", version, path: absolutePath };
-  }
-
-  const raw = readFileSync(absolutePath, "utf8");
-  const existing = findManagedSection(raw);
-
-  if (existing.found) {
-    const nextContent = `${raw.slice(0, existing.startIdx)}${block}${raw.slice(existing.endIdx)}`;
-    writeFileSync(absolutePath, nextContent, "utf8");
-    return {
-      action: "updated",
-      oldVersion: existing.version,
-      version,
-      path: absolutePath,
-    };
-  }
-
-  const omcEndIdx = raw.indexOf(OMC_END);
-  if (omcEndIdx !== -1) {
-    const insertAt = omcEndIdx + OMC_END.length;
-    const before = raw.slice(0, insertAt);
-    const after = raw.slice(insertAt);
-    const nextContent = `${before}\n${block}${after}`;
-    writeFileSync(absolutePath, nextContent, "utf8");
-    return { action: "inserted_after_omc", version, path: absolutePath };
-  }
-
-  const separator = raw.endsWith("\n") ? "" : "\n";
-  writeFileSync(absolutePath, `${raw}${separator}${block}\n`, "utf8");
-  return { action: "appended", version, path: absolutePath };
-}
-
-export function migrateClaudeMd(filePath, options = {}) {
-  const absolutePath = resolve(filePath);
-  if (!existsSync(absolutePath)) {
-    return { action: "no_file", removed: [], path: absolutePath };
-  }
-
-  const raw = readFileSync(absolutePath, "utf8");
-  const existing = findManagedSection(raw);
-  const legacy = detectLegacyRange(raw);
-
-  if (existing.found && !legacy.found) {
-    return {
-      action: "already_managed",
-      removed: [],
-      version: existing.version,
-      path: absolutePath,
-    };
-  }
-
-  const removed = [];
-  let nextContent = raw;
-
-  if (legacy.found && legacy.startIdx !== -1 && legacy.endIdx !== -1) {
-    nextContent = `${nextContent.slice(0, legacy.startIdx)}${nextContent.slice(legacy.endIdx)}`;
-    removed.push("<user_cli_routing> block");
-  }
-
-  const existingAfterLegacy = findManagedSection(nextContent);
-  if (existingAfterLegacy.found) {
-    nextContent = `${nextContent.slice(0, existingAfterLegacy.startIdx)}${nextContent.slice(existingAfterLegacy.endIdx)}`;
-    removed.push("old TFX block");
-  }
-
-  writeFileSync(absolutePath, normalizeSpacing(nextContent), "utf8");
-  const writeResult = writeSection(absolutePath, options);
-
-  return {
-    action: "migrated",
-    removed,
-    version: writeResult.version,
-    path: absolutePath,
-  };
-}

package/scripts/lib/context.mjs

@@ -1,67 +0,0 @@
-/**
- * 요청별 로그 컨텍스트 전파 (AsyncLocalStorage 기반).
- *
- * Hub HTTP 서버의 요청마다 correlationId를 자동 할당하여,
- * 하나의 요청에서 발생한 모든 로그를 추적할 수 있다.
- *
- * 사용법:
- *   import { getLogger, getCorrelationId, withRequestContext } from './lib/context.mjs';
- *
- *   // 미들웨어에서 컨텍스트 생성
- *   withRequestContext({ method: 'POST', path: '/bridge/result' }, () => {
- *     const log = getLogger();
- *     log.info({ agentId }, 'bridge.result_received');
- *   });
- *
- *   // 내부 함수에서 자동 상관 ID
- *   function processResult() {
- *     const log = getLogger();
- *     log.info('result.processed'); // correlationId 자동 포함
- *   }
- */
-import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
-
-import { logger } from "./logger.mjs";
-
-/** @type {AsyncLocalStorage<{logger: import('pino').Logger, correlationId: string}>} */
-export const asyncLocalStorage = new AsyncLocalStorage();
-
-/**
- * 현재 요청 컨텍스트의 로거를 반환한다.
- * 요청 컨텍스트 밖에서 호출하면 기본 로거를 반환한다.
- *
- * @returns {import('pino').Logger}
- */
-export function getLogger() {
-  return asyncLocalStorage.getStore()?.logger || logger;
-}
-
-/**
- * 현재 요청의 상관 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/dynamic-route-cli.mjs

@@ -1,107 +0,0 @@
-#!/usr/bin/env node
-// scripts/lib/dynamic-route-cli.mjs
-//
-// Phase 1 Wire-up 3 helper — tfx-route.sh 등 sh 경로에서 dynamic routing
-// decision 을 받아 단일 CLI 문자열 (또는 JSON) 으로 출력한다.
-//
-// 사용:
-//   node scripts/lib/dynamic-route-cli.mjs --agent-hint codex
-//   → "codex"
-//   node scripts/lib/dynamic-route-cli.mjs --agent-hint codex --json
-//   → {"scenario":"fallback","mode":"codex-default","shards":[{"cli":"codex",...}]}
-//   node scripts/lib/dynamic-route-cli.mjs --agent-hint codex --field scenario
-//   → "fallback"
-//
-// 정책:
-//   - opt-in env TRIFLUX_DYNAMIC_ROUTING=1|true 미설정 시 즉시 silent exit 0
-//     (override 없음 = stdout empty, sh caller 가 graceful no-op).
-//   - error 발생 시 stderr 에 한 줄 + exit 0 (sh caller 가 fallback path 진행).
-
-import { createDynamicRouter } from "@triflux/core/hub/dynamic-routing-engine.mjs";
-
-function parseArgs(argv) {
-  const args = {
-    taskId: `tfx-route-${process.pid}-${Date.now()}`,
-    agentHint: "codex",
-    teamSize: 1,
-    json: false,
-    field: null,
-  };
-  for (let i = 2; i < argv.length; i++) {
-    const v = argv[i];
-    switch (v) {
-      case "--task-id":
-        args.taskId = argv[++i] || args.taskId;
-        break;
-      case "--agent-hint":
-        args.agentHint = argv[++i] || args.agentHint;
-        break;
-      case "--team-size":
-        args.teamSize = Number(argv[++i]) || args.teamSize;
-        break;
-      case "--json":
-        args.json = true;
-        break;
-      case "--field":
-        args.field = argv[++i] || null;
-        break;
-      case "--help":
-      case "-h":
-        process.stdout.write(
-          "Usage: dynamic-route-cli.mjs [--task-id ID] [--agent-hint CLI] [--team-size N] [--json|--field FIELD]\n",
-        );
-        process.exit(0);
-        break;
-    }
-  }
-  return args;
-}
-
-async function main() {
-  const args = parseArgs(process.argv);
-
-  // opt-in env 미설정 시 silent no-op (sh caller graceful path)
-  const flag = process.env.TRIFLUX_DYNAMIC_ROUTING;
-  if (flag !== "1" && flag !== "true") return;
-
-  let decision;
-  try {
-    const router = createDynamicRouter();
-    decision = await router.routeRequest({
-      task_id: args.taskId,
-      team_size: args.teamSize,
-      agent_hint: args.agentHint,
-    });
-  } catch (err) {
-    process.stderr.write(
-      `[dynamic-route-cli] error: ${err?.message || String(err)}\n`,
-    );
-    return;
-  }
-
-  if (args.json) {
-    process.stdout.write(JSON.stringify(decision));
-    return;
-  }
-
-  if (args.field) {
-    const value = decision?.[args.field];
-    if (value !== undefined && value !== null) {
-      process.stdout.write(String(value));
-    }
-    return;
-  }
-
-  // 기본 — shards[0].cli 만 stdout 으로 (sh caller 가 즉시 비교)
-  const cli = decision?.shards?.[0]?.cli;
-  if (cli) {
-    process.stdout.write(String(cli));
-  }
-}
-
-main().catch((err) => {
-  process.stderr.write(
-    `[dynamic-route-cli] fatal: ${err?.message || String(err)}\n`,
-  );
-  process.exit(0); // sh caller 가 정상 fallback 하도록 always 0
-});