@openacp/cli 0.4.10 → 0.4.11

package/dist/chunk-3DIPXFZJ.js

@@ -0,0 +1,650 @@
+import {
+  ConfigManager,
+  ConfigSchema,
+  applyMigrations,
+  expandHome
+} from "./chunk-WYZFGHHI.js";
+
+// src/core/doctor/index.ts
+import * as fs8 from "fs";
+import * as path4 from "path";
+import * as os2 from "os";
+
+// src/core/doctor/checks/config.ts
+import * as fs from "fs";
+var configCheck = {
+  name: "Config",
+  order: 1,
+  async run(ctx) {
+    const results = [];
+    if (!fs.existsSync(ctx.configPath)) {
+      results.push({ status: "fail", message: "Config file not found" });
+      return results;
+    }
+    results.push({ status: "pass", message: "Config file exists" });
+    let raw;
+    try {
+      raw = JSON.parse(fs.readFileSync(ctx.configPath, "utf-8"));
+    } catch (err) {
+      results.push({
+        status: "fail",
+        message: `Config JSON invalid: ${err instanceof Error ? err.message : String(err)}`
+      });
+      return results;
+    }
+    results.push({ status: "pass", message: "JSON valid" });
+    const testRaw = structuredClone(raw);
+    const { changed } = applyMigrations(testRaw);
+    if (changed) {
+      results.push({
+        status: "warn",
+        message: "Pending config migrations",
+        fixable: true,
+        fixRisk: "safe",
+        fix: async () => {
+          applyMigrations(raw);
+          fs.writeFileSync(ctx.configPath, JSON.stringify(raw, null, 2));
+          return { success: true, message: "applied migrations" };
+        }
+      });
+    }
+    const result = ConfigSchema.safeParse(raw);
+    if (!result.success) {
+      for (const issue of result.error.issues) {
+        results.push({
+          status: "fail",
+          message: `Validation: ${issue.path.join(".")} \u2014 ${issue.message}`
+        });
+      }
+    } else {
+      results.push({ status: "pass", message: "Schema valid" });
+    }
+    return results;
+  }
+};
+
+// src/core/doctor/checks/agents.ts
+import { execFileSync } from "child_process";
+import * as fs2 from "fs";
+import * as path from "path";
+function commandExists(cmd) {
+  try {
+    execFileSync("which", [cmd], { stdio: "pipe" });
+    return true;
+  } catch {
+  }
+  let dir = process.cwd();
+  while (true) {
+    const binPath = path.join(dir, "node_modules", ".bin", cmd);
+    if (fs2.existsSync(binPath)) return true;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+var agentsCheck = {
+  name: "Agents",
+  order: 2,
+  async run(ctx) {
+    const results = [];
+    if (!ctx.config) {
+      results.push({ status: "fail", message: "Cannot check agents \u2014 config not loaded" });
+      return results;
+    }
+    const agents = ctx.config.agents;
+    const defaultAgent = ctx.config.defaultAgent;
+    if (!agents[defaultAgent]) {
+      results.push({
+        status: "fail",
+        message: `Default agent "${defaultAgent}" not found in agents config`
+      });
+    }
+    for (const [name, agent] of Object.entries(agents)) {
+      const isDefault = name === defaultAgent;
+      if (commandExists(agent.command)) {
+        results.push({
+          status: "pass",
+          message: `${agent.command} found${isDefault ? " (default)" : ""}`
+        });
+      } else {
+        results.push({
+          status: isDefault ? "fail" : "warn",
+          message: `${agent.command} not found in PATH${isDefault ? " (default agent!)" : ""}`
+        });
+      }
+    }
+    return results;
+  }
+};
+
+// src/core/doctor/checks/telegram.ts
+var BOT_TOKEN_REGEX = /^\d+:[A-Za-z0-9_-]{35,}$/;
+var telegramCheck = {
+  name: "Telegram",
+  order: 3,
+  async run(ctx) {
+    const results = [];
+    if (!ctx.config) {
+      results.push({ status: "fail", message: "Cannot check Telegram \u2014 config not loaded" });
+      return results;
+    }
+    const tgConfig = ctx.config.channels.telegram;
+    if (!tgConfig || !tgConfig.enabled) {
+      results.push({ status: "pass", message: "Telegram not enabled (skipped)" });
+      return results;
+    }
+    const botToken = tgConfig.botToken;
+    const chatId = tgConfig.chatId;
+    if (!botToken || !BOT_TOKEN_REGEX.test(botToken)) {
+      results.push({ status: "fail", message: "Bot token format invalid" });
+      return results;
+    }
+    results.push({ status: "pass", message: "Bot token format valid" });
+    let botId;
+    try {
+      const res = await fetch(`https://api.telegram.org/bot${botToken}/getMe`);
+      const data = await res.json();
+      if (data.ok && data.result) {
+        botId = data.result.id;
+        results.push({ status: "pass", message: `Bot token valid (@${data.result.username})` });
+      } else {
+        results.push({ status: "fail", message: `Bot token rejected: ${data.description || "unknown error"}` });
+        return results;
+      }
+    } catch (err) {
+      results.push({ status: "fail", message: `Cannot reach Telegram API: ${err instanceof Error ? err.message : String(err)}` });
+      return results;
+    }
+    if (!chatId || chatId === 0) {
+      results.push({ status: "fail", message: "Chat ID not configured" });
+      return results;
+    }
+    try {
+      const res = await fetch(`https://api.telegram.org/bot${botToken}/getChat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ chat_id: chatId })
+      });
+      const data = await res.json();
+      if (!data.ok || !data.result) {
+        results.push({ status: "fail", message: `Chat ID invalid: ${data.description || "unknown error"}` });
+        return results;
+      }
+      if (data.result.type !== "supergroup") {
+        results.push({ status: "fail", message: `Chat is "${data.result.type}", must be a supergroup` });
+        return results;
+      }
+      if (!data.result.is_forum) {
+        results.push({ status: "warn", message: "Chat does not have topics enabled" });
+      } else {
+        results.push({ status: "pass", message: `Chat is supergroup with topics ("${data.result.title}")` });
+      }
+    } catch (err) {
+      results.push({ status: "fail", message: `Cannot validate chat: ${err instanceof Error ? err.message : String(err)}` });
+      return results;
+    }
+    try {
+      const res = await fetch(`https://api.telegram.org/bot${botToken}/getChatMember`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ chat_id: chatId, user_id: botId })
+      });
+      const data = await res.json();
+      if (!data.ok || !data.result) {
+        results.push({ status: "fail", message: `Cannot check bot membership: ${data.description || "unknown"}` });
+      } else if (data.result.status === "administrator" || data.result.status === "creator") {
+        results.push({ status: "pass", message: "Bot is admin in group" });
+      } else {
+        results.push({
+          status: "fail",
+          message: `Bot is "${data.result.status}" \u2014 must be admin. Promote bot in group settings.`
+        });
+      }
+    } catch (err) {
+      results.push({ status: "fail", message: `Admin check failed: ${err instanceof Error ? err.message : String(err)}` });
+    }
+    return results;
+  }
+};
+
+// src/core/doctor/checks/storage.ts
+import * as fs3 from "fs";
+var storageCheck = {
+  name: "Storage",
+  order: 4,
+  async run(ctx) {
+    const results = [];
+    if (!fs3.existsSync(ctx.dataDir)) {
+      results.push({
+        status: "fail",
+        message: "Data directory ~/.openacp does not exist",
+        fixable: true,
+        fixRisk: "safe",
+        fix: async () => {
+          fs3.mkdirSync(ctx.dataDir, { recursive: true });
+          return { success: true, message: "created directory" };
+        }
+      });
+    } else {
+      try {
+        fs3.accessSync(ctx.dataDir, fs3.constants.W_OK);
+        results.push({ status: "pass", message: "Data directory exists and writable" });
+      } catch {
+        results.push({ status: "fail", message: "Data directory not writable" });
+      }
+    }
+    if (fs3.existsSync(ctx.sessionsPath)) {
+      try {
+        const content = fs3.readFileSync(ctx.sessionsPath, "utf-8");
+        const data = JSON.parse(content);
+        if (typeof data === "object" && data !== null && "sessions" in data) {
+          results.push({ status: "pass", message: "Sessions file valid" });
+        } else {
+          results.push({
+            status: "fail",
+            message: "Sessions file has invalid structure",
+            fixable: true,
+            fixRisk: "risky",
+            fix: async () => {
+              fs3.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
+              return { success: true, message: "reset sessions file" };
+            }
+          });
+        }
+      } catch {
+        results.push({
+          status: "fail",
+          message: "Sessions file corrupt (invalid JSON)",
+          fixable: true,
+          fixRisk: "risky",
+          fix: async () => {
+            fs3.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
+            return { success: true, message: "reset sessions file" };
+          }
+        });
+      }
+    } else {
+      results.push({ status: "pass", message: "Sessions file not present yet (created on first session)" });
+    }
+    if (!fs3.existsSync(ctx.logsDir)) {
+      results.push({
+        status: "warn",
+        message: "Log directory does not exist",
+        fixable: true,
+        fixRisk: "safe",
+        fix: async () => {
+          fs3.mkdirSync(ctx.logsDir, { recursive: true });
+          return { success: true, message: "created log directory" };
+        }
+      });
+    } else {
+      try {
+        fs3.accessSync(ctx.logsDir, fs3.constants.W_OK);
+        results.push({ status: "pass", message: "Log directory exists and writable" });
+      } catch {
+        results.push({ status: "fail", message: "Log directory not writable" });
+      }
+    }
+    return results;
+  }
+};
+
+// src/core/doctor/checks/workspace.ts
+import * as fs4 from "fs";
+var workspaceCheck = {
+  name: "Workspace",
+  order: 5,
+  async run(ctx) {
+    const results = [];
+    if (!ctx.config) {
+      results.push({ status: "fail", message: "Cannot check workspace \u2014 config not loaded" });
+      return results;
+    }
+    const baseDir = expandHome(ctx.config.workspace.baseDir);
+    if (!fs4.existsSync(baseDir)) {
+      results.push({
+        status: "warn",
+        message: `Workspace directory does not exist: ${baseDir}`,
+        fixable: true,
+        fixRisk: "safe",
+        fix: async () => {
+          fs4.mkdirSync(baseDir, { recursive: true });
+          return { success: true, message: "created directory" };
+        }
+      });
+    } else {
+      try {
+        fs4.accessSync(baseDir, fs4.constants.W_OK);
+        results.push({ status: "pass", message: `Workspace directory exists: ${baseDir}` });
+      } catch {
+        results.push({ status: "fail", message: `Workspace directory not writable: ${baseDir}` });
+      }
+    }
+    return results;
+  }
+};
+
+// src/core/doctor/checks/plugins.ts
+import * as fs5 from "fs";
+import * as path2 from "path";
+var pluginsCheck = {
+  name: "Plugins",
+  order: 6,
+  async run(ctx) {
+    const results = [];
+    if (!fs5.existsSync(ctx.pluginsDir)) {
+      results.push({
+        status: "warn",
+        message: "Plugins directory does not exist",
+        fixable: true,
+        fixRisk: "safe",
+        fix: async () => {
+          fs5.mkdirSync(ctx.pluginsDir, { recursive: true });
+          fs5.writeFileSync(
+            path2.join(ctx.pluginsDir, "package.json"),
+            JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
+          );
+          return { success: true, message: "initialized plugins directory" };
+        }
+      });
+      return results;
+    }
+    results.push({ status: "pass", message: "Plugins directory exists" });
+    const pkgPath = path2.join(ctx.pluginsDir, "package.json");
+    if (!fs5.existsSync(pkgPath)) {
+      results.push({
+        status: "warn",
+        message: "Plugins package.json missing",
+        fixable: true,
+        fixRisk: "safe",
+        fix: async () => {
+          fs5.writeFileSync(
+            pkgPath,
+            JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
+          );
+          return { success: true, message: "created package.json" };
+        }
+      });
+      return results;
+    }
+    try {
+      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+      const deps = pkg.dependencies || {};
+      const count = Object.keys(deps).length;
+      results.push({ status: "pass", message: `Plugins package.json valid (${count} plugins)` });
+    } catch {
+      results.push({
+        status: "fail",
+        message: "Plugins package.json is invalid JSON",
+        fixable: true,
+        fixRisk: "risky",
+        fix: async () => {
+          fs5.writeFileSync(
+            pkgPath,
+            JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
+          );
+          return { success: true, message: "reset package.json" };
+        }
+      });
+    }
+    return results;
+  }
+};
+
+// src/core/doctor/checks/daemon.ts
+import * as fs6 from "fs";
+import * as net from "net";
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkPortInUse(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(true));
+    server.once("listening", () => {
+      server.close();
+      resolve(false);
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+var daemonCheck = {
+  name: "Daemon",
+  order: 7,
+  async run(ctx) {
+    const results = [];
+    if (fs6.existsSync(ctx.pidPath)) {
+      const content = fs6.readFileSync(ctx.pidPath, "utf-8").trim();
+      const pid = parseInt(content, 10);
+      if (isNaN(pid)) {
+        results.push({
+          status: "warn",
+          message: "PID file contains invalid data",
+          fixable: true,
+          fixRisk: "safe",
+          fix: async () => {
+            fs6.unlinkSync(ctx.pidPath);
+            return { success: true, message: "removed invalid PID file" };
+          }
+        });
+      } else if (!isProcessAlive(pid)) {
+        results.push({
+          status: "warn",
+          message: `Stale PID file (PID ${pid} not running)`,
+          fixable: true,
+          fixRisk: "safe",
+          fix: async () => {
+            fs6.unlinkSync(ctx.pidPath);
+            return { success: true, message: "removed stale PID file" };
+          }
+        });
+      } else {
+        results.push({ status: "pass", message: `Daemon running (PID ${pid})` });
+      }
+    }
+    if (fs6.existsSync(ctx.portFilePath)) {
+      const content = fs6.readFileSync(ctx.portFilePath, "utf-8").trim();
+      const port = parseInt(content, 10);
+      if (isNaN(port)) {
+        results.push({
+          status: "warn",
+          message: "Port file contains invalid data",
+          fixable: true,
+          fixRisk: "safe",
+          fix: async () => {
+            fs6.unlinkSync(ctx.portFilePath);
+            return { success: true, message: "removed invalid port file" };
+          }
+        });
+      } else {
+        results.push({ status: "pass", message: `Port file valid (port ${port})` });
+      }
+    }
+    if (ctx.config) {
+      const apiPort = ctx.config.api.port;
+      const inUse = await checkPortInUse(apiPort);
+      if (inUse) {
+        if (fs6.existsSync(ctx.pidPath)) {
+          const pid = parseInt(fs6.readFileSync(ctx.pidPath, "utf-8").trim(), 10);
+          if (!isNaN(pid) && isProcessAlive(pid)) {
+            results.push({ status: "pass", message: `API port ${apiPort} in use by OpenACP daemon` });
+          } else {
+            results.push({ status: "warn", message: `API port ${apiPort} in use by another process` });
+          }
+        } else {
+          results.push({ status: "warn", message: `API port ${apiPort} in use by another process` });
+        }
+      } else {
+        results.push({ status: "pass", message: `API port ${apiPort} available` });
+      }
+    }
+    return results;
+  }
+};
+
+// src/core/doctor/checks/tunnel.ts
+import * as fs7 from "fs";
+import * as path3 from "path";
+import * as os from "os";
+import { execFileSync as execFileSync2 } from "child_process";
+var BIN_DIR = path3.join(os.homedir(), ".openacp", "bin");
+var BIN_NAME = os.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
+var BIN_PATH = path3.join(BIN_DIR, BIN_NAME);
+var tunnelCheck = {
+  name: "Tunnel",
+  order: 8,
+  async run(ctx) {
+    const results = [];
+    if (!ctx.config) {
+      results.push({ status: "fail", message: "Cannot check tunnel \u2014 config not loaded" });
+      return results;
+    }
+    if (!ctx.config.tunnel.enabled) {
+      results.push({ status: "pass", message: "Tunnel not enabled (skipped)" });
+      return results;
+    }
+    const provider = ctx.config.tunnel.provider;
+    results.push({ status: "pass", message: `Tunnel provider: ${provider}` });
+    if (provider === "cloudflare") {
+      let found = false;
+      if (fs7.existsSync(BIN_PATH)) {
+        found = true;
+      } else {
+        try {
+          execFileSync2("which", ["cloudflared"], { stdio: "pipe" });
+          found = true;
+        } catch {
+        }
+      }
+      if (found) {
+        results.push({ status: "pass", message: "cloudflared binary found" });
+      } else {
+        results.push({
+          status: "warn",
+          message: "cloudflared binary not found",
+          fixable: true,
+          fixRisk: "safe",
+          fix: async () => {
+            try {
+              const { ensureCloudflared } = await import("./install-cloudflared-BTGUD7SW.js");
+              await ensureCloudflared();
+              return { success: true, message: "installed cloudflared" };
+            } catch (err) {
+              return { success: false, message: err instanceof Error ? err.message : String(err) };
+            }
+          }
+        });
+      }
+    }
+    const tunnelPort = ctx.config.tunnel.port;
+    if (tunnelPort < 1 || tunnelPort > 65535) {
+      results.push({ status: "fail", message: `Invalid tunnel port: ${tunnelPort}` });
+    } else {
+      results.push({ status: "pass", message: `Tunnel port: ${tunnelPort}` });
+    }
+    return results;
+  }
+};
+
+// src/core/doctor/index.ts
+var ALL_CHECKS = [
+  configCheck,
+  agentsCheck,
+  telegramCheck,
+  storageCheck,
+  workspaceCheck,
+  pluginsCheck,
+  daemonCheck,
+  tunnelCheck
+];
+var CHECK_TIMEOUT_MS = 1e4;
+var DoctorEngine = class {
+  dryRun;
+  constructor(options) {
+    this.dryRun = options?.dryRun ?? false;
+  }
+  async runAll() {
+    const ctx = await this.buildContext();
+    const checks = [...ALL_CHECKS].sort((a, b) => a.order - b.order);
+    const categories = [];
+    const pendingFixes = [];
+    const summary = { passed: 0, warnings: 0, failed: 0, fixed: 0 };
+    for (const check of checks) {
+      let results;
+      try {
+        results = await Promise.race([
+          check.run(ctx),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("timeout")), CHECK_TIMEOUT_MS)
+          )
+        ]);
+      } catch {
+        results = [{ status: "fail", message: `${check.name} check timed out` }];
+      }
+      for (const result of results) {
+        if (result.fixable && result.fix) {
+          if (result.fixRisk === "safe" && !this.dryRun) {
+            try {
+              const fixResult = await result.fix();
+              if (fixResult.success) {
+                result.message += ` \u2192 Fixed (${fixResult.message})`;
+                result.status = "warn";
+                delete result.fix;
+                summary.fixed++;
+              }
+            } catch {
+            }
+          } else if (result.fixRisk === "risky") {
+            pendingFixes.push({
+              category: check.name,
+              message: result.message,
+              fix: result.fix
+            });
+          }
+        }
+        if (result.status === "pass") summary.passed++;
+        else if (result.status === "warn") summary.warnings++;
+        else if (result.status === "fail") summary.failed++;
+      }
+      categories.push({ name: check.name, results });
+    }
+    return { categories, summary, pendingFixes };
+  }
+  async buildContext() {
+    const dataDir = path4.join(os2.homedir(), ".openacp");
+    const configPath = process.env.OPENACP_CONFIG_PATH || path4.join(dataDir, "config.json");
+    let config = null;
+    let rawConfig = null;
+    try {
+      const content = fs8.readFileSync(configPath, "utf-8");
+      rawConfig = JSON.parse(content);
+      const cm = new ConfigManager();
+      await cm.load();
+      config = cm.get();
+    } catch {
+    }
+    const logsDir = config ? expandHome(config.logging.logDir) : path4.join(dataDir, "logs");
+    return {
+      config,
+      rawConfig,
+      configPath,
+      dataDir,
+      sessionsPath: path4.join(dataDir, "sessions.json"),
+      pidPath: path4.join(dataDir, "openacp.pid"),
+      portFilePath: path4.join(dataDir, "api.port"),
+      pluginsDir: path4.join(dataDir, "plugins"),
+      logsDir
+    };
+  }
+};
+
+export {
+  DoctorEngine
+};
+//# sourceMappingURL=chunk-3DIPXFZJ.js.map