@holic512/plugin-systemd 1.0.1

package/README.md

@@ -0,0 +1,71 @@
+# @holic512/plugin-systemd
+
+Interactive systemd service management tool for SlothTool.
+
+SlothTool 的 systemd 服务管理插件，提供交互式操作与命令行支持。
+
+## Install / 安装
+
+```bash
+slothtool install @holic512/plugin-systemd
+```
+
+## Usage / 使用
+
+### Interactive mode / 交互式模式
+
+```bash
+slothtool systemd -i
+```
+
+### Command mode / 命令模式
+
+```bash
+# List services
+slothtool systemd list --state active
+slothtool systemd list --all
+
+# Service actions
+slothtool systemd start ssh.service
+slothtool systemd stop ssh.service
+slothtool systemd restart ssh.service
+slothtool systemd enable ssh.service
+slothtool systemd disable ssh.service
+
+# Logs
+slothtool systemd logs ssh.service --lines 50
+slothtool systemd logs ssh.service --follow
+slothtool systemd logs ssh.service --since "1 hour ago"
+```
+
+## Features / 功能
+
+- Interactive-first UX with history-based quick actions
+- Service management: start/stop/restart/enable/disable/status
+- Logs with line limit, follow, and since filters
+- History cache for recent services/actions/searches
+- Bilingual (Chinese/English) messages
+
+- 交互式优先，支持历史记录快捷操作
+- 服务管理：启动/停止/重启/启用/禁用/状态
+- 日志查看：行数限制、持续跟随、时间过滤
+- 历史缓存：最近服务/操作/搜索记录
+- 中英文双语支持
+
+## Troubleshooting / 常见问题
+
+### Permission denied / 权限不足
+
+Some actions require root permission. The plugin does not auto-sudo. Copy the suggestion it prints, for example:
+
+```bash
+sudo systemctl restart nginx.service
+```
+
+部分操作需要 root 权限。插件不会自动提权，请复制提示的 sudo 命令执行。
+
+### systemctl not found / 找不到 systemctl
+
+Ensure you are running on a Linux system with systemd installed and running.
+
+请确认运行环境为 Linux 且已安装并启用 systemd。

