@triflux/core 10.50.1 → 10.50.2

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");
-}

package/scripts/lib/toml.mjs

@@ -1,132 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname } from "node:path";
-import { sanitizeCodexProfileConfig } from "./codex-profile-config.mjs";
-
-const require = createRequire(import.meta.url);
-let TOML = null;
-try {
-  TOML = require("@iarna/toml");
-} catch {
-  TOML = null;
-}
-
-function walk(value, visitor) {
-  if (!value || typeof value !== "object") return;
-  for (const [key, child] of Object.entries(value)) {
-    visitor(value, key, child);
-    walk(child, visitor);
-  }
-}
-
-export function parseToml(source) {
-  if (!TOML) return parseTomlFallback(source);
-  return TOML.parse(source || "");
-}
-
-export function stringifyToml(value) {
-  if (!TOML) return stringifyTomlFallback(value);
-  return TOML.stringify(value);
-}
-
-function parseTomlFallback(source = "") {
-  const root = {};
-  let current = root;
-  for (const rawLine of String(source).split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    const section = line.match(/^\[([^\]]+)\]$/);
-    if (section) {
-      current = root;
-      for (const part of section[1].split(".")) {
-        current[part] ??= {};
-        current = current[part];
-      }
-      continue;
-    }
-    const assignment = line.match(/^([A-Za-z0-9_-]+)\s*=\s*"([^"]*)"$/);
-    if (assignment) {
-      current[assignment[1]] = assignment[2];
-    }
-  }
-  return root;
-}
-
-function stringifyTomlFallback(value) {
-  const lines = [];
-  for (const [key, child] of Object.entries(value)) {
-    if (child && typeof child === "object") continue;
-    lines.push(`${key} = "${String(child)}"`);
-  }
-  function writeSections(prefix, obj) {
-    for (const [key, child] of Object.entries(obj)) {
-      if (!child || typeof child !== "object") continue;
-      const section = [...prefix, key];
-      lines.push("", `[${section.join(".")}]`);
-      for (const [childKey, childValue] of Object.entries(child)) {
-        if (childValue && typeof childValue === "object") continue;
-        lines.push(`${childKey} = "${String(childValue)}"`);
-      }
-      writeSections(section, child);
-    }
-  }
-  writeSections([], value);
-  return `${lines.join("\n")}\n`;
-}
-
-export function detectTopLevelCodexConfig(source) {
-  const parsed = parseToml(source);
-  return {
-    hasTopLevelSandboxOrApproval:
-      Object.hasOwn(parsed, "sandbox") ||
-      Object.hasOwn(parsed, "approval_mode"),
-  };
-}
-
-export function patchMcpApprovalMode(source) {
-  const parsed = parseToml(source);
-  let count = 0;
-  walk(parsed.mcp_servers, (parent, key, value) => {
-    if (key === "approval_mode" && value === "approve") {
-      parent[key] = "full-auto";
-      count += 1;
-    }
-  });
-  return {
-    changed: count > 0,
-    count,
-    toml: count > 0 ? stringifyToml(parsed) : source,
-  };
-}
-
-export function patchCodexConfigFile(path, { now = () => new Date() } = {}) {
-  if (!path || !existsSync(path)) return { changed: false, count: 0 };
-  const source = readFileSync(path, "utf8");
-  const approvalPatched = patchMcpApprovalMode(source);
-  const profileSanitized = sanitizeCodexProfileConfig(approvalPatched.toml, {
-    codexHome: dirname(path),
-  });
-  const changed = approvalPatched.changed || profileSanitized.changed;
-  if (!changed) {
-    return {
-      changed: false,
-      count: 0,
-      removedProfiles: [],
-      migratedProfiles: [],
-    };
-  }
-  const stamp = now()
-    .toISOString()
-    .replace(/[-:]/g, "")
-    .replace(/\..*$/, "")
-    .replace("T", "-");
-  writeFileSync(`${path}.bak-${stamp}`, source);
-  writeFileSync(path, profileSanitized.toml);
-  return {
-    changed: true,
-    count: approvalPatched.count,
-    removedProfiles: profileSanitized.removedProfiles,
-    migratedProfiles: profileSanitized.migratedProfiles,
-    toml: profileSanitized.toml,
-  };
-}