@triflux/core 10.50.1 → 10.51.0

package/mesh/mesh-protocol.mjs

@@ -1,96 +0,0 @@
-import { randomUUID } from "node:crypto";
-
-export const MSG_TYPES = Object.freeze({
-  REQUEST: "request",
-  RESPONSE: "response",
-  EVENT: "event",
-  HEARTBEAT: "heartbeat",
-});
-
-const VALID_TYPES = new Set(Object.values(MSG_TYPES));
-
-/**
- * Creates an immutable mesh message.
- * @param {string} type - One of MSG_TYPES values
- * @param {string} from - Sender agent ID
- * @param {string} to - Recipient agent ID (or "*" for broadcast)
- * @param {unknown} payload - Message payload
- * @returns {Readonly<object>}
- */
-export function createMessage(type, from, to, payload = null) {
-  if (!VALID_TYPES.has(type)) {
-    throw new TypeError(`Invalid message type: ${type}`);
-  }
-  if (!from || typeof from !== "string") {
-    throw new TypeError("from must be a non-empty string");
-  }
-  if (!to || typeof to !== "string") {
-    throw new TypeError("to must be a non-empty string");
-  }
-  return Object.freeze({
-    type,
-    from,
-    to,
-    payload,
-    timestamp: new Date().toISOString(),
-    correlationId: randomUUID(),
-  });
-}
-
-/**
- * Serializes a message to a JSON string.
- * @param {object} message
- * @returns {string}
- */
-export function serialize(message) {
-  return JSON.stringify(message);
-}
-
-/**
- * Deserializes a JSON string to a message object.
- * @param {string} raw
- * @returns {object}
- */
-export function deserialize(raw) {
-  if (typeof raw !== "string") {
-    throw new TypeError("raw must be a string");
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new SyntaxError(`Failed to parse message: ${raw}`);
-  }
-  return parsed;
-}
-
-/**
- * Validates a message object.
- * @param {unknown} message
- * @returns {{ valid: boolean, errors: string[] }}
- */
-export function validate(message) {
-  const errors = [];
-
-  if (!message || typeof message !== "object") {
-    return { valid: false, errors: ["message must be an object"] };
-  }
-
-  if (!VALID_TYPES.has(message.type)) {
-    errors.push(`Invalid type: ${message.type}`);
-  }
-  if (!message.from || typeof message.from !== "string") {
-    errors.push("from must be a non-empty string");
-  }
-  if (!message.to || typeof message.to !== "string") {
-    errors.push("to must be a non-empty string");
-  }
-  if (!message.timestamp || typeof message.timestamp !== "string") {
-    errors.push("timestamp must be a non-empty string");
-  }
-  if (!message.correlationId || typeof message.correlationId !== "string") {
-    errors.push("correlationId must be a non-empty string");
-  }
-
-  return { valid: errors.length === 0, errors };
-}

package/mesh/mesh-queue.mjs

