triflux 10.9.21 → 10.9.22

package/scripts/__tests__/release-governance.test.mjs

@@ -0,0 +1,148 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+
+import { bumpVersion } from "../release/bump-version.mjs";
+import { assertVersionSync, writeJson } from "../release/lib.mjs";
+import { prepareRelease } from "../release/prepare.mjs";
+import { publishRelease } from "../release/publish.mjs";
+import { verifyRelease } from "../release/verify.mjs";
+
+function makeRepo() {
+  const root = mkdtempSync(join(tmpdir(), "tfx-release-"));
+  mkdirSync(join(root, "scripts", "release"), { recursive: true });
+  mkdirSync(join(root, ".claude-plugin"), { recursive: true });
+  mkdirSync(join(root, "packages", "triflux"), { recursive: true });
+  mkdirSync(join(root, ".omx", "plans"), { recursive: true });
+
+  writeJson(join(root, "package.json"), { name: "triflux", version: "1.2.3" });
+  writeJson(join(root, "packages", "triflux", "package.json"), {
+    name: "triflux",
+    version: "1.2.0",
+  });
+  writeJson(join(root, ".claude-plugin", "plugin.json"), {
+    name: "triflux",
+    version: "1.1.0",
+  });
+  writeJson(join(root, ".claude-plugin", "marketplace.json"), {
+    version: "1.2.0",
+    plugins: [{ name: "triflux", version: "1.0.0" }],
+  });
+  writeJson(join(root, "package-lock.json"), {
+    name: "triflux",
+    version: "1.2.0",
+    packages: {
+      "": {
+        version: "1.0.0",
+      },
+    },
+  });
+  writeJson(join(root, "scripts", "release", "version-manifest.json"), {
+    canonicalFile: "package.json",
+    canonicalPath: ["version"],
+    targets: [
+      { file: "package.json", paths: [["version"]] },
+      { file: "packages/triflux/package.json", paths: [["version"]] },
+      { file: ".claude-plugin/plugin.json", paths: [["version"]] },
+      {
+        file: ".claude-plugin/marketplace.json",
+        paths: [["version"], ["plugins", 0, "version"]],
+      },
+      {
+        file: "package-lock.json",
+        paths: [["version"], ["packages", "", "version"]],
+      },
+    ],
+  });
+  return root;
+}
+
+describe("release governance scripts", () => {
+  it("assertVersionSync detects mismatches and fixes them", () => {
+    const root = makeRepo();
+    try {
+      const before = assertVersionSync({ rootDir: root });
+      assert.equal(before.ok, false);
+      assert.ok(before.mismatches.length >= 4);
+
+      const after = assertVersionSync({ rootDir: root, fix: true });
+      assert.equal(after.ok, true);
+      assert.deepEqual(
+        JSON.parse(readFileSync(join(root, ".claude-plugin", "plugin.json"))),
+        { name: "triflux", version: "1.2.3" },
+      );
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("bumpVersion writes canonical version and syncs targets", async () => {
+    const root = makeRepo();
+    try {
+      const result = await bumpVersion({
+        rootDir: root,
+        nextVersion: "2.0.0",
+        write: true,
+      });
+      assert.equal(result.ok, true);
+      assert.equal(
+        JSON.parse(readFileSync(join(root, "package.json"), "utf8")).version,
+        "2.0.0",
+      );
+      assert.equal(
+        JSON.parse(
+          readFileSync(
+            join(root, "packages", "triflux", "package.json"),
+            "utf8",
+          ),
+        ).version,
+        "2.0.0",
+      );
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("prepare/publish/verify support dry-run planning", async () => {
+    const root = makeRepo();
+    try {
+      assertVersionSync({ rootDir: root, fix: true });
+      const execStub = (command, args) => {
+        if (command === "git" && args[0] === "status") return "";
+        if (command === "git" && args[0] === "describe") return "v1.2.2";
+        if (command === "git" && args[0] === "log")
+          return "abc1234 feat: sample\n";
+        return "";
+      };
+
+      const prepare = await prepareRelease({
+        rootDir: root,
+        version: "1.2.3",
+        allowDirty: true,
+        dryRun: true,
+        execFileSyncFn: execStub,
+      });
+      assert.equal(prepare.ok, true);
+      assert.equal(prepare.commands.length, 3);
+
+      const publish = await publishRelease({
+        rootDir: root,
+        version: "1.2.3",
+        dryRun: true,
+      });
+      assert.equal(publish.steps.length >= 3, true);
+
+      const verify = await verifyRelease({
+        rootDir: root,
+        version: "1.2.3",
+        dryRun: true,
+      });
+      assert.equal(verify.ok, true);
+      assert.equal(verify.checks[1].name, "npm-view");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/scripts/doctor-diagnose.mjs

@@ -139,14 +139,13 @@ function collectSystemInfo() {
     freeMemMB: Math.round(freemem() / 1024 / 1024),
   };
 
-  // Windows Terminal version
+  // Windows Terminal version (wt.exe --version은 GUI 다이얼로그를 띄우므로 AppxPackage로 조회)
   try {
-    const wtVer = execSync("wt.exe --version 2>&1", {
-      encoding: "utf8",
-      timeout: 5000,
-      windowsHide: true,
-    }).trim();
-    info.wtVersion = wtVer;
+    const wtVer = execSync(
+      'powershell.exe -NoProfile -NoLogo -Command "(Get-AppxPackage Microsoft.WindowsTerminal).Version"',
+      { encoding: "utf8", timeout: 5000, windowsHide: true },
+    ).trim();
+    info.wtVersion = wtVer || "not found";
   } catch {
     info.wtVersion = "not found";
   }

package/scripts/lib/cross-review-utils.mjs

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 
 export const SESSION_TTL_SEC = 30 * 60;
-export const STATE_REL_PATH = join(".omc", "state", "cross-review.json");
+export const STATE_REL_PATH = join(".triflux", "state", "cross-review.json");
 
 export function readStdin() {
   return new Promise((resolve) => {
@@ -39,7 +39,7 @@ export function shouldTrackPath(filePath) {
   if (typeof filePath !== "string" || !filePath.trim()) return false;
 
   const lower = filePath.toLowerCase();
-  if (lower.startsWith(".omc/") || lower.startsWith(".claude/")) return false;
+  if (lower.startsWith(".triflux/") || lower.startsWith(".omc/") || lower.startsWith(".claude/")) return false;
   if (lower === "package-lock.json" || lower.endsWith("/package-lock.json"))
     return false;
   if (/\.(md|lock|yml|yaml)$/i.test(lower)) return false;

package/scripts/lib/mcp-filter.mjs

@@ -672,18 +672,22 @@ export function getCodexMcpConfig(options = {}) {
   const targetServers = registeredServers;
 
   if (resolvedProfile === "none") {
-    // Codex 0.115+: transport 없는 서버에 enabled=false를 보내면 "invalid transport" 에러.
-    // 비허용 서버는 override에서 제외하고, 허용 서버만 명시적으로 설정한다.
-    return { mcp_servers: {} };
+    // 등록된 서버를 전부 enabled=false로 비활성화.
+    // 미등록 서버에 보내면 "invalid transport" 에러지만, registeredServers는 등록 확인 완료.
+    const config = { mcp_servers: {} };
+    for (const server of targetServers) {
+      config.mcp_servers[server] = { enabled: false };
+    }
+    return config;
   }
 
   const config = { mcp_servers: {} };
   const allowedToolsByServer =
     getProfileDefinition(resolvedProfile).allowedToolsByServer;
   for (const server of targetServers) {
-    // Codex 0.115+: transport 없는 서버에 enabled=false를 보내면 "invalid transport" 에러.
-    // 비허용 서버는 override에서 제외한다 (Codex 기본 설정이 유지됨).
     if (!allowedServers.has(server)) {
+      // 비허용 서버는 명시적으로 비활성화하여 MCP 시작 자체를 방지.
+      config.mcp_servers[server] = { enabled: false };
       continue;
     }
 

package/scripts/release/bump-version.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  assertVersionSync,
+  isSemver,
+  parseArgs,
+  ROOT,
+  readJson,
+  syncVersionTargets,
+  writeJson,
+} from "./lib.mjs";
+
+export async function bumpVersion({
+  nextVersion,
+  rootDir = ROOT,
+  write = false,
+} = {}) {
+  if (!isSemver(nextVersion)) {
+    throw new Error(`Invalid semver version: ${nextVersion}`);
+  }
+
+  const packagePath = join(rootDir, "package.json");
+  const packageJson = readJson(packagePath);
+  const previousVersion = packageJson.version;
+  packageJson.version = nextVersion;
+
+  if (write) {
+    writeJson(packagePath, packageJson);
+    const syncedFiles = syncVersionTargets({
+      rootDir,
+      expectedVersion: nextVersion,
+    });
+    const post = assertVersionSync({ rootDir, expectedVersion: nextVersion });
+    return {
+      ok: post.ok,
+      previousVersion,
+      nextVersion,
+      updatedFiles: ["package.json", ...syncedFiles],
+      targets: post.targets,
+    };
+  }
+
+  const preview = assertVersionSync({
+    rootDir,
+    expectedVersion: nextVersion,
+  });
+  return {
+    ok: true,
+    previousVersion,
+    nextVersion,
+    updatedFiles: ["package.json"],
+    targets: preview.targets.map((target) => ({
+      ...target,
+      expected: nextVersion,
+      inSync: target.file === "package.json",
+    })),
+  };
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const args = parseArgs(process.argv.slice(2));
+  const nextVersion = args.next || args.version;
+  const result = await bumpVersion({
+    nextVersion,
+    rootDir: args.root,
+    write: Boolean(args.write),
+  });
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(
+      `${args.write ? "Bumped" : "Planned"} version ${result.previousVersion} -> ${result.nextVersion}`,
+    );
+    console.log(`Updated files: ${result.updatedFiles.join(", ")}`);
+  }
+}

package/scripts/release/check-sync.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+
+import { assertVersionSync, formatPathSegments, parseArgs } from "./lib.mjs";
+
+export { assertVersionSync } from "./lib.mjs";
+
+function toJson(result) {
+  return {
+    ok: result.ok,
+    rootVersion: result.rootVersion,
+    fixedFiles: result.fixedFiles,
+    mismatches: result.mismatches.map((target) => ({
+      file: target.file,
+      path: formatPathSegments(target.path),
+      found: target.found ?? null,
+      expected: target.expected,
+      missing: target.missing,
+    })),
+  };
+}
+
+function printHuman(result) {
+  if (result.ok) {
+    console.log(`Version sync OK (${result.rootVersion})`);
+    return;
+  }
+  console.log(`Version sync mismatch (${result.rootVersion})`);
+  for (const target of result.mismatches) {
+    console.log(
+      `- ${target.file} :: ${formatPathSegments(target.path)} => found=${target.found ?? "missing"}, expected=${target.expected}`,
+    );
+  }
+  if (result.fixedFiles.length) {
+    console.log(`Fixed files: ${result.fixedFiles.join(", ")}`);
+  }
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  const args = parseArgs(process.argv.slice(2));
+  const result = assertVersionSync({
+    rootDir: args.root,
+    fix: Boolean(args.fix),
+  });
+  if (args.json) {
+    console.log(JSON.stringify(toJson(result), null, 2));
+  } else {
+    printHuman(result);
+  }
+  process.exitCode = result.ok ? 0 : 1;
+}

package/scripts/release/lib.mjs

@@ -0,0 +1,303 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const ROOT = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+);
+export const DEFAULT_MANIFEST_PATH = join(
+  ROOT,
+  "scripts",
+  "release",
+  "version-manifest.json",
+);
+
+export function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!token.startsWith("--")) continue;
+    const key = token.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+      continue;
+    }
+    args[key] = next;
+    i++;
+  }
+  return args;
+}
+
+export function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+
+export function writeJson(filePath, value) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export function getValueAtPath(obj, pathSegments) {
+  return pathSegments.reduce((acc, segment) => {
+    if (acc === undefined || acc === null) return undefined;
+    return acc[segment];
+  }, obj);
+}
+
+export function setValueAtPath(obj, pathSegments, value) {
+  if (!pathSegments.length) {
+    throw new Error("pathSegments must not be empty");
+  }
+  let cursor = obj;
+  for (let i = 0; i < pathSegments.length - 1; i++) {
+    const segment = pathSegments[i];
+    const nextSegment = pathSegments[i + 1];
+    if (
+      cursor[segment] === undefined ||
+      cursor[segment] === null ||
+      typeof cursor[segment] !== "object"
+    ) {
+      cursor[segment] = typeof nextSegment === "number" ? [] : {};
+    }
+    cursor = cursor[segment];
+  }
+  cursor[pathSegments.at(-1)] = value;
+}
+
+export function formatPathSegments(pathSegments) {
+  return pathSegments
+    .map((segment) =>
+      typeof segment === "number"
+        ? `[${segment}]`
+        : segment === ""
+          ? '[""]'
+          : `.${segment}`,
+    )
+    .join("")
+    .replace(/^\./, "");
+}
+
+export function isSemver(value) {
+  return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(String(value || "").trim());
+}
+
+export function loadVersionManifest({
+  rootDir = ROOT,
+  manifestPath = join(rootDir, "scripts", "release", "version-manifest.json"),
+} = {}) {
+  const manifest = readJson(manifestPath);
+  if (!manifest.canonicalFile || !Array.isArray(manifest.targets)) {
+    throw new Error(`Invalid version manifest: ${manifestPath}`);
+  }
+  return manifest;
+}
+
+export function getCanonicalVersion({
+  rootDir = ROOT,
+  manifest = loadVersionManifest({ rootDir }),
+} = {}) {
+  const canonicalPath = join(rootDir, manifest.canonicalFile);
+  const canonicalJson = readJson(canonicalPath);
+  const value = getValueAtPath(
+    canonicalJson,
+    manifest.canonicalPath || ["version"],
+  );
+  if (!isSemver(value)) {
+    throw new Error(
+      `Canonical version is missing or invalid at ${manifest.canonicalFile}`,
+    );
+  }
+  return value;
+}
+
+export function collectVersionTargets({
+  rootDir = ROOT,
+  manifest = loadVersionManifest({ rootDir }),
+  expectedVersion = getCanonicalVersion({ rootDir, manifest }),
+} = {}) {
+  return manifest.targets.flatMap((target) => {
+    const absolutePath = join(rootDir, target.file);
+    if (!existsSync(absolutePath)) {
+      return target.paths.map((pathSegments) => ({
+        file: target.file,
+        absolutePath,
+        path: pathSegments,
+        found: undefined,
+        expected: expectedVersion,
+        inSync: false,
+        missing: true,
+      }));
+    }
+    const json = readJson(absolutePath);
+    return target.paths.map((pathSegments) => {
+      const found = getValueAtPath(json, pathSegments);
+      return {
+        file: target.file,
+        absolutePath,
+        path: pathSegments,
+        found,
+        expected: expectedVersion,
+        inSync: found === expectedVersion,
+        missing: false,
+      };
+    });
+  });
+}
+
+export function syncVersionTargets({
+  rootDir = ROOT,
+  manifest = loadVersionManifest({ rootDir }),
+  expectedVersion = getCanonicalVersion({ rootDir, manifest }),
+} = {}) {
+  const touched = new Set();
+  for (const target of manifest.targets) {
+    const absolutePath = join(rootDir, target.file);
+    if (!existsSync(absolutePath)) {
+      throw new Error(`Cannot sync missing target: ${target.file}`);
+    }
+    const json = readJson(absolutePath);
+    let changed = false;
+    for (const pathSegments of target.paths) {
+      if (getValueAtPath(json, pathSegments) !== expectedVersion) {
+        setValueAtPath(json, pathSegments, expectedVersion);
+        changed = true;
+      }
+    }
+    if (changed) {
+      writeJson(absolutePath, json);
+      touched.add(target.file);
+    }
+  }
+  return [...touched];
+}
+
+export function assertVersionSync({
+  rootDir = ROOT,
+  manifestPath = join(rootDir, "scripts", "release", "version-manifest.json"),
+  expectedVersion,
+  fix = false,
+} = {}) {
+  const manifest = loadVersionManifest({ rootDir, manifestPath });
+  const rootVersion =
+    expectedVersion || getCanonicalVersion({ rootDir, manifest });
+  let targets = collectVersionTargets({
+    rootDir,
+    manifest,
+    expectedVersion: rootVersion,
+  });
+  const mismatches = targets.filter((target) => !target.inSync);
+  let fixedFiles = [];
+
+  if (fix && mismatches.length) {
+    fixedFiles = syncVersionTargets({
+      rootDir,
+      manifest,
+      expectedVersion: rootVersion,
+    });
+    targets = collectVersionTargets({
+      rootDir,
+      manifest,
+      expectedVersion: rootVersion,
+    });
+  }
+
+  return {
+    ok: targets.every((target) => target.inSync),
+    rootVersion,
+    targets,
+    mismatches: targets.filter((target) => !target.inSync),
+    fixedFiles,
+  };
+}
+
+export function ensureGitClean({
+  rootDir = ROOT,
+  execFileSyncFn = execFileSync,
+} = {}) {
+  const output = execFileSyncFn("git", ["status", "--porcelain"], {
+    cwd: rootDir,
+    encoding: "utf8",
+  }).trim();
+  return { clean: output.length === 0, output };
+}
+
+export function getPreviousTag({
+  rootDir = ROOT,
+  execFileSyncFn = execFileSync,
+} = {}) {
+  try {
+    return execFileSyncFn("git", ["describe", "--tags", "--abbrev=0"], {
+      cwd: rootDir,
+      encoding: "utf8",
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+export function getCommitSummaries({
+  rootDir = ROOT,
+  previousTag,
+  execFileSyncFn = execFileSync,
+} = {}) {
+  const range = previousTag ? `${previousTag}..HEAD` : "HEAD~10..HEAD";
+  try {
+    return execFileSyncFn("git", ["log", "--oneline", range], {
+      cwd: rootDir,
+      encoding: "utf8",
+    })
+      .trim()
+      .split(/\r?\n/)
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+export function buildReleaseNotes({
+  version,
+  rootDir = ROOT,
+  execFileSyncFn = execFileSync,
+} = {}) {
+  const previousTag = getPreviousTag({ rootDir, execFileSyncFn });
+  const commits = getCommitSummaries({
+    rootDir,
+    previousTag,
+    execFileSyncFn,
+  });
+  const heading = previousTag
+    ? `Changes since ${previousTag}`
+    : "Recent changes (no prior tag found)";
+  const lines = commits.length
+    ? commits.map((commit) => `- ${commit}`)
+    : ["- No commit summary available"];
+
+  return [
+    `# Release v${version}`,
+    "",
+    `## ${heading}`,
+    ...lines,
+    "",
+    "## Install",
+    `- npm: \`npm install -g triflux@${version}\``,
+    "- Claude Code:",
+    "  - `/plugin marketplace add tellang/triflux`",
+    "  - `/plugin install triflux@tellang`",
+    "",
+  ].join("\n");
+}
+
+export function runCommand(
+  command,
+  args,
+  { cwd = ROOT, execFileSyncFn = execFileSync } = {},
+) {
+  execFileSyncFn(command, args, {
+    cwd,
+    stdio: "inherit",
+  });
+}