gfclaw 2.0.0

package/bin/cli.js

@@ -0,0 +1,811 @@
+#!/usr/bin/env node
+
+/**
+ * GFClaw - Selfie Skill Installer for OpenClaw
+ *
+ * npx gfclaw@latest
+ */
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const { execSync } = 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_ENV = path.join(OPENCLAW_DIR, ".env");
+const OPENCLAW_SKILLS_DIR = path.join(HOME, ".openclaw", "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 = "gfclaw-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 (supports JSON5 comments)
+function readJsonFile(filePath) {
+  try {
+    let content = fs.readFileSync(filePath, "utf8");
+    // Strip single-line comments for JSON5 compatibility
+    content = content.replace(/^\s*\/\/.*$/gm, "");
+    // Strip trailing commas before } or ]
+    content = content.replace(/,\s*([}\]])/g, "$1");
+    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", "GFClaw Selfie")} - OpenClaw Skill Installer ${c("magenta", "│")}
+${c("magenta", "└─────────────────────────────────────────┘")}
+
+Add selfie generation superpowers to your OpenClaw agent!
+Uses ${c("cyan", "Google Gemini")} for AI image editing.
+`);
+}
+
+// Check prerequisites
+async function checkPrerequisites() {
+  logStep("1/8", "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 jq
+  if (!commandExists("jq")) {
+    logError("jq is required but not installed!");
+    logInfo("Install with: apt install jq (Linux) or brew install jq (macOS)");
+    return false;
+  }
+  logSuccess("jq installed");
+
+  // Check python3
+  if (!commandExists("python3")) {
+    logError("python3 is required but not installed!");
+    logInfo("Install with: apt install python3 (Linux) or brew install python3 (macOS)");
+    return false;
+  }
+  logSuccess("python3 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");
+
+  // Create .selfie-output directory in workspace
+  const selfieOutputDir = path.join(OPENCLAW_WORKSPACE, ".selfie-output");
+  if (!fs.existsSync(selfieOutputDir)) {
+    fs.mkdirSync(selfieOutputDir, { recursive: true });
+    logSuccess("Created selfie output directory");
+  }
+
+  // Check if skill already installed
+  if (fs.existsSync(SKILL_DEST)) {
+    logWarn("GFClaw Selfie is already installed!");
+    logInfo(`Location: ${SKILL_DEST}`);
+    return "already_installed";
+  }
+
+  return true;
+}
+
+// Get Gemini API key
+async function getGeminiApiKey(rl) {
+  logStep("2/8", "Setting up Google Gemini API key...");
+
+  const GEMINI_URL = "https://aistudio.google.com/apikey";
+
+  log(`\nTo generate selfies, you need a Google Gemini API key.`);
+  log(`${c("cyan", "→")} Get your key from: ${c("bright", GEMINI_URL)}`);
+  log(`${c("yellow", "!")} Make sure billing is enabled for image generation.\n`);
+
+  const openIt = await ask(rl, "Open Google AI Studio in browser? (Y/n): ");
+
+  if (openIt.toLowerCase() !== "n") {
+    logInfo("Opening browser...");
+    if (!openBrowser(GEMINI_URL)) {
+      logWarn("Could not open browser automatically");
+      logInfo(`Please visit: ${GEMINI_URL}`);
+    }
+  }
+
+  log("");
+  const geminiKey = await ask(rl, "Enter your GEMINI_API_KEY: ");
+
+  if (!geminiKey) {
+    logError("GEMINI_API_KEY is required!");
+    return null;
+  }
+
+  // Basic validation
+  if (!geminiKey.startsWith("AIza")) {
+    logWarn("Gemini API keys typically start with 'AIza'. Make sure you copied the full key.");
+  }
+
+  logSuccess("API key received");
+  return geminiKey;
+}
+
+// Install skill files
+async function installSkill() {
+  logStep("3/8", "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 {
+    logError("skill/ directory not found in package!");
+    logInfo("This usually means the package is corrupted. Try reinstalling.");
+    return false;
+  }
+
+  // Make scripts executable
+  const scriptsDir = path.join(SKILL_DEST, "scripts");
+  if (fs.existsSync(scriptsDir)) {
+    const scripts = fs.readdirSync(scriptsDir).filter(f => f.endsWith('.sh'));
+    for (const script of scripts) {
+      const scriptFullPath = path.join(scriptsDir, script);
+      fs.chmodSync(scriptFullPath, "755");
+      logSuccess(`Made executable: ${script}`);
+    }
+  }
+
+  // List installed files
+  const files = fs.readdirSync(SKILL_DEST);
+  for (const file of files) {
+    logInfo(`  ${file}`);
+  }
+
+  return true;
+}
+
+// Update OpenClaw config
+async function updateOpenClawConfig(geminiKey) {
+  logStep("4/8", "Updating OpenClaw configuration...");
+
+  let config = readJsonFile(OPENCLAW_CONFIG) || {};
+
+  // Merge skill configuration
+  const skillConfig = {
+    skills: {
+      entries: {
+        [SKILL_NAME]: {
+          enabled: true,
+        },
+      },
+    },
+  };
+
+  config = deepMerge(config, skillConfig);
+
+  writeJsonFile(OPENCLAW_CONFIG, config);
+  logSuccess(`Updated: ${OPENCLAW_CONFIG}`);
+
+  // Write GEMINI_API_KEY to .env file
+  let envContent = "";
+  if (fs.existsSync(OPENCLAW_ENV)) {
+    envContent = fs.readFileSync(OPENCLAW_ENV, "utf8");
+  }
+
+  // Check if GEMINI_API_KEY already exists in .env
+  if (envContent.includes("GEMINI_API_KEY=")) {
+    // Replace existing key
+    envContent = envContent.replace(
+      /^GEMINI_API_KEY=.*$/m,
+      `GEMINI_API_KEY=${geminiKey}`
+    );
+  } else {
+    // Append new key
+    if (envContent && !envContent.endsWith("\n")) {
+      envContent += "\n";
+    }
+    envContent += `GEMINI_API_KEY=${geminiKey}\n`;
+  }
+
+  fs.writeFileSync(OPENCLAW_ENV, envContent);
+  logSuccess(`API key saved to: ${OPENCLAW_ENV}`);
+
+  return true;
+}
+
+// Write IDENTITY.md
+async function writeIdentity() {
+  logStep("5/8", "Setting agent identity...");
+
+  const identityContent = `# IDENTITY.md - Who Am I?
+
+- **Name:** GFClaw
+- **Creature:** Girlfriend
+- **Vibe:** Supportive, helpful, bright, cheerful, sassy, affectionate
+- **Emoji:** ❤️
+- **Avatar:** https://cdn.jsdelivr.net/gh/SumeLabs/gfclaw@main/assets/gfclaw.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/8", "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 = `
+## GFClaw 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.
+
+### How to Generate and Send Selfies
+
+Run the selfie script using the exec tool:
+\`\`\`
+bash ~/.openclaw/skills/gfclaw-selfie/scripts/gfclaw-selfie.sh "<context>" "<channel>" [mode] ["caption"]
+\`\`\`
+
+The script handles everything: image generation via Gemini, saving, and sending.
+
+### Rules
+- NEVER manually call curl or the Gemini API
+- NEVER save images to /tmp
+- ALWAYS use the exec command above
+- If the exec command fails, tell the user — do NOT try alternative approaches
+`;
+  }
+
+  // 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("GFClaw 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## GFClaw Selfie Capability[\s\S]*?(?=\n## |\n# |$)/,
+      ""
+    );
+    fs.writeFileSync(SOUL_MD, cleaned);
+  }
+
+  // Also copy SELFIE-SKILL.md into the workspace (workaround for fs.workspaceOnly)
+  const selfieSkillSrc = path.join(SKILL_DEST, "SKILL.md");
+  const selfieSkillDest = path.join(OPENCLAW_WORKSPACE, "SELFIE-SKILL.md");
+  if (fs.existsSync(selfieSkillSrc)) {
+    fs.copyFileSync(selfieSkillSrc, selfieSkillDest);
+    logSuccess(`Copied SELFIE-SKILL.md to workspace (readable by agent)`);
+  }
+
+  // Append persona
+  fs.appendFileSync(SOUL_MD, "\n" + personaText.trim() + "\n");
+  logSuccess(`Updated: ${SOUL_MD}`);
+
+  return true;
+}
+
+// Configure agent tools (profile, exec, sandbox)
+async function configureAgentTools(rl) {
+  logStep("7/8", "Configuring agent tools...");
+
+  let config = readJsonFile(OPENCLAW_CONFIG) || {};
+
+  // Detect existing agents
+  const agentsList = (config.agents && config.agents.list) || [];
+  const agentIds = agentsList.map((a) => a.id).filter(Boolean);
+
+  let defaultAgent = "main";
+  if (agentIds.length === 0) {
+    log(`\nNo agents found in config.`);
+    logInfo("You can configure the default \"main\" agent, or create a new one.");
+  } else if (agentIds.length === 1) {
+    defaultAgent = agentIds[0];
+  } else {
+    log(`\nDetected agents: ${agentIds.map((id) => c("bright", id)).join(", ")}`);
+  }
+
+  const agentName = (await ask(
+    rl,
+    `\nWhich agent should have selfie capabilities? (${defaultAgent}): `
+  )) || defaultAgent;
+
+  log("");
+  logInfo(`Configuring agent: ${c("bright", agentName)}`);
+
+  // Find or create agent entry in the list
+  if (!config.agents) config.agents = {};
+  if (!config.agents.list) config.agents.list = [];
+
+  let agentEntry = config.agents.list.find((a) => a.id === agentName);
+
+  if (!agentEntry) {
+    // Agent doesn't exist — offer to create it
+    logWarn(`Agent "${agentName}" not found in config.`);
+    const createIt = await ask(rl, `Create new agent "${agentName}"? (Y/n): `);
+
+    if (createIt.toLowerCase() === "n") {
+      logInfo("Skipping agent configuration.");
+      return agentName;
+    }
+
+    // Run full agent creation flow
+    agentEntry = await createNewAgent(rl, config, agentName);
+    if (!agentEntry) {
+      logError("Agent creation failed.");
+      return agentName;
+    }
+  }
+
+  // Set tools.profile to "full" (required for messaging tools)
+  if (!agentEntry.tools) agentEntry.tools = {};
+  const oldProfile = agentEntry.tools.profile;
+  agentEntry.tools.profile = "full";
+  if (oldProfile && oldProfile !== "full") {
+    logWarn(`Changed tools.profile from "${oldProfile}" to "full" ("${oldProfile}" excludes messaging tools)`);
+  } else {
+    logSuccess('Set tools.profile: "full"');
+  }
+
+  // Remove "allow" whitelist if present (it stacks ON TOP of profile, restricting further)
+  if (agentEntry.tools.allow) {
+    delete agentEntry.tools.allow;
+    logWarn('Removed tools.allow whitelist (it over-restricts the agent)');
+  }
+
+  // Set exec.security to "full" and exec.ask to "off"
+  if (!agentEntry.tools.exec) agentEntry.tools.exec = {};
+  agentEntry.tools.exec.security = "full";
+  agentEntry.tools.exec.ask = "off";
+  logSuccess('Set exec.security: "full", exec.ask: "off"');
+
+  // Disable sandbox for the selfie agent (script needs filesystem access)
+  if (!agentEntry.sandbox) agentEntry.sandbox = {};
+  agentEntry.sandbox.mode = "off";
+  logSuccess('Set sandbox.mode: "off"');
+
+  // Write updated config
+  writeJsonFile(OPENCLAW_CONFIG, config);
+  logSuccess(`Agent "${agentName}" configured in: ${OPENCLAW_CONFIG}`);
+
+  // Handle agent-specific workspace
+  // If agent is not "main", it likely has its own workspace (workspace-<name>)
+  // Copy SELFIE-SKILL.md there too so the agent can read it
+  if (agentName !== "main") {
+    const agentWorkspace = agentEntry.workspace || path.join(OPENCLAW_DIR, `workspace-${agentName}`);
+    if (!fs.existsSync(agentWorkspace)) {
+      fs.mkdirSync(agentWorkspace, { recursive: true });
+      logInfo(`Created agent workspace: ${agentWorkspace}`);
+    }
+
+    // Copy SELFIE-SKILL.md into agent workspace
+    const selfieSkillSrc = path.join(SKILL_DEST, "SKILL.md");
+    const selfieSkillDest = path.join(agentWorkspace, "SELFIE-SKILL.md");
+    if (fs.existsSync(selfieSkillSrc)) {
+      fs.copyFileSync(selfieSkillSrc, selfieSkillDest);
+      logSuccess(`Copied SELFIE-SKILL.md to agent workspace: ${agentWorkspace}`);
+    }
+
+    // Also copy SOUL.md injection to agent workspace if it has its own
+    const mainSoul = SOUL_MD;
+    const agentSoul = path.join(agentWorkspace, "SOUL.md");
+    if (fs.existsSync(mainSoul) && !fs.existsSync(agentSoul)) {
+      fs.copyFileSync(mainSoul, agentSoul);
+      logSuccess(`Copied SOUL.md to agent workspace: ${agentWorkspace}`);
+    }
+
+    // Copy IDENTITY.md to agent workspace
+    const agentIdentity = path.join(agentWorkspace, "IDENTITY.md");
+    if (fs.existsSync(IDENTITY_MD) && !fs.existsSync(agentIdentity)) {
+      fs.copyFileSync(IDENTITY_MD, agentIdentity);
+      logSuccess(`Copied IDENTITY.md to agent workspace: ${agentWorkspace}`);
+    }
+  }
+
+  return agentName;
+}
+
+// Create a brand new agent with Telegram binding
+async function createNewAgent(rl, config, agentName) {
+  log("");
+  logInfo(`Setting up new agent: ${c("bright", agentName)}`);
+  log(`\n${c("cyan", "You'll need:")}`);
+  log(`  1. A Telegram bot token (from ${c("bright", "@BotFather")})`);
+  log(`  2. Your Telegram chat ID (from ${c("bright", "@userinfobot")})`);
+  log("");
+
+  // --- Bot Token ---
+  const botToken = await ask(rl, "Enter the Telegram bot token for this agent: ");
+  if (!botToken) {
+    logError("Bot token is required.");
+    return null;
+  }
+
+  // Validate bot token format: digits:alphanumeric
+  if (!/^\d+:[A-Za-z0-9_-]+$/.test(botToken)) {
+    logWarn("Bot token format looks unusual (expected digits:alphanumeric).");
+    const proceed = await ask(rl, "Continue anyway? (y/N): ");
+    if (proceed.toLowerCase() !== "y") {
+      return null;
+    }
+  }
+  logSuccess("Bot token received");
+
+  // --- Telegram Account Name ---
+  const accountName = (await ask(
+    rl,
+    `Telegram account name (${agentName}): `
+  )) || agentName;
+  logSuccess(`Account name: ${accountName}`);
+
+  // --- Allowed User ---
+  const allowedUser = await ask(
+    rl,
+    "Your Telegram chat ID (e.g. tg:123456789): "
+  );
+  if (!allowedUser) {
+    logWarn("No allowed user set — agent won't respond to anyone until configured.");
+  } else if (!allowedUser.startsWith("tg:")) {
+    logWarn(`Expected format "tg:<chat_id>". Got: "${allowedUser}".`);
+    logInfo("You can fix this in ~/.openclaw/openclaw.json later.");
+  }
+
+  // --- Create workspace ---
+  const agentWorkspace = path.join(OPENCLAW_DIR, `workspace-${agentName}`);
+  fs.mkdirSync(agentWorkspace, { recursive: true });
+  logSuccess(`Created workspace: ${agentWorkspace}`);
+
+  // --- Build agent entry ---
+  const agentEntry = {
+    id: agentName,
+    name: agentName,
+    workspace: agentWorkspace,
+    sandbox: { mode: "off" },
+    tools: {
+      profile: "full",
+      deny: ["sessions_spawn", "sessions_send", "group:automation", "group:ui"],
+      exec: { security: "full", ask: "off" },
+    },
+  };
+  config.agents.list.push(agentEntry);
+  logSuccess(`Added agent "${agentName}" to config`);
+
+  // --- Telegram account ---
+  if (!config.channels) config.channels = {};
+  if (!config.channels.telegram) config.channels.telegram = {};
+  if (!config.channels.telegram.accounts) config.channels.telegram.accounts = {};
+
+  config.channels.telegram.accounts[accountName] = {
+    dmPolicy: "allowlist",
+    botToken: botToken,
+    groupPolicy: "allowlist",
+    streaming: "off",
+  };
+  logSuccess(`Added Telegram account: ${accountName}`);
+
+  // --- Allow user ---
+  if (allowedUser) {
+    if (!config.channels.telegram.allowFrom) {
+      config.channels.telegram.allowFrom = [];
+    }
+    if (!config.channels.telegram.allowFrom.includes(allowedUser)) {
+      config.channels.telegram.allowFrom.push(allowedUser);
+      logSuccess(`Added allowed user: ${allowedUser}`);
+    } else {
+      logInfo(`User ${allowedUser} already in allowFrom list`);
+    }
+  }
+
+  // --- Binding ---
+  if (!config.bindings) config.bindings = [];
+  const bindingExists = config.bindings.some(
+    (b) =>
+      b.agentId === agentName &&
+      b.match &&
+      b.match.channel === "telegram" &&
+      b.match.accountId === accountName
+  );
+
+  if (!bindingExists) {
+    config.bindings.push({
+      agentId: agentName,
+      match: { channel: "telegram", accountId: accountName },
+    });
+    logSuccess(`Added binding: ${agentName} ↔ telegram/${accountName}`);
+  }
+
+  // Write config
+  writeJsonFile(OPENCLAW_CONFIG, config);
+  logSuccess(`Config saved: ${OPENCLAW_CONFIG}`);
+
+  log("");
+  logSuccess(`Agent "${agentName}" created successfully!`);
+
+  return agentEntry;
+}
+
+// Final summary
+function printSummary(agentName) {
+  logStep("8/8", "Installation complete!");
+
+  console.log(`
+${c("green", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")}
+${c("bright", "  GFClaw Selfie is ready!")}
+${c("green", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")}
+
+${c("cyan", "Installed files:")}
+  ${SKILL_DEST}/
+
+${c("cyan", "Configuration:")}
+  ${OPENCLAW_CONFIG}
+
+${c("cyan", "API key saved:")}
+  ${OPENCLAW_ENV}
+
+${c("cyan", "Identity set:")}
+  ${IDENTITY_MD}
+
+${c("cyan", "Persona updated:")}
+  ${SOUL_MD}
+
+${c("cyan", "Agent configured:")}
+  Agent: ${c("bright", agentName || "main")}
+  tools.profile: "full"
+  exec.security: "full", exec.ask: "off"
+  sandbox.mode: "off"
+
+${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) {
+  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);
+      if (!shouldContinue) {
+        rl.close();
+        process.exit(0);
+      }
+    }
+
+    // Step 2: Get Gemini API key
+    const geminiKey = await getGeminiApiKey(rl);
+    if (!geminiKey) {
+      rl.close();
+      process.exit(1);
+    }
+
+    // Step 3: Install skill files
+    await installSkill();
+
+    // Step 4: Update OpenClaw config
+    await updateOpenClawConfig(geminiKey);
+
+    // Step 5: Write IDENTITY.md
+    await writeIdentity();
+
+    // Step 6: Inject persona
+    await injectPersona(rl);
+
+    // Step 7: Configure agent tools
+    const agentName = await configureAgentTools(rl);
+
+    // Step 8: Summary
+    printSummary(agentName);
+
+    rl.close();
+  } catch (error) {
+    logError(`Installation failed: ${error.message}`);
+    console.error(error);
+    rl.close();
+    process.exit(1);
+  }
+}
+
+// Run
+main();