opencode-orchestrator 1.2.38 → 1.2.46

package/dist/scripts/postinstall.js

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
+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');
+});
 
 // scripts/postinstall.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, copyFileSync, renameSync, unlinkSync } from "fs";
 import { homedir, tmpdir } from "os";
 import { join } from "path";
 var LOG_FILE = join(tmpdir(), "opencode-orchestrator.log");
@@ -57,74 +63,199 @@ function getConfigPaths() {
   }
   return paths;
 }
+function validateConfig(config) {
+  try {
+    if (typeof config !== "object" || config === null) {
+      return false;
+    }
+    if (config.plugin !== void 0 && !Array.isArray(config.plugin)) {
+      return false;
+    }
+    if (config.plugin) {
+      for (const p of config.plugin) {
+        if (typeof p !== "string") {
+          return false;
+        }
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createBackup(configFile) {
+  try {
+    if (!existsSync(configFile)) {
+      return null;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupFile = `${configFile}.backup.${timestamp}`;
+    copyFileSync(configFile, backupFile);
+    log("Backup created", { backupFile });
+    return backupFile;
+  } catch (error) {
+    log("Failed to create backup", { error: String(error) });
+    return null;
+  }
+}
+function atomicWriteJSON(filePath, data) {
+  const tempFile = `${filePath}.tmp.${Date.now()}`;
+  try {
+    writeFileSync(tempFile, JSON.stringify(data, null, 2) + "\n", { mode: 420 });
+    renameSync(tempFile, filePath);
+    log("Atomic write successful", { filePath });
+  } catch (error) {
+    try {
+      if (existsSync(tempFile)) {
+        unlinkSync(tempFile);
+      }
+    } catch {
+    }
+    throw error;
+  }
+}
 function registerInConfig(configDir) {
   const configFile = join(configDir, "opencode.json");
+  let backupFile = null;
   try {
     if (!existsSync(configDir)) {
-      mkdirSync(configDir, { recursive: true });
+      mkdirSync(configDir, { recursive: true, mode: 493 });
+      log("Created config directory", { configDir });
     }
+    backupFile = createBackup(configFile);
     let config = {};
     if (existsSync(configFile)) {
       try {
-        config = JSON.parse(readFileSync(configFile, "utf-8"));
-      } catch {
-        config = {};
+        const content = readFileSync(configFile, "utf-8").trim();
+        if (content) {
+          config = JSON.parse(content);
+          if (!validateConfig(config)) {
+            log("Invalid config structure detected, using safe defaults", { config });
+            config = { plugin: [] };
+          }
+        }
+      } catch (error) {
+        log("Failed to parse existing config, creating new one", { error: String(error) });
+        if (backupFile) {
+          console.log(`\u26A0\uFE0F  Corrupted config detected. Backup saved: ${backupFile}`);
+        }
+        config = { plugin: [] };
       }
     }
     if (!config.plugin) {
       config.plugin = [];
     }
-    const hasPlugin = config.plugin.some(
-      (p) => p.includes(PLUGIN_NAME)
-    );
-    if (!hasPlugin) {
-      config.plugin.push(PLUGIN_NAME);
-      writeFileSync(configFile, JSON.stringify(config, null, 2) + "\n");
-      return true;
+    const hasPlugin = config.plugin.some((p) => {
+      if (typeof p !== "string") return false;
+      return p === PLUGIN_NAME || p.includes(PLUGIN_NAME);
+    });
+    if (hasPlugin) {
+      log("Plugin already registered", { configFile });
+      return { success: false, backupFile };
+    }
+    config.plugin.push(PLUGIN_NAME);
+    log("Adding plugin to config", { plugin: PLUGIN_NAME, configFile });
+    atomicWriteJSON(configFile, config);
+    try {
+      const verifyContent = readFileSync(configFile, "utf-8");
+      const verifyConfig = JSON.parse(verifyContent);
+      if (!verifyConfig.plugin?.includes(PLUGIN_NAME)) {
+        throw new Error("Verification failed: plugin not found after write");
+      }
+    } catch (verifyError) {
+      log("Write verification failed, rolling back", { error: String(verifyError) });
+      if (backupFile && existsSync(backupFile)) {
+        copyFileSync(backupFile, configFile);
+        console.log(`\u26A0\uFE0F  Write verification failed. Restored from backup.`);
+      }
+      throw verifyError;
+    }
+    log("Plugin registered successfully", { configFile });
+    return { success: true, backupFile };
+  } catch (error) {
+    log("Registration failed", { error: String(error), configFile });
+    if (backupFile && existsSync(backupFile)) {
+      try {
+        copyFileSync(backupFile, configFile);
+        log("Rolled back to backup", { backupFile });
+        console.log(`\u26A0\uFE0F  Registration failed. Restored from backup: ${backupFile}`);
+      } catch (rollbackError) {
+        log("Rollback failed", { error: String(rollbackError) });
+      }
+    }
+    return { success: false, backupFile };
+  }
+}
+function cleanupOldBackups(configFile) {
+  try {
+    const configDir = join(configFile, "..");
+    const files = __require("fs").readdirSync(configDir);
+    const backupFiles = files.filter((f) => f.startsWith("opencode.json.backup.")).sort().reverse();
+    for (let i = 5; i < backupFiles.length; i++) {
+      const backupPath = join(configDir, backupFiles[i]);
+      try {
+        unlinkSync(backupPath);
+        log("Deleted old backup", { file: backupFiles[i] });
+      } catch {
+      }
     }
-    return false;
   } catch {
-    return false;
   }
 }
 try {
   console.log("\u{1F3AF} OpenCode Orchestrator - Installing...");
-  log("Installation started", { platform: process.platform });
+  log("Installation started", { platform: process.platform, node: process.version });
   const configPaths = getConfigPaths();
   log("Config paths to check", configPaths);
   let registered = false;
   let alreadyRegistered = false;
+  let backupCreated = null;
   for (const configDir of configPaths) {
     const configFile = join(configDir, "opencode.json");
     if (existsSync(configFile)) {
       try {
-        const config = JSON.parse(readFileSync(configFile, "utf-8"));
-        if (config.plugin?.some((p) => p.includes(PLUGIN_NAME))) {
-          alreadyRegistered = true;
-          continue;
+        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 {
+      } catch (error) {
+        log("Error checking existing config", { error: String(error), configFile });
       }
     }
-    if (registerInConfig(configDir)) {
+    const result = registerInConfig(configDir);
+    if (result.success) {
       console.log(`\u2705 Plugin registered: ${configFile}`);
-      log("Plugin registered successfully", { configFile });
+      if (result.backupFile) {
+        console.log(`   Backup created: ${result.backupFile}`);
+        backupCreated = result.backupFile;
+      }
       registered = true;
+      cleanupOldBackups(configFile);
+    } else if (result.backupFile) {
+      backupCreated = result.backupFile;
     }
   }
   if (!registered && alreadyRegistered) {
     console.log("\u2705 Plugin already registered.");
     log("Plugin was already registered");
   } else if (!registered) {
-    console.log("\u26A0\uFE0F Could not register plugin in any config location.");
+    console.log("\u26A0\uFE0F  Could not register plugin in any config location.");
+    console.log("   This may be due to permissions or file system issues.");
+    console.log(`   Check logs: ${LOG_FILE}`);
     log("Failed to register plugin in any location");
   }
   console.log("");
   console.log("\u{1F680} Ready! Restart OpenCode to use.");
   console.log("");
-  log("Installation completed", { registered, alreadyRegistered });
+  log("Installation completed", { registered, alreadyRegistered, backupCreated });
 } catch (error) {
   log("Installation error", { error: String(error) });
-  console.error(formatError(error, "register plugin"));
+  console.error("\u274C " + formatError(error, "register plugin"));
+  console.log(`   Check logs: ${LOG_FILE}`);
   process.exit(0);
 }

package/dist/scripts/preuninstall.js

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
+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');
+});
 
 // scripts/preuninstall.ts
-import { existsSync, readFileSync, writeFileSync, appendFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, appendFileSync, copyFileSync, renameSync, unlinkSync } from "fs";
 import { homedir, tmpdir } from "os";
 import { join } from "path";
 var LOG_FILE = join(tmpdir(), "opencode-orchestrator.log");
@@ -57,50 +63,186 @@ function getConfigPaths() {
   }
   return paths;
 }
+function validateConfig(config) {
+  try {
+    if (typeof config !== "object" || config === null) {
+      return false;
+    }
+    if (config.plugin !== void 0 && !Array.isArray(config.plugin)) {
+      return false;
+    }
+    if (config.plugin) {
+      for (const p of config.plugin) {
+        if (typeof p !== "string") {
+          return false;
+        }
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createBackup(configFile) {
+  try {
+    if (!existsSync(configFile)) {
+      return null;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupFile = `${configFile}.backup.${timestamp}`;
+    copyFileSync(configFile, backupFile);
+    log("Backup created", { backupFile });
+    return backupFile;
+  } catch (error) {
+    log("Failed to create backup", { error: String(error) });
+    return null;
+  }
+}
+function atomicWriteJSON(filePath, data) {
+  const tempFile = `${filePath}.tmp.${Date.now()}`;
+  try {
+    writeFileSync(tempFile, JSON.stringify(data, null, 2) + "\n", { mode: 420 });
+    renameSync(tempFile, filePath);
+    log("Atomic write successful", { filePath });
+  } catch (error) {
+    try {
+      if (existsSync(tempFile)) {
+        unlinkSync(tempFile);
+      }
+    } catch {
+    }
+    throw error;
+  }
+}
 function removeFromConfig(configDir) {
   const configFile = join(configDir, "opencode.json");
+  let backupFile = null;
   try {
     if (!existsSync(configFile)) {
-      return false;
+      log("Config file does not exist", { configFile });
+      return { success: false, backupFile: null };
+    }
+    backupFile = createBackup(configFile);
+    const content = readFileSync(configFile, "utf-8").trim();
+    if (!content) {
+      log("Empty config file", { configFile });
+      return { success: false, backupFile };
+    }
+    let config;
+    try {
+      config = JSON.parse(content);
+    } catch (error) {
+      log("Failed to parse config, skipping", { error: String(error), configFile });
+      console.log(`\u26A0\uFE0F  Corrupted config detected. Backup saved: ${backupFile}`);
+      return { success: false, backupFile };
+    }
+    if (!validateConfig(config)) {
+      log("Invalid config structure, skipping", { config, configFile });
+      return { success: false, backupFile };
     }
-    const config = JSON.parse(readFileSync(configFile, "utf-8"));
     if (!config.plugin || !Array.isArray(config.plugin)) {
-      return false;
+      log("No plugin array found", { configFile });
+      return { success: false, backupFile };
     }
     const originalLength = config.plugin.length;
-    config.plugin = config.plugin.filter(
-      (p) => !p.includes(PLUGIN_NAME)
-    );
-    if (config.plugin.length < originalLength) {
-      writeFileSync(configFile, JSON.stringify(config, null, 2) + "\n");
-      return true;
+    const originalPlugins = [...config.plugin];
+    config.plugin = config.plugin.filter((p) => {
+      if (typeof p !== "string") return true;
+      return p !== PLUGIN_NAME && !p.includes(PLUGIN_NAME);
+    });
+    if (config.plugin.length === originalLength) {
+      log("Plugin not found in config", { configFile });
+      return { success: false, backupFile };
+    }
+    const removedCount = originalLength - config.plugin.length;
+    log("Removing plugin from config", {
+      plugin: PLUGIN_NAME,
+      removedCount,
+      originalPlugins,
+      newPlugins: config.plugin,
+      configFile
+    });
+    atomicWriteJSON(configFile, config);
+    try {
+      const verifyContent = readFileSync(configFile, "utf-8");
+      const verifyConfig = JSON.parse(verifyContent);
+      const stillHasPlugin = verifyConfig.plugin?.some(
+        (p) => typeof p === "string" && (p === PLUGIN_NAME || p.includes(PLUGIN_NAME))
+      );
+      if (stillHasPlugin) {
+        throw new Error("Verification failed: plugin still present after removal");
+      }
+    } catch (verifyError) {
+      log("Write verification failed, rolling back", { error: String(verifyError) });
+      if (backupFile && existsSync(backupFile)) {
+        copyFileSync(backupFile, configFile);
+        console.log(`\u26A0\uFE0F  Write verification failed. Restored from backup.`);
+      }
+      throw verifyError;
+    }
+    log("Plugin removed successfully", { configFile, removedCount });
+    return { success: true, backupFile };
+  } catch (error) {
+    log("Removal failed", { error: String(error), configFile });
+    if (backupFile && existsSync(backupFile)) {
+      try {
+        copyFileSync(backupFile, configFile);
+        log("Rolled back to backup", { backupFile });
+        console.log(`\u26A0\uFE0F  Removal failed. Restored from backup: ${backupFile}`);
+      } catch (rollbackError) {
+        log("Rollback failed", { error: String(rollbackError) });
+      }
+    }
+    return { success: false, backupFile };
+  }
+}
+function cleanupOldBackups(configFile) {
+  try {
+    const configDir = join(configFile, "..");
+    const files = __require("fs").readdirSync(configDir);
+    const backupFiles = files.filter((f) => f.startsWith("opencode.json.backup.")).sort().reverse();
+    for (let i = 5; i < backupFiles.length; i++) {
+      const backupPath = join(configDir, backupFiles[i]);
+      try {
+        unlinkSync(backupPath);
+        log("Deleted old backup", { file: backupFiles[i] });
+      } catch {
+      }
     }
-    return false;
   } catch {
-    return false;
   }
 }
 try {
   console.log("\u{1F9F9} OpenCode Orchestrator - Uninstalling...");
-  log("Uninstallation started", { platform: process.platform });
+  log("Uninstallation started", { platform: process.platform, node: process.version });
   const configPaths = getConfigPaths();
   log("Config paths to check", configPaths);
   let removed = false;
+  let backupCreated = null;
   for (const configDir of configPaths) {
     const configFile = join(configDir, "opencode.json");
-    if (removeFromConfig(configDir)) {
+    const result = removeFromConfig(configDir);
+    if (result.success) {
       console.log(`\u2705 Plugin removed: ${configFile}`);
-      log("Plugin removed successfully", { configFile });
+      if (result.backupFile) {
+        console.log(`   Backup created: ${result.backupFile}`);
+        backupCreated = result.backupFile;
+      }
       removed = true;
+      cleanupOldBackups(configFile);
+    } else if (result.backupFile) {
+      backupCreated = result.backupFile;
     }
   }
   if (!removed) {
     console.log("\u2705 Plugin was not registered. Nothing to clean up.");
     log("Plugin was not registered");
   }
-  log("Uninstallation completed", { removed });
+  console.log("");
+  log("Uninstallation completed", { removed, backupCreated });
 } catch (error) {
   log("Uninstallation error", { error: String(error) });
-  console.error(formatError(error, "clean up config"));
+  console.error("\u274C " + formatError(error, "clean up config"));
+  console.log(`   Check logs: ${LOG_FILE}`);
   process.exit(0);
 }

package/dist/shared/task/interfaces/parallel-task.d.ts

@@ -1,9 +1,11 @@
 /**
  * Parallel task running in child session
+ * MERGED: Contains both core and shared fields
  */
 import type { ParallelTaskStatus } from "../types/index.js";
 import type { TaskProgress } from "./task-progress.js";
-export interface ParallelTask {
+import type { Poolable } from "../../../core/pool/object-pool.js";
+export interface ParallelTask extends Poolable {
     id: string;
     sessionID: string;
     parentSessionID: string;
@@ -16,11 +18,11 @@ export interface ParallelTask {
     error?: string;
     result?: string;
     concurrencyKey?: string;
-    /** Depth tracking - prevents infinite recursion */
     depth: number;
-    /** Stability detection */
+    mode?: "normal" | "race" | "fractal";
+    groupID?: string;
     lastMsgCount?: number;
     stablePolls?: number;
-    /** Progress tracking */
     progress?: TaskProgress;
+    hasStartedOutputting?: boolean;
 }

package/dist/tools/registry.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tool Registry - Centralized tool registration
+ *
+ * Consolidates all tool definitions for cleaner plugin initialization
+ */
+import type { ToolDefinition } from "@opencode-ai/plugin";
+/**
+ * Register all tools in one place
+ * @param directory - Working directory
+ * @param asyncAgentTools - Parallel agent tools from ParallelAgentManager
+ * @param dynamicTools - Dynamic tools from PluginManager
+ * @returns Complete tool registry
+ */
+export declare function registerAllTools(directory: string, asyncAgentTools: Record<string, ToolDefinition>, dynamicTools: Record<string, ToolDefinition>): Record<string, ToolDefinition>;

package/dist/tools/rust-pool.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Rust Tool Connection Pool
+ *
+ * Maintains persistent Rust processes for faster tool calls.
+ * First call: ~50-100ms (spawn overhead)
+ * Subsequent calls: ~5-10ms (10x faster!)
+ */
+export declare class RustToolPool {
+    private processes;
+    private maxSize;
+    private idleTimeout;
+    private cleanupInterval;
+    private shuttingDown;
+    constructor(maxSize?: number);
+    /**
+     * Call a Rust tool using pooled connection
+     */
+    call(name: string, args: Record<string, unknown>): Promise<string>;
+    /**
+     * Get an available process from pool
+     */
+    private getAvailable;
+    /**
+     * Wait for a process to become available
+     */
+    private waitForAvailable;
+    /**
+     * Create a new pooled process
+     */
+    private createProcess;
+    /**
+     * Send a request to a pooled process
+     */
+    private sendRequest;
+    /**
+     * Release a process back to the pool
+     */
+    private release;
+    /**
+     * Start cleanup timer for idle processes
+     */
+    private startCleanupTimer;
+    /**
+     * Shutdown the pool
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        total: number;
+        busy: number;
+        idle: number;
+    };
+}
+/**
+ * Get or create the global pool
+ */
+export declare function getRustToolPool(): RustToolPool;
+/**
+ * Shutdown the global pool
+ */
+export declare function shutdownRustToolPool(): Promise<void>;

package/dist/tools/rust.d.ts

@@ -1 +1,5 @@
+/**
+ * Call Rust tool with connection pooling
+ * Performance: ~5-10ms (10x faster than spawning each time)
+ */
 export declare function callRustTool(name: string, args: Record<string, unknown>): Promise<string>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "opencode-orchestrator",
   "displayName": "OpenCode Orchestrator",
   "description": "Distributed Cognitive Architecture for OpenCode. Turns simple prompts into specialized multi-agent workflows (Planner, Coder, Reviewer).",
-  "version": "1.2.38",
+  "version": "1.2.46",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {

package/dist/core/agents/interfaces/concurrency-config.interface.d.ts

@@ -1,9 +0,0 @@
-/**
- * ConcurrencyConfig Interface
- */
-export interface ConcurrencyConfig {
-    defaultConcurrency?: number;
-    agentConcurrency?: Record<string, number>;
-    providerConcurrency?: Record<string, number>;
-    modelConcurrency?: Record<string, number>;
-}

package/dist/core/agents/interfaces/parallel-task.interface.d.ts

@@ -1,26 +0,0 @@
-/**
- * ParallelTask Interface - Represents a task running in a parallel session
- */
-import type { ParallelTaskStatus } from "../types/parallel-task-status.type.js";
-import type { TaskProgress } from "./task-progress.interface.js";
-export interface ParallelTask {
-    id: string;
-    sessionID: string;
-    parentSessionID: string;
-    description: string;
-    prompt: string;
-    agent: string;
-    status: ParallelTaskStatus;
-    startedAt: Date;
-    completedAt?: Date;
-    error?: string;
-    result?: string;
-    concurrencyKey?: string;
-    depth: number;
-    mode?: "normal" | "race" | "fractal";
-    groupID?: string;
-    lastMsgCount?: number;
-    stablePolls?: number;
-    progress?: TaskProgress;
-    hasStartedOutputting?: boolean;
-}

package/dist/core/agents/interfaces/task-progress.interface.d.ts

@@ -1,9 +0,0 @@
-/**
- * TaskProgress Interface
- */
-export interface TaskProgress {
-    toolCalls: number;
-    lastTool?: string;
-    lastMessage?: string;
-    lastUpdate: Date;
-}