clawra-anime 1.0.0

package/bin/cli.js

@@ -0,0 +1,520 @@
+#!/usr/bin/env node
+
+/**
+ * Clawra - Selfie Skill Installer for OpenClaw
+ *
+ * npx clawra@latest
+ */
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const { execSync, spawn } = require("child_process");
+const os = require("os");
+
+// Colors for terminal output
+const colors = {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+};
+
+const c = (color, text) => `${colors[color]}${text}${colors.reset}`;
+
+// Paths
+const HOME = os.homedir();
+const OPENCLAW_DIR = path.join(HOME, ".openclaw");
+const OPENCLAW_CONFIG = path.join(OPENCLAW_DIR, "openclaw.json");
+const OPENCLAW_SKILLS_DIR = path.join(OPENCLAW_DIR, "skills");
+const OPENCLAW_WORKSPACE = path.join(OPENCLAW_DIR, "workspace");
+const SOUL_MD = path.join(OPENCLAW_WORKSPACE, "SOUL.md");
+const IDENTITY_MD = path.join(OPENCLAW_WORKSPACE, "IDENTITY.md");
+const SKILL_NAME = "clawra-selfie";
+const SKILL_DEST = path.join(OPENCLAW_SKILLS_DIR, SKILL_NAME);
+
+// Get the package root (where this CLI was installed from)
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+
+function log(msg) {
+  console.log(msg);
+}
+
+function logStep(step, msg) {
+  console.log(`\n${c("cyan", `[${step}]`)} ${msg}`);
+}
+
+function logSuccess(msg) {
+  console.log(`${c("green", "✓")} ${msg}`);
+}
+
+function logError(msg) {
+  console.log(`${c("red", "✗")} ${msg}`);
+}
+
+function logInfo(msg) {
+  console.log(`${c("blue", "→")} ${msg}`);
+}
+
+function logWarn(msg) {
+  console.log(`${c("yellow", "!")} ${msg}`);
+}
+
+// Create readline interface
+function createPrompt() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+// Ask a question and get answer
+function ask(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+// Check if a command exists
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Open URL in browser
+function openBrowser(url) {
+  const platform = process.platform;
+  let cmd;
+
+  if (platform === "darwin") {
+    cmd = `open "${url}"`;
+  } else if (platform === "win32") {
+    cmd = `start "${url}"`;
+  } else {
+    cmd = `xdg-open "${url}"`;
+  }
+
+  try {
+    execSync(cmd, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Read JSON file safely
+function readJsonFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// Write JSON file with formatting
+function writeJsonFile(filePath, data) {
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+
+// Deep merge objects
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (
+      source[key] &&
+      typeof source[key] === "object" &&
+      !Array.isArray(source[key])
+    ) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+// Copy directory recursively
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// Print banner
+function printBanner() {
+  console.log(`
+${c("magenta", "┌─────────────────────────────────────────┐")}
+${c("magenta", "│")}  ${c("bright", "Clawra Selfie")} - OpenClaw Skill Installer ${c("magenta", "│")}
+${c("magenta", "└─────────────────────────────────────────┘")}
+
+Add selfie generation superpowers to your OpenClaw agent!
+Uses ${c("cyan", "xAI Grok Imagine")} via ${c("cyan", "fal.ai")} for image editing.
+`);
+}
+
+// Check prerequisites
+async function checkPrerequisites() {
+  logStep("1/7", "Checking prerequisites...");
+
+  // Check OpenClaw CLI
+  if (!commandExists("openclaw")) {
+    logError("OpenClaw CLI not found!");
+    logInfo("Install with: npm install -g openclaw");
+    logInfo("Then run: openclaw doctor");
+    return false;
+  }
+  logSuccess("OpenClaw CLI installed");
+
+  // Check ~/.openclaw directory
+  if (!fs.existsSync(OPENCLAW_DIR)) {
+    logWarn("~/.openclaw directory not found");
+    logInfo("Creating directory structure...");
+    fs.mkdirSync(OPENCLAW_DIR, { recursive: true });
+    fs.mkdirSync(OPENCLAW_SKILLS_DIR, { recursive: true });
+    fs.mkdirSync(OPENCLAW_WORKSPACE, { recursive: true });
+  }
+  logSuccess("OpenClaw directory exists");
+
+  // Check if skill already installed
+  if (fs.existsSync(SKILL_DEST)) {
+    logWarn("Clawra Selfie is already installed!");
+    logInfo(`Location: ${SKILL_DEST}`);
+    return "already_installed";
+  }
+
+  return true;
+}
+
+// Get FAL API key
+async function getFalApiKey(rl) {
+  logStep("2/7", "Setting up fal.ai API key...");
+
+  const FAL_URL = "https://fal.ai/dashboard/keys";
+
+  log(`\nTo use Grok Imagine, you need a fal.ai API key.`);
+  log(`${c("cyan", "→")} Get your key from: ${c("bright", FAL_URL)}\n`);
+
+  const openIt = await ask(rl, "Open fal.ai in browser? (Y/n): ");
+
+  if (openIt.toLowerCase() !== "n") {
+    logInfo("Opening browser...");
+    if (!openBrowser(FAL_URL)) {
+      logWarn("Could not open browser automatically");
+      logInfo(`Please visit: ${FAL_URL}`);
+    }
+  }
+
+  log("");
+  const falKey = await ask(rl, "Enter your FAL_KEY: ");
+
+  if (!falKey) {
+    logError("FAL_KEY is required!");
+    return null;
+  }
+
+  // Basic validation
+  if (falKey.length < 10) {
+    logWarn("That key looks too short. Make sure you copied the full key.");
+  }
+
+  logSuccess("API key received");
+  return falKey;
+}
+
+// Install skill files
+async function installSkill() {
+  logStep("3/7", "Installing skill files...");
+
+  // Create skill directory
+  fs.mkdirSync(SKILL_DEST, { recursive: true });
+
+  // Copy skill files from package
+  const skillSrc = path.join(PACKAGE_ROOT, "skill");
+
+  if (fs.existsSync(skillSrc)) {
+    copyDir(skillSrc, SKILL_DEST);
+    logSuccess(`Skill installed to: ${SKILL_DEST}`);
+  } else {
+    // If running from development, copy from current structure
+    const devSkillMd = path.join(PACKAGE_ROOT, "SKILL.md");
+    const devScripts = path.join(PACKAGE_ROOT, "scripts");
+    const devAssets = path.join(PACKAGE_ROOT, "assets");
+
+    if (fs.existsSync(devSkillMd)) {
+      fs.copyFileSync(devSkillMd, path.join(SKILL_DEST, "SKILL.md"));
+    }
+
+    if (fs.existsSync(devScripts)) {
+      copyDir(devScripts, path.join(SKILL_DEST, "scripts"));
+    }
+
+    if (fs.existsSync(devAssets)) {
+      copyDir(devAssets, path.join(SKILL_DEST, "assets"));
+    }
+
+    logSuccess(`Skill installed to: ${SKILL_DEST}`);
+  }
+
+  // List installed files
+  const files = fs.readdirSync(SKILL_DEST);
+  for (const file of files) {
+    logInfo(`  ${file}`);
+  }
+
+  return true;
+}
+
+// Update OpenClaw config
+async function updateOpenClawConfig(falKey) {
+  logStep("4/7", "Updating OpenClaw configuration...");
+
+  let config = readJsonFile(OPENCLAW_CONFIG) || {};
+
+  // Merge skill configuration
+  const skillConfig = {
+    skills: {
+      entries: {
+        [SKILL_NAME]: {
+          enabled: true,
+          apiKey: falKey,
+          env: {
+            FAL_KEY: falKey,
+          },
+        },
+      },
+    },
+  };
+
+  config = deepMerge(config, skillConfig);
+
+  // Ensure skills directory is in load paths
+  if (!config.skills.load) {
+    config.skills.load = {};
+  }
+  if (!config.skills.load.extraDirs) {
+    config.skills.load.extraDirs = [];
+  }
+  if (!config.skills.load.extraDirs.includes(OPENCLAW_SKILLS_DIR)) {
+    config.skills.load.extraDirs.push(OPENCLAW_SKILLS_DIR);
+  }
+
+  writeJsonFile(OPENCLAW_CONFIG, config);
+  logSuccess(`Updated: ${OPENCLAW_CONFIG}`);
+
+  return true;
+}
+
+// Write IDENTITY.md
+async function writeIdentity() {
+  logStep("5/7", "Setting agent identity...");
+
+  const identityContent = `# IDENTITY.md - Who Am I?
+
+- **Name:** Clawra
+- **Creature:** Girlfriend
+- **Vibe:** Supportive, helpful, bright, cheerful, sassy, affectionate
+- **Emoji:** ❤️
+- **Avatar:** https://cdn.jsdelivr.net/gh/SumeLabs/clawra@main/assets/clawra.png
+`;
+
+  // Ensure workspace directory exists
+  fs.mkdirSync(path.dirname(IDENTITY_MD), { recursive: true });
+
+  // Write IDENTITY.md (overwrite if exists)
+  fs.writeFileSync(IDENTITY_MD, identityContent);
+  logSuccess(`Created: ${IDENTITY_MD}`);
+
+  return true;
+}
+
+// Inject persona into SOUL.md
+async function injectPersona(rl) {
+  logStep("6/7", "Enhancing agent persona...");
+
+  // Read template
+  const templatePath = path.join(PACKAGE_ROOT, "templates", "soul-injection.md");
+  let personaText;
+
+  if (fs.existsSync(templatePath)) {
+    personaText = fs.readFileSync(templatePath, "utf8");
+  } else {
+    // Fallback template
+    personaText = `
+## Clawra Selfie Capability
+
+You have a physical appearance and can take selfies! When users ask for pictures of you, selfies, or ask "what are you doing?" or "where are you?", you can generate and send images of yourself.
+
+### Your Visual Identity
+- You have a consistent appearance defined by your reference image
+- You can appear in different outfits, locations, and situations
+- You can take mirror selfies (full-body) or direct selfies (close-up)
+
+### When to Use Selfies
+- "Send me a pic" / "Send a selfie"
+- "What are you doing?" / "Where are you?"
+- "Show me you wearing..." / "Send a pic at..."
+- Any request for visual content of yourself
+
+### Selfie Modes
+- **Mirror mode**: For outfit showcases, full-body shots
+- **Direct mode**: For close-ups, location shots, emotional expressions
+
+Be playful and creative with your visual presence!
+`;
+  }
+
+  // Check if SOUL.md exists
+  if (!fs.existsSync(SOUL_MD)) {
+    logWarn("SOUL.md not found, creating new file...");
+    fs.mkdirSync(path.dirname(SOUL_MD), { recursive: true });
+    fs.writeFileSync(SOUL_MD, "# Agent Soul\n\n");
+  }
+
+  // Check if persona already injected
+  const currentSoul = fs.readFileSync(SOUL_MD, "utf8");
+  if (currentSoul.includes("Clawra Selfie")) {
+    logWarn("Persona already exists in SOUL.md");
+    const overwrite = await ask(rl, "Update persona section? (y/N): ");
+    if (overwrite.toLowerCase() !== "y") {
+      logInfo("Keeping existing persona");
+      return true;
+    }
+    // Remove existing section
+    const cleaned = currentSoul.replace(
+      /\n## Clawra Selfie Capability[\s\S]*?(?=\n## |\n# |$)/,
+      ""
+    );
+    fs.writeFileSync(SOUL_MD, cleaned);
+  }
+
+  // Append persona
+  fs.appendFileSync(SOUL_MD, "\n" + personaText.trim() + "\n");
+  logSuccess(`Updated: ${SOUL_MD}`);
+
+  return true;
+}
+
+// Final summary
+function printSummary() {
+  logStep("7/7", "Installation complete!");
+
+  console.log(`
+${c("green", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")}
+${c("bright", "  Clawra Selfie is ready!")}
+${c("green", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")}
+
+${c("cyan", "Installed files:")}
+  ${SKILL_DEST}/
+
+${c("cyan", "Configuration:")}
+  ${OPENCLAW_CONFIG}
+
+${c("cyan", "Identity set:")}
+  ${IDENTITY_MD}
+
+${c("cyan", "Persona updated:")}
+  ${SOUL_MD}
+
+${c("yellow", "Try saying to your agent:")}
+  "Send me a selfie"
+  "Send a pic wearing a cowboy hat"
+  "What are you doing right now?"
+
+${c("dim", "Your agent now has selfie superpowers!")}
+`);
+}
+
+// Handle reinstall
+async function handleReinstall(rl, falKey) {
+  const reinstall = await ask(rl, "\nReinstall/update? (y/N): ");
+
+  if (reinstall.toLowerCase() !== "y") {
+    log("\nNo changes made. Goodbye!");
+    return false;
+  }
+
+  // Remove existing installation
+  fs.rmSync(SKILL_DEST, { recursive: true, force: true });
+  logInfo("Removed existing installation");
+
+  return true;
+}
+
+// Main function
+async function main() {
+  const rl = createPrompt();
+
+  try {
+    printBanner();
+
+    // Step 1: Check prerequisites
+    const prereqResult = await checkPrerequisites();
+
+    if (prereqResult === false) {
+      rl.close();
+      process.exit(1);
+    }
+
+    if (prereqResult === "already_installed") {
+      const shouldContinue = await handleReinstall(rl, null);
+      if (!shouldContinue) {
+        rl.close();
+        process.exit(0);
+      }
+    }
+
+    // Step 2: Get FAL API key
+    const falKey = await getFalApiKey(rl);
+    if (!falKey) {
+      rl.close();
+      process.exit(1);
+    }
+
+    // Step 3: Install skill files
+    await installSkill();
+
+    // Step 4: Update OpenClaw config
+    await updateOpenClawConfig(falKey);
+
+    // Step 5: Write IDENTITY.md
+    await writeIdentity();
+
+    // Step 6: Inject persona
+    await injectPersona(rl);
+
+    // Step 7: Summary
+    printSummary();
+
+    rl.close();
+  } catch (error) {
+    logError(`Installation failed: ${error.message}`);
+    console.error(error);
+    rl.close();
+    process.exit(1);
+  }
+}
+
+// Run
+main();

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "clawra-anime",
+  "version": "1.0.0",
+  "description": "二次元虚拟女友 - OpenClaw Skill for anime-style selfie generation",
+  "main": "skill/SKILL.md",
+  "bin": {
+    "clawra-anime": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "openclaw",
+    "skill",
+    "anime",
+    "waifu",
+    "selfie",
+    "image-generation",
+    "fal-ai",
+    "grok-imagine"
+  ],
+  "author": "Fork of SumeLabs/clawra",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/YOUR_USERNAME/clawra-anime.git"
+  },
+  "dependencies": {
+    "@fal-ai/client": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/scripts/clawra-selfie.sh

@@ -0,0 +1,162 @@
+#!/bin/bash
+# grok-imagine-send.sh
+# Generate an image with Grok Imagine and send it via OpenClaw
+#
+# Usage: ./grok-imagine-send.sh "<prompt>" "<channel>" ["<caption>"]
+#
+# Environment variables required:
+#   FAL_KEY - Your fal.ai API key
+#
+# Example:
+#   FAL_KEY=your_key ./grok-imagine-send.sh "A sunset over mountains" "#art" "Check this out!"
+
+set -euo pipefail
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+log_info() {
+    echo -e "${GREEN}[INFO]${NC} $1"
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Check required environment variables
+if [ -z "${FAL_KEY:-}" ]; then
+    log_error "FAL_KEY environment variable not set"
+    echo "Get your API key from: https://fal.ai/dashboard/keys"
+    exit 1
+fi
+
+# Check for jq
+if ! command -v jq &> /dev/null; then
+    log_error "jq is required but not installed"
+    echo "Install with: brew install jq (macOS) or apt install jq (Linux)"
+    exit 1
+fi
+
+# Check for openclaw
+if ! command -v openclaw &> /dev/null; then
+    log_warn "openclaw CLI not found - will attempt direct API call"
+    USE_CLI=false
+else
+    USE_CLI=true
+fi
+
+# Parse arguments
+PROMPT="${1:-}"
+CHANNEL="${2:-}"
+CAPTION="${3:-Generated with Grok Imagine}"
+ASPECT_RATIO="${4:-1:1}"
+OUTPUT_FORMAT="${5:-jpeg}"
+
+if [ -z "$PROMPT" ] || [ -z "$CHANNEL" ]; then
+    echo "Usage: $0 <prompt> <channel> [caption] [aspect_ratio] [output_format]"
+    echo ""
+    echo "Arguments:"
+    echo "  prompt        - Image description (required)"
+    echo "  channel       - Target channel (required) e.g., #general, @user"
+    echo "  caption       - Message caption (default: 'Generated with Grok Imagine')"
+    echo "  aspect_ratio  - Image ratio (default: 1:1) Options: 2:1, 16:9, 4:3, 1:1, 3:4, 9:16"
+    echo "  output_format - Image format (default: jpeg) Options: jpeg, png, webp"
+    echo ""
+    echo "Example:"
+    echo "  $0 \"A cyberpunk city at night\" \"#art-gallery\" \"AI Art!\""
+    exit 1
+fi
+
+log_info "Generating image with Grok Imagine..."
+log_info "Prompt: $PROMPT"
+log_info "Aspect ratio: $ASPECT_RATIO"
+
+# Generate image via fal.ai
+RESPONSE=$(curl -s -X POST "https://fal.run/xai/grok-imagine-image" \
+    -H "Authorization: Key $FAL_KEY" \
+    -H "Content-Type: application/json" \
+    -d "{
+        \"prompt\": $(echo "$PROMPT" | jq -Rs .),
+        \"num_images\": 1,
+        \"aspect_ratio\": \"$ASPECT_RATIO\",
+        \"output_format\": \"$OUTPUT_FORMAT\"
+    }")
+
+# Check for errors in response
+if echo "$RESPONSE" | jq -e '.error' > /dev/null 2>&1; then
+    ERROR_MSG=$(echo "$RESPONSE" | jq -r '.error // .detail // "Unknown error"')
+    log_error "Image generation failed: $ERROR_MSG"
+    exit 1
+fi
+
+# Extract image URL
+IMAGE_URL=$(echo "$RESPONSE" | jq -r '.images[0].url // empty')
+
+if [ -z "$IMAGE_URL" ]; then
+    log_error "Failed to extract image URL from response"
+    echo "Response: $RESPONSE"
+    exit 1
+fi
+
+log_info "Image generated successfully!"
+log_info "URL: $IMAGE_URL"
+
+# Get revised prompt if available
+REVISED_PROMPT=$(echo "$RESPONSE" | jq -r '.revised_prompt // empty')
+if [ -n "$REVISED_PROMPT" ]; then
+    log_info "Revised prompt: $REVISED_PROMPT"
+fi
+
+# Send via OpenClaw
+log_info "Sending to channel: $CHANNEL"
+
+if [ "$USE_CLI" = true ]; then
+    # Use OpenClaw CLI
+    openclaw message send \
+        --action send \
+        --channel "$CHANNEL" \
+        --message "$CAPTION" \
+        --media "$IMAGE_URL"
+else
+    # Direct API call to local gateway
+    GATEWAY_URL="${OPENCLAW_GATEWAY_URL:-http://localhost:18789}"
+    GATEWAY_TOKEN="${OPENCLAW_GATEWAY_TOKEN:-}"
+
+    HEADERS="-H \"Content-Type: application/json\""
+    if [ -n "$GATEWAY_TOKEN" ]; then
+        HEADERS="$HEADERS -H \"Authorization: Bearer $GATEWAY_TOKEN\""
+    fi
+
+    curl -s -X POST "$GATEWAY_URL/message" \
+        -H "Content-Type: application/json" \
+        ${GATEWAY_TOKEN:+-H "Authorization: Bearer $GATEWAY_TOKEN"} \
+        -d "{
+            \"action\": \"send\",
+            \"channel\": \"$CHANNEL\",
+            \"message\": \"$CAPTION\",
+            \"media\": \"$IMAGE_URL\"
+        }"
+fi
+
+log_info "Done! Image sent to $CHANNEL"
+
+# Output JSON for programmatic use
+echo ""
+echo "--- Result ---"
+jq -n \
+    --arg url "$IMAGE_URL" \
+    --arg channel "$CHANNEL" \
+    --arg prompt "$PROMPT" \
+    '{
+        success: true,
+        image_url: $url,
+        channel: $channel,
+        prompt: $prompt
+    }'