@triflux/remote 10.50.1 → 10.50.2

package/scripts/lib/cli-codex.mjs

@@ -1,62 +0,0 @@
-// cli-codex.mjs — Codex CLI adapter (Phase 0 PoC).
-//
-// 책임: agent 이름과 입력 파라미터를 받아 Codex 실행 계획(profile/effort/timeout/runMode)을
-// 산출한다. 실제 spawn 은 Phase 1 에서 이관된다 (현재는 tfx-route.sh 가 수행).
-//
-// 진입점: tfx-route.mjs → selectAdapter("codex") → plan({...}).
-// 출처: agent-route-policy.mjs 의 canonical Codex role policy.
-// timeoutSec은 lane 예상 소요 시간(advisory)이다. hard ceiling 집행은 Bash route가 소유한다.
-
-export const id = "codex";
-export const cliType = "codex";
-export const command = "codex";
-
-import {
-  CODEX_AGENT_POLICY,
-  resolveCodexAgentPolicy,
-  resolveCodexAgentProfile,
-  resolveNestedCodexAgentProfile,
-} from "./agent-route-policy.mjs";
-
-// Compatibility re-exports for launchers which historically imported these
-// helpers from this adapter. The policy module owns the semantics.
-export { resolveCodexAgentProfile, resolveNestedCodexAgentProfile };
-
-export function plan({
-  agent,
-  prompt = "",
-  mcpProfile = "auto",
-  timeoutSec,
-  contextFile,
-  profileOverride = "auto",
-  retryProfile = null,
-  nested = false,
-} = {}) {
-  if (!agent) {
-    throw new Error("[cli-codex] agent required");
-  }
-  const cfg = resolveCodexAgentPolicy(agent);
-  const profile = resolveCodexAgentProfile(agent, {
-    profileOverride,
-    retryProfile,
-    nested,
-  });
-  const effectiveTimeoutSec =
-    Number.isFinite(timeoutSec) && timeoutSec > 0 ? timeoutSec : cfg.timeoutSec;
-  return {
-    command,
-    subcommand: cfg.subcommand ?? "exec",
-    profile,
-    effort: profile,
-    timeoutMs: effectiveTimeoutSec * 1000,
-    runMode: cfg.runMode,
-    opusOversight: cfg.opusOversight,
-    mcpProfile: mcpProfile === "auto" ? cfg.mcpHint : mcpProfile,
-    promptLength: prompt.length,
-    contextFile: contextFile || null,
-  };
-}
-
-export function describe() {
-  return { id, cliType, command, agents: Object.keys(CODEX_AGENT_POLICY) };
-}

package/scripts/lib/cli-gemini.mjs

@@ -1,37 +0,0 @@
-// cli-gemini.mjs — legacy Gemini adapter alias.
-// The public "gemini" label remains accepted, but the executable plan is AGY.
-
-import * as agyAdapter from "./cli-agy.mjs";
-
-export const id = "gemini";
-export const cliType = "antigravity";
-export const command = "agy";
-
-export function plan({
-  agent,
-  prompt = "",
-  mcpProfile = "auto",
-  timeoutSec,
-  contextFile,
-} = {}) {
-  if (!agent) {
-    throw new Error("[cli-gemini] agent required");
-  }
-  return agyAdapter.plan({
-    agent: agent === "gemini" ? "antigravity" : agent,
-    prompt,
-    mcpProfile,
-    timeoutSec,
-    contextFile,
-  });
-}
-
-export function describe() {
-  return {
-    id,
-    cliType,
-    command,
-    aliases: ["gemini"],
-    agents: ["gemini", "designer", "writer", "antigravity", "agy"],
-  };
-}

package/scripts/lib/env.mjs

@@ -1,14 +0,0 @@
-export function buildPreflightEnv(env = process.env) {
-  return {
-    ...env,
-    GIT_TERMINAL_PROMPT: env.GIT_TERMINAL_PROMPT ?? "0",
-    GIT_ASKPASS: env.GIT_ASKPASS ?? "false",
-    npm_config_yes: env.npm_config_yes ?? "true",
-  };
-}
-
-export function shouldWarnGhAuth(env = process.env, checks = {}) {
-  if (!checks.ghExists) return false;
-  if (env.GH_TOKEN || env.GITHUB_TOKEN) return false;
-  return checks.ghAuthenticated === false;
-}

