openclaw-safeclaw-plugin 1.1.0 → 1.2.0

package/dist/index.js

@@ -15,13 +15,21 @@ const { version: PLUGIN_VERSION } = require('./package.json');
 const CONFIG_RELOAD_INTERVAL_MS = 60_000; // Reload config every 60 seconds
 let config = loadConfig();
 let configLoadedAt = Date.now();
+// OpenClaw plugin config — merged on top of file config when available
+let _ocPluginConfig = {};
+// Logger — defaults to console, replaced by api.logger when available
+let log = console;
 function getConfig() {
     const now = Date.now();
     if (now - configLoadedAt >= CONFIG_RELOAD_INTERVAL_MS) {
         config = loadConfig();
         configLoadedAt = now;
     }
-    return config;
+    // OpenClaw config takes priority over file config
+    return {
+        ...config,
+        ...Object.fromEntries(Object.entries(_ocPluginConfig).filter(([_, v]) => v != null)),
+    };
 }
 // --- HTTP Client ---
 async function post(path, body) {
@@ -47,10 +55,10 @@ async function post(path, body) {
                 const rawDetail = errBody.detail ?? `HTTP ${res.status}`;
                 const detail = typeof rawDetail === 'string' ? rawDetail : JSON.stringify(rawDetail);
                 const hint = errBody.hint ? ` (${errBody.hint})` : '';
-                console.warn(`[SafeClaw] ${path}: ${detail}${hint}`);
+                log.warn(`[SafeClaw] ${path}: ${detail}${hint}`);
             }
             catch {
-                console.warn(`[SafeClaw] HTTP ${res.status} from ${path}`);
+                log.warn(`[SafeClaw] HTTP ${res.status} from ${path}`);
             }
             return null; // Caller checks failMode
         }
@@ -58,22 +66,43 @@ async function post(path, body) {
     }
     catch (e) {
         if (e instanceof DOMException && e.name === 'TimeoutError') {
-            console.warn(`[SafeClaw] Timeout after ${cfg.timeoutMs}ms on ${path} (${cfg.serviceUrl})`);
+            log.warn(`[SafeClaw] Timeout after ${cfg.timeoutMs}ms on ${path} (${cfg.serviceUrl})`);
         }
         else if (e instanceof TypeError && (e.message.includes('fetch') || e.message.includes('ECONNREFUSED'))) {
-            console.warn(`[SafeClaw] Connection refused: ${cfg.serviceUrl}${path} — is the service running?`);
+            log.warn(`[SafeClaw] Connection refused: ${cfg.serviceUrl}${path} — is the service running?`);
         }
         else {
-            console.warn(`[SafeClaw] Service unavailable: ${cfg.serviceUrl}${path}`);
+            log.warn(`[SafeClaw] Service unavailable: ${cfg.serviceUrl}${path}`);
         }
         return null; // Caller checks failMode
     }
 }
