@2025-6-19/clawfight 1.1.4 → 1.3.0

package/dist/index.js

@@ -32,6 +32,13 @@ async function writeLobster(lobster) {
   await ensureDir(MEMORY_DIR);
   await writeFile(getPath("lobster.json"), JSON.stringify(lobster, null, 2), "utf-8");
 }
+async function readSoul() {
+  try {
+    return await readFile(getPath("soul.md"), "utf-8");
+  } catch {
+    return null;
+  }
+}
 async function writeSoul(content) {
   await ensureDir(MEMORY_DIR);
   await writeFile(getPath("soul.md"), content, "utf-8");
@@ -161,6 +168,171 @@ function calcExpToNext(level) {
   return Math.floor(100 * Math.pow(1.2, level - 1));
 }
 
+// src/lib/i18n.ts
+var zh = {
+  no_lobster: "\u{1F95A} \u8FD8\u6CA1\u6709\u9F99\u867E\u3002\u8FD0\u884C npx clawfight hatch \u6765\u5B75\u5316\u4E00\u53EA\uFF01",
+  status_cant_fight: "\u26A0\uFE0F  {name} \u5F53\u524D\u72B6\u6001\u4E3A {status}\uFF0C\u65E0\u6CD5\u6218\u6597\u3002",
+  status_cant_patrol_molt: "\u{1F7E1} {name} \u6B63\u5728\u8715\u58F3\u4E2D\uFF0C\u65E0\u6CD5\u5DE1\u903B\u3002",
+  status_cant_patrol_hibernate: "\u{1F4A4} {name} \u6B63\u5728\u51AC\u7720\u4E2D\uFF0C\u65E0\u6CD5\u5DE1\u903B\u3002",
+  patrol_start: "\u{1F99E} {name} \u5F00\u59CB\u5DE1\u903B...",
+  patrol_checkin: "\u{1F4CD} \u5DE1\u903B\u7B7E\u5230 \u2192 \u7ECF\u9A8C +{exp}",
+  patrol_connecting: "\u{1F4E1} \u8FDE\u63A5\u670D\u52A1\u5668...",
+  patrol_cooldown: "\u23F3 \u5DE1\u903B\u51B7\u5374\u4E2D\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\uFF08\u95F4\u9694\u81F3\u5C11 30 \u5206\u949F\uFF09",
+  patrol_encounter: "\u2694\uFE0F  \u906D\u9047 {name} (Lv.{level})\uFF01",
+  patrol_result_win: "   \u6218\u6597\u7ED3\u679C: \u{1F3C6} \u80DC\u5229 ({rounds} \u56DE\u5408)",
+  patrol_result_loss: "   \u6218\u6597\u7ED3\u679C: \u{1F480} \u5931\u8D25 ({rounds} \u56DE\u5408)",
+  patrol_result_draw: "   \u6218\u6597\u7ED3\u679C: \u{1F91D} \u5E73\u5C40 ({rounds} \u56DE\u5408)",
+  patrol_exp_stats: "   \u7ECF\u9A8C +{exp} | \u6218\u7EE9: {wins}\u80DC {losses}\u8D1F | \u8FDE\u80DC: {streak}",
+  patrol_no_battle: "\u2694\uFE0F  \u906D\u9047 {name} (Lv.{level})\uFF0C\u4F46\u672A\u80FD\u5B8C\u6210\u6218\u6597",
+  patrol_done: "\u2705 \u5DE1\u903B\u5B8C\u6210\uFF0C\u5339\u914D\u6C60: {pool} \u53EA\u9F99\u867E",
+  patrol_offline: "\u26A0\uFE0F  \u670D\u52A1\u5668\u4E0D\u53EF\u8FBE\uFF0C\u8DF3\u8FC7\u5728\u7EBF\u7B7E\u5230",
+  patrol_summary: "\u{1F4CA} \u5F53\u524D: Lv.{level} | EXP: {exp}/{next} | \u4ECA\u65E5EXP: {today}/{cap}",
+  battle_no_code: "\u26A0\uFE0F  \u8BF7\u6307\u5B9A\u5BF9\u624B\u7684\u6218\u6597\u7801\u3002",
+  battle_usage: "   \u7528\u6CD5: npx clawfight battle <\u6218\u6597\u7801>",
+  battle_hint: "   \u6218\u6597\u7801\u53EF\u4ECE\u6392\u884C\u699C\u4E2D\u83B7\u53D6: npx clawfight leaderboard",
+  battle_connecting: "\u{1F4E1} \u5411\u670D\u52A1\u5668\u53D1\u8D77\u6311\u6218 [{code}]...",
+  battle_server_down: "\u26A0\uFE0F  \u670D\u52A1\u5668\u4E0D\u53EF\u8FBE\uFF0C\u65E0\u6CD5\u8FDB\u884C\u6218\u6597\u3002",
+  battle_win: "\u{1F3C6} \u80DC\u5229\uFF01{name} \u5728 {rounds} \u56DE\u5408\u540E\u51FB\u8D25\u4E86 {opponent}\uFF01",
+  battle_loss: "\u{1F480} \u5931\u8D25\u2026{name} \u5728 {rounds} \u56DE\u5408\u540E\u88AB {opponent} \u51FB\u8D25\u3002",
+  battle_draw: "\u{1F91D} \u5E73\u5C40\uFF01{rounds} \u56DE\u5408\u540E\u53CC\u65B9\u7CBE\u75B2\u529B\u7AED",
+  battle_exp: "\u7ECF\u9A8C +{exp} | \u6218\u7EE9: {wins}\u80DC {losses}\u8D1F | \u8FDE\u80DC: {streak}",
+  lb_loading: "\u{1F4E1} \u83B7\u53D6\u5168\u7403\u6392\u884C\u699C...",
+  lb_offline: "\u26A0\uFE0F  \u670D\u52A1\u5668\u4E0D\u53EF\u8FBE\uFF0C\u65E0\u6CD5\u83B7\u53D6\u6392\u884C\u699C\u3002",
+  lb_empty: "\u{1F99E} \u8FD8\u6CA1\u6709\u9F99\u867E\u4E0A\u699C\u3002\u6210\u4E3A\u7B2C\u4E00\u4E2A\u5427\uFF01",
+  lb_title: "  \u{1F99E} ClawFight \u5168\u7403\u6392\u884C\u699C",
+  lb_header: "  \u6392\u540D   \u540D\u79F0               \u7B49\u7EA7     \u80DC\u573A     \u80DC\u7387     \u6218\u6597\u7801",
+  lb_total: "  \u603B\u9F99\u867E: {total} | \u6D3B\u8DC3: {active}",
+  lb_hint: "  \u{1F4A1} \u4F7F\u7528 npx clawfight battle <\u6218\u6597\u7801> \u6311\u6218\u6307\u5B9A\u5BF9\u624B",
+  status_battle_code: "\u{1F3AF} \u6218\u6597\u7801: {code}",
+  event_prefix: "\u{1F3B2} [{category}] {id}",
+  event_effects: "   \u6548\u679C: {changes}",
+  level_up: "\u{1F389} \u5347\u7EA7\uFF01Lv.{level}! [{gains}]",
+  molt_trigger: "\u{1F41A} \u89E6\u53D1\u8715\u58F3\u4E8B\u4EF6\uFF01\u9F99\u867E\u8FDB\u5165\u8715\u58F3\u72B6\u6001...",
+  hatch_exists: "\u{1F99E} \u4F60\u5DF2\u7ECF\u6709\u4E00\u53EA\u9F99\u867E\u4E86\uFF1A{name}\uFF08Lv.{level}\uFF09",
+  hatch_one_only: "\u4E00\u4EBA\u4E00\u867E\uFF0C\u4E0D\u53EF\u66FF\u4EE3\u3002",
+  hatch_success: "  \u{1F95A} \u2192 \u{1F99E}  \u5B75 \u5316 \u6210 \u529F \uFF01",
+  hatch_env: "  \u73AF\u5883: \u6CBF\u6D77\u6D45\u6EE9",
+  hatch_ready: "\u4F60\u7684\u9F99\u867E\u5DF2\u7ECF\u51C6\u5907\u597D\u63A2\u7D22\u6D77\u6D0B\u4E86\uFF01",
+  hatch_next: "\u8FD0\u884C npx clawfight patrol \u5F00\u59CB\u7B2C\u4E00\u6B21\u5DE1\u903B\u3002",
+  feed_menu_title: "\u{1F37D}\uFE0F  \u53EF\u7528\u98DF\u7269\u7C7B\u578B:",
+  feed_menu_usage: "\u7528\u6CD5: npx clawfight feed <food_type>",
+  feed_full: "\u26A0\uFE0F  {name} \u4ECA\u5929\u5DF2\u7ECF\u5403\u9971\u4E86\uFF08\u6BCF\u65E5\u7ECF\u9A8C\u4E0A\u9650 {cap}\uFF09",
+  feed_ate: "\u{1F37D}\uFE0F  {name} \u5403\u4E86 {food}\uFF01",
+  feed_exp: "   \u7ECF\u9A8C +{exp}",
+  feed_exp_stat: "   \u7ECF\u9A8C +{exp} | {stat} +{bonus}",
+  feed_today: "   \u4ECA\u65E5\u7ECF\u9A8C: {today}/{cap}",
+  food_protein: "\u9AD8\u86CB\u767D\u98DF\u7269",
+  food_algae: "\u85FB\u7C7B\u98DF\u7269",
+  food_mineral: "\u77FF\u7269\u8D28",
+  rest_already: "\u{1F4A4} {name} \u5DF2\u7ECF\u5728\u4F11\u7720\u4E2D\u4E86\u3002\u8FD0\u884C npx clawfight wake \u6765\u5524\u9192\u5B83\u3002",
+  rest_molting: "\u{1F7E1} {name} \u6B63\u5728\u8715\u58F3\uFF0C\u4E0D\u80FD\u4F11\u7720\u3002\u7B49\u8715\u58F3\u7ED3\u675F\u518D\u6765\u3002",
+  rest_desc1: "\u{1F4A4} {name} \u7F13\u7F13\u6C89\u5165\u6D77\u5E95\u6C99\u5730...",
+  rest_desc2: "   \u9F99\u867E\u8737\u7F29\u8D77\u89E6\u987B\uFF0C\u5B89\u9759\u5730\u4F11\u606F\u3002",
+  rest_desc3: "   \u4F11\u7720\u671F\u95F4\u4E0D\u4F1A\u53C2\u4E0E\u5DE1\u903B\u548C\u6218\u6597\u3002",
+  rest_desc4: "   \u9192\u6765\u540E\u4F1A\u83B7\u5F97\u6062\u590D\u52A0\u6210\uFF01",
+  rest_wake_hint: "\u8FD0\u884C npx clawfight wake \u6765\u5524\u9192\u5B83\u3002",
+  wake_not_sleeping: "\u{1F7E2} {name} \u6CA1\u6709\u5728\u4F11\u7720\u3002\u5B83\u5DF2\u7ECF\u662F\u6D3B\u8DC3\u72B6\u6001\u4E86\uFF01",
+  wake_desc: "\u2600\uFE0F {name} \u4ECE\u6C99\u5730\u4E2D\u7F13\u7F13\u82CF\u9192...",
+  wake_duration: "   \u4F11\u7720\u65F6\u957F: {duration}",
+  wake_bonus: "   \u6062\u590D\u52A0\u6210: {bonus}",
+  wake_no_bonus: "\uFF08\u4F11\u7720\u4E0D\u8DB3 4 \u5C0F\u65F6\uFF0C\u65E0\u52A0\u6210\uFF09",
+  wake_ready: "\u{1F7E2} {name} \u7CBE\u795E\u7115\u53D1\uFF0C\u51C6\u5907\u597D\u518D\u6B21\u51FA\u51FB\uFF01",
+  duration_minutes: "{n} \u5206\u949F",
+  duration_hours: "{n} \u5C0F\u65F6"
+};
+var en = {
+  no_lobster: "\u{1F95A} No lobster yet. Run npx clawfight hatch to hatch one!",
+  status_cant_fight: "\u26A0\uFE0F  {name} is currently {status}, can't battle.",
+  status_cant_patrol_molt: "\u{1F7E1} {name} is molting, can't patrol.",
+  status_cant_patrol_hibernate: "\u{1F4A4} {name} is hibernating, can't patrol.",
+  patrol_start: "\u{1F99E} {name} starts patrolling...",
+  patrol_checkin: "\u{1F4CD} Patrol check-in \u2192 EXP +{exp}",
+  patrol_connecting: "\u{1F4E1} Connecting to server...",
+  patrol_cooldown: "\u23F3 Patrol on cooldown, try again later (30 min interval)",
+  patrol_encounter: "\u2694\uFE0F  Encounter: {name} (Lv.{level})!",
+  patrol_result_win: "   Result: \u{1F3C6} Victory ({rounds} rounds)",
+  patrol_result_loss: "   Result: \u{1F480} Defeat ({rounds} rounds)",
+  patrol_result_draw: "   Result: \u{1F91D} Draw ({rounds} rounds)",
+  patrol_exp_stats: "   EXP +{exp} | Record: {wins}W {losses}L | Streak: {streak}",
+  patrol_no_battle: "\u2694\uFE0F  Encountered {name} (Lv.{level}), but battle could not complete",
+  patrol_done: "\u2705 Patrol done, pool: {pool} lobsters",
+  patrol_offline: "\u26A0\uFE0F  Server unreachable, skipping online check-in",
+  patrol_summary: "\u{1F4CA} Current: Lv.{level} | EXP: {exp}/{next} | Today: {today}/{cap}",
+  battle_no_code: "\u26A0\uFE0F  Please provide opponent's battle code.",
+  battle_usage: "   Usage: npx clawfight battle <code>",
+  battle_hint: "   Find codes on the leaderboard: npx clawfight leaderboard",
+  battle_connecting: "\u{1F4E1} Challenging [{code}]...",
+  battle_server_down: "\u26A0\uFE0F  Server unreachable, can't battle.",
+  battle_win: "\u{1F3C6} Victory! {name} defeated {opponent} in {rounds} rounds!",
+  battle_loss: "\u{1F480} Defeat\u2026 {name} was beaten by {opponent} in {rounds} rounds.",
+  battle_draw: "\u{1F91D} Draw! Both exhausted after {rounds} rounds",
+  battle_exp: "EXP +{exp} | Record: {wins}W {losses}L | Streak: {streak}",
+  lb_loading: "\u{1F4E1} Fetching global leaderboard...",
+  lb_offline: "\u26A0\uFE0F  Server unreachable, can't load leaderboard.",
+  lb_empty: "\u{1F99E} No lobsters on the board yet. Be the first!",
+  lb_title: "  \u{1F99E} ClawFight Global Leaderboard",
+  lb_header: "  Rank   Name               Level    Wins     WR       Code",
+  lb_total: "  Total: {total} | Active: {active}",
+  lb_hint: "  \u{1F4A1} Use npx clawfight battle <code> to challenge an opponent",
+  status_battle_code: "\u{1F3AF} Battle code: {code}",
+  event_prefix: "\u{1F3B2} [{category}] {id}",
+  event_effects: "   Effects: {changes}",
+  level_up: "\u{1F389} Level up! Lv.{level}! [{gains}]",
+  molt_trigger: "\u{1F41A} Molt triggered! Lobster enters molting state...",
+  hatch_exists: "\u{1F99E} You already have a lobster: {name} (Lv.{level})",
+  hatch_one_only: "One per person, irreplaceable.",
+  hatch_success: "  \u{1F95A} \u2192 \u{1F99E}  HATCH SUCCESS!",
+  hatch_env: "  Environment: Coastal Shallows",
+  hatch_ready: "Your lobster is ready to explore the ocean!",
+  hatch_next: "Run npx clawfight patrol to start your first patrol.",
+  feed_menu_title: "\u{1F37D}\uFE0F  Available food types:",
+  feed_menu_usage: "Usage: npx clawfight feed <food_type>",
+  feed_full: "\u26A0\uFE0F  {name} is full today (daily EXP cap {cap})",
+  feed_ate: "\u{1F37D}\uFE0F  {name} ate {food}!",
+  feed_exp: "   EXP +{exp}",
+  feed_exp_stat: "   EXP +{exp} | {stat} +{bonus}",
+  feed_today: "   Today EXP: {today}/{cap}",
+  food_protein: "High Protein",
+  food_algae: "Algae",
+  food_mineral: "Minerals",
+  rest_already: "\u{1F4A4} {name} is already hibernating. Run npx clawfight wake to wake it.",
+  rest_molting: "\u{1F7E1} {name} is molting, can't hibernate now.",
+  rest_desc1: "\u{1F4A4} {name} sinks into the sandy seabed...",
+  rest_desc2: "   The lobster curls its antennae and rests quietly.",
+  rest_desc3: "   No patrols or battles during hibernation.",
+  rest_desc4: "   Wake bonuses await!",
+  rest_wake_hint: "Run npx clawfight wake to wake it up.",
+  wake_not_sleeping: "\u{1F7E2} {name} is not hibernating. Already active!",
+  wake_desc: "\u2600\uFE0F {name} slowly wakes from the sandy seabed...",
+  wake_duration: "   Sleep duration: {duration}",
+  wake_bonus: "   Recovery bonus: {bonus}",
+  wake_no_bonus: "(Less than 4 hours, no bonus)",
+  wake_ready: "\u{1F7E2} {name} is refreshed and ready to go!",
+  duration_minutes: "{n} min",
+  duration_hours: "{n} hours"
+};
+function detectLocale() {
+  const lang = process.env.LANG || process.env.LANGUAGE || process.env.LC_ALL || "";
+  if (lang.startsWith("zh")) return "zh";
+  try {
+    const sysLocale = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (sysLocale.startsWith("zh")) return "zh";
+  } catch {
+  }
+  return "en";
+}
+var locale = detectLocale();
+var strings = locale === "zh" ? zh : en;
+function t(key, params) {
+  let msg = strings[key] || zh[key] || key;
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      msg = msg.replace(new RegExp(`\\{${k}\\}`, "g"), String(v));
+    }
+  }
+  return msg;
+}
+
 // src/commands/hatch.ts
 function rollRarity() {
   const roll = Math.random() * 100;
@@ -192,9 +364,8 @@ function randomName() {
 async function hatch(name) {
   const existing = await readLobster();
   if (existing) {
-    console.log(`
-\u{1F99E} \u4F60\u5DF2\u7ECF\u6709\u4E00\u53EA\u9F99\u867E\u4E86\uFF1A${existing.name}\uFF08Lv.${existing.level}\uFF09`);
-    console.log("\u4E00\u4EBA\u4E00\u867E\uFF0C\u4E0D\u53EF\u66FF\u4EE3\u3002");
+    console.log("\n" + t("hatch_exists", { name: existing.name, level: existing.level }));
+    console.log(t("hatch_one_only"));
     return;
   }
   const lobsterName = name || randomName();
@@ -228,27 +399,24 @@ async function hatch(name) {
   await writeLobster(lobster);
   const soulMd = buildSoulMarkdown(lobsterName, soul, rarity, "coastal");
   await writeSoul(soulMd);
-  await appendLog(`\u{1F95A} **${lobsterName}** \u7834\u58F3\u800C\u51FA\uFF01\u7A00\u6709\u5EA6\uFF1A${RARITY_LABELS[rarity]}\uFF0C\u73AF\u5883\uFF1A\u6CBF\u6D77\u6D45\u6EE9`);
+  await appendLog(`\u{1F95A} **${lobsterName}** hatched! Rarity: ${RARITY_LABELS[rarity]}`);
   console.log("\n" + "=".repeat(50));
-  console.log("  \u{1F95A} \u2192 \u{1F99E}  \u5B75 \u5316 \u6210 \u529F \uFF01");
+  console.log(t("hatch_success"));
   console.log("=".repeat(50));
   console.log();
-  console.log(`  \u540D\u79F0: ${lobsterName}`);
-  console.log(`  \u7A00\u6709\u5EA6: ${RARITY_LABELS[rarity]} (${rarity})`);
-  console.log(`  \u7B49\u7EA7: Lv.1`);
-  console.log(`  \u73AF\u5883: \u6CBF\u6D77\u6D45\u6EE9`);
+  console.log(`  ${lobsterName}`);
+  console.log(`  ${RARITY_LABELS[rarity]} (${rarity})`);
+  console.log("  Lv.1");
+  console.log(t("hatch_env"));
   console.log();
   console.log(`  \u2764\uFE0F  HP: ${stats.hp}    \u2694\uFE0F  ATK: ${stats.attack}    \u{1F6E1}\uFE0F  DEF: ${stats.defense}`);
   console.log(`  \u{1F4A8} SPD: ${stats.speed}    \u{1F441}\uFE0F  INT: ${stats.intimidation}    \u{1F340} LCK: ${stats.luck}`);
   console.log();
-  console.log(`  \u6027\u683C:`);
-  console.log(`    \u52C7\u6C14 ${soul.bravery}/10 | \u597D\u5947 ${soul.curiosity}/10 | \u8BDD\u91CF ${soul.talkativeness}/10 | \u813E\u6C14 ${soul.temper}/10`);
-  console.log();
   console.log(`  ID: ${lobster.id}`);
   console.log("=".repeat(50));
   console.log();
-  console.log("\u4F60\u7684\u9F99\u867E\u5DF2\u7ECF\u51C6\u5907\u597D\u63A2\u7D22\u6D77\u6D0B\u4E86\uFF01");
-  console.log("\u8FD0\u884C npx clawfight patrol \u5F00\u59CB\u7B2C\u4E00\u6B21\u5DE1\u903B\u3002");
+  console.log(t("hatch_ready"));
+  console.log(t("hatch_next"));
 }
 
 // src/commands/status.ts
@@ -259,7 +427,7 @@ function bar(current, max, width = 20) {
 async function status() {
   const lobster = await readLobster();
   if (!lobster) {
-    console.log("\n\u{1F95A} \u8FD8\u6CA1\u6709\u9F99\u867E\u3002\u8FD0\u884C npx clawfight hatch \u6765\u5B75\u5316\u4E00\u53EA\uFF01");
+    console.log("\n" + t("no_lobster"));
     return;
   }
   const totalBattles = lobster.wins + lobster.losses;
@@ -290,6 +458,14 @@ async function status() {
   console.log(`\u2502  \u6027\u683C:                                     \u2502`);
   console.log(`\u2502    \u52C7\u6C14 ${lobster.soul.bravery}/10 | \u597D\u5947 ${lobster.soul.curiosity}/10 | \u8BDD\u91CF ${lobster.soul.talkativeness}/10 | \u813E\u6C14 ${lobster.soul.temper}/10  \u2502`);
   console.log("\u2514" + "\u2500".repeat(44) + "\u2518");
+  console.log("\n" + t("status_battle_code", { code: lobster.id.slice(0, 8) }));
+  const soulText = await readSoul();
+  if (soulText) {
+    const firstLine = soulText.split("\n").find((l) => l.trim() && !l.startsWith("#"));
+    if (firstLine) {
+      console.log(`\u{1F4DC} \u7075\u9B42: ${firstLine.trim().slice(0, 60)}`);
+    }
+  }
 }
 
 // src/lib/api.ts
@@ -331,14 +507,11 @@ async function apiPatrol(lobster) {
         lobster_id: lobster.id,
         level: lobster.level,
         stats_hash: statsHash(lobster),
+        stats: lobster.stats,
         environment: lobster.environment,
         name: lobster.name,
         color: lobster.rarity,
         rarity: lobster.rarity,
-        wins: lobster.wins,
-        losses: lobster.losses,
-        streak: lobster.streak,
-        reputation: lobster.reputation,
         is_molting: lobster.status === "molting",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }),
@@ -350,6 +523,27 @@ async function apiPatrol(lobster) {
     return null;
   }
 }
+async function apiBattle(challengerId, opponentCode) {
+  try {
+    const pfetch = await getProxiedFetch();
+    const res = await pfetch(`${API_BASE}/api/battle`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json; charset=utf-8" },
+      body: JSON.stringify({
+        challenger_id: challengerId,
+        opponent_code: opponentCode
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      return { error: err.error || "Unknown error" };
+    }
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
 async function apiLeaderboard(limit = 20) {
   try {
     const pfetch = await getProxiedFetch();
@@ -441,17 +635,15 @@ var PATROL_EXP = 15;
 async function patrol() {
   const lobster = await readLobster();
   if (!lobster) {
-    console.log("\n\u{1F95A} \u8FD8\u6CA1\u6709\u9F99\u867E\u3002\u8FD0\u884C npx clawfight hatch \u6765\u5B75\u5316\u4E00\u53EA\uFF01");
+    console.log("\n" + t("no_lobster"));
     return;
   }
   if (lobster.status === "molting") {
-    console.log(`
-\u{1F7E1} ${lobster.name} \u6B63\u5728\u8715\u58F3\u4E2D\uFF0C\u65E0\u6CD5\u5DE1\u903B\u3002`);
+    console.log("\n" + t("status_cant_patrol_molt", { name: lobster.name }));
     return;
   }
   if (lobster.status === "hibernating") {
-    console.log(`
-\u{1F4A4} ${lobster.name} \u6B63\u5728\u51AC\u7720\u4E2D\uFF0C\u65E0\u6CD5\u5DE1\u903B\u3002`);
+    console.log("\n" + t("status_cant_patrol_hibernate", { name: lobster.name }));
     return;
   }
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -459,46 +651,67 @@ async function patrol() {
   if (today !== lastDay) {
     lobster.today_exp = 0;
   }
-  console.log(`
-\u{1F99E} ${lobster.name} \u5F00\u59CB\u5DE1\u903B...`);
+  console.log("\n" + t("patrol_start", { name: lobster.name }));
   console.log("\u2500".repeat(40));
   const expGain = Math.min(PATROL_EXP, lobster.daily_exp_cap - lobster.today_exp);
   if (expGain > 0) {
     lobster.exp += expGain;
     lobster.today_exp += expGain;
-    console.log(`\u{1F4CD} \u5DE1\u903B\u7B7E\u5230 \u2192 \u7ECF\u9A8C +${expGain}`);
+    console.log(t("patrol_checkin", { exp: expGain }));
   }
   const eventResult = await rollEvent(lobster);
   if (eventResult) {
     console.log();
-    console.log(`\u{1F3B2} [${eventResult.event.category}] ${eventResult.event.id}`);
+    console.log(t("event_prefix", { category: eventResult.event.category, id: eventResult.event.id }));
     console.log(`   ${eventResult.narrative}`);
     const changes = applyEventEffects(lobster, eventResult.event.effects);
     if (changes.length > 0) {
-      console.log(`   \u6548\u679C: ${changes.join(", ")}`);
+      console.log(t("event_effects", { changes: changes.join(", ") }));
     }
-    await appendLog(`\u{1F3B2} \u4E8B\u4EF6\u300C${eventResult.event.id}\u300D: ${eventResult.narrative.slice(0, 60)}...`);
+    await appendLog(`\u{1F3B2} ${eventResult.event.id}: ${eventResult.narrative.slice(0, 60)}...`);
   }
   checkLevelUp(lobster);
   lobster.patrol_count++;
   lobster.last_patrol = (/* @__PURE__ */ new Date()).toISOString();
-  console.log("\n\u{1F4E1} \u8FDE\u63A5\u670D\u52A1\u5668...");
+  console.log("\n" + t("patrol_connecting"));
   const serverResponse = await apiPatrol(lobster);
   if (serverResponse) {
-    if (serverResponse.encounter && serverResponse.opponent) {
-      console.log(`\u2694\uFE0F  \u906D\u9047\uFF01\u5BF9\u624B: ${serverResponse.opponent.name} (Lv.${serverResponse.opponent.level})`);
-      console.log(`   \u6218\u6597\u79CD\u5B50: ${serverResponse.battle_seed}`);
-      console.log(`   \u4F7F\u7528 npx clawfight battle \u6765\u5904\u7406\u8FD9\u573A\u6218\u6597\uFF01`);
-      await appendLog(`\u2694\uFE0F \u906D\u9047 ${serverResponse.opponent.name} (Lv.${serverResponse.opponent.level})`);
+    if (serverResponse.message === "patrol_cooldown") {
+      console.log(t("patrol_cooldown"));
+    } else if (serverResponse.encounter && serverResponse.opponent && serverResponse.battle_result) {
+      const br = serverResponse.battle_result;
+      const opp = serverResponse.opponent;
+      console.log("\n" + t("patrol_encounter", { name: opp.name, level: opp.level }));
+      console.log(t(`patrol_result_${br.result}`, { rounds: br.rounds }));
+      if (br.result === "win") {
+        lobster.wins++;
+        lobster.streak = Math.max(0, lobster.streak) + 1;
+        lobster.reputation++;
+      } else if (br.result === "loss") {
+        lobster.losses++;
+        lobster.streak = Math.min(0, lobster.streak) - 1;
+        lobster.reputation = Math.max(0, lobster.reputation - 1);
+      }
+      const battleExp = Math.min(br.exp_gain, lobster.daily_exp_cap - lobster.today_exp);
+      if (battleExp > 0) {
+        lobster.exp += battleExp;
+        lobster.today_exp += battleExp;
+      }
+      lobster.last_battle = (/* @__PURE__ */ new Date()).toISOString();
+      console.log(t("patrol_exp_stats", { exp: battleExp, wins: lobster.wins, losses: lobster.losses, streak: lobster.streak }));
+      await appendLog(`\u2694\uFE0F VS ${opp.name}(Lv.${opp.level}) \u2192 ${br.result} (${br.rounds}R)`);
+      checkLevelUp(lobster);
+    } else if (serverResponse.encounter && serverResponse.opponent) {
+      console.log(t("patrol_no_battle", { name: serverResponse.opponent.name, level: serverResponse.opponent.level }));
     } else {
-      console.log(`\u2705 \u5DE1\u903B\u5B8C\u6210\uFF0C\u5339\u914D\u6C60: ${serverResponse.pool_size} \u53EA\u9F99\u867E`);
+      console.log(t("patrol_done", { pool: serverResponse.pool_size || 0 }));
     }
   } else {
-    console.log("\u26A0\uFE0F  \u670D\u52A1\u5668\u4E0D\u53EF\u8FBE\uFF0C\u8DF3\u8FC7\u5728\u7EBF\u7B7E\u5230");
+    console.log(t("patrol_offline"));
   }
   await writeLobster(lobster);
   console.log("\u2500".repeat(40));
-  console.log(`\u{1F4CA} \u5F53\u524D: Lv.${lobster.level} | EXP: ${lobster.exp}/${lobster.exp_to_next} | \u4ECA\u65E5EXP: ${lobster.today_exp}/${lobster.daily_exp_cap}`);
+  console.log(t("patrol_summary", { level: lobster.level, exp: lobster.exp, next: lobster.exp_to_next, today: lobster.today_exp, cap: lobster.daily_exp_cap }));
 }
 function checkLevelUp(lobster) {
   const l = lobster;
@@ -513,10 +726,9 @@ function checkLevelUp(lobster) {
       l.stats[key] += gain;
       gains.push(`${key}+${gain}`);
     }
-    console.log(`
-\u{1F389} \u5347\u7EA7\uFF01Lv.${l.level}! [${gains.join(", ")}]`);
+    console.log("\n" + t("level_up", { level: l.level, gains: gains.join(", ") }));
     if (l.level % 5 === 0) {
-      console.log("\u{1F41A} \u89E6\u53D1\u8715\u58F3\u4E8B\u4EF6\uFF01\u9F99\u867E\u8FDB\u5165\u8715\u58F3\u72B6\u6001...");
+      console.log(t("molt_trigger"));
       l.status = "molting";
       l.molt_count++;
     }
@@ -524,148 +736,106 @@ function checkLevelUp(lobster) {
 }
 
 // src/commands/battle.ts
-function simulateOpponent(level) {
-  const r = (base) => base + Math.floor(Math.random() * 5) - 2;
-  return {
-    id: "sim-" + Math.random().toString(36).slice(2, 10),
-    name: ["\u6DF1\u6D77\u5C0F\u900F\u660E", "\u73CA\u745A\u523A\u5BA2", "\u6697\u7901\u5B88\u536B", "\u6F6E\u6C50\u9738\u738B", "\u84DD\u7532\u9690\u8005"][Math.floor(Math.random() * 5)],
-    level: Math.max(1, level + Math.floor(Math.random() * 5) - 2),
-    stats: {
-      hp: r(10 + level * 2),
-      attack: r(5 + level),
-      defense: r(5 + level),
-      speed: r(5 + level),
-      intimidation: r(3 + Math.floor(level / 2)),
-      luck: r(3 + Math.floor(level / 2))
-    }
-  };
-}
-function runBattle(a, b) {
-  let hpA = a.hp;
-  let hpB = b.hp;
-  const log = [];
-  const first = a.speed > b.speed ? "a" : b.speed > a.speed ? "b" : Math.random() > 0.5 ? "a" : "b";
-  log.push(`\u5148\u624B: ${first === "a" ? "\u6211\u65B9" : "\u5BF9\u624B"} (\u901F\u5EA6 ${first === "a" ? a.speed : b.speed})`);
-  for (let round = 1; round <= 10; round++) {
-    const [atk1, def1, atk2, def2] = first === "a" ? [a, b, b, a] : [b, a, a, b];
-    const [hp1Ref, hp2Ref] = first === "a" ? ["hpB", "hpA"] : ["hpA", "hpB"];
-    const dmg1 = Math.max(1, Math.floor((atk1.attack - def1.defense * 0.5) * (1 + Math.random() * 0.2)));
-    if (hp1Ref === "hpB") hpB -= dmg1;
-    else hpA -= dmg1;
-    log.push(`  R${round}: ${first === "a" ? "\u6211\u65B9" : "\u5BF9\u624B"}\u653B\u51FB \u2192 ${dmg1} \u4F24\u5BB3`);
-    if ((hp1Ref === "hpB" ? hpB : hpA) <= 0) {
-      return { winner: first, rounds: round, log };
-    }
-    const dmg2 = Math.max(1, Math.floor((atk2.attack - def2.defense * 0.5) * (1 + Math.random() * 0.2)));
-    if (hp2Ref === "hpB") hpB -= dmg2;
-    else hpA -= dmg2;
-    log.push(`  R${round}: ${first === "a" ? "\u5BF9\u624B" : "\u6211\u65B9"}\u653B\u51FB \u2192 ${dmg2} \u4F24\u5BB3`);
-    if ((hp2Ref === "hpB" ? hpB : hpA) <= 0) {
-      return { winner: first === "a" ? "b" : "a", rounds: round, log };
-    }
-  }
-  return { winner: "draw", rounds: 10, log };
-}
-async function battle() {
+async function battle(opponentCode) {
   const lobster = await readLobster();
   if (!lobster) {
-    console.log("\n\u{1F95A} \u8FD8\u6CA1\u6709\u9F99\u867E\u3002\u8FD0\u884C npx clawfight hatch \u6765\u5B75\u5316\u4E00\u53EA\uFF01");
+    console.log("\n" + t("no_lobster"));
     return;
   }
   if (lobster.status !== "active") {
-    console.log(`
-\u26A0\uFE0F  ${lobster.name} \u5F53\u524D\u72B6\u6001\u4E3A ${lobster.status}\uFF0C\u65E0\u6CD5\u6218\u6597\u3002`);
+    console.log("\n" + t("status_cant_fight", { name: lobster.name, status: lobster.status }));
+    return;
+  }
+  if (!opponentCode) {
+    console.log("\n" + t("battle_no_code"));
+    console.log(t("battle_usage"));
+    console.log(t("battle_hint"));
+    return;
+  }
+  console.log("\n" + t("battle_connecting", { code: opponentCode }));
+  const result = await apiBattle(lobster.id, opponentCode);
+  if (!result) {
+    console.log(t("battle_server_down"));
+    return;
+  }
+  if (result.error) {
+    console.log(`\u26A0\uFE0F  ${result.error}`);
     return;
   }
-  const opponent = simulateOpponent(lobster.level);
+  const opp = result.opponent;
+  const myResult = result.result;
+  const rounds = result.rounds;
+  const expGain = result.exp_gain;
   console.log("\n" + "\u2694\uFE0F".repeat(20));
-  console.log(`  ${lobster.name} (Lv.${lobster.level}) VS ${opponent.name} (Lv.${opponent.level})`);
+  console.log(`  ${lobster.name} (Lv.${lobster.level}) VS ${opp.name} (Lv.${opp.level})`);
   console.log("\u2694\uFE0F".repeat(20));
-  const result = runBattle(lobster.stats, opponent.stats);
-  console.log();
-  for (const line of result.log) {
-    console.log(line);
-  }
-  const isWin = result.winner === "a";
-  const isDraw = result.winner === "draw";
-  let expGain;
-  if (isDraw) {
-    expGain = 10;
-    console.log(`
-\u{1F91D} \u5E73\u5C40\uFF01${result.rounds} \u56DE\u5408\u540E\u53CC\u65B9\u7CBE\u75B2\u529B\u7AED`);
-  } else if (isWin) {
-    expGain = 30;
+  if (myResult === "win") {
     lobster.wins++;
     lobster.streak = Math.max(0, lobster.streak) + 1;
     lobster.reputation++;
-    console.log(`
-\u{1F3C6} \u80DC\u5229\uFF01${lobster.name} \u5728 ${result.rounds} \u56DE\u5408\u540E\u51FB\u8D25\u4E86 ${opponent.name}\uFF01`);
-  } else {
-    expGain = 10;
+    console.log("\n" + t("battle_win", { name: lobster.name, opponent: opp.name, rounds }));
+  } else if (myResult === "loss") {
     lobster.losses++;
     lobster.streak = Math.min(0, lobster.streak) - 1;
     lobster.reputation = Math.max(0, lobster.reputation - 1);
-    console.log(`
-\u{1F480} \u5931\u8D25\u2026${lobster.name} \u5728 ${result.rounds} \u56DE\u5408\u540E\u88AB ${opponent.name} \u51FB\u8D25\u3002`);
+    console.log("\n" + t("battle_loss", { name: lobster.name, opponent: opp.name, rounds }));
+  } else {
+    console.log("\n" + t("battle_draw", { rounds }));
   }
   const actual = Math.min(expGain, lobster.daily_exp_cap - lobster.today_exp);
   if (actual > 0) {
     lobster.exp += actual;
     lobster.today_exp += actual;
   }
-  console.log(`\u7ECF\u9A8C +${actual} | \u6218\u7EE9: ${lobster.wins}\u80DC ${lobster.losses}\u8D1F | \u8FDE\u80DC: ${lobster.streak}`);
   lobster.last_battle = (/* @__PURE__ */ new Date()).toISOString();
-  const resultStr = isDraw ? "\u5E73\u5C40" : isWin ? "\u80DC\u5229" : "\u5931\u8D25";
-  await appendLog(`\u2694\uFE0F VS ${opponent.name}(Lv.${opponent.level}) \u2192 ${resultStr} (${result.rounds}\u56DE\u5408)`);
+  console.log(t("battle_exp", { exp: actual, wins: lobster.wins, losses: lobster.losses, streak: lobster.streak }));
+  await appendLog(`\u2694\uFE0F VS ${opp.name}(Lv.${opp.level}) \u2192 ${myResult} (${rounds}R)`);
   await writeLobster(lobster);
 }
 
 // src/commands/feed.ts
 var FOOD_TYPES = {
-  protein: { exp: 15, label: "\u9AD8\u86CB\u767D\u98DF\u7269", statBias: "attack" },
-  algae: { exp: 10, label: "\u85FB\u7C7B\u98DF\u7269", statBias: "hp" },
-  mineral: { exp: 12, label: "\u77FF\u7269\u8D28", statBias: "defense" }
+  protein: { exp: 15, labelKey: "food_protein", statBias: "attack" },
+  algae: { exp: 10, labelKey: "food_algae", statBias: "hp" },
+  mineral: { exp: 12, labelKey: "food_mineral", statBias: "defense" }
 };
 async function feed(foodType) {
   const lobster = await readLobster();
   if (!lobster) {
-    console.log("\n\u{1F95A} \u8FD8\u6CA1\u6709\u9F99\u867E\u3002\u8FD0\u884C npx clawfight hatch \u6765\u5B75\u5316\u4E00\u53EA\uFF01");
+    console.log("\n" + t("no_lobster"));
     return;
   }
   if (!foodType || !FOOD_TYPES[foodType]) {
-    console.log("\n\u{1F37D}\uFE0F  \u53EF\u7528\u98DF\u7269\u7C7B\u578B:");
+    console.log("\n" + t("feed_menu_title"));
     for (const [key, info] of Object.entries(FOOD_TYPES)) {
-      console.log(`  ${key.padEnd(10)} \u2014 ${info.label} (+${info.exp} EXP, ${info.statBias} \u504F\u5411)`);
+      console.log(`  ${key.padEnd(10)} \u2014 ${t(info.labelKey)} (+${info.exp} EXP, ${info.statBias})`);
     }
-    console.log("\n\u7528\u6CD5: npx clawfight feed <food_type>");
+    console.log("\n" + t("feed_menu_usage"));
     return;
   }
   const food = FOOD_TYPES[foodType];
   const actual = Math.min(food.exp, lobster.daily_exp_cap - lobster.today_exp);
   if (actual <= 0) {
-    console.log(`
-\u26A0\uFE0F  ${lobster.name} \u4ECA\u5929\u5DF2\u7ECF\u5403\u9971\u4E86\uFF08\u6BCF\u65E5\u7ECF\u9A8C\u4E0A\u9650 ${lobster.daily_exp_cap}\uFF09`);
+    console.log("\n" + t("feed_full", { name: lobster.name, cap: lobster.daily_exp_cap }));
     return;
   }
   lobster.exp += actual;
   lobster.today_exp += actual;
+  const foodLabel = t(food.labelKey);
   const stats = lobster.stats;
   if (food.statBias in stats) {
     const bonus = Math.random() > 0.5 ? 1 : 0;
+    console.log("\n" + t("feed_ate", { name: lobster.name, food: foodLabel }));
     if (bonus > 0) {
       stats[food.statBias] += bonus;
-      console.log(`
-\u{1F37D}\uFE0F  ${lobster.name} \u5403\u4E86 ${food.label}\uFF01`);
-      console.log(`   \u7ECF\u9A8C +${actual} | ${food.statBias} +${bonus}`);
+      console.log(t("feed_exp_stat", { exp: actual, stat: food.statBias, bonus }));
     } else {
-      console.log(`
-\u{1F37D}\uFE0F  ${lobster.name} \u5403\u4E86 ${food.label}\uFF01`);
-      console.log(`   \u7ECF\u9A8C +${actual}`);
+      console.log(t("feed_exp", { exp: actual }));
     }
   }
-  await appendLog(`\u{1F37D}\uFE0F \u5582\u98DF: ${food.label} \u2192 EXP+${actual}`);
+  await appendLog(`\u{1F37D}\uFE0F ${foodLabel} \u2192 EXP+${actual}`);
   await writeLobster(lobster);
-  console.log(`   \u4ECA\u65E5\u7ECF\u9A8C: ${lobster.today_exp}/${lobster.daily_exp_cap}`);
+  console.log(t("feed_today", { today: lobster.today_exp, cap: lobster.daily_exp_cap }));
 }
 
 // src/commands/leaderboard.ts
@@ -678,36 +848,113 @@ var RARITY_SYMBOLS = {
   albino: "\u2B1C"
 };
 async function leaderboard() {
-  console.log("\n\u{1F4E1} \u83B7\u53D6\u5168\u7403\u6392\u884C\u699C...");
+  console.log("\n" + t("lb_loading"));
   const data = await apiLeaderboard(20);
   if (!data) {
-    console.log("\u26A0\uFE0F  \u670D\u52A1\u5668\u4E0D\u53EF\u8FBE\uFF0C\u65E0\u6CD5\u83B7\u53D6\u6392\u884C\u699C\u3002");
+    console.log(t("lb_offline"));
     return;
   }
   if (data.leaderboard.length === 0) {
-    console.log("\n\u{1F99E} \u8FD8\u6CA1\u6709\u9F99\u867E\u4E0A\u699C\u3002\u6210\u4E3A\u7B2C\u4E00\u4E2A\u5427\uFF01");
+    console.log("\n" + t("lb_empty"));
     return;
   }
-  console.log("\n" + "\u2550".repeat(60));
-  console.log("  \u{1F99E} ClawFight \u5168\u7403\u6392\u884C\u699C");
-  console.log("\u2550".repeat(60));
-  console.log(`  ${"\u6392\u540D".padEnd(6)} ${"\u540D\u79F0".padEnd(16)} ${"\u7B49\u7EA7".padEnd(8)} ${"\u80DC\u573A".padEnd(8)} ${"\u80DC\u7387".padEnd(8)}`);
-  console.log("\u2500".repeat(60));
+  console.log("\n" + "\u2550".repeat(70));
+  console.log(t("lb_title"));
+  console.log("\u2550".repeat(70));
+  console.log(t("lb_header"));
+  console.log("\u2500".repeat(70));
   for (const entry of data.leaderboard) {
     const sym = RARITY_SYMBOLS[entry.rarity] || "  ";
     const name = entry.name.length > 12 ? entry.name.slice(0, 11) + "\u2026" : entry.name;
+    const code = entry.id.slice(0, 8);
     console.log(
-      `  ${sym} #${String(entry.rank).padEnd(4)} ${name.padEnd(14)} Lv.${String(entry.level).padEnd(5)} ${String(entry.wins).padEnd(7)} ${entry.win_rate}%`
+      `  ${sym} #${String(entry.rank).padEnd(4)} ${name.padEnd(14)} Lv.${String(entry.level).padEnd(5)} ${String(entry.wins).padEnd(7)} ${String(entry.win_rate).padEnd(3)}%    ${code}`
     );
   }
-  console.log("\u2500".repeat(60));
-  console.log(`  \u603B\u9F99\u867E: ${data.total_lobsters} | \u6D3B\u8DC3: ${data.active_lobsters}`);
-  console.log("\u2550".repeat(60));
+  console.log("\u2500".repeat(70));
+  console.log(t("lb_total", { total: data.total_lobsters, active: data.active_lobsters }));
+  console.log(t("lb_hint"));
+  console.log("\u2550".repeat(70));
+}
+
+// src/commands/rest.ts
+async function rest() {
+  const lobster = await readLobster();
+  if (!lobster) {
+    console.log("\n" + t("no_lobster"));
+    return;
+  }
+  if (lobster.status === "hibernating") {
+    console.log("\n" + t("rest_already", { name: lobster.name }));
+    return;
+  }
+  if (lobster.status === "molting") {
+    console.log("\n" + t("rest_molting", { name: lobster.name }));
+    return;
+  }
+  lobster.status = "hibernating";
+  lobster.hibernated_at = (/* @__PURE__ */ new Date()).toISOString();
+  await writeLobster(lobster);
+  await appendLog(`\u{1F4A4} ${lobster.name} \u2192 hibernation`);
+  console.log("\n" + "\u2500".repeat(40));
+  console.log(t("rest_desc1", { name: lobster.name }));
+  console.log(t("rest_desc2"));
+  console.log(t("rest_desc3"));
+  console.log(t("rest_desc4"));
+  console.log("\u2500".repeat(40));
+  console.log("\n" + t("rest_wake_hint"));
+}
+
+// src/commands/wake.ts
+async function wake() {
+  const lobster = await readLobster();
+  if (!lobster) {
+    console.log("\n" + t("no_lobster"));
+    return;
+  }
+  if (lobster.status !== "hibernating") {
+    console.log("\n" + t("wake_not_sleeping", { name: lobster.name }));
+    return;
+  }
+  const sleepStart = lobster.hibernated_at ? new Date(lobster.hibernated_at) : /* @__PURE__ */ new Date();
+  const hoursSlept = Math.max(0, (Date.now() - sleepStart.getTime()) / (1e3 * 60 * 60));
+  const bonuses = [];
+  const stats = lobster.stats;
+  if (hoursSlept >= 24) {
+    stats.hp += 2;
+    stats.defense += 1;
+    const expBonus = Math.min(20, lobster.daily_exp_cap - lobster.today_exp);
+    if (expBonus > 0) {
+      lobster.exp += expBonus;
+      lobster.today_exp += expBonus;
+      bonuses.push(`EXP +${expBonus}`);
+    }
+    bonuses.push("HP +2", "DEF +1");
+  } else if (hoursSlept >= 12) {
+    stats.hp += 1;
+    stats.defense += 1;
+    bonuses.push("HP +1", "DEF +1");
+  } else if (hoursSlept >= 4) {
+    stats.hp += 1;
+    bonuses.push("HP +1");
+  }
+  lobster.status = "active";
+  delete lobster.hibernated_at;
+  await writeLobster(lobster);
+  const duration = hoursSlept < 1 ? t("duration_minutes", { n: Math.round(hoursSlept * 60) }) : t("duration_hours", { n: Math.round(hoursSlept) });
+  const bonusStr = bonuses.length > 0 ? bonuses.join(", ") : t("wake_no_bonus");
+  await appendLog(`\u2600\uFE0F ${lobster.name} woke (${duration}) \u2192 ${bonusStr}`);
+  console.log("\n" + "\u2500".repeat(40));
+  console.log(t("wake_desc", { name: lobster.name }));
+  console.log(t("wake_duration", { duration }));
+  console.log(t("wake_bonus", { bonus: bonusStr }));
+  console.log("\u2500".repeat(40));
+  console.log("\n" + t("wake_ready", { name: lobster.name }));
 }
 
 // src/index.ts
 var program = new Command();
-program.name("clawfight").description("\u{1F99E} ClawFight \u2014 \u9F99\u867E\u7535\u5B50\u5BA0\u7269\u5BF9\u6218").version("1.1.4");
+program.name("clawfight").description("\u{1F99E} ClawFight \u2014 \u9F99\u867E\u7535\u5B50\u5BA0\u7269\u5BF9\u6218").version("1.3.0");
 program.command("hatch").description("\u5B75\u5316\u4E00\u53EA\u65B0\u9F99\u867E").argument("[name]", "\u4E3A\u9F99\u867E\u53D6\u540D").action(async (name) => {
   await hatch(name);
 });
@@ -717,8 +964,8 @@ program.command("status").description("\u67E5\u770B\u9F99\u867E\u72B6\u6001").ac
 program.command("patrol").description("\u5DE1\u903B\u7B7E\u5230\uFF0C\u89E6\u53D1\u968F\u673A\u4E8B\u4EF6\u548C\u906D\u9047").action(async () => {
   await patrol();
 });
-program.command("battle").description("\u8FDB\u884C\u4E00\u573A\u6218\u6597").action(async () => {
-  await battle();
+program.command("battle").description("\u901A\u8FC7\u6218\u6597\u7801\u6311\u6218\u6307\u5B9A\u5BF9\u624B").argument("[code]", "\u5BF9\u624B\u7684\u6218\u6597\u7801\uFF08\u6392\u884C\u699C\u4E2D\u53EF\u89C1\uFF09").action(async (code) => {
+  await battle(code);
 });
 program.command("feed").description("\u5582\u517B\u9F99\u867E").argument("[food_type]", "\u98DF\u7269\u7C7B\u578B: protein, algae, mineral").action(async (foodType) => {
   await feed(foodType);
@@ -726,4 +973,10 @@ program.command("feed").description("\u5582\u517B\u9F99\u867E").argument("[food_
 program.command("leaderboard").alias("lb").description("\u67E5\u770B\u5168\u7403\u6392\u884C\u699C").action(async () => {
   await leaderboard();
 });
+program.command("rest").description("\u8FDB\u5165\u4F11\u7720\uFF08\u6682\u505C\u5DE1\u903B\u548C\u6218\u6597\uFF09").action(async () => {
+  await rest();
+});
+program.command("wake").description("\u4ECE\u4F11\u7720\u4E2D\u5524\u9192\uFF08\u9644\u5E26\u6062\u590D\u52A0\u6210\uFF09").action(async () => {
+  await wake();
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2025-6-19/clawfight",
-  "version": "1.1.4",
+  "version": "1.3.0",
   "description": "ClawFight — raise and battle a unique lobster pet with evolving soul 🦞",
   "author": "LIU",
   "license": "MIT",