opencode-supertask 0.1.40 → 0.1.41

package/dist/daemon/gateway-diagnostic-runner.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/daemon/gateway-diagnostic-runner.js

@@ -0,0 +1,461 @@
+// src/daemon/pm2.ts
+import { execSync, spawnSync } from "child_process";
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { homedir as homedir2, userInfo } from "os";
+import { delimiter, dirname, isAbsolute, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+import { Database as Database2 } from "bun:sqlite";
+
+// src/gateway/config.ts
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_CONFIG_PATH = join(homedir(), ".config/opencode/supertask.json");
+
+// src/daemon/management-lock.ts
+import { Database } from "bun:sqlite";
+
+// src/daemon/pm2.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var PROCESS_NAME = "supertask-gateway";
+var MAC_LAUNCH_AGENT_LABEL = "com.supertask.pm2-resurrect";
+var GATEWAY_LOCK_STALE_MS = 3e4;
+function runtimeHome(env) {
+  return resolve(env.HOME || homedir2());
+}
+function runtimePath(value, cwd) {
+  return resolve(cwd, value);
+}
+function versionFile(env = process.env, cwd = process.cwd()) {
+  return env.SUPERTASK_VERSION_FILE ? runtimePath(env.SUPERTASK_VERSION_FILE, cwd) : join2(runtimeHome(env), ".local/share/opencode/supertask-gateway-version");
+}
+function getRunningVersion(env = process.env, cwd = process.cwd()) {
+  try {
+    const path = versionFile(env, cwd);
+    if (!existsSync(path)) return null;
+    return readFileSync(path, "utf-8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function packageVersionFromGatewayEntry(gatewayEntry) {
+  if (gatewayEntry === null) return null;
+  let directory = dirname(gatewayEntry);
+  for (let depth = 0; depth < 6; depth += 1) {
+    const packagePath = join2(directory, "package.json");
+    if (existsSync(packagePath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
+        if (pkg.name === "opencode-supertask" && typeof pkg.version === "string") {
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  return null;
+}
+function resolveRuntimeExecutable(command, env, cwd) {
+  if (isAbsolute(command) || command.includes("/")) return runtimePath(command, cwd);
+  for (const entry of (env.PATH ?? "").split(delimiter)) {
+    if (!entry) continue;
+    const candidate = resolve(cwd, entry, command);
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return command;
+}
+function runtimeScope(runtime) {
+  const { cwd, env } = runtime;
+  const home = runtimeHome(env);
+  return {
+    cwd: resolve(cwd),
+    databasePath: env.SUPERTASK_DB_PATH ? runtimePath(env.SUPERTASK_DB_PATH, cwd) : join2(home, ".local/share/opencode/tasks.db"),
+    configPath: env.SUPERTASK_CONFIG_PATH ? runtimePath(env.SUPERTASK_CONFIG_PATH, cwd) : join2(home, ".config/opencode/supertask.json"),
+    opencodePath: resolveRuntimeExecutable(env.SUPERTASK_OPENCODE_BIN ?? "opencode", env, cwd),
+    home,
+    pm2Home: env.PM2_HOME ? runtimePath(env.PM2_HOME, cwd) : join2(home, ".pm2"),
+    managementLockPath: canonicalManagementLockPath(env, cwd)
+  };
+}
+function scopesMatch(left, right) {
+  return left.databasePath === right.databasePath && left.configPath === right.configPath && left.opencodePath === right.opencodePath && left.home === right.home && left.pm2Home === right.pm2Home && left.managementLockPath === right.managementLockPath;
+}
+function currentScope() {
+  return runtimeScope({ cwd: process.cwd(), env: process.env });
+}
+function diagnoseOpenCodeRuntime(runtime = {
+  cwd: process.cwd(),
+  env: process.env
+}) {
+  const executable = runtimeScope(runtime).opencodePath;
+  const result = spawnSync(executable, ["--version"], {
+    cwd: runtime.cwd,
+    env: runtime.env,
+    encoding: "utf8",
+    timeout: 1e4,
+    killSignal: "SIGKILL"
+  });
+  const ok = result.status === 0 && result.error === void 0;
+  return {
+    ok,
+    executable,
+    version: ok ? result.stdout.trim() || result.stderr.trim() || null : null,
+    error: ok ? null : result.error?.message || result.stderr.trim() || result.stdout.trim() || `exit code ${result.status}`
+  };
+}
+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 ?? join2(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 pm2Bin(env = process.env) {
+  return env.SUPERTASK_PM2_BIN ?? (process.platform === "win32" ? "pm2.cmd" : "pm2");
+}
+function pm2CommandTimeoutMs(env = process.env) {
+  const configured = Number(env.SUPERTASK_PM2_COMMAND_TIMEOUT_MS ?? 15e3);
+  return Number.isFinite(configured) && configured > 0 ? configured : 15e3;
+}
+function resolvePm2Bin() {
+  const configured = pm2Bin();
+  if (isAbsolute(configured)) return configured;
+  const result = spawnSync("which", [configured], { encoding: "utf8" });
+  const resolved = result.status === 0 ? result.stdout.trim().split("\n")[0] : "";
+  if (!resolved) throw new Error(`[supertask] \u65E0\u6CD5\u89E3\u6790 pm2 \u53EF\u6267\u884C\u6587\u4EF6: ${configured}`);
+  return resolved;
+}
+function launchAgentPath() {
+  return process.env.SUPERTASK_LAUNCH_AGENT_PATH ?? join2(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;", "&");
+}
+function plistValue(contents, key) {
+  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  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 (!existsSync(plistPath)) return false;
+  try {
+    const contents = readFileSync(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() : join2(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 = join2(pm2Home, "dump.pm2");
+    const dump = JSON.parse(readFileSync(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 ?? join2(runtimeHome(env), ".pm2");
+  if (!contents.stdout.includes("resurrect") || !contents.stdout.includes(expectedPm2Home)) {
+    return false;
+  }
+  try {
+    const dump = JSON.parse(readFileSync(join2(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",
+    env,
+    shell: process.platform === "win32",
+    timeout: pm2CommandTimeoutMs(env),
+    killSignal: "SIGKILL"
+  });
+  return result.status === 0;
+}
+function resolveCommand(command) {
+  const lookup = process.platform === "win32" ? "where" : "which";
+  const result = spawnSync(lookup, [command], { encoding: "utf8" });
+  return result.status === 0 ? result.stdout.trim().split("\n")[0] || null : null;
+}
+function npmPreferredEnvironment() {
+  if (process.platform === "win32") return null;
+  const npm = resolveCommand("npm");
+  const node = resolveCommand("node");
+  if (!npm || !node) return null;
+  const command = resolvePm2Bin();
+  const path = [.../* @__PURE__ */ new Set([
+    dirname(command),
+    dirname(npm),
+    dirname(node),
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin"
+  ])].join(delimiter);
+  return { command, env: { ...process.env, PATH: path } };
+}
+function pm2Exec(args, options = {}) {
+  const npmEnvironment = options.preferNpm ? npmPreferredEnvironment() : null;
+  const effectiveEnv = options.env ?? npmEnvironment?.env ?? process.env;
+  const result = spawnSync(npmEnvironment?.command ?? pm2Bin(effectiveEnv), args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: effectiveEnv,
+    shell: process.platform === "win32",
+    timeout: options.timeoutMs ?? pm2CommandTimeoutMs(effectiveEnv),
+    killSignal: "SIGKILL"
+  });
+  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  if (result.error) return { ok: false, output: result.error.message };
+  return { ok: result.status === 0, output };
+}
+function requirePm2(args, action, options = {}) {
+  const result = pm2Exec(args, options);
+  if (!result.ok) throw new Error(`[supertask] ${action} failed: ${result.output || "unknown pm2 error"}`);
+  return result.output;
+}
+function pm2JsonList(env = process.env) {
+  const output = requirePm2(["jlist"], "pm2 jlist", { env });
+  try {
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed)) throw new Error("result is not an array");
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`[supertask] Invalid pm2 jlist output: ${message}`);
+  }
+}
+function gatewayEntryFromProcess(processInfo) {
+  const args = processInfo?.pm2_env?.args ?? processInfo?.args;
+  const candidates = Array.isArray(args) ? [...args].reverse() : typeof args === "string" ? [args] : [];
+  const savedCwd = processInfo?.pm2_env?.pm_cwd ?? processInfo?.pm_cwd;
+  for (const candidate of candidates) {
+    const path = typeof savedCwd === "string" ? runtimePath(candidate, savedCwd) : candidate;
+    if (existsSync(path)) return resolve(path);
+  }
+  return null;
+}
+function gatewayEnvironmentFromProcess(processInfo) {
+  const saved = processInfo?.pm2_env?.env ?? processInfo?.env;
+  if (!saved) return { ...process.env };
+  const env = {};
+  for (const [key, value] of Object.entries(saved)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  return env;
+}
+function gatewayRuntimeFromProcess(processInfo) {
+  const gatewayEntry = gatewayEntryFromProcess(processInfo);
+  if (!gatewayEntry) return null;
+  const savedBunPath = processInfo?.pm2_env?.pm_exec_path ?? processInfo?.pm_exec_path;
+  const savedCwd = processInfo?.pm2_env?.pm_cwd ?? processInfo?.pm_cwd;
+  const savedEnv = gatewayEnvironmentFromProcess(processInfo);
+  if (typeof savedBunPath !== "string" || typeof savedCwd !== "string") return null;
+  try {
+    accessSync(savedBunPath, constants.X_OK);
+    if (!statSync(savedCwd).isDirectory()) return null;
+    if (spawnSync(savedBunPath, ["--version"], {
+      stdio: "ignore",
+      env: savedEnv,
+      timeout: pm2CommandTimeoutMs(savedEnv),
+      killSignal: "SIGKILL"
+    }).status !== 0) return null;
+  } catch {
+    return null;
+  }
+  const killTimeout = processInfo?.pm2_env?.kill_timeout ?? processInfo?.kill_timeout;
+  return {
+    gatewayEntry,
+    bunPath: savedBunPath,
+    cwd: resolve(savedCwd),
+    env: savedEnv,
+    killTimeoutMs: Number.isInteger(killTimeout) && killTimeout >= 5e3 ? killTimeout : void 0
+  };
+}
+function hasRestorableSavedGatewayRuntime(processInfo) {
+  return gatewayRuntimeFromProcess(processInfo) !== null;
+}
+function databasePath(env = process.env, cwd = process.cwd()) {
+  return env.SUPERTASK_DB_PATH ? runtimePath(env.SUPERTASK_DB_PATH, cwd) : join2(runtimeHome(env), ".local/share/opencode/tasks.db");
+}
+function isGatewayReady(expectedPid, path = databasePath()) {
+  if (!existsSync(path)) return false;
+  let database = null;
+  try {
+    database = new Database2(path, { readonly: true });
+    const row = database.query(
+      "SELECT pid, heartbeat_at, ready_at FROM gateway_lock WHERE id = 1"
+    ).get();
+    if (!row || row.ready_at == null) return false;
+    if (expectedPid !== void 0 && row.pid !== expectedPid) return false;
+    const ageMs = Date.now() - row.heartbeat_at;
+    return ageMs >= -5e3 && ageMs < GATEWAY_LOCK_STALE_MS;
+  } catch {
+    return false;
+  } finally {
+    database?.close();
+  }
+}
+function gatewayVersionFromLock(expectedPid, path) {
+  if (!existsSync(path)) return void 0;
+  let database = null;
+  try {
+    database = new Database2(path, { readonly: true });
+    const row = database.query(
+      "SELECT pid, version FROM gateway_lock WHERE id = 1"
+    ).get();
+    if (!row || row.pid !== expectedPid) return void 0;
+    return row.version;
+  } catch {
+    return void 0;
+  } finally {
+    database?.close();
+  }
+}
+function managementLockPath(env = process.env, cwd = process.cwd()) {
+  const override = env.SUPERTASK_PM2_MANAGEMENT_LOCK;
+  if (override) return runtimePath(override, cwd);
+  return join2(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) : join2(home, ".pm2");
+  return join2(pm2Home, "supertask-gateway.manage.sqlite");
+}
+
+// src/daemon/gateway-diagnostic-runner.ts
+try {
+  console.log(JSON.stringify(getGatewayDiagnostic()));
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}
+//# sourceMappingURL=gateway-diagnostic-runner.js.map