package/bin/systemd.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+const {t} = require('../lib/i18n');
+const systemd = require('../lib/systemd');
+const history = require('../lib/history');
+const config = require('../lib/config');
+const {interactiveMain} = require('../lib/interactive');
+
+const args = process.argv.slice(2);
+
+function showHelp() {
+    console.log(t('title') + '\n');
+    console.log(t('usage'));
+    console.log('  systemd [options] [command]\n');
+    console.log(t('options'));
+    console.log('  -h, --help        ' + t('help'));
+    console.log('  -i, --interactive ' + t('interactive') + '\n');
+    console.log(t('commands'));
+    console.log('  list [--all] [--state active|inactive|failed] [--pattern <keyword>]  ' + t('commandList'));
+    console.log('  start <service>                                                 ' + t('commandStart'));
+    console.log('  stop <service>                                                  ' + t('commandStop'));
+    console.log('  restart <service>                                               ' + t('commandRestart'));
+    console.log('  enable <service>                                                ' + t('commandEnable'));
+    console.log('  disable <service>                                               ' + t('commandDisable'));
+    console.log('  logs <service> [--lines N] [--follow] [--since "..."]            ' + t('commandLogs'));
+    console.log('  status <service>                                                ' + t('commandStatus') + '\n');
+    console.log(t('examples'));
+    console.log('  systemd -i                          ' + t('exampleInteractive'));
+    console.log('  systemd list --state active         ' + t('exampleList'));
+    console.log('  systemd list --all                  ' + t('exampleListAll'));
+    console.log('  systemd start ssh.service           ' + t('exampleStart'));
+    console.log('  systemd logs ssh.service --lines 50 ' + t('exampleLogs'));
+}
+
+function printError(message) {
+    console.error(message);
+}
+
+function checkEnvOrExit() {
+    const env = systemd.checkEnvironment();
+    if (!env.ok) {
+        printError(env.message);
+        process.exit(1);
+    }
+}
+
+function requireServiceName(name) {
+    if (!name) {
+        printError(t('missingService'));
+        process.exit(2);
+    }
+    if (!systemd.validateServiceName(name)) {
+        printError(t('invalidServiceName'));
+        process.exit(2);
+    }
+}
+
+function handlePermissionSuggestion(result, action, service) {
+    if (!result || result.success) return;
+    if (systemd.detectPermissionError(result.message || result.stderr)) {
+        const suggestion = action === 'logs'
+            ? `sudo journalctl -u ${service}`
+            : action === 'list'
+                ? 'sudo systemctl list-units --type=service'
+                : `sudo systemctl ${action} ${service}`;
+        console.error(t('permissionDenied'));
+        console.error(t('suggestion') + ' ' + suggestion);
+    }
+}
+
+async function main() {
+    if (args.length === 0 || args.includes('-i') || args.includes('--interactive')) {
+        checkEnvOrExit();
+        await interactiveMain();
+        return;
+    }
+
+    if (args.includes('--help') || args.includes('-h')) {
+        showHelp();
+        process.exit(0);
+    }
+
+    checkEnvOrExit();
+
+    const command = args[0];
+
+    if (command === 'list') {
+        const all = args.includes('--all');
+        let state;
+        let pattern;
+        for (let i = 1; i < args.length; i += 1) {
+            if (args[i] === '--state' && args[i + 1]) {
+                state = args[i + 1];
+            }
+            if (args[i] === '--pattern' && args[i + 1]) {
+                pattern = args[i + 1];
+            }
+        }
+        const result = await systemd.listServices({all, state, pattern});
+        if (result.result.success) {
+            process.stdout.write(result.result.stdout);
+        } else {
+            printError(result.result.message || t('commandFailed'));
+            handlePermissionSuggestion(result.result, 'list', '');
+            process.exit(1);
+        }
+        return;
+    }
+
+    if (command === 'start' || command === 'stop' || command === 'restart' || command === 'enable' || command === 'disable' || command === 'status') {
+        const service = args[1];
+        requireServiceName(service);
+        let result;
+        switch (command) {
+            case 'start':
+                result = await systemd.startService(service);
+                break;
+            case 'stop':
+                result = await systemd.stopService(service);
+                break;
+            case 'restart':
+                result = await systemd.restartService(service);
+                break;
+            case 'enable':
+                result = await systemd.enableService(service);
+                break;
+            case 'disable':
+                result = await systemd.disableService(service);
+                break;
+            case 'status':
+                result = await systemd.statusService(service);
+                break;
+        }
+        if (result.success) {
+            if (result.stdout && !result.streamed) process.stdout.write(result.stdout);
+        } else {
+            printError(result.message || t('commandFailed'));
+            handlePermissionSuggestion(result, command, service);
+            process.exit(1);
+        }
+        history.addRecentService(service);
+        history.addAction(systemd.buildResult(command, service, result));
+        return;
+    }
+
+    if (command === 'logs') {
+        const service = args[1];
+        requireServiceName(service);
+        let lines;
+        let follow = false;
+        let since;
+        for (let i = 2; i < args.length; i += 1) {
+            if (args[i] === '--lines' && args[i + 1]) {
+                lines = Number(args[i + 1]);
+            }
+            if (args[i] === '--follow') {
+                follow = true;
+            }
+            if (args[i] === '--since' && args[i + 1]) {
+                since = args[i + 1];
+            }
+        }
+        const cfg = config.readConfig();
+        const result = await systemd.showLogs(service, {
+            lines: lines || cfg.logLines,
+            follow,
+            since
+        });
+        if (result.success) {
+            if (result.stdout && !result.streamed) process.stdout.write(result.stdout);
+        } else {
+            printError(result.message || t('commandFailed'));
+            handlePermissionSuggestion(result, 'logs', service);
+            process.exit(1);
+        }
+        history.addRecentService(service);
+        history.addAction(systemd.buildResult('logs', service, result));
+        return;
+    }
+
+    printError(t('invalidArgs'));
+    showHelp();
+    process.exit(2);
+}
+
+process.on('SIGINT', () => {
+    process.exit(0);
+});
+
+main().catch(error => {
+    console.error(t('commandFailed') + ': ' + error.message);
+    process.exit(1);
+});

package/lib/config.js

@@ -0,0 +1,77 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+function getSlothToolHome() {
+    return path.join(os.homedir(), '.slothtool');
+}
+
+function getPluginConfigsDir() {
+    return path.join(getSlothToolHome(), 'plugin-configs');
+}
+
+function getSystemdConfigPath() {
+    return path.join(getPluginConfigsDir(), 'systemd.json');
+}
+
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, {recursive: true});
+    }
+}
+
+function getDefaultConfig() {
+    return {
+        logLines: 200,
+        confirmDangerous: true,
+        historyLimits: {
+            services: 20,
+            actions: 50,
+            searches: 20
+        }
+    };
+}
+
+function readConfig() {
+    const configPath = getSystemdConfigPath();
+    ensureDir(getPluginConfigsDir());
+
+    if (!fs.existsSync(configPath)) {
+        return getDefaultConfig();
+    }
+
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const config = JSON.parse(content);
+        const defaultConfig = getDefaultConfig();
+        return {
+            logLines: config.logLines ?? defaultConfig.logLines,
+            confirmDangerous: config.confirmDangerous ?? defaultConfig.confirmDangerous,
+            historyLimits: {
+                ...defaultConfig.historyLimits,
+                ...(config.historyLimits || {})
+            }
+        };
+    } catch (error) {
+        console.error('Failed to read config:', error.message);
+        return getDefaultConfig();
+    }
+}
+
+function writeConfig(config) {
+    const configPath = getSystemdConfigPath();
+    ensureDir(getPluginConfigsDir());
+
+    try {
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    } catch (error) {
+        console.error('Failed to write config:', error.message);
+        throw error;
+    }
+}
+
+module.exports = {
+    getDefaultConfig,
+    readConfig,
+    writeConfig
+};

package/lib/history.js