package/scripts/lib/hub.mjs

@@ -1,48 +0,0 @@
-import { spawn } from "node:child_process";
-
-export function parseHubPort(hubUrl = "") {
-  try {
-    const parsed = new URL(hubUrl);
-    return parsed.port || "27888";
-  } catch {
-    return "27888";
-  }
-}
-
-export async function restartHub({
-  hubUrl = process.env.TFX_HUB_URL || "http://127.0.0.1:27888",
-  hubServer,
-  nodeBin = process.execPath,
-  spawnFn = spawn,
-  fetchFn = globalThis.fetch,
-  sleepMs = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-  attempts = 8,
-} = {}) {
-  if (!hubServer) return { ok: false, error: "hub_server_missing" };
-  const port = parseHubPort(hubUrl);
-  const child = spawnFn(nodeBin, [hubServer], {
-    env: { ...process.env, TFX_HUB_PORT: port },
-    stdio: "ignore",
-    detached: true,
-  });
-  child.unref?.();
-
-  for (let i = 0; i < attempts; i += 1) {
-    await sleepMs(500);
-    try {
-      const response = await fetchFn(`${hubUrl.replace(/\/$/, "")}/status`);
-      if (response?.ok) return { ok: true, pid: child.pid };
-    } catch {
-      // Keep polling until attempts are exhausted.
-    }
-  }
-  return { ok: false, pid: child.pid };
-}
-
-export async function withHubRestart({ action, restart }) {
-  const first = await action();
-  if (first?.ok) return first;
-  const restarted = await restart();
-  if (!restarted?.ok) return first;
-  return action();
-}

package/scripts/lib/pid.mjs

@@ -1,63 +0,0 @@
-import { appendFileSync, existsSync, readFileSync, rmSync } from "node:fs";
-import { createRequire } from "node:module";
-
-const require = createRequire(import.meta.url);
-let treeKill = null;
-try {
-  treeKill = require("tree-kill");
-} catch {
-  treeKill = null;
-}
-
-function defaultIsAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function defaultKillTree(pid) {
-  return new Promise((resolve) => {
-    if (treeKill) {
-      treeKill(pid, "SIGTERM", () => resolve());
-      return;
-    }
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
-      // Process already exited.
-    }
-    resolve();
-  });
-}
-
-export class PidTracker {
-  constructor(path, options = {}) {
-    this.path = path;
-    this.isAlive = options.isAlive ?? defaultIsAlive;
-    this.killTree = options.killTree ?? defaultKillTree;
-  }
-
-  track(pid) {
-    if (!pid) return;
-    appendFileSync(this.path, `${pid}\n`);
-  }
-
-  list() {
-    if (!existsSync(this.path)) return [];
-    return readFileSync(this.path, "utf8")
-      .split(/\r?\n/)
-      .map((line) => Number(line.trim()))
-      .filter((pid) => Number.isInteger(pid) && pid > 0);
-  }
-
-  async cleanup() {
-    for (const pid of this.list()) {
-      if (!this.isAlive(pid)) continue;
-      await this.killTree(pid);
-    }
-    rmSync(this.path, { force: true });
-  }
-}

package/scripts/lib/quota.mjs

