maskweaver 0.10.0 → 0.10.1

package/dist/cli/config-manager/npm-dist-tags.d.ts

@@ -0,0 +1,7 @@
+export interface NpmDistTags {
+    latest?: string;
+    beta?: string;
+    next?: string;
+    [tag: string]: string | undefined;
+}
+export declare function fetchNpmDistTags(packageName: string): Promise<NpmDistTags | null>;

package/dist/cli/config-manager/npm-dist-tags.js

@@ -0,0 +1,15 @@
+const NPM_FETCH_TIMEOUT_MS = 5000;
+export async function fetchNpmDistTags(packageName) {
+    try {
+        const res = await fetch(`https://registry.npmjs.org/-/package/${encodeURIComponent(packageName)}/dist-tags`, {
+            signal: AbortSignal.timeout(NPM_FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/cli/config-manager/plugin-name-with-version.d.ts

@@ -0,0 +1 @@
+export declare function getPluginNameWithVersion(currentVersion: string, packageName: string): Promise<string>;

package/dist/cli/config-manager/plugin-name-with-version.js

@@ -0,0 +1,21 @@
+import { fetchNpmDistTags } from "./npm-dist-tags.js";
+const PRIORITIZED_TAGS = ["latest", "beta", "next"];
+function getFallbackEntry(version, packageName) {
+    const prereleaseMatch = version.match(/-([a-zA-Z][a-zA-Z0-9-]*)(?:\.|$)/);
+    if (prereleaseMatch) {
+        return `${packageName}@${prereleaseMatch[1]}`;
+    }
+    return packageName;
+}
+export async function getPluginNameWithVersion(currentVersion, packageName) {
+    const distTags = await fetchNpmDistTags(packageName);
+    if (distTags) {
+        const allTags = new Set([...PRIORITIZED_TAGS, ...Object.keys(distTags)]);
+        for (const tag of allTags) {
+            if (distTags[tag] === currentVersion) {
+                return `${packageName}@${tag}`;
+            }
+        }
+    }
+    return getFallbackEntry(currentVersion, packageName);
+}

package/dist/cli/config-manager/version-compatibility.d.ts

@@ -0,0 +1,9 @@
+export interface VersionCompatibility {
+    canUpgrade: boolean;
+    reason?: string;
+    isDowngrade: boolean;
+    isMajorBump: boolean;
+    requiresMigration: boolean;
+}
+export declare function checkVersionCompatibility(currentVersion: string | null, newVersion: string): VersionCompatibility;
+export declare function extractVersionFromPluginEntry(entry: string): string | null;

package/dist/cli/config-manager/version-compatibility.js

@@ -0,0 +1,81 @@
+function parseVersion(version) {
+    const clean = version.replace(/^v/, "").split("-")[0];
+    return clean.split(".").map(Number);
+}
+function compareVersions(a, b) {
+    const partsA = parseVersion(a);
+    const partsB = parseVersion(b);
+    const maxLen = Math.max(partsA.length, partsB.length);
+    for (let i = 0; i < maxLen; i++) {
+        const numA = partsA[i] ?? 0;
+        const numB = partsB[i] ?? 0;
+        if (numA !== numB) {
+            return numA - numB;
+        }
+    }
+    return 0;
+}
+export function checkVersionCompatibility(currentVersion, newVersion) {
+    if (!currentVersion) {
+        return {
+            canUpgrade: true,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+        };
+    }
+    const cleanCurrent = currentVersion.replace(/^v/, "");
+    const cleanNew = newVersion.replace(/^v/, "");
+    try {
+        const comparison = compareVersions(cleanNew, cleanCurrent);
+        if (comparison < 0) {
+            return {
+                canUpgrade: false,
+                reason: `Downgrade from ${currentVersion} to ${newVersion} is not allowed`,
+                isDowngrade: true,
+                isMajorBump: false,
+                requiresMigration: false,
+            };
+        }
+        if (comparison === 0) {
+            return {
+                canUpgrade: true,
+                reason: `Version ${newVersion} is already installed`,
+                isDowngrade: false,
+                isMajorBump: false,
+                requiresMigration: false,
+            };
+        }
+        const currentMajor = cleanCurrent.split(".")[0];
+        const newMajor = cleanNew.split(".")[0];
+        const isMajorBump = currentMajor !== newMajor;
+        if (isMajorBump) {
+            return {
+                canUpgrade: true,
+                reason: `Major version upgrade from ${currentVersion} to ${newVersion} - configuration migration may be required`,
+                isDowngrade: false,
+                isMajorBump: true,
+                requiresMigration: true,
+            };
+        }
+        return {
+            canUpgrade: true,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+        };
+    }
+    catch {
+        return {
+            canUpgrade: true,
+            reason: `Unable to compare versions ${currentVersion} and ${newVersion} - proceeding with caution`,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+        };
+    }
+}
+export function extractVersionFromPluginEntry(entry) {
+    const match = entry.match(/@(.+)$/);
+    return match ? match[1] : null;
+}

package/dist/cli/install.js

@@ -7,8 +7,10 @@ import { VERSION } from "../version.js";
 import { runDoctor, printDoctorReport } from "./doctor.js";
 import { writeDefaultRuntimeConfig, writeDefaultPluginConfig } from "../shared/generate-agents.js";
 const PLUGIN_NAME = "maskweaver";
+const PLUGIN_LATEST = "maskweaver@latest";
 const LEGACY_PLUGIN_NAMES = ["maskweaver/plugin", "@maskweaver/plugin"];
-const ALL_PLUGIN_NAMES = [PLUGIN_NAME, ...LEGACY_PLUGIN_NAMES];
+const ALL_PLUGIN_NAMES = [PLUGIN_NAME, PLUGIN_LATEST, ...LEGACY_PLUGIN_NAMES];
+const ALL_BARE_OR_VERSIONED = [PLUGIN_NAME, PLUGIN_LATEST];
 const CONFIG_NAME = "opencode.json";
 const colors = {
     reset: "\x1b[0m",
@@ -83,19 +85,31 @@ function getInstalledPluginEntries(config) {
     return config.plugin.filter((plugin) => ALL_PLUGIN_NAMES.includes(plugin));
 }
 function isPluginInstalled(config) {
-    return getInstalledPluginEntries(config).length > 0;
+    if (!config.plugin || !Array.isArray(config.plugin))
+        return false;
+    return config.plugin.some((p) => ALL_BARE_OR_VERSIONED.some(name => p === name || p.startsWith(`${name}@`)));
 }
 function normalizePluginEntries(config) {
     if (!config.plugin || !Array.isArray(config.plugin)) {
         return { migratedFrom: [], changed: false };
     }
     const migratedFrom = config.plugin.filter((plugin) => LEGACY_PLUGIN_NAMES.includes(plugin));
-    if (migratedFrom.length === 0) {
+    const hasBare = config.plugin.some((p) => p === PLUGIN_NAME);
+    const hasVersioned = config.plugin.some((p) => p.startsWith(`${PLUGIN_NAME}@`));
+    if (migratedFrom.length === 0 && !hasBare && !hasVersioned) {
+        if (config.plugin.some((p) => p === PLUGIN_LATEST)) {
+            return { migratedFrom: [], changed: false };
+        }
         return { migratedFrom: [], changed: false };
     }
-    const preserved = config.plugin.filter((plugin) => !ALL_PLUGIN_NAMES.includes(plugin));
-    config.plugin = [...preserved, PLUGIN_NAME];
-    return { migratedFrom, changed: true };
+    const preserved = config.plugin.filter((plugin) => !ALL_PLUGIN_NAMES.includes(plugin) &&
+        !plugin.startsWith(`${PLUGIN_NAME}@`));
+    const existingVersioned = config.plugin.find((p) => p.startsWith(`${PLUGIN_NAME}@`));
+    config.plugin = [...preserved, existingVersioned || PLUGIN_LATEST];
+    if (migratedFrom.length > 0 || hasBare) {
+        return { migratedFrom: [...migratedFrom, hasBare ? PLUGIN_NAME : ""].filter(Boolean), changed: true };
+    }
+    return { migratedFrom: [], changed: false };
 }
 async function installPlugin(options) {
     const isLocal = options.local || false;
@@ -120,13 +134,14 @@ async function installPlugin(options) {
             log("");
             return;
         }
-        if (config.plugin.includes(PLUGIN_NAME)) {
+        const alreadyInstalled = config.plugin.some((p) => p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`));
+        if (alreadyInstalled) {
             warning(`플러그인이 이미 설치되어 있습니다.`);
-            info(`현재 ${scope} 설정에 등록되어 있습니다: ${PLUGIN_NAME}`);
+            info(`현재 ${scope} 설정에 등록되어 있습니다: ${PLUGIN_LATEST}`);
             log("");
             return;
         }
-        config.plugin.push(PLUGIN_NAME);
+        config.plugin.push(PLUGIN_LATEST);
         writeConfig(configPath, config);
         let createdRuntimeConfig = false;
         let createdPluginConfig = false;
@@ -150,7 +165,7 @@ async function installPlugin(options) {
         }
         success(`플러그인이 성공적으로 설치되었습니다!`);
         log("");
-        log(`📦 설치된 플러그인: ${PLUGIN_NAME}`, "bright");
+        log(`📦 설치된 플러그인: ${PLUGIN_LATEST}`, "bright");
         log(`📍 위치: ${configPath}`, "dim");
         log("");
         log(`다음 단계:`, "bright");
@@ -190,7 +205,7 @@ async function uninstallPlugin(options) {
             log("");
             return;
         }
-        config.plugin = config.plugin.filter((p) => !ALL_PLUGIN_NAMES.includes(p));
+        config.plugin = config.plugin.filter((p) => !ALL_PLUGIN_NAMES.includes(p) && !p.startsWith(`${PLUGIN_NAME}@`));
         writeConfig(configPath, config);
         success(`플러그인이 성공적으로 제거되었습니다.`);
         log("");

package/dist/plugin/index.js

@@ -5,6 +5,8 @@ import * as os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { VERSION } from '../version.js';
+import { fetchNpmDistTags } from '../cli/config-manager/npm-dist-tags.js';
+import { checkVersionCompatibility } from '../cli/config-manager/version-compatibility.js';
 import { loadPluginConfig, isMaskEnabled, isToolEnabled, getDefaultMask, isAutoActivateEnabled, isVerboseLoggingEnabled, isCompletionSoundEnabled, validateConfig, } from './config/index.js';
 import { createMemorySearchTool } from './tools/memorySearch.js';
 import { createMemoryWriteTool } from './tools/memoryWrite.js';
@@ -595,10 +597,10 @@ function playCompletionSound(config) {
 }
 let state = null;
 const OPENCODE_PACKAGES_DIR = path.join(os.homedir(), '.cache', 'opencode', 'packages');
-const MASKWEAVER_PACKAGE_GLOB = 'maskweaver@*';
-function getCacheVersion() {
-    if (!fs.existsSync(OPENCODE_PACKAGES_DIR))
-        return null;
+function getCachedPackageVersion() {
+    if (!fs.existsSync(OPENCODE_PACKAGES_DIR)) {
+        return { version: null, pkgDir: null };
+    }
     const entries = fs.readdirSync(OPENCODE_PACKAGES_DIR);
     for (const entry of entries) {
         if (!entry.startsWith('maskweaver@'))
@@ -615,51 +617,88 @@ function getCacheVersion() {
             continue;
         }
     }
-    return null;
+    return { version: null, pkgDir: null };
 }
-function getLatestNpmVersion() {
-    try {
-        const result = spawnSync('npm', ['view', 'maskweaver', 'version'], {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-            timeout: 10000,
-            windowsHide: true,
-        });
-        if (result.status === 0 && result.stdout) {
-            return result.stdout.trim();
-        }
-    }
-    catch { }
-    return null;
+async function fetchLatestFromRegistry() {
+    return fetchNpmDistTags('maskweaver');
 }
-function checkAndInvalidateCache() {
-    const cached = getCacheVersion();
-    if (!cached) {
-        return { invalidated: false, cachedVersion: null, latestVersion: null };
+async function checkForUpdates() {
+    const cached = getCachedPackageVersion();
+    const installedVersion = cached.version;
+    const latestTags = await fetchLatestFromRegistry();
+    const latestVersion = latestTags?.latest ?? null;
+    if (!installedVersion) {
+        return {
+            updateAvailable: false,
+            installedVersion: null,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: null,
+        };
     }
-    if (cached.version === VERSION) {
-        return { invalidated: false, cachedVersion: cached.version, latestVersion: null };
+    if (installedVersion === VERSION) {
+        return {
+            updateAvailable: false,
+            installedVersion,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: null,
+        };
     }
-    const latest = getLatestNpmVersion();
-    if (latest && latest !== cached.version) {
-        try {
-            fs.rmSync(cached.pkgDir, { recursive: true, force: true });
-            return { invalidated: true, cachedVersion: cached.version, latestVersion: latest };
-        }
-        catch {
-            return { invalidated: false, cachedVersion: cached.version, latestVersion: latest };
-        }
+    if (!latestVersion || latestVersion === installedVersion) {
+        return {
+            updateAvailable: false,
+            installedVersion,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: `Plugin cache v${installedVersion} — current is v${VERSION}.`,
+        };
+    }
+    const compatibility = checkVersionCompatibility(installedVersion, latestVersion);
+    const currentIsLatest = installedVersion === latestVersion;
+    if (currentIsLatest) {
+        return {
+            updateAvailable: false,
+            installedVersion,
+            latestVersion,
+            isDowngrade: false,
+            isMajorBump: false,
+            requiresMigration: false,
+            message: `Plugin cache v${installedVersion} — current is v${VERSION}.`,
+        };
     }
-    return { invalidated: false, cachedVersion: cached.version, latestVersion: latest };
+    return {
+        updateAvailable: true,
+        installedVersion,
+        latestVersion,
+        isDowngrade: compatibility.isDowngrade,
+        isMajorBump: compatibility.isMajorBump,
+        requiresMigration: compatibility.requiresMigration,
+        message: `Update available: v${installedVersion} → v${latestVersion}${compatibility.requiresMigration ? ' (major upgrade — migration may be required)' : ''}.`,
+    };
 }
 export const MaskweaverPlugin = async ({ client, directory, project, worktree, $, serverUrl }) => {
-    const cacheCheck = checkAndInvalidateCache();
-    if (cacheCheck.invalidated) {
-        pluginLog(client, 'warn', `Stale plugin cache detected (v${cacheCheck.cachedVersion}). Cleared — v${cacheCheck.latestVersion} will install on next restart.`);
-        pluginLog(client, 'warn', `Please restart OpenCode to activate maskweaver v${VERSION}.`);
+    const updateCheck = await checkForUpdates();
+    if (updateCheck.updateAvailable) {
+        if (updateCheck.isDowngrade) {
+            pluginLog(client, 'warn', `Downgrade detected (v${updateCheck.installedVersion} → v${updateCheck.latestVersion}) — not allowed. Please use opencode --upgrade.`);
+        }
+        else {
+            pluginLog(client, 'warn', `Update available: maskweaver v${updateCheck.installedVersion} → v${updateCheck.latestVersion}`);
+            if (updateCheck.requiresMigration) {
+                pluginLog(client, 'warn', `Major version upgrade — configuration migration may be required.`);
+            }
+            pluginLog(client, 'info', `Run \`opencode --upgrade\` or \`npm update -g maskweaver\` to update.`);
+        }
     }
-    else if (cacheCheck.cachedVersion && cacheCheck.cachedVersion !== VERSION) {
-        pluginLog(client, 'info', `Plugin cache v${cacheCheck.cachedVersion} — current is v${VERSION}. Restart recommended.`);
+    else if (updateCheck.message) {
+        pluginLog(client, 'info', updateCheck.message);
     }
     const pluginConfig = loadPluginConfig(directory, { client, verbose: false });
     const configErrors = validateConfig(pluginConfig);

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.9.9";
+export declare const VERSION = "0.10.1";
 export declare function getVersionString(): string;

package/dist/version.js

@@ -1,4 +1,4 @@
-export const VERSION = '0.9.9';
+export const VERSION = '0.10.1';
 export function getVersionString() {
     return `Maskweaver v${VERSION}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maskweaver",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "AI Expert Persona System - Give your AI coding assistant expert personalities (가면술사)",
   "type": "module",
   "main": "./dist/index.js",