opencode-orchestrator 1.2.62 → 1.2.66

package/dist/scripts/postinstall.js

@@ -1,9 +1,197 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/jsonc-parser/lib/umd/main.js
+var require_main = __commonJS({
+  "node_modules/jsonc-parser/lib/umd/main.js"(exports, module) {
+    (function(factory) {
+      if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(__require, exports);
+        if (v !== void 0) module.exports = v;
+      } else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./impl/format", "./impl/edit", "./impl/scanner", "./impl/parser"], factory);
+      }
+    })(function(require2, exports2) {
+      "use strict";
+      Object.defineProperty(exports2, "__esModule", { value: true });
+      exports2.applyEdits = exports2.modify = exports2.format = exports2.printParseErrorCode = exports2.ParseErrorCode = exports2.stripComments = exports2.visit = exports2.getNodeValue = exports2.getNodePath = exports2.findNodeAtOffset = exports2.findNodeAtLocation = exports2.parseTree = exports2.parse = exports2.getLocation = exports2.SyntaxKind = exports2.ScanError = exports2.createScanner = void 0;
+      const formatter = require2("./impl/format");
+      const edit = require2("./impl/edit");
+      const scanner = require2("./impl/scanner");
+      const parser = require2("./impl/parser");
+      exports2.createScanner = scanner.createScanner;
+      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 || (exports2.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 || (exports2.SyntaxKind = SyntaxKind = {}));
+      exports2.getLocation = parser.getLocation;
+      exports2.parse = parser.parse;
+      exports2.parseTree = parser.parseTree;
+      exports2.findNodeAtLocation = parser.findNodeAtLocation;
+      exports2.findNodeAtOffset = parser.findNodeAtOffset;
+      exports2.getNodePath = parser.getNodePath;
+      exports2.getNodeValue = parser.getNodeValue;
+      exports2.visit = parser.visit;
+      exports2.stripComments = parser.stripComments;
+      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 || (exports2.ParseErrorCode = ParseErrorCode = {}));
+      function printParseErrorCode2(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>";
+      }
+      exports2.printParseErrorCode = printParseErrorCode2;
+      function format(documentText, range, options) {
+        return formatter.format(documentText, range, options);
+      }
+      exports2.format = format;
+      function modify2(text, path, value, options) {
+        return edit.setProperty(text, path, value, options);
+      }
+      exports2.modify = modify2;
+      function applyEdits2(text, edits) {
+        let sortedEdits = edits.slice(0).sort((a, b) => {
+          const diff = a.offset - b.offset;
+          if (diff === 0) {
+            return a.length - b.length;
+          }
+          return diff;
+        });
+        let lastModifiedOffset = text.length;
+        for (let i = sortedEdits.length - 1; i >= 0; i--) {
+          let e = sortedEdits[i];
+          if (e.offset + e.length <= lastModifiedOffset) {
+            text = edit.applyEdit(text, e);
+          } else {
+            throw new Error("Overlapping edit");
+          }
+          lastModifiedOffset = e.offset;
+        }
+        return text;
+      }
+      exports2.applyEdits = applyEdits2;
+    });
+  }
+});
 
 // scripts/postinstall.ts
+var import_jsonc_parser = __toESM(require_main(), 1);
 import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, copyFileSync, renameSync, unlinkSync, readdirSync } from "fs";
 import { homedir, tmpdir } from "os";
