talking-stick 0.2.0 → 0.3.0

package/dist/install-migration.js

@@ -0,0 +1,84 @@
+import { SUPPORTED_HARNESSES, planUninstall, runAction } from "./install.js";
+import { NoopAuditLog } from "./install-audit.js";
+export async function removeStaleMcpRegistrations(options) {
+    const audit = options.audit ?? new NoopAuditLog();
+    const strict = options.strict ?? true;
+    const harnesses = options.harnesses === undefined || options.harnesses === "all"
+        ? [...SUPPORTED_HARNESSES]
+        : options.harnesses;
+    const installOptions = {
+        skipMissing: true,
+        ...(options.installOptions ?? {})
+    };
+    const results = [];
+    for (const harness of harnesses) {
+        const result = await removeOneHarness(harness, installOptions, strict);
+        results.push(result);
+        audit.append({
+            reason: options.reason,
+            package_version_from: options.packageVersionFrom,
+            package_version_to: options.packageVersionTo,
+            harness,
+            config_path: result.configPath,
+            action: result.action,
+            server_name: result.serverName,
+            detail: result.message
+        });
+    }
+    return results.map(({ harness, action, message }) => ({ harness, action, message }));
+}
+async function removeOneHarness(harness, installOptions, strict) {
+    const action = planUninstall(harness, installOptions);
+    if (action.kind === "skip") {
+        return {
+            harness,
+            action: "skipped",
+            message: action.message,
+            serverName: installOptions.serverName ?? "talking-stick"
+        };
+    }
+    if (action.kind === "file-patch") {
+        const state = action.inspect ? action.inspect() : "unknown";
+        const serverName = action.serverName ?? "talking-stick";
+        if (state === "absent") {
+            return {
+                harness,
+                action: "absent",
+                message: `${harness}: no Talking Stick MCP entry to remove`,
+                configPath: action.filePath,
+                serverName
+            };
+        }
+        if (strict && state !== "present") {
+            return {
+                harness,
+                action: "preserved",
+                message: `${harness}: hand-edited entry left alone (state=${state})`,
+                configPath: action.filePath,
+                serverName
+            };
+        }
+    }
+    const installResult = await runAction(action, installOptions);
+    return mapInstallResult(harness, action, installResult);
+}
+function mapInstallResult(harness, action, result) {
+    let serverName = "talking-stick";
+    if ("serverName" in action && typeof action.serverName === "string") {
+        serverName = action.serverName;
+    }
+    const configPath = action.kind === "file-patch" ? action.filePath : undefined;
+    if (!result.ok) {
+        return { harness, action: "failed", message: result.message, configPath, serverName };
+    }
+    switch (result.status) {
+        case "already_absent":
+            return { harness, action: "absent", message: result.message, configPath, serverName };
+        case "removed":
+            return { harness, action: "removed", message: result.message, configPath, serverName };
+        case "skipped":
+            return { harness, action: "skipped", message: result.message, configPath, serverName };
+        default:
+            return { harness, action: "failed", message: result.message, configPath, serverName };
+    }
+}

package/dist/install.js

@@ -115,75 +115,6 @@ function resolveHarnessConfigDirFromResolved(harness, resolved) {
             throw new Error(`Unknown harness: ${harness}`);
     }
 }
