kernelbot 1.0.34 → 1.0.36

package/src/life/improvements.js

@@ -1,16 +1,12 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { randomBytes } from 'crypto';
 import { getLogger } from '../utils/logger.js';
+import { genId } from '../utils/ids.js';
 
 const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const IMPROVEMENTS_FILE = join(LIFE_DIR, 'improvements.json');
 
-function genId() {
-  return `imp_${randomBytes(4).toString('hex')}`;
-}
-
 export class ImprovementTracker {
   constructor() {
     mkdirSync(LIFE_DIR, { recursive: true });
@@ -39,7 +35,7 @@ export class ImprovementTracker {
   addProposal(proposal) {
     const logger = getLogger();
     const entry = {
-      id: genId(),
+      id: genId('imp'),
       createdAt: Date.now(),
       status: 'pending', // pending, approved, rejected
       description: proposal.description,

package/src/life/journal.js

@@ -2,13 +2,10 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from
 import { join } from 'path';
 import { homedir } from 'os';
 import { getLogger } from '../utils/logger.js';
+import { todayDateStr } from '../utils/date.js';
 
 const JOURNAL_DIR = join(homedir(), '.kernelbot', 'life', 'journals');
 
-function todayDate() {
-  return new Date().toISOString().slice(0, 10);
-}
-
 function formatDate(date) {
   return new Date(date + 'T00:00:00').toLocaleDateString('en-US', {
     weekday: 'long',
@@ -38,7 +35,7 @@ export class JournalManager {
    */
   writeEntry(title, content) {
     const logger = getLogger();
-    const date = todayDate();
+    const date = todayDateStr();
     const filePath = this._journalPath(date);
     const time = timeNow();
 
@@ -58,7 +55,7 @@ export class JournalManager {
    * Get today's journal content.
    */
   getToday() {
-    const filePath = this._journalPath(todayDate());
+    const filePath = this._journalPath(todayDateStr());
     if (!existsSync(filePath)) return null;
     return readFileSync(filePath, 'utf-8');
   }

package/src/life/memory.js

@@ -1,21 +1,14 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { randomBytes } from 'crypto';
 import { getLogger } from '../utils/logger.js';
+import { genId } from '../utils/ids.js';
+import { todayDateStr } from '../utils/date.js';
 
 const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const EPISODIC_DIR = join(LIFE_DIR, 'memories', 'episodic');
 const SEMANTIC_FILE = join(LIFE_DIR, 'memories', 'semantic', 'topics.json');
 
-function today() {
-  return new Date().toISOString().slice(0, 10);
-}
-
-function genId(prefix = 'ep') {
-  return `${prefix}_${randomBytes(4).toString('hex')}`;
-}
-
 export class MemoryManager {
   constructor() {
     this._episodicCache = new Map(); // date -> array
@@ -56,7 +49,7 @@ export class MemoryManager {
    */
   addEpisodic(memory) {
     const logger = getLogger();
-    const date = today();
+    const date = todayDateStr();
     const entries = this._loadEpisodicDay(date);
     const entry = {
       id: genId('ep'),

package/src/life/share-queue.js

@@ -1,16 +1,13 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { randomBytes } from 'crypto';
 import { getLogger } from '../utils/logger.js';
+import { genId } from '../utils/ids.js';
+import { getStartOfDayMs } from '../utils/date.js';
 
 const LIFE_DIR = join(homedir(), '.kernelbot', 'life');
 const SHARES_FILE = join(LIFE_DIR, 'shares.json');
 
-function genId() {
-  return `sh_${randomBytes(4).toString('hex')}`;
-}
-
 export class ShareQueue {
   constructor() {
     mkdirSync(LIFE_DIR, { recursive: true });
@@ -43,7 +40,7 @@ export class ShareQueue {
   add(content, source, priority = 'medium', targetUserId = null, tags = []) {
     const logger = getLogger();
     const item = {
-      id: genId(),
+      id: genId('sh'),
       content,
       source,
       createdAt: Date.now(),
@@ -115,9 +112,7 @@ export class ShareQueue {
    * Get count of shares sent today (for rate limiting proactive shares).
    */
   getSharedTodayCount() {
-    const todayStart = new Date();
-    todayStart.setHours(0, 0, 0, 0);
-    const cutoff = todayStart.getTime();
+    const cutoff = getStartOfDayMs();
     return this._data.shared.filter(s => s.sharedAt >= cutoff).length;
   }
 

package/src/prompts/orchestrator.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { WORKER_TYPES } from '../swarm/worker-registry.js';
+import { buildTemporalAwareness } from '../utils/temporal-awareness.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
@@ -22,18 +23,26 @@ export function getOrchestratorPrompt(config, skillPrompt = null, userPersona =
     .map(([key, w]) => `  - **${key}**: ${w.emoji} ${w.description}`)
     .join('\n');
 
-  // Build current time header
-  const now = new Date();
-  const timeStr = now.toLocaleString('en-US', {
-    weekday: 'long',
-    year: 'numeric',
-    month: 'long',
-    day: 'numeric',
-    hour: '2-digit',
-    minute: '2-digit',
-    timeZoneName: 'short',
-  });
-  let timeBlock = `## Current Time\n${timeStr}`;
+  // Build current time header — enhanced with spatial/temporal awareness if local config exists
+  const awareness = buildTemporalAwareness();
+  let timeBlock;
+  if (awareness) {
+    // Full awareness block from local_context.json (timezone, location, work status)
+    timeBlock = awareness;
+  } else {
+    // Fallback: basic server time (no local context configured)
+    const now = new Date();
+    const timeStr = now.toLocaleString('en-US', {
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+      timeZoneName: 'short',
+    });
+    timeBlock = `## Current Time\n${timeStr}`;
+  }
   if (temporalContext) {
     timeBlock += `\n${temporalContext}`;
   }

package/src/providers/base.js

@@ -12,11 +12,30 @@ export class BaseProvider {
     this.timeout = timeout || 60_000;
   }
 
+  /**
+   * Compute retry delay using exponential backoff with full jitter.
+   * Formula: random(0, min(MAX_BACKOFF, BASE * 2^attempt))
+   * This distributes retries across time and avoids thundering-herd
+   * when multiple workers retry simultaneously after a service hiccup.
+   *
+   * @param {number} attempt - Current attempt (1-indexed)
+   * @returns {number} Delay in milliseconds
+   */
+  _retryDelay(attempt) {
+    const BASE_MS = 1000;
+    const MAX_BACKOFF_MS = 30_000;
+    const ceiling = Math.min(MAX_BACKOFF_MS, BASE_MS * Math.pow(2, attempt));
+    return Math.round(Math.random() * ceiling);
+  }
+
   /**
    * Wrap an async LLM call with timeout + retries on transient errors (up to 3 attempts).
    * Composes an internal timeout AbortController with an optional external signal
    * (e.g. worker cancellation). Either aborting will cancel the call.
    *
+   * Uses exponential backoff with full jitter between retries to avoid
+   * thundering-herd effects when services recover from outages.
+   *
    * @param {(signal: AbortSignal) => Promise<any>} fn - The API call, receives composed signal
    * @param {AbortSignal} [externalSignal] - Optional external abort signal
    * @returns {Promise<any>}
@@ -56,7 +75,8 @@ export class BaseProvider {
         removeListener?.();
 
         if (attempt < 3 && this._isTransient(err)) {
-          await new Promise((r) => setTimeout(r, 1500 * attempt));
+          const delay = this._retryDelay(attempt);
+          await new Promise((r) => setTimeout(r, delay));
           continue;
         }
         throw err;
@@ -66,17 +86,28 @@ export class BaseProvider {
 
   /**
    * Determine if an error is transient and worth retrying.
-   * Covers connection errors, timeouts, 5xx, and 429 rate limits.
+   * Covers connection errors, DNS failures, timeouts, 5xx, and 429 rate limits.
    */
   _isTransient(err) {
     const msg = err?.message || '';
+
+    // Network-level & connection errors
     if (
       msg.includes('Connection error') ||
       msg.includes('ECONNRESET') ||
+      msg.includes('ECONNREFUSED') ||
+      msg.includes('ECONNABORTED') ||
+      msg.includes('EPIPE') ||
+      msg.includes('ENETUNREACH') ||
+      msg.includes('EHOSTUNREACH') ||
       msg.includes('socket hang up') ||
       msg.includes('ETIMEDOUT') ||
+      msg.includes('ENOTFOUND') ||
+      msg.includes('EAI_AGAIN') ||
       msg.includes('fetch failed') ||
-      msg.includes('timed out')
+      msg.includes('timed out') ||
+      msg.includes('network socket disconnected') ||
+      msg.includes('other side closed')
     ) {
       return true;
     }
@@ -92,7 +123,8 @@ export class BaseProvider {
       } catch {}
     }
 
-    return (status >= 500 && status < 600) || status === 429;
+    // Anthropic overloaded (529) is also transient
+    return (status >= 500 && status < 600) || status === 429 || status === 529;
   }
 
   /**

package/src/security/auth.js

@@ -1,9 +1,46 @@
 export function isAllowedUser(userId, config) {
   const allowed = config.telegram.allowed_users;
-  if (!allowed || allowed.length === 0) return true; // dev mode
+  if (!allowed || allowed.length === 0) return false;
   return allowed.includes(userId);
 }
 
 export function getUnauthorizedMessage() {
   return 'Access denied. You are not authorized to use this bot.';
 }
+
+/**
+ * Send an alert to the admin when an unauthorized user attempts access.
+ */
+export async function alertAdmin(bot, { userId, username, firstName, text, type }) {
+  const adminId = Number(process.env.OWNER_TELEGRAM_ID);
+  if (!adminId) return;
+
+  const userTag = username ? `@${username}` : 'بدون معرّف';
+  const name = firstName || 'غير معروف';
+  const content = text || '—';
+  const updateType = type || 'message';
+
+  const alert =
+    `🚨 *محاولة وصول غير مصرح بها\\!*\n\n` +
+    `👤 *المستخدم:* ${escapeMarkdown(userTag)} \\(ID: \`${userId}\`\\)\n` +
+    `📛 *الاسم:* ${escapeMarkdown(name)}\n` +
+    `📩 *النوع:* ${escapeMarkdown(updateType)}\n` +
+    `💬 *المحتوى:* ${escapeMarkdown(content)}`;
+
+  try {
+    await bot.sendMessage(adminId, alert, { parse_mode: 'MarkdownV2' });
+  } catch {
+    // Fallback to plain text if MarkdownV2 fails
+    const plain =
+      `🚨 محاولة وصول غير مصرح بها!\n\n` +
+      `👤 المستخدم: ${userTag} (ID: ${userId})\n` +
+      `📛 الاسم: ${name}\n` +
+      `📩 النوع: ${updateType}\n` +
+      `💬 المحتوى: ${content}`;
+    await bot.sendMessage(adminId, plain).catch(() => {});
+  }
+}
+
+function escapeMarkdown(text) {
+  return String(text).replace(/[_*[\]()~`>#+\-=|{}.!\\]/g, '\\$&');
+}

package/src/services/stt.js

@@ -38,9 +38,18 @@ export class STTService {
 
     return new Promise((resolve, reject) => {
       const writer = createWriteStream(tmpPath);
+
+      const fail = (err) => {
+        writer.destroy();
+        // Clean up the partial temp file so it doesn't leak on disk
+        try { unlinkSync(tmpPath); } catch {}
+        reject(err);
+      };
+
+      response.data.on('error', fail);
       response.data.pipe(writer);
       writer.on('finish', () => resolve(tmpPath));
-      writer.on('error', reject);
+      writer.on('error', fail);
     });
   }
 

package/src/tools/docker.js

@@ -1,4 +1,5 @@
 import { shellRun, shellEscape } from '../utils/shell.js';
+import { getLogger } from '../utils/logger.js';
 
 const run = (cmd, timeout = 30000) => shellRun(cmd, timeout, { maxBuffer: 10 * 1024 * 1024 });
 
@@ -53,21 +54,49 @@ export const definitions = [
 
 export const handlers = {
   docker_ps: async (params) => {
+    const logger = getLogger();
     const flag = params.all ? '-a' : '';
-    return await run(`docker ps ${flag} --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}\t{{.Image}}"`);
+    logger.debug('docker_ps: listing containers');
+    const result = await run(`docker ps ${flag} --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}\t{{.Image}}"`);
+    if (result.error) logger.error(`docker_ps failed: ${result.error}`);
+    return result;
   },
 
   docker_logs: async (params) => {
-    const tail = parseInt(params.tail, 10) || 100;
-    return await run(`docker logs --tail ${tail} ${shellEscape(params.container)}`);
+    const logger = getLogger();
+    if (params.tail != null) {
+      const tail = parseInt(params.tail, 10);
+      if (!Number.isFinite(tail) || tail <= 0 || tail > 10000) {
+        return { error: 'Invalid tail value: must be between 1 and 10000' };
+      }
+      logger.debug(`docker_logs: fetching ${tail} lines from ${params.container}`);
+      const result = await run(`docker logs --tail ${tail} ${shellEscape(params.container)}`);
+      if (result.error) logger.error(`docker_logs failed for ${params.container}: ${result.error}`);
+      return result;
+    }
+    logger.debug(`docker_logs: fetching 100 lines from ${params.container}`);
+    const result = await run(`docker logs --tail 100 ${shellEscape(params.container)}`);
+    if (result.error) logger.error(`docker_logs failed for ${params.container}: ${result.error}`);
+    return result;
   },
 
   docker_exec: async (params) => {
-    return await run(`docker exec ${shellEscape(params.container)} ${params.command}`);
+    const logger = getLogger();
+    if (!params.command || !params.command.trim()) {
+      return { error: 'Command must not be empty' };
+    }
+    logger.debug(`docker_exec: running command in ${params.container}`);
+    const result = await run(`docker exec ${shellEscape(params.container)} sh -c ${shellEscape(params.command)}`);
+    if (result.error) logger.error(`docker_exec failed in ${params.container}: ${result.error}`);
+    return result;
   },
 
   docker_compose: async (params) => {
+    const logger = getLogger();
     const dir = params.project_dir ? `-f ${shellEscape(params.project_dir + '/docker-compose.yml')}` : '';
-    return await run(`docker compose ${dir} ${params.action}`, 120000);
+    logger.debug(`docker_compose: ${params.action}`);
+    const result = await run(`docker compose ${dir} ${params.action}`, 120000);
+    if (result.error) logger.error(`docker_compose '${params.action}' failed: ${result.error}`);
+    return result;
   },
 };

package/src/tools/git.js

@@ -2,6 +2,7 @@ import simpleGit from 'simple-git';
 import { join } from 'path';
 import { homedir } from 'os';
 import { mkdirSync } from 'fs';
+import { getLogger } from '../utils/logger.js';
 
 function getWorkspaceDir(config) {
   const dir = config.claude_code?.workspace_dir || join(homedir(), '.kernelbot', 'workspaces');
@@ -117,6 +118,7 @@ export const handlers = {
       await git.clone(authUrl, targetDir);
       return { success: true, path: targetDir };
     } catch (err) {
+      getLogger().error(`git_clone failed for ${params.repo}: ${err.message}`);
       return { error: err.message };
     }
   },
@@ -132,6 +134,7 @@ export const handlers = {
       }
       return { success: true, branch };
     } catch (err) {
+      getLogger().error(`git_checkout failed for branch ${params.branch}: ${err.message}`);
       return { error: err.message };
     }
   },
@@ -144,6 +147,7 @@ export const handlers = {
       const result = await git.commit(message);
       return { success: true, commit: result.commit, summary: result.summary };
     } catch (err) {
+      getLogger().error(`git_commit failed: ${err.message}`);
       return { error: err.message };
     }
   },
@@ -169,6 +173,7 @@ export const handlers = {
       await git.push('origin', branch, options);
       return { success: true, branch };
     } catch (err) {
+      getLogger().error(`git_push failed: ${err.message}`);
       return { error: err.message };
     }
   },
@@ -181,6 +186,7 @@ export const handlers = {
       const staged = await git.diff(['--cached']);
       return { unstaged: diff || '(no changes)', staged: staged || '(no staged changes)' };
     } catch (err) {
+      getLogger().error(`git_diff failed: ${err.message}`);
       return { error: err.message };
     }
   },

package/src/tools/github.js

@@ -1,4 +1,5 @@
 import { Octokit } from '@octokit/rest';
+import { getLogger } from '../utils/logger.js';
 
 function getOctokit(config) {
   const token = config.github?.token || process.env.GITHUB_TOKEN;
@@ -104,6 +105,7 @@ export const handlers = {
 
       return { success: true, pr_number: data.number, url: data.html_url };
     } catch (err) {
+      getLogger().error(`github_create_pr failed: ${err.message}`);
       return { error: err.message };
     }
   },
@@ -122,6 +124,7 @@ export const handlers = {
 
       return { diff: data };
     } catch (err) {
+      getLogger().error(`github_get_pr_diff failed: ${err.message}`);
       return { error: err.message };
     }
   },
@@ -141,6 +144,7 @@ export const handlers = {
 
       return { success: true, review_id: data.id };
     } catch (err) {
+      getLogger().error(`github_post_review failed: ${err.message}`);
       return { error: err.message };
     }
   },
@@ -169,6 +173,7 @@ export const handlers = {
 
       return { success: true, url: data.html_url, clone_url: data.clone_url };
     } catch (err) {
+      getLogger().error(`github_create_repo failed: ${err.message}`);
       return { error: err.message };
     }
   },
@@ -195,6 +200,7 @@ export const handlers = {
 
       return { prs };
     } catch (err) {
+      getLogger().error(`github_list_prs failed: ${err.message}`);
       return { error: err.message };
     }
   },

package/src/tools/jira.js

@@ -1,4 +1,5 @@
 import axios from 'axios';
+import { getLogger } from '../utils/logger.js';
 
 /**
  * Create an axios instance configured for the JIRA REST API.
@@ -142,6 +143,7 @@ export const handlers = {
       if (err.response?.status === 404) {
         return { error: `Ticket ${params.ticket_key} not found` };
       }
+      getLogger().error(`jira_get_ticket failed for ${params.ticket_key}: ${err.message}`);
       return { error: err.response?.data?.errorMessages?.join('; ') || err.message };
     }
   },
@@ -169,6 +171,7 @@ export const handlers = {
         tickets: (data.issues || []).map(formatIssue),
       };
     } catch (err) {
+      getLogger().error(`jira_search_tickets failed: ${err.message}`);
       return { error: err.response?.data?.errorMessages?.join('; ') || err.message };
     }
   },
@@ -198,6 +201,7 @@ export const handlers = {
         tickets: (data.issues || []).map(formatIssue),
       };
     } catch (err) {
+      getLogger().error(`jira_list_my_tickets failed: ${err.message}`);
       return { error: err.response?.data?.errorMessages?.join('; ') || err.message };
     }
   },
@@ -226,6 +230,7 @@ export const handlers = {
         tickets: (data.issues || []).map(formatIssue),
       };
     } catch (err) {
+      getLogger().error(`jira_get_project_tickets failed for ${params.project_key}: ${err.message}`);
       return { error: err.response?.data?.errorMessages?.join('; ') || err.message };
     }
   },

package/src/tools/monitor.js

@@ -59,17 +59,24 @@ export const handlers = {
   },
 
   system_logs: async (params) => {
-    const lines = parseInt(params.lines, 10) || 50;
+    let finalLines = 50;
+    if (params.lines != null) {
+      const lines = parseInt(params.lines, 10);
+      if (!Number.isFinite(lines) || lines <= 0 || lines > 10000) {
+        return { error: 'Invalid lines value: must be between 1 and 10000' };
+      }
+      finalLines = lines;
+    }
     const source = params.source || 'journalctl';
     const filter = params.filter;
 
     if (source === 'journalctl') {
       const filterArg = filter ? ` -g ${shellEscape(filter)}` : '';
-      return await run(`journalctl -n ${lines}${filterArg} --no-pager`);
+      return await run(`journalctl -n ${finalLines}${filterArg} --no-pager`);
     }
 
     // Reading a log file
     const filterCmd = filter ? ` | grep -i ${shellEscape(filter)}` : '';
-    return await run(`tail -n ${lines} ${shellEscape(source)}${filterCmd}`);
+    return await run(`tail -n ${finalLines} ${shellEscape(source)}${filterCmd}`);
   },
 };

package/src/tools/network.js

@@ -1,4 +1,5 @@
 import { shellRun, shellEscape } from '../utils/shell.js';
+import { getLogger } from '../utils/logger.js';
 
 const run = (cmd, timeout = 15000) => shellRun(cmd, timeout);
 
@@ -38,14 +39,17 @@ export const definitions = [
 
 export const handlers = {
   check_port: async (params) => {
+    const logger = getLogger();
     const host = params.host || 'localhost';
     const port = parseInt(params.port, 10);
     if (!Number.isFinite(port) || port <= 0 || port > 65535) return { error: 'Invalid port number' };
 
+    logger.debug(`check_port: checking ${host}:${port}`);
     // Use nc (netcat) for port check — works on both macOS and Linux
     const result = await run(`nc -z -w 3 ${shellEscape(host)} ${port} 2>&1 && echo "OPEN" || echo "CLOSED"`, 5000);
 
     if (result.error) {
+      logger.error(`check_port failed for ${host}:${port}: ${result.error}`);
       return { port, host, status: 'closed', detail: result.error };
     }
 
@@ -82,15 +86,22 @@ export const handlers = {
   },
 
   nginx_reload: async () => {
+    const logger = getLogger();
     // Test config first
+    logger.debug('nginx_reload: testing configuration');
     const test = await run('nginx -t 2>&1');
     if (test.error || (test.output && test.output.includes('failed'))) {
+      logger.error(`nginx_reload: config test failed: ${test.error || test.output}`);
       return { error: `Config test failed: ${test.error || test.output}` };
     }
 
     const reload = await run('nginx -s reload 2>&1');
-    if (reload.error) return reload;
+    if (reload.error) {
+      logger.error(`nginx_reload failed: ${reload.error}`);
+      return reload;
+    }
 
+    logger.debug('nginx_reload: successfully reloaded');
     return { success: true, test_output: test.output };
   },
 };

package/src/tools/process.js

@@ -1,4 +1,5 @@
 import { shellRun as run, shellEscape } from '../utils/shell.js';
+import { getLogger } from '../utils/logger.js';
 
 export const definitions = [
   {
@@ -42,25 +43,38 @@ export const definitions = [
 
 export const handlers = {
   process_list: async (params) => {
+    const logger = getLogger();
     const filter = params.filter;
+    logger.debug(`process_list: ${filter ? `filtering by "${filter}"` : 'listing all'}`);
     const cmd = filter ? `ps aux | head -1 && ps aux | grep -i ${shellEscape(filter)} | grep -v grep` : 'ps aux';
     return await run(cmd);
   },
 
   kill_process: async (params) => {
+    const logger = getLogger();
     if (params.pid) {
       const pid = parseInt(params.pid, 10);
       if (!Number.isFinite(pid) || pid <= 0) return { error: 'Invalid PID' };
-      return await run(`kill ${pid}`);
+      logger.debug(`kill_process: killing PID ${pid}`);
+      const result = await run(`kill ${pid}`);
+      if (result.error) logger.error(`kill_process failed for PID ${pid}: ${result.error}`);
+      return result;
     }
     if (params.name) {
-      return await run(`pkill -f ${shellEscape(params.name)}`);
+      logger.debug(`kill_process: killing processes matching "${params.name}"`);
+      const result = await run(`pkill -f ${shellEscape(params.name)}`);
+      if (result.error) logger.error(`kill_process failed for name "${params.name}": ${result.error}`);
+      return result;
     }
     return { error: 'Provide either pid or name' };
   },
 
   service_control: async (params) => {
+    const logger = getLogger();
     const { service, action } = params;
-    return await run(`systemctl ${shellEscape(action)} ${shellEscape(service)}`);
+    logger.debug(`service_control: ${action} ${service}`);
+    const result = await run(`systemctl ${shellEscape(action)} ${shellEscape(service)}`);
+    if (result.error) logger.error(`service_control failed: ${action} ${service}: ${result.error}`);
+    return result;
   },
 };