@@ -1,47 +0,0 @@
-export const QUOTA_PATTERNS = [
-  /usage limit exceeded/i,
-  /rate limit exceeded/i,
-  /rate limit reached/i,
-  /try again at/i,
-  /purchase more credits/i,
-  /quota exceeded/i,
-  /RESOURCE_EXHAUSTED/i,
-  /rateLimitExceeded/i,
-  /Too Many Requests/i,
-  /rate_limit_error/i,
-  /overloaded_error/i,
-  /insufficient_quota/i,
-];
-
-export class QuotaStreamBuffer {
-  constructor({ maxBytes = 65536 } = {}) {
-    this.maxBytes = maxBytes;
-    this.text = "";
-  }
-
-  push(chunk) {
-    this.text += Buffer.isBuffer(chunk)
-      ? chunk.toString("utf8")
-      : String(chunk);
-    if (this.text.length > this.maxBytes) {
-      this.text = this.text.slice(-this.maxBytes);
-    }
-    return detectQuotaText(this.text);
-  }
-}
-
-export function detectQuotaText(text = "") {
-  return QUOTA_PATTERNS.some((pattern) => pattern.test(text));
-}
-
-export function getRerouteTarget(cliType) {
-  switch (cliType) {
-    case "codex":
-    case "gemini":
-      return "antigravity";
-    case "antigravity":
-      return "codex";
-    default:
-      return null;
-  }
-}

package/scripts/lib/skill-state.mjs

