oh-my-opencode 2.5.4 → 2.6.0

package/dist/cli/index.js

@@ -2244,7 +2244,7 @@ var require_picocolors = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "oh-my-opencode",
-    version: "2.5.3",
+    version: "2.5.4",
     description: "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -2303,6 +2303,7 @@ var require_package = __commonJS((exports, module) => {
       "@opencode-ai/sdk": "^1.0.162",
       commander: "^14.0.2",
       hono: "^4.10.4",
+      "jsonc-parser": "^3.3.1",
       picocolors: "^1.1.1",
       picomatch: "^4.0.2",
       "xdg-basedir": "^5.1.0",
@@ -2923,12 +2924,886 @@ var import_picocolors2 = __toESM(require_picocolors(), 1);
 // src/cli/config-manager.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
-var OPENCODE_CONFIG_DIR = join(homedir(), ".config", "opencode");
-var OPENCODE_JSON = join(OPENCODE_CONFIG_DIR, "opencode.json");
-var OPENCODE_JSONC = join(OPENCODE_CONFIG_DIR, "opencode.jsonc");
-var OPENCODE_PACKAGE_JSON = join(OPENCODE_CONFIG_DIR, "package.json");
-var OMO_CONFIG = join(OPENCODE_CONFIG_DIR, "oh-my-opencode.json");
+import { join as join2 } from "path";
+// src/shared/command-executor.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+// src/shared/logger.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var logFile = path.join(os.tmpdir(), "oh-my-opencode.log");
+function log(message, data) {
+  try {
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}
+`;
+    fs.appendFileSync(logFile, logEntry);
+  } catch {}
+}
+// src/shared/deep-merge.ts
+var DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_3, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_3, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_3, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_3, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_3, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_3, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_3, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function printParseErrorCode(code) {
+  switch (code) {
+    case 1:
+      return "InvalidSymbol";
+    case 2:
+      return "InvalidNumberFormat";
+    case 3:
+      return "PropertyNameExpected";
+    case 4:
+      return "ValueExpected";
+    case 5:
+      return "ColonExpected";
+    case 6:
+      return "CommaExpected";
+    case 7:
+      return "CloseBraceExpected";
+    case 8:
+      return "CloseBracketExpected";
+    case 9:
+      return "EndOfFileExpected";
+    case 10:
+      return "InvalidCommentToken";
+    case 11:
+      return "UnexpectedEndOfComment";
+    case 12:
+      return "UnexpectedEndOfString";
+    case 13:
+      return "UnexpectedEndOfNumber";
+    case 14:
+      return "InvalidUnicode";
+    case 15:
+      return "InvalidEscapeCharacter";
+    case 16:
+      return "InvalidCharacter";
+  }
+  return "<unknown ParseErrorCode>";
+}
+
+// src/shared/jsonc-parser.ts
+function parseJsonc(content) {
+  const errors = [];
+  const result = parse2(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    const errorMessages = errors.map((e2) => `${printParseErrorCode(e2.error)} at offset ${e2.offset}`).join(", ");
+    throw new SyntaxError(`JSONC parse error: ${errorMessages}`);
+  }
+  return result;
+}
+// src/cli/config-manager.ts
+var OPENCODE_CONFIG_DIR = join2(homedir(), ".config", "opencode");
+var OPENCODE_JSON = join2(OPENCODE_CONFIG_DIR, "opencode.json");
+var OPENCODE_JSONC = join2(OPENCODE_CONFIG_DIR, "opencode.jsonc");
+var OPENCODE_PACKAGE_JSON = join2(OPENCODE_CONFIG_DIR, "package.json");
+var OMO_CONFIG = join2(OPENCODE_CONFIG_DIR, "oh-my-opencode.json");
 var CHATGPT_HOTFIX_REPO = "code-yeongyu/opencode-openai-codex-auth#fix/orphaned-function-call-output-with-tools";
 async function fetchLatestVersion(packageName) {
   try {
@@ -2950,67 +3825,10 @@ function detectConfigFormat() {
   }
   return { format: "none", path: OPENCODE_JSON };
 }
-function stripJsoncComments(content) {
-  let result = "";
-  let i = 0;
-  let inString = false;
-  let escape = false;
-  while (i < content.length) {
-    const char = content[i];
-    if (escape) {
-      result += char;
-      escape = false;
-      i++;
-      continue;
-    }
-    if (char === "\\") {
-      result += char;
-      escape = true;
-      i++;
-      continue;
-    }
-    if (char === '"' && !inString) {
-      inString = true;
-      result += char;
-      i++;
-      continue;
-    }
-    if (char === '"' && inString) {
-      inString = false;
-      result += char;
-      i++;
-      continue;
-    }
-    if (inString) {
-      result += char;
-      i++;
-      continue;
-    }
-    if (char === "/" && content[i + 1] === "/") {
-      while (i < content.length && content[i] !== `
-`) {
-        i++;
-      }
-      continue;
-    }
-    if (char === "/" && content[i + 1] === "*") {
-      i += 2;
-      while (i < content.length - 1 && !(content[i] === "*" && content[i + 1] === "/")) {
-        i++;
-      }
-      i += 2;
-      continue;
-    }
-    result += char;
-    i++;
-  }
-  return result.replace(/,(\s*[}\]])/g, "$1");
-}
-function parseConfig(path, isJsonc) {
+function parseConfig(path2, isJsonc) {
   try {
-    const content = readFileSync(path, "utf-8");
-    const cleaned = isJsonc ? stripJsoncComments(content) : content;
-    return JSON.parse(cleaned);
+    const content = readFileSync(path2, "utf-8");
+    return parseJsonc(content);
   } catch {
     return null;
   }
@@ -3022,26 +3840,26 @@ function ensureConfigDir() {
 }
 function addPluginToOpenCodeConfig() {
   ensureConfigDir();
-  const { format, path } = detectConfigFormat();
+  const { format: format2, path: path2 } = detectConfigFormat();
   const pluginName = "oh-my-opencode";
   try {
-    if (format === "none") {
+    if (format2 === "none") {
       const config2 = { plugin: [pluginName] };
-      writeFileSync(path, JSON.stringify(config2, null, 2) + `
+      writeFileSync(path2, JSON.stringify(config2, null, 2) + `
 `);
-      return { success: true, configPath: path };
+      return { success: true, configPath: path2 };
     }
