@wpro-eng/opencode-config 1.0.0 → 1.1.2

package/dist/index.js

@@ -4,25 +4,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __require = import.meta.require;
@@ -7476,7 +7494,6 @@ var NEVER = INVALID;
 // src/config.ts
 import { existsSync, readFileSync } from "fs";
 import { dirname, join as join2 } from "path";
-import { homedir as homedir2 } from "os";
 
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -8283,7 +8300,6 @@ var ParseErrorCode;
 })(ParseErrorCode || (ParseErrorCode = {}));
 
 // src/constants.ts
-var TEAM_REPO_URL = "git@github.com:wpromote/opencode-config.git";
 var REPO_SHORT_NAME = "opencode-config";
 var CONFIG_FILENAMES = ["wpromote.json", "wpromote.jsonc"];
 
@@ -8329,7 +8345,6 @@ function logWarn(message) {
 // src/config.ts
 var UserConfigSchema = exports_external.object({
   disable: exports_external.array(exports_external.string()).default([]),
-  ref: exports_external.string().optional(),
   installMethod: exports_external.enum(["link", "copy"]).default("link"),
   dryRun: exports_external.boolean().default(false),
   orchestration: exports_external.object({
@@ -8390,7 +8405,6 @@ var UserConfigSchema = exports_external.object({
 }).strict();
 var DEFAULT_CONFIG = {
   disable: [],
-  ref: undefined,
   installMethod: "link",
   dryRun: false,
   orchestration: {
@@ -8445,7 +8459,8 @@ var DEFAULT_CONFIG = {
 };
 function getConfigPaths() {
   const projectDir = join2(process.cwd(), ".opencode");
-  const userDir = join2(homedir2(), ".config", "opencode");
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  const userDir = join2(home, ".config", "opencode");
   return [
     ...CONFIG_FILENAMES.map((filename) => join2(projectDir, filename)),
     ...CONFIG_FILENAMES.map((filename) => join2(userDir, filename))
@@ -8485,9 +8500,8 @@ function loadConfigWithLocation() {
   return { config: DEFAULT_CONFIG, configDir: null };
 }
 
-// src/git.ts
+// src/assets.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
-var {$ } = globalThis.Bun;
 import * as path from "path";
 import * as fs from "fs";
 
@@ -8610,201 +8624,27 @@ function discoverInstructions(repoPath) {
   return instructions;
 }
 
-// src/repo.ts
-function getRepoId(url) {
-  const sshMatch = url.match(/^git@([^:]+):(.+?)(\.git)?$/);
-  if (sshMatch) {
-    const host = sshMatch[1];
-    const p = sshMatch[2].replace(/\//g, "-");
-    return `${host}-${p}`;
-  }
-  const httpsMatch = url.match(/^https?:\/\/([^/]+)\/(.+?)(\.git)?$/);
-  if (httpsMatch) {
-    const host = httpsMatch[1];
-    const p = httpsMatch[2].replace(/\//g, "-");
-    return `${host}-${p}`;
-  }
-  return url.replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").slice(0, 100);
-}
-
-// src/git.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 3,
-  initialDelayMs: 1000,
-  maxDelayMs: 30000,
-  backoffMultiplier: 2
-};
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-async function withRetry(operation, operationName, config = DEFAULT_RETRY_CONFIG) {
-  let lastError;
-  let delay = config.initialDelayMs;
-  for (let attempt = 0;attempt <= config.maxRetries; attempt++) {
-    try {
-      return await operation();
-    } catch (error) {
-      lastError = error;
-      const isNetworkError = isNetworkRelatedError(lastError);
-      if (!isNetworkError) {
-        throw lastError;
-      }
-      if (attempt >= config.maxRetries) {
-        logError(`${operationName} failed after ${config.maxRetries + 1} attempts: ${lastError.message}`);
-        throw lastError;
-      }
-      logWarn(`${operationName} failed (attempt ${attempt + 1}/${config.maxRetries + 1}), retrying in ${delay}ms: ${lastError.message}`);
-      await sleep(delay);
-      delay = Math.min(delay * config.backoffMultiplier, config.maxDelayMs);
-    }
-  }
-  throw lastError || new Error(`${operationName} failed`);
-}
-function isNetworkRelatedError(error) {
-  const message = error.message.toLowerCase();
-  const networkPatterns = [
-    "could not resolve host",
-    "connection refused",
-    "connection timed out",
-    "connection reset",
-    "network is unreachable",
-    "no route to host",
-    "temporary failure in name resolution",
-    "ssl",
-    "tls",
-    "certificate",
-    "handshake",
-    "unable to access",
-    "couldn't connect",
-    "failed to connect",
-    "ssh_exchange_identification",
-    "kex_exchange_identification",
-    "connection closed by remote host",
-    "early eof",
-    "unexpected disconnect",
-    "remote end hung up",
-    "the remote end hung up unexpectedly"
-  ];
-  return networkPatterns.some((pattern) => message.includes(pattern));
-}
-var CACHE_BASE = path.join(process.env.HOME || "~", ".cache", "opencode", "wpromote-config", "repos");
+// src/assets.ts
 var DISCOVERY_LIMITS = {
   maxFiles: 100,
   maxFileSize: 256 * 1024,
   maxDepth: 10
 };
-function getRepoPath(url) {
-  return path.join(CACHE_BASE, getRepoId(url));
-}
-function isCloned(repoPath) {
-  return fs.existsSync(path.join(repoPath, ".git"));
-}
-async function cloneRepo(url, repoPath, retryConfig = DEFAULT_RETRY_CONFIG) {
-  fs.mkdirSync(path.dirname(repoPath), { recursive: true });
-  await withRetry(async () => {
-    const result = await $`git clone ${url} ${repoPath}`.quiet().nothrow();
-    if (result.exitCode !== 0) {
-      const stderr = result.stderr.toString().trim();
-      const stdout = result.stdout.toString().trim();
-      const output = [stderr, stdout].filter(Boolean).join(`
-`) || `exit code ${result.exitCode}`;
-      throw new Error(`git clone failed: ${output}`);
-    }
-  }, `git clone ${url}`, retryConfig);
-}
-async function fetchAndCheckout(repoPath, ref, retryConfig = DEFAULT_RETRY_CONFIG) {
-  const beforeCommit = await $`git -C ${repoPath} rev-parse HEAD`.quiet();
-  const beforeHash = beforeCommit.stdout.toString().trim();
-  await withRetry(async () => {
-    const fetchResult = await $`git -C ${repoPath} fetch --all --prune`.quiet();
-    if (fetchResult.exitCode !== 0) {
-      const stderr = fetchResult.stderr.toString().trim();
-      const stdout = fetchResult.stdout.toString().trim();
-      const output = [stderr, stdout].filter(Boolean).join(`
-`) || `exit code ${fetchResult.exitCode}`;
-      throw new Error(`git fetch failed: ${output}`);
-    }
-  }, `git fetch (${repoPath})`, retryConfig);
-  const checkoutResult = await $`git -C ${repoPath} checkout ${ref}`.quiet().nothrow();
-  if (checkoutResult.exitCode !== 0) {
-    const stderr = checkoutResult.stderr.toString().trim();
-    const stdout = checkoutResult.stdout.toString().trim();
-    const output = [stderr, stdout].filter(Boolean).join(`
-`) || `exit code ${checkoutResult.exitCode}`;
-    throw new Error(`git checkout ${ref} failed: ${output}`);
-  }
-  const isBranch = await $`git -C ${repoPath} symbolic-ref -q HEAD`.quiet().nothrow();
-  if (isBranch.exitCode === 0) {
-    await withRetry(async () => {
-      const pullResult = await $`git -C ${repoPath} pull --ff-only`.quiet();
-      if (pullResult.exitCode !== 0) {
-        const stderr = pullResult.stderr.toString().trim();
-        const stdout = pullResult.stdout.toString().trim();
-        const output = [stderr, stdout].filter(Boolean).join(`
-`) || `exit code ${pullResult.exitCode}`;
-        throw new Error(`git pull failed: ${output}`);
-      }
-    }, `git pull (${repoPath})`, retryConfig);
-  }
-  const afterCommit = await $`git -C ${repoPath} rev-parse HEAD`.quiet();
-  const afterHash = afterCommit.stdout.toString().trim();
-  return beforeHash !== afterHash;
-}
-async function getCurrentRef(repoPath) {
-  const branchResult = await $`git -C ${repoPath} symbolic-ref --short HEAD`.quiet().nothrow();
-  if (branchResult.exitCode === 0)
-    return branchResult.stdout.toString().trim();
-  const commitResult = await $`git -C ${repoPath} rev-parse --short HEAD`.quiet();
-  return commitResult.stdout.toString().trim();
-}
-async function syncTeamRepository(ref) {
-  const effectiveRef = ref ?? "main";
-  const repoId = getRepoId(TEAM_REPO_URL);
-  const repoPath = getRepoPath(TEAM_REPO_URL);
-  const shortName = REPO_SHORT_NAME;
-  let updated = false;
-  let error;
-  try {
-    if (!isCloned(repoPath)) {
-      if (fs.existsSync(repoPath)) {
-        fs.rmSync(repoPath, { recursive: true, force: true });
-      }
-      await cloneRepo(TEAM_REPO_URL, repoPath);
-      updated = true;
-    }
-    updated = await fetchAndCheckout(repoPath, effectiveRef) || updated;
-  } catch (err) {
-    error = err instanceof Error ? err.message : String(err);
-  }
-  let skills = [];
-  let agents = [];
-  let commands = [];
-  let plugins = [];
-  let instructions = [];
-  let mcps = [];
-  let currentRef = effectiveRef;
-  if (isCloned(repoPath)) {
-    currentRef = await getCurrentRef(repoPath);
-    skills = await discoverSkills(repoPath);
-    agents = await discoverAgents(repoPath);
-    commands = await discoverCommands(repoPath);
-    plugins = await discoverPlugins(repoPath, shortName);
-    instructions = discoverInstructions(repoPath);
-    mcps = await discoverMcps(repoPath);
-  }
+async function discoverAssets(packageRoot) {
+  const skills = await discoverSkills(packageRoot);
+  const agents = await discoverAgents(packageRoot);
+  const commands = await discoverCommands(packageRoot);
+  const plugins = await discoverPlugins(packageRoot, REPO_SHORT_NAME);
+  const instructions = discoverInstructions(packageRoot);
+  const mcps = await discoverMcps(packageRoot);
   return {
-    repoId,
-    repoPath,
-    shortName,
-    ref: currentRef,
+    shortName: REPO_SHORT_NAME,
     skills,
     agents,
     commands,
     plugins,
     instructions,
-    mcps,
-    updated,
-    error
+    mcps
   };
 }
 async function discoverSkills(repoPath) {
@@ -9130,10 +8970,10 @@ async function discoverMcps(repoPath) {
 // src/install.ts
 import * as path3 from "path";
 import * as fs3 from "fs";
-var {$: $3 } = globalThis.Bun;
+var {$: $2 } = globalThis.Bun;
 
 // src/copy.ts
-var {$: $2 } = globalThis.Bun;
+var {$ } = globalThis.Bun;
 import * as fs2 from "fs";
 import * as path2 from "path";
 var rsyncAvailable = null;
@@ -9142,7 +8982,7 @@ async function detectRsync() {
     return rsyncAvailable;
   }
   try {
-    const result = await $2`which rsync`.quiet();
+    const result = await $`which rsync`.quiet();
     rsyncAvailable = result.exitCode === 0;
   } catch {
     rsyncAvailable = false;
@@ -9157,7 +8997,7 @@ async function copyWithRsync(source, target) {
     } else if (stat.isDirectory()) {}
   }
   fs2.mkdirSync(path2.dirname(target), { recursive: true });
-  const result = await $2`rsync -a --delete ${source}/ ${target}/`.quiet();
+  const result = await $`rsync -a --delete ${source}/ ${target}/`.quiet();
   if (result.exitCode !== 0) {
     throw new Error(`rsync failed: ${result.stderr.toString()}`);
   }
@@ -9384,7 +9224,7 @@ function hasLocalConflict(skillName) {
 }
 async function findGitRoot(startPath) {
   try {
-    const result = await $3`git -C ${startPath} rev-parse --show-toplevel`.quiet();
+    const result = await $2`git -C ${startPath} rev-parse --show-toplevel`.quiet();
     if (result.exitCode === 0) {
       return result.stdout.toString().trim();
     }
@@ -9432,9 +9272,9 @@ ${gitignoreEntry}
 // src/plugin-install.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
-import { homedir as homedir3 } from "os";
-var PLUGIN_DIR_PLURAL = path4.join(homedir3(), ".config", "opencode", "plugins");
-var PLUGIN_DIR_SINGULAR = path4.join(homedir3(), ".config", "opencode", "plugin");
+import { homedir as homedir2 } from "os";
+var PLUGIN_DIR_PLURAL = path4.join(homedir2(), ".config", "opencode", "plugins");
+var PLUGIN_DIR_SINGULAR = path4.join(homedir2(), ".config", "opencode", "plugin");
 var REMOTE_PREFIX = "_remote_";
 function removePathIfExists(targetPath) {
   try {
@@ -9607,8 +9447,8 @@ function findBrokenUnmanagedPluginLinks(pluginDir) {
 // src/mcp-install.ts
 import * as fs5 from "fs";
 import * as path5 from "path";
-import { homedir as homedir4 } from "os";
-var DEFAULT_MCP_DIR = path5.join(homedir4(), ".config", "opencode", "mcp");
+import { homedir as homedir3 } from "os";
+var DEFAULT_MCP_DIR = path5.join(homedir3(), ".config", "opencode", "mcp");
 function getMcpPluginsSubdirForRepo(repoShortName) {
   return path5.join("_plugins", repoShortName);
 }
@@ -9808,131 +9648,12 @@ function createDisableMatcher(disable) {
   };
 }
 
-// src/lock.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
-import * as os from "os";
-var DEFAULT_TIMEOUT_MS = 30000;
-var POLL_INTERVAL_MS = 500;
-var STALE_THRESHOLD_MS = 5 * 60 * 1000;
-function getLockPath() {
-  return path6.join(getRepoPath(TEAM_REPO_URL), ".sync.lock");
-}
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    if (err.code === "EPERM") {
-      return true;
-    }
-    return false;
-  }
-}
-function isLockStale(lockData) {
-  if (lockData.hostname === os.hostname()) {
-    if (!isProcessRunning(lockData.pid)) {
-      logDebug(`Lock held by dead process ${lockData.pid}, considering stale`);
-      return true;
-    }
-  }
-  const age = Date.now() - lockData.timestamp;
-  if (age > STALE_THRESHOLD_MS) {
-    if (lockData.hostname !== os.hostname()) {
-      logDebug(`Lock from remote host ${lockData.hostname} is ${Math.round(age / 1000)}s old, considering stale`);
-      return true;
-    }
-  }
-  return false;
-}
-function readLockData() {
-  const lockPath = getLockPath();
-  try {
-    const content = fs6.readFileSync(lockPath, "utf8");
-    const data = JSON.parse(content);
-    if (typeof data.pid !== "number" || typeof data.hostname !== "string" || typeof data.timestamp !== "number") {
-      logDebug("Invalid lockfile structure, ignoring");
-      return;
-    }
-    return data;
-  } catch {
-    return;
-  }
-}
-function removeLockFile() {
-  const lockPath = getLockPath();
-  try {
-    fs6.unlinkSync(lockPath);
-  } catch {}
-}
-function tryAcquireLock() {
-  const lockPath = getLockPath();
-  fs6.mkdirSync(path6.dirname(lockPath), { recursive: true });
-  const existingLock = readLockData();
-  if (existingLock) {
-    if (isLockStale(existingLock)) {
-      logDebug("Removing stale lock");
-      removeLockFile();
-    } else {
-      return false;
-    }
-  }
-  try {
-    const data = {
-      pid: process.pid,
-      hostname: os.hostname(),
-      timestamp: Date.now()
-    };
-    fs6.writeFileSync(lockPath, JSON.stringify(data, null, 2), { flag: "wx" });
-    return true;
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      return false;
-    }
-    throw err;
-  }
-}
-async function acquireLock(timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const startTime = Date.now();
-  while (true) {
-    if (tryAcquireLock()) {
-      logDebug("Acquired sync lock");
-      return { acquired: true };
-    }
-    const elapsed = Date.now() - startTime;
-    if (elapsed >= timeoutMs) {
-      const lockData = readLockData();
-      const holder = lockData ? `pid ${lockData.pid} on ${lockData.hostname}` : "unknown process";
-      return {
-        acquired: false,
-        error: `Failed to acquire sync lock after ${Math.round(elapsed / 1000)}s (held by ${holder})`
-      };
-    }
-    await new Promise((resolve4) => setTimeout(resolve4, POLL_INTERVAL_MS));
-  }
-}
-function releaseLock() {
-  const lockData = readLockData();
-  if (lockData && lockData.pid === process.pid && lockData.hostname === os.hostname()) {
-    removeLockFile();
-    logDebug("Released sync lock");
-  }
-}
-async function withLock(fn, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const lockResult = await acquireLock(timeoutMs);
-  if (!lockResult.acquired) {
-    throw new Error(lockResult.error);
-  }
-  try {
-    return await fn();
-  } finally {
-    releaseLock();
-  }
-}
+// src/index.ts
+import * as path8 from "path";
 
 // src/mcp-schema.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
@@ -10080,7 +9801,7 @@ function validateMcpConfig(obj) {
 }
 function validateMcpFile(mcpJsonPath) {
   try {
-    const content = fs7.readFileSync(mcpJsonPath, "utf-8");
+    const content = fs6.readFileSync(mcpJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     return validateMcpConfig(parsed);
   } catch (err) {
@@ -10099,7 +9820,7 @@ function validateMcpFile(mcpJsonPath) {
   }
 }
 function validateMcpInfo(mcp) {
-  const mcpJsonPath = mcp.path.endsWith(".json") ? mcp.path : path7.join(mcp.path, "mcp.json");
+  const mcpJsonPath = mcp.path.endsWith(".json") ? mcp.path : path6.join(mcp.path, "mcp.json");
   const result = validateMcpFile(mcpJsonPath);
   for (const warning of result.warnings) {
     logWarn(`MCP '${mcp.name}': ${warning}`);
@@ -10117,32 +9838,22 @@ function filterValidMcps(mcps) {
 }
 
 // src/status.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
-var STATUS_BASE = path8.join(process.env.HOME || "~", ".cache", "opencode", "wpromote-config");
+import * as fs7 from "fs";
+import * as path7 from "path";
+var STATUS_BASE = path7.join(process.env.HOME || "~", ".cache", "opencode", "wpromote-config");
 function getStatusFilePath() {
-  return path8.join(STATUS_BASE, `${REPO_SHORT_NAME}.sync-status.json`);
-}
-function readSyncStatus() {
-  const statusPath = getStatusFilePath();
-  try {
-    const content = fs8.readFileSync(statusPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
+  return path7.join(STATUS_BASE, `${REPO_SHORT_NAME}.sync-status.json`);
 }
 function writeSyncStatus(status) {
   const statusPath = getStatusFilePath();
-  const dir = path8.dirname(statusPath);
-  fs8.mkdirSync(dir, { recursive: true });
-  fs8.writeFileSync(statusPath, JSON.stringify(status, null, 2));
+  const dir = path7.dirname(statusPath);
+  fs7.mkdirSync(dir, { recursive: true });
+  fs7.writeFileSync(statusPath, JSON.stringify(status, null, 2));
   logDebug(`Wrote sync status to ${statusPath}`);
 }
 function updateSyncStatus(data) {
   const status = {
     lastSyncTime: new Date().toISOString(),
-    currentRef: data.currentRef,
     installedSkills: data.installedSkills,
     installedPlugins: data.installedPlugins,
     installedMcps: data.installedMcps,
@@ -10156,43 +9867,16 @@ function updateSyncStatus(data) {
   };
   writeSyncStatus(status);
 }
-function recordSyncError(error) {
-  const existing = readSyncStatus();
-  const status = existing ?? {
-    lastSyncTime: null,
-    currentRef: null,
-    installedSkills: 0,
-    installedPlugins: 0,
-    installedMcps: 0,
-    remoteAgents: 0,
-    remoteCommands: 0,
-    remoteInstructions: 0,
-    skippedConflicts: 0,
-    disabledAssets: 0,
-    lastError: null,
-    pluginsChanged: false
-  };
-  status.lastError = error;
-  writeSyncStatus(status);
-}
 
 // src/index.ts
+var PACKAGE_ROOT = path8.resolve(import.meta.dir, "..");
 var initialized = false;
 var REQUIRED_RUNTIME_PLUGINS = ["@tarquinen/opencode-dcp@latest"];
 var DEFAULT_OPENCODE_AGENTS_TO_DISABLE = ["build", "plan"];
 async function performSync(config) {
   const disableMatcher = createDisableMatcher(config.disable);
   log(config.dryRun ? "[DRY-RUN] Analyzing team configuration..." : "Syncing team configuration...");
-  const result = await syncTeamRepository(config.ref);
-  const degradedSyncMode = Boolean(result.error);
-  if (degradedSyncMode) {
-    const syncError = result.error ?? "Unknown sync error";
-    logError(`\u2717 Failed to sync team repository: ${syncError}`);
-    if (!config.dryRun) {
-      recordSyncError(syncError);
-    }
-    log("Continuing with cached assets in degraded mode");
-  }
+  const result = await discoverAssets(PACKAGE_ROOT);
   if (!config.dryRun) {
     const brokenUnmanagedLinks = findBrokenUnmanagedPluginLinks();
     if (brokenUnmanagedLinks.length > 0) {
@@ -10366,20 +10050,6 @@ async function performSync(config) {
       dryRun: dryRunReport
     };
   }
-  if (degradedSyncMode) {
-    return {
-      result,
-      skippedConflicts,
-      totalSkills: 0,
-      remoteAgents,
-      remoteCommands,
-      remoteMcps,
-      remoteInstructions,
-      pluginsChanged: false,
-      totalPlugins: 0,
-      totalMcps: 0
-    };
-  }
   const filteredResult = { ...result, skills: skillsToInstall };
   const installResults = await createInstallsForRepo(filteredResult, config.installMethod);
   for (const sr of installResults) {
@@ -10390,7 +10060,7 @@ async function performSync(config) {
       logError(`\u2717 Failed to install skill ${sr.skillName}: ${sr.error}`);
     }
   }
-  log(`\u2713 ${result.shortName} (${result.ref}) - ${totalSkills} skills`);
+  log(`\u2713 ${result.shortName} - ${totalSkills} skills`);
   const cleanup = cleanupStaleInstalls(currentSkills);
   if (cleanup.removed.length > 0) {
     log(`Cleaned up ${cleanup.removed.length} stale skill installs`);
@@ -10450,7 +10120,6 @@ async function performSync(config) {
   }
   const totalMcps = newMcpInstalls.size;
   updateSyncStatus({
-    currentRef: result.ref,
     installedSkills: totalSkills,
     installedPlugins: totalPlugins,
     installedMcps: totalMcps,
@@ -10536,7 +10205,7 @@ var WpromoteConfigPlugin = async (ctx) => {
     pluginsChanged,
     totalPlugins,
     totalMcps
-  } = await withLock(async () => performSync(userConfig));
+  } = await performSync(userConfig);
   if (pluginsChanged) {
     log("\u26A0 Plugin changes detected. Restart OpenCode to apply.");
   }

package/instruction/getting-started.md

@@ -0,0 +1,24 @@
+# Getting Started with Wpromote OpenCode
+
+Welcome to the Wpromote OpenCode configuration.
+
+## Quick Start
+
+1. Install the plugin
+2. Restart OpenCode
+3. All team configs will be synced automatically
+
+## Configuration
+
+Create `~/.config/opencode/wpromote.json` (or `~/.config/opencode/wpromote.jsonc`) to customize:
+
+```json
+{
+  "disable": ["skill:example"],
+  "installMethod": "link"
+}
+```
+
+## Overriding Team Configs
+
+To override a team skill/agent/command, create a local file with the same name in your personal config directory.