@@ -1,220 +0,0 @@
-import {
-  access,
-  mkdir,
-  open,
-  readdir,
-  readFile,
-  rename,
-  rm,
-  writeFile,
-} from "node:fs/promises";
-import { basename, join } from "node:path";
-
-const DEFAULT_STATE_DIR = join(process.cwd(), ".tfx", "state");
-const STOP_HOOKS = new Map();
-
-function stateFilePath(stateDir, skillName) {
-  return join(stateDir, `${skillName}-active.json`);
-}
-
-function assertValidSkillName(skillName) {
-  if (basename(skillName) !== skillName) {
-    throw new Error(`Invalid skill name: ${skillName}`);
-  }
-}
-
-function assertValidOnStop(onStop) {
-  if (onStop !== undefined && typeof onStop !== "function") {
-    throw new TypeError("onStop must be a function");
-  }
-}
-
-async function readStateFile(filePath) {
-  try {
-    const raw = await readFile(filePath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
-function rememberStopHook(filePath, onStop) {
-  if (typeof onStop === "function") {
-    STOP_HOOKS.set(filePath, onStop);
-    return;
-  }
-  STOP_HOOKS.delete(filePath);
-}
-
-function logStopHookWarning(message, error) {
-  if (error) {
-    console.warn(message, error);
-    return;
-  }
-  console.warn(message);
-}
-
-async function runStopHook(filePath, state, onStop) {
-  if (!state?.hasStopHook) {
-    STOP_HOOKS.delete(filePath);
-    return;
-  }
-
-  const hook = onStop ?? STOP_HOOKS.get(filePath);
-  STOP_HOOKS.delete(filePath);
-
-  if (typeof hook !== "function") {
-    return;
-  }
-
-  try {
-    await hook({
-      skillName: state.skillName,
-      filePath,
-      state,
-    });
-  } catch (error) {
-    logStopHookWarning(
-      `Failed to run stop-hook for skill: ${state.skillName}`,
-      error,
-    );
-  }
-}
-
-/**
- * Activate a skill by writing its state file.
- * Throws if the skill is already active.
- *
- * @param {string} skillName
- * @param {{ stateDir?: string, onStop?: (() => Promise<void> | void) }} options
- */
-export async function activateSkill(
-  skillName,
-  { stateDir = DEFAULT_STATE_DIR, onStop } = {},
-) {
-  assertValidSkillName(skillName);
-  assertValidOnStop(onStop);
-
-  await mkdir(stateDir, { recursive: true });
-
-  const filePath = stateFilePath(stateDir, skillName);
-  const lockPath = `${filePath}.lock`;
-  const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  let lockHandle;
-
-  try {
-    lockHandle = await open(lockPath, "wx");
-    try {
-      await access(filePath);
-      throw new Error(`Skill already active: ${skillName}`);
-    } catch (error) {
-      if (error?.message === `Skill already active: ${skillName}`) {
-        throw error;
-      }
-      if (error?.code !== "ENOENT") {
-        throw error;
-      }
-    }
-
-    const state = {
-      skillName,
-      pid: process.pid,
-      activatedAt: Date.now(),
-      hasStopHook: typeof onStop === "function",
-    };
-    await writeFile(tmpPath, JSON.stringify(state), "utf8");
-    await rename(tmpPath, filePath);
-    rememberStopHook(filePath, onStop);
-  } finally {
-    await rm(tmpPath, { force: true }).catch(() => {});
-    if (lockHandle) {
-      await lockHandle.close().catch(() => {});
-    }
-    await rm(lockPath, { force: true }).catch(() => {});
-  }
-}
-
-/**
- * Deactivate a skill by removing its state file.
- * Does not throw if the file does not exist.
- *
- * @param {string} skillName
- * @param {{ stateDir?: string, onStop?: (() => Promise<void> | void) }} options
- */
-export async function deactivateSkill(
-  skillName,
-  { stateDir = DEFAULT_STATE_DIR, onStop } = {},
-) {
-  assertValidOnStop(onStop);
-
-  const filePath = stateFilePath(stateDir, skillName);
-  const state = await readStateFile(filePath);
-
-  try {
-    await runStopHook(filePath, state, onStop);
-  } finally {
-    STOP_HOOKS.delete(filePath);
-    await rm(filePath, { force: true }).catch(() => {});
-  }
-}
-
-/**
- * Return all currently active skills by scanning *-active.json files.
- *
- * @param {{ stateDir?: string }} options
- * @returns {Promise<Array<{ skillName: string, pid: number, activatedAt: number, hasStopHook?: boolean }>>}
- */
-export async function getActiveSkills({ stateDir = DEFAULT_STATE_DIR } = {}) {
-  let entries;
-  try {
-    entries = await readdir(stateDir);
-  } catch {
-    return [];
-  }
-
-  const results = [];
-  for (const entry of entries) {
-    if (!entry.endsWith("-active.json")) continue;
-    const state = await readStateFile(join(stateDir, entry));
-    if (state) {
-      results.push(state);
-    }
-  }
-  return results;
-}
-
-/**
- * Remove state files for skills whose processes are no longer alive.
- *
- * @param {{ stateDir?: string }} options
- * @returns {Promise<string[]>} list of pruned skill names
- */
-export async function pruneOrphanSkillStates({
-  stateDir = DEFAULT_STATE_DIR,
-} = {}) {
-  const active = await getActiveSkills({ stateDir });
-  const pruned = [];
-
-  for (const state of active) {
-    let alive = true;
-    try {
-      process.kill(state.pid, 0);
-    } catch {
-      alive = false;
-    }
-
-    if (!alive) {
-      const filePath = stateFilePath(stateDir, state.skillName);
-      STOP_HOOKS.delete(filePath);
-      if (state.hasStopHook) {
-        logStopHookWarning(
-          `Skipping stop-hook for orphaned skill state: ${state.skillName}`,
-        );
-      }
-      await rm(filePath, { force: true }).catch(() => {});
-      pruned.push(state.skillName);
-    }
-  }
-
-  return pruned;
-}

package/scripts/lib/team.mjs

@@ -1,75 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-function teamContext(env) {
-  const team = env.TFX_TEAM_NAME || "";
-  const taskId = env.TFX_TEAM_TASK_ID || "";
-  if (!team || !taskId) return null;
-  return {
-    team,
-    taskId,
-    agent: env.TFX_TEAM_AGENT_NAME || "agent",
-    lead: env.TFX_TEAM_LEAD_NAME || "team-lead",
-  };
-}
-
-export async function claimTask({ env = process.env, bridge } = {}) {
-  const ctx = teamContext(env);
-  if (!ctx) return { skipped: true };
-  const response = await bridge.claim({
-    team: ctx.team,
-    taskId: ctx.taskId,
-    owner: ctx.agent,
-    status: "in_progress",
-  });
-  if (response?.ok) return { claimed: true };
-  const code = response?.error?.code;
-  const before = response?.error?.details?.task_before ?? {};
-  if (
-    code === "CLAIM_CONFLICT" &&
-    before.owner === ctx.agent &&
-    before.status === "in_progress"
-  ) {
-    return { claimed: true, alreadyClaimed: true };
-  }
-  if (code === "CLAIM_CONFLICT") {
-    return { claimed: false, conflict: true, owner: before.owner ?? null };
-  }
-  return { claimed: false, error: response?.error ?? null };
-}
-
-export async function completeTask({
-  env = process.env,
-  bridge,
-  result = "success",
-  summary = "작업 완료",
-  now = () => new Date().toISOString(),
-} = {}) {
-  const ctx = teamContext(env);
-  if (!ctx) return { skipped: true };
-  const trimmed = String(summary).slice(0, 4096);
-  const response = await bridge.complete({
-    team: ctx.team,
-    taskId: ctx.taskId,
-    agent: ctx.agent,
-    result,
-    summary: trimmed,
-  });
-
-  const resultDir =
-    env.TFX_RESULT_DIR ||
-    join(process.env.HOME || ".", ".claude", "tfx-results", ctx.team);
-  mkdirSync(resultDir, { recursive: true });
-  writeFileSync(
-    join(resultDir, `${ctx.taskId}.json`),
-    `${JSON.stringify({
-      taskId: ctx.taskId,
-      agent: ctx.agent,
-      team: ctx.team,
-      result,
-      summary: trimmed,
-      timestamp: now(),
-    })}\n`,
-  );
-  return { completed: Boolean(response?.ok), response };
-}

package/scripts/lib/timeout.mjs

@@ -1,66 +0,0 @@
-import { spawn } from "node:child_process";
-
-export function timeoutCodeForSignal(signal) {
-  return signal ? 124 : null;
-}
-
-export function runWithTimeout(command, args = [], options = {}) {
-  const {
-    cwd = process.cwd(),
-    env = process.env,
-    input,
-    timeoutMs = 0,
-    stdio = "pipe",
-    spawnFn = spawn,
-  } = options;
-
-  return new Promise((resolve, reject) => {
-    const controller = new AbortController();
-    let timedOut = false;
-    const child = spawnFn(command, args, {
-      cwd,
-      env,
-      stdio,
-      signal: controller.signal,
-    });
-    const stdout = [];
-    const stderr = [];
-    let timer = null;
-
-    if (child.stdout) child.stdout.on("data", (chunk) => stdout.push(chunk));
-    if (child.stderr) child.stderr.on("data", (chunk) => stderr.push(chunk));
-    child.on("error", (err) => {
-      if (timedOut && err.name === "AbortError") return;
-      reject(err);
-    });
-    child.on("exit", (code, signal) => {
-      if (timer) clearTimeout(timer);
-      resolve({
-        code: timedOut ? 124 : (code ?? timeoutCodeForSignal(signal) ?? 1),
-        signal,
-        timedOut,
-        stdout: Buffer.concat(stdout).toString("utf8"),
-        stderr: Buffer.concat(stderr).toString("utf8"),
-      });
-    });
-
-    if (timeoutMs > 0) {
-      timer = setTimeout(() => {
-        timedOut = true;
-        controller.abort();
-        if (child.pid) {
-          try {
-            process.kill(child.pid, "SIGTERM");
-          } catch {
-            // Process already exited.
-          }
-        }
-      }, timeoutMs);
-      timer.unref?.();
-    }
-
-    if (input !== undefined && child.stdin) {
-      child.stdin.end(input);
-    }
-  });
-}

package/scripts/lib/tmp.mjs

@@ -1,26 +0,0 @@
-import { mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-export function resolveTmpDir({ env = process.env, cwd = process.cwd() } = {}) {
-  const candidate = env.TFX_TMP || tmpdir();
-  try {
-    mkdirSync(candidate, { recursive: true });
-    return candidate;
-  } catch {
-    const fallback = join(cwd, ".tfx-tmp");
-    try {
-      mkdirSync(fallback, { recursive: true });
-    } catch {
-      // Bash printed the fallback path even when mkdir failed.
-    }
-    return fallback;
-  }
-}
-
-export function resolveJobsDir({
-  env = process.env,
-  tmpDir = resolveTmpDir({ env }),
-} = {}) {
-  return env.TFX_JOBS_DIR || join(tmpDir, "tfx-jobs");
-}