limbo-ai 1.31.0 → 1.32.0

package/.gitlab-ci.yml

@@ -186,6 +186,7 @@ release:
       git add package.json
       git commit -m "chore: release v${VERSION} [skip ci]"
       git tag "v${VERSION}"
+      git checkout -B main
       git push origin main --follow-tags
 
       # Create GitLab Release

package/RELEASES.md

@@ -0,0 +1,32 @@
+# Limbo Releases
+
+> User-facing changelog. The section for the latest version (above the first `---`)
+> is sent to users as the update notification in Telegram. Keep it non-technical
+> and human-readable. Technical details go below the `---` separator.
+>
+> Format:
+> ```
+> ## vX.Y.Z
+>
+> - Human-readable change 1
+> - Human-readable change 2
+>
+> ---
+>
+> ### Technical changelog
+> - feat: technical description (#PR)
+> - fix: technical description (#PR)
+> ```
+
+## v1.30.0
+
+- Limbo now notifies you when a new version is available
+- You can update directly from Telegram with one tap
+- Improved startup reliability
+
+---
+
+### Technical changelog
+- feat: update notification system with wakeup routine
+- feat: update_instance MCP tool + flag-file bridge to host
+- feat: telegram-notify lib for deterministic system messages

package/cli.js

@@ -23,8 +23,10 @@ const LIMBO_DIR = (() => {
 })();
 const VAULT_DIR = path.join(LIMBO_DIR, 'vault');
 const OPENCLAW_STATE_DIR = path.join(LIMBO_DIR, 'openclaw-state');
+const FLAGS_DIR = path.join(LIMBO_DIR, 'flags');
 const SECRETS_DIR = path.join(LIMBO_DIR, 'secrets');
-const ENV_FILE = path.join(LIMBO_DIR, '.env');
+const CONFIG_DIR = path.join(LIMBO_DIR, 'config');
+const ENV_FILE = path.join(CONFIG_DIR, '.env');
 const COMPOSE_FILE = path.join(LIMBO_DIR, 'docker-compose.yml');
 const DEFAULT_REGISTRY = 'registry.gitlab.com/tomas209/limbo';
 const REGISTRY_IMAGE = process.env.LIMBO_REGISTRY || DEFAULT_REGISTRY;