-export function planInstall(harness, options = {}) {
-    const resolved = resolveOptions(options);
-    const [serverBin, ...serverArgs] = resolved.serverCommand;
-    if (!serverBin)
-        throw new Error("serverCommand must include at least the binary");
-    switch (harness) {
-        case "claude-code":
-            if (resolved.skipMissing && !resolved.hooks.which("claude")) {
-                return skipAction(harness, "claude not on PATH");
-            }
-            return {
-                kind: "exec",
-                harness,
-                command: "claude",
-                args: ["mcp", "add", "-s", "user", resolved.serverName, "--", serverBin, ...serverArgs],
-                description: `claude mcp add -s user ${resolved.serverName} -- ${resolved.serverCommand.join(" ")}`,
-                operation: "install",
-                serverName: resolved.serverName,
-                serverCommand: resolved.serverCommand
-            };
-        case "codex":
-            if (resolved.skipMissing && !resolved.hooks.which("codex")) {
-                return skipAction(harness, "codex not on PATH");
-            }
-            return {
-                kind: "exec",
-                harness,
-                command: "codex",
-                args: ["mcp", "add", resolved.serverName, "--", serverBin, ...serverArgs],
-                description: `codex mcp add ${resolved.serverName} -- ${resolved.serverCommand.join(" ")}`,
-                operation: "install",
-                serverName: resolved.serverName,
-                serverCommand: resolved.serverCommand
-            };
-        case "gemini":
-            if (resolved.skipMissing && !resolved.hooks.which("gemini")) {
-                return skipAction(harness, "gemini not on PATH");
-            }
-            return {
-                kind: "exec",
-                harness,
-                command: "gemini",
-                args: ["mcp", "add", "-s", "user", "-t", "stdio", resolved.serverName, serverBin, ...serverArgs],
-                description: `gemini mcp add -s user -t stdio ${resolved.serverName} ${resolved.serverCommand.join(" ")}`,
-                operation: "install",
-                serverName: resolved.serverName,
-                serverCommand: resolved.serverCommand
-            };
-        case "opencode": {
-            const filePath = resolveOpencodeConfigPath(options);
-            const configDir = path.dirname(filePath);
-            if (resolved.skipMissing && !resolved.hooks.pathExists(configDir)) {
-                return skipAction(harness, `opencode config directory not found: ${configDir}`);
-            }
-            return {
-                kind: "file-patch",
-                harness,
-                filePath,
-                description: `merge mcp.${resolved.serverName} into ${filePath}`,
-                operation: "install",
-                serverName: resolved.serverName,
-                inspect: () => inspectOpencodeConfig(filePath, resolved),
-                apply: () => patchOpencodeConfig(filePath, resolved, "install")
-            };
-        }
-        default:
-            throw new Error(`Unknown harness: ${harness}`);
-    }
-}
 export function planUninstall(harness, options = {}) {
     const resolved = resolveOptions(options);
     switch (harness) {

package/dist/update-migration.js

@@ -0,0 +1,135 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveDataDir } from "./config.js";
+import { FileAuditLog, defaultAuditLogPath } from "./install-audit.js";
+import { removeStaleMcpRegistrations } from "./install-migration.js";
+export const UPDATE_MIGRATION_STATE_FILE = "update-migrations-state.json";
+export async function runStaleMcpCleanup(options) {
+    const packageVersionTo = options.packageVersionTo ?? options.packageVersion ?? readPackageVersion();
+    const dataDir = options.dataDir ?? resolveMigrationDataDir(options.installOptions);
+    const statePath = resolveUpdateMigrationStatePath(dataDir);
+    const auditPath = defaultAuditLogPath(dataDir);
+    const audit = options.audit ?? new FileAuditLog(auditPath);
+    const results = await removeStaleMcpRegistrations({
+        harnesses: options.harnesses ?? "all",
+        reason: options.reason,
+        packageVersionFrom: options.packageVersionFrom,
+        packageVersionTo,
+        audit,
+        installOptions: options.installOptions
+    });
+    if (options.updateState !== false && !results.some((result) => result.action === "failed")) {
+        writeUpdateMigrationState(statePath, {
+            mcp_cleanup_version: packageVersionTo,
+            updated_at: new Date().toISOString()
+        });
+    }
+    return {
+        status: "ran",
+        packageVersionFrom: options.packageVersionFrom,
+        packageVersionTo,
+        statePath,
+        auditPath,
+        results
+    };
+}
+export async function runFirstRunMcpMigration(options = {}) {
+    const packageVersion = options.packageVersion ?? readPackageVersion();
+    const dataDir = options.dataDir ?? resolveMigrationDataDir(options.installOptions);
+    const statePath = resolveUpdateMigrationStatePath(dataDir);
+    const auditPath = defaultAuditLogPath(dataDir);
+    const state = readUpdateMigrationState(statePath);
+    if (state.mcp_cleanup_version === packageVersion) {
+        return {
+            status: "current",
+            packageVersion,
+            statePath,
+            auditPath,
+            results: []
+        };
+    }
+    return runStaleMcpCleanup({
+        harnesses: "all",
+        reason: "first-run",
+        packageVersionFrom: state.mcp_cleanup_version,
+        packageVersionTo: packageVersion,
+        dataDir,
+        audit: options.audit,
+        installOptions: options.installOptions
+    });
+}
+export function resolveUpdateMigrationStatePath(dataDir) {
+    return path.join(dataDir, UPDATE_MIGRATION_STATE_FILE);
+}
+export function readUpdateMigrationState(statePath) {
+    try {
+        const raw = fs.readFileSync(statePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isPlainObject(parsed))
+            return {};
+        return {
+            mcp_cleanup_version: typeof parsed.mcp_cleanup_version === "string"
+                ? parsed.mcp_cleanup_version
+                : undefined,
+            updated_at: typeof parsed.updated_at === "string" ? parsed.updated_at : undefined
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        return {};
+    }
+}
+export function writeUpdateMigrationState(statePath, state) {
+    fs.mkdirSync(path.dirname(statePath), { recursive: true });
+    const tmpPath = `${statePath}.${process.pid}.tmp`;
+    fs.writeFileSync(tmpPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    fs.renameSync(tmpPath, statePath);
+}
+export function readPackageVersion(startUrl = import.meta.url) {
+    const root = findPackageRoot(fileURLToPath(startUrl));
+    if (!root)
+        return "unknown";
+    try {
+        const raw = fs.readFileSync(path.join(root, "package.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === "string" && parsed.version.trim()
+            ? parsed.version
+            : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function resolveMigrationDataDir(installOptions) {
+    const options = {
+        env: installOptions?.env,
+        platform: installOptions?.platform,
+        homeDir: installOptions?.homeDir
+    };
+    return resolveDataDir(options);
+}
+function findPackageRoot(startPath) {
+    let current;
+    try {
+        current = fs.statSync(startPath).isDirectory()
+            ? startPath
+            : path.dirname(startPath);
+    }
+    catch {
+        current = path.dirname(startPath);
+    }
+    while (true) {
+        const candidate = path.join(current, "package.json");
+        if (fs.existsSync(candidate))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}