triflux 10.3.4 → 10.7.0

package/scripts/__tests__/keyword-detector.test.mjs

@@ -5,7 +5,12 @@ import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
-import { compileRules, loadRules, matchRules, resolveConflicts } from "../lib/keyword-rules.mjs";
+import {
+  compileRules,
+  loadRules,
+  matchRules,
+  resolveConflicts,
+} from "../lib/keyword-rules.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const projectRoot = resolve(__dirname, "..", "..");
@@ -37,7 +42,7 @@ function runDetector(prompt) {
   const payload = { prompt, cwd: projectRoot };
   const result = spawnSync(process.execPath, [detectorScriptPath], {
     input: JSON.stringify(payload),
-    encoding: "utf8"
+    encoding: "utf8",
   });
 
   assert.equal(result.status, 0, result.stderr);
@@ -50,29 +55,32 @@ test("extractPrompt: prompt/message.content/parts[].text 우선순위", () => {
     extractPrompt({
       prompt: "from prompt",
       message: { content: "from message" },
-      parts: [{ text: "from parts" }]
+      parts: [{ text: "from parts" }],
     }),
-    "from prompt"
+    "from prompt",
   );
 
   assert.equal(
     extractPrompt({
       prompt: "   ",
       message: { content: "from message" },
-      parts: [{ text: "from parts" }]
+      parts: [{ text: "from parts" }],
     }),
-    "from message"
+    "from message",
   );
 
   assert.equal(
     extractPrompt({
       message: { content: [{ text: "from message-part" }] },
-      parts: [{ text: "from parts" }]
+      parts: [{ text: "from parts" }],
     }),
-    "from message-part"
+    "from message-part",
   );
 
-  assert.equal(extractPrompt({ parts: [{ text: "from parts" }] }), "from parts");
+  assert.equal(
+    extractPrompt({ parts: [{ text: "from parts" }] }),
+    "from parts",
+  );
 });
 
 test("sanitizeForKeywordDetection: 코드블록/URL/파일경로/XML 태그 제거", () => {
@@ -84,7 +92,7 @@ test("sanitizeForKeywordDetection: 코드블록/URL/파일경로/XML 태그 제
     "https://example.com/path?q=1",
     "C:\\Users\\SSAFY\\Desktop\\Projects\\tools\\triflux",
     "./hooks/keyword-rules.json",
-    "<tag>jira 이슈 생성</tag>"
+    "<tag>jira 이슈 생성</tag>",
   ].join("\n");
 
   const sanitized = sanitizeForKeywordDetection(input);
@@ -142,8 +150,8 @@ test("compileRules: 정규식 컴파일 실패", () => {
       supersedes: [],
       exclusive: false,
       state: null,
-      mcp_route: null
-    }
+      mcp_route: null,
+    },
   ]);
 
   assert.deepEqual(compiled, []);