@@ -184,6 +186,8 @@ function composeContent() {
       - limbo-data:/data
       - ${VAULT_DIR}:/data/vault
       - ${OPENCLAW_STATE_DIR}:/home/limbo/.openclaw
+      - ${CONFIG_DIR}:/data/config
+      - ${FLAGS_DIR}:/flags
     secrets:
       - llm_api_key
       - telegram_bot_token
@@ -191,14 +195,14 @@ function composeContent() {
       - groq_api_key
       - brave_api_key
     env_file:
-      - ${LIMBO_DIR}/.env
+      - ${ENV_FILE}
     environment:
       LIMBO_PORT: "${PORT}"
       NODE_OPTIONS: "\${LIMBO_NODE_OPTIONS:---max-old-space-size=512}"
 ${resolveExtraEnv()}    healthcheck:
       test:
         - CMD-SHELL
-        - node -e "fetch('http://localhost:'\${LIMBO_PORT:-18789}'/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
+        - node -e "fetch('http://localhost:${PORT}/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
       interval: 10s
       timeout: 5s
       retries: 3
@@ -246,6 +250,8 @@ function composeContentHardened() {
       - limbo-data:/data
       - ${VAULT_DIR}:/data/vault
       - ${OPENCLAW_STATE_DIR}:/home/limbo/.openclaw
+      - ${CONFIG_DIR}:/data/config
+      - ${FLAGS_DIR}:/flags
     secrets:
       - llm_api_key
       - telegram_bot_token
@@ -253,7 +259,7 @@ function composeContentHardened() {
       - groq_api_key
       - brave_api_key
     env_file:
-      - ${LIMBO_DIR}/.env
+      - ${ENV_FILE}
     environment:
       LIMBO_PORT: "${PORT}"
       NODE_OPTIONS: "\${LIMBO_NODE_OPTIONS:---max-old-space-size=512}"
@@ -265,7 +271,7 @@ ${resolveExtraEnv()}    networks:
     healthcheck:
       test:
         - CMD-SHELL
-        - node -e "fetch('http://localhost:'\${LIMBO_PORT:-18789}'/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
+        - node -e "fetch('http://localhost:${PORT}/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
       interval: 10s
       timeout: 5s
       retries: 3
@@ -1105,8 +1111,17 @@ function ensureComposeFile(hardened = false) {
   fs.mkdirSync(path.join(VAULT_DIR, 'notes'), { recursive: true });
   fs.mkdirSync(path.join(VAULT_DIR, 'maps'), { recursive: true });
   fs.mkdirSync(OPENCLAW_STATE_DIR, { recursive: true });
+  fs.mkdirSync(FLAGS_DIR, { recursive: true });
   migrateLegacyState();
   fs.mkdirSync(SECRETS_DIR, { recursive: true, mode: 0o700 });
+  // Ensure config dir and .env exist (bind-mounted into container as /data/config/)
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  // Migrate legacy .env from LIMBO_DIR root to config/ subdir
+  const legacyEnv = path.join(LIMBO_DIR, '.env');
+  if (legacyEnv !== ENV_FILE && fs.existsSync(legacyEnv) && !fs.existsSync(ENV_FILE)) {
+    fs.renameSync(legacyEnv, ENV_FILE);
+  }
+  if (!fs.existsSync(ENV_FILE)) fs.writeFileSync(ENV_FILE, '', { mode: 0o600 });
   // Ensure secret files exist (Docker Compose secrets require the files to be present)
   for (const name of ['llm_api_key', 'telegram_bot_token', 'gateway_token', 'groq_api_key', 'brave_api_key']) {
     const fp = path.join(SECRETS_DIR, name);
@@ -2140,19 +2155,22 @@ function cmdUpdate() {
     return;
   }
 
-  // Patch image tag to :latest in existing compose files (handles upgrades from pinned tags)
-  let compose = fs.readFileSync(COMPOSE_FILE, 'utf8');
-  // Migrate from any old registry (ghcr.io, pinned tags) to current REGISTRY_IMAGE
-  const patched = compose.replace(
-    /image:\s*(?:ghcr\.io\/tomasward1\/limbo|registry\.gitlab\.com\/tomas209\/limbo):\S+/g,
-    `image: ${REGISTRY_IMAGE}:${DEFAULT_TAG}`
-  );
-  if (patched !== compose) {
-    compose = patched;
-    fs.writeFileSync(COMPOSE_FILE, compose);
-    log(`Patched compose image to ${REGISTRY_IMAGE}:${DEFAULT_TAG}`);
+  // Restore PORT from existing .env so the regenerated compose uses the right port.
+  const existingEnv = parseEnvFile();
+  if (existingEnv.LIMBO_PORT) {
+    const parsed = parseInt(existingEnv.LIMBO_PORT, 10);
+    if (Number.isFinite(parsed) && parsed >= 1 && parsed <= 65535) PORT = parsed;
   }
 
+  // Regenerate compose file from current template. This handles:
+  //   - ZeroClaw → OpenClaw migration (volume mounts, healthcheck)
+  //   - Image registry/tag updates
+  //   - Any new compose changes shipped with the CLI
+  // Detect hardened mode from existing compose (squid sidecar present).
+  const existingCompose = fs.readFileSync(COMPOSE_FILE, 'utf8');
+  const hardened = existingCompose.includes('squid:');
+  ensureComposeFile(hardened);
+
   log('Pulling latest image...');
   run(`docker compose -f "${COMPOSE_FILE}" pull -q`);
   log('Restarting...');
@@ -2264,6 +2282,65 @@ ${c.bold}Usage:${c.reset}
   }
 }
 
+async function cmdSwitchBrain() {
+  const existingEnv = parseEnvFile();
+  if (!existingEnv.MODEL_PROVIDER) {
+    die('No existing configuration found. Run `limbo start` first to set up.');
+  }
+
+  // Resolve port from existing config before generating compose file
+  if (existingEnv.LIMBO_PORT) {
+    const parsed = parseInt(existingEnv.LIMBO_PORT, 10);
+    if (Number.isFinite(parsed) && parsed >= 1 && parsed <= 65535) PORT = parsed;
+  }
+
+  ensureComposeFile(false);
+
+  const lang = existingEnv.CLI_LANGUAGE || 'en';
+  const currentProvider = existingEnv.MODEL_PROVIDER || 'unknown';
+  const currentModel = existingEnv.MODEL_NAME || 'unknown';
+
+  header(lang === 'es' ? 'Cambiar Proveedor' : 'Switch Provider');
+  console.log(`  ${c.dim}${lang === 'es' ? 'Proveedor actual' : 'Current provider'}: ${c.reset}${c.bold}${currentProvider}${c.reset} (${currentModel})\n`);
+
+  const envContent = fs.readFileSync(ENV_FILE, 'utf8');
+  const cleaned = envContent
+    .replace(/^SWITCH_BRAIN_MODE=.*\n?/gm, '')
+    .replace(/^AUTH_MODE=.*\n?/gm, '')
+    .replace(/^MODEL_PROVIDER=.*\n?/gm, '')
+    .replace(/^MODEL_NAME=.*\n?/gm, '');
+  fs.writeFileSync(ENV_FILE, cleaned + 'SWITCH_BRAIN_MODE=true\n', { mode: 0o600 });
+
+  pullOrBuildImage(lang);
+  ensureVolumePermissions();
+
+  log(lang === 'es' ? 'Iniciando wizard de cambio de proveedor...' : 'Starting provider switch wizard...');
+  const upResult = runDockerCompose(['up', '-d', '--remove-orphans', '--force-recreate'], { stdio: 'pipe' });
+  if (upResult.status !== 0) {
+    process.stderr.write(upResult.stderr || '');
+    die('Container failed to start. Run `limbo logs` to investigate.');
+  }
+
+  const wizardUrl = extractWizardUrl();
+
+  let tunnel = null;
+  if (isServerEnvironment() || process.argv.includes('--tunnel')) {
+    tunnel = await createSetupTunnel(PORT);
+  }
+
+  const displayUrl = wizardUrl || `http://127.0.0.1:${PORT}`;
+  if (!wizardUrl) {
+    warn('Could not extract setup token from container logs.');
+  }
+  printWizardUrl(displayUrl, tunnel);
+
+  try {
+    const envAfter = fs.readFileSync(ENV_FILE, 'utf8');
+    const final = envAfter.replace(/^SWITCH_BRAIN_MODE=.*\n?/gm, '');
+    if (final !== envAfter) fs.writeFileSync(ENV_FILE, final, { mode: 0o600 });
+  } catch {}
+}
+
 function cmdHelp() {
   console.log(`
 ${c.bold}limbo${c.reset} - personal AI memory agent
@@ -2278,6 +2355,7 @@ ${c.bold}Commands:${c.reset}
   update        Pull latest image and restart
   status        Show container status
   config        Configure optional features (voice, web-search)
+  switch-brain  Change your AI provider (opens a quick wizard)
   help          Show this help
 
 ${c.bold}Flags:${c.reset}
@@ -2402,6 +2480,7 @@ if (require.main === module) {
       case 'update':  cmdUpdate(); break;
       case 'status':  cmdStatus(); break;
       case 'config':  cmdConfig(); break;
+      case 'switch-brain': await cmdSwitchBrain(); break;
       case 'version':
       case '--version':
       case '-v':      console.log(require('./package.json').version); break;

package/docker-compose.dev.yml

@@ -8,3 +8,5 @@ services:
       - ./scripts/entrypoint.sh:/entrypoint.sh:ro
       - ./migrations:/app/migrations:ro
       - ./workspace:/app/workspace:ro
+      - ./lib:/app/lib:ro
+      - ./RELEASES.md:/app/RELEASES.md:ro

package/docker-compose.test.yml

@@ -1,36 +1,74 @@
-# Local testing — setup persists across restarts.
-# Start:  docker compose -f docker-compose.test.yml up -d
+# Local e2e testing — reuses pre-configured state from /tmp/limbo-e2e-test.
+# First-time setup: run `limbo start` once to complete the wizard, then copy
+# the resulting state to /tmp/limbo-e2e-test/.  Subsequent tests reuse it.
+#
+# Build:  docker build -t limbo:test .
+# Start:  LIMBO_IMAGE=limbo:test docker compose -f docker-compose.test.yml up -d
 # Logs:   docker compose -f docker-compose.test.yml logs -f
 # Stop:   docker compose -f docker-compose.test.yml down
-# Reset:  docker compose -f docker-compose.test.yml down -v  (wipes setup)
 services:
   limbo:
-    image: ${LIMBO_IMAGE:-ghcr.io/tomasward1/limbo:latest}
+    image: ${LIMBO_IMAGE:-limbo:test}
     init: true
     restart: "no"
+    read_only: true
+    security_opt:
+      - no-new-privileges:true
+    cap_drop:
+      - ALL
+    cap_add:
+      - CHOWN
+      - FOWNER
+    pids_limit: 200
+    tmpfs:
+      - /tmp:size=100M,noexec,nosuid,nodev
+      - /home/limbo/.npm:size=50M,noexec,nosuid,nodev,uid=999,gid=999
     ports:
-      - "127.0.0.1:18789:18789"
+      - "127.0.0.1:18900:18900"
     volumes:
-      - limbo-test-data:/data
-      - limbo-test-state:/home/limbo/.openclaw
+      - limbo-e2e-data:/data
+      - /tmp/limbo-e2e-test/vault:/data/vault
+      - /tmp/limbo-e2e-test/openclaw-state:/home/limbo/.openclaw
+      - /tmp/limbo-e2e-test/flags:/flags
+    secrets:
+      - llm_api_key
+      - telegram_bot_token
+      - gateway_token
+      - groq_api_key
+      - brave_api_key
+    env_file:
+      - /tmp/limbo-e2e-test/.env
+    environment:
+      LIMBO_PORT: "18900"
+      NODE_OPTIONS: "${LIMBO_NODE_OPTIONS:---max-old-space-size=512}"
     logging:
       driver: json-file
       options:
         max-size: "10m"
         max-file: "3"
-    tmpfs:
-      - /tmp:size=100M
     mem_limit: 1g
     memswap_limit: 1g
     healthcheck:
-      test: ["CMD", "node", "-e", "fetch('http://localhost:18789/healthz').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"]
-      interval: 30s
-      timeout: 10s
+      test:
+        - CMD-SHELL
+        - node -e "fetch('http://localhost:'${LIMBO_PORT:-18900}'/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
+      interval: 10s
+      timeout: 5s
       retries: 3
-      start_period: 30s
+      start_period: 5s
+
+secrets:
+  llm_api_key:
+    file: /tmp/limbo-e2e-test/secrets/llm_api_key
+  telegram_bot_token:
+    file: /tmp/limbo-e2e-test/secrets/telegram_bot_token
+  gateway_token:
+    file: /tmp/limbo-e2e-test/secrets/gateway_token
+  groq_api_key:
+    file: /tmp/limbo-e2e-test/secrets/groq_api_key
+  brave_api_key:
+    file: /tmp/limbo-e2e-test/secrets/brave_api_key
 
 volumes:
-  limbo-test-data:
-    name: limbo-test-data
-  limbo-test-state:
-    name: limbo-test-state
+  limbo-e2e-data:
+    name: limbo-e2e-test_limbo-data

package/lib/telegram-notify.js

@@ -0,0 +1,97 @@
+/**
+ * telegram-notify.js — Deterministic Telegram messaging via Bot API.
+ *
+ * Sends messages directly through the Telegram HTTP API without depending on
+ * OpenClaw or any agent runtime.  Used by the wakeup routine (entrypoint) and
+ * the update_instance MCP tool for system-level notifications that MUST fire.
+ *
+ * Requires two secrets:
+ *   - telegram_bot_token
+ *   - telegram_chat_id
+ *
+ * Both are written by the setup wizard (setup-server/server.js) during initial
+ * Telegram pairing and persisted in the OpenClaw secrets directory.
+ */
+
+const https = require("node:https");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const STATE_DIR =
+  process.env.OPENCLAW_STATE_DIR || "/home/limbo/.openclaw";
+const SECRETS_DIR = path.join(STATE_DIR, "secrets");
+
+function readSecret(name) {
+  // Docker secrets take priority, then OpenClaw secrets dir
+  for (const dir of ["/run/secrets", SECRETS_DIR]) {
+    const p = path.join(dir, name);
+    try {
+      const v = fs.readFileSync(p, "utf8").trim();
+      if (v) return v;
+    } catch {
+      // not found — try next
+    }
+  }
+  return "";
+}
+
+/**
+ * Send a Telegram message via the Bot API.
+ *
+ * @param {string} text        — Message text (supports MarkdownV2 if parse_mode set)
+ * @param {object} [options]   — Extra sendMessage params (parse_mode, reply_markup, etc.)
+ * @returns {Promise<object>}  — Telegram API response body
+ */
+function sendMessage(text, options = {}) {
+  const token = readSecret("telegram_bot_token");
+  const chatId = readSecret("telegram_chat_id");
+
+  if (!token || !chatId) {
+    return Promise.reject(
+      new Error("telegram-notify: missing bot_token or chat_id in secrets")
+    );
+  }
+
+  const body = JSON.stringify({
+    chat_id: chatId,
+    text,
+    ...options,
+  });
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      {
+        hostname: "api.telegram.org",
+        path: `/bot${token}/sendMessage`,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body),
+        },
+        timeout: 10000,
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (parsed.ok) resolve(parsed);
+            else reject(new Error(`Telegram API error: ${data}`));
+          } catch {
+            reject(new Error(`Telegram API parse error: ${data}`));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("telegram-notify: request timed out"));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+
+module.exports = { sendMessage, readSecret };

package/lib/wakeup.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+/**
+ * wakeup.js — Deterministic startup routine.
+ *
+ * Runs in the entrypoint BEFORE OpenClaw starts.  Handles system-level
+ * notifications that must always fire, independent of the LLM.
+ *
+ * Current checks:
+ *   1. Post-update notification — tell the user we're back after an update
+ *   2. Version check — notify if a newer version is available on npm
+ *
+ * Future checks can be added to the `checks` array below.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const https = require("node:https");
+const { sendMessage } = require("./telegram-notify");
+
+const FLAGS_DIR = "/flags";
+const DATA_DIR = "/data";
+const VERSION_FILE = path.join(DATA_DIR, ".limbo-version");
+const LAST_CHECK_FILE = path.join(DATA_DIR, ".update-last-check");
+const RELEASES_FILE = "/app/RELEASES.md";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+function log(msg) {
+  const ts = new Date().toISOString();
+  console.log(`[${ts}] [wakeup] ${msg}`);
+}
+
+// ── Check 1: Post-update notification ──────────────────────────────────────
+
+async function checkPostUpdate() {
+  const flagPath = path.join(FLAGS_DIR, "updated.flag");
+  if (!fs.existsSync(flagPath)) return;
+
+  let previousVersion;
+  try {
+    previousVersion = fs.readFileSync(flagPath, "utf8").trim();
+  } catch {
+    previousVersion = "unknown";
+  }
+
+  const currentVersion = getCurrentVersion();
+  const changelog = parseUserChangelog();
+
+  let text;
+  if (changelog) {
+    text =
+      `Ya volvi. Actualizado de v${previousVersion} a v${currentVersion}.\n\n` +
+      `Que hay de nuevo:\n${changelog}`;
+  } else {
+    text = `Ya volvi. Actualizado a v${currentVersion}.`;
+  }
+
+  try {
+    await sendMessage(text);
+    log(`Post-update notification sent (${previousVersion} -> ${currentVersion})`);
+  } catch (err) {
+    log(`Post-update notification failed: ${err.message}`);
+  }
+
+  // Clean up flag and persist current version
+  try { fs.unlinkSync(flagPath); } catch {}
+  persistVersion(currentVersion);
+}
+
+// ── Check 2: New version available ─────────────────────────────────────────
+
+async function checkNewVersion() {
+  // Don't check more than once per day
+  try {
+    const lastCheck = fs.readFileSync(LAST_CHECK_FILE, "utf8").trim();
+    if (Date.now() - Number(lastCheck) < CHECK_INTERVAL_MS) return;
+  } catch {
+    // No last-check file — proceed
+  }
+
+  const currentVersion = getCurrentVersion();
+  let latestVersion;
+
+  try {
+    latestVersion = await fetchLatestVersion();
+  } catch (err) {
+    log(`Version check failed: ${err.message}`);
+    return;
+  }
+
+  // Persist check timestamp regardless of result
+  try { fs.writeFileSync(LAST_CHECK_FILE, String(Date.now())); } catch {}
+
+  if (!latestVersion || latestVersion === currentVersion) return;
+  if (!isNewer(latestVersion, currentVersion)) return;
+
+  log(`New version available: ${currentVersion} -> ${latestVersion}`);
+
+  try {
+    await sendMessage(
+      `Hay una nueva version de Limbo disponible: v${latestVersion}\n\n` +
+        `Cuando quieras actualizar, pedimelo.`,
+      {
+        reply_markup: JSON.stringify({
+          inline_keyboard: [
+            [
+              { text: "Actualizar", callback_data: "limbo_update_yes" },
+              { text: "Ahora no", callback_data: "limbo_update_no" },
+            ],
+          ],
+        }),
+      }
+    );
+  } catch (err) {
+    log(`Version notification failed: ${err.message}`);
+  }
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function getCurrentVersion() {
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync("/app/package.json", "utf8")
+    );
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+
+function persistVersion(version) {
+  try {
+    fs.writeFileSync(VERSION_FILE, version);
+  } catch {}
+}
+
+function parseUserChangelog() {
+  try {
+    const content = fs.readFileSync(RELEASES_FILE, "utf8");
+    // Extract everything between the first "## v" heading and the first "---"
+    const match = content.match(/^## v[\d.]+\s*\n([\s\S]*?)(?=\n---)/m);
+    if (!match) return null;
+    return match[1].trim();
+  } catch {
+    return null;
+  }
+}
+
+function fetchLatestVersion() {
+  return new Promise((resolve, reject) => {
+    const req = https.get(
+      "https://registry.npmjs.org/limbo-ai/latest",
+      { timeout: 10000 },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(data).version);
+          } catch {
+            reject(new Error("Failed to parse npm response"));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("npm registry timeout"));
+    });
+  });
+}
+
+function isNewer(latest, current) {
+  const l = latest.split(".").map(Number);
+  const c = current.split(".").map(Number);
+  return (
+    l[0] > c[0] ||
+    (l[0] === c[0] && l[1] > c[1]) ||
+    (l[0] === c[0] && l[1] === c[1] && l[2] > c[2])
+  );
+}
+
+// ── Run all checks ─────────────────────────────────────────────────────────
+
+async function main() {
+  log("Wakeup routine starting");
+
+  const checks = [checkPostUpdate, checkNewVersion];
+
+  for (const check of checks) {
+    try {
+      await check();
+    } catch (err) {
+      log(`Check ${check.name} failed: ${err.message}`);
+    }
+  }
+
+  log("Wakeup routine complete");
+}
+
+main().catch((err) => {
+  log(`Wakeup fatal error: ${err.message}`);
+  // Non-fatal — don't prevent OpenClaw from starting
+  process.exit(0);
+});

package/mcp-server/index.js

@@ -15,6 +15,7 @@ import { vaultUpdateMap } from "./tools/update-map.js";
 import { vaultStoreFile } from "./tools/store-file.js";
 import { vaultGetFile } from "./tools/get-file.js";
 import { workspaceRead, workspaceWrite } from "./tools/workspace.js";
+import { updateInstance } from "./tools/update-instance.js";
 
 /**
  * General response size guard. Any tool_result text content exceeding this
@@ -259,6 +260,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ["filename", "content"],
       },
     },
+    {
+      name: "update_instance",
+      description:
+        "Trigger a Limbo self-update. Notifies the user that Limbo is going offline briefly, then signals the host to pull the latest image and restart. Use when the user wants to update Limbo.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+      },
+    },
   ],
 }));
 
@@ -371,6 +381,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         break;
       }
 
+      case "update_instance": {
+        result = await updateInstance();
+        break;
+      }
+
       default:
         result = {
           content: [{ type: "text", text: `Unknown tool: ${name}` }],