-    const config = parseConfig(path, format === "jsonc");
+    const config = parseConfig(path2, format2 === "jsonc");
     if (!config) {
-      return { success: false, configPath: path, error: "Failed to parse config" };
+      return { success: false, configPath: path2, error: "Failed to parse config" };
     }
     const plugins = config.plugin ?? [];
     if (plugins.some((p2) => p2.startsWith(pluginName))) {
-      return { success: true, configPath: path };
+      return { success: true, configPath: path2 };
     }
     config.plugin = [...plugins, pluginName];
-    if (format === "jsonc") {
-      const content = readFileSync(path, "utf-8");
+    if (format2 === "jsonc") {
+      const content = readFileSync(path2, "utf-8");
       const pluginArrayRegex = /"plugin"\s*:\s*\[([\s\S]*?)\]/;
       const match = content.match(pluginArrayRegex);
       if (match) {
@@ -3051,19 +3869,19 @@ function addPluginToOpenCodeConfig() {
         const newContent = content.replace(pluginArrayRegex, `"plugin": [
     ${newArrayContent}
   ]`);
-        writeFileSync(path, newContent);
+        writeFileSync(path2, newContent);
       } else {
         const newContent = content.replace(/^(\s*\{)/, `$1
   "plugin": ["${pluginName}"],`);
-        writeFileSync(path, newContent);
+        writeFileSync(path2, newContent);
       }
     } else {
-      writeFileSync(path, JSON.stringify(config, null, 2) + `
+      writeFileSync(path2, JSON.stringify(config, null, 2) + `
 `);
     }
-    return { success: true, configPath: path };
+    return { success: true, configPath: path2 };
   } catch (err) {
-    return { success: false, configPath: path, error: String(err) };
+    return { success: false, configPath: path2, error: String(err) };
   }
 }
 function deepMerge(target, source) {
@@ -3119,8 +3937,7 @@ function writeOmoConfig(installConfig) {
     const newConfig = generateOmoConfig(installConfig);
     if (existsSync(OMO_CONFIG)) {
       const content = readFileSync(OMO_CONFIG, "utf-8");
-      const cleaned = stripJsoncComments(content);
-      const existing = JSON.parse(cleaned);
+      const existing = parseJsonc(content);
       delete existing.agents;
       const merged = deepMerge(existing, newConfig);
       writeFileSync(OMO_CONFIG, JSON.stringify(merged, null, 2) + `
@@ -3161,9 +3978,9 @@ async function getOpenCodeVersion() {
 }
 async function addAuthPlugins(config) {
   ensureConfigDir();
-  const { format, path } = detectConfigFormat();
+  const { format: format2, path: path2 } = detectConfigFormat();
   try {
-    const existingConfig = format !== "none" ? parseConfig(path, format === "jsonc") : null;
+    const existingConfig = format2 !== "none" ? parseConfig(path2, format2 === "jsonc") : null;
     const plugins = existingConfig?.plugin ?? [];
     if (config.hasGemini) {
       const version = await fetchLatestVersion("opencode-antigravity-auth");
@@ -3178,11 +3995,11 @@ async function addAuthPlugins(config) {
       }
     }
     const newConfig = { ...existingConfig ?? {}, plugin: plugins };
-    writeFileSync(path, JSON.stringify(newConfig, null, 2) + `
+    writeFileSync(path2, JSON.stringify(newConfig, null, 2) + `
 `);
-    return { success: true, configPath: path };
+    return { success: true, configPath: path2 };
   } catch (err) {
-    return { success: false, configPath: path, error: String(err) };
+    return { success: false, configPath: path2, error: String(err) };
   }
 }
 function setupChatGPTHotfix() {
@@ -3270,9 +4087,9 @@ var CODEX_PROVIDER_CONFIG = {
 };
 function addProviderConfig(config) {
   ensureConfigDir();
-  const { format, path } = detectConfigFormat();
+  const { format: format2, path: path2 } = detectConfigFormat();
   try {
-    const existingConfig = format !== "none" ? parseConfig(path, format === "jsonc") : null;
+    const existingConfig = format2 !== "none" ? parseConfig(path2, format2 === "jsonc") : null;
     const newConfig = { ...existingConfig ?? {} };
     const providers = newConfig.provider ?? {};
     if (config.hasGemini) {
@@ -3284,11 +4101,11 @@ function addProviderConfig(config) {
     if (Object.keys(providers).length > 0) {
       newConfig.provider = providers;
     }
-    writeFileSync(path, JSON.stringify(newConfig, null, 2) + `
+    writeFileSync(path2, JSON.stringify(newConfig, null, 2) + `
 `);
-    return { success: true, configPath: path };
+    return { success: true, configPath: path2 };
   } catch (err) {
-    return { success: false, configPath: path, error: String(err) };
+    return { success: false, configPath: path2, error: String(err) };
   }
 }
 function detectCurrentConfig() {
@@ -3299,11 +4116,11 @@ function detectCurrentConfig() {
     hasChatGPT: true,
     hasGemini: false
   };
-  const { format, path } = detectConfigFormat();
-  if (format === "none") {
+  const { format: format2, path: path2 } = detectConfigFormat();
+  if (format2 === "none") {
     return result;
   }
-  const openCodeConfig = parseConfig(path, format === "jsonc");
+  const openCodeConfig = parseConfig(path2, format2 === "jsonc");
   if (!openCodeConfig) {
     return result;
   }
@@ -3319,7 +4136,7 @@ function detectCurrentConfig() {
   }
   try {
     const content = readFileSync(OMO_CONFIG, "utf-8");
-    const omoConfig = JSON.parse(stripJsoncComments(content));
+    const omoConfig = parseJsonc(content);
     const agents = omoConfig.agents ?? {};
     if (agents["Sisyphus"]?.model === "opencode/big-pickle") {
       result.hasClaude = false;
@@ -3946,7 +4763,7 @@ var serializeObjectParam = ({ allowReserved, explode, name, style, value, valueO
 
 // node_modules/@opencode-ai/sdk/dist/gen/core/utils.gen.js
 var PATH_PARAM_RE = /\{[^{}]+\}/g;
-var defaultPathSerializer = ({ path, url: _url }) => {
+var defaultPathSerializer = ({ path: path2, url: _url }) => {
   let url = _url;
   const matches = _url.match(PATH_PARAM_RE);
   if (matches) {
@@ -3965,7 +4782,7 @@ var defaultPathSerializer = ({ path, url: _url }) => {
         name = name.substring(1);
         style = "matrix";
       }
-      const value = path[name];
+      const value = path2[name];
       if (value === undefined || value === null) {
         continue;
       }
@@ -3996,11 +4813,11 @@ var defaultPathSerializer = ({ path, url: _url }) => {
   }
   return url;
 };
-var getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+var getUrl = ({ baseUrl, path: path2, query, querySerializer, url: _url }) => {
   const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
   let url = (baseUrl ?? "") + pathUrl;
-  if (path) {
-    url = defaultPathSerializer({ path, url });
+  if (path2) {
+    url = defaultPathSerializer({ path: path2, url });
   }
   let search = query ? querySerializer(query) : "";
   if (search.startsWith("?")) {
@@ -5482,20 +6299,16 @@ Sending prompt...`));
 
 Session ended with error: ${eventState.lastError}`));
           console.error(import_picocolors5.default.yellow("Check if todos were completed before the error."));
-          abortController.abort();
-          await eventProcessor.catch(() => {});
           cleanup();
-          return 1;
+          process.exit(1);
         }
         const shouldExit = await checkCompletionConditions(ctx);
         if (shouldExit) {
           console.log(import_picocolors5.default.green(`
 
 All tasks completed.`));
-          abortController.abort();
-          await eventProcessor.catch(() => {});
           cleanup();
-          return 0;
+          process.exit(0);
         }
       }
       await eventProcessor.catch(() => {});
@@ -5515,6 +6328,307 @@ All tasks completed.`));
     return 1;
   }
 }
+// src/hooks/auto-update-checker/checker.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+import { fileURLToPath } from "url";
+
+// src/hooks/auto-update-checker/constants.ts
+import * as path2 from "path";
+import * as os2 from "os";
+var PACKAGE_NAME = "oh-my-opencode";
+var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+var NPM_FETCH_TIMEOUT = 5000;
+function getCacheDir() {
+  if (process.platform === "win32") {
+    return path2.join(process.env.LOCALAPPDATA ?? os2.homedir(), "opencode");
+  }
+  return path2.join(os2.homedir(), ".cache", "opencode");
+}
+var CACHE_DIR = getCacheDir();
+var VERSION_FILE = path2.join(CACHE_DIR, "version");
+var INSTALLED_PACKAGE_JSON = path2.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
+function getUserConfigDir() {
+  if (process.platform === "win32") {
+    return process.env.APPDATA ?? path2.join(os2.homedir(), "AppData", "Roaming");
+  }
+  return process.env.XDG_CONFIG_HOME ?? path2.join(os2.homedir(), ".config");
+}
+var USER_CONFIG_DIR = getUserConfigDir();
+var USER_OPENCODE_CONFIG = path2.join(USER_CONFIG_DIR, "opencode", "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = path2.join(USER_CONFIG_DIR, "opencode", "opencode.jsonc");
+
+// src/hooks/auto-update-checker/checker.ts
+function isLocalDevMode(directory) {
+  return getLocalDevPath(directory) !== null;
+}
+function stripJsonComments(json) {
+  return json.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m2, g2) => g2 ? "" : m2).replace(/,(\s*[}\]])/g, "$1");
+}
+function getConfigPaths(directory) {
+  return [
+    path3.join(directory, ".opencode", "opencode.json"),
+    path3.join(directory, ".opencode", "opencode.jsonc"),
+    USER_OPENCODE_CONFIG,
+    USER_OPENCODE_CONFIG_JSONC
+  ];
+}
+function getLocalDevPath(directory) {
+  for (const configPath of getConfigPaths(directory)) {
+    try {
+      if (!fs2.existsSync(configPath))
+        continue;
+      const content = fs2.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(stripJsonComments(content));
+      const plugins = config.plugin ?? [];
+      for (const entry of plugins) {
+        if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
+          try {
+            return fileURLToPath(entry);
+          } catch {
+            return entry.replace("file://", "");
+          }
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function findPackageJsonUp(startPath) {
+  try {
+    const stat = fs2.statSync(startPath);
+    let dir = stat.isDirectory() ? startPath : path3.dirname(startPath);
+    for (let i = 0;i < 10; i++) {
+      const pkgPath = path3.join(dir, "package.json");
+      if (fs2.existsSync(pkgPath)) {
+        try {
+          const content = fs2.readFileSync(pkgPath, "utf-8");
+          const pkg = JSON.parse(content);
+          if (pkg.name === PACKAGE_NAME)
+            return pkgPath;
+        } catch {}
+      }
+      const parent = path3.dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {}
+  return null;
+}
+function findPluginEntry(directory) {
+  for (const configPath of getConfigPaths(directory)) {
+    try {
+      if (!fs2.existsSync(configPath))
+        continue;
+      const content = fs2.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(stripJsonComments(content));
+      const plugins = config.plugin ?? [];
+      for (const entry of plugins) {
+        if (entry === PACKAGE_NAME) {
+          return { entry, isPinned: false, pinnedVersion: null, configPath };
+        }
+        if (entry.startsWith(`${PACKAGE_NAME}@`)) {
+          const pinnedVersion = entry.slice(PACKAGE_NAME.length + 1);
+          const isPinned = pinnedVersion !== "latest";
+          return { entry, isPinned, pinnedVersion: isPinned ? pinnedVersion : null, configPath };
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function getCachedVersion() {
+  try {
+    if (fs2.existsSync(INSTALLED_PACKAGE_JSON)) {
+      const content = fs2.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.version)
+        return pkg.version;
+    }
+  } catch {}
+  try {
+    const currentDir = path3.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = findPackageJsonUp(currentDir);
+    if (pkgPath) {
+      const content = fs2.readFileSync(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.version)
+        return pkg.version;
+    }
+  } catch (err) {
+    log("[auto-update-checker] Failed to resolve version from current directory:", err);
+  }
+  return null;
+}
+async function getLatestVersion() {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
+  try {
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    return data.latest ?? null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+// src/cli/get-local-version/formatter.ts
+var import_picocolors6 = __toESM(require_picocolors(), 1);
+var SYMBOLS2 = {
+  check: import_picocolors6.default.green("\u2713"),
+  cross: import_picocolors6.default.red("\u2717"),
+  arrow: import_picocolors6.default.cyan("\u2192"),
+  info: import_picocolors6.default.blue("\u2139"),
+  warn: import_picocolors6.default.yellow("\u26A0"),
+  pin: import_picocolors6.default.magenta("\uD83D\uDCCC"),
+  dev: import_picocolors6.default.cyan("\uD83D\uDD27")
+};
+function formatVersionOutput(info) {
+  const lines = [];
+  lines.push("");
+  lines.push(import_picocolors6.default.bold(import_picocolors6.default.white("oh-my-opencode Version Information")));
+  lines.push(import_picocolors6.default.dim("\u2500".repeat(50)));
+  lines.push("");
+  if (info.currentVersion) {
+    lines.push(`  Current Version: ${import_picocolors6.default.cyan(info.currentVersion)}`);
+  } else {
+    lines.push(`  Current Version: ${import_picocolors6.default.dim("unknown")}`);
+  }
+  if (!info.isLocalDev && info.latestVersion) {
+    lines.push(`  Latest Version:  ${import_picocolors6.default.cyan(info.latestVersion)}`);
+  }
+  lines.push("");
+  switch (info.status) {
+    case "up-to-date":
+      lines.push(`  ${SYMBOLS2.check} ${import_picocolors6.default.green("You're up to date!")}`);
+      break;
+    case "outdated":
+      lines.push(`  ${SYMBOLS2.warn} ${import_picocolors6.default.yellow("Update available")}`);
+      lines.push(`  ${import_picocolors6.default.dim("Run:")} ${import_picocolors6.default.cyan("cd ~/.config/opencode && bun update oh-my-opencode")}`);
+      break;
+    case "local-dev":
+      lines.push(`  ${SYMBOLS2.dev} ${import_picocolors6.default.cyan("Running in local development mode")}`);
+      lines.push(`  ${import_picocolors6.default.dim("Using file:// protocol from config")}`);
+      break;
+    case "pinned":
+      lines.push(`  ${SYMBOLS2.pin} ${import_picocolors6.default.magenta(`Version pinned to ${info.pinnedVersion}`)}`);
+      lines.push(`  ${import_picocolors6.default.dim("Update check skipped for pinned versions")}`);
+      break;
+    case "error":
+      lines.push(`  ${SYMBOLS2.cross} ${import_picocolors6.default.red("Unable to check for updates")}`);
+      lines.push(`  ${import_picocolors6.default.dim("Network error or npm registry unavailable")}`);
+      break;
+    case "unknown":
+      lines.push(`  ${SYMBOLS2.info} ${import_picocolors6.default.yellow("Version information unavailable")}`);
+      break;
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function formatJsonOutput(info) {
+  return JSON.stringify(info, null, 2);
+}
+
+// src/cli/get-local-version/index.ts
+async function getLocalVersion(options = {}) {
+  const directory = options.directory ?? process.cwd();
+  try {
+    if (isLocalDevMode(directory)) {
+      const currentVersion2 = getCachedVersion();
+      const info2 = {
+        currentVersion: currentVersion2,
+        latestVersion: null,
+        isUpToDate: false,
+        isLocalDev: true,
+        isPinned: false,
+        pinnedVersion: null,
+        status: "local-dev"
+      };
+      console.log(options.json ? formatJsonOutput(info2) : formatVersionOutput(info2));
+      return 0;
+    }
+    const pluginInfo = findPluginEntry(directory);
+    if (pluginInfo?.isPinned) {
+      const info2 = {
+        currentVersion: pluginInfo.pinnedVersion,
+        latestVersion: null,
+        isUpToDate: false,
+        isLocalDev: false,
+        isPinned: true,
+        pinnedVersion: pluginInfo.pinnedVersion,
+        status: "pinned"
+      };
+      console.log(options.json ? formatJsonOutput(info2) : formatVersionOutput(info2));
+      return 0;
+    }
+    const currentVersion = getCachedVersion();
+    if (!currentVersion) {
+      const info2 = {
+        currentVersion: null,
+        latestVersion: null,
+        isUpToDate: false,
+        isLocalDev: false,
+        isPinned: false,
+        pinnedVersion: null,
+        status: "unknown"
+      };
+      console.log(options.json ? formatJsonOutput(info2) : formatVersionOutput(info2));
+      return 1;
+    }
+    const latestVersion = await getLatestVersion();
+    if (!latestVersion) {
+      const info2 = {
+        currentVersion,
+        latestVersion: null,
+        isUpToDate: false,
+        isLocalDev: false,
+        isPinned: false,
+        pinnedVersion: null,
+        status: "error"
+      };
+      console.log(options.json ? formatJsonOutput(info2) : formatVersionOutput(info2));
+      return 0;
+    }
+    const isUpToDate = currentVersion === latestVersion;
+    const info = {
+      currentVersion,
+      latestVersion,
+      isUpToDate,
+      isLocalDev: false,
+      isPinned: false,
+      pinnedVersion: null,
+      status: isUpToDate ? "up-to-date" : "outdated"
+    };
+    console.log(options.json ? formatJsonOutput(info) : formatVersionOutput(info));
+    return 0;
+  } catch (error) {
+    const info = {
+      currentVersion: null,
+      latestVersion: null,
+      isUpToDate: false,
+      isLocalDev: false,
+      isPinned: false,
+      pinnedVersion: null,
+      status: "error"
+    };
+    console.log(options.json ? formatJsonOutput(info) : formatVersionOutput(info));
+    return 1;
+  }
+}
+
 // src/cli/index.ts
 var packageJson = await Promise.resolve().then(() => __toESM(require_package(), 1));
 var VERSION = packageJson.version;
@@ -5560,6 +6674,25 @@ Unlike 'opencode run', this command waits until:
   const exitCode = await run(runOptions);
   process.exit(exitCode);
 });
+program2.command("get-local-version").description("Show current installed version and check for updates").option("-d, --directory <path>", "Working directory to check config from").option("--json", "Output in JSON format for scripting").addHelpText("after", `
+Examples:
+  $ bunx oh-my-opencode get-local-version
+  $ bunx oh-my-opencode get-local-version --json
+  $ bunx oh-my-opencode get-local-version --directory /path/to/project
+
+This command shows:
+  - Current installed version
+  - Latest available version on npm
+  - Whether you're up to date
+  - Special modes (local dev, pinned version)
+`).action(async (options) => {
+  const versionOptions = {
+    directory: options.directory,
+    json: options.json ?? false
+  };
+  const exitCode = await getLocalVersion(versionOptions);
+  process.exit(exitCode);
+});
 program2.command("version").description("Show version information").action(() => {
   console.log(`oh-my-opencode v${VERSION}`);
 });