+async function get(path) {
+    const cfg = getConfig();
+    if (!cfg.enabled)
+        return null;
+    const headers = {};
+    if (cfg.apiKey)
+        headers['Authorization'] = `Bearer ${cfg.apiKey}`;
+    try {
+        const res = await fetch(`${cfg.serviceUrl}${path}`, {
+            signal: AbortSignal.timeout(cfg.timeoutMs),
+            headers,
+        });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+// --- Plugin Definition ---
 let handshakeCompleted = false;
 async function performHandshake() {
     const cfg = getConfig();
     if (!cfg.apiKey) {
-        console.warn('[SafeClaw] No API key configured — skipping handshake');
+        log.warn('[SafeClaw] No API key configured — skipping handshake');
         return false;
     }
     const r = await post('/handshake', {
@@ -81,37 +110,37 @@ async function performHandshake() {
         configHash: configHash(cfg),
     });
     if (r === null) {
-        console.warn('[SafeClaw] ✗ Handshake failed — API key may be invalid or service unreachable');
+        log.warn('[SafeClaw] Handshake failed — API key may be invalid or service unreachable');
         return false;
     }
-    console.log(`[SafeClaw] ✓ Handshake OK — org=${r.orgId}, scope=${r.scope}, engine=${r.engineReady ? 'ready' : 'not ready'}`);
+    log.info(`[SafeClaw] Handshake OK — org=${r.orgId}, scope=${r.scope}, engine=${r.engineReady ? 'ready' : 'not ready'}`);
     handshakeCompleted = true;
     return true;
 }
 async function checkConnection() {
     const cfg = getConfig();
     const label = `[SafeClaw]`;
-    console.log(`${label} Connecting to ${cfg.serviceUrl} ...`);
-    console.log(`${label} Mode: enforcement=${cfg.enforcement}, failMode=${cfg.failMode}`);
+    log.info(`${label} Connecting to ${cfg.serviceUrl} ...`);
+    log.info(`${label} Mode: enforcement=${cfg.enforcement}, failMode=${cfg.failMode}`);
     try {
         const res = await fetch(`${cfg.serviceUrl}/health`, {
             signal: AbortSignal.timeout(cfg.timeoutMs * 2),
         });
         if (res.ok) {
             const data = await res.json();
-            console.log(`${label} ✓ Connected — service ${data.status ?? 'ok'}`);
+            log.info(`${label} Connected — service ${data.status ?? 'ok'}`);
         }
         else {
-            console.warn(`${label} ✗ Service responded with HTTP ${res.status}`);
+            log.warn(`${label} Service responded with HTTP ${res.status}`);
         }
     }
     catch {
-        console.warn(`${label} ✗ Cannot reach service at ${cfg.serviceUrl}`);
+        log.warn(`${label} Cannot reach service at ${cfg.serviceUrl}`);
         if (cfg.failMode === 'closed') {
-            console.warn(`${label}   fail-mode=closed → tool calls will be BLOCKED until service is reachable`);
+            log.warn(`${label}   fail-mode=closed — tool calls will be BLOCKED until service is reachable`);
         }
         else {
-            console.warn(`${label}   fail-mode=open → tool calls will be ALLOWED despite no connection`);
+            log.warn(`${label}   fail-mode=open — tool calls will be ALLOWED despite no connection`);
         }
     }
 }
@@ -124,6 +153,8 @@ export default {
             console.log('[SafeClaw] Plugin disabled');
             return;
         }
+        log = api.logger ?? console;
+        _ocPluginConfig = api.pluginConfig ?? {};
         // Generate a unique instance ID for this plugin run (fallback when agentId is not configured)
         const instanceId = getConfig().agentId || `instance-${crypto.randomUUID()}`;
         // Heartbeat watchdog — send config hash to service every 30s
@@ -139,20 +170,8 @@ export default {
                 // Heartbeat failure is non-fatal
             }
         };
-        // Start heartbeat only after connection check + handshake completes (#84)
+        // Clean shutdown: send shutdown heartbeat and clear interval (#194)
         let heartbeatInterval;
-        checkConnection()
-            .then(() => performHandshake())
-            .then((ok) => {
-            if (!ok && getConfig().failMode === 'closed') {
-                console.warn('[SafeClaw] Handshake failed with fail-mode=closed — tool calls will be BLOCKED');
-            }
-            heartbeatInterval = setInterval(sendHeartbeat, 30000);
-            return sendHeartbeat();
-        })
-            .catch(() => { });
-        // Clean shutdown: send shutdown heartbeat and clear interval
-        // Use async shutdown for SIGINT/SIGTERM where async is supported (#55)
         const shutdown = async () => {
             if (heartbeatInterval)
                 clearInterval(heartbeatInterval);
@@ -167,29 +186,56 @@ export default {
                 // Best-effort shutdown notification
             }
         };
-        process.on('SIGINT', async () => { await shutdown(); process.exit(0); });
-        process.on('SIGTERM', async () => { await shutdown(); process.exit(0); });
-        // THE GATE — constraint checking on every tool call
+        // Start heartbeat after connection check + handshake completes (#84)
+        const startupPromise = checkConnection()
+            .then(() => performHandshake())
+            .then((ok) => {
+            if (!ok && getConfig().failMode === 'closed') {
+                log.warn('[SafeClaw] Handshake failed with fail-mode=closed — tool calls will be BLOCKED');
+            }
+            heartbeatInterval = setInterval(sendHeartbeat, 30000);
+            return sendHeartbeat();
+        })
+            .catch(() => { });
+        // Register as an OpenClaw service so the gateway manages our lifecycle.
+        // The service's stop() method sends the shutdown heartbeat — no process.exit()
+        // needed, which avoids killing the entire gateway process (#194).
+        if (api.registerService) {
+            api.registerService({
+                id: 'safeclaw-governance',
+                start() { },
+                async stop() {
+                    await startupPromise; // Ensure startup finished before tearing down
+                    await shutdown();
+                },
+            });
+        }
+        else {
+            // Fallback for older OpenClaw versions without registerService:
+            // No process.exit() — just clean up on beforeExit
+            process.on('beforeExit', () => { shutdown().catch(() => { }); });
+        }
+        // THE GATE — constraint checking on every tool call (#195: use correct OpenClaw field names)
         api.on('before_tool_call', async (event, ctx) => {
             const cfg = getConfig();
             if (!handshakeCompleted && cfg.failMode === 'closed' && cfg.enforcement === 'enforce') {
                 return { block: true, blockReason: 'SafeClaw handshake not completed (fail-closed)' };
             }
             const r = await post('/evaluate/tool-call', {
-                sessionId: ctx.sessionId ?? event.sessionId,
-                userId: ctx.userId ?? event.userId,
-                toolName: event.toolName ?? event.tool_name,
+                sessionId: ctx.sessionId ?? event.sessionId ?? '',
+                userId: ctx.agentId ?? '',
+                toolName: event.toolName ?? '',
                 params: event.params ?? {},
-                sessionHistory: event.sessionHistory ?? [],
+                runId: ctx.runId ?? '',
             });
             if (r === null && cfg.failMode === 'closed' && cfg.enforcement === 'enforce') {
                 return { block: true, blockReason: `SafeClaw service unavailable at ${cfg.serviceUrl} (fail-closed)` };
             }
             else if (r === null && cfg.failMode === 'closed' && cfg.enforcement === 'warn-only') {
-                console.warn(`[SafeClaw] Service unavailable at ${cfg.serviceUrl} (fail-closed mode, warn-only)`);
+                log.warn(`[SafeClaw] Service unavailable at ${cfg.serviceUrl} (fail-closed mode, warn-only)`);
             }
             else if (r === null && cfg.failMode === 'closed' && cfg.enforcement === 'audit-only') {
-                console.warn(`[SafeClaw] Service unavailable at ${cfg.serviceUrl} (fail-closed mode, audit-only)`);
+                log.warn(`[SafeClaw] Service unavailable at ${cfg.serviceUrl} (fail-closed mode, audit-only)`);
             }
             if (r?.block) {
                 const blockReason = r.reason || 'Blocked by SafeClaw (no reason provided)';
@@ -197,71 +243,195 @@ export default {
                     return { block: true, blockReason };
                 }
                 if (cfg.enforcement === 'warn-only') {
-                    console.warn(`[SafeClaw] Warning: ${blockReason}`);
+                    log.warn(`[SafeClaw] Warning: ${blockReason}`);
                 }
                 // audit-only: logged server-side, no action here
             }
         }, { priority: 100 });
         // Context injection — prepend governance context to agent system prompt
-        api.on('before_agent_start', async (event, ctx) => {
+        // (#195: before_agent_start is deprecated; use before_prompt_build + prependSystemContext)
+        api.on('before_prompt_build', async (event, ctx) => {
             const r = await post('/context/build', {
-                sessionId: ctx.sessionId ?? event.sessionId,
-                userId: ctx.userId ?? event.userId,
+                sessionId: ctx.sessionId ?? event.sessionId ?? '',
+                userId: ctx.agentId ?? '',
             });
             if (r?.prependContext) {
-                return { prependContext: r.prependContext };
+                return { prependSystemContext: r.prependContext };
             }
         }, { priority: 100 });
         // Message governance — check outbound messages
+        // (#195: use ctx.conversationId/sessionId, ctx.accountId; return only { cancel: true })
         api.on('message_sending', async (event, ctx) => {
             const cfg = getConfig();
             const r = await post('/evaluate/message', {
-                sessionId: ctx.sessionId ?? event.sessionId,
-                userId: ctx.userId ?? event.userId,
+                sessionId: ctx.conversationId ?? ctx.sessionId ?? event.sessionId ?? '',
+                userId: ctx.accountId ?? '',
                 to: event.to,
                 content: event.content,
+                channelId: ctx.channelId ?? '',
             });
             if (r === null && cfg.failMode === 'closed' && cfg.enforcement === 'enforce') {
-                return { cancel: true, cancelReason: 'SafeClaw service unavailable (fail-closed mode)' };
+                log.warn('[SafeClaw] Blocking message: service unavailable (fail-closed mode)');
+                return { cancel: true };
             }
             else if (r === null && cfg.failMode === 'closed' && cfg.enforcement === 'warn-only') {
-                console.warn('[SafeClaw] Service unavailable (fail-closed mode, warn-only)');
+                log.warn('[SafeClaw] Service unavailable (fail-closed mode, warn-only)');
             }
             else if (r === null && cfg.failMode === 'closed' && cfg.enforcement === 'audit-only') {
-                console.info('[SafeClaw] audit-only: service unreachable, allowing message (fail-closed)');
+                log.info('[SafeClaw] audit-only: service unreachable, allowing message (fail-closed)');
             }
             if (r?.block) {
                 const blockReason = r.reason || 'Blocked by SafeClaw (no reason provided)';
                 if (cfg.enforcement === 'enforce') {
-                    return { cancel: true, cancelReason: blockReason };
+                    log.warn(`[SafeClaw] Blocking message: ${blockReason}`);
+                    return { cancel: true };
                 }
                 if (cfg.enforcement === 'warn-only') {
-                    console.warn(`[SafeClaw] Warning: ${blockReason}`);
+                    log.warn(`[SafeClaw] Warning: ${blockReason}`);
                 }
                 // audit-only: logged server-side, no action here
             }
         }, { priority: 100 });
         // Async logging — fire-and-forget, no return value needed
+        // (#195: use event.prompt for input, event.lastAssistant for output; add provider/model)
         api.on('llm_input', (event, ctx) => {
             post('/log/llm-input', {
-                sessionId: ctx.sessionId ?? event.sessionId,
-                content: event.content,
+                sessionId: event.sessionId ?? ctx.sessionId ?? '',
+                content: event.prompt ?? '',
+                provider: event.provider ?? '',
+                model: event.model ?? '',
             }).catch(() => { });
         });
         api.on('llm_output', (event, ctx) => {
             post('/log/llm-output', {
-                sessionId: ctx.sessionId ?? event.sessionId,
-                content: event.content,
+                sessionId: event.sessionId ?? ctx.sessionId ?? '',
+                content: event.lastAssistant ?? '',
+                provider: event.provider ?? '',
+                model: event.model ?? '',
+                usage: event.usage ?? {},
             }).catch(() => { });
         });
+        // (#195: use event.toolName, !event.error for success, add durationMs and error)
         api.on('after_tool_call', (event, ctx) => {
             post('/record/tool-result', {
-                sessionId: ctx.sessionId ?? event.sessionId,
-                toolName: event.toolName ?? event.tool_name,
+                sessionId: ctx.sessionId ?? event.sessionId ?? '',
+                toolName: event.toolName ?? '',
                 params: event.params ?? {},
                 result: event.result ?? '',
-                success: event.success ?? false,
-            }).catch((e) => console.warn('[SafeClaw] Failed to record tool result:', e));
+                success: !event.error,
+                error: event.error ? String(event.error) : '',
+                durationMs: event.durationMs ?? 0,
+            }).catch((e) => log.warn('[SafeClaw] Failed to record tool result:', e));
         });
+        // Subagent governance — block delegation bypass attempts (#188)
+        api.on('subagent_spawning', async (event, ctx) => {
+            const cfg = getConfig();
+            const r = await post('/evaluate/subagent-spawn', {
+                sessionId: ctx.sessionId ?? event.sessionId,
+                userId: ctx.agentId,
+                parentAgentId: event.parentAgentId,
+                childConfig: event.childConfig ?? {},
+                reason: event.reason ?? '',
+            });
+            if (r?.block && cfg.enforcement === 'enforce') {
+                throw new Error(r.reason || 'Blocked by SafeClaw: delegation bypass detected');
+            }
+            if (r?.block && cfg.enforcement === 'warn-only') {
+                log.warn(`[SafeClaw] Subagent spawn warning: ${r.reason}`);
+            }
+        }, { priority: 100 });
+        // Subagent ended — record child agent lifecycle (#188)
+        api.on('subagent_ended', (event, ctx) => {
+            post('/record/subagent-ended', {
+                sessionId: ctx.sessionId ?? event.sessionId,
+                parentAgentId: event.parentAgentId,
+                childAgentId: event.childAgentId,
+            }).catch(() => { });
+        });
+        // Session lifecycle — notify service of session start (#189)
+        api.on('session_start', (event, ctx) => {
+            post('/session/start', {
+                sessionId: ctx.sessionId ?? event.sessionId,
+                userId: ctx.agentId,
+                agentId: instanceId,
+                metadata: event.metadata ?? {},
+            }).catch(() => { });
+        });
+        // Session lifecycle — notify service of session end (#189)
+        api.on('session_end', (event, ctx) => {
+            post('/session/end', {
+                sessionId: ctx.sessionId ?? event.sessionId,
+                userId: ctx.agentId,
+                agentId: instanceId,
+            }).catch(() => { });
+        });
+        // Inbound message governance — evaluate received messages (#190)
+        api.on('message_received', (event, ctx) => {
+            post('/evaluate/inbound-message', {
+                sessionId: ctx.sessionId ?? event.sessionId,
+                userId: ctx.agentId,
+                channel: event.channel ?? ctx.channelId ?? '',
+                sender: event.sender ?? '',
+                content: event.content ?? '',
+                metadata: event.metadata ?? {},
+            }).catch(() => { });
+        });
+        // Agent tools — let agents introspect governance state (#197)
+        if (api.registerTool) {
+            api.registerTool({
+                name: 'safeclaw_status',
+                description: 'Check SafeClaw governance service status, enforcement mode, and active constraints',
+                parameters: {},
+                async execute(_params, _ctx) {
+                    const health = await get('/health');
+                    const cfg = getConfig();
+                    return {
+                        status: health?.status ?? 'unreachable',
+                        enforcement: cfg.enforcement,
+                        failMode: cfg.failMode,
+                        serviceUrl: cfg.serviceUrl,
+                        handshakeCompleted,
+                    };
+                },
+            });
+            api.registerTool({
+                name: 'safeclaw_check_action',
+                description: 'Check if a specific tool call would be allowed by SafeClaw governance (dry run, no side effects)',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        toolName: { type: 'string', description: 'Tool name to check' },
+                        params: { type: 'object', description: 'Tool parameters to validate' },
+                    },
+                    required: ['toolName'],
+                },
+                async execute(params, ctx) {
+                    const r = await post('/evaluate/tool-call', {
+                        sessionId: ctx.sessionId ?? '',
+                        userId: ctx.agentId ?? '',
+                        toolName: params.toolName,
+                        params: params.params ?? {},
+                        dryRun: true,
+                    });
+                    return r ?? { error: 'Service unreachable' };
+                },
+            });
+        }
+        // CLI extension — `safeclaw status` command (#197)
+        if (api.registerCli) {
+            api.registerCli(({ program }) => {
+                const cmd = program.command('safeclaw').description('SafeClaw governance controls');
+                cmd.command('status')
+                    .description('Show SafeClaw service status and enforcement mode')
+                    .action(async () => {
+                    const cfg = getConfig();
+                    const health = await get('/health');
+                    console.log(`SafeClaw: ${health?.status ?? 'unreachable'}`);
+                    console.log(`  Enforcement: ${cfg.enforcement}`);
+                    console.log(`  Fail mode: ${cfg.failMode}`);
+                    console.log(`  Service: ${cfg.serviceUrl}`);
+                });
+            }, { commands: ['safeclaw'] });
+        }
     },
 };