@@ -1,163 +0,0 @@
-const DEFAULT_MAX_QUEUE_SIZE = 100;
-const DEFAULT_TTL_MS = 0; // 0 = no expiry
-
-/**
- * Creates a per-agent message queue with TTL and size limits.
- *
- * @param {object} [opts]
- * @param {number} [opts.maxQueueSize=100] - Max messages per agent queue
- * @param {number} [opts.ttlMs=0]         - Message TTL in ms (0 = no expiry)
- * @returns {object} Queue API
- */
-export function createMessageQueue(opts = {}) {
-  const { maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, ttlMs = DEFAULT_TTL_MS } =
-    opts;
-
-  /** @type {Map<string, Array<{ message: object, enqueuedAt: number }>>} */
-  const queues = new Map();
-
-  /**
-   * Returns the queue array for an agent (creates if absent).
-   * @param {string} agentId
-   * @returns {Array}
-   */
-  function getQueue(agentId) {
-    let q = queues.get(agentId);
-    if (!q) {
-      q = [];
-      queues.set(agentId, q);
-    }
-    return q;
-  }
-
-  /**
-   * Removes expired messages from the front of a queue.
-   * @param {Array} q
-   * @param {number} now
-   */
-  function purgeExpired(q, now) {
-    if (ttlMs <= 0) return;
-    while (q.length > 0 && now - q[0].enqueuedAt > ttlMs) {
-      q.shift();
-    }
-  }
-
-  /**
-   * Adds a message to the target agent's queue.
-   * If queue exceeds maxQueueSize, the oldest message is dropped.
-   *
-   * @param {string} agentId - Target agent
-   * @param {object} message - Mesh message
-   * @returns {{ queued: boolean, dropped: boolean }}
-   */
-  function enqueue(agentId, message) {
-    if (!agentId || typeof agentId !== "string") {
-      throw new TypeError("agentId must be a non-empty string");
-    }
-    const q = getQueue(agentId);
-    const now = Date.now();
-
-    purgeExpired(q, now);
-
-    let dropped = false;
-    if (q.length >= maxQueueSize) {
-      q.shift();
-      dropped = true;
-    }
-
-    q.push({ message, enqueuedAt: now });
-    return { queued: true, dropped };
-  }
-
-  /**
-   * Removes and returns the next message for an agent.
-   *
-   * @param {string} agentId
-   * @returns {object | null} The message, or null if queue is empty
-   */
-  function dequeue(agentId) {
-    const q = queues.get(agentId);
-    if (!q || q.length === 0) return null;
-
-    const now = Date.now();
-    purgeExpired(q, now);
-
-    if (q.length === 0) return null;
-    return q.shift().message;
-  }
-
-  /**
-   * Returns the next message without removing it.
-   *
-   * @param {string} agentId
-   * @returns {object | null}
-   */
-  function peek(agentId) {
-    const q = queues.get(agentId);
-    if (!q || q.length === 0) return null;
-
-    const now = Date.now();
-    purgeExpired(q, now);
-
-    if (q.length === 0) return null;
-    return q[0].message;
-  }
-
-  /**
-   * Returns the number of (non-expired) messages in an agent's queue.
-   *
-   * @param {string} agentId
-   * @returns {number}
-   */
-  function size(agentId) {
-    const q = queues.get(agentId);
-    if (!q) return 0;
-
-    const now = Date.now();
-    purgeExpired(q, now);
-
-    return q.length;
-  }
-
-  /**
-   * Drains all messages for an agent.
-   *
-   * @param {string} agentId
-   * @returns {object[]} Array of messages
-   */
-  function drain(agentId) {
-    const q = queues.get(agentId);
-    if (!q || q.length === 0) return [];
-
-    const now = Date.now();
-    purgeExpired(q, now);
-
-    const messages = q.map((entry) => entry.message);
-    q.length = 0;
-    return messages;
-  }
-
-  /**
-   * Removes an agent's queue entirely.
-   * @param {string} agentId
-   */
-  function clear(agentId) {
-    queues.delete(agentId);
-  }
-
-  /**
-   * Returns total message count across all agent queues.
-   * @returns {number}
-   */
-  function totalSize() {
-    let total = 0;
-    const now = Date.now();
-    for (const [, q] of queues) {
-      purgeExpired(q, now);
-      total += q.length;
-    }
-    return total;
-  }
-
-  return { enqueue, dequeue, peek, size, drain, clear, totalSize };
-}

package/mesh/mesh-registry.mjs

