clawmarketbot 0.1.0 → 0.1.2

package/dist/index.js

@@ -48,6 +48,17 @@ async function askSecret(question) {
   const value = await password({ message: question.trim() || "Secret", mask: true });
   return value.trim();
 }
+async function askOptional(question, hintUrl) {
+  if (hintUrl) {
+    console.log(`  Get one at: ${hintUrl}`);
+  }
+  const value = await input({ message: `${question.trim()} (Enter to skip)`, default: "" });
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+async function confirm(question, defaultYes = true) {
+  return promptConfirm({ message: question, default: defaultYes });
+}
 
 // src/lib/auth-config.ts
 import path from "path";
@@ -201,13 +212,13 @@ Hey ${username}! You're now logged in.
 }
 
 // src/commands/config.ts
-import fs5 from "fs/promises";
-import path4 from "path";
+import fs4 from "fs/promises";
+import path3 from "path";
 import os3 from "os";
-import { createHash as createHash2, randomUUID } from "crypto";
-import { spawn as spawn2 } from "child_process";
+import { createHash, randomUUID } from "crypto";
+import { spawn } from "child_process";
 import JSON52 from "json5";
-import fetch3 from "node-fetch";
+import fetch2 from "node-fetch";
 
 // ../../contracts/token.js
 var CLAWMARKET_DOWNLOAD_TOKEN_PATTERN = "[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}";
@@ -576,112 +587,6 @@ async function loadOpenClawContext() {
   };
 }
 