@@ -0,0 +1,104 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const config = require('./config');
+
+function getSlothToolHome() {
+    return path.join(os.homedir(), '.slothtool');
+}
+
+function getPluginConfigsDir() {
+    return path.join(getSlothToolHome(), 'plugin-configs');
+}
+
+function getHistoryPath() {
+    return path.join(getPluginConfigsDir(), 'systemd.history.json');
+}
+
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, {recursive: true});
+    }
+}
+
+function getDefaultHistory() {
+    return {
+        recentServices: [],
+        recentSearches: [],
+        actions: []
+    };
+}
+
+function readHistory() {
+    const historyPath = getHistoryPath();
+    ensureDir(getPluginConfigsDir());
+
+    if (!fs.existsSync(historyPath)) {
+        return getDefaultHistory();
+    }
+
+    try {
+        const content = fs.readFileSync(historyPath, 'utf8');
+        const history = JSON.parse(content);
+        return {
+            recentServices: Array.isArray(history.recentServices) ? history.recentServices : [],
+            recentSearches: Array.isArray(history.recentSearches) ? history.recentSearches : [],
+            actions: Array.isArray(history.actions) ? history.actions : []
+        };
+    } catch (error) {
+        return getDefaultHistory();
+    }
+}
+
+function writeHistory(history) {
+    const historyPath = getHistoryPath();
+    ensureDir(getPluginConfigsDir());
+    fs.writeFileSync(historyPath, JSON.stringify(history, null, 2), 'utf8');
+}
+
+function trimList(list, limit) {
+    if (!Array.isArray(list)) {
+        return [];
+    }
+    return list.slice(0, limit);
+}
+
+function addRecentService(service) {
+    if (!service) return;
+    const cfg = config.readConfig();
+    const history = readHistory();
+    const newList = [service, ...history.recentServices.filter(item => item !== service)];
+    history.recentServices = trimList(newList, cfg.historyLimits.services);
+    writeHistory(history);
+}
+
+function addRecentSearch(search) {
+    if (!search) return;
+    const cfg = config.readConfig();
+    const history = readHistory();
+    const newList = [search, ...history.recentSearches.filter(item => item !== search)];
+    history.recentSearches = trimList(newList, cfg.historyLimits.searches);
+    writeHistory(history);
+}
+
+function addAction(action) {
+    if (!action) return;
+    const cfg = config.readConfig();
+    const history = readHistory();
+    const newList = [action, ...history.actions];
+    history.actions = trimList(newList, cfg.historyLimits.actions);
+    writeHistory(history);
+}
+
+function clearHistory() {
+    writeHistory(getDefaultHistory());
+}
+
+module.exports = {
+    readHistory,
+    writeHistory,
+    addRecentService,
+    addRecentSearch,
+    addAction,
+    clearHistory
+};

package/lib/i18n.js

