open-multi-agent-kit 0.80.4 → 0.80.6

package/dist/migrations.js

@@ -1,12 +1,15 @@
 /**
  * One-time migrations that run on startup.
  */
+import { createHash } from "node:crypto";
 import chalk from "chalk";
-import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync, } from "fs";
+import { basename, dirname, join, relative, resolve, sep } from "path";
 import { CONFIG_DIR_NAME, getAgentDir, getBinDir } from "./config.js";
+import { recordHarnessControlEvent } from "./core/harness-control-events.js";
 import { migrateKeybindingsConfig } from "./core/keybindings.js";
 import { isLegacyEnvVarNameConfigValue } from "./core/resolve-config-value.js";
+import { runHarnessControlTransactionSync } from "./core/transaction-coordinator.js";
 import { stripJsonComments } from "./utils/json.js";
 const MIGRATION_GUIDE_URL = "https://github.com/dmae97/open-multi-agent-kit/blob/main/packages/coding-agent/CHANGELOG.md#extensions-migration";
 const EXTENSIONS_DOC_URL = "https://github.com/dmae97/open-multi-agent-kit/blob/main/packages/coding-agent/docs/extensions.md";
@@ -315,11 +318,414 @@ function migrateToolsToBin() {
  * Check for deprecated hooks/ and tools/ directories.
  * Note: tools/ may contain fd/rg binaries extracted by pi, so only warn if it has other files.
  */
+const EXTENSION_SOURCE_EXTENSIONS = new Set([".ts", ".js", ".mts", ".cts", ".mjs", ".cjs", ".tsx", ".jsx"]);
+const LEGACY_MANIFEST_FIELDS = ["hooks", "customTools", "extensions"];
+const MAX_LEGACY_EXTENSION_SCAN_DEPTH = 8;
+function extensionName(name) {
+    const dotIndex = name.lastIndexOf(".");
+    return dotIndex >= 0 ? name.slice(dotIndex) : "";
+}
+function isExtensionSourceFile(name) {
+    return EXTENSION_SOURCE_EXTENSIONS.has(extensionName(name));
+}
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function manifestEntrypointReferencesSource(value) {
+    if (typeof value === "string")
+        return isExtensionSourceFile(value);
+    if (Array.isArray(value))
+        return value.some((entry) => manifestEntrypointReferencesSource(entry));
+    if (isObjectRecord(value))
+        return Object.values(value).some((entry) => manifestEntrypointReferencesSource(entry));
+    return false;
+}
+function inspectLegacyExtensionManifest(dir, scope) {
+    const packageJsonPath = join(dir, "package.json");
+    if (!existsSync(packageJsonPath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (!isObjectRecord(parsed))
+            return undefined;
+        const manifests = [parsed.pi, parsed.omk].filter(isObjectRecord);
+        const hasLegacyManifestArray = manifests.some((manifest) => LEGACY_MANIFEST_FIELDS.some((field) => Array.isArray(manifest[field])));
+        const hasManifestEntrypoint = [parsed.main, parsed.module, parsed.exports].some(manifestEntrypointReferencesSource);
+        if (!hasLegacyManifestArray && !hasManifestEntrypoint)
+            return undefined;
+        return {
+            code: "LEGACY_EXTENSION_ENTRYPOINT",
+            scope,
+            path: packageJsonPath,
+            classification: "legacy",
+            confidence: hasLegacyManifestArray ? 0.96 : 0.82,
+            evidence: [hasLegacyManifestArray ? "manifest legacy array" : "manifest entrypoint"],
+            recommendedAction: "move-to-extensions",
+        };
+    }
+    catch {
+        return {
+            code: "LEGACY_EXTENSION_UNKNOWN",
+            scope,
+            path: packageJsonPath,
+            classification: "unknown",
+            confidence: 0.5,
+            evidence: ["package.json parse failed"],
+            recommendedAction: "inspect-manifest",
+        };
+    }
+}
+function isPathWithin(parent, child) {
+    const resolvedParent = resolve(parent);
+    const resolvedChild = resolve(child);
+    return resolvedChild === resolvedParent || resolvedChild.startsWith(`${resolvedParent}${sep}`);
+}
+function addLegacySourceDiagnostic(diagnostics, scope, entryPath, evidence) {
+    diagnostics.push({
+        code: "LEGACY_EXTENSION_ENTRYPOINT",
+        scope,
+        path: entryPath,
+        classification: "legacy",
+        confidence: 0.98,
+        evidence: [evidence],
+        recommendedAction: "move-to-extensions",
+    });
+}
+function addUnknownExtensionDiagnostic(diagnostics, scope, entryPath, evidence, confidence = 0.4) {
+    diagnostics.push({
+        code: "LEGACY_EXTENSION_UNKNOWN",
+        scope,
+        path: entryPath,
+        classification: "unknown",
+        confidence,
+        evidence: [evidence],
+        recommendedAction: "inspect-manifest",
+    });
+}
+function collectLegacyExtensionDiagnostics(entryPath, hooksRealPath, scope, depth, visitedRealPaths, diagnostics) {
+    if (depth > MAX_LEGACY_EXTENSION_SCAN_DEPTH) {
+        addUnknownExtensionDiagnostic(diagnostics, scope, entryPath, "maximum scan depth exceeded");
+        return;
+    }
+    let currentPath = entryPath;
+    let stats;
+    try {
+        stats = lstatSync(currentPath);
+        if (stats.isSymbolicLink()) {
+            const targetPath = realpathSync(currentPath);
+            if (!isPathWithin(hooksRealPath, targetPath)) {
+                addUnknownExtensionDiagnostic(diagnostics, scope, currentPath, "symlink target outside hooks directory", 0.6);
+                return;
+            }
+            currentPath = targetPath;
+            stats = lstatSync(currentPath);
+        }
+    }
+    catch {
+        addUnknownExtensionDiagnostic(diagnostics, scope, entryPath, "path stat failed");
+        return;
+    }
+    if (stats.isFile()) {
+        if (isExtensionSourceFile(entryPath) || isExtensionSourceFile(currentPath)) {
+            addLegacySourceDiagnostic(diagnostics, scope, entryPath, basename(entryPath));
+        }
+        return;
+    }
+    if (!stats.isDirectory())
+        return;
+    let directoryRealPath;
+    try {
+        directoryRealPath = realpathSync(currentPath);
+    }
+    catch {
+        addUnknownExtensionDiagnostic(diagnostics, scope, entryPath, "directory realpath failed");
+        return;
+    }
+    if (visitedRealPaths.has(directoryRealPath))
+        return;
+    visitedRealPaths.add(directoryRealPath);
+    const manifestDiagnostic = inspectLegacyExtensionManifest(currentPath, scope);
+    if (manifestDiagnostic)
+        diagnostics.push({ ...manifestDiagnostic, path: join(entryPath, "package.json") });
+    let entries;
+    try {
+        entries = readdirSync(currentPath, { withFileTypes: true });
+    }
+    catch {
+        addUnknownExtensionDiagnostic(diagnostics, scope, entryPath, "directory read failed");
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        collectLegacyExtensionDiagnostics(join(entryPath, entry.name), hooksRealPath, scope, depth + 1, visitedRealPaths, diagnostics);
+    }
+}
+function getLegacyExtensionDiagnosticsForHooksDir(hooksDir, scope) {
+    if (!existsSync(hooksDir))
+        return [];
+    try {
+        const hooksRealPath = realpathSync(hooksDir);
+        const diagnostics = [];
+        const visitedRealPaths = new Set();
+        for (const entry of readdirSync(hooksDir, { withFileTypes: true })) {
+            if (entry.name.startsWith("."))
+                continue;
+            collectLegacyExtensionDiagnostics(join(hooksDir, entry.name), hooksRealPath, scope, 1, visitedRealPaths, diagnostics);
+        }
+        return diagnostics;
+    }
+    catch {
+        return [
+            {
+                code: "LEGACY_EXTENSION_UNKNOWN",
+                scope,
+                path: hooksDir,
+                classification: "unknown",
+                confidence: 0.4,
+                evidence: ["directory read failed"],
+                recommendedAction: "inspect-manifest",
+            },
+        ];
+    }
+}
+function getExtensionDeprecationScanTargets(cwd) {
+    const agentDir = getAgentDir();
+    const projectDir = join(cwd, CONFIG_DIR_NAME);
+    return [
+        {
+            scope: "global",
+            hooksDir: join(agentDir, "hooks"),
+            extensionsDir: join(agentDir, "extensions"),
+        },
+        {
+            scope: "project",
+            hooksDir: join(projectDir, "hooks"),
+            extensionsDir: join(projectDir, "extensions"),
+        },
+    ];
+}
+export function getExtensionDeprecationDiagnostics(cwd) {
+    return getExtensionDeprecationScanTargets(cwd).flatMap((target) => getLegacyExtensionDiagnosticsForHooksDir(target.hooksDir, target.scope));
+}
+function getMigrationSourcePath(diagnostic) {
+    const name = basename(diagnostic.path);
+    if (name === "package.json" || /^index\.[cm]?[tj]sx?$/.test(name)) {
+        return dirname(diagnostic.path);
+    }
+    return diagnostic.path;
+}
+function createMigrationSourceStat(path) {
+    try {
+        const stats = lstatSync(path);
+        return {
+            isDirectory: stats.isDirectory(),
+            size: stats.size,
+            mtimeMs: stats.mtimeMs,
+            mode: stats.mode,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function createMigrationSourceStatTree(path, depth = 0) {
+    const sourceStat = createMigrationSourceStat(path);
+    if (!sourceStat)
+        return undefined;
+    if (!sourceStat.isDirectory || depth >= MAX_LEGACY_EXTENSION_SCAN_DEPTH) {
+        return { name: basename(path), sourceStat };
+    }
+    const children = readdirSync(path)
+        .filter((entry) => !entry.startsWith("."))
+        .sort()
+        .map((entry) => createMigrationSourceStatTree(join(path, entry), depth + 1));
+    return { name: basename(path), sourceStat, children };
+}
+function createMigrationSourceContentTree(path, depth = 0) {
+    const sourceStat = createMigrationSourceStat(path);
+    if (!sourceStat)
+        return undefined;
+    if (!sourceStat.isDirectory) {
+        try {
+            return {
+                name: basename(path),
+                type: "file",
+                sha256: createHash("sha256").update(readFileSync(path)).digest("hex"),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (depth >= MAX_LEGACY_EXTENSION_SCAN_DEPTH)
+        return { name: basename(path), type: "directory", truncated: true };
+    const children = readdirSync(path)
+        .filter((entry) => !entry.startsWith("."))
+        .sort()
+        .map((entry) => createMigrationSourceContentTree(join(path, entry), depth + 1));
+    return { name: basename(path), type: "directory", children };
+}
+function hashMigrationSourceStat(path) {
+    const tree = createMigrationSourceStatTree(path);
+    if (!tree)
+        return undefined;
+    return createHash("sha256").update(JSON.stringify(tree)).digest("hex");
+}
+function hashMigrationSourceContent(path) {
+    const tree = createMigrationSourceContentTree(path);
+    if (!tree)
+        return undefined;
+    return createHash("sha256").update(JSON.stringify(tree)).digest("hex");
+}
+function addMigrationSourceStat(action) {
+    const sourceStat = createMigrationSourceStat(action.from);
+    return {
+        ...action,
+        sourceStat,
+        sourceStatHash: hashMigrationSourceStat(action.from),
+        sourceContentHash: hashMigrationSourceContent(action.from),
+    };
+}
+export function createExtensionMigrationPlan(cwd) {
+    const diagnostics = getExtensionDeprecationDiagnostics(cwd);
+    const targets = getExtensionDeprecationScanTargets(cwd);
+    const actions = [];
+    const seenSources = new Set();
+    for (const diagnostic of diagnostics) {
+        if (diagnostic.classification !== "legacy")
+            continue;
+        const target = targets.find((candidate) => candidate.scope === diagnostic.scope);
+        if (!target)
+            continue;
+        const sourcePath = getMigrationSourcePath(diagnostic);
+        if (!isPathWithin(target.hooksDir, sourcePath))
+            continue;
+        if ([...seenSources].some((seenSource) => isPathWithin(seenSource, sourcePath)))
+            continue;
+        for (const seenSource of [...seenSources]) {
+            if (isPathWithin(sourcePath, seenSource)) {
+                seenSources.delete(seenSource);
+                const actionIndex = actions.findIndex((action) => action.from === seenSource);
+                if (actionIndex >= 0)
+                    actions.splice(actionIndex, 1);
+            }
+        }
+        seenSources.add(sourcePath);
+        const relativeSource = relative(target.hooksDir, sourcePath);
+        const destinationPath = join(target.extensionsDir, relativeSource);
+        const destinationExists = existsSync(destinationPath);
+        actions.push(addMigrationSourceStat({
+            action: "move",
+            scope: diagnostic.scope,
+            from: sourcePath,
+            to: destinationPath,
+            status: destinationExists ? "blocked" : "ready",
+            reason: diagnostic.evidence.join(", "),
+            blocker: destinationExists ? "target already exists" : undefined,
+        }));
+    }
+    recordHarnessControlEvent("extension.migration.plan", "completed", {
+        diagnostics: diagnostics.length,
+        legacyDiagnostics: diagnostics.filter((diagnostic) => diagnostic.classification === "legacy").length,
+        unknownDiagnostics: diagnostics.filter((diagnostic) => diagnostic.classification === "unknown").length,
+        actions: actions.length,
+        blockedActions: actions.filter((action) => action.status === "blocked").length,
+    });
+    return { diagnostics, actions };
+}
+export function applyExtensionMigrationPlan(cwd, plan = createExtensionMigrationPlan(cwd)) {
+    const readyActions = plan.actions.filter((action) => action.status === "ready");
+    const preflightBlocked = plan.actions.filter((action) => action.status !== "ready");
+    if (preflightBlocked.length > 0) {
+        recordHarnessControlEvent("extension.migration.apply", "blocked", {
+            actions: plan.actions.length,
+            blockedActions: preflightBlocked.length,
+            reason: "preflight blocked actions present",
+        });
+        return plan;
+    }
+    const appliedMoves = [];
+    let appliedPlan = plan;
+    const transaction = runHarnessControlTransactionSync({
+        kind: "extension.migration.apply",
+        data: {
+            actions: plan.actions.length,
+            readyActions: readyActions.length,
+            cwd,
+        },
+        beforeState: plan.actions.map((action) => ({
+            from: action.from,
+            to: action.to,
+            status: action.status,
+            sourceStatHash: action.sourceStatHash,
+            sourceContentHash: action.sourceContentHash,
+        })),
+        afterState: () => appliedPlan.actions.map((action) => ({ from: action.from, to: action.to, status: action.status })),
+        commit: () => {
+            for (const action of readyActions) {
+                if (!existsSync(action.from))
+                    throw new Error(`source missing: ${action.from}`);
+                if (existsSync(action.to))
+                    throw new Error(`target already exists: ${action.to}`);
+                const currentContentHash = hashMigrationSourceContent(action.from);
+                if (action.sourceContentHash && currentContentHash !== action.sourceContentHash) {
+                    throw new Error(`source content changed before migration: ${action.from}`);
+                }
+                const currentHash = hashMigrationSourceStat(action.from);
+                if (action.sourceStatHash && currentHash !== action.sourceStatHash) {
+                    throw new Error(`source changed before migration: ${action.from}`);
+                }
+            }
+            for (const action of readyActions) {
+                mkdirSync(dirname(action.to), { recursive: true });
+                renameSync(action.from, action.to);
+                appliedMoves.push({ from: action.from, to: action.to });
+            }
+            appliedPlan = {
+                diagnostics: plan.diagnostics,
+                actions: plan.actions.map((action) => action.status === "ready" ? { ...action, status: "applied" } : action),
+            };
+            return appliedPlan;
+        },
+        rollback: () => {
+            for (const move of [...appliedMoves].reverse()) {
+                if (existsSync(move.to) && !existsSync(move.from)) {
+                    mkdirSync(dirname(move.from), { recursive: true });
+                    renameSync(move.to, move.from);
+                }
+            }
+            appliedPlan = {
+                diagnostics: plan.diagnostics,
+                actions: plan.actions.map((action) => action.status === "ready" ? { ...action, status: "rolled_back" } : action),
+            };
+        },
+    });
+    if (transaction.status === "completed")
+        return appliedPlan;
+    const recoveryJournalPath = transaction.status === "in_doubt" ? join(cwd, ".omk", "runs", "extension-migration-recovery.json") : undefined;
+    if (recoveryJournalPath) {
+        mkdirSync(dirname(recoveryJournalPath), { recursive: true });
+        writeFileSync(recoveryJournalPath, `${JSON.stringify({ status: "in_doubt", appliedMoves, error: String(transaction.error) }, null, 2)}\n`, "utf-8");
+    }
+    return {
+        diagnostics: plan.diagnostics,
+        actions: plan.actions.map((action) => action.status === "ready"
+            ? {
+                ...action,
+                status: transaction.status === "in_doubt" ? "in_doubt" : "blocked",
+                blocker: transaction.error instanceof Error ? transaction.error.message : String(transaction.error),
+                recoveryJournalPath,
+            }
+            : action),
+    };
+}
 function checkDeprecatedExtensionDirs(baseDir, label) {
     const hooksDir = join(baseDir, "hooks");
     const toolsDir = join(baseDir, "tools");
     const warnings = [];
-    if (existsSync(hooksDir)) {
+    const scope = label === "Global" ? "global" : "project";
+    if (getLegacyExtensionDiagnosticsForHooksDir(hooksDir, scope).some((diagnostic) => diagnostic.classification === "legacy")) {
         warnings.push(`${label} hooks/ directory found. Hooks have been renamed to extensions.`);
     }
     if (existsSync(toolsDir)) {