-// src/lib/npm-install.ts
-import fs4 from "fs/promises";
-import path3 from "path";
-import { createHash } from "crypto";
-import { spawn } from "child_process";
-import fetch2 from "node-fetch";
-function parseNpmPackageSpec(spec) {
-  if (spec.startsWith("@")) {
-    const versionAt2 = spec.indexOf("@", 1);
-    if (versionAt2 === -1) return { packageName: spec, version: "latest" };
-    return {
-      packageName: spec.slice(0, versionAt2),
-      version: spec.slice(versionAt2 + 1) || "latest"
-    };
-  }
-  const versionAt = spec.indexOf("@");
-  if (versionAt === -1) return { packageName: spec, version: "latest" };
-  return {
-    packageName: spec.slice(0, versionAt),
-    version: spec.slice(versionAt + 1) || "latest"
-  };
-}
-async function fetchNpmPackageVersion(packageName, version = "latest") {
-  const encodedName = packageName.startsWith("@") ? `@${encodeURIComponent(packageName.slice(1))}` : encodeURIComponent(packageName);
-  const url = `https://registry.npmjs.org/${encodedName}/${encodeURIComponent(version)}`;
-  const response = await fetch2(url, { headers: { Accept: "application/json" } });
-  if (!response.ok) {
-    if (response.status === 404) {
-      throw new Error(`npm package "${packageName}" not found in the registry.`);
-    }
-    throw new Error(`npm registry request failed: HTTP ${response.status}`);
-  }
-  const data = await response.json();
-  if (!data?.dist?.tarball) {
-    throw new Error(`npm package "${packageName}" has no tarball URL in registry metadata.`);
-  }
-  return data;
-}
-async function downloadNpmTarball(tarballUrl, destPath, expectedShasum) {
-  const response = await fetch2(tarballUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to download tarball: HTTP ${response.status}`);
-  }
-  const bytes = Buffer.from(await response.arrayBuffer());
-  const actual = createHash("sha1").update(bytes).digest("hex");
-  if (actual !== expectedShasum) {
-    throw new Error(
-      `Tarball integrity check failed: expected ${expectedShasum}, got ${actual}.`
-    );
-  }
-  await fs4.writeFile(destPath, bytes);
-}
-async function extractNpmTarball(tarballPath, destDir) {
-  await new Promise((resolve, reject) => {
-    const child = spawn("tar", ["-xzf", tarballPath, "-C", destDir]);
-    let stderr = "";
-    child.stderr?.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", (err) => {
-      if (err.code === "ENOENT") {
-        reject(new Error('"tar" is required to install npm packages but was not found in PATH.'));
-      } else {
-        reject(err);
-      }
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(
-          new Error(`tar exited with code ${code}${stderr.trim() ? `: ${stderr.trim()}` : ""}`)
-        );
-      }
-    });
-  });
-}
-async function findBotZipInExtractedPackage(extractedDir) {
-  const packageRoot = path3.join(extractedDir, "package");
-  async function scan(dir) {
-    let entries;
-    try {
-      entries = await fs4.readdir(dir, { withFileTypes: true });
-    } catch {
-      return null;
-    }
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === "bot.zip") {
-        return path3.join(dir, entry.name);
-      }
-    }
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name.endsWith(".zip")) {
-        return path3.join(dir, entry.name);
-      }
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const found = await scan(path3.join(dir, entry.name));
-      if (found) return found;
-    }
-    return null;
-  }
-  return scan(packageRoot);
-}
-
 // src/commands/config.ts
 function isValidDownloadToken(token) {
   return isClawMarketDownloadToken(token);
@@ -692,13 +597,13 @@ function assertValidDownloadToken(token) {
   }
 }
 async function resolveSafeDownloadPath(targetPath) {
-  const resolved = path4.resolve(targetPath);
+  const resolved = path3.resolve(targetPath);
   if (!await fileExists(resolved)) {
     return { outputPath: resolved, renamed: false };
   }
-  const parsed = path4.parse(resolved);
+  const parsed = path3.parse(resolved);
   for (let i = 1; i <= 1e3; i += 1) {
-    const candidate = path4.join(parsed.dir, `${parsed.name}-${i}${parsed.ext}`);
+    const candidate = path3.join(parsed.dir, `${parsed.name}-${i}${parsed.ext}`);
     if (!await fileExists(candidate)) {
       return { outputPath: candidate, renamed: true };
     }
@@ -709,7 +614,7 @@ function getDefaultServer() {
   return process.env.CLAWMARKET_API_URL || "http://localhost:8000";
 }
 function sha256(content) {
-  return createHash2("sha256").update(content).digest("hex");
+  return createHash("sha256").update(content).digest("hex");
 }
 function verifyDownloadedArtifactChecksum(content, checksumHeader) {
   if (!checksumHeader) return;
@@ -726,7 +631,7 @@ function sanitizeSlugPart(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
 }
 function sanitizeFileName(value) {
-  const base = path4.basename(value || "").replace(/[^A-Za-z0-9._-]/g, "-");
+  const base = path3.basename(value || "").replace(/[^A-Za-z0-9._-]/g, "-");
   return base || "download.bin";
 }
 function parseContentDispositionFileName(headerValue) {
@@ -745,6 +650,17 @@ function parseContentDispositionFileName(headerValue) {
   if (plain?.[1]) return sanitizeFileName(plain[1].trim());
   return null;
 }
+function normalizeCronJobs(raw) {
+  if (Array.isArray(raw)) {
+    return raw.filter((item) => !!item && typeof item === "object");
+  }
+  if (raw && typeof raw === "object" && Array.isArray(raw.jobs)) {
+    return raw.jobs.filter(
+      (item) => !!item && typeof item === "object"
+    );
+  }
+  return [];
+}
 function toStringOrUndefined(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
@@ -762,7 +678,7 @@ async function readJsonError(response) {
   }
 }
 async function fetchDownloadArtifact(server, token) {
-  const response = await fetch3(`${server}/download/${encodeURIComponent(token)}?format=file`, {
+  const response = await fetch2(`${server}/download/${encodeURIComponent(token)}?format=file`, {
     method: "GET"
   });
   if (!response.ok) {
@@ -779,7 +695,7 @@ async function fetchDownloadArtifact(server, token) {
 }
 async function runCommand(command, args, options = {}) {
   return new Promise((resolve, reject) => {
-    const child = spawn2(command, args, {
+    const child = spawn(command, args, {
       cwd: options.cwd,
       stdio: options.stdio === "inherit" ? "inherit" : "pipe"
     });
@@ -829,73 +745,251 @@ async function extractZipArtifact(artifactPath, destinationDir) {
     throw error;
   }
 }
-async function findInstallerPackage(rootDir) {
-  const queue = [path4.resolve(rootDir)];
+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");
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "invalid JSON";
+    throw new Error(`Package config is invalid JSON (${configPath}): ${reason}`);
+  }
+}
+function resolveInstallPaths(botConfig, agentId, stateDir, sourceBase) {
+  function applyTemplate(tpl) {
+    return tpl.replace(/\{agent_id\}/g, agentId);
+  }
+  const srcWorkspace = botConfig.paths?.workspace ?? `workspace-${agentId}`;
+  const srcAgentState = botConfig.paths?.agentState ?? `agents/${agentId}`;
+  const srcMemoryDb = botConfig.paths?.memoryDb ?? null;
+  const srcCronJobs = botConfig.paths?.cronJobs ?? null;
+  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));
+  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)),
+    targetAgentRoot,
+    targetAgentDir: path3.join(targetAgentRoot, "agent"),
+    targetMemoryDb: tplMemoryDb ? path3.join(stateDir, applyTemplate(tplMemoryDb)) : null
+  };
+}
+async function findSourceRoot(extractedDir) {
+  const queue = [path3.resolve(extractedDir)];
   const seen = /* @__PURE__ */ new Set();
   while (queue.length > 0) {
     const current = queue.shift();
     if (!current || seen.has(current)) continue;
     seen.add(current);
-    const rootInstallerPath = path4.join(current, "installer.sh");
-    const sourceInstallerPath = path4.join(current, "source", "installer.sh");
-    const configPath = path4.join(current, "source", "bot-config.json");
-    if (await fileExists(rootInstallerPath) && await fileExists(configPath)) {
-      return {
-        packageRoot: current,
-        installerPath: rootInstallerPath,
-        botConfigPath: configPath,
-        layout: "root-installer"
-      };
-    }
-    if (await fileExists(sourceInstallerPath) && await fileExists(configPath)) {
-      return {
-        packageRoot: current,
-        installerPath: sourceInstallerPath,
-        botConfigPath: configPath,
-        layout: "source-installer"
-      };
+    if (await fileExists(path3.join(current, "source", "bot-config.json"))) {
+      return current;
     }
     let entries;
     try {
-      entries = await fs5.readdir(current, { withFileTypes: true });
+      entries = await fs4.readdir(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (entry.name === "." || entry.name === "..") continue;
-      queue.push(path4.join(current, entry.name));
+      if (!entry.isDirectory() || entry.name === "__MACOSX") continue;
+      queue.push(path3.join(current, entry.name));
     }
   }
   return null;
 }
-async function ensureInstallableLayout(pkg) {
-  if (pkg.layout === "root-installer") {
-    return {
-      packageRoot: pkg.packageRoot,
-      installerScriptName: "installer.sh",
-      botConfigPath: pkg.botConfigPath
-    };
+async function copyDirRecursive(src, dest) {
+  await fs4.mkdir(dest, { recursive: true });
+  const entries = await fs4.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirRecursive(srcPath, destPath);
+    } else {
+      await fs4.copyFile(srcPath, destPath);
+    }
+  }
+}
+async function stripMacOsJunk(dir) {
+  const macosDir = path3.join(dir, "__MACOSX");
+  await fs4.rm(macosDir, { recursive: true, force: true }).catch(() => void 0);
+  async function removeDsStore(d) {
+    let entries;
+    try {
+      entries = await fs4.readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path3.join(d, entry.name);
+      if (entry.isFile() && entry.name === ".DS_Store") {
+        await fs4.rm(full, { force: true }).catch(() => void 0);
+      } else if (entry.isDirectory()) {
+        await removeDsStore(full);
+      }
+    }
+  }
+  await removeDsStore(dir);
+}
+async function buildOpenClawConfigPatch(configPath, agentId, agentName, botConfig, installPaths) {
+  const raw = await fs4.readFile(configPath, "utf-8");
+  const config = JSON52.parse(raw);
+  const agentEntry = {
+    id: agentId,
+    name: agentName,
+    workspace: installPaths.targetWorkspace,
+    agentDir: installPaths.targetAgentDir
+  };
+  if (botConfig.agent?.heartbeat) agentEntry.heartbeat = botConfig.agent.heartbeat;
+  if (botConfig.agent?.identity) agentEntry.identity = botConfig.agent.identity;
+  const agents = config.agents ?? {};
+  if (!Array.isArray(agents.list)) agents.list = [];
+  agents.list.push(agentEntry);
+  config.agents = agents;
+  if (botConfig.tools?.web?.search?.enabled === true || botConfig.tools?.web?.fetch?.enabled === true) {
+    const tools = config.tools ?? {};
+    const web = tools.web ?? {};
+    if (botConfig.tools?.web?.search?.enabled === true) {
+      const s = web.search ?? {};
+      s.enabled = true;
+      web.search = s;
+    }
+    if (botConfig.tools?.web?.fetch?.enabled === true) {
+      const f = web.fetch ?? {};
+      f.enabled = true;
+      web.fetch = f;
+    }
+    tools.web = web;
+    config.tools = tools;
   }
-  const promotedInstallerPath = path4.join(pkg.packageRoot, "installer.sh");
-  await fs5.copyFile(pkg.installerPath, promotedInstallerPath);
-  await fs5.chmod(promotedInstallerPath, 493).catch(() => void 0);
   return {
-    packageRoot: pkg.packageRoot,
-    installerScriptName: "installer.sh",
-    botConfigPath: pkg.botConfigPath
+    configContent: JSON.stringify(config, null, 2) + "\n",
+    configBackupContent: raw
   };
 }
-async function readBotInstallerConfig(configPath) {
-  if (!await fileExists(configPath)) {
-    throw new Error(`Package is missing required config file: ${configPath}`);
+async function prepareCronJobsFromBundle(sourceCronPath, cronStorePath, agentId) {
+  if (!sourceCronPath || !await fileExists(sourceCronPath)) return null;
+  const raw = await fs4.readFile(sourceCronPath, "utf-8");
+  const bundleJobs = normalizeCronJobs(JSON.parse(raw));
+  if (bundleJobs.length === 0) return null;
+  const shouldInstall = await resolveCronChoice(true);
+  if (!shouldInstall) return null;
+  const newJobs = bundleJobs.map((j) => ({
+    ...j,
+    agentId,
+    state: {},
+    delivery: { mode: "announce", channel: "last", bestEffort: true }
+  }));
+  let existed = false;
+  let backupContent = null;
+  let existingJobs = [];
+  if (await fileExists(cronStorePath)) {
+    existed = true;
+    backupContent = await fs4.readFile(cronStorePath, "utf-8");
+    existingJobs = normalizeCronJobs(JSON52.parse(backupContent));
   }
-  const raw = await fs5.readFile(configPath, "utf-8");
-  try {
-    return JSON.parse(raw);
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : "invalid JSON";
-    throw new Error(`Package config is invalid JSON (${configPath}): ${reason}`);
+  const existingKeys = new Set(
+    existingJobs.map((j) => `${String(j.agentId)}::${String(j.name)}`)
+  );
+  const deduped = newJobs.filter(
+    (j) => !existingKeys.has(`${String(j.agentId)}::${String(j.name)}`)
+  );
+  if (deduped.length === 0) {
+    console.log("All cron jobs already present, skipping.");
+    return null;
+  }
+  const merged = [...existingJobs, ...deduped];
+  return {
+    content: JSON.stringify({ version: 1, jobs: merged }, null, 2) + "\n",
+    existed,
+    backupContent,
+    jobCount: deduped.length
+  };
+}
+async function setupApiKeysFromConfig(botConfig, configPath, envPath) {
+  if (!botConfig.apiKeys?.enabled) return;
+  console.log("");
+  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("  API Key Setup");
+  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("  You can skip any key now and add it later.");
+  const brave = botConfig.apiKeys.braveSearch;
+  if (brave?.enabled) {
+    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 config = JSON52.parse(raw);
+      const tools = config.tools ?? {};
+      const web = tools.web ?? {};
+      const search = web.search ?? {};
+      search.apiKey = key;
+      web.search = search;
+      tools.web = web;
+      config.tools = tools;
+      await fs4.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.");
+    }
+  }
+  const envKeys = botConfig.apiKeys.env ?? [];
+  if (envKeys.length > 0) {
+    await fs4.mkdir(path3.dirname(envPath), { recursive: true });
+    let envContent = "";
+    try {
+      envContent = await fs4.readFile(envPath, "utf-8");
+    } catch {
+    }
+    let keysWritten = 0;
+    for (const keyDef of envKeys) {
+      console.log("");
+      const val = await askOptional(keyDef.prompt ?? keyDef.key, keyDef.url);
+      if (val) {
+        const regex = new RegExp(`^${keyDef.key}=.*$`, "m");
+        if (regex.test(envContent)) {
+          envContent = envContent.replace(regex, `${keyDef.key}=${val}`);
+        } else {
+          envContent = envContent.trimEnd() + `
+${keyDef.key}=${val}`;
+        }
+        keysWritten++;
+      }
+    }
+    if (keysWritten > 0) {
+      await fs4.writeFile(envPath, envContent.trim() + "\n", "utf-8");
+      console.log(`
+  ${keysWritten} key(s) saved to .env`);
+    }
+  }
+}
+async function validateInstalledWorkspace(workspacePath, botConfig) {
+  const requiredFiles = botConfig.validation?.requiredFiles ?? [];
+  const requiredDirs = botConfig.validation?.requiredDirs ?? [];
+  if (requiredFiles.length === 0 && requiredDirs.length === 0) return;
+  const warnings = [];
+  for (const file of requiredFiles) {
+    if (!await fileExists(path3.join(workspacePath, file))) {
+      warnings.push(`Missing expected file: ${file}`);
+    }
+  }
+  for (const dir of requiredDirs) {
+    try {
+      const stat = await fs4.stat(path3.join(workspacePath, dir));
+      if (!stat.isDirectory()) warnings.push(`Expected directory but found file: ${dir}`);
+    } catch {
+      warnings.push(`Missing expected directory: ${dir}`);
+    }
+  }
+  if (warnings.length > 0) {
+    console.log("\nValidation warnings:");
+    for (const w of warnings) console.warn(`  \u26A0  ${w}`);
   }
 }
 async function resolveAgentId(suggestedAgentId) {
@@ -909,13 +1003,64 @@ async function resolveAgentId(suggestedAgentId) {
   }
   return prompted;
 }
+async function resolveCronChoice(hasPackagedCronJobs) {
+  if (!hasPackagedCronJobs) return false;
+  const canPrompt = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (!canPrompt) {
+    throw new Error("Install requires an interactive terminal to confirm cron job installation.");
+  }
+  return confirm("Install packaged cron jobs for this new agent?", true);
+}
+async function commitInstallTransaction(input2) {
+  let movedWorkspace = false;
+  let movedAgentDir = false;
+  let copiedMemoryDb = false;
+  try {
+    await fs4.mkdir(path3.dirname(input2.workspacePath), { recursive: true });
+    await fs4.rename(input2.stagedWorkspacePath, input2.workspacePath);
+    movedWorkspace = true;
+    await fs4.mkdir(path3.dirname(input2.agentDirPath), { recursive: true });
+    await fs4.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);
+      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 fs4.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);
+      } else {
+        await fs4.rm(input2.cronStorePath, { force: true }).catch(() => void 0);
+      }
+    }
+    if (copiedMemoryDb && input2.memoryDbTargetPath) {
+      await fs4.rm(input2.memoryDbTargetPath, { force: true }).catch(() => void 0);
+    }
+    await fs4.writeFile(input2.configPath, input2.configBackupContent, "utf-8").catch(() => void 0);
+    if (movedWorkspace) {
+      await fs4.rm(input2.workspacePath, { recursive: true, force: true }).catch(() => void 0);
+    }
+    if (movedAgentDir) {
+      await fs4.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}`);
+  }
+}
 function registerConfigCommands(program2) {
   const configCommand = program2.command("config").description("Download and install published configs");
   configCommand.command("download").description("Download a published config artifact from a one-time token").argument("<token>", "One-time download token").action(async (token) => {
     try {
       assertValidDownloadToken(token);
       const server = getDefaultServer();
-      const response = await fetch3(`${server}/download/${encodeURIComponent(token)}?format=file`, {
+      const response = await fetch2(`${server}/download/${encodeURIComponent(token)}?format=file`, {
         method: "GET"
       });
       if (!response.ok) {
@@ -923,12 +1068,12 @@ function registerConfigCommands(program2) {
       }
       const fileFromHeader = parseContentDispositionFileName(response.headers.get("content-disposition"));
       const fallbackFile = `clawmarket-${token}.bin`;
-      const preferredPath = path4.resolve(fileFromHeader || fallbackFile);
+      const preferredPath = path3.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 fs5.mkdir(path4.dirname(outputPath), { recursive: true });
-      await fs5.writeFile(outputPath, bytes);
+      await fs4.mkdir(path3.dirname(outputPath), { recursive: true });
+      await fs4.writeFile(outputPath, bytes);
       if (renamed) {
         console.log(`Existing file detected, saved as: ${outputPath}`);
       }
@@ -945,21 +1090,24 @@ function registerConfigCommands(program2) {
       const server = getDefaultServer();
       const context = await loadOpenClawContext();
       const artifact = await fetchDownloadArtifact(server, token);
-      const tempRoot = await fs5.mkdtemp(path4.join(os3.tmpdir(), `.clawmarket-install-${randomUUID().slice(0, 8)}-`));
+      const tempRoot = await fs4.mkdtemp(
+        path3.join(os3.tmpdir(), `.clawmarket-install-${randomUUID().slice(0, 8)}-`)
+      );
       try {
-        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);
+        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);
         await extractZipArtifact(artifactPath, extractedPath);
-        const packageInfo = await findInstallerPackage(extractedPath);
-        if (!packageInfo) {
+        await stripMacOsJunk(extractedPath);
+        const sourceRoot = await findSourceRoot(extractedPath);
+        if (!sourceRoot) {
           throw new Error(
-            "Downloaded artifact is not an installable bot package (missing installer.sh + source/bot-config.json or source/installer.sh + source/bot-config.json)."
+            "Downloaded artifact is not an installable bot package (missing source/bot-config.json)."
           );
         }
-        const installLayout = await ensureInstallableLayout(packageInfo);
-        const botConfig = await readBotInstallerConfig(installLayout.botConfigPath);
+        const sourceBase = path3.join(sourceRoot, "source");
+        const botConfig = await readBotInstallerConfig(path3.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).`
@@ -969,110 +1117,77 @@ function registerConfigCommands(program2) {
         const suggestedAgentId = validateAgentId(configuredAgentId) ? configuredAgentId : sanitizeSlugPart(configuredAgentId) || "agent";
         const agentId = await resolveAgentId(suggestedAgentId);
         const agentName = toStringOrUndefined(botConfig.agent?.name) || agentId;
-        const existing = new Set(context.agents.map((agent) => agent.id.toLowerCase()));
-        if (existing.has(agentId.toLowerCase())) {
+        const existingIds = new Set(context.agents.map((a) => a.id.toLowerCase()));
+        if (existingIds.has(agentId.toLowerCase())) {
           throw new Error(`Agent id "${agentId}" already exists. Choose another id.`);
         }
-        console.log("Running packaged installer...");
-        await runCommand(
-          "bash",
-          [installLayout.installerScriptName, "--agent-id", agentId, "--agent-name", agentName, context.paths.stateDir],
-          { cwd: installLayout.packageRoot, stdio: "inherit" }
+        const installPaths = resolveInstallPaths(botConfig, agentId, context.paths.stateDir, sourceBase);
+        const stagedWorkspacePath = path3.join(tempRoot, "staged-workspace");
+        const stagedAgentDirPath = path3.join(tempRoot, "staged-agent");
+        await copyDirRecursive(installPaths.sourceWorkspace, stagedWorkspacePath);
+        await copyDirRecursive(installPaths.sourceAgentState, stagedAgentDirPath);
+        const { configContent, configBackupContent } = await buildOpenClawConfigPatch(
+          context.paths.configPath,
+          agentId,
+          agentName,
+          botConfig,
+          installPaths
+        );
+        const cronResult = await prepareCronJobsFromBundle(
+          installPaths.sourceCronJobs,
+          context.paths.cronStorePath,
+          agentId
         );
+        console.log("\nInstalling...");
+        await commitInstallTransaction({
+          stagedWorkspacePath,
+          stagedAgentDirPath,
+          workspacePath: installPaths.targetWorkspace,
+          agentDirPath: installPaths.targetAgentDir,
+          agentRootPath: installPaths.targetAgentRoot,
+          configPath: context.paths.configPath,
+          configContent,
+          configBackupContent,
+          cronStorePath: context.paths.cronStorePath,
+          cronContent: cronResult?.content ?? null,
+          cronExisted: cronResult?.existed ?? false,
+          cronBackupContent: cronResult?.backupContent ?? null,
+          memoryDbStagedPath: installPaths.sourceMemoryDb,
+          memoryDbTargetPath: installPaths.targetMemoryDb
+        });
+        await setupApiKeysFromConfig(botConfig, context.paths.configPath, context.paths.envPath);
+        const installerShPath = path3.join(sourceBase, "installer.sh");
+        if (await fileExists(installerShPath)) {
+          console.log("\nRunning post-install hook (installer.sh)...");
+          await runCommand("bash", [installerShPath, context.paths.stateDir], {
+            cwd: sourceBase,
+            stdio: "inherit"
+          });
+        }
+        await validateInstalledWorkspace(installPaths.targetWorkspace, botConfig);
         const refreshed = await loadOpenClawContext();
-        const installed = refreshed.agents.find((agent) => agent.id.toLowerCase() === agentId.toLowerCase());
+        const installed = refreshed.agents.find((a) => a.id.toLowerCase() === agentId.toLowerCase());
         if (!installed) {
-          throw new Error("Installer finished, but the new agent was not detected in openclaw.json.");
+          throw new Error("Install finished, but the new agent was not detected in openclaw.json.");
         }
-        console.log("Installed package into OpenClaw as an additional agent");
-        console.log(`  Agent ID: ${installed.id}`);
-        console.log(`  Name: ${installed.name}`);
+        console.log("\n\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("  Installed successfully into OpenClaw");
+        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(`  Agent ID:  ${installed.id}`);
+        console.log(`  Name:      ${installed.name}`);
         console.log(`  Workspace: ${installed.workspace}`);
         console.log(`  Agent Dir: ${installed.agentDir}`);
-        console.log("\nNext steps:");
-        console.log("  1) openclaw agents list");
-        console.log("  2) openclaw gateway restart");
-      } finally {
-        await fs5.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Install failed";
-      console.error(message);
-      process.exit(1);
-    }
-  });
-  configCommand.command("install-npm").description("Install a bot config from an npm package (e.g. @clawmarket/my-bot)").argument("<package>", "npm package name, optionally with version (e.g. @clawmarket/my-bot or @clawmarket/my-bot@1.2.0)").action(async (packageSpec) => {
-    try {
-      const { packageName, version } = parseNpmPackageSpec(packageSpec);
-      console.log(`Looking up ${packageSpec} in the npm registry...`);
-      const context = await loadOpenClawContext();
-      const pkgMeta = await fetchNpmPackageVersion(packageName, version);
-      console.log(`Found ${pkgMeta.name}@${pkgMeta.version}`);
-      const tempRoot = await fs5.mkdtemp(
-        path4.join(os3.tmpdir(), `.clawmarket-npm-${randomUUID().slice(0, 8)}-`)
-      );
-      try {
-        const tarballPath = path4.join(tempRoot, "package.tgz");
-        console.log("Downloading package...");
-        await downloadNpmTarball(pkgMeta.dist.tarball, tarballPath, pkgMeta.dist.shasum);
-        const npmExtractedPath = path4.join(tempRoot, "npm-extracted");
-        await fs5.mkdir(npmExtractedPath, { recursive: true });
-        await extractNpmTarball(tarballPath, npmExtractedPath);
-        const botZipPath = await findBotZipInExtractedPackage(npmExtractedPath);
-        if (!botZipPath) {
-          throw new Error(
-            `npm package "${pkgMeta.name}" does not contain a bot.zip. Expected a bot.zip at the package root inside the tarball.`
-          );
-        }
-        const botZipFileName = sanitizeFileName(path4.basename(botZipPath));
-        const stagedZipPath = path4.join(tempRoot, botZipFileName);
-        await fs5.copyFile(botZipPath, stagedZipPath);
-        const botExtractedPath = path4.join(tempRoot, "bot-extracted");
-        await fs5.mkdir(botExtractedPath, { recursive: true });
-        await extractZipArtifact(stagedZipPath, botExtractedPath);
-        const packageInfo = await findInstallerPackage(botExtractedPath);
-        if (!packageInfo) {
-          throw new Error(
-            "Bot zip is not an installable package (missing installer.sh + source/bot-config.json)."
-          );
+        if (cronResult) {
+          console.log(`  Cron jobs: ${cronResult.jobCount} installed`);
         }
-        const installLayout = await ensureInstallableLayout(packageInfo);
-        const botConfig = await readBotInstallerConfig(installLayout.botConfigPath);
-        if (typeof botConfig.installerSpecVersion === "number" && botConfig.installerSpecVersion !== 1) {
-          console.warn(
-            `Warning: installerSpecVersion=${botConfig.installerSpecVersion} (this CLI currently expects version 1).`
-          );
+        if (installPaths.targetMemoryDb && await fileExists(installPaths.targetMemoryDb)) {
+          console.log(`  Memory DB: ${installPaths.targetMemoryDb}`);
         }
-        const configuredAgentId = toStringOrUndefined(botConfig.agent?.id) || "agent";
-        const suggestedAgentId = validateAgentId(configuredAgentId) ? configuredAgentId : sanitizeSlugPart(configuredAgentId) || "agent";
-        const agentId = await resolveAgentId(suggestedAgentId);
-        const agentName = toStringOrUndefined(botConfig.agent?.name) || agentId;
-        const existing = new Set(context.agents.map((agent) => agent.id.toLowerCase()));
-        if (existing.has(agentId.toLowerCase())) {
-          throw new Error(`Agent id "${agentId}" already exists. Choose another id.`);
-        }
-        console.log("Running packaged installer...");
-        await runCommand(
-          "bash",
-          [installLayout.installerScriptName, "--agent-id", agentId, "--agent-name", agentName, context.paths.stateDir],
-          { cwd: installLayout.packageRoot, stdio: "inherit" }
-        );
-        const refreshed = await loadOpenClawContext();
-        const installed = refreshed.agents.find((agent) => agent.id.toLowerCase() === agentId.toLowerCase());
-        if (!installed) {
-          throw new Error("Installer finished, but the new agent was not detected in openclaw.json.");
-        }
-        console.log(`
-Installed ${pkgMeta.name}@${pkgMeta.version} into OpenClaw as a new agent`);
-        console.log(`  Agent ID: ${installed.id}`);
-        console.log(`  Name: ${installed.name}`);
-        console.log(`  Workspace: ${installed.workspace}`);
-        console.log(`  Agent Dir: ${installed.agentDir}`);
         console.log("\nNext steps:");
         console.log("  1) openclaw agents list");
         console.log("  2) openclaw gateway restart");
       } finally {
-        await fs5.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
+        await fs4.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Install failed";

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "clawmarketbot",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "description": "CLI tool for ClawMarket - discover, download, and install OpenClaw configs",
   "type": "module",
   "bin": {
-    "clawmarketbot": "./dist/index.js"
+    "clawmarketbot": "dist/index.js"
   },
   "main": "./dist/index.js",
   "exports": {