@@ -0,0 +1,204 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+function getSettingsPath() {
+    return path.join(os.homedir(), '.slothtool', 'settings.json');
+}
+
+function getLanguage() {
+    try {
+        if (fs.existsSync(getSettingsPath())) {
+            const settings = JSON.parse(fs.readFileSync(getSettingsPath(), 'utf8'));
+            return settings.language || 'zh';
+        }
+    } catch (error) {
+        // ignore errors and fallback
+    }
+    return 'zh';
+}
+
+const messages = {
+    zh: {
+        title: 'systemd - 服务管理工具',
+        usage: '用法：',
+        options: '选项：',
+        commands: '命令：',
+        examples: '示例：',
+        help: '显示帮助信息',
+        interactive: '交互式模式',
+        commandList: '列出服务',
+        commandStart: '启动服务',
+        commandStop: '停止服务',
+        commandRestart: '重启服务',
+        commandEnable: '启用服务',
+        commandDisable: '禁用服务',
+        commandLogs: '查看服务日志',
+        commandStatus: '查看服务状态',
+        listAll: '包含未运行服务',
+        listState: '按状态过滤',
+        listPattern: '按关键词过滤',
+        logsLines: '显示行数',
+        logsFollow: '持续跟随日志',
+        logsSince: '起始时间',
+        exampleInteractive: '进入交互式模式',
+        exampleList: '列出运行中的服务',
+        exampleListAll: '列出所有服务',
+        exampleStart: '启动服务',
+        exampleLogs: '查看服务日志',
+        notLinux: '当前系统不支持 systemd（仅支持 Linux）',
+        systemctlNotFound: '未找到 systemctl 命令，请确认 systemd 已安装',
+        invalidServiceName: '无效的服务名称',
+        missingService: '缺少服务名称参数',
+        invalidArgs: '参数错误',
+        commandFailed: '命令执行失败',
+        permissionDenied: '权限不足，无法执行操作',
+        suggestion: '可尝试：',
+        noServicesFound: '未找到匹配的服务',
+        menuTitle: '请选择操作：',
+        menuQuickActions: '快速操作（历史记录）',
+        menuListChoose: '列表并选择服务',
+        menuStart: '启动服务',
+        menuStop: '停止服务',
+        menuRestart: '重启服务',
+        menuEnable: '启用服务',
+        menuDisable: '禁用服务',
+        menuLogs: '查看日志',
+        menuHistory: '历史记录',
+        menuSettings: '设置',
+        menuExit: '退出',
+        menuStatus: '查看服务状态',
+        promptSearch: '输入搜索关键词（可选）：',
+        promptAction: '选择操作：',
+        quickActionRecentActions: '最近操作',
+        quickActionRecentService: '最近服务',
+        promptState: '选择状态过滤：',
+        stateAll: '全部',
+        stateActive: '运行中',
+        stateInactive: '未运行',
+        stateFailed: '失败',
+        promptService: '选择服务：',
+        promptServiceName: '请输入服务名称：',
+        promptConfirmStop: '确定要停止该服务吗？',
+        promptConfirmDisable: '确定要禁用该服务吗？',
+        promptConfirmRestart: '确定要重启该服务吗？',
+        promptLogLines: '日志行数：',
+        promptLogFollow: '是否持续跟随日志？',
+        promptLogSince: '起始时间（可选）：',
+        historyEmpty: '暂无历史记录',
+        historyActionsTitle: '最近操作：',
+        historyServicesTitle: '最近服务：',
+        historySearchesTitle: '最近搜索：',
+        historyClearConfirm: '确定清空历史记录吗？',
+        historyCleared: '历史记录已清空',
+        settingsTitle: '设置',
+        settingsLogLines: '默认日志行数：',
+        settingsConfirmDangerous: '危险操作确认：',
+        settingsHistoryLimits: '历史记录上限：',
+        settingsSaved: '设置已保存',
+        actionSuccess: '操作成功',
+        actionFailed: '操作失败',
+        unknownError: '未知错误'
+    },
+    en: {
+        title: 'systemd - Service Management Tool',
+        usage: 'Usage:',
+        options: 'Options:',
+        commands: 'Commands:',
+        examples: 'Examples:',
+        help: 'Show help message',
+        interactive: 'Interactive mode',
+        commandList: 'List services',
+        commandStart: 'Start service',
+        commandStop: 'Stop service',
+        commandRestart: 'Restart service',
+        commandEnable: 'Enable service',
+        commandDisable: 'Disable service',
+        commandLogs: 'Show service logs',
+        commandStatus: 'Show service status',
+        listAll: 'Include inactive services',
+        listState: 'Filter by state',
+        listPattern: 'Filter by keyword',
+        logsLines: 'Number of lines',
+        logsFollow: 'Follow logs',
+        logsSince: 'Since time',
+        exampleInteractive: 'Enter interactive mode',
+        exampleList: 'List active services',
+        exampleListAll: 'List all services',
+        exampleStart: 'Start a service',
+        exampleLogs: 'Show service logs',
+        notLinux: 'systemd is only supported on Linux',
+        systemctlNotFound: 'systemctl not found. Please ensure systemd is installed',
+        invalidServiceName: 'Invalid service name',
+        missingService: 'Missing service name',
+        invalidArgs: 'Invalid arguments',
+        commandFailed: 'Command failed',
+        permissionDenied: 'Permission denied',
+        suggestion: 'Try:',
+        noServicesFound: 'No services matched',
+        menuTitle: 'Select an action:',
+        menuQuickActions: 'Quick actions (history)',
+        menuListChoose: 'List and choose service',
+        menuStart: 'Start service',
+        menuStop: 'Stop service',
+        menuRestart: 'Restart service',
+        menuEnable: 'Enable service',
+        menuDisable: 'Disable service',
+        menuLogs: 'View logs',
+        menuHistory: 'History',
+        menuSettings: 'Settings',
+        menuExit: 'Exit',
+        menuStatus: 'Show service status',
+        promptSearch: 'Search keyword (optional):',
+        promptAction: 'Select action:',
+        quickActionRecentActions: 'Recent actions',
+        quickActionRecentService: 'Recent services',
+        promptState: 'Select state filter:',
+        stateAll: 'All',
+        stateActive: 'Active',
+        stateInactive: 'Inactive',
+        stateFailed: 'Failed',
+        promptService: 'Select service:',
+        promptServiceName: 'Enter service name:',
+        promptConfirmStop: 'Are you sure you want to stop this service?',
+        promptConfirmDisable: 'Are you sure you want to disable this service?',
+        promptConfirmRestart: 'Are you sure you want to restart this service?',
+        promptLogLines: 'Log lines:',
+        promptLogFollow: 'Follow logs?',
+        promptLogSince: 'Since time (optional):',
+        historyEmpty: 'No history available',
+        historyActionsTitle: 'Recent actions:',
+        historyServicesTitle: 'Recent services:',
+        historySearchesTitle: 'Recent searches:',
+        historyClearConfirm: 'Clear history?',
+        historyCleared: 'History cleared',
+        settingsTitle: 'Settings',
+        settingsLogLines: 'Default log lines:',
+        settingsConfirmDangerous: 'Confirm dangerous actions:',
+        settingsHistoryLimits: 'History limits:',
+        settingsSaved: 'Settings saved',
+        actionSuccess: 'Action succeeded',
+        actionFailed: 'Action failed',
+        unknownError: 'Unknown error'
+    }
+};
+
+function t(key, params = {}) {
+    const lang = getLanguage();
+    const langMessages = messages[lang] || messages.zh;
+    let message = langMessages[key];
+    if (message === undefined) {
+        return key;
+    }
+    if (typeof message === 'string') {
+        return message.replace(/\{(\w+)\}/g, (match, param) => {
+            return params[param] !== undefined ? params[param] : match;
+        });
+    }
+    return message;
+}
+
+module.exports = {
+    t,
+    getLanguage
+};

