aiblueprint-cli 1.4.29 → 1.4.31

package/dist/cli.js

@@ -33100,6 +33100,7 @@ function getPlaySoundCommand(soundPath) {
 var KNOWN_CLAUDE_PATHS = [
   /\/Users\/[^/]+\/\.claude\//,
   /\/home\/[^/]+\/\.claude\//,
+  /\/root\/\.claude\//,
   /C:\\Users\\[^\\]+\\\.claude\\/i
 ];
 function transformHookCommand(command, claudeDir) {
@@ -33108,6 +33109,13 @@ function transformHookCommand(command, claudeDir) {
     transformed = transformed.replace(pattern, `${claudeDir}/`);
   }
   transformed = transformed.replace(/\\/g, "/");
+  const isAudioCommand = /^(afplay|paplay|aplay|mpv|ffplay|powershell)\s/.test(transformed);
+  if (isAudioCommand) {
+    const newCommand = transformAudioCommand(transformed, claudeDir);
+    if (newCommand) {
+      return newCommand;
+    }
+  }
   return transformed;
 }
 function transformHook(hook, claudeDir) {
@@ -33151,12 +33159,39 @@ function isTextFile(filePath) {
   const ext = filePath.toLowerCase().slice(filePath.lastIndexOf("."));
   return TEXT_FILE_EXTENSIONS.has(ext);
 }
+function transformAudioCommand(command, claudeDir) {
+  const soundFileMatch = command.match(/(?:finish\.mp3|need-human\.mp3|[^'"\s]+\.(?:mp3|wav))/);
+  if (!soundFileMatch)
+    return null;
+  const soundFile = soundFileMatch[0];
+  let soundPath;
+  if (soundFile.includes("/")) {
+    soundPath = soundFile;
+  } else {
+    soundPath = `${claudeDir}/song/${soundFile}`;
+  }
+  return getPlaySoundCommand(soundPath);
+}
 function transformFileContent(content, claudeDir) {
   let transformed = content;
   for (const pattern of KNOWN_CLAUDE_PATHS) {
     transformed = transformed.replace(new RegExp(pattern.source, "g"), `${claudeDir}/`);
   }
   transformed = transformed.replace(/\\/g, "/");
+  const audioPatterns = [
+    /afplay\s+-v\s+[\d.]+\s+'[^']+'/g,
+    /afplay\s+'[^']+'/g,
+    /paplay\s+'[^']+'/g,
+    /aplay\s+'[^']+'/g,
+    /mpv\s+--no-video[^']*'[^']+'/g,
+    /ffplay\s+-nodisp[^']*'[^']+'/g
+  ];
+  for (const pattern of audioPatterns) {
+    transformed = transformed.replace(pattern, (match) => {
+      const newCommand = transformAudioCommand(match, claudeDir);
+      return newCommand || match;
+    });
+  }
   return transformed;
 }
 
@@ -36046,13 +36081,283 @@ async function backupLoadCommand(options = {}) {
   }
 }
 
-// src/commands/dynamic-scripts.ts
+// src/commands/openclaw-pro.ts
+import os18 from "os";
 import path18 from "path";
-import { homedir } from "os";
 
-// src/lib/script-parser.ts
+// src/lib/openclaw-installer.ts
 var import_fs_extra12 = __toESM(require_lib4(), 1);
+import os16 from "os";
 import path16 from "path";
+import { exec as exec4 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec4);
+var OPENCLAW_PRO_REPO = "Melvynx/openclawpro";
+function getCacheRepoDir2() {
+  return path16.join(os16.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
+}
+async function execGitWithAuth2(command, token, repoUrl, cwd) {
+  const authenticatedUrl = `https://x-access-token:${token}@${repoUrl.replace(/^https?:\/\//, "")}`;
+  const fullCommand = `git ${command.replace(repoUrl, authenticatedUrl)}`;
+  try {
+    await execAsync3(fullCommand, { cwd, timeout: 120000 });
+  } catch (error) {
+    throw new Error(`Git command failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function cloneOrUpdateRepo2(token) {
+  const cacheDir = getCacheRepoDir2();
+  const repoUrl = `https://github.com/${OPENCLAW_PRO_REPO}.git`;
+  if (await import_fs_extra12.default.pathExists(path16.join(cacheDir, ".git"))) {
+    try {
+      await execGitWithAuth2("pull", token, repoUrl, cacheDir);
+    } catch (error) {
+      await import_fs_extra12.default.remove(cacheDir);
+      await import_fs_extra12.default.ensureDir(path16.dirname(cacheDir));
+      await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
+    }
+  } else {
+    await import_fs_extra12.default.ensureDir(path16.dirname(cacheDir));
+    await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
+  }
+  return path16.join(cacheDir, "openclaw-config");
+}
+async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
+  const walk = async (dir, baseDir = dir) => {
+    const entries = await import_fs_extra12.default.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const sourcePath = path16.join(dir, entry.name);
+      const relativePath = path16.relative(baseDir, sourcePath);
+      const targetPath = path16.join(targetDir, relativePath);
+      if (entry.isDirectory()) {
+        await import_fs_extra12.default.ensureDir(targetPath);
+        onProgress?.(relativePath, "directory");
+        await walk(sourcePath, baseDir);
+      } else {
+        await import_fs_extra12.default.copy(sourcePath, targetPath, { overwrite: true });
+        onProgress?.(relativePath, "file");
+      }
+    }
+  };
+  await walk(cacheConfigDir);
+}
+async function installOpenclawProConfigs(options) {
+  const { githubToken, openclawFolder, onProgress } = options;
+  const targetFolder = openclawFolder || path16.join(os16.homedir(), ".openclaw");
+  try {
+    const cacheConfigDir = await cloneOrUpdateRepo2(githubToken);
+    await copyConfigFromCache2(cacheConfigDir, targetFolder, onProgress);
+    return;
+  } catch (error) {
+    throw new Error(`Failed to install OpenClaw Pro configs: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+
+// src/lib/openclaw-token-storage.ts
+var import_fs_extra13 = __toESM(require_lib4(), 1);
+import os17 from "os";
+import path17 from "path";
+function getConfigDir2() {
+  const platform = os17.platform();
+  if (platform === "win32") {
+    return path17.join(process.env.APPDATA || os17.homedir(), "openclaw");
+  }
+  return path17.join(os17.homedir(), ".config", "openclaw");
+}
+function getTokenPath() {
+  return path17.join(getConfigDir2(), "token.txt");
+}
+async function saveOpenclawToken(githubToken) {
+  const configDir = getConfigDir2();
+  await import_fs_extra13.default.ensureDir(configDir);
+  await import_fs_extra13.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
+}
+async function getOpenclawToken() {
+  const tokenPath = getTokenPath();
+  if (await import_fs_extra13.default.pathExists(tokenPath)) {
+    const token = await import_fs_extra13.default.readFile(tokenPath, "utf8");
+    return token.trim();
+  }
+  return null;
+}
+function getOpenclawTokenInfo() {
+  return {
+    path: getTokenPath(),
+    platform: os17.platform()
+  };
+}
+
+// src/commands/openclaw-pro.ts
+var import_fs_extra14 = __toESM(require_lib4(), 1);
+var API_URL2 = "https://codeline.app/api/products";
+var OPENCLAW_PRODUCT_ID = "prd_t2GRwX3aH1";
+async function openclawProActivateCommand(userToken) {
+  Ie(source_default.blue(`\uD83D\uDD11 Activate OpenClaw Pro ${source_default.gray(`v${getVersion()}`)}`));
+  try {
+    if (!userToken) {
+      const result = await he({
+        message: "Enter your OpenClaw Pro access token:",
+        placeholder: "Your ProductsOnUsers ID from codeline.app",
+        validate: (value) => {
+          if (!value)
+            return "Token is required";
+          if (value.length < 5)
+            return "Token seems invalid";
+          return;
+        }
+      });
+      if (pD(result)) {
+        xe("Activation cancelled");
+        process.exit(0);
+      }
+      userToken = result;
+    }
+    const spinner = Y2();
+    spinner.start("Validating token...");
+    const response = await fetch(`${API_URL2}/${OPENCLAW_PRODUCT_ID}/have-access?token=${userToken}`);
+    if (!response.ok) {
+      spinner.stop("Token validation failed");
+      M2.error("Invalid token or no access");
+      M2.info("Get OpenClaw Pro at: https://codeline.app");
+      Se(source_default.red("❌ Activation failed"));
+      process.exit(1);
+    }
+    const data = await response.json();
+    if (!data.hasAccess) {
+      spinner.stop("Token validation failed");
+      M2.error("No access to OpenClaw Pro");
+      Se(source_default.red("❌ Activation failed"));
+      process.exit(1);
+    }
+    spinner.stop("Token validated");
+    const githubToken = data.product.metadata?.["cli-github-token"];
+    if (!githubToken) {
+      M2.error("No GitHub token found in product metadata. Contact support.");
+      Se(source_default.red("❌ Activation failed"));
+      process.exit(1);
+    }
+    spinner.start("Saving token...");
+    await saveOpenclawToken(githubToken);
+    spinner.stop("Token saved");
+    const tokenInfo = getOpenclawTokenInfo();
+    M2.success("✅ Token activated!");
+    M2.info(`User: ${data.user.name} (${data.user.email})`);
+    M2.info(`Product: ${data.product.title}`);
+    M2.info(`Token saved to: ${tokenInfo.path}`);
+    M2.info(source_default.cyan(`
+\uD83D\uDCA1 Next step: Run 'npx aiblueprint-cli@latest openclaw pro setup'`));
+    Se(source_default.green("✅ Activation complete!"));
+  } catch (error) {
+    if (error instanceof Error) {
+      M2.error(error.message);
+    }
+    Se(source_default.red("❌ Activation failed"));
+    process.exit(1);
+  }
+}
+async function openclawProStatusCommand() {
+  Ie(source_default.blue(`\uD83D\uDCCA OpenClaw Pro Status ${source_default.gray(`v${getVersion()}`)}`));
+  try {
+    const token = await getOpenclawToken();
+    if (!token) {
+      M2.warn("No token found");
+      M2.info("Run: npx aiblueprint-cli@latest openclaw pro activate <token>");
+      Se(source_default.yellow("⚠️  Not activated"));
+      process.exit(0);
+    }
+    const tokenInfo = getOpenclawTokenInfo();
+    M2.success("✅ Token active");
+    M2.info(`Token file: ${tokenInfo.path}`);
+    Se(source_default.green("Token is saved"));
+  } catch (error) {
+    if (error instanceof Error) {
+      M2.error(error.message);
+    }
+    Se(source_default.red("❌ Failed to check status"));
+    process.exit(1);
+  }
+}
+async function openclawProSetupCommand(options = {}) {
+  Ie(source_default.blue(`⚙️  Setup OpenClaw Pro ${source_default.gray(`v${getVersion()}`)}`));
+  try {
+    const githubToken = await getOpenclawToken();
+    if (!githubToken) {
+      M2.error("No token found");
+      M2.info("Run: npx aiblueprint-cli@latest openclaw pro activate <token>");
+      Se(source_default.red("❌ Not activated"));
+      process.exit(1);
+    }
+    const openclawDir = options.folder ? path18.resolve(options.folder) : path18.join(os18.homedir(), ".openclaw");
+    const spinner = Y2();
+    const onProgress = (file, type) => {
+      spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
+    };
+    spinner.start("Installing OpenClaw Pro configurations...");
+    await installOpenclawProConfigs({
+      githubToken,
+      openclawFolder: openclawDir,
+      onProgress
+    });
+    spinner.stop("OpenClaw Pro configurations installed");
+    let skillCount = 0;
+    const skillsDir = path18.join(openclawDir, "skills");
+    if (await import_fs_extra14.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra14.default.readdir(skillsDir);
+      const dirs = await Promise.all(items.map(async (item) => {
+        const stat = await import_fs_extra14.default.stat(path18.join(skillsDir, item));
+        return stat.isDirectory();
+      }));
+      skillCount = dirs.filter(Boolean).length;
+    }
+    M2.success("✅ Setup complete!");
+    M2.info("Installed:");
+    M2.info(`  • Skills (${skillCount})`);
+    M2.info(`  • IDENTITY.md`);
+    M2.info(source_default.cyan(`
+\uD83D\uDCA1 Skills installed to: ` + skillsDir));
+    Se(source_default.green("\uD83D\uDE80 OpenClaw Pro ready!"));
+  } catch (error) {
+    if (error instanceof Error) {
+      M2.error(error.message);
+    }
+    Se(source_default.red("❌ Setup failed"));
+    process.exit(1);
+  }
+}
+async function openclawProUpdateCommand(options = {}) {
+  Ie(source_default.blue(`\uD83D\uDD04 Update OpenClaw Pro ${source_default.gray(`v${getVersion()}`)}`));
+  try {
+    const githubToken = await getOpenclawToken();
+    if (!githubToken) {
+      M2.error("No token found");
+      M2.info("Run: npx aiblueprint-cli@latest openclaw pro activate <token>");
+      Se(source_default.red("❌ Not activated"));
+      process.exit(1);
+    }
+    const spinner = Y2();
+    spinner.start("Updating OpenClaw Pro configurations...");
+    await installOpenclawProConfigs({
+      githubToken,
+      openclawFolder: options.folder
+    });
+    spinner.stop("OpenClaw Pro configurations updated");
+    Se(source_default.green("✅ Update completed"));
+  } catch (error) {
+    if (error instanceof Error) {
+      M2.error(error.message);
+    }
+    Se(source_default.red("❌ Update failed"));
+    process.exit(1);
+  }
+}
+
+// src/commands/dynamic-scripts.ts
+import path21 from "path";
+import { homedir } from "os";
+
+// src/lib/script-parser.ts
+var import_fs_extra15 = __toESM(require_lib4(), 1);
+import path19 from "path";
 var EXCLUDED_SCRIPTS = ["test", "lint", "format", "start"];
 var EXCLUDED_SUFFIXES = [":test", ":lint", ":test-fixtures", ":start"];
 function shouldIncludeScript(scriptName) {
@@ -36063,12 +36368,12 @@ function shouldIncludeScript(scriptName) {
   return true;
 }
 async function readScriptsPackageJson(claudeDir) {
-  const packageJsonPath = path16.join(claudeDir, "scripts", "package.json");
+  const packageJsonPath = path19.join(claudeDir, "scripts", "package.json");
   try {
-    if (!await import_fs_extra12.default.pathExists(packageJsonPath)) {
+    if (!await import_fs_extra15.default.pathExists(packageJsonPath)) {
       return null;
     }
-    const content = await import_fs_extra12.default.readFile(packageJsonPath, "utf-8");
+    const content = await import_fs_extra15.default.readFile(packageJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.scripts || null;
   } catch (error) {
@@ -36112,14 +36417,14 @@ function groupScriptsByPrefix(commands) {
 }
 
 // src/commands/script-runner.ts
-var import_fs_extra13 = __toESM(require_lib4(), 1);
+var import_fs_extra16 = __toESM(require_lib4(), 1);
 import { spawn as spawn2 } from "child_process";
 import { execSync as execSync4 } from "child_process";
-import path17 from "path";
-import os16 from "os";
+import path20 from "path";
+import os19 from "os";
 function checkCommand(cmd) {
   try {
-    const isWindows = os16.platform() === "win32";
+    const isWindows = os19.platform() === "win32";
     const whichCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
     execSync4(whichCmd, { stdio: "ignore" });
     return true;
@@ -36145,18 +36450,18 @@ async function executeScript(scriptName, claudeDir) {
     console.error(source_default.red("Bun is not installed. Install with: npm install -g bun"));
     return 1;
   }
-  const scriptsDir = path17.join(claudeDir, "scripts");
-  if (!await import_fs_extra13.default.pathExists(scriptsDir)) {
+  const scriptsDir = path20.join(claudeDir, "scripts");
+  if (!await import_fs_extra16.default.pathExists(scriptsDir)) {
     console.error(source_default.red(`Scripts directory not found at ${scriptsDir}`));
     console.log(source_default.gray("Run: aiblueprint claude-code setup"));
     return 1;
   }
-  const packageJsonPath = path17.join(scriptsDir, "package.json");
-  if (!await import_fs_extra13.default.pathExists(packageJsonPath)) {
+  const packageJsonPath = path20.join(scriptsDir, "package.json");
+  if (!await import_fs_extra16.default.pathExists(packageJsonPath)) {
     console.error(source_default.red(`package.json not found in ${scriptsDir}`));
     return 1;
   }
-  const packageJson = await import_fs_extra13.default.readJson(packageJsonPath);
+  const packageJson = await import_fs_extra16.default.readJson(packageJsonPath);
   if (!packageJson.scripts || !packageJson.scripts[scriptName]) {
     console.error(source_default.red(`Script "${scriptName}" not found in package.json`));
     return 1;
@@ -36179,7 +36484,7 @@ async function executeScript(scriptName, claudeDir) {
 
 // src/commands/dynamic-scripts.ts
 function getClaudeDir(parentOptions) {
-  return parentOptions.claudeCodeFolder || parentOptions.folder ? path18.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path18.join(homedir(), ".claude");
+  return parentOptions.claudeCodeFolder || parentOptions.folder ? path21.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path21.join(homedir(), ".claude");
 }
 async function registerDynamicScriptCommands(claudeCodeCmd, claudeDir) {
   const scripts = await readScriptsPackageJson(claudeDir);
@@ -36268,6 +36573,24 @@ backupCmd.command("load").description("Load a previous backup interactively").ac
   const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
   backupLoadCommand({ folder: claudeCodeFolder });
 });
+var openclawCmd = program2.command("openclaw").description("OpenClaw configuration commands").option("-f, --folder <path>", "Specify custom OpenClaw folder path (default: ~/.openclaw)");
+var openclawProCmd = openclawCmd.command("pro").description("Manage OpenClaw Pro features");
+openclawProCmd.command("activate [token]").description("Activate OpenClaw Pro with your access token").action((token) => {
+  openclawProActivateCommand(token);
+});
+openclawProCmd.command("status").description("Check your OpenClaw Pro token status").action(() => {
+  openclawProStatusCommand();
+});
+openclawProCmd.command("setup").description("Install OpenClaw Pro configurations (requires activation)").action((options, command) => {
+  const parentOptions = command.parent.parent.opts();
+  const folder = parentOptions.folder;
+  openclawProSetupCommand({ folder });
+});
+openclawProCmd.command("update").description("Update OpenClaw Pro configurations").action((options, command) => {
+  const parentOptions = command.parent.parent.opts();
+  const folder = parentOptions.folder;
+  openclawProUpdateCommand({ folder });
+});
 try {
   const claudeDir = join2(homedir2(), ".claude");
   await registerDynamicScriptCommands(claudeCodeCmd, claudeDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiblueprint-cli",
-  "version": "1.4.29",
+  "version": "1.4.31",
   "description": "AIBlueprint CLI for setting up Claude Code configurations",
   "author": "AIBlueprint",
   "license": "MIT",