@rethinkingstudio/clawpilot 1.1.17 → 2.0.0-beta.1

package/src/commands/local-handlers.ts

@@ -1,533 +0,0 @@
-import { cpSync, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "fs";
-import { basename, dirname, join } from "path";
-import { homedir } from "os";
-import { execOpenclaw, resolveOpenclawConfigPath, resolveOpenclawDir } from "./openclaw-cli.js";
-
-export type LocalResult =
-  | { ok: true; payload?: unknown }
-  | { ok: false; error: string };
-
-type LocalCommandParams = Record<string, unknown>;
-
-type BackupListItem = {
-  id: string;
-  createdAt: number;
-  files: number;
-};
-
-// ---------------------------------------------------------------------------
-
-export function handleLocalCommand(method: string, params: unknown): LocalResult | null {
-  const commandParams = isRecord(params) ? params : {};
-  switch (method) {
-    case "clawpilot.config":          return readOpenclawConfig();
-    case "clawpilot.fix.tools.2026_3_2": return fixToolsPermissions202632();
-    case "clawpilot.restore.config":  return restoreConfig();
-    case "clawpilot.watchskill":      return watchSkill();
-    case "clawpilot.doctor":          return runDoctor();
-    case "clawpilot.doctor.fix":      return runDoctorFix();
-    case "clawpilot.logs":            return readLogs();
-    case "clawpilot.gateway.restart": return restartGateway();
-    case "clawpilot.version":         return getOpenclawVersion();
-    case "clawpilot.update":          return updateOpenclaw();
-    case "clawpilot.backup.create":   return createBackup();
-    case "clawpilot.backup.list":     return listBackups();
-    case "clawpilot.backup.restore":  return restoreBackup(commandParams);
-    default:                          return null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function execErrorOutput(err: unknown): string {
-  const e = err as { stdout?: Buffer | string; stderr?: Buffer | string };
-  const out = e.stdout?.toString() ?? "";
-  const errStr = e.stderr?.toString() ?? "";
-  if (out && errStr) return `${out}\n${errStr}`;
-  return out || errStr;
-}
-
-/** Run openclaw with the resolved path and the enriched subprocess environment. */
-function openclaw(args: string): Buffer {
-  return execOpenclaw(args);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-function backupsDir(): string {
-  return join(homedir(), ".clawai", "backups");
-}
-
-function formatBackupId(date = new Date(), prefix = ""): string {
-  const pad = (value: number) => String(value).padStart(2, "0");
-  return `${prefix}${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
-}
-
-function countFilesRecursive(path: string): number {
-  const stats = statSync(path);
-  if (stats.isFile()) return 1;
-  return readdirSync(path).reduce((count, name) => count + countFilesRecursive(join(path, name)), 0);
-}
-
-function listWorkspaceMarkdownFiles(workspaceDir: string): string[] {
-  if (!existsSync(workspaceDir)) return [];
-  return readdirSync(workspaceDir)
-    .filter((name) => name.endsWith(".md"))
-    .filter((name) => statSync(join(workspaceDir, name)).isFile());
-}
-
-function copyWithParents(from: string, to: string): void {
-  mkdirSync(dirname(to), { recursive: true });
-  cpSync(from, to, { recursive: true });
-}
-
-function createBackupSnapshot(prefix = ""): {
-  backupId: string;
-  path: string;
-  copied: string[];
-  skipped: string[];
-} {
-  const openclawDir = resolveOpenclawDir();
-  const configPath = resolveOpenclawConfigPath();
-  if (!existsSync(configPath)) {
-    throw new Error(`openclaw config not found: ${configPath}`);
-  }
-
-  const backupId = formatBackupId(new Date(), prefix);
-  const targetDir = join(backupsDir(), backupId);
-  const copied: string[] = [];
-  const skipped: string[] = [];
-
-  mkdirSync(targetDir, { recursive: true });
-
-  copyWithParents(configPath, join(targetDir, "openclaw.json"));
-  copied.push("openclaw.json");
-
-  const cronPath = join(openclawDir, "cron", "jobs.json");
-  if (existsSync(cronPath)) {
-    copyWithParents(cronPath, join(targetDir, "cron", "jobs.json"));
-    copied.push("cron/jobs.json");
-  } else {
-    skipped.push("cron/jobs.json");
-  }
-
-  const workspaceDir = join(openclawDir, "workspace");
-  const workspaceMarkdownFiles = listWorkspaceMarkdownFiles(workspaceDir);
-  if (workspaceMarkdownFiles.length > 0) {
-    for (const name of workspaceMarkdownFiles) {
-      copyWithParents(join(workspaceDir, name), join(targetDir, "workspace", name));
-      copied.push(`workspace/${name}`);
-    }
-  } else {
-    skipped.push("workspace/*.md");
-  }
-
-  const credentialsDir = join(openclawDir, "credentials");
-  if (existsSync(credentialsDir)) {
-    copyWithParents(credentialsDir, join(targetDir, "credentials"));
-    copied.push("credentials/*");
-  } else {
-    skipped.push("credentials/*");
-  }
-
-  return { backupId, path: targetDir, copied, skipped };
-}
-
-function backupSummary(action: string, backupId: string, copied: string[], skipped: string[], extraLines: string[] = []): string {
-  const lines = [
-    `${action}: ${backupId}`,
-    "",
-    "Copied:",
-    ...(copied.length > 0 ? copied.map((item) => `- ${item}`) : ["- (none)"]),
-  ];
-
-  if (skipped.length > 0) {
-    lines.push("", "Skipped:", ...skipped.map((item) => `- ${item}`));
-  }
-
-  if (extraLines.length > 0) {
-    lines.push("", ...extraLines);
-  }
-
-  return lines.join("\n");
-}
-
-function maskSensitive(value: unknown, parentKey?: string): unknown {
-  if (Array.isArray(value)) {
-    return value.map(item => maskSensitive(item));
-  }
-
-  if (value && typeof value === "object") {
-    const out: Record<string, unknown> = {};
-    for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
-      const normalized = key.toLowerCase();
-      if (
-        normalized.includes("token")
-        || normalized.includes("secret")
-        || normalized.includes("password")
-        || normalized == "apikey"
-        || normalized == "api_key"
-      ) {
-        out[key] = maskString(typeof child === "string" ? child : String(child ?? ""));
-      } else {
-        out[key] = maskSensitive(child, key);
-      }
-    }
-    return out;
-  }
-
-  if (typeof value === "string" && parentKey) {
-    const normalized = parentKey.toLowerCase();
-    if (
-      normalized.includes("token")
-      || normalized.includes("secret")
-      || normalized.includes("password")
-      || normalized == "apikey"
-      || normalized == "api_key"
-    ) {
-      return maskString(value);
-    }
-  }
-
-  return value;
-}
-
-function maskString(value: string): string {
-  if (!value) return value;
-  if (value.length <= 8) return "******";
-  return `${value.slice(0, 4)}******${value.slice(-2)}`;
-}
-
-// ---------------------------------------------------------------------------
-// Command implementations
-// ---------------------------------------------------------------------------
-
-function readOpenclawConfig(): LocalResult {
-  try {
-    const configPath = resolveOpenclawConfigPath();
-    if (!existsSync(configPath)) {
-      return { ok: false, error: `openclaw config not found: ${configPath}` };
-    }
-
-    const raw = readFileSync(configPath, "utf-8");
-    const parsed = JSON.parse(raw) as Record<string, unknown>;
-    const masked = maskSensitive(parsed);
-    const output = JSON.stringify(masked, null, 2);
-
-    return { ok: true, payload: { output: `[${configPath}]\n${output}` } };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-function fixToolsPermissions202632(): LocalResult {
-  const steps = [
-    "config set tools.profile full",
-    "config set tools.sessions.visibility all",
-    "config set tools.exec.security full",
-    "config set tools.exec.ask off",
-    "gateway restart",
-  ];
-
-  try {
-    const outputs: string[] = [];
-
-    for (const step of steps) {
-      const output = openclaw(step).toString().trim();
-      if (output) {
-        outputs.push(output);
-      }
-    }
-
-    const summary = [
-      "Applied OpenClaw 2026.3.2 tool permission fix.",
-      "Configured:",
-      "- tools.profile = full",
-      "- tools.sessions.visibility = all",
-      "- tools.exec.security = full",
-      "- tools.exec.ask = off",
-      "",
-      "Gateway restarted.",
-    ].join("\n");
-
-    const output = outputs.length > 0 ? `${summary}\n\n${outputs.join("\n\n")}` : summary;
-    return { ok: true, payload: { output } };
-  } catch (err) {
-    const output = execErrorOutput(err);
-    return output ? { ok: true, payload: { output } } : { ok: false, error: String(err) };
-  }
-}
-
-function restoreConfig(): LocalResult {
-  try {
-    const openclawDir = resolveOpenclawDir();
-    const configPath = resolveOpenclawConfigPath();
-    if (!existsSync(openclawDir)) {
-      return { ok: false, error: `openclaw config dir not found: ${openclawDir}` };
-    }
-    const configFileName = basename(configPath) || "openclaw.json";
-    const bakFiles = readdirSync(openclawDir)
-      .filter(name => name.startsWith("openclaw.json.bak"))
-      .map(name => {
-        const path = join(openclawDir, name);
-        return { name, path, mtime: statSync(path).mtimeMs };
-      })
-      .sort((a, b) => b.mtime - a.mtime);
-
-    if (bakFiles.length === 0) {
-      return { ok: false, error: "No backup files found in ~/.openclaw/" };
-    }
-    const latest = bakFiles[0];
-    copyFileSync(latest.path, configPath);
-    console.log(`[clawpilot] Config restored from ${latest.name}`);
-    return { ok: true, payload: { restoredFrom: latest.name, config: configFileName } };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-function watchSkill(): LocalResult {
-  try {
-    openclaw("config set skills.load.watch true");
-    openclaw("gateway restart");
-    console.log("[clawpilot] skills.load.watch set to true and gateway restarted");
-    return { ok: true, payload: { message: "skills.load.watch enabled and gateway restarted" } };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-function runDoctor(): LocalResult {
-  try {
-    const output = openclaw("doctor").toString();
-    console.log("[clawpilot] doctor completed");
-    return { ok: true, payload: { output } };
-  } catch (err) {
-    const output = execErrorOutput(err);
-    return output ? { ok: true, payload: { output } } : { ok: false, error: String(err) };
-  }
-}
-
-function runDoctorFix(): LocalResult {
-  try {
-    const output = openclaw("doctor --fix").toString();
-    console.log("[clawpilot] doctor --fix completed");
-    return { ok: true, payload: { output } };
-  } catch (err) {
-    const output = execErrorOutput(err);
-    return output ? { ok: true, payload: { output } } : { ok: false, error: String(err) };
-  }
-}
-
-function readLogs(): LocalResult {
-  try {
-    const openclawDir = resolveOpenclawDir();
-    const logsDir = join(openclawDir, "logs");
-    let logFiles: string[] = [];
-
-    if (existsSync(logsDir)) {
-      logFiles = readdirSync(logsDir)
-        .filter(f => f.endsWith(".log"))
-        .map(f => join(logsDir, f));
-    } else {
-      logFiles = readdirSync(openclawDir)
-        .filter(f => f.endsWith(".log"))
-        .map(f => join(openclawDir, f));
-    }
-
-    if (logFiles.length === 0) {
-      return { ok: true, payload: { output: "No log files found." } };
-    }
-
-    const logFilesWithMtime = logFiles.map(f => ({ path: f, mtime: statSync(f).mtimeMs }));
-    logFilesWithMtime.sort((a, b) => b.mtime - a.mtime);
-    const latest = logFilesWithMtime[0].path;
-    const allLines = readFileSync(latest, "utf-8").split("\n");
-    const last100 = allLines.slice(-100).join("\n");
-
-    console.log(`[clawpilot] logs read from ${latest}`);
-    return { ok: true, payload: { output: `[${latest}]\n${last100}` } };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-function restartGateway(): LocalResult {
-  try {
-    const output = openclaw("gateway restart").toString();
-    console.log("[clawpilot] gateway restarted");
-    return { ok: true, payload: { output: output || "Gateway restarted successfully." } };
-  } catch (err) {
-    const output = execErrorOutput(err);
-    return output ? { ok: true, payload: { output } } : { ok: false, error: String(err) };
-  }
-}
-
-function getOpenclawVersion(): LocalResult {
-  const candidates = ["--version", "version"];
-
-  for (const args of candidates) {
-    try {
-      const output = openclaw(args).toString().trim();
-      const version = output
-        .split("\n")
-        .map(line => line.trim())
-        .find(line => line.length > 0);
-
-      if (version) {
-        console.log(`[clawpilot] openclaw version detected via "${args}": ${version}`);
-        return { ok: true, payload: { version, output } };
-      }
-    } catch (err) {
-      const output = execErrorOutput(err).trim();
-      const version = output
-        .split("\n")
-        .map(line => line.trim())
-        .find(line => /^v?\d+\./.test(line) || /openclaw/i.test(line));
-
-      if (version) {
-        console.log(`[clawpilot] openclaw version parsed from error output via "${args}": ${version}`);
-        return { ok: true, payload: { version, output } };
-      }
-    }
-  }
-
-  return { ok: false, error: "Unable to determine openclaw version." };
-}
-
-function updateOpenclaw(): LocalResult {
-  try {
-    const output = openclaw("update").toString();
-    console.log("[clawpilot] openclaw updated");
-    return { ok: true, payload: { output: output || "openclaw updated successfully." } };
-  } catch (err) {
-    const output = execErrorOutput(err);
-    return output ? { ok: true, payload: { output } } : { ok: false, error: String(err) };
-  }
-}
-
-function createBackup(): LocalResult {
-  try {
-    const snapshot = createBackupSnapshot();
-    console.log(`[clawpilot] backup created: ${snapshot.backupId}`);
-    return {
-      ok: true,
-      payload: {
-        backupId: snapshot.backupId,
-        output: backupSummary("Backup created", snapshot.backupId, snapshot.copied, snapshot.skipped),
-      },
-    };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-function listBackups(): LocalResult {
-  try {
-    const root = backupsDir();
-    if (!existsSync(root)) {
-      return { ok: true, payload: { items: [] as BackupListItem[] } };
-    }
-
-    const items = readdirSync(root)
-      .map((name) => join(root, name))
-      .filter((path) => statSync(path).isDirectory())
-      .map((path) => {
-        const id = basename(path) || path;
-        return {
-          id,
-          createdAt: statSync(path).mtimeMs,
-          files: countFilesRecursive(path),
-        } satisfies BackupListItem;
-      })
-      .sort((a, b) => b.createdAt - a.createdAt);
-
-    return { ok: true, payload: { items } };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-function restoreBackup(params: LocalCommandParams): LocalResult {
-  try {
-    const backupId = typeof params.backupId === "string" ? params.backupId.trim() : "";
-    if (!backupId) {
-      return { ok: false, error: "backupId is required." };
-    }
-    if (!/^[A-Za-z0-9_-]+$/.test(backupId)) {
-      return { ok: false, error: "Invalid backupId." };
-    }
-
-    const sourceDir = join(backupsDir(), backupId);
-    if (!existsSync(sourceDir) || !statSync(sourceDir).isDirectory()) {
-      return { ok: false, error: `Backup not found: ${backupId}` };
-    }
-
-    const preRestoreSnapshot = createBackupSnapshot("pre-restore-");
-    const openclawDir = resolveOpenclawDir();
-    const configPath = resolveOpenclawConfigPath();
-    const restored: string[] = [];
-    const skipped: string[] = [];
-
-    const backupConfigPath = join(sourceDir, "openclaw.json");
-    if (existsSync(backupConfigPath)) {
-      copyWithParents(backupConfigPath, configPath);
-      restored.push("openclaw.json");
-    } else {
-      skipped.push("openclaw.json");
-    }
-
-    const backupCronPath = join(sourceDir, "cron", "jobs.json");
-    if (existsSync(backupCronPath)) {
-      copyWithParents(backupCronPath, join(openclawDir, "cron", "jobs.json"));
-      restored.push("cron/jobs.json");
-    } else {
-      skipped.push("cron/jobs.json");
-    }
-
-    const backupWorkspaceDir = join(sourceDir, "workspace");
-    if (existsSync(backupWorkspaceDir)) {
-      const workspaceMarkdownFiles = listWorkspaceMarkdownFiles(backupWorkspaceDir);
-      if (workspaceMarkdownFiles.length > 0) {
-        for (const name of workspaceMarkdownFiles) {
-          copyWithParents(join(backupWorkspaceDir, name), join(openclawDir, "workspace", name));
-          restored.push(`workspace/${name}`);
-        }
-      } else {
-        skipped.push("workspace/*.md");
-      }
-    } else {
-      skipped.push("workspace/*.md");
-    }
-
-    const backupCredentialsDir = join(sourceDir, "credentials");
-    if (existsSync(backupCredentialsDir)) {
-      copyWithParents(backupCredentialsDir, join(openclawDir, "credentials"));
-      restored.push("credentials/*");
-    } else {
-      skipped.push("credentials/*");
-    }
-
-    console.log(`[clawpilot] backup restored: ${backupId}`);
-    return {
-      ok: true,
-      payload: {
-        backupId,
-        preRestoreBackupId: preRestoreSnapshot.backupId,
-        output: backupSummary(
-          "Backup restored",
-          backupId,
-          restored,
-          skipped,
-          [`Pre-restore backup: ${preRestoreSnapshot.backupId}`]
-        ),
-      },
-    };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}