@@ -1,78 +0,0 @@
-/**
- * Creates an agent registry for the mesh network.
- * Agents register with capabilities; registry enables discovery.
- * @returns {object} Registry API
- */
-export function createRegistry() {
-  // Map<agentId, AgentInfo>
-  const agents = new Map();
-
-  /**
-   * Registers an agent with the registry.
-   * @param {string} agentId
-   * @param {string[]} capabilities
-   */
-  function register(agentId, capabilities = []) {
-    if (!agentId || typeof agentId !== "string") {
-      throw new TypeError("agentId must be a non-empty string");
-    }
-    if (!Array.isArray(capabilities)) {
-      throw new TypeError("capabilities must be an array");
-    }
-    const info = Object.freeze({
-      agentId,
-      capabilities: Object.freeze([...capabilities]),
-      registeredAt: new Date().toISOString(),
-    });
-    agents.set(agentId, info);
-  }
-
-  /**
-   * Unregisters an agent from the registry.
-   * @param {string} agentId
-   */
-  function unregister(agentId) {
-    agents.delete(agentId);
-  }
-
-  /**
-   * Discovers agents that have a specific capability.
-   * @param {string} capability
-   * @returns {string[]} Array of agentIds
-   */
-  function discover(capability) {
-    const result = [];
-    for (const [agentId, info] of agents) {
-      if (info.capabilities.includes(capability)) {
-        result.push(agentId);
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Gets agent info by ID.
-   * @param {string} agentId
-   * @returns {object | null}
-   */
-  function getAgent(agentId) {
-    return agents.get(agentId) ?? null;
-  }
-
-  /**
-   * Lists all registered agents.
-   * @returns {object[]}
-   */
-  function listAll() {
-    return [...agents.values()];
-  }
-
-  /**
-   * Clears all registered agents.
-   */
-  function clear() {
-    agents.clear();
-  }
-
-  return { register, unregister, discover, getAgent, listAll, clear };
-}

package/mesh/mesh-router.mjs

@@ -1,77 +0,0 @@
-import { validate } from "./mesh-protocol.mjs";
-
-/**
- * Routes a mesh message to target agent(s) based on the `to` field.
- *
- * Addressing modes:
- *   - "agent-id"       → direct delivery (registry lookup)
- *   - "*"              → broadcast to all registered agents
- *   - "capability:X"   → discover agents with capability X
- *
- * @param {object} message  - A mesh-protocol message
- * @param {object} registry - A mesh-registry instance
- * @returns {{ routed: boolean, targets?: string[], reason?: string }}
- */
-export function routeMessage(message, registry) {
-  const { valid, errors } = validate(message);
-  if (!valid) {
-    return { routed: false, reason: `invalid message: ${errors.join(", ")}` };
-  }
-
-  const { to, from } = message;
-
-  // Broadcast
-  if (to === "*") {
-    const all = registry.listAll();
-    const targets = all.map((a) => a.agentId).filter((id) => id !== from);
-    if (targets.length === 0) {
-      return { routed: false, reason: "broadcast: no agents registered" };
-    }
-    return { routed: true, targets };
-  }
-
-  // Capability-based routing
-  if (to.startsWith("capability:")) {
-    const capability = to.slice("capability:".length);
-    if (!capability) {
-      return { routed: false, reason: "capability: empty capability name" };
-    }
-    const targets = registry.discover(capability);
-    if (targets.length === 0) {
-      return {
-        routed: false,
-        reason: `capability: no agents with "${capability}"`,
-      };
-    }
-    return { routed: true, targets };
-  }
-
-  // Direct addressing
-  const agent = registry.getAgent(to);
-  if (!agent) {
-    return { routed: false, reason: `agent not found: "${to}"` };
-  }
-  return { routed: true, targets: [to] };
-}
-
-/**
- * Routes a message and collects dead-letter info when delivery fails.
- *
- * @param {object} message
- * @param {object} registry
- * @returns {{ routed: boolean, targets?: string[], deadLetter?: object }}
- */
-export function routeOrDeadLetter(message, registry) {
-  const result = routeMessage(message, registry);
-  if (!result.routed) {
-    return {
-      ...result,
-      deadLetter: {
-        originalMessage: message,
-        reason: result.reason,
-        timestamp: new Date().toISOString(),
-      },
-    };
-  }
-  return result;
-}

package/scripts/lib/agent-json.mjs

@@ -1,27 +0,0 @@
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-export function agentJsonPath({ tmpDir, pid = process.pid }) {
-  return join(tmpDir, `tfx-agent-${pid}.json`);
-}
-
-export function registerAgent({
-  tmpDir,
-  pid = process.pid,
-  cli = "",
-  agent = "",
-  started = Math.floor(Date.now() / 1000),
-}) {
-  mkdirSync(tmpDir, { recursive: true });
-  const file = agentJsonPath({ tmpDir, pid });
-  writeFileSync(
-    file,
-    `${JSON.stringify({ pid, cli, agent, started })}\n`,
-    "utf8",
-  );
-  return file;
-}
-
-export function removeAgent({ tmpDir, pid = process.pid }) {
-  rmSync(agentJsonPath({ tmpDir, pid }), { force: true });
-}

package/scripts/lib/async.mjs

@@ -1,174 +0,0 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-
-function jobDir(jobsDir, jobId) {
-  return join(jobsDir, jobId);
-}
-
-function readState(dir) {
-  const path = join(dir, "state.json");
-  if (!existsSync(path)) return null;
-  return JSON.parse(readFileSync(path, "utf8"));
-}
-
-function writeState(dir, state) {
-  writeFileSync(join(dir, "state.json"), `${JSON.stringify(state, null, 2)}\n`);
-}
-
-function fileSize(path) {
-  try {
-    return statSync(path).size;
-  } catch {
-    return 0;
-  }
-}
-
-function isAlive(pid) {
-  if (!pid || pid === "starting") return false;
-  try {
-    process.kill(Number(pid), 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function createJob({
-  jobsDir,
-  command,
-  args = [],
-  env = process.env,
-  cwd = process.cwd(),
-  timeoutMs = 0,
-}) {
-  mkdirSync(jobsDir, { recursive: true });
-  const id = randomUUID();
-  const dir = jobDir(jobsDir, id);
-  mkdirSync(dir, { recursive: true });
-  const startedAt = Date.now();
-  const stdoutPath = join(dir, "result.log");
-  const stderrPath = join(dir, "stderr.log");
-  writeState(dir, {
-    id,
-    state: "starting",
-    startedAt,
-    command,
-    args,
-    timeoutMs,
-  });
-  writeFileSync(join(dir, "pid"), "starting");
-  writeFileSync(join(dir, "start_time"), String(Math.floor(startedAt / 1000)));
-
-  const child = spawn(command, args, {
-    cwd,
-    env,
-    detached: true,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  child.unref?.();
-  writeFileSync(join(dir, "pid"), String(child.pid));
-  writeState(dir, {
-    id,
-    state: "running",
-    pid: child.pid,
-    startedAt,
-    command,
-    args,
-    timeoutMs,
-  });
-  child.stdout?.on("data", (chunk) => {
-    writeFileSync(stdoutPath, chunk, { flag: "a" });
-  });
-  child.stderr?.on("data", (chunk) => {
-    writeFileSync(stderrPath, chunk, { flag: "a" });
-  });
-  let timer = null;
-  let timedOut = false;
-  if (timeoutMs > 0) {
-    timer = setTimeout(() => {
-      timedOut = true;
-      try {
-        process.kill(child.pid, "SIGTERM");
-      } catch {
-        // Process already exited.
-      }
-    }, timeoutMs);
-    timer.unref?.();
-  }
-  child.on("exit", (code) => {
-    if (timer) clearTimeout(timer);
-    const exitCode = timedOut ? 124 : (code ?? 1);
-    writeFileSync(join(dir, "exit_code"), String(exitCode));
-    writeFileSync(join(dir, "done"), "");
-    writeState(dir, {
-      id,
-      state: exitCode === 0 ? "done" : exitCode === 124 ? "timeout" : "failed",
-      pid: child.pid,
-      startedAt,
-      finishedAt: Date.now(),
-      exitCode,
-      command,
-      args,
-      timeoutMs,
-    });
-  });
-
-  return { id, dir, pid: child.pid };
-}
-
-export function getJobStatus(jobId, { jobsDir }) {
-  const dir = jobDir(jobsDir, jobId);
-  if (!existsSync(dir))
-    return { state: "error", text: "error: job not found", exitCode: 1 };
-  const state = readState(dir);
-  if (state?.state === "done") return { ...state, text: "done" };
-  if (state?.state === "timeout") return { ...state, text: "timeout" };
-  if (state?.state === "failed") return { ...state, text: "failed" };
-  const pidText = existsSync(join(dir, "pid"))
-    ? readFileSync(join(dir, "pid"), "utf8").trim()
-    : "";
-  if (pidText === "starting")
-    return { ...(state ?? {}), state: "starting", text: "starting" };
-  if (isAlive(pidText)) {
-    const start =
-      Number(readFileSync(join(dir, "start_time"), "utf8")) ||
-      Math.floor(Date.now() / 1000);
-    const elapsed = Math.max(0, Math.floor(Date.now() / 1000) - start);
-    const bytes = fileSize(join(dir, "result.log"));
-    return {
-      ...(state ?? {}),
-      state: "running",
-      text: `running elapsed=${elapsed}s output=${bytes}B`,
-    };
-  }
-  return { ...(state ?? {}), state: "failed", text: "failed" };
-}
-
-export function getJobResult(jobId, { jobsDir }) {
-  const dir = jobDir(jobsDir, jobId);
-  if (!existsSync(dir)) throw new Error("job not found");
-  const status = getJobStatus(jobId, { jobsDir });
-  if (!["done", "timeout", "failed"].includes(status.state)) {
-    throw new Error("job still running");
-  }
-  const stdout = existsSync(join(dir, "result.log"))
-    ? readFileSync(join(dir, "result.log"), "utf8")
-    : "";
-  const stderr = existsSync(join(dir, "stderr.log"))
-    ? readFileSync(join(dir, "stderr.log"), "utf8")
-    : "";
-  return {
-    state: status.state,
-    exitCode: status.exitCode ?? 1,
-    stdout: stdout || stderr,
-    stderr,
-  };
-}

package/scripts/lib/cli-agy.mjs

@@ -1,85 +0,0 @@
-// cli-agy.mjs — Antigravity (agy) CLI adapter (Phase 0 PoC).
-//
-// 책임: agy 1.1.27 부터 --print 는 값(프롬프트)이 필수이고 stdin 프롬프트는 거부되므로
-// plan() 은 프롬프트를 args 의 --print 값으로 넣고 stdinMode="argv" 를 돌려준다.
-// --print 뒤에 다른 플래그가 오면 그 플래그를 프롬프트로 삼키므로 항상 마지막에 둔다.
-//
-// 출처: scripts/tfx-route.sh route_agent() L1052-L1059, run_codex_exec() L2036-L2046.
-//        .claude/rules/tfx-update-logic.md Antigravity CLI 1.0.0 정밀 sanity matrix.
-// timeoutSec은 lane 예상 소요 시간(advisory)이다. hard ceiling 집행은 Bash route가 소유한다.
-
-import {
-  resolveGeminiModel,
-  resolveGeminiProfileForPurpose,
-} from "./gemini-profiles.mjs";
-
-export const id = "agy";
-export const cliType = "antigravity";
-export const command = "agy";
-
-// #310: agent-map.json normalizes upstream callers to antigravity,
-// but this adapter also accepts the direct `agy` route for compatibility.
-const AGENT_PROFILES = {
-  antigravity: {
-    profile: "agy_v1",
-    timeoutSec: 900,
-    runMode: "bg",
-    opusOversight: false,
-    mcpHint: "docs",
-  },
-  agy: {
-    profile: "agy_v1",
-    timeoutSec: 900,
-    runMode: "bg",
-    opusOversight: false,
-    mcpHint: "docs",
-  },
-};
-
-const DEFAULT_PROFILE = AGENT_PROFILES.antigravity;
-
-export function plan({
-  agent,
-  prompt = "",
-  mcpProfile = "auto",
-  timeoutSec,
-  contextFile,
-  geminiProfilesPath,
-} = {}) {
-  if (!agent) {
-    throw new Error("[cli-agy] agent required");
-  }
-  const cfg = AGENT_PROFILES[agent] ?? DEFAULT_PROFILE;
-  const effectiveTimeoutSec =
-    Number.isFinite(timeoutSec) && timeoutSec > 0 ? timeoutSec : cfg.timeoutSec;
-  return {
-    command,
-    profile: cfg.profile,
-    effort: cfg.profile,
-    // effort 는 역할별 SSOT(gemini-profiles.mjs): designer → High, writer → Medium ...
-    geminiProfile: resolveGeminiProfileForPurpose(agent),
-    model: resolveGeminiModel(resolveGeminiProfileForPurpose(agent), {
-      profilesPath: geminiProfilesPath,
-    }),
-    args: [
-      "--dangerously-skip-permissions",
-      "--model",
-      resolveGeminiModel(resolveGeminiProfileForPurpose(agent), {
-        profilesPath: geminiProfilesPath,
-      }),
-      "--print",
-      prompt,
-    ],
-    stdinMode: "argv",
-    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(AGENT_PROFILES) };
-}