@@ -156,30 +164,64 @@ test("matchRules: tfx 키워드 매칭", () => {
     { text: "tfx auto 돌려줘", expectedId: "tfx-unified" },
     { text: "tfx codex 로 실행", expectedId: "tfx-codex" },
     { text: "tfx gemini 로 실행", expectedId: "tfx-gemini" },
-    { text: "canceltfx", expectedId: "tfx-cancel" }
+    { text: "canceltfx", expectedId: "tfx-cancel" },
   ];
 
   for (const { text, expectedId } of cases) {
     const clean = sanitizeForKeywordDetection(text);
     const matches = matchRules(compiledRules, clean);
-    assert.ok(matches.some((match) => match.id === expectedId), `${text} => ${expectedId} 미매칭`);
+    assert.ok(
+      matches.some((match) => match.id === expectedId),
+      `${text} => ${expectedId} 미매칭`,
+    );
   }
 });
 
 test("matchRules: MCP 라우팅 매칭", () => {
   const compiledRules = loadCompiledRules();
   const cases = [
-    { text: "노션 페이지 조회해줘", expectedId: "notion-route", expectedRoute: "gemini" },
-    { text: "jira 이슈 생성", expectedId: "jira-route", expectedRoute: "codex" },
-    { text: "크롬 열고 로그인", expectedId: "chrome-route", expectedRoute: "gemini" },
-    { text: "이메일 보내줘", expectedId: "mail-route", expectedRoute: "gemini" },
-    { text: "캘린더 일정 생성", expectedId: "calendar-route", expectedRoute: "gemini" },
-    { text: "playwright 테스트 작성", expectedId: "playwright-route", expectedRoute: "gemini" },
-    { text: "canva 디자인 생성", expectedId: "canva-route", expectedRoute: "gemini" }
+    {
+      text: "노션 페이지 조회해줘",
+      expectedId: "notion-route",
+      expectedRoute: "gemini",
+    },
+    {
+      text: "jira 이슈 생성",
+      expectedId: "jira-route",
+      expectedRoute: "codex",
+    },
+    {
+      text: "크롬 열고 로그인",
+      expectedId: "chrome-route",
+      expectedRoute: "gemini",
+    },
+    {
+      text: "이메일 보내줘",
+      expectedId: "mail-route",
+      expectedRoute: "gemini",
+    },
+    {
+      text: "캘린더 일정 생성",
+      expectedId: "calendar-route",
+      expectedRoute: "gemini",
+    },
+    {
+      text: "playwright 테스트 작성",
+      expectedId: "playwright-route",
+      expectedRoute: "gemini",
+    },
+    {
+      text: "canva 디자인 생성",
+      expectedId: "canva-route",
+      expectedRoute: "gemini",
+    },
   ];
 
   for (const { text, expectedId, expectedRoute } of cases) {
-    const matches = matchRules(compiledRules, sanitizeForKeywordDetection(text));
+    const matches = matchRules(
+      compiledRules,
+      sanitizeForKeywordDetection(text),
+    );
     const matched = matches.find((match) => match.id === expectedId);
     assert.ok(matched, `${text} => ${expectedId} 미매칭`);
     assert.equal(matched.mcp_route, expectedRoute);
@@ -188,7 +230,10 @@ test("matchRules: MCP 라우팅 매칭", () => {
 
 test("matchRules: 일반 대화는 매칭 없음", () => {
   const compiledRules = loadCompiledRules();
-  const matches = matchRules(compiledRules, sanitizeForKeywordDetection("오늘 점심 메뉴 추천해줘"));
+  const matches = matchRules(
+    compiledRules,
+    sanitizeForKeywordDetection("오늘 점심 메뉴 추천해줘"),
+  );
   assert.deepEqual(matches, []);
 });
 
@@ -197,12 +242,12 @@ test("resolveConflicts: priority 정렬 및 supersedes 처리", () => {
     { id: "rule-c", priority: 3, supersedes: [], exclusive: false },
     { id: "rule-b", priority: 2, supersedes: ["rule-c"], exclusive: false },
     { id: "rule-a", priority: 1, supersedes: [], exclusive: false },
-    { id: "rule-a", priority: 1, supersedes: [], exclusive: false }
+    { id: "rule-a", priority: 1, supersedes: [], exclusive: false },
   ]);
 
   assert.deepEqual(
     resolved.map((rule) => rule.id),
-    ["rule-a", "rule-b"]
+    ["rule-a", "rule-b"],
   );
 });
 
@@ -210,10 +255,13 @@ test("resolveConflicts: exclusive 처리", () => {
   const resolved = resolveConflicts([
     { id: "normal", priority: 1, supersedes: [], exclusive: false },
     { id: "exclusive", priority: 0, supersedes: [], exclusive: true },
-    { id: "later", priority: 2, supersedes: [], exclusive: false }
+    { id: "later", priority: 2, supersedes: [], exclusive: false },
   ]);
 
-  assert.deepEqual(resolved.map((rule) => rule.id), ["exclusive"]);
+  assert.deepEqual(
+    resolved.map((rule) => rule.id),
+    ["exclusive"],
+  );
 });
 
 test("코드블록 내 키워드: sanitize 후 매칭 안 됨", () => {
@@ -229,6 +277,7 @@ test("OMC 키워드와 triflux 키워드 비간섭 + TRIFLUX 네임스페이스"
   assert.equal(omcLike.suppressOutput, true);
 
   const triflux = runDetector("tfx multi 세션 시작");
-  const additionalContext = triflux?.hookSpecificOutput?.additionalContext || "";
+  const additionalContext =
+    triflux?.hookSpecificOutput?.additionalContext || "";
   assert.match(additionalContext, /^\[TRIFLUX MAGIC KEYWORD: tfx-multi\]/);
 });

package/scripts/__tests__/mcp-guard-engine.test.mjs

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { describe, it, afterEach } from "node:test";
+import { afterEach, describe, it } from "node:test";
 import { fileURLToPath } from "node:url";
 
 import {
@@ -22,7 +22,10 @@ const originalHome = {
 };
 
 function createHomeDir(prefix = "mcp-guard-") {
-  const base = join(tmpdir(), `${prefix}${Date.now()}-${Math.random().toString(16).slice(2)}`);
+  const base = join(
+    tmpdir(),
+    `${prefix}${Date.now()}-${Math.random().toString(16).slice(2)}`,
+  );
   mkdirSync(base, { recursive: true });
   mkdirSync(join(base, ".gemini"), { recursive: true });
   mkdirSync(join(base, ".claude", "cache", "tfx-hub"), { recursive: true });
@@ -58,9 +61,18 @@ describe("mcp guard engine", () => {
     const homeDir = createHomeDir();
     withHome(homeDir);
 
-    assert.equal(isWatchedPath(join(homeDir, ".gemini", "settings.json")), true);
-    assert.equal(isWatchedPath(join(PROJECT_ROOT, "nested", ".mcp.json")), true);
-    assert.equal(isWatchedPath(join(PROJECT_ROOT, "nested", "settings.yaml")), false);
+    assert.equal(
+      isWatchedPath(join(homeDir, ".gemini", "settings.json")),
+      true,
+    );
+    assert.equal(
+      isWatchedPath(join(PROJECT_ROOT, "nested", ".mcp.json")),
+      true,
+    );
+    assert.equal(
+      isWatchedPath(join(PROJECT_ROOT, "nested", "settings.yaml")),
+      false,
+    );
   });
 
   it("detects stdio MCP servers from JSON config", () => {
@@ -68,15 +80,25 @@ describe("mcp guard engine", () => {
     withHome(homeDir);
 
     const settingsPath = join(homeDir, ".gemini", "settings.json");
-    writeFileSync(settingsPath, JSON.stringify({
-      mcpServers: {
-        "unsafe-stdio": { command: "node", args: ["server.js"] },
-        "safe-url": { url: "http://127.0.0.1:27888/mcp" },
-      },
-    }, null, 2));
+    writeFileSync(
+      settingsPath,
+      JSON.stringify(
+        {
+          mcpServers: {
+            "unsafe-stdio": { command: "node", args: ["server.js"] },
+            "safe-url": { url: "http://127.0.0.1:27888/mcp" },
+          },
+        },
+        null,
+        2,
+      ),
+    );
 
     const found = scanForStdioServers(settingsPath);
-    assert.deepEqual(found.map((server) => server.name), ["unsafe-stdio"]);
+    assert.deepEqual(
+      found.map((server) => server.name),
+      ["unsafe-stdio"],
+    );
   });
 
   it("replaces stdio MCP entries with tfx-hub and writes a backup", () => {
@@ -84,22 +106,38 @@ describe("mcp guard engine", () => {
     withHome(homeDir);
 
     const pidPath = join(homeDir, ".claude", "cache", "tfx-hub", "hub.pid");
-    writeFileSync(pidPath, JSON.stringify({ host: "127.0.0.1", port: 30123 }), "utf8");
+    writeFileSync(
+      pidPath,
+      JSON.stringify({ host: "127.0.0.1", port: 30123 }),
+      "utf8",
+    );
 
     const settingsPath = join(homeDir, ".gemini", "settings.json");
-    writeFileSync(settingsPath, JSON.stringify({
-      mcpServers: {
-        "unsafe-stdio": { command: "node", args: ["server.js"] },
-      },
-    }, null, 2));
+    writeFileSync(
+      settingsPath,
+      JSON.stringify(
+        {
+          mcpServers: {
+            "unsafe-stdio": { command: "node", args: ["server.js"] },
+          },
+        },
+        null,
+        2,
+      ),
+    );
 
-    const result = remediate(settingsPath, scanForStdioServers(settingsPath), { stdio_action: "replace-with-hub" });
+    const result = remediate(settingsPath, scanForStdioServers(settingsPath), {
+      stdio_action: "replace-with-hub",
+    });
     const updated = JSON.parse(readFileSync(settingsPath, "utf8"));
 
     assert.equal(result.modified, true);
     assert.equal(existsSync(`${settingsPath}.bak`), true);
     assert.deepEqual(result.removedServers, ["unsafe-stdio"]);
-    assert.equal(updated.mcpServers["tfx-hub"].url, "http://127.0.0.1:30123/mcp");
+    assert.equal(
+      updated.mcpServers["tfx-hub"].url,
+      "http://127.0.0.1:30123/mcp",
+    );
     assert.equal(Object.hasOwn(updated.mcpServers, "unsafe-stdio"), false);
   });
 

package/scripts/__tests__/remote-spawn-transfer.test.mjs

@@ -1,8 +1,8 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it } from "node:test";
 
 import {
   buildRemoteTransferPlan,
@@ -22,7 +22,10 @@ describe("remote-spawn transfer plan", () => {
 
     const tokens = extractExplicitFileTokens(source);
 
-    assert.deepEqual(tokens.sort(), ["./notes.txt", ".omx/plans/prd.md", "docs/spec.md"].sort());
+    assert.deepEqual(
+      tokens.sort(),
+      ["./notes.txt", ".omx/plans/prd.md", "docs/spec.md"].sort(),
+    );
   });
 
   it("handoff + 참조 파일 전송 계획과 프롬프트 재작성", () => {
@@ -34,7 +37,7 @@ describe("remote-spawn transfer plan", () => {
       writeFileSync(
         join(root, "handoff.md"),
         [
-          "Open \"./prd.md\" before anything else.",
+          'Open "./prd.md" before anything else.',
           "Then inspect `docs/spec.md` and [again](docs/spec.md).",
         ].join("\n"),
         "utf8",
@@ -53,9 +56,15 @@ describe("remote-spawn transfer plan", () => {
       assert.equal(plan.transfers[1].type, "reference");
       assert.equal(plan.transfers[2].type, "reference");
 
-      assert.match(plan.prompt, /Staged handoff file: \/remote\/stage\/abc123\/handoff\/handoff\.md/);
+      assert.match(
+        plan.prompt,
+        /Staged handoff file: \/remote\/stage\/abc123\/handoff\/handoff\.md/,
+      );
       assert.match(plan.prompt, /\/remote\/stage\/abc123\/refs\/\d{2}-prd\.md/);
-      assert.match(plan.prompt, /\/remote\/stage\/abc123\/refs\/\d{2}-spec\.md/);
+      assert.match(
+        plan.prompt,
+        /\/remote\/stage\/abc123\/refs\/\d{2}-spec\.md/,
+      );
       assert.equal(plan.prompt.includes("./prd.md"), false);
       assert.equal(plan.prompt.includes("docs/spec.md"), false);
       assert.match(plan.prompt, /---\n\ncontinue with execution$/);
@@ -69,12 +78,13 @@ describe("remote-spawn transfer plan", () => {
     try {
       writeFileSync(join(root, "handoff.md"), "Read `./missing.md`", "utf8");
       assert.throws(
-        () => buildRemoteTransferPlan({
-          cwd: root,
-          handoffPath: "handoff.md",
-          maxBytes: 1024 * 1024,
-          remoteStageRoot: "/remote/stage/abc123",
-        }),
+        () =>
+          buildRemoteTransferPlan({
+            cwd: root,
+            handoffPath: "handoff.md",
+            maxBytes: 1024 * 1024,
+            remoteStageRoot: "/remote/stage/abc123",
+          }),
         /referenced file not found:/,
       );
     } finally {
@@ -89,12 +99,13 @@ describe("remote-spawn transfer plan", () => {
       writeFileSync(join(root, "handoff.md"), "Open ./big-ref.txt", "utf8");
 
       assert.throws(
-        () => buildRemoteTransferPlan({
-          cwd: root,
-          handoffPath: "handoff.md",
-          maxBytes: 16,
-          remoteStageRoot: "/remote/stage/abc123",
-        }),
+        () =>
+          buildRemoteTransferPlan({
+            cwd: root,
+            handoffPath: "handoff.md",
+            maxBytes: 16,
+            remoteStageRoot: "/remote/stage/abc123",
+          }),
         /referenced file too large:/,
       );
     } finally {

package/scripts/__tests__/remote-spawn.test.mjs

@@ -1,5 +1,5 @@
-import { describe, it } from "node:test";
 import assert from "node:assert/strict";
+import { describe, it } from "node:test";
 
 import { __remoteSpawnTest } from "../remote-spawn.mjs";
 
@@ -25,7 +25,9 @@ describe("remote-spawn watcher", () => {
       getPaneStatus: () => statuses[Math.min(pollIndex++, statuses.length - 1)],
       killSession: (name) => killed.push(name),
       now: () => nowMs,
-      sleep: async (ms) => { nowMs += ms; },
+      sleep: async (ms) => {
+        nowMs += ms;
+      },
     });
 
     assert.equal(result.cleaned, true);
@@ -43,9 +45,13 @@ describe("remote-spawn watcher", () => {
       maxWaitMs: 250,
       sessionExists: () => true,
       getPaneStatus: () => ({ isDead: false, exitCode: null }),
-      killSession: () => { killCount += 1; },
+      killSession: () => {
+        killCount += 1;
+      },
       now: () => nowMs,
-      sleep: async (ms) => { nowMs += ms; },
+      sleep: async (ms) => {
+        nowMs += ms;
+      },
     });
 
     assert.equal(result.cleaned, false);

package/scripts/__tests__/session-start-fast.test.mjs

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+describe("session-start-fast: 모듈 구조 검증", () => {
+  it("hooks/session-start-fast.mjs import 성공", async () => {
+    const mod = await import("../../hooks/session-start-fast.mjs");
+    assert.ok(mod);
+    assert.equal(typeof mod.execute, "function");
+  });
+
+  it("BLOCKING 훅 모듈 import 가능", async () => {
+    const setup = await import("../../scripts/setup.mjs");
+    assert.equal(typeof setup.runCritical, "function");
+
+    const guard = await import("../../scripts/mcp-safety-guard.mjs");
+    assert.equal(typeof guard.run, "function");
+  });
+
+  it("DEFERRED 훅 모듈 import 가능", async () => {
+    const hubEnsure = await import("../../scripts/hub-ensure.mjs");
+    assert.equal(typeof hubEnsure.run, "function");
+
+    const gateway = await import("../../scripts/mcp-gateway-ensure.mjs");
+    assert.equal(typeof gateway.run, "function");
+  });
+
+  it("BACKGROUND 훅 모듈 import 가능", async () => {
+    const preflight = await import("../../scripts/preflight-cache.mjs");
+    assert.equal(typeof preflight.run, "function");
+  });
+
+  it("setup.mjs에 runDeferred export 존재", async () => {
+    const setup = await import("../../scripts/setup.mjs");
+    assert.equal(typeof setup.runDeferred, "function");
+  });
+});