package/dist/tui/Status.js

@@ -6,6 +6,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { fileURLToPath } from 'url';
+import { isNemoClawSandbox, getSandboxName } from './config.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_VERSION = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8')).version;
 export default function Status({ config }) {
@@ -169,5 +170,5 @@ export default function Status({ config }) {
             return _jsxs(Text, { color: "green", children: [dot, " "] });
         return _jsxs(Text, { color: "red", children: [dot, " "] });
     };
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Status" }) }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  Service      ' }), _jsxs(Text, { color: serviceDotColor, children: [dot, " "] }), _jsx(Text, { children: serviceText })] }), connected && (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '    Evaluate   ' }), statusDot(evaluateStatus), _jsx(Text, { children: evaluateStatus === 'ok' ? 'Responding' : evaluateStatus === 'checking' ? 'Checking...' : 'Not responding' })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '    Handshake  ' }), statusDot(handshakeStatus), _jsx(Text, { children: handshakeStatus === 'ok' ? handshakeDetail : handshakeStatus === 'checking' ? 'Checking...' : handshakeDetail })] })] })), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  OpenClaw      ' }), _jsxs(Text, { color: openclawDotColor, children: [dot, " "] }), _jsx(Text, { children: openclawText }), restartMsg && _jsx(Text, { dimColor: true, children: `  (${restartMsg})` })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '    Plugin     ' }), statusDot(pluginInstalled), _jsx(Text, { children: pluginInstalled ? 'Installed' : 'Not installed' })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '    Config     ' }), statusDot(pluginEnabled), _jsx(Text, { children: pluginEnabled ? 'Enabled' : 'Not enabled' })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  API Key      ' }), statusDot(!!config.apiKey), _jsx(Text, { children: apiKeyMasked })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  Enforcement  ' }), _jsx(Text, { children: config.enforcement })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  Fail Mode    ' }), _jsx(Text, { children: config.failMode })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  Enabled      ' }), _jsx(Text, { color: config.enabled ? 'green' : 'red', children: config.enabled ? 'ON' : 'OFF' })] }), health?.version && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { dimColor: true, children: '  Service v' }), _jsx(Text, { children: health.version })] })), lastCheck && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ['  Last check: ', lastCheck.toLocaleTimeString()] }) })), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { dimColor: true, children: '  Press ' }), _jsx(Text, { bold: true, children: "r" }), _jsx(Text, { dimColor: true, children: ' to restart OpenClaw daemon' })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Status" }) }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  Service      ' }), _jsxs(Text, { color: serviceDotColor, children: [dot, " "] }), _jsx(Text, { children: serviceText })] }), connected && (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '    Evaluate   ' }), statusDot(evaluateStatus), _jsx(Text, { children: evaluateStatus === 'ok' ? 'Responding' : evaluateStatus === 'checking' ? 'Checking...' : 'Not responding' })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '    Handshake  ' }), statusDot(handshakeStatus), _jsx(Text, { children: handshakeStatus === 'ok' ? handshakeDetail : handshakeStatus === 'checking' ? 'Checking...' : handshakeDetail })] })] })), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  OpenClaw      ' }), _jsxs(Text, { color: openclawDotColor, children: [dot, " "] }), _jsx(Text, { children: openclawText }), restartMsg && _jsx(Text, { dimColor: true, children: `  (${restartMsg})` })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '    Plugin     ' }), statusDot(pluginInstalled), _jsx(Text, { children: pluginInstalled ? 'Installed' : 'Not installed' })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '    Config     ' }), statusDot(pluginEnabled), _jsx(Text, { children: pluginEnabled ? 'Enabled' : 'Not enabled' })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  API Key      ' }), statusDot(!!config.apiKey), _jsx(Text, { children: apiKeyMasked })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  Enforcement  ' }), _jsx(Text, { children: config.enforcement })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  Fail Mode    ' }), _jsx(Text, { children: config.failMode })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  Enabled      ' }), _jsx(Text, { color: config.enabled ? 'green' : 'red', children: config.enabled ? 'ON' : 'OFF' })] }), isNemoClawSandbox() && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  NemoClaw     ' }), _jsxs(Text, { color: "green", children: [dot, " "] }), _jsxs(Text, { children: ["Sandbox: ", getSandboxName()] })] })), health?.version && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { dimColor: true, children: '  Service v' }), _jsx(Text, { children: health.version })] })), lastCheck && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ['  Last check: ', lastCheck.toLocaleTimeString()] }) })), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { dimColor: true, children: '  Press ' }), _jsx(Text, { bold: true, children: "r" }), _jsx(Text, { dimColor: true, children: ' to restart OpenClaw daemon' })] })] }));
 }

