linux-autoruns 2.9.1__py3-none-any.whl

linux_autoruns/__init__.py

@@ -0,0 +1,3 @@
+def main():
+    from .main import main as launch
+    launch()

linux_autoruns/gui/detail_dialog.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFont
+from PySide6.QtWidgets import (QApplication, QDialog, QGroupBox, QLabel,
+                               QPlainTextEdit, QPushButton, QScrollArea,
+                               QVBoxLayout, QWidget)
+
+from ..models import AutostartEntry
+from .theme import DARK_THEME_QSS
+
+
+class DetailDialog(QDialog):
+    def __init__(self, entry: AutostartEntry, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(f"Entry Detail: {entry.name}")
+        self.setMinimumSize(550, 500)
+        self.setMaximumSize(700, 900)
+        self.setStyleSheet(DARK_THEME_QSS)
+        scroll = QScrollArea(self)
+        scroll.setWidgetResizable(True)
+        container = QWidget()
+        layout = QVBoxLayout(container)
+        layout.setSpacing(8)
+        layout.setContentsMargins(12, 12, 12, 12)
+        self._add_section(layout, "Genel Bilgiler", self._general_fields(entry))
+        if entry.command:
+            self._add_section(layout, "Komut", {"Command": entry.command})
+        if entry.exec_args:
+            self._add_section(layout, "Argümanlar", {"Args": " ".join(entry.exec_args)})
+        if entry.tags:
+            self._add_section(layout, "Etiketler", {"Tags": ", ".join(entry.tags)})
+        if entry.details:
+            detail_items = {}
+            for k, v in entry.details.items():
+                if isinstance(v, list):
+                    detail_items[k] = ", ".join(str(i) for i in v)
+                else:
+                    detail_items[k] = str(v)
+            self._add_section(layout, "Detaylar", detail_items)
+        if entry.file_path:
+            content = self._read_raw_content(entry.file_path)
+            if content:
+                group = QGroupBox("Ham İçerik")
+                vbox = QVBoxLayout()
+                text_edit = QPlainTextEdit()
+                text_edit.setPlainText(content)
+                text_edit.setReadOnly(True)
+                text_edit.setMaximumHeight(300)
+                mono = QFont("monospace")
+                mono.setStyleHint(QFont.Monospace)
+                text_edit.setFont(mono)
+                copy_btn = QPushButton("Kopyala")
+                copy_btn.clicked.connect(lambda: QApplication.clipboard().setText(content))
+                btn_row = QVBoxLayout()
+                btn_row.addWidget(copy_btn)
+                btn_row.addStretch()
+                hbox = QVBoxLayout()
+                hbox.addWidget(text_edit)
+                hbox.addLayout(btn_row)
+                vbox.addLayout(hbox)
+                group.setLayout(vbox)
+                layout.addWidget(group)
+        layout.addStretch()
+        scroll.setWidget(container)
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.addWidget(scroll)
+
+    def _general_fields(self, entry: AutostartEntry) -> dict:
+        fields = {}
+        fields["Kategori"] = entry.category
+        fields["Dosya"] = entry.file_path
+        fields["Ad"] = entry.name
+        fields["Durum"] = "+ Aktif" if entry.enabled else "- Pasif"
+        if entry.user:
+            fields["Kullanıcı"] = entry.user
+        fields["Scope"] = entry.scope
+        if entry.description:
+            fields["Tanım"] = entry.description
+        if entry.comment:
+            fields["Not"] = entry.comment
+        if entry.last_modified:
+            fields["Değişim"] = entry.last_modified
+        if entry.file_size is not None:
+            size = entry.file_size
+            if size > 1024:
+                fields["Boyut"] = f"{size / 1024:.1f} KB"
+            else:
+                fields["Boyut"] = f"{size} B"
+        if entry.file_permissions:
+            fields["İzinler"] = entry.file_permissions
+        if entry.owner:
+            fields["Sahip"] = entry.owner
+        return fields
+
+    def _add_section(self, layout: QVBoxLayout, title: str, items: dict):
+        group = QGroupBox(title)
+        vbox = QVBoxLayout()
+        for key, value in items.items():
+            lbl_key = QLabel(f"{key}:")
+            lbl_val = QLabel(str(value))
+            lbl_val.setWordWrap(True)
+            lbl_val.setTextInteractionFlags(Qt.TextSelectableByMouse)
+            btn = QPushButton("Kopyala")
+            btn.clicked.connect(lambda checked, v=str(value): QApplication.clipboard().setText(v))
+            top_row = QVBoxLayout()
+            top_row.addWidget(lbl_key)
+            top_row.addWidget(btn)
+            h = QVBoxLayout()
+            h.addLayout(top_row)
+            h.addWidget(lbl_val)
+            vbox.addLayout(h)
+        group.setLayout(vbox)
+        layout.addWidget(group)
+
+    def _read_raw_content(self, path: str) -> str | None:
+        try:
+            return Path(path).read_text(encoding="utf-8", errors="replace")
+        except (OSError, PermissionError):
+            return None

linux_autoruns/gui/main_window.py

@@ -0,0 +1,342 @@
+from __future__ import annotations
+
+import csv
+import io
+import json
+import os
+import subprocess
+from datetime import datetime, timezone
+
+from PySide6.QtCore import QSettings, Qt, QTimer
+from PySide6.QtGui import QColor, QKeySequence, QShortcut
+from PySide6.QtWidgets import (QApplication, QCheckBox, QFileDialog,
+                               QHBoxLayout, QHeaderView, QLabel, QLineEdit,
+                               QMainWindow, QMenu, QMessageBox, QProgressBar,
+                               QPushButton, QSplitter, QStatusBar, QTableView,
+                               QTreeWidget, QTreeWidgetItem, QVBoxLayout,
+                               QWidget)
+
+from ..models import AutostartEntry
+from ..scanners import SCANNERS
+from .detail_dialog import DetailDialog
+from .models import EntryFilterProxy, EntryTableModel
+from .theme import CATPPUCCIN_MOCHA, DARK_THEME_QSS
+from .worker import ScanWorker
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self._settings = QSettings("linux-autoruns", "linux-autoruns")
+        self.setWindowTitle("Linux Autoruns")
+        self.setMinimumSize(1000, 600)
+        self._restore_geometry()
+        self._all_entries: list[AutostartEntry] = []
+        self._worker: ScanWorker | None = None
+        self._edit_mode = False
+        self._selected_category: str | None = None
+        self._error_count = 0
+        self._model = EntryTableModel(self)
+        self._proxy = EntryFilterProxy(self)
+        self._proxy.setSourceModel(self._model)
+        self._search_debounce = QTimer()
+        self._search_debounce.setSingleShot(True)
+        self._search_debounce.setInterval(150)
+        self._search_debounce.timeout.connect(self._apply_filters)
+        self._setup_ui()
+        self._apply_theme()
+        self._start_scan()
+
+    def _restore_geometry(self):
+        geom = self._settings.value("geometry")
+        if geom:
+            self.restoreGeometry(geom)
+        else:
+            self.resize(1200, 700)
+
+    def closeEvent(self, event):
+        self._settings.setValue("geometry", self.saveGeometry())
+        super().closeEvent(event)
+
+    def _setup_ui(self):
+        central = QWidget()
+        self.setCentralWidget(central)
+        main_layout = QVBoxLayout(central)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.setSpacing(0)
+        toolbar = self._create_toolbar()
+        main_layout.addLayout(toolbar)
+        self._progress_bar = QProgressBar()
+        self._progress_bar.setMaximumHeight(4)
+        self._progress_bar.setTextVisible(False)
+        self._progress_bar.setValue(0)
+        main_layout.addWidget(self._progress_bar)
+        splitter = QSplitter(Qt.Horizontal)
+        self._tree = QTreeWidget()
+        self._tree.setHeaderLabel("Kategoriler")
+        self._tree.setMinimumWidth(200)
+        self._tree.setMaximumWidth(350)
+        self._tree.setSortingEnabled(True)
+        self._tree.sortByColumn(0, Qt.AscendingOrder)
+        self._tree.itemClicked.connect(self._on_category_clicked)
+        splitter.addWidget(self._tree)
+        self._table = QTableView()
+        self._table.setModel(self._proxy)
+        self._table.setSelectionBehavior(QTableView.SelectRows)
+        self._table.setSelectionMode(QTableView.SingleSelection)
+        self._table.setAlternatingRowColors(True)
+        self._table.setSortingEnabled(True)
+        self._table.verticalHeader().setVisible(False)
+        self._table.setContextMenuPolicy(Qt.CustomContextMenu)
+        self._table.customContextMenuRequested.connect(self._on_context_menu)
+        self._table.doubleClicked.connect(self._on_inspect)
+        header = self._table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
+        header.setSectionResizeMode(1, QHeaderView.Stretch)
+        header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
+        header.setSectionResizeMode(3, QHeaderView.ResizeToContents)
+        header.setSectionResizeMode(4, QHeaderView.Stretch)
+        header.setSectionResizeMode(5, QHeaderView.ResizeToContents)
+        splitter.addWidget(self._table)
+        splitter.setStretchFactor(0, 0)
+        splitter.setStretchFactor(1, 1)
+        main_layout.addWidget(splitter)
+        self._status_bar = QStatusBar()
+        self.setStatusBar(self._status_bar)
+        self._status_bar.showMessage("Tarama başlatılmadı")
+        quit_shortcut = QShortcut(QKeySequence("Ctrl+C"), self)
+        quit_shortcut.activated.connect(self.close)
+
+    def _create_toolbar(self) -> QHBoxLayout:
+        toolbar = QHBoxLayout()
+        toolbar.setContentsMargins(8, 8, 8, 8)
+        toolbar.setSpacing(8)
+        lbl = QLabel("🔍")
+        lbl.setStyleSheet(f"color: {CATPPUCCIN_MOCHA['blue']}; font-size: 16px;")
+        toolbar.addWidget(lbl)
+        self._search = QLineEdit()
+        self._search.setPlaceholderText("Ara... (isim, komut, dosya)")
+        self._search.setFixedWidth(250)
+        self._search.textChanged.connect(self._on_search)
+        toolbar.addWidget(self._search)
+        self._enabled_only = QCheckBox("Sadece aktif")
+        self._enabled_only.stateChanged.connect(self._on_filter_changed)
+        toolbar.addWidget(self._enabled_only)
+        self._edit_mode_cb = QCheckBox("Düzenleme Modu")
+        self._edit_mode_cb.stateChanged.connect(self._on_edit_mode_changed)
+        toolbar.addWidget(self._edit_mode_cb)
+        toolbar.addStretch()
+        self._scan_btn = QPushButton("Scan")
+        self._scan_btn.clicked.connect(self._start_scan)
+        toolbar.addWidget(self._scan_btn)
+        self._export_json_btn = QPushButton("Export JSON")
+        self._export_json_btn.clicked.connect(self._export_json)
+        self._export_json_btn.setEnabled(False)
+        toolbar.addWidget(self._export_json_btn)
+        self._export_csv_btn = QPushButton("Export CSV")
+        self._export_csv_btn.clicked.connect(self._export_csv)
+        self._export_csv_btn.setEnabled(False)
+        toolbar.addWidget(self._export_csv_btn)
+        return toolbar
+
+    def _apply_theme(self):
+        self.setStyleSheet(DARK_THEME_QSS)
+
+    def _on_edit_mode_changed(self, state):
+        self._edit_mode = state == Qt.Checked.value
+
+    def _start_scan(self):
+        if self._worker and self._worker.isRunning():
+            self._worker.cancel()
+            self._scan_btn.setText("Scan")
+            self._progress_bar.setValue(0)
+            return
+        self._all_entries.clear()
+        self._selected_category = None
+        self._error_count = 0
+        self._model.set_entries([])
+        self._tree.clear()
+        self._scan_btn.setText("Durdur")
+        self._export_json_btn.setEnabled(False)
+        self._export_csv_btn.setEnabled(False)
+        self._progress_bar.setValue(0)
+        self._worker = ScanWorker(SCANNERS, self)
+        self._worker.progress.connect(self._on_progress)
+        self._worker.entry_found.connect(self._on_entry_found)
+        self._worker.scan_complete.connect(self._on_scan_complete)
+        self._worker.error.connect(self._on_error)
+        self._worker.start()
+
+    def _on_progress(self, category: str, percent: int):
+        self._progress_bar.setValue(percent)
+        self._status_bar.showMessage(f"Taranıyor: {category} ({percent}%)")
+
+    def _on_entry_found(self, entry: AutostartEntry):
+        self._all_entries.append(entry)
+        self._model.add_entry(entry)
+
+    def _on_scan_complete(self, entries: list):
+        self._all_entries = entries
+        self._model.set_entries(entries)
+        self._scan_btn.setText("Scan")
+        self._export_json_btn.setEnabled(True)
+        self._export_csv_btn.setEnabled(True)
+        self._progress_bar.setValue(100)
+        total = len(entries)
+        enabled = sum(1 for e in entries if e.enabled)
+        cats = len(set(e.category for e in entries))
+        msg = f"Tamamlandı: {total} entry ({enabled} aktif) - {cats} kategori"
+        if self._error_count:
+            msg += f" ({self._error_count} hata)"
+        self._status_bar.showMessage(msg)
+        has_user = any(e.user for e in entries)
+        self._table.setColumnHidden(3, not has_user)
+        self._rebuild_tree()
+
+    def _on_error(self, msg: str):
+        self._error_count += 1
+        self._status_bar.showMessage(f"Hata ({self._error_count}): {msg[:80]}")
+
+    def _rebuild_tree(self):
+        self._tree.clear()
+        root = QTreeWidgetItem(self._tree)
+        root.setText(0, f"Tümü ({len(self._all_entries)})")
+        root.setData(0, Qt.UserRole, len(self._all_entries))
+        counts: dict[str, int] = {}
+        for entry in self._all_entries:
+            counts[entry.category] = counts.get(entry.category, 0) + 1
+        for cat in sorted(counts):
+            item = QTreeWidgetItem(self._tree)
+            item.setText(0, f"{cat} ({counts[cat]})")
+            item.setData(0, Qt.UserRole, counts[cat])
+
+    def _on_category_clicked(self, item: QTreeWidgetItem, column: int):
+        text = item.text(0)
+        if text.startswith("Tümü"):
+            self._selected_category = None
+        else:
+            category = text.rsplit(" (", 1)[0] if " (" in text else text
+            if self._selected_category == category:
+                self._selected_category = None
+            else:
+                self._selected_category = category
+        self._apply_filters()
+
+    def _apply_filters(self):
+        self._proxy.set_category_filter(self._selected_category)
+        self._proxy.set_enabled_only(self._enabled_only.isChecked())
+        self._proxy.set_search_text(self._search.text())
+        has_user = any(e.user for e in self._all_entries)
+        self._table.setColumnHidden(3, not has_user)
+
+    def _on_search(self, text: str):
+        self._search_debounce.start()
+
+    def _on_filter_changed(self):
+        self._apply_filters()
+
+    def _on_context_menu(self, pos):
+        index = self._table.indexAt(pos)
+        if not index.isValid():
+            return
+        source_index = self._proxy.mapToSource(index)
+        entry: AutostartEntry | None = self._model.entry_at(source_index.row())
+        if not entry:
+            return
+        menu = QMenu(self)
+        copy_name = menu.addAction("Copy Name")
+        copy_path = menu.addAction("Copy Path")
+        copy_command = menu.addAction("Copy Command")
+        copy_json = menu.addAction("Copy Full Details (JSON)")
+        menu.addSeparator()
+        inspect_action = menu.addAction("Inspect Details...")
+        menu.addSeparator()
+        open_location = menu.addAction("Open File Location")
+        if self._edit_mode:
+            menu.addSeparator()
+            toggle_action = menu.addAction(
+                "Disable" if entry.enabled else "Enable"
+            )
+        else:
+            toggle_action = None
+        action = menu.exec(self._table.mapToGlobal(pos))
+        if action == copy_name:
+            QApplication.clipboard().setText(entry.name)
+        elif action == copy_path:
+            QApplication.clipboard().setText(entry.file_path)
+        elif action == copy_command:
+            QApplication.clipboard().setText(entry.command or "")
+        elif action == copy_json:
+            QApplication.clipboard().setText(json.dumps(entry.to_dict(), indent=2, ensure_ascii=False))
+        elif action == inspect_action:
+            self._open_detail(entry)
+        elif action == open_location:
+            dirpath = os.path.dirname(entry.file_path)
+            if os.path.isdir(dirpath):
+                subprocess.Popen(["xdg-open", dirpath])
+        elif toggle_action and action == toggle_action:
+            entry.enabled = not entry.enabled
+            self._model.set_entries(list(self._model.get_all_entries()))
+
+    def _on_inspect(self, index):
+        source_index = self._proxy.mapToSource(index)
+        entry: AutostartEntry | None = self._model.entry_at(source_index.row())
+        if entry:
+            self._open_detail(entry)
+
+    def _open_detail(self, entry: AutostartEntry):
+        dialog = DetailDialog(entry, self)
+        dialog.exec()
+
+    def _export_json(self):
+        path, _ = QFileDialog.getSaveFileName(
+            self, "JSON olarak kaydet", "autoruns_export.json", "JSON (*.json)"
+        )
+        if not path:
+            return
+        data = {
+            "scan_time": datetime.now(tz=timezone.utc).isoformat(),
+            "hostname": os.uname().nodename,
+            "entries": [e.to_dict() for e in self._all_entries],
+            "summary": {
+                "total": len(self._all_entries),
+                "enabled": sum(1 for e in self._all_entries if e.enabled),
+                "by_category": {},
+            },
+        }
+        for entry in self._all_entries:
+            cat = entry.category
+            data["summary"]["by_category"][cat] = data["summary"]["by_category"].get(cat, 0) + 1
+        try:
+            with open(path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+            self._status_bar.showMessage(f"Dışa aktarıldı: {path}")
+        except OSError as e:
+            QMessageBox.critical(self, "Hata", f"JSON kaydedilemedi: {e}")
+
+    def _export_csv(self):
+        path, _ = QFileDialog.getSaveFileName(
+            self, "CSV olarak kaydet", "autoruns_export.csv", "CSV (*.csv)"
+        )
+        if not path:
+            return
+        try:
+            with open(path, "w", encoding="utf-8", newline="") as f:
+                writer = csv.writer(f)
+                writer.writerow(["Enabled", "Name", "Category", "User", "Description",
+                                 "Command", "Path", "Modified", "Tags"])
+                for entry in self._all_entries:
+                    writer.writerow([
+                        "+" if entry.enabled else "-",
+                        entry.name,
+                        entry.category,
+                        entry.user or "",
+                        entry.description or "",
+                        entry.command or "",
+                        entry.file_path,
+                        entry.last_modified or "",
+                        ",".join(entry.tags),
+                    ])
+            self._status_bar.showMessage(f"Dışa aktarıldı: {path}")
+        except OSError as e:
+            QMessageBox.critical(self, "Hata", f"CSV kaydedilemedi: {e}")

linux_autoruns/gui/models.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from PySide6.QtCore import (QAbstractTableModel, QModelIndex,
+                            QRegularExpression, QSortFilterProxyModel, Qt)
+from PySide6.QtGui import QColor
+
+from ..models import AutostartEntry
+from .theme import CATPPUCCIN_MOCHA
+
+
+class EntryTableModel(QAbstractTableModel):
+    HEADERS = ["+", "Name", "Category", "User", "Description", "Modified"]
+    _FIELD_MAP = {
+        1: "name",
+        2: "category",
+        3: "user",
+        4: "description",
+        5: "last_modified",
+    }
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._entries: list[AutostartEntry] = []
+
+    def rowCount(self, parent=QModelIndex()) -> int:
+        return len(self._entries)
+
+    def columnCount(self, parent=QModelIndex()) -> int:
+        return len(self.HEADERS)
+
+    def data(self, index: QModelIndex, role: int = Qt.DisplayRole):
+        if not index.isValid():
+            return None
+        entry = self._entries[index.row()]
+        col = index.column()
+        if role == Qt.DisplayRole:
+            if col == 0:
+                return "+" if entry.enabled else "-"
+            field = self._FIELD_MAP.get(col)
+            if field:
+                val = getattr(entry, field, None)
+                return str(val) if val is not None else ""
+            return ""
+        if role == Qt.TextAlignmentRole:
+            if col == 0:
+                return int(Qt.AlignCenter)
+            return int(Qt.AlignLeft | Qt.AlignVCenter)
+        if role == Qt.ForegroundRole:
+            if col == 0:
+                color = CATPPUCCIN_MOCHA["green"] if entry.enabled else CATPPUCCIN_MOCHA["red"]
+                return QColor(color)
+            if col == 1:
+                return QColor(CATPPUCCIN_MOCHA["blue"])
+        if role == Qt.UserRole:
+            return entry
+        return None
+
+    def headerData(self, section: int, orientation, role: int = Qt.DisplayRole):
+        if role == Qt.DisplayRole and orientation == Qt.Horizontal:
+            return self.HEADERS[section]
+        return None
+
+    def set_entries(self, entries: list[AutostartEntry]):
+        self.beginResetModel()
+        self._entries = entries
+        self.endResetModel()
+
+    def add_entry(self, entry: AutostartEntry):
+        row = len(self._entries)
+        self.beginInsertRows(QModelIndex(), row, row)
+        self._entries.append(entry)
+        self.endInsertRows()
+
+    def entry_at(self, row: int) -> AutostartEntry | None:
+        if 0 <= row < len(self._entries):
+            return self._entries[row]
+        return None
+
+    def get_all_entries(self) -> list[AutostartEntry]:
+        return list(self._entries)
+
+
+class EntryFilterProxy(QSortFilterProxyModel):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._filter_category: str | None = None
+        self._filter_enabled_only: bool = False
+
+    def set_category_filter(self, category: str | None):
+        self._filter_category = category
+        self.invalidateFilter()
+
+    def set_enabled_only(self, enabled: bool):
+        self._filter_enabled_only = enabled
+        self.invalidateFilter()
+
+    def set_search_text(self, text: str):
+        self.setFilterRegularExpression(QRegularExpression(text, QRegularExpression.CaseInsensitiveOption))
+
+    def filterAcceptsRow(self, source_row: int, source_parent: QModelIndex) -> bool:
+        model = self.sourceModel()
+        if not model:
+            return True
+        index = model.index(source_row, 0, source_parent)
+        entry: AutostartEntry | None = model.data(index, Qt.UserRole)
+        if not entry:
+            return True
+        if self._filter_category and entry.category != self._filter_category:
+            return False
+        if self._filter_enabled_only and not entry.enabled:
+            return False
+        pattern = self.filterRegularExpression().pattern()
+        if pattern:
+            searchable = f"{entry.name} {entry.description or ''} {entry.command or ''} {entry.file_path}".lower()
+            if pattern.lower() not in searchable:
+                return False
+        return True