-import { join } from "path";
+import { dirname, join, basename } from "path";
+var isCI = process.env.CI === "true" || process.env.CONTINUOUS_INTEGRATION === "true";
+var TIMEOUT_MS = 3e4;
+var timeoutId = setTimeout(() => {
+  console.log("\u26A0\uFE0F  postinstall timeout - exiting gracefully");
+  process.exit(0);
+}, TIMEOUT_MS);
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
 var LOG_FILE = join(tmpdir(), "opencode-orchestrator.log");
 function log(message, data) {
   try {
@@ -40,6 +228,41 @@ function formatError(err, context) {
   return `Failed to ${context}: ${String(err)}`;
 }
 var PLUGIN_NAME = "opencode-orchestrator";
+function isOurPluginEntry(p) {
+  return p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`);
+}
+function getConfigFileCandidates(configDir) {
+  return [join(configDir, "opencode.jsonc"), join(configDir, "opencode.json")];
+}
+function resolveConfigFile(configDir) {
+  for (const candidate of getConfigFileCandidates(configDir)) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return getConfigFileCandidates(configDir)[0];
+}
+function parseConfigContent(rawContent) {
+  const errors = [];
+  const config = (0, import_jsonc_parser.parse)(rawContent, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    const [firstError] = errors;
+    const line = rawContent.slice(0, firstError.offset).split("\n").length;
+    const column = firstError.offset - rawContent.lastIndexOf("\n", firstError.offset - 1);
+    return {
+      parseError: `${(0, import_jsonc_parser.printParseErrorCode)(firstError.error)} at line ${line}, column ${column}`
+    };
+  }
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    return {
+      parseError: "Root config must be a JSON object"
+    };
+  }
+  return { config };
+}
 function detectWSLWindowsConfigDir() {
   try {
     const isWSL = process.env.WSL_DISTRO_NAME || process.env.WSLENV;
@@ -99,7 +322,21 @@ function getConfigPaths() {
       paths.push(wslWindowsConfig);
     }
   }
-  return paths;
+  return [...new Set(paths)];
+}
+function readExistingConfig(configDir) {
+  for (const configFile of getConfigFileCandidates(configDir)) {
+    if (!existsSync(configFile)) continue;
+    const rawContent = readFileSync(configFile, "utf-8").trim();
+    if (!rawContent) {
+      return { file: configFile, config: {} };
+    }
+    const parsed = parseConfigContent(rawContent);
+    if (parsed.config) {
+      return { file: configFile, config: parsed.config };
+    }
+  }
+  return null;
 }
 function validateConfig(config) {
   try {
@@ -136,10 +373,19 @@ function createBackup(configFile) {
     return null;
   }
 }
-function atomicWriteJSON(filePath, data) {
+function atomicWriteJSON(filePath, data, originalContent) {
   const tempFile = `${filePath}.tmp.${Date.now()}`;
   try {
-    writeFileSync(tempFile, JSON.stringify(data, null, 2) + "\n", { mode: 420 });
+    let output = JSON.stringify(data, null, 2) + "\n";
+    if (filePath.endsWith(".jsonc") && originalContent !== void 0) {
+      const source = originalContent.trim() ? originalContent : "{}";
+      const edits = (0, import_jsonc_parser.modify)(source, ["plugin"], data.plugin, {
+        formattingOptions: { tabSize: 2, insertSpaces: true }
+      });
+      output = (0, import_jsonc_parser.applyEdits)(source, edits);
+      if (!output.endsWith("\n")) output += "\n";
+    }
+    writeFileSync(tempFile, output, { mode: 420 });
     renameSync(tempFile, filePath);
     log("Atomic write successful", { filePath });
   } catch (error) {
@@ -153,8 +399,9 @@ function atomicWriteJSON(filePath, data) {
   }
 }
 function registerInConfig(configDir) {
-  const configFile = join(configDir, "opencode.json");
+  const configFile = resolveConfigFile(configDir);
   let backupFile = null;
+  let originalContent;
   try {
     if (!existsSync(configDir)) {
       mkdirSync(configDir, { recursive: true, mode: 493 });
@@ -164,24 +411,22 @@ function registerInConfig(configDir) {
     let fileExisted = false;
     if (existsSync(configFile)) {
       fileExisted = true;
-      const rawContent = readFileSync(configFile, "utf-8").trim();
-      if (rawContent) {
-        let parseError;
-        try {
-          config = JSON.parse(rawContent);
-        } catch (err) {
-          parseError = err;
-        }
-        if (parseError) {
+      const rawContent = readFileSync(configFile, "utf-8");
+      originalContent = rawContent;
+      const trimmedContent = rawContent.trim();
+      if (trimmedContent) {
+        const parsed = parseConfigContent(trimmedContent);
+        if (parsed.parseError) {
           backupFile = createBackup(configFile);
-          log("Corrupted config JSON, skipping this path to avoid data loss", { configFile });
-          console.log(`\u26A0\uFE0F  opencode.json at ${configFile} has invalid JSON and was skipped.`);
+          log("Corrupted config JSON, skipping this path to avoid data loss", { configFile, parseError: parsed.parseError });
+          console.log(`\u26A0\uFE0F  opencode config at ${configFile} has invalid JSON/JSONC and was skipped.`);
           if (backupFile) {
             console.log(`   Backup saved: ${backupFile}`);
           }
           console.log(`   Please fix the file manually, then add "${PLUGIN_NAME}" to the "plugin" array.`);
           return { success: false, backupFile, skipped: true };
         }
+        config = parsed.config ?? {};
         if (!validateConfig(config)) {
           log("Unexpected config structure, skipping to avoid corruption", { config, configFile });
           console.log(`\u26A0\uFE0F  Unexpected config structure in ${configFile}. Skipping to avoid corruption.`);
@@ -198,7 +443,7 @@ function registerInConfig(configDir) {
     }
     const hasPlugin = config.plugin.some((p) => {
       if (typeof p !== "string") return false;
-      return p === PLUGIN_NAME || p.includes(PLUGIN_NAME);
+      return isOurPluginEntry(p);
     });
     if (hasPlugin) {
       log("Plugin already registered", { configFile });
@@ -209,11 +454,15 @@ function registerInConfig(configDir) {
     }
     config.plugin.push(PLUGIN_NAME);
     log("Adding plugin to config", { plugin: PLUGIN_NAME, configFile });
-    atomicWriteJSON(configFile, config);
+    atomicWriteJSON(configFile, config, originalContent);
     try {
       const verifyContent = readFileSync(configFile, "utf-8");
-      const verifyConfig = JSON.parse(verifyContent);
-      if (!verifyConfig.plugin?.includes(PLUGIN_NAME)) {
+      const verifyParsed = parseConfigContent(verifyContent);
+      if (verifyParsed.parseError || !verifyParsed.config) {
+        throw new Error(`Verification parse failed: ${verifyParsed.parseError ?? "unknown parse error"}`);
+      }
+      const verifyConfig = verifyParsed.config;
+      if (!verifyConfig.plugin?.some((p) => isOurPluginEntry(p))) {
         throw new Error("Verification failed: plugin not found after write");
       }
     } catch (verifyError) {
@@ -242,9 +491,10 @@ function registerInConfig(configDir) {
 }
 function cleanupOldBackups(configFile) {
   try {
-    const configDir = join(configFile, "..");
+    const configDir = dirname(configFile);
+    const configBase = basename(configFile);
     const files = readdirSync(configDir);
-    const backupFiles = files.filter((f) => f.startsWith("opencode.json.backup.")).sort().reverse();
+    const backupFiles = files.filter((f) => f.startsWith(`${configBase}.backup.`)).sort().reverse();
     for (let i = 5; i < backupFiles.length; i++) {
       const backupPath = join(configDir, backupFiles[i]);
       try {
@@ -257,32 +507,37 @@ function cleanupOldBackups(configFile) {
   }
 }
 try {
+  if (isCI) log("Running in CI mode");
   console.log("\u{1F3AF} OpenCode Orchestrator - Installing...");
   log("Installation started", { platform: process.platform, node: process.version });
+  if (isCI) {
+    console.log("\u2139\uFE0F  CI environment detected. Skipping automatic plugin registration.");
+    log("Skipping automatic plugin registration in CI");
+    clearTimeout(timeoutId);
+    process.exit(0);
+  }
   const configPaths = getConfigPaths();
   log("Config paths to check", configPaths);
   let registered = false;
   let alreadyRegistered = false;
   let skippedCorrupt = false;
   let backupCreated = null;
+  let targetConfigDir = configPaths[0];
   for (const configDir of configPaths) {
-    const configFile = join(configDir, "opencode.json");
-    if (existsSync(configFile)) {
-      try {
-        const content = readFileSync(configFile, "utf-8").trim();
-        if (content) {
-          const config = JSON.parse(content);
-          if (config.plugin?.some((p) => typeof p === "string" && (p === PLUGIN_NAME || p.includes(PLUGIN_NAME)))) {
-            alreadyRegistered = true;
-            log("Plugin already registered in this location", { configFile });
-            continue;
-          }
-        }
-      } catch (error) {
-        log("Error checking existing config", { error: String(error), configFile });
-      }
+    const existing = readExistingConfig(configDir);
+    if (!existing) {
+      continue;
     }
-    const result = registerInConfig(configDir);
+    targetConfigDir = configDir;
+    if (existing.config.plugin?.some((p) => typeof p === "string" && isOurPluginEntry(p))) {
+      alreadyRegistered = true;
+      log("Plugin already registered in this location", { configFile: existing.file });
+      break;
+    }
+  }
+  if (!alreadyRegistered && targetConfigDir) {
+    const configFile = resolveConfigFile(targetConfigDir);
+    const result = registerInConfig(targetConfigDir);
     if (result.skipped) {
       skippedCorrupt = true;
       if (result.backupFile) backupCreated = result.backupFile;
@@ -310,6 +565,7 @@ try {
     console.log(`   Check logs: ${LOG_FILE}`);
     log("Failed to register plugin in any location");
   }
+  clearTimeout(timeoutId);
   console.log("");
   console.log("\u{1F680} Ready! Restart OpenCode to use.");
   console.log("");
@@ -319,4 +575,6 @@ try {
   console.error("\u274C " + formatError(error, "register plugin"));
   console.log(`   Check logs: ${LOG_FILE}`);
   process.exit(0);
+} finally {
+  clearTimeout(timeoutId);
 }