clawmarketbot 0.1.8 → 0.1.10

package/dist/index.js

@@ -212,9 +212,9 @@ Hey ${username}! You're now logged in.
 }
 
 // src/commands/config.ts
-import fs4 from "fs/promises";
-import path3 from "path";
-import os3 from "os";
+import fs5 from "fs/promises";
+import path4 from "path";
+import os4 from "os";
 import { createHash, randomUUID } from "crypto";
 import { spawn } from "child_process";
 import JSON52 from "json5";
@@ -587,6 +587,52 @@ async function loadOpenClawContext() {
   };
 }
 
+// src/lib/snapshots.ts
+import path3 from "path";
+import fs4 from "fs/promises";
+import os3 from "os";
+var SNAPSHOT_EXPIRY_MS = 24 * 60 * 60 * 1e3;
+function getSnapshotsDir() {
+  return path3.join(os3.homedir(), ".clawmarket", "snapshots");
+}
+function snapshotFilePath() {
+  return path3.join(getSnapshotsDir(), "install-snapshot.json");
+}
+async function saveInstallSnapshot(data) {
+  const dir = getSnapshotsDir();
+  await fs4.mkdir(dir, { recursive: true, mode: 448 });
+  await fs4.chmod(dir, 448).catch(() => void 0);
+  const snapshot = {
+    version: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...data
+  };
+  const filePath = snapshotFilePath();
+  await fs4.writeFile(filePath, JSON.stringify(snapshot, null, 2), { mode: 384 });
+  await fs4.chmod(filePath, 384).catch(() => void 0);
+}
+async function loadLatestSnapshot() {
+  const filePath = snapshotFilePath();
+  if (!await fileExists(filePath)) return null;
+  try {
+    const raw = await fs4.readFile(filePath, "utf-8");
+    const snapshot = JSON.parse(raw);
+    if (snapshot.version !== 1 || !snapshot.createdAt) return null;
+    const age = Date.now() - new Date(snapshot.createdAt).getTime();
+    if (age > SNAPSHOT_EXPIRY_MS) {
+      await deleteSnapshot();
+      return null;
+    }
+    return snapshot;
+  } catch {
+    return null;
+  }
+}
+async function deleteSnapshot() {
+  const filePath = snapshotFilePath();
+  await fs4.rm(filePath, { force: true }).catch(() => void 0);
+}
+
 // src/commands/config.ts
 function isValidDownloadToken(token) {
   return isClawMarketDownloadToken(token);
@@ -597,13 +643,13 @@ function assertValidDownloadToken(token) {
   }
 }
 async function resolveSafeDownloadPath(targetPath) {
-  const resolved = path3.resolve(targetPath);
+  const resolved = path4.resolve(targetPath);
   if (!await fileExists(resolved)) {
     return { outputPath: resolved, renamed: false };
   }
-  const parsed = path3.parse(resolved);
+  const parsed = path4.parse(resolved);
   for (let i = 1; i <= 1e3; i += 1) {
-    const candidate = path3.join(parsed.dir, `${parsed.name}-${i}${parsed.ext}`);
+    const candidate = path4.join(parsed.dir, `${parsed.name}-${i}${parsed.ext}`);
     if (!await fileExists(candidate)) {
       return { outputPath: candidate, renamed: true };
     }
@@ -631,7 +677,7 @@ function sanitizeSlugPart(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
 }
 function sanitizeFileName(value) {
-  const base = path3.basename(value || "").replace(/[^A-Za-z0-9._-]/g, "-");
+  const base = path4.basename(value || "").replace(/[^A-Za-z0-9._-]/g, "-");
   return base || "download.bin";
 }
 function parseContentDispositionFileName(headerValue) {
@@ -697,7 +743,8 @@ async function runCommand(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd: options.cwd,
-      stdio: options.stdio === "inherit" ? "inherit" : "pipe"
+      stdio: options.stdio === "inherit" ? "inherit" : "pipe",
+      env: options.env
     });
     let stdout = "";
     let stderr = "";
@@ -749,7 +796,7 @@ async function readBotInstallerConfig(configPath) {
   if (!await fileExists(configPath)) {
     throw new Error(`Package is missing required config file: ${configPath}`);
   }
-  const raw = await fs4.readFile(configPath, "utf-8");
+  const raw = await fs5.readFile(configPath, "utf-8");
   try {
     return JSON.parse(raw);
   } catch (error) {
@@ -768,68 +815,68 @@ function resolveInstallPaths(botConfig, agentId, stateDir, sourceBase) {
   const tplWorkspace = botConfig.paths?.targetWorkspace ?? "workspace-{agent_id}";
   const tplAgentState = botConfig.paths?.targetAgentState ?? "agents/{agent_id}";
   const tplMemoryDb = botConfig.paths?.targetMemoryDb ?? null;
-  const targetAgentRoot = path3.join(stateDir, applyTemplate(tplAgentState));
+  const targetAgentRoot = path4.join(stateDir, applyTemplate(tplAgentState));
   return {
-    sourceWorkspace: path3.join(sourceBase, srcWorkspace),
-    sourceAgentState: path3.join(sourceBase, srcAgentState),
-    sourceMemoryDb: srcMemoryDb ? path3.join(sourceBase, srcMemoryDb) : null,
-    sourceCronJobs: srcCronJobs ? path3.join(sourceBase, srcCronJobs) : null,
-    targetWorkspace: path3.join(stateDir, applyTemplate(tplWorkspace)),
+    sourceWorkspace: path4.join(sourceBase, srcWorkspace),
+    sourceAgentState: path4.join(sourceBase, srcAgentState),
+    sourceMemoryDb: srcMemoryDb ? path4.join(sourceBase, srcMemoryDb) : null,
+    sourceCronJobs: srcCronJobs ? path4.join(sourceBase, srcCronJobs) : null,
+    targetWorkspace: path4.join(stateDir, applyTemplate(tplWorkspace)),
     targetAgentRoot,
-    targetAgentDir: path3.join(targetAgentRoot, "agent"),
-    targetMemoryDb: tplMemoryDb ? path3.join(stateDir, applyTemplate(tplMemoryDb)) : null
+    targetAgentDir: path4.join(targetAgentRoot, "agent"),
+    targetMemoryDb: tplMemoryDb ? path4.join(stateDir, applyTemplate(tplMemoryDb)) : null
   };
 }
 async function findSourceRoot(extractedDir) {
-  const queue = [path3.resolve(extractedDir)];
+  const queue = [path4.resolve(extractedDir)];
   const seen = /* @__PURE__ */ new Set();
   while (queue.length > 0) {
     const current = queue.shift();
     if (!current || seen.has(current)) continue;
     seen.add(current);
-    if (await fileExists(path3.join(current, "source", "bot-config.json"))) {
+    if (await fileExists(path4.join(current, "source", "bot-config.json"))) {
       return current;
     }
     let entries;
     try {
-      entries = await fs4.readdir(current, { withFileTypes: true });
+      entries = await fs5.readdir(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name === "__MACOSX") continue;
-      queue.push(path3.join(current, entry.name));
+      queue.push(path4.join(current, entry.name));
     }
   }
   return null;
 }
 async function copyDirRecursive(src, dest) {
-  await fs4.mkdir(dest, { recursive: true });
-  const entries = await fs4.readdir(src, { withFileTypes: true });
+  await fs5.mkdir(dest, { recursive: true });
+  const entries = await fs5.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path3.join(src, entry.name);
-    const destPath = path3.join(dest, entry.name);
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirRecursive(srcPath, destPath);
     } else {
-      await fs4.copyFile(srcPath, destPath);
+      await fs5.copyFile(srcPath, destPath);
     }
   }
 }
 async function stripMacOsJunk(dir) {
-  const macosDir = path3.join(dir, "__MACOSX");
-  await fs4.rm(macosDir, { recursive: true, force: true }).catch(() => void 0);
+  const macosDir = path4.join(dir, "__MACOSX");
+  await fs5.rm(macosDir, { recursive: true, force: true }).catch(() => void 0);
   async function removeDsStore(d) {
     let entries;
     try {
-      entries = await fs4.readdir(d, { withFileTypes: true });
+      entries = await fs5.readdir(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path3.join(d, entry.name);
+      const full = path4.join(d, entry.name);
       if (entry.isFile() && entry.name === ".DS_Store") {
-        await fs4.rm(full, { force: true }).catch(() => void 0);
+        await fs5.rm(full, { force: true }).catch(() => void 0);
       } else if (entry.isDirectory()) {
         await removeDsStore(full);
       }
@@ -838,7 +885,7 @@ async function stripMacOsJunk(dir) {
   await removeDsStore(dir);
 }
 async function buildOpenClawConfigPatch(configPath, agentId, agentName, botConfig, installPaths, existingAgents = []) {
-  const raw = await fs4.readFile(configPath, "utf-8");
+  const raw = await fs5.readFile(configPath, "utf-8");
   const config = JSON52.parse(raw);
   const agentEntry = {
     id: agentId,
@@ -886,7 +933,7 @@ async function buildOpenClawConfigPatch(configPath, agentId, agentName, botConfi
 }
 async function prepareCronJobsFromBundle(sourceCronPath, cronStorePath, agentId) {
   if (!sourceCronPath || !await fileExists(sourceCronPath)) return null;
-  const raw = await fs4.readFile(sourceCronPath, "utf-8");
+  const raw = await fs5.readFile(sourceCronPath, "utf-8");
   const bundleJobs = normalizeCronJobs(JSON.parse(raw));
   if (bundleJobs.length === 0) return null;
   const shouldInstall = await resolveCronChoice(true);
@@ -902,7 +949,7 @@ async function prepareCronJobsFromBundle(sourceCronPath, cronStorePath, agentId)
   let existingJobs = [];
   if (await fileExists(cronStorePath)) {
     existed = true;
-    backupContent = await fs4.readFile(cronStorePath, "utf-8");
+    backupContent = await fs5.readFile(cronStorePath, "utf-8");
     existingJobs = normalizeCronJobs(JSON52.parse(backupContent));
   }
   const existingKeys = new Set(
@@ -935,7 +982,7 @@ async function setupApiKeysFromConfig(botConfig, configPath, envPath) {
     console.log("");
     const key = await askOptional(brave.prompt ?? "Brave Search API key", brave.url);
     if (key) {
-      const raw = await fs4.readFile(configPath, "utf-8");
+      const raw = await fs5.readFile(configPath, "utf-8");
       const config = JSON52.parse(raw);
       const tools = config.tools ?? {};
       const web = tools.web ?? {};
@@ -944,7 +991,7 @@ async function setupApiKeysFromConfig(botConfig, configPath, envPath) {
       web.search = search;
       tools.web = web;
       config.tools = tools;
-      await fs4.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      await fs5.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
       console.log("  Brave Search key saved to openclaw.json");
     } else {
       console.log("  Skipped Brave Search key.");
@@ -952,10 +999,10 @@ async function setupApiKeysFromConfig(botConfig, configPath, envPath) {
   }
   const envKeys = botConfig.apiKeys.env ?? [];
   if (envKeys.length > 0) {
-    await fs4.mkdir(path3.dirname(envPath), { recursive: true });
+    await fs5.mkdir(path4.dirname(envPath), { recursive: true });
     let envContent = "";
     try {
-      envContent = await fs4.readFile(envPath, "utf-8");
+      envContent = await fs5.readFile(envPath, "utf-8");
     } catch {
     }
     let keysWritten = 0;
@@ -974,7 +1021,7 @@ ${keyDef.key}=${val}`;
       }
     }
     if (keysWritten > 0) {
-      await fs4.writeFile(envPath, envContent.trim() + "\n", "utf-8");
+      await fs5.writeFile(envPath, envContent.trim() + "\n", "utf-8");
       console.log(`
   ${keysWritten} key(s) saved to .env`);
     }
@@ -986,13 +1033,13 @@ async function validateInstalledWorkspace(workspacePath, botConfig) {
   if (requiredFiles.length === 0 && requiredDirs.length === 0) return;
   const warnings = [];
   for (const file of requiredFiles) {
-    if (!await fileExists(path3.join(workspacePath, file))) {
+    if (!await fileExists(path4.join(workspacePath, file))) {
       warnings.push(`Missing expected file: ${file}`);
     }
   }
   for (const dir of requiredDirs) {
     try {
-      const stat = await fs4.stat(path3.join(workspacePath, dir));
+      const stat = await fs5.stat(path4.join(workspacePath, dir));
       if (!stat.isDirectory()) warnings.push(`Expected directory but found file: ${dir}`);
     } catch {
       warnings.push(`Missing expected directory: ${dir}`);
@@ -1027,46 +1074,46 @@ async function commitInstallTransaction(input2) {
   let movedAgentDir = false;
   let copiedMemoryDb = false;
   try {
-    await fs4.mkdir(path3.dirname(input2.workspacePath), { recursive: true });
-    await fs4.rename(input2.stagedWorkspacePath, input2.workspacePath);
+    await fs5.mkdir(path4.dirname(input2.workspacePath), { recursive: true });
+    await fs5.rename(input2.stagedWorkspacePath, input2.workspacePath);
     movedWorkspace = true;
-    await fs4.mkdir(path3.dirname(input2.agentDirPath), { recursive: true });
-    await fs4.rename(input2.stagedAgentDirPath, input2.agentDirPath);
+    await fs5.mkdir(path4.dirname(input2.agentDirPath), { recursive: true });
+    await fs5.rename(input2.stagedAgentDirPath, input2.agentDirPath);
     movedAgentDir = true;
     if (input2.memoryDbStagedPath && input2.memoryDbTargetPath && await fileExists(input2.memoryDbStagedPath)) {
-      await fs4.mkdir(path3.dirname(input2.memoryDbTargetPath), { recursive: true });
-      await fs4.copyFile(input2.memoryDbStagedPath, input2.memoryDbTargetPath);
+      await fs5.mkdir(path4.dirname(input2.memoryDbTargetPath), { recursive: true });
+      await fs5.copyFile(input2.memoryDbStagedPath, input2.memoryDbTargetPath);
       copiedMemoryDb = true;
     }
     if (input2.cronContent !== null) {
-      await fs4.mkdir(path3.dirname(input2.cronStorePath), { recursive: true });
-      await fs4.writeFile(input2.cronStorePath, input2.cronContent, "utf-8");
+      await fs5.mkdir(path4.dirname(input2.cronStorePath), { recursive: true });
+      await fs5.writeFile(input2.cronStorePath, input2.cronContent, "utf-8");
     }
-    await fs4.writeFile(input2.configPath, input2.configContent, "utf-8");
+    await fs5.writeFile(input2.configPath, input2.configContent, "utf-8");
   } catch (error) {
     if (input2.cronContent !== null) {
       if (input2.cronExisted && input2.cronBackupContent !== null) {
-        await fs4.writeFile(input2.cronStorePath, input2.cronBackupContent, "utf-8").catch(() => void 0);
+        await fs5.writeFile(input2.cronStorePath, input2.cronBackupContent, "utf-8").catch(() => void 0);
       } else {
-        await fs4.rm(input2.cronStorePath, { force: true }).catch(() => void 0);
+        await fs5.rm(input2.cronStorePath, { force: true }).catch(() => void 0);
       }
     }
     if (copiedMemoryDb && input2.memoryDbTargetPath) {
-      await fs4.rm(input2.memoryDbTargetPath, { force: true }).catch(() => void 0);
+      await fs5.rm(input2.memoryDbTargetPath, { force: true }).catch(() => void 0);
     }
-    await fs4.writeFile(input2.configPath, input2.configBackupContent, "utf-8").catch(() => void 0);
+    await fs5.writeFile(input2.configPath, input2.configBackupContent, "utf-8").catch(() => void 0);
     if (movedWorkspace) {
-      await fs4.rm(input2.workspacePath, { recursive: true, force: true }).catch(() => void 0);
+      await fs5.rm(input2.workspacePath, { recursive: true, force: true }).catch(() => void 0);
     }
     if (movedAgentDir) {
-      await fs4.rm(input2.agentRootPath, { recursive: true, force: true }).catch(() => void 0);
+      await fs5.rm(input2.agentRootPath, { recursive: true, force: true }).catch(() => void 0);
     }
     const message = error instanceof Error ? error.message : "unknown failure";
     throw new Error(`Install failed and was rolled back: ${message}`);
   }
 }
 async function buildOpenClawConfigUnpatch(configPath, agentId) {
-  const raw = await fs4.readFile(configPath, "utf-8");
+  const raw = await fs5.readFile(configPath, "utf-8");
   const config = JSON52.parse(raw);
   const agents = config.agents ?? {};
   if (!Array.isArray(agents.list)) {
@@ -1089,7 +1136,7 @@ async function buildOpenClawConfigUnpatch(configPath, agentId) {
 }
 async function buildCronJobsUnpatch(cronStorePath, agentId) {
   if (!await fileExists(cronStorePath)) return null;
-  const raw = await fs4.readFile(cronStorePath, "utf-8");
+  const raw = await fs5.readFile(cronStorePath, "utf-8");
   let parsed;
   try {
     parsed = JSON52.parse(raw);
@@ -1135,7 +1182,7 @@ function buildUninstallPlan(context, agentId) {
     path: agent.workspace,
     description: `Workspace directory`
   });
-  const agentRootDir = path3.dirname(agent.agentDir);
+  const agentRootDir = path4.dirname(agent.agentDir);
   removals.push({
     type: "directory",
     path: agentRootDir,
@@ -1160,37 +1207,37 @@ function buildUninstallPlan(context, agentId) {
 }
 async function commitUninstallTransaction(plan) {
   try {
-    await fs4.writeFile(plan.configPath, plan.configPatch.after, "utf-8");
+    await fs5.writeFile(plan.configPath, plan.configPatch.after, "utf-8");
   } catch (error) {
     const msg = error instanceof Error ? error.message : "unknown failure";
     throw new Error(`Uninstall failed while patching openclaw.json: ${msg}`);
   }
   if (plan.cronPatch) {
     try {
-      await fs4.writeFile(plan.cronStorePath, plan.cronPatch.after, "utf-8");
+      await fs5.writeFile(plan.cronStorePath, plan.cronPatch.after, "utf-8");
     } catch (error) {
-      await fs4.writeFile(plan.configPath, plan.configPatch.before, "utf-8").catch(() => void 0);
+      await fs5.writeFile(plan.configPath, plan.configPatch.before, "utf-8").catch(() => void 0);
       const msg = error instanceof Error ? error.message : "unknown failure";
       throw new Error(`Uninstall failed while patching cron jobs (rolled back openclaw.json): ${msg}`);
     }
   }
   try {
-    await fs4.rm(plan.agent.workspace, { recursive: true, force: true });
+    await fs5.rm(plan.agent.workspace, { recursive: true, force: true });
   } catch (error) {
-    await fs4.writeFile(plan.configPath, plan.configPatch.before, "utf-8").catch(() => void 0);
+    await fs5.writeFile(plan.configPath, plan.configPatch.before, "utf-8").catch(() => void 0);
     if (plan.cronPatch) {
-      await fs4.writeFile(plan.cronStorePath, plan.cronPatch.before, "utf-8").catch(() => void 0);
+      await fs5.writeFile(plan.cronStorePath, plan.cronPatch.before, "utf-8").catch(() => void 0);
     }
     const msg = error instanceof Error ? error.message : "unknown failure";
     throw new Error(`Uninstall failed while removing workspace (rolled back config files): ${msg}`);
   }
-  const agentRootDir = path3.dirname(plan.agent.agentDir);
+  const agentRootDir = path4.dirname(plan.agent.agentDir);
   try {
-    await fs4.rm(agentRootDir, { recursive: true, force: true });
+    await fs5.rm(agentRootDir, { recursive: true, force: true });
   } catch (error) {
-    await fs4.writeFile(plan.configPath, plan.configPatch.before, "utf-8").catch(() => void 0);
+    await fs5.writeFile(plan.configPath, plan.configPatch.before, "utf-8").catch(() => void 0);
     if (plan.cronPatch) {
-      await fs4.writeFile(plan.cronStorePath, plan.cronPatch.before, "utf-8").catch(() => void 0);
+      await fs5.writeFile(plan.cronStorePath, plan.cronPatch.before, "utf-8").catch(() => void 0);
     }
     const msg = error instanceof Error ? error.message : "unknown failure";
     throw new Error(`Uninstall failed while removing agent directory (rolled back config files): ${msg}`);
@@ -1220,12 +1267,12 @@ function registerConfigCommands(program2) {
       }
       const fileFromHeader = parseContentDispositionFileName(response.headers.get("content-disposition"));
       const fallbackFile = `clawmarket-${token}.bin`;
-      const preferredPath = path3.resolve(fileFromHeader || fallbackFile);
+      const preferredPath = path4.resolve(fileFromHeader || fallbackFile);
       const { outputPath, renamed } = await resolveSafeDownloadPath(preferredPath);
       const bytes = Buffer.from(await response.arrayBuffer());
       verifyDownloadedArtifactChecksum(bytes, response.headers.get(CLAWMARKET_ARTIFACT_SHA256_HEADER));
-      await fs4.mkdir(path3.dirname(outputPath), { recursive: true });
-      await fs4.writeFile(outputPath, bytes);
+      await fs5.mkdir(path4.dirname(outputPath), { recursive: true });
+      await fs5.writeFile(outputPath, bytes);
       if (renamed) {
         console.log(`Existing file detected, saved as: ${outputPath}`);
       }
@@ -1242,14 +1289,14 @@ function registerConfigCommands(program2) {
       const server = getDefaultServer();
       const context = await loadOpenClawContext();
       const artifact = await fetchDownloadArtifact(server, token);
-      const tempRoot = await fs4.mkdtemp(
-        path3.join(os3.tmpdir(), `.clawmarket-install-${randomUUID().slice(0, 8)}-`)
+      const tempRoot = await fs5.mkdtemp(
+        path4.join(os4.tmpdir(), `.clawmarket-install-${randomUUID().slice(0, 8)}-`)
       );
       try {
-        const artifactPath = path3.join(tempRoot, sanitizeFileName(artifact.fileName));
-        const extractedPath = path3.join(tempRoot, "extracted");
-        await fs4.mkdir(extractedPath, { recursive: true });
-        await fs4.writeFile(artifactPath, artifact.bytes);
+        const artifactPath = path4.join(tempRoot, sanitizeFileName(artifact.fileName));
+        const extractedPath = path4.join(tempRoot, "extracted");
+        await fs5.mkdir(extractedPath, { recursive: true });
+        await fs5.writeFile(artifactPath, artifact.bytes);
         await extractZipArtifact(artifactPath, extractedPath);
         await stripMacOsJunk(extractedPath);
         const sourceRoot = await findSourceRoot(extractedPath);
@@ -1258,8 +1305,8 @@ function registerConfigCommands(program2) {
             "Downloaded artifact is not an installable bot package (missing source/bot-config.json)."
           );
         }
-        const sourceBase = path3.join(sourceRoot, "source");
-        const botConfig = await readBotInstallerConfig(path3.join(sourceBase, "bot-config.json"));
+        const sourceBase = path4.join(sourceRoot, "source");
+        const botConfig = await readBotInstallerConfig(path4.join(sourceBase, "bot-config.json"));
         if (typeof botConfig.installerSpecVersion === "number" && botConfig.installerSpecVersion !== 1) {
           console.warn(
             `Warning: installerSpecVersion=${botConfig.installerSpecVersion} (this CLI currently expects version 1).`
@@ -1274,8 +1321,8 @@ function registerConfigCommands(program2) {
           throw new Error(`Agent id "${agentId}" already exists. Choose another id.`);
         }
         const installPaths = resolveInstallPaths(botConfig, agentId, context.paths.stateDir, sourceBase);
-        const stagedWorkspacePath = path3.join(tempRoot, "staged-workspace");
-        const stagedAgentDirPath = path3.join(tempRoot, "staged-agent");
+        const stagedWorkspacePath = path4.join(tempRoot, "staged-workspace");
+        const stagedAgentDirPath = path4.join(tempRoot, "staged-agent");
         await copyDirRecursive(installPaths.sourceWorkspace, stagedWorkspacePath);
         await copyDirRecursive(installPaths.sourceAgentState, stagedAgentDirPath);
         const { configContent, configBackupContent } = await buildOpenClawConfigPatch(
@@ -1291,6 +1338,20 @@ function registerConfigCommands(program2) {
           context.paths.cronStorePath,
           agentId
         );
+        await saveInstallSnapshot({
+          agentId,
+          agentName,
+          openclawConfigBefore: configBackupContent,
+          cronStoreBefore: cronResult?.backupContent ?? null,
+          cronStoreExisted: cronResult?.existed ?? false,
+          installedPaths: {
+            workspace: installPaths.targetWorkspace,
+            agentRoot: installPaths.targetAgentRoot,
+            memoryDb: installPaths.targetMemoryDb ?? null
+          },
+          configPath: context.paths.configPath,
+          cronStorePath: context.paths.cronStorePath
+        });
         console.log("\nInstalling...");
         await commitInstallTransaction({
           stagedWorkspacePath,
@@ -1309,15 +1370,29 @@ function registerConfigCommands(program2) {
           memoryDbTargetPath: installPaths.targetMemoryDb
         });
         await setupApiKeysFromConfig(botConfig, context.paths.configPath, context.paths.envPath);
-        const installerShPath = path3.join(sourceBase, "installer.sh");
+        const installerShPath = path4.join(sourceBase, "installer.sh");
         if (await fileExists(installerShPath)) {
-          console.log("\nRunning post-install hook (installer.sh)...");
-          const hookPath = path3.join(sourceRoot, "_clawmarket_installer.sh");
-          await fs4.copyFile(installerShPath, hookPath);
-          await runCommand("bash", [hookPath, context.paths.stateDir], {
-            cwd: sourceRoot,
-            stdio: "inherit"
-          });
+          if (botConfig.agent?.id) {
+            console.log("\nSkipping installer.sh \u2014 bot-config.json agent declaration handled by CLI.");
+          } else {
+            console.log("\nRunning post-install hook (installer.sh)...");
+            const hookPath = path4.join(sourceRoot, "_clawmarket_installer.sh");
+            await fs5.copyFile(installerShPath, hookPath);
+            await runCommand("bash", [hookPath, context.paths.stateDir], {
+              cwd: sourceRoot,
+              stdio: "inherit",
+              env: {
+                ...process.env,
+                CLAWMARKET_CLI_INSTALL: "1",
+                CLAWMARKET_AGENT_ID: agentId,
+                CLAWMARKET_AGENT_NAME: agentName,
+                CLAWMARKET_WORKSPACE: installPaths.targetWorkspace,
+                CLAWMARKET_AGENT_ROOT: installPaths.targetAgentRoot,
+                CLAWMARKET_CONFIG_PATH: context.paths.configPath,
+                CLAWMARKET_STATE_DIR: context.paths.stateDir
+              }
+            });
+          }
         }
         await validateInstalledWorkspace(installPaths.targetWorkspace, botConfig);
         const refreshed = await loadOpenClawContext();
@@ -1342,7 +1417,7 @@ function registerConfigCommands(program2) {
         console.log("  1) openclaw agents list");
         console.log("  2) openclaw gateway restart");
       } finally {
-        await fs4.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
+        await fs5.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Install failed";
@@ -1379,7 +1454,7 @@ function registerConfigCommands(program2) {
       console.log(`  Uninstalled "${agent.name}" (${agent.id})`);
       console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
       console.log(`  Removed workspace: ${agent.workspace}`);
-      console.log(`  Removed agent dir: ${path3.dirname(agent.agentDir)}`);
+      console.log(`  Removed agent dir: ${path4.dirname(agent.agentDir)}`);
       console.log(`  Removed from openclaw.json agents.list`);
       if (cronPatch) {
         console.log(`  Removed ${cronPatch.removedCount} cron job(s)`);
@@ -1391,11 +1466,95 @@ function registerConfigCommands(program2) {
       process.exit(1);
     }
   });
+  configCommand.command("restore").description("Restore OpenClaw state to before the last install (snapshots expire after 24 hours)").option("--force", "Skip confirmation prompt").action(async (opts) => {
+    try {
+      const snapshot = await loadLatestSnapshot();
+      if (!snapshot) {
+        console.log("No recent install snapshot found (snapshots expire after 24 hours).");
+        return;
+      }
+      console.log("");
+      console.log(`Restore to state before installing "${snapshot.agentName}" (${snapshot.agentId})?`);
+      console.log("");
+      console.log(`  - Restore openclaw.json`);
+      console.log(`  - Remove workspace: ${snapshot.installedPaths.workspace}`);
+      console.log(`  - Remove agent directory: ${snapshot.installedPaths.agentRoot}`);
+      if (snapshot.installedPaths.memoryDb) {
+        console.log(`  - Remove memory DB: ${snapshot.installedPaths.memoryDb}`);
+      }
+      if (snapshot.cronStoreBefore !== null) {
+        console.log(`  - Restore cron jobs`);
+      } else if (!snapshot.cronStoreExisted) {
+      }
+      console.log("");
+      if (!opts.force) {
+        const canPrompt = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+        if (!canPrompt) {
+          throw new Error("Restore requires an interactive terminal for confirmation. Use --force to skip.");
+        }
+        const confirmed = await confirm("Proceed with restore?", false);
+        if (!confirmed) {
+          console.log("Restore cancelled.");
+          return;
+        }
+      }
+      await fs5.writeFile(snapshot.configPath, snapshot.openclawConfigBefore, "utf-8");
+      if (snapshot.cronStoreBefore !== null) {
+        await fs5.writeFile(snapshot.cronStorePath, snapshot.cronStoreBefore, "utf-8");
+      } else if (!snapshot.cronStoreExisted) {
+        await fs5.rm(snapshot.cronStorePath, { force: true }).catch(() => void 0);
+      }
+      await fs5.rm(snapshot.installedPaths.workspace, { recursive: true, force: true }).catch(() => void 0);
+      await fs5.rm(snapshot.installedPaths.agentRoot, { recursive: true, force: true }).catch(() => void 0);
+      if (snapshot.installedPaths.memoryDb) {
+        await fs5.rm(snapshot.installedPaths.memoryDb, { force: true }).catch(() => void 0);
+      }
+      await deleteSnapshot();
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      console.log(`  Restored to pre-install state`);
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      console.log(`  Restored openclaw.json`);
+      console.log(`  Removed workspace: ${snapshot.installedPaths.workspace}`);
+      console.log(`  Removed agent dir: ${snapshot.installedPaths.agentRoot}`);
+      if (snapshot.installedPaths.memoryDb) {
+        console.log(`  Removed memory DB: ${snapshot.installedPaths.memoryDb}`);
+      }
+      if (snapshot.cronStoreBefore !== null) {
+        console.log(`  Restored cron jobs`);
+      }
+      console.log("");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Restore failed";
+      console.error(message);
+      process.exit(1);
+    }
+  });
+  configCommand.command("snapshots").description("List available install snapshots").action(async () => {
+    try {
+      const snapshot = await loadLatestSnapshot();
+      if (!snapshot) {
+        console.log("No install snapshots available.");
+        return;
+      }
+      const created = new Date(snapshot.createdAt);
+      const expires = new Date(created.getTime() + 24 * 60 * 60 * 1e3);
+      const formatDate = (d) => d.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "");
+      console.log("");
+      console.log(`  Agent:   ${snapshot.agentId} (${snapshot.agentName})`);
+      console.log(`  Created: ${formatDate(created)}`);
+      console.log(`  Expires: ${formatDate(expires)}`);
+      console.log("");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to list snapshots";
+      console.error(message);
+      process.exit(1);
+    }
+  });
 }
 
 // src/index.ts
 var program = new Command();
-program.name("clawmarketbot").description("CLI tool for ClawMarket - discover, download, and install OpenClaw configs").version("0.1.8");
+program.name("clawmarketbot").description("CLI tool for ClawMarket - discover, download, and install OpenClaw configs").version("0.1.10");
 registerAuthCommands(program);
 registerConfigCommands(program);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmarketbot",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "private": false,
   "description": "CLI tool for ClawMarket - discover, download, and install OpenClaw configs",
   "type": "module",