package/dist/tui/config.d.ts

@@ -32,3 +32,5 @@ export declare function saveConfig(config: SafeClawConfig): void;
  * Used to detect whether the on-disk config has drifted from the in-memory state.
  */
 export declare function configHash(config: SafeClawConfig): string;
+export declare function isNemoClawSandbox(): boolean;
+export declare function getSandboxName(): string | null;

package/dist/tui/config.js

@@ -75,6 +75,13 @@ export function loadConfig() {
         defaults.agentId = process.env.SAFECLAW_AGENT_ID;
     if (process.env.SAFECLAW_AGENT_TOKEN)
         defaults.agentToken = process.env.SAFECLAW_AGENT_TOKEN;
+    // NemoClaw sandbox detection
+    if (process.env.OPENSHELL_SANDBOX) {
+        // Inside NemoClaw sandbox — localhost won't work, use container-to-host bridge
+        if (!process.env.SAFECLAW_URL && defaults.serviceUrl === 'http://localhost:8420/api/v1') {
+            defaults.serviceUrl = 'http://host.containers.internal:8420/api/v1';
+        }
+    }
     defaults.serviceUrl = defaults.serviceUrl.replace(/\/+$/, '');
     const validModes = ['enforce', 'warn-only', 'audit-only', 'disabled'];
     if (!validModes.includes(defaults.enforcement)) {
@@ -145,7 +152,16 @@ export function saveConfig(config) {
     }
     // Ensure parent directory exists
     mkdirSync(dirname(CONFIG_PATH), { recursive: true, mode: 0o700 });
-    writeFileSync(CONFIG_PATH, JSON.stringify(existing, null, 2) + '\n', { encoding: 'utf-8', mode: 0o600 });
+    try {
+        writeFileSync(CONFIG_PATH, JSON.stringify(existing, null, 2) + '\n', { encoding: 'utf-8', mode: 0o600 });
+    }
+    catch (e) {
+        if (e.code === 'EROFS' || e.code === 'EACCES') {
+            // Sandbox filesystem is read-only — silently skip
+            return;
+        }
+        throw e;
+    }
 }
 /**
  * SHA-256 hash of the four TUI-managed config fields.
@@ -160,3 +176,10 @@ export function configHash(config) {
     });
     return crypto.createHash('sha256').update(payload).digest('hex');
 }
+// --- NemoClaw sandbox helpers ---
+export function isNemoClawSandbox() {
+    return !!process.env.OPENSHELL_SANDBOX;
+}
+export function getSandboxName() {
+    return process.env.OPENSHELL_SANDBOX || null;
+}