package/lib/interactive.js

@@ -0,0 +1,458 @@
+const prompts = require('prompts');
+const {t} = require('./i18n');
+const config = require('./config');
+const history = require('./history');
+const systemd = require('./systemd');
+
+function formatServiceChoice(service) {
+    const description = `${service.load} ${service.active} ${service.sub}`;
+    const title = `${service.unit} - ${service.description}`;
+    return {title, value: service.unit, description};
+}
+
+function formatActionLabel(action) {
+    switch (action) {
+        case 'start':
+            return t('commandStart');
+        case 'stop':
+            return t('commandStop');
+        case 'restart':
+            return t('commandRestart');
+        case 'enable':
+            return t('commandEnable');
+        case 'disable':
+            return t('commandDisable');
+        case 'status':
+            return t('commandStatus');
+        case 'logs':
+            return t('commandLogs');
+        default:
+            return action;
+    }
+}
+
+function printResult(result, action, service) {
+    if (result.success) {
+        if (result.stdout && !result.streamed) {
+            process.stdout.write(result.stdout);
+        }
+        if (!result.streamed) {
+            console.log(t('actionSuccess'));
+        }
+    } else {
+        console.error(t('actionFailed') + ': ' + (result.message || t('unknownError')));
+        if (systemd.detectPermissionError(result.message || result.stderr)) {
+            console.error(t('permissionDenied'));
+            const suggestion = action === 'logs'
+                ? `sudo journalctl -u ${service}`
+                : action === 'list'
+                    ? 'sudo systemctl list-units --type=service'
+                    : `sudo systemctl ${action} ${service}`;
+            console.error(t('suggestion') + ' ' + suggestion);
+        }
+    }
+}
+
+async function chooseServiceByList() {
+    const search = await prompts({
+        type: 'text',
+        name: 'keyword',
+        message: t('promptSearch')
+    });
+    if (search.keyword) {
+        history.addRecentSearch(search.keyword);
+    }
+    const state = await prompts({
+        type: 'select',
+        name: 'state',
+        message: t('promptState'),
+        choices: [
+            {title: t('stateAll'), value: 'all'},
+            {title: t('stateActive'), value: 'active'},
+            {title: t('stateInactive'), value: 'inactive'},
+            {title: t('stateFailed'), value: 'failed'}
+        ]
+    });
+    const filterState = state.state === 'all' ? undefined : state.state;
+    const list = await systemd.listServices({
+        all: state.state === 'all',
+        state: filterState,
+        pattern: search.keyword || undefined,
+        forInteractive: true
+    });
+    if (!list.result.success) {
+        printResult(list.result, 'list', '');
+        return null;
+    }
+    if (list.services.length === 0) {
+        console.log(t('noServicesFound'));
+        return null;
+    }
+    const serviceChoice = await prompts({
+        type: 'select',
+        name: 'service',
+        message: t('promptService'),
+        choices: list.services.map(formatServiceChoice)
+    });
+    if (!serviceChoice.service) {
+        return null;
+    }
+    return serviceChoice.service;
+}
+
+async function inputServiceName() {
+    const response = await prompts({
+        type: 'text',
+        name: 'service',
+        message: t('promptServiceName'),
+        validate: value => systemd.validateServiceName(value) || t('invalidServiceName')
+    });
+    return response.service || null;
+}
+
+async function confirmIfDangerous(action) {
+    const cfg = config.readConfig();
+    if (!cfg.confirmDangerous) return true;
+    if (action === 'stop') {
+        const confirm = await prompts({
+            type: 'confirm',
+            name: 'ok',
+            message: t('promptConfirmStop'),
+            initial: false
+        });
+        return !!confirm.ok;
+    }
+    if (action === 'disable') {
+        const confirm = await prompts({
+            type: 'confirm',
+            name: 'ok',
+            message: t('promptConfirmDisable'),
+            initial: false
+        });
+        return !!confirm.ok;
+    }
+    if (action === 'restart') {
+        const confirm = await prompts({
+            type: 'confirm',
+            name: 'ok',
+            message: t('promptConfirmRestart'),
+            initial: true
+        });
+        return !!confirm.ok;
+    }
+    return true;
+}
+
+async function runAction(action, service) {
+    if (!service) return;
+    let result;
+    switch (action) {
+        case 'start':
+            result = await systemd.startService(service);
+            break;
+        case 'stop':
+            result = await systemd.stopService(service);
+            break;
+        case 'restart':
+            result = await systemd.restartService(service);
+            break;
+        case 'enable':
+            result = await systemd.enableService(service);
+            break;
+        case 'disable':
+            result = await systemd.disableService(service);
+            break;
+        case 'status':
+            result = await systemd.statusService(service);
+            break;
+        case 'logs':
+            result = await systemd.showLogs(service, {lines: config.readConfig().logLines});
+            break;
+        default:
+            return;
+    }
+    printResult(result, action, service);
+    if (result.success) {
+        history.addRecentService(service);
+    }
+    history.addAction(systemd.buildResult(action, service, result));
+}
+
+async function quickActionsMenu() {
+    const hist = history.readHistory();
+    const hasActions = hist.actions.length > 0;
+    const hasServices = hist.recentServices.length > 0;
+    if (!hasActions && !hasServices) {
+        console.log(t('historyEmpty'));
+        return;
+    }
+
+    const modeResponse = await prompts({
+        type: 'select',
+        name: 'mode',
+        message: t('menuQuickActions'),
+        choices: [
+            {title: t('quickActionRecentActions'), value: 'actions', disabled: !hasActions},
+            {title: t('quickActionRecentService'), value: 'service', disabled: !hasServices},
+            {title: t('menuExit'), value: 'exit'}
+        ]
+    });
+
+    if (!modeResponse.mode || modeResponse.mode === 'exit') {
+        return;
+    }
+
+    if (modeResponse.mode === 'actions') {
+        const actionChoices = hist.actions.map((entry, index) => {
+            const label = `${entry.time} - ${formatActionLabel(entry.action)} ${entry.service} (${entry.result})`;
+            return {title: label, value: index};
+        });
+        const response = await prompts({
+            type: 'select',
+            name: 'actionIndex',
+            message: t('quickActionRecentActions'),
+            choices: [
+                ...actionChoices,
+                {title: t('menuExit'), value: '__exit__'}
+            ]
+        });
+        if (response.actionIndex === undefined || response.actionIndex === '__exit__') return;
+        const selected = hist.actions[response.actionIndex];
+        if (!selected) return;
+        await runAction(selected.action, selected.service);
+        return;
+    }
+
+    if (modeResponse.mode === 'service') {
+        const serviceResponse = await prompts({
+            type: 'select',
+            name: 'service',
+            message: t('promptService'),
+            choices: hist.recentServices.slice(0, 10).map(service => ({
+                title: service,
+                value: service
+            }))
+        });
+        if (!serviceResponse.service) return;
+
+        const actionResponse = await prompts({
+            type: 'select',
+            name: 'action',
+            message: t('promptAction'),
+            choices: [
+                {title: t('commandStart'), value: 'start'},
+                {title: t('commandStop'), value: 'stop'},
+                {title: t('commandRestart'), value: 'restart'},
+                {title: t('commandEnable'), value: 'enable'},
+                {title: t('commandDisable'), value: 'disable'},
+                {title: t('commandStatus'), value: 'status'},
+                {title: t('commandLogs'), value: 'logs'}
+            ]
+        });
+        if (!actionResponse.action) return;
+
+        if (['stop', 'disable', 'restart'].includes(actionResponse.action)) {
+            const confirmed = await confirmIfDangerous(actionResponse.action);
+            if (!confirmed) return;
+        }
+
+        if (actionResponse.action === 'logs') {
+            await handleLogsFlow(serviceResponse.service);
+            return;
+        }
+
+        await runAction(actionResponse.action, serviceResponse.service);
+    }
+}
+
+async function historyMenu() {
+    const hist = history.readHistory();
+    if (!hist.actions.length && !hist.recentServices.length && !hist.recentSearches.length) {
+        console.log(t('historyEmpty'));
+        return;
+    }
+    console.log(t('historyActionsTitle'));
+    hist.actions.slice(0, 10).forEach(entry => {
+        console.log(`  ${entry.time} ${formatActionLabel(entry.action)} ${entry.service} (${entry.result})`);
+    });
+    console.log('\n' + t('historyServicesTitle'));
+    hist.recentServices.slice(0, 10).forEach(service => console.log('  ' + service));
+    console.log('\n' + t('historySearchesTitle'));
+    hist.recentSearches.slice(0, 10).forEach(search => console.log('  ' + search));
+
+    const response = await prompts({
+        type: 'confirm',
+        name: 'clear',
+        message: t('historyClearConfirm'),
+        initial: false
+    });
+    if (response.clear) {
+        history.clearHistory();
+        console.log(t('historyCleared'));
+    }
+}
+
+async function settingsMenu() {
+    const cfg = config.readConfig();
+    const logLinesResponse = await prompts({
+        type: 'number',
+        name: 'logLines',
+        message: t('settingsLogLines'),
+        initial: cfg.logLines,
+        min: 1
+    });
+    const confirmResponse = await prompts({
+        type: 'confirm',
+        name: 'confirmDangerous',
+        message: t('settingsConfirmDangerous'),
+        initial: cfg.confirmDangerous
+    });
+    const historyResponse = await prompts({
+        type: 'number',
+        name: 'actionsLimit',
+        message: `${t('settingsHistoryLimits')} (actions)`,
+        initial: cfg.historyLimits.actions,
+        min: 1
+    });
+    const servicesResponse = await prompts({
+        type: 'number',
+        name: 'servicesLimit',
+        message: `${t('settingsHistoryLimits')} (services)`,
+        initial: cfg.historyLimits.services,
+        min: 1
+    });
+    const searchesResponse = await prompts({
+        type: 'number',
+        name: 'searchesLimit',
+        message: `${t('settingsHistoryLimits')} (searches)`,
+        initial: cfg.historyLimits.searches,
+        min: 1
+    });
+
+    const newConfig = {
+        logLines: logLinesResponse.logLines || cfg.logLines,
+        confirmDangerous: confirmResponse.confirmDangerous ?? cfg.confirmDangerous,
+        historyLimits: {
+            actions: historyResponse.actionsLimit || cfg.historyLimits.actions,
+            services: servicesResponse.servicesLimit || cfg.historyLimits.services,
+            searches: searchesResponse.searchesLimit || cfg.historyLimits.searches
+        }
+    };
+    config.writeConfig(newConfig);
+    console.log(t('settingsSaved'));
+}
+
+async function handleLogsFlow(service) {
+    const cfg = config.readConfig();
+    const linesResponse = await prompts({
+        type: 'number',
+        name: 'lines',
+        message: t('promptLogLines'),
+        initial: cfg.logLines,
+        min: 1
+    });
+    const followResponse = await prompts({
+        type: 'confirm',
+        name: 'follow',
+        message: t('promptLogFollow'),
+        initial: false
+    });
+    const sinceResponse = await prompts({
+        type: 'text',
+        name: 'since',
+        message: t('promptLogSince')
+    });
+    const result = await systemd.showLogs(service, {
+        lines: linesResponse.lines || cfg.logLines,
+        follow: !!followResponse.follow,
+        since: sinceResponse.since || undefined
+    });
+    printResult(result, 'logs', service);
+    if (result.success) {
+        history.addRecentService(service);
+    }
+    history.addAction(systemd.buildResult('logs', service, result));
+}
+
+async function interactiveMain() {
+    while (true) {
+        const response = await prompts({
+            type: 'select',
+            name: 'action',
+            message: t('menuTitle'),
+            choices: [
+                {title: t('menuQuickActions'), value: 'quick'},
+                {title: t('menuListChoose'), value: 'listChoose'},
+                {title: t('menuStart'), value: 'start'},
+                {title: t('menuStop'), value: 'stop'},
+                {title: t('menuRestart'), value: 'restart'},
+                {title: t('menuEnable'), value: 'enable'},
+                {title: t('menuDisable'), value: 'disable'},
+                {title: t('menuStatus'), value: 'status'},
+                {title: t('menuLogs'), value: 'logs'},
+                {title: t('menuHistory'), value: 'history'},
+                {title: t('menuSettings'), value: 'settings'},
+                {title: t('menuExit'), value: 'exit'}
+            ]
+        });
+
+        if (!response.action || response.action === 'exit') {
+            break;
+        }
+
+        if (response.action === 'quick') {
+            await quickActionsMenu();
+        } else if (response.action === 'listChoose') {
+            const service = await chooseServiceByList();
+            if (service) {
+                history.addRecentService(service);
+                console.log(service);
+            }
+        } else if (response.action === 'start') {
+            const service = await inputServiceName();
+            if (service) {
+                await runAction('start', service);
+            }
+        } else if (response.action === 'stop') {
+            const service = await inputServiceName();
+            if (service && await confirmIfDangerous('stop')) {
+                await runAction('stop', service);
+            }
+        } else if (response.action === 'restart') {
+            const service = await inputServiceName();
+            if (service && await confirmIfDangerous('restart')) {
+                await runAction('restart', service);
+            }
+        } else if (response.action === 'enable') {
+            const service = await inputServiceName();
+            if (service) {
+                await runAction('enable', service);
+            }
+        } else if (response.action === 'disable') {
+            const service = await inputServiceName();
+            if (service && await confirmIfDangerous('disable')) {
+                await runAction('disable', service);
+            }
+        } else if (response.action === 'status') {
+            const service = await inputServiceName();
+            if (service) {
+                await runAction('status', service);
+            }
+        } else if (response.action === 'logs') {
+            const service = await inputServiceName();
+            if (service) {
+                await handleLogsFlow(service);
+            }
+        } else if (response.action === 'history') {
+            await historyMenu();
+        } else if (response.action === 'settings') {
+            await settingsMenu();
+        }
+
+        console.log('');
+    }
+}
+
+module.exports = {
+    interactiveMain
+};

