@triflux/remote 10.1.0 → 10.26.0

package/scripts/lib/skill-template.mjs

@@ -0,0 +1,375 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import {
+  basename,
+  extname,
+  isAbsolute,
+  join,
+  relative,
+  resolve,
+} from "node:path";
+
+const IF_TAG_RE = /{{\s*(#if\s+([A-Za-z0-9_.-]+)|\/if)\s*}}/g;
+const PARTIAL_RE = /{{>\s*([A-Za-z0-9_./-]+)\s*}}/g;
+const FILE_INCLUDE_RE = /{{#include\s+([A-Za-z0-9_./-]+)\s*}}/g;
+const VARIABLE_RE = /{{\s*([A-Za-z0-9_.-]+)\s*}}/g;
+const FRONTMATTER_RE = /^---\r?\n(?:([\s\S]*?)\r?\n)?---\r?\n?/;
+
+function isTruthy(value) {
+  if (typeof value === "string") return value.trim().length > 0;
+  return Boolean(value);
+}
+
+function normalizeVariable(context, key) {
+  if (Object.hasOwn(context, key)) return context[key];
+  const upper = key.toUpperCase();
+  if (Object.hasOwn(context, upper)) return context[upper];
+  return undefined;
+}
+
+function parseBoolean(raw) {
+  if (typeof raw !== "string") return undefined;
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  return undefined;
+}
+
+function parseScalar(raw) {
+  if (raw == null) return "";
+  const value = raw.trim();
+  if (!value) return "";
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+  const bool = parseBoolean(value);
+  return bool ?? value;
+}
+
+function parseMultilineValue(lines, startIndex, marker) {
+  const fold = marker.startsWith(">");
+  const chunks = [];
+  let index = startIndex;
+
+  while (index + 1 < lines.length && /^\s+/.test(lines[index + 1])) {
+    index += 1;
+    chunks.push(lines[index].replace(/^\s+/, ""));
+  }
+
+  return {
+    index,
+    value: fold ? chunks.join(" ").trim() : chunks.join("\n").trim(),
+  };
+}
+
+function parseListValue(lines, startIndex) {
+  const items = [];
+  let index = startIndex;
+
+  while (index + 1 < lines.length) {
+    const nextLine = lines[index + 1];
+    const match = nextLine.match(/^\s*-\s+(.*)$/);
+    if (match) {
+      index += 1;
+      items.push(parseScalar(match[1]));
+      continue;
+    }
+    if (/^\s*$/.test(nextLine)) {
+      index += 1;
+      continue;
+    }
+    break;
+  }
+
+  return { index, value: items };
+}
+
+function parseFrontmatterBlock(block) {
+  const lines = block.split(/\r?\n/);
+  const data = {};
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match) continue;
+
+    const [, rawKey, rawValue] = match;
+    const key = rawKey.trim();
+    const value = rawValue.trim();
+
+    if (value === ">" || value === "|" || value === ">-" || value === "|-") {
+      const parsed = parseMultilineValue(lines, i, value);
+      data[key] = parsed.value;
+      i = parsed.index;
+      continue;
+    }
+
+    if (!value) {
+      const parsed = parseListValue(lines, i);
+      if (parsed.index !== i) {
+        data[key] = parsed.value;
+        i = parsed.index;
+        continue;
+      }
+    }
+
+    data[key] = parseScalar(value);
+  }
+
+  return data;
+}
+
+function evaluateConditionals(source, context) {
+  const matcher = new RegExp(IF_TAG_RE.source, "g");
+
+  function walk(startIndex, nested) {
+    let output = "";
+    let cursor = startIndex;
+
+    while (true) {
+      const found = matcher.exec(source);
+      if (!found) {
+        if (nested) throw new Error("Unclosed {{#if ...}} block in template");
+        output += source.slice(cursor);
+        return { output, index: source.length };
+      }
+
+      output += source.slice(cursor, found.index);
+      cursor = matcher.lastIndex;
+
+      const directive = found[1];
+      const flag = found[2];
+      if (directive.startsWith("#if")) {
+        const nestedResult = walk(cursor, true);
+        cursor = nestedResult.index;
+        matcher.lastIndex = cursor;
+        if (isTruthy(normalizeVariable(context, flag))) {
+          output += nestedResult.output;
+        }
+        continue;
+      }
+
+      if (!nested) {
+        throw new Error("Unexpected {{/if}} without matching {{#if ...}}");
+      }
+      return { output, index: cursor };
+    }
+  }
+
+  return walk(0, false).output;
+}
+
+function renderPartials(source, context, partials, options, includeStack) {
+  return source.replace(PARTIAL_RE, (_full, partialName) => {
+    const partial = partials[partialName];
+    if (partial == null) {
+      throw new Error(`Missing partial: ${partialName}`);
+    }
+    if (includeStack.includes(partialName)) {
+      const chain = [...includeStack, partialName].join(" -> ");
+      throw new Error(`Circular partial include: ${chain}`);
+    }
+    return renderWithContext(partial, context, partials, options, [
+      ...includeStack,
+      partialName,
+    ]);
+  });
+}
+
+function normalizeIncludeName(includeName) {
+  return includeName.replace(/\\/g, "/");
+}
+
+function resolveIncludeContent(includeName, options) {
+  const normalizedName = normalizeIncludeName(includeName);
+  if (Object.hasOwn(options.includes, normalizedName)) {
+    return options.includes[normalizedName];
+  }
+  if (!options.includeBaseDir) {
+    throw new Error(`Missing include: ${normalizedName}`);
+  }
+
+  const baseDir = resolve(options.includeBaseDir);
+  const fullPath = resolve(baseDir, normalizedName);
+  const relativePath = relative(baseDir, fullPath);
+  const isInsideBaseDir =
+    relativePath === "" ||
+    (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+
+  if (!isInsideBaseDir || !existsSync(fullPath)) {
+    throw new Error(`Missing include: ${normalizedName}`);
+  }
+
+  const content = readFileSync(fullPath, "utf8");
+  options.includes[normalizedName] = content;
+  return content;
+}
+
+function renderFileIncludes(source, context, partials, options, includeStack) {
+  return source.replace(FILE_INCLUDE_RE, (_full, includeName) => {
+    const normalizedName = normalizeIncludeName(includeName);
+    const content = resolveIncludeContent(normalizedName, options);
+    if (includeStack.includes(normalizedName)) {
+      const chain = [...includeStack, normalizedName].join(" -> ");
+      throw new Error(`Circular template include: ${chain}`);
+    }
+    return renderWithContext(content, context, partials, options, [
+      ...includeStack,
+      normalizedName,
+    ]);
+  });
+}
+
+function renderVariables(source, context) {
+  return source.replace(VARIABLE_RE, (full, key) => {
+    const value = normalizeVariable(context, key);
+    if (value == null) {
+      throw new Error(`Missing template variable: ${key}`);
+    }
+    return String(value);
+  });
+}
+
+function renderWithContext(
+  source,
+  context,
+  partials,
+  options,
+  includeStack = [],
+) {
+  const afterIf = evaluateConditionals(source, context);
+  const afterPartials = renderPartials(
+    afterIf,
+    context,
+    partials,
+    options,
+    includeStack,
+  );
+  const afterFileIncludes = renderFileIncludes(
+    afterPartials,
+    context,
+    partials,
+    options,
+    includeStack,
+  );
+  return renderVariables(afterFileIncludes, context);
+}
+
+function readAllTemplateFiles(rootDir, currentDir = rootDir) {
+  if (!rootDir || !existsSync(rootDir)) return [];
+
+  const entries = readdirSync(currentDir, { withFileTypes: true }).sort(
+    (left, right) => left.name.localeCompare(right.name),
+  );
+  const files = [];
+
+  for (const entry of entries) {
+    const fullPath = join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...readAllTemplateFiles(rootDir, fullPath));
+      continue;
+    }
+
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith(".md") && !entry.name.endsWith(".tmpl")) continue;
+
+    const relativePath = relative(rootDir, fullPath).replace(/\\/g, "/");
+    const content = readFileSync(fullPath, "utf8");
+    files.push({ fullPath, relativePath, content });
+  }
+
+  return files;
+}
+
+function setPartial(partials, key, value) {
+  if (!key) return;
+  if (!Object.hasOwn(partials, key)) {
+    partials[key] = value;
+  }
+}
+
+export function parseFrontmatter(source) {
+  const match = source.match(FRONTMATTER_RE);
+  if (!match) return { data: {}, body: source };
+
+  const data = parseFrontmatterBlock(match[1] ?? "");
+  const body = source.slice(match[0].length);
+  return { data, body };
+}
+
+export function buildSkillTemplateContext({
+  frontmatter = {},
+  skillDirName = "",
+} = {}) {
+  const context = { ...frontmatter };
+  const skillName = String(frontmatter.name || skillDirName || "").trim();
+  const skillDescription = String(frontmatter.description || "").trim();
+
+  let deep = frontmatter.DEEP ?? frontmatter.deep;
+  if (typeof deep === "string") {
+    const parsed = parseBoolean(deep.trim().toLowerCase());
+    deep = parsed ?? deep;
+  }
+  if (typeof deep !== "boolean") {
+    deep = /(^|[-_])deep($|[-_])/i.test(skillName);
+  }
+
+  context.SKILL_NAME = skillName;
+  context.SKILL_DESCRIPTION = skillDescription;
+  context.DEEP = deep;
+  return context;
+}
+
+export function loadTemplatePartials(partialsDir) {
+  const files = readAllTemplateFiles(partialsDir);
+  const partials = {};
+
+  for (const file of files) {
+    const extension = extname(file.relativePath);
+    const withoutExt = extension
+      ? file.relativePath.slice(0, -extension.length)
+      : file.relativePath;
+    const normalized = withoutExt.replace(/\\/g, "/");
+    const base = basename(normalized);
+
+    setPartial(partials, normalized, file.content);
+    setPartial(partials, base, file.content);
+  }
+
+  return partials;
+}
+
+export function loadSkillManifest(skillDir) {
+  const manifestPath = join(skillDir, "skill.json");
+  if (!existsSync(manifestPath)) return null;
+
+  const raw = readFileSync(manifestPath, "utf8");
+  return JSON.parse(raw);
+}
+
+export function parseFrontmatterWithManifest(source, skillDir) {
+  const manifest = skillDir ? loadSkillManifest(skillDir) : null;
+  const { data: yamlData, body } = parseFrontmatter(source);
+
+  if (!manifest) return { data: yamlData, body };
+
+  const merged = { ...yamlData };
+  if (manifest.name) merged.name = manifest.name;
+  if (manifest.description) merged.description = manifest.description;
+  if (manifest.triggers) merged.triggers = manifest.triggers;
+  if (manifest.argument_hint) merged["argument-hint"] = manifest.argument_hint;
+  if (manifest.internal != null) merged.internal = manifest.internal;
+  if (manifest.deprecated != null) merged.deprecated = manifest.deprecated;
+  if (manifest.superseded_by) merged["superseded-by"] = manifest.superseded_by;
+
+  return { data: merged, body };
+}
+
+export function renderSkillTemplate(template, context = {}, options = {}) {
+  const { partials = {}, includes = {}, includeBaseDir = "" } = options;
+  return renderWithContext(template, context, partials, {
+    includeBaseDir,
+    includes: { ...includes },
+  });
+}

package/scripts/lib/team.mjs

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+
+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 patched = patchMcpApprovalMode(source);
+  if (!patched.changed) return patched;
+  const stamp = now()
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .replace(/\..*$/, "")
+    .replace("T", "-");
+  writeFileSync(`${path}.bak-${stamp}`, source);
+  writeFileSync(path, patched.toml);
+  return patched;
+}