opencode-supertask 0.1.37 → 0.1.39

package/dist/plugin/supertask.js

@@ -28368,6 +28368,26 @@ function getRunningVersion(env = process.env, cwd = process.cwd()) {
     return null;
   }
 }
+function packageVersionFromGatewayEntry(gatewayEntry) {
+  if (gatewayEntry === null) return null;
+  let directory = dirname4(gatewayEntry);
+  for (let depth = 0; depth < 6; depth += 1) {
+    const packagePath = join4(directory, "package.json");
+    if (existsSync4(packagePath)) {
+      try {
+        const pkg = JSON.parse(readFileSync3(packagePath, "utf8"));
+        if (pkg.name === "opencode-supertask" && typeof pkg.version === "string") {
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname4(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  return null;
+}
 function resolveRuntimeExecutable(command, env, cwd) {
   if (isAbsolute2(command) || command.includes("/")) return runtimePath(command, cwd);
   for (const entry of (env.PATH ?? "").split(delimiter)) {
@@ -28428,6 +28448,55 @@ function assertOpenCodeRuntime(runtime) {
     );
   }
 }
+function getGatewayDiagnostic(options = {}) {
+  const producerScope = currentScope();
+  if (!isPm2Installed()) {
+    return {
+      pm2Installed: false,
+      processFound: false,
+      status: null,
+      pid: null,
+      ready: false,
+      runningVersion: getRunningVersion(),
+      gatewayEntry: null,
+      gatewayPackageVersion: null,
+      logRotationInstalled: false,
+      startupConfigured: process.platform === "darwin" || process.platform === "linux" ? false : null,
+      currentScope: producerScope,
+      gatewayScope: null,
+      scopeMatches: false,
+      gatewayOpenCode: null
+    };
+  }
+  const processes = pm2JsonList();
+  const gateway = processes.find((item) => item.name === PROCESS_NAME);
+  const runtime = gatewayRuntimeFromProcess(gateway);
+  const gatewayEnv = runtime?.env ?? process.env;
+  const managedScope = runtime ? runtimeScope(runtime) : null;
+  const pid = typeof gateway?.pid === "number" ? gateway.pid : null;
+  const readyPath = managedScope?.databasePath ?? databasePath();
+  const lockedVersion = pid == null ? void 0 : gatewayVersionFromLock(pid, readyPath);
+  const gatewayEntry = runtime?.gatewayEntry ?? null;
+  return {
+    pm2Installed: true,
+    processFound: gateway != null,
+    status: gateway?.pm2_env?.status ?? null,
+    pid,
+    ready: pid != null && isGatewayReady(pid, readyPath),
+    runningVersion: lockedVersion === void 0 ? getRunningVersion(gatewayEnv, runtime?.cwd) : lockedVersion,
+    gatewayEntry,
+    gatewayPackageVersion: packageVersionFromGatewayEntry(gatewayEntry),
+    logRotationInstalled: processes.some((item) => item.name === "pm2-logrotate" && item.pm2_env?.status === "online"),
+    startupConfigured: process.platform === "darwin" ? isMacLaunchAgentConfigured(
+      gatewayEnv.PM2_HOME ?? join4(runtimeHome(gatewayEnv), ".pm2"),
+      runtime ?? void 0
+    ) : process.platform === "linux" ? isLinuxStartupConfigured(gatewayEnv, runtime?.cwd, runtime ?? void 0) : null,
+    currentScope: producerScope,
+    gatewayScope: managedScope,
+    scopeMatches: managedScope != null && scopesMatch(producerScope, managedScope),
+    gatewayOpenCode: runtime === null || !options.probeOpenCode ? null : diagnoseOpenCodeRuntime(runtime)
+  };
+}
 function writeRunningVersion(version3, env = process.env, cwd = process.cwd()) {
   const path = versionFile(env, cwd);
   mkdirSync3(dirname4(path), { recursive: true });
@@ -28451,6 +28520,9 @@ function resolvePm2Bin() {
 function launchAgentPath() {
   return process.env.SUPERTASK_LAUNCH_AGENT_PATH ?? join4(runtimeHome(process.env), "Library/LaunchAgents", `${MAC_LAUNCH_AGENT_LABEL}.plist`);
 }
+function launchctlBin() {
+  return process.env.SUPERTASK_LAUNCHCTL_BIN ?? "launchctl";
+}
 function xmlUnescape(value) {
   return value.replaceAll("&apos;", "'").replaceAll("&quot;", '"').replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
 }
@@ -28459,6 +28531,100 @@ function plistValue(contents, key) {
   const match = contents.match(new RegExp(`<key>\\s*${escapedKey}\\s*</key>\\s*<string>([^<]*)</string>`));
   return match?.[1] ? xmlUnescape(match[1]) : null;
 }
+function isMacLaunchAgentConfigured(expectedPm2Home, expectedRuntime) {
+  if (typeof process.getuid !== "function") return false;
+  const plistPath = launchAgentPath();
+  if (!existsSync4(plistPath)) return false;
+  try {
+    const contents = readFileSync3(plistPath, "utf8");
+    const argumentsBlock = contents.match(
+      /<key>\s*ProgramArguments\s*<\/key>\s*<array>([\s\S]*?)<\/array>/
+    )?.[1];
+    const programArguments = argumentsBlock ? [...argumentsBlock.matchAll(/<string>([^<]*)<\/string>/g)].map((match) => xmlUnescape(match[1])) : [];
+    const bunPath = programArguments[0];
+    const supervisorEntry = programArguments[1];
+    const pm2Path = programArguments[2];
+    const pm2Home = plistValue(contents, "PM2_HOME");
+    const managementLock = plistValue(contents, "SUPERTASK_PM2_MANAGEMENT_LOCK");
+    if (!bunPath || !supervisorEntry || !pm2Path || !pm2Home || !managementLock) return false;
+    if (expectedPm2Home && pm2Home !== expectedPm2Home) return false;
+    const expectedManagementLock = expectedRuntime ? managementLockPath(expectedRuntime.env, expectedRuntime.cwd) : process.env.SUPERTASK_PM2_MANAGEMENT_LOCK ? managementLockPath() : join4(expectedPm2Home ?? currentScope().pm2Home, "supertask-gateway.manage.sqlite");
+    if (managementLock !== expectedManagementLock) return false;
+    accessSync(bunPath, constants.X_OK);
+    accessSync(supervisorEntry, constants.R_OK);
+    accessSync(pm2Path, constants.X_OK);
+    if (spawnSync(bunPath, ["--version"], {
+      stdio: "ignore",
+      timeout: pm2CommandTimeoutMs(),
+      killSignal: "SIGKILL"
+    }).status !== 0) return false;
+    if (spawnSync(pm2Path, ["--version"], {
+      stdio: "ignore",
+      env: { ...process.env, PM2_HOME: pm2Home },
+      timeout: pm2CommandTimeoutMs(),
+      killSignal: "SIGKILL"
+    }).status !== 0) return false;
+    const loaded = spawnSync(
+      launchctlBin(),
+      ["print", `gui/${process.getuid()}/${MAC_LAUNCH_AGENT_LABEL}`],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: pm2CommandTimeoutMs(),
+        killSignal: "SIGKILL"
+      }
+    );
+    if (loaded.status !== 0) return false;
+    if (!loaded.stdout.includes("state = running")) return false;
+    if (!loaded.stdout.includes(`path = ${plistPath}`)) return false;
+    if (!loaded.stdout.includes(`program = ${bunPath}`)) return false;
+    const dumpPath = join4(pm2Home, "dump.pm2");
+    const dump = JSON.parse(readFileSync3(dumpPath, "utf8"));
+    if (!Array.isArray(dump)) return false;
+    const gateway = dump.find((item) => item.name === PROCESS_NAME);
+    const dumpRuntime = gatewayRuntimeFromProcess(gateway);
+    if (!dumpRuntime || !hasRestorableSavedGatewayRuntime(gateway)) return false;
+    return expectedRuntime === void 0 || dumpRuntime.gatewayEntry === expectedRuntime.gatewayEntry && dumpRuntime.bunPath === expectedRuntime.bunPath && dumpRuntime.cwd === expectedRuntime.cwd && scopesMatch(runtimeScope(dumpRuntime), runtimeScope(expectedRuntime));
+  } catch {
+    return false;
+  }
+}
+function systemctlBin(env = process.env) {
+  return env.SUPERTASK_SYSTEMCTL_BIN ?? "systemctl";
+}
+function isLinuxStartupConfigured(env = process.env, cwd = process.cwd(), expectedRuntime) {
+  const unit = env.SUPERTASK_PM2_SYSTEMD_UNIT ?? `pm2-${userInfo().username}.service`;
+  const enabled = spawnSync(systemctlBin(env), ["is-enabled", unit], {
+    encoding: "utf8",
+    env,
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: pm2CommandTimeoutMs(env),
+    killSignal: "SIGKILL"
+  });
+  if (enabled.status !== 0 || enabled.stdout.trim() !== "enabled") return false;
+  const contents = spawnSync(systemctlBin(env), ["cat", unit], {
+    encoding: "utf8",
+    env,
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: pm2CommandTimeoutMs(env),
+    killSignal: "SIGKILL"
+  });
+  if (contents.status !== 0) return false;
+  const expectedPm2Home = env.PM2_HOME ?? join4(runtimeHome(env), ".pm2");
+  if (!contents.stdout.includes("resurrect") || !contents.stdout.includes(expectedPm2Home)) {
+    return false;
+  }
+  try {
+    const dump = JSON.parse(readFileSync3(join4(expectedPm2Home, "dump.pm2"), "utf8"));
+    if (!Array.isArray(dump)) return false;
+    const gateway = dump.find((item) => item.name === PROCESS_NAME);
+    const runtime = gatewayRuntimeFromProcess(gateway);
+    if (!runtime || !hasRestorableSavedGatewayRuntime(gateway)) return false;
+    return runtime.cwd === resolve(cwd) && scopesMatch(runtimeScope(runtime), runtimeScope({ cwd, env })) && (expectedRuntime === void 0 || runtime.gatewayEntry === expectedRuntime.gatewayEntry && runtime.bunPath === expectedRuntime.bunPath);
+  } catch {
+    return false;
+  }
+}
 function isPm2Installed(env = process.env) {
   const result = spawnSync(pm2Bin(env), ["--version"], {
     stdio: "ignore",
@@ -28568,6 +28734,9 @@ function gatewayRuntimeFromProcess(processInfo) {
     killTimeoutMs: Number.isInteger(killTimeout) && killTimeout >= 5e3 ? killTimeout : void 0
   };
 }
+function hasRestorableSavedGatewayRuntime(processInfo) {
+  return gatewayRuntimeFromProcess(processInfo) !== null;
+}
 function currentGatewayRuntime(gatewayEntry = resolveGatewayEntry()) {
   return {
     gatewayEntry: resolve(gatewayEntry),
@@ -28764,6 +28933,11 @@ function assertRuntimeCanControlPm2(runtime, existing) {
 function savePm2State(env = process.env) {
   requirePm2(["save"], "pm2 save", { env });
 }
+function managementLockPath(env = process.env, cwd = process.cwd()) {
+  const override = env.SUPERTASK_PM2_MANAGEMENT_LOCK;
+  if (override) return runtimePath(override, cwd);
+  return join4(runtimeScope({ env, cwd }).pm2Home, "supertask-gateway.manage.sqlite");
+}
 function canonicalManagementLockPath(env = process.env, cwd = process.cwd()) {
   const home = runtimeHome(env);
   const pm2Home = env.PM2_HOME ? runtimePath(env.PM2_HOME, cwd) : join4(home, ".pm2");
@@ -28972,10 +29146,23 @@ function ensureGatewayUnlocked() {
 
 // src/daemon/update.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync, realpathSync } from "fs";
-import { homedir as homedir4 } from "os";
+import {
+  chmodSync as chmodSync2,
+  closeSync,
+  existsSync as existsSync5,
+  mkdtempSync,
+  openSync,
+  readFileSync as readFileSync4,
+  readdirSync,
+  realpathSync,
+  rmSync as rmSync2
+} from "fs";
+import { homedir as homedir4, tmpdir } from "os";
 import { dirname as dirname5, join as join5, resolve as resolve2 } from "path";
 var PACKAGE_NAME = "opencode-supertask";
+function isVersionConverged(version3, state) {
+  return state.packageVersion === version3 && state.plugin.ok && state.plugin.version === version3 && state.plugin.cachedVersion === version3 && (!state.cli.installed || state.cli.version === version3) && state.gateway.pm2Installed && state.gateway.processFound && state.gateway.status === "online" && state.gateway.ready && state.gateway.runningVersion === version3 && state.gateway.gatewayPackageVersion === version3 && state.gateway.scopeMatches;
+}
 function pluginAt(packageDir) {
   const packageJson = join5(packageDir, "package.json");
   const gatewayEntry = join5(packageDir, "dist/gateway/index.js");
@@ -29127,7 +29314,7 @@ function updateGlobalCli(version3) {
   }
   return { ...after, action: "updated" };
 }
-function latestVersion() {
+function getLatestVersion() {
   const result = spawnSync2(npmBin(), [
     "view",
     PACKAGE_NAME,
@@ -29167,6 +29354,116 @@ function resolveInstalledPluginVersion(expectedVersion) {
   const actual = installed.length > 0 ? installed.map((plugin) => plugin.version).join(", ") : "\u672A\u627E\u5230\u53EF\u8FD0\u884C\u7F13\u5B58";
   throw new Error(`[supertask] OpenCode \u63D2\u4EF6\u7F13\u5B58\u7248\u672C\u4E0D\u5339\u914D\uFF1A\u671F\u671B ${expectedVersion}\uFF0C\u5B9E\u9645 ${actual}`);
 }
+function resolveConfiguredPluginSpec(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("[supertask] OpenCode \u6700\u7EC8\u914D\u7F6E\u4E0D\u662F\u5BF9\u8C61");
+  }
+  const plugins = value.plugin;
+  if (!Array.isArray(plugins)) {
+    throw new Error(`[supertask] OpenCode \u6700\u7EC8\u914D\u7F6E\u672A\u542F\u7528 ${PACKAGE_NAME}`);
+  }
+  const matches = plugins.flatMap((entry) => {
+    if (typeof entry === "string") return [entry];
+    if (Array.isArray(entry) && typeof entry[0] === "string") return [entry[0]];
+    return [];
+  }).filter((spec2) => spec2 === PACKAGE_NAME || spec2.startsWith(`${PACKAGE_NAME}@`));
+  if (matches.length === 0) {
+    throw new Error(`[supertask] OpenCode \u6700\u7EC8\u914D\u7F6E\u672A\u542F\u7528 ${PACKAGE_NAME}`);
+  }
+  if (matches.length !== 1) {
+    throw new Error(`[supertask] OpenCode \u6700\u7EC8\u914D\u7F6E\u5305\u542B\u591A\u4E2A ${PACKAGE_NAME} \u58F0\u660E: ${matches.join(", ")}`);
+  }
+  const spec = matches[0];
+  const version3 = spec.startsWith(`${PACKAGE_NAME}@`) ? spec.slice(PACKAGE_NAME.length + 1) : null;
+  return {
+    spec,
+    version: version3 !== null && isSemanticVersion(version3) ? version3 : null,
+    exact: version3 !== null && isSemanticVersion(version3)
+  };
+}
+function getOpenCodePluginDiagnostic() {
+  const failed = (message) => ({
+    ok: false,
+    spec: "",
+    version: null,
+    exact: false,
+    cachedVersion: null,
+    packageDir: null,
+    error: message
+  });
+  let outputDirectory = null;
+  let outputFd = null;
+  try {
+    outputDirectory = mkdtempSync(join5(tmpdir(), "opencode-supertask-config-"));
+    chmodSync2(outputDirectory, 448);
+    const outputPath = join5(outputDirectory, "resolved-config.json");
+    outputFd = openSync(outputPath, "w", 384);
+    const result = spawnSync2(opencodeBin(), ["debug", "config", "--pure"], {
+      encoding: "utf8",
+      env: process.env,
+      timeout: 3e4,
+      stdio: ["ignore", outputFd, "pipe"]
+    });
+    closeSync(outputFd);
+    outputFd = null;
+    if (result.error) {
+      return failed(`[supertask] \u65E0\u6CD5\u8BFB\u53D6 OpenCode \u6700\u7EC8\u914D\u7F6E: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+      const detail = `${result.stderr ?? ""}`.trim();
+      return failed(`[supertask] \u65E0\u6CD5\u8BFB\u53D6 OpenCode \u6700\u7EC8\u914D\u7F6E: ${detail || `\u9000\u51FA\u7801 ${result.status}`}`);
+    }
+    let config2;
+    try {
+      config2 = JSON.parse(readFileSync4(outputPath, "utf8"));
+    } catch {
+      return failed("[supertask] OpenCode \u6700\u7EC8\u914D\u7F6E\u4E0D\u662F\u6709\u6548 JSON");
+    }
+    let configured;
+    try {
+      configured = resolveConfiguredPluginSpec(config2);
+    } catch (error45) {
+      return failed(error45 instanceof Error ? error45.message : String(error45));
+    }
+    if (!configured.exact || configured.version === null) {
+      return {
+        ok: false,
+        ...configured,
+        cachedVersion: null,
+        packageDir: null,
+        error: `[supertask] OpenCode \u63D2\u4EF6\u5FC5\u987B\u56FA\u5B9A\u7CBE\u786E\u7248\u672C\uFF0C\u4E0D\u80FD\u4F7F\u7528 ${configured.spec}`
+      };
+    }
+    try {
+      const installed = resolveInstalledPluginVersion(configured.version);
+      return {
+        ok: true,
+        ...configured,
+        cachedVersion: installed.version,
+        packageDir: installed.packageDir,
+        error: null
+      };
+    } catch (error45) {
+      return {
+        ok: false,
+        ...configured,
+        cachedVersion: null,
+        packageDir: null,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      };
+    }
+  } catch (error45) {
+    return failed(`[supertask] \u65E0\u6CD5\u8BFB\u53D6 OpenCode \u6700\u7EC8\u914D\u7F6E: ${error45 instanceof Error ? error45.message : String(error45)}`);
+  } finally {
+    if (outputFd !== null) {
+      try {
+        closeSync(outputFd);
+      } catch {
+      }
+    }
+    if (outputDirectory !== null) rmSync2(outputDirectory, { recursive: true, force: true });
+  }
+}
 function installPluginVersion(version3) {
   if (!isSemanticVersion(version3)) {
     throw new Error(`[supertask] OpenCode \u63D2\u4EF6\u7248\u672C\u65E0\u6548: ${version3}`);
@@ -29190,9 +29487,6 @@ function installPluginVersion(version3) {
   }
   return resolveInstalledPluginVersion(version3);
 }
-function installLatestPlugin() {
-  return installPluginVersion(latestVersion());
-}
 
 // plugin/supertask.ts
 var _initialized = false;
@@ -29590,11 +29884,31 @@ var SuperTaskPlugin = async () => {
             });
           }
           try {
-            console.log("[supertask] Updating OpenCode plugin cache...");
             const previousVersion = getPackageVersion();
+            const targetVersion = getLatestVersion();
+            const plugin = getOpenCodePluginDiagnostic();
+            const cli = getGlobalCliDiagnostic();
+            const gateway = getGatewayDiagnostic();
+            if (isVersionConverged(targetVersion, {
+              packageVersion: previousVersion,
+              plugin,
+              cli,
+              gateway
+            })) {
+              return JSON.stringify({
+                success: true,
+                upToDate: true,
+                before: targetVersion,
+                after: targetVersion,
+                restarted: false,
+                cli,
+                message: `SuperTask \u5DF2\u662F\u6700\u65B0\u7248\u672C ${targetVersion}\uFF0CGateway \u672A\u91CD\u542F\u3002`
+              });
+            }
+            console.log("[supertask] Updating OpenCode plugin cache...");
             let installed;
             try {
-              installed = installLatestPlugin();
+              installed = installPluginVersion(targetVersion);
             } catch (updateError) {
               let detail = updateError instanceof Error ? updateError.message : String(updateError);
               try {