package/lib/systemd.js

@@ -0,0 +1,184 @@
+const {spawn, spawnSync} = require('child_process');
+const {t} = require('./i18n');
+
+const SAFE_SERVICE_RE = /^[A-Za-z0-9@._:-]+$/;
+
+function validateServiceName(name) {
+    return typeof name === 'string' && name.length > 0 && SAFE_SERVICE_RE.test(name);
+}
+
+function isLinux() {
+    return process.platform === 'linux';
+}
+
+function isSystemctlAvailable() {
+    const result = spawnSync('systemctl', ['--version'], {encoding: 'utf8'});
+    return result.status === 0;
+}
+
+function checkEnvironment() {
+    if (!isLinux()) {
+        return {ok: false, message: t('notLinux')};
+    }
+    if (!isSystemctlAvailable()) {
+        return {ok: false, message: t('systemctlNotFound')};
+    }
+    return {ok: true};
+}
+
+function buildResult(action, service, result) {
+    return {
+        time: new Date().toISOString(),
+        action,
+        service,
+        result: result.success ? 'success' : 'failed',
+        code: result.code ?? 1,
+        message: result.message || ''
+    };
+}
+
+function runCommand(command, args, options = {}) {
+    const streamOutput = !!options.streamOutput;
+    return new Promise((resolve) => {
+        const child = spawn(command, args, {stdio: ['ignore', 'pipe', 'pipe']});
+        let stdout = '';
+        let stderr = '';
+
+        if (child.stdout) {
+            child.stdout.on('data', (data) => {
+                const text = data.toString();
+                stdout += text;
+                if (streamOutput) {
+                    process.stdout.write(text);
+                }
+            });
+        }
+
+        if (child.stderr) {
+            child.stderr.on('data', (data) => {
+                const text = data.toString();
+                stderr += text;
+                if (streamOutput) {
+                    process.stderr.write(text);
+                }
+            });
+        }
+
+        child.on('close', (code) => {
+            const exitCode = code ?? 1;
+            resolve({
+                success: exitCode === 0,
+                code: exitCode,
+                stdout,
+                stderr,
+                message: stderr || stdout,
+                streamed: streamOutput
+            });
+        });
+
+        child.on('error', (error) => {
+            resolve({
+                success: false,
+                code: 1,
+                stdout,
+                stderr,
+                message: error.message,
+                streamed: streamOutput
+            });
+        });
+    });
+}
+
+function detectPermissionError(text) {
+    if (!text) return false;
+    const lowered = text.toLowerCase();
+    return lowered.includes('permission denied') ||
+        lowered.includes('access denied') ||
+        lowered.includes('authentication is required');
+}
+
+async function listServices(options = {}) {
+    const args = ['list-units', '--type=service', '--no-pager'];
+    if (options.all) {
+        args.push('--all');
+    }
+    if (options.state) {
+        args.push(`--state=${options.state}`);
+    }
+    if (options.pattern) {
+        args.push(`--pattern=${options.pattern}`);
+    }
+    if (options.forInteractive) {
+        args.push('--no-legend');
+    }
+    const result = await runCommand('systemctl', args);
+    if (options.forInteractive && result.success) {
+        const lines = result.stdout.split('\n').filter(line => line.trim());
+        const services = lines.map(line => {
+            const parts = line.split(/\s+/);
+            const unit = parts[0];
+            const load = parts[1];
+            const active = parts[2];
+            const sub = parts[3];
+            const description = parts.slice(4).join(' ');
+            return {unit, load, active, sub, description};
+        });
+        return {result, services};
+    }
+    return {result, services: []};
+}
+
+function statusService(service) {
+    return runCommand('systemctl', ['status', service, '--no-pager'], {streamOutput: true});
+}
+
+function startService(service) {
+    return runCommand('systemctl', ['start', service]);
+}
+
+function stopService(service) {
+    return runCommand('systemctl', ['stop', service]);
+}
+
+function restartService(service) {
+    return runCommand('systemctl', ['restart', service]);
+}
+
+function enableService(service) {
+    return runCommand('systemctl', ['enable', service]);
+}
+
+function disableService(service) {
+    return runCommand('systemctl', ['disable', service]);
+}
+
+function showLogs(service, options = {}) {
+    const args = ['-u', service, '--no-pager'];
+    if (options.lines) {
+        args.push('-n', String(options.lines));
+    }
+    if (options.follow) {
+        args.push('-f');
+    }
+    if (options.since) {
+        args.push('--since', options.since);
+    }
+    return runCommand('journalctl', args, {streamOutput: !!options.follow});
+}
+
+module.exports = {
+    SAFE_SERVICE_RE,
+    validateServiceName,
+    isSystemctlAvailable,
+    checkEnvironment,
+    buildResult,
+    detectPermissionError,
+    listServices,
+    statusService,
+    startService,
+    stopService,
+    restartService,
+    enableService,
+    disableService,
+    showLogs
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@holic512/plugin-systemd",
+  "version": "1.0.1",
+  "description": "Interactive systemd service management tool",
+  "main": "lib/systemd.js",
+  "bin": {
+    "systemd": "bin/systemd.js"
+  },
+  "slothtool": {
+    "interactive": true,
+    "interactiveFlag": "-i"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "slothtool",
+    "plugin",
+    "systemd",
+    "service",
+    "journalctl"
+  ],
+  "author": "holic512",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/holic512/SlothTool.git",
+    "directory": "packages/plugin-systemd"
+  },
+  "homepage": "https://github.com/holic512/SlothTool#readme",
+  "bugs": {
+    "url": "https://github.com/holic512/SlothTool/issues"
+  },
+  "os": [
+    "linux"
+  ],
+  "license": "ISC",
+  "dependencies": {
+    "prompts": "^2.4.2"
+  }
+}