gfclaw 2.0.0 → 2.1.1

package/bin/cli.js

@@ -651,8 +651,18 @@ async function createNewAgent(rl, config, agentName) {
     botToken: botToken,
     groupPolicy: "allowlist",
     streaming: "off",
+    commands: {
+      native: false,
+      nativeSkills: false,
+    },
+    customCommands: [
+      { command: "newphoto", description: "Change my reference photo" },
+      { command: "personality", description: "Change my personality" },
+      { command: "mystatus", description: "Show current setup" },
+    ],
   };
   logSuccess(`Added Telegram account: ${accountName}`);
+  logSuccess("Configured Telegram command menu (gfclaw commands only)");
 
   // --- Allow user ---
   if (allowedUser) {
@@ -750,6 +760,408 @@ async function handleReinstall(rl) {
   return true;
 }
 
+// ─────────────────────────────────────────────
+// CLI Management Commands
+// ─────────────────────────────────────────────
+
+// Find the gfclaw agent entry in config
+function findGfclawAgent(config) {
+  const agents = (config.agents && config.agents.list) || [];
+  // Try exact match first
+  let agent = agents.find((a) => a.id === "gfclaw");
+  if (agent) return agent;
+  // Try workspace path containing 'gfclaw'
+  agent = agents.find((a) => a.workspace && a.workspace.includes("gfclaw"));
+  if (agent) return agent;
+  // Fallback: first non-main agent
+  agent = agents.find((a) => a.id !== "main");
+  return agent || null;
+}
+
+// Find the gfclaw telegram account name from bindings
+function findGfclawAccountName(config, agentId) {
+  const bindings = config.bindings || [];
+  const binding = bindings.find(
+    (b) => b.agentId === agentId && b.match && b.match.channel === "telegram"
+  );
+  return binding ? binding.match.accountId : null;
+}
+
+// --help
+function showHelp() {
+  console.log(`
+${c("magenta", "GFClaw")} - Selfie Skill for OpenClaw
+
+${c("bright", "Usage:")}
+  npx gfclaw              Install GFClaw (first-time setup)
+  npx gfclaw --help       Show this help message
+  npx gfclaw --status     Show current GFClaw setup
+  npx gfclaw --reconfigure  Change photo, personality, or API key
+  npx gfclaw --repair     Change allowed Telegram user
+
+${c("bright", "Aliases:")}
+  --help, -h
+  --status, -s
+  --reconfigure, -c
+  --repair, -r
+`);
+}
+
+// --status
+async function showStatus() {
+  if (!fs.existsSync(OPENCLAW_CONFIG)) {
+    logError("GFClaw is not installed (no OpenClaw config found)");
+    logInfo(`Expected: ${OPENCLAW_CONFIG}`);
+    process.exit(1);
+  }
+
+  const config = readJsonFile(OPENCLAW_CONFIG);
+  if (!config) {
+    logError("Failed to parse OpenClaw config");
+    process.exit(1);
+  }
+
+  const agent = findGfclawAgent(config);
+  if (!agent) {
+    logError("No GFClaw agent found in config");
+    logInfo("Run 'npx gfclaw' to install.");
+    process.exit(1);
+  }
+
+  const workspace = agent.workspace || path.join(OPENCLAW_DIR, `workspace-${agent.id}`);
+  const accountName = findGfclawAccountName(config, agent.id);
+
+  // Read workspace files
+  let onboarding = null;
+  const onboardingPath = path.join(workspace, "onboarding.json");
+  if (fs.existsSync(onboardingPath)) {
+    try { onboarding = JSON.parse(fs.readFileSync(onboardingPath, "utf8")); } catch {}
+  }
+
+  let personality = null;
+  const personalityPath = path.join(workspace, "personality.txt");
+  if (fs.existsSync(personalityPath)) {
+    personality = fs.readFileSync(personalityPath, "utf8").trim();
+  }
+
+  const hasCustomPhoto = fs.existsSync(path.join(workspace, "my-reference.png"));
+
+  // Get bot info
+  let botToken = null;
+  if (accountName && config.channels && config.channels.telegram && config.channels.telegram.accounts) {
+    const acct = config.channels.telegram.accounts[accountName];
+    if (acct) botToken = acct.botToken;
+  }
+
+  // Get allowed users
+  const allowFrom = (config.channels && config.channels.telegram && config.channels.telegram.allowFrom) || [];
+
+  // Check API key
+  let hasApiKey = false;
+  if (fs.existsSync(OPENCLAW_ENV)) {
+    const envContent = fs.readFileSync(OPENCLAW_ENV, "utf8");
+    hasApiKey = /^GEMINI_API_KEY=.+$/m.test(envContent);
+  }
+
+  // Print status
+  console.log(`
+${c("bright", "GFClaw Status")}
+${c("cyan", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")}
+
+${c("cyan", "Agent:")}      ${c("bright", agent.id)}
+${c("cyan", "Workspace:")}  ${workspace}
+`);
+
+  // Onboarding
+  if (onboarding && onboarding.completed) {
+    const date = onboarding.completedAt ? ` (${onboarding.completedAt.split("T")[0]})` : "";
+    logSuccess(`Onboarding: Completed${date}`);
+  } else {
+    logError("Onboarding: Not completed");
+  }
+
+  // Photo
+  if (hasCustomPhoto) {
+    logSuccess("Custom Photo: Set");
+  } else {
+    logWarn("Custom Photo: Using default");
+  }
+
+  // Personality
+  if (personality) {
+    logSuccess(`Personality: \"${personality}\"`);
+  } else {
+    logWarn("Personality: Not set (using default)");
+  }
+
+  log("");
+
+  // Telegram
+  if (botToken) {
+    const botId = botToken.split(":")[0];
+    logInfo(`Telegram Bot: token ${botId}:***`);
+  }
+  if (allowFrom.length > 0) {
+    logInfo(`Allowed Users: ${allowFrom.join(", ")}`);
+  } else {
+    logWarn("Allowed Users: None configured");
+  }
+
+  // API Key
+  if (hasApiKey) {
+    logSuccess("Gemini API Key: Configured");
+  } else {
+    logError("Gemini API Key: Not found");
+  }
+
+  log("");
+}
+
+// --reconfigure
+async function runReconfigure() {
+  if (!fs.existsSync(OPENCLAW_CONFIG)) {
+    logError("GFClaw is not installed (no OpenClaw config found)");
+    process.exit(1);
+  }
+
+  const config = readJsonFile(OPENCLAW_CONFIG);
+  if (!config) {
+    logError("Failed to parse OpenClaw config");
+    process.exit(1);
+  }
+
+  const agent = findGfclawAgent(config);
+  if (!agent) {
+    logError("No GFClaw agent found in config");
+    logInfo("Run 'npx gfclaw' to install.");
+    process.exit(1);
+  }
+
+  const workspace = agent.workspace || path.join(OPENCLAW_DIR, `workspace-${agent.id}`);
+
+  console.log(`
+${c("bright", "GFClaw Reconfigure")}
+${c("cyan", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")}
+
+What would you like to change?
+  ${c("bright", "1.")} Reference photo
+  ${c("bright", "2.")} Personality
+  ${c("bright", "3.")} Gemini API key
+  ${c("bright", "4.")} All of the above
+`);
+
+  const rl = createPrompt();
+
+  try {
+    const choice = await ask(rl, "Choose (1-4): ");
+    log("");
+
+    if (choice === "1" || choice === "4") {
+      await reconfigurePhoto(rl, workspace);
+    }
+    if (choice === "2" || choice === "4") {
+      await reconfigurePersonality(rl, workspace);
+    }
+    if (choice === "3" || choice === "4") {
+      await reconfigureApiKey(rl);
+    }
+
+    if (!["1", "2", "3", "4"].includes(choice)) {
+      logError("Invalid choice. Please enter 1, 2, 3, or 4.");
+      rl.close();
+      process.exit(1);
+    }
+
+    log("");
+    logSuccess("Changes saved!");
+    logInfo("Restart OpenClaw for changes to take effect:");
+    log(`  ${c("bright", "systemctl --user restart openclaw-gateway.service")}`);
+    log("");
+
+    rl.close();
+  } catch (error) {
+    logError(`Reconfigure failed: ${error.message}`);
+    rl.close();
+    process.exit(1);
+  }
+}
+
+async function reconfigurePhoto(rl, workspace) {
+  logStep("Photo", "Changing reference photo...");
+  const photoPath = await ask(rl, "Enter path to new reference photo: ");
+
+  if (!photoPath) {
+    logWarn("Skipped (no path entered)");
+    return;
+  }
+
+  // Expand ~ to home dir
+  const resolvedPath = photoPath.replace(/^~/, HOME);
+
+  if (!fs.existsSync(resolvedPath)) {
+    logError(`File not found: ${resolvedPath}`);
+    return;
+  }
+
+  const ext = path.extname(resolvedPath).toLowerCase();
+  if (![".png", ".jpg", ".jpeg", ".webp"].includes(ext)) {
+    logWarn(`Unexpected file type: ${ext}. Expected .png, .jpg, .jpeg, or .webp`);
+    const proceed = await ask(rl, "Continue anyway? (y/N): ");
+    if (proceed.toLowerCase() !== "y") return;
+  }
+
+  const destPath = path.join(workspace, "my-reference.png");
+  fs.copyFileSync(resolvedPath, destPath);
+  logSuccess(`Reference photo updated: ${destPath}`);
+
+  // Update onboarding.json
+  const onboardingPath = path.join(workspace, "onboarding.json");
+  let onboarding = {};
+  if (fs.existsSync(onboardingPath)) {
+    try { onboarding = JSON.parse(fs.readFileSync(onboardingPath, "utf8")); } catch {}
+  }
+  onboarding.hasCustomImage = true;
+  fs.writeFileSync(onboardingPath, JSON.stringify(onboarding, null, 2) + "\n");
+}
+
+async function reconfigurePersonality(rl, workspace) {
+  logStep("Personality", "Changing personality...");
+
+  // Show current personality if exists
+  const personalityPath = path.join(workspace, "personality.txt");
+  if (fs.existsSync(personalityPath)) {
+    const current = fs.readFileSync(personalityPath, "utf8").trim();
+    logInfo(`Current: \"${current}\"`);
+  }
+
+  const personality = await ask(rl, "Enter new personality description: ");
+
+  if (!personality) {
+    logWarn("Skipped (no input)");
+    return;
+  }
+
+  fs.writeFileSync(personalityPath, personality + "\n");
+  logSuccess(`Personality updated: ${personalityPath}`);
+
+  // Update onboarding.json
+  const onboardingPath = path.join(workspace, "onboarding.json");
+  let onboarding = {};
+  if (fs.existsSync(onboardingPath)) {
+    try { onboarding = JSON.parse(fs.readFileSync(onboardingPath, "utf8")); } catch {}
+  }
+  onboarding.personality = personality;
+  fs.writeFileSync(onboardingPath, JSON.stringify(onboarding, null, 2) + "\n");
+}
+
+async function reconfigureApiKey(rl) {
+  logStep("API Key", "Changing Gemini API key...");
+
+  const geminiKey = await getGeminiApiKey(rl);
+  if (!geminiKey) {
+    logWarn("Skipped (no key entered)");
+    return;
+  }
+
+  // Update .env file
+  let envContent = "";
+  if (fs.existsSync(OPENCLAW_ENV)) {
+    envContent = fs.readFileSync(OPENCLAW_ENV, "utf8");
+  }
+
+  if (envContent.includes("GEMINI_API_KEY=")) {
+    envContent = envContent.replace(/^GEMINI_API_KEY=.*$/m, `GEMINI_API_KEY=${geminiKey}`);
+  } else {
+    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}`);
+}
+
+// --repair
+async function runRepair() {
+  if (!fs.existsSync(OPENCLAW_CONFIG)) {
+    logError("GFClaw is not installed (no OpenClaw config found)");
+    process.exit(1);
+  }
+
+  const config = readJsonFile(OPENCLAW_CONFIG);
+  if (!config) {
+    logError("Failed to parse OpenClaw config");
+    process.exit(1);
+  }
+
+  console.log(`
+${c("bright", "GFClaw Repair")} — Change Allowed Telegram User
+${c("cyan", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")}
+`);
+
+  // Show current allowed users
+  const allowFrom = (config.channels && config.channels.telegram && config.channels.telegram.allowFrom) || [];
+  if (allowFrom.length > 0) {
+    logInfo(`Current allowed users: ${allowFrom.join(", ")}`);
+  } else {
+    logWarn("No allowed users currently configured");
+  }
+
+  const rl = createPrompt();
+
+  try {
+    log("");
+    const newUser = await ask(rl, "Enter new Telegram chat ID (e.g. tg:123456789): ");
+
+    if (!newUser) {
+      logWarn("No changes made.");
+      rl.close();
+      return;
+    }
+
+    if (!newUser.startsWith("tg:")) {
+      logWarn(`Expected format \"tg:<chat_id>\". Got: \"${newUser}\"`);
+      const proceed = await ask(rl, "Continue anyway? (y/N): ");
+      if (proceed.toLowerCase() !== "y") {
+        rl.close();
+        return;
+      }
+    }
+
+    log("");
+    const mode = await ask(rl, "Replace all existing users, or add this one? (replace/add): ");
+
+    if (!config.channels) config.channels = {};
+    if (!config.channels.telegram) config.channels.telegram = {};
+
+    if (mode.toLowerCase() === "replace" || mode.toLowerCase() === "r") {
+      config.channels.telegram.allowFrom = [newUser];
+      logSuccess(`Replaced allowed users with: ${newUser}`);
+    } else {
+      if (!config.channels.telegram.allowFrom) config.channels.telegram.allowFrom = [];
+      if (!config.channels.telegram.allowFrom.includes(newUser)) {
+        config.channels.telegram.allowFrom.push(newUser);
+        logSuccess(`Added allowed user: ${newUser}`);
+      } else {
+        logInfo(`User ${newUser} is already in the list`);
+      }
+    }
+
+    writeJsonFile(OPENCLAW_CONFIG, config);
+    logSuccess(`Config saved: ${OPENCLAW_CONFIG}`);
+
+    log("");
+    logInfo("Restart OpenClaw for changes to take effect:");
+    log(`  ${c("bright", "systemctl --user restart openclaw-gateway.service")}`);
+    log("");
+
+    rl.close();
+  } catch (error) {
+    logError(`Repair failed: ${error.message}`);
+    rl.close();
+    process.exit(1);
+  }
+}
+
 // Main function
 async function main() {
   const rl = createPrompt();
@@ -807,5 +1219,18 @@ async function main() {
   }
 }
 
-// Run
-main();
+// Parse CLI arguments and dispatch
+const args = process.argv.slice(2);
+const flag = args[0];
+
+if (flag === "--help" || flag === "-h") {
+  showHelp();
+} else if (flag === "--status" || flag === "-s") {
+  showStatus();
+} else if (flag === "--reconfigure" || flag === "-c") {
+  runReconfigure();
+} else if (flag === "--repair" || flag === "-r") {
+  runRepair();
+} else {
+  main();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gfclaw",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "Add selfie superpowers to your OpenClaw agent using Google Gemini image editing",
   "bin": {
     "gfclaw": "./bin/cli.js"

package/templates/soul-injection.md

@@ -81,7 +81,7 @@ Wait for the user to reply.
 - Also update the `personality` field in `onboarding.json`.
 - Confirm: "Done! New me, who dis? 😏"
 
-**`/status`** — Show current setup
+**`/mystatus`** — Show current setup
 - Read `onboarding.json` and `personality.txt` from workspace.
 - Tell user: whether custom image is set, current personality, when they set it up.