-
-8BE9FD?style=for-the-badge&color=8BE9FD&logoColor=282A36){kind=icon}
@@ -53,11 +54,11 @@ ATK builds on these open-source projects. Go star them:
- **[PixelFlasher](https://github.com/badabing2005/PixelFlasher)** (badabing2005): Pixel flash-sequence reference.
- **[Wails](https://wails.io)**: Go and Web application framework.
- **[Lucide](https://lucide.dev)**: icon set.
-- **[adb-gui-kit](https://github.com/Drenzzz/adb-gui-kit)** (Drenzzz): early base ADB GUI groundwork this project started from.
+- **[adb-gui-kit](https://github.com/Drenzzz/adb-gui-kit)** (Drenzzz): early ADB GUI groundwork this project started from.
### 🗺️ See the Live System Map in action
-Real-time demos of the map engine showing live device telemetry: You may have seen this viral on X, it is getting around ! Yes it came from here, This is the original implementation.
+Real-time demos of the map engine showing live device telemetry:
**▶️ Demo 1**
@@ -105,6 +106,10 @@ https://github.com/user-attachments/assets/47a3590a-11f8-416f-b972-0e89d933419c
+> [!NOTE]
+> The four demos above are hosted on GitHub's attachment CDN, so they play inline
+> here. The copies in `screenshot/*.mp4` are no longer needed for playback and you
+> can delete them to keep the repo small.
---
@@ -326,6 +331,11 @@ wails build -tags webkit2_41
**Dev mode (hot reload):** `wails dev -tags webkit2_41`
+> [!NOTE]
+> **About the Live System Map.** The map engine is the one closed-source part of
+> ATK, and its sources are not in this public repo. The **pre-built releases ship
+> the complete app**, map included, and that is the supported way to run ATK with
+> the map. Building from this repo gives you the full toolkit minus the map module.
**Package as .deb**
```bash
diff --git a/backend_gsi.go b/backend_gsi.go
new file mode 100644
index 0000000..59cce14
--- /dev/null
+++ b/backend_gsi.go
@@ -0,0 +1,302 @@
+package main
+
+// GSI Loader backend — two ways to run a Generic System Image on the device:
+//
+// 1. DSU (temporary): install a GSI as a guest OS via Dynamic System Updates.
+// Non-destructive, no unlock, no wipe. Follows the exact adb flow from the
+// Android DSU docs (see dsi_info.txt): gzip the raw image, push it to
+// /storage/emulated/0/Download, then fire the START_INSTALL intent at
+// com.android.dynsystem. Managed afterwards with gsi_tool.
+//
+// 2. GSI flash (permanent): fastboot-flash a GSI to the system partition.
+// Destructive; DANGER-gated (App Lock). Sequences the documented fastboot
+// steps with a dry-run preview.
+
+import (
+ "compress/gzip"
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+ "strconv"
+ "strings"
+ "time"
+)
+
+const dsuDefaultUserdata int64 = 8589934592 // 8 GiB
+const dsuRemoteDir = "/storage/emulated/0/Download"
+
+// GsiCompat reports whether the device can run a GSI and which one.
+type GsiCompat struct {
+ TrebleEnabled bool `json:"trebleEnabled"`
+ Abi string `json:"abi"` // ro.product.cpu.abi, e.g. arm64-v8a
+ GsiArch string `json:"gsiArch"` // derived: arm64 / x86_64 / arm / x86
+ VndkIsolated bool `json:"vndkIsolated"` // true => any newer GSI ok; false => same-version only
+ AndroidRelease string `json:"androidRelease"`
+ Sdk string `json:"sdk"`
+ DsuStatus string `json:"dsuStatus"`
+}
+
+// GsiCompat runs the documented compatibility checks (getprop + ld.config).
+func (a *App) GsiCompat() (GsiCompat, error) {
+ c := GsiCompat{}
+ if v, err := a.runAdbShell("getprop", "ro.treble.enabled"); err == nil {
+ c.TrebleEnabled = strings.TrimSpace(v) == "true"
+ }
+ if v, err := a.runAdbShell("getprop", "ro.product.cpu.abi"); err == nil {
+ c.Abi = strings.TrimSpace(v)
+ c.GsiArch = gsiArchForAbi(c.Abi)
+ }
+ if v, err := a.runAdbShell("getprop", "ro.build.version.release"); err == nil {
+ c.AndroidRelease = strings.TrimSpace(v)
+ }
+ if v, err := a.runAdbShell("getprop", "ro.build.version.sdk"); err == nil {
+ c.Sdk = strings.TrimSpace(v)
+ }
+ if v, err := a.runAdbShell("cat", "/system/etc/ld.config.version_identifier.txt"); err == nil {
+ c.VndkIsolated = vendorNamespaceIsolated(v)
+ }
+ if v, err := a.runAdbShell("gsi_tool", "status"); err == nil {
+ c.DsuStatus = strings.TrimSpace(v)
+ }
+ return c, nil
+}
+
+func gsiArchForAbi(abi string) string {
+ switch {
+ case strings.HasPrefix(abi, "arm64"):
+ return "arm64"
+ case strings.HasPrefix(abi, "x86_64"):
+ return "x86_64"
+ case strings.HasPrefix(abi, "x86"):
+ return "x86"
+ case strings.HasPrefix(abi, "arm"):
+ return "arm"
+ }
+ return abi
+}
+
+// vendorNamespaceIsolated parses ld.config for the [vendor] section and reports
+// whether namespace.default.isolated is true (full VNDK => any newer GSI works).
+func vendorNamespaceIsolated(ld string) bool {
+ inVendor := false
+ for _, line := range strings.Split(ld, "\n") {
+ t := strings.TrimSpace(line)
+ if strings.HasPrefix(t, "[") && strings.HasSuffix(t, "]") {
+ inVendor = t == "[vendor]"
+ continue
+ }
+ if inVendor && strings.Contains(t, "namespace.default.isolated") {
+ return strings.Contains(strings.ToLower(t), "true")
+ }
+ }
+ return false
+}
+
+// --- gsi_tool management ---------------------------------------------------
+
+func (a *App) GsiDsuStatus() (string, error) { return a.runAdbShell("gsi_tool", "status") }
+func (a *App) DsuEnable() (string, error) { return a.runAdbShell("gsi_tool", "enable") }
+func (a *App) DsuDisable() (string, error) { return a.runAdbShell("gsi_tool", "disable") }
+func (a *App) DsuWipe() (string, error) { return a.runAdbShell("gsi_tool", "wipe") }
+
+// --- DSU install -----------------------------------------------------------
+
+// InstallDsu prepares and installs a temporary DSU from a GSI image, then fires
+// the DynamicSystemInstallationService intent. `systemSize` is the UNCOMPRESSED
+// raw image size in bytes (auto = file size for a raw .img; REQUIRED for a .gz).
+// `userdataSize` defaults to 8 GiB when <= 0.
+func (a *App) InstallDsu(imagePath string, systemSize int64, userdataSize int64) (string, error) {
+ imagePath = strings.TrimSpace(imagePath)
+ if imagePath == "" {
+ return "", fmt.Errorf("no GSI image selected")
+ }
+ info, err := os.Stat(imagePath)
+ if err != nil || info.IsDir() {
+ return "", fmt.Errorf("image not found: %s", imagePath)
+ }
+ if isSparseImage(imagePath) {
+ return "", fmt.Errorf("this looks like a SPARSE image — DSU needs an unsparsed raw image. Convert first:\n simg2img system.img system_raw.img\nthen select the raw .img (or a .gz you made from it).")
+ }
+
+ if userdataSize <= 0 {
+ userdataSize = dsuDefaultUserdata
+ }
+
+ var gzPath string
+ var sysSize int64
+ isGz := strings.HasSuffix(strings.ToLower(imagePath), ".gz")
+ if isGz {
+ gzPath = imagePath
+ if systemSize <= 0 {
+ return "", fmt.Errorf("for a .gz image, provide the uncompressed system image size (bytes) — DSU needs KEY_SYSTEM_SIZE")
+ }
+ sysSize = systemSize
+ } else {
+ // Raw image: size is exact; gzip it host-side as the docs require.
+ sysSize = info.Size()
+ if systemSize > 0 {
+ sysSize = systemSize
+ }
+ gzPath = filepath.Join(os.TempDir(), "atk-dsu.gz")
+ if err := gzipFile(imagePath, gzPath); err != nil {
+ return "", fmt.Errorf("failed to gzip image: %w", err)
+ }
+ defer os.Remove(gzPath)
+ }
+
+ // Push the gzipped image to the device (progress via transfer:* events).
+ if _, err := a.PushWithProgress(gzPath, dsuRemoteDir); err != nil {
+ return "", err
+ }
+ remote := dsuRemoteDir + "/" + filepath.Base(gzPath)
+
+ // Fire the DSU install intent — verbatim from the Android docs.
+ out, err := a.runAdbShell(
+ "am", "start-activity",
+ "-n", "com.android.dynsystem/com.android.dynsystem.VerificationActivity",
+ "-a", "android.os.image.action.START_INSTALL",
+ "-d", "file://"+remote,
+ "--el", "KEY_SYSTEM_SIZE", strconv.FormatInt(sysSize, 10),
+ "--el", "KEY_USERDATA_SIZE", strconv.FormatInt(userdataSize, 10),
+ )
+ if err != nil {
+ return "", fmt.Errorf("failed to launch DSU install: %w (%s)", err, strings.TrimSpace(out))
+ }
+ return fmt.Sprintf("DSU install started (system %s, userdata %s). On the device, tap Restart in the notification to boot the GSI, or Discard to cancel. Use 'gsi_tool enable' for sticky mode.",
+ humanBytes(sysSize), humanBytes(userdataSize)), nil
+}
+
+// isSparseImage checks the Android sparse-image magic (0xed26ff3a, little-endian).
+func isSparseImage(path string) bool {
+ f, err := os.Open(path)
+ if err != nil {
+ return false
+ }
+ defer f.Close()
+ var b [4]byte
+ if _, err := io.ReadFull(f, b[:]); err != nil {
+ return false
+ }
+ return b[0] == 0x3a && b[1] == 0xff && b[2] == 0x26 && b[3] == 0xed
+}
+
+func gzipFile(src, dst string) error {
+ in, err := os.Open(src)
+ if err != nil {
+ return err
+ }
+ defer in.Close()
+ out, err := os.Create(dst)
+ if err != nil {
+ return err
+ }
+ defer out.Close()
+ zw := gzip.NewWriter(out)
+ if _, err := io.Copy(zw, in); err != nil {
+ zw.Close()
+ return err
+ }
+ return zw.Close()
+}
+
+func humanBytes(n int64) string {
+ const u = 1024
+ if n < u {
+ return fmt.Sprintf("%d B", n)
+ }
+ div, exp := int64(u), 0
+ for x := n / u; x >= u; x /= u {
+ div *= u
+ exp++
+ }
+ return fmt.Sprintf("%.1f %ciB", float64(n)/float64(div), "KMGTPE"[exp])
+}
+
+// --- GSI permanent flash (fastboot) ----------------------------------------
+
+type GsiFlashOpts struct {
+ Fastbootd bool `json:"fastbootd"` // reboot fastboot (fastbootd) first
+ WipeData bool `json:"wipeData"` // fastboot -w
+ DisableVerity bool `json:"disableVerity"` // flash vbmeta --disable-verification
+ DeleteProduct bool `json:"deleteProduct"` // free space: delete product_{entry.text}
+ {entry.hex}
diff --git a/frontend/src/components/views/ViewAppInspect.tsx b/frontend/src/components/views/ViewAppInspect.tsx
index 3bdb123..0edd004 100644
--- a/frontend/src/components/views/ViewAppInspect.tsx
+++ b/frontend/src/components/views/ViewAppInspect.tsx
@@ -1,8 +1,14 @@
-import { useState } from 'react'
-import { Search, Package, Shield, Activity, Server, Database, Cpu, FileCode, AlertTriangle } from 'lucide-react'
-import { InspectApp, CheckPinning, ListPackages } from '../../lib/wails'
+import { useState, useEffect } from 'react'
+import { Search, Package, Shield, ShieldCheck, Activity, Server, Database, Cpu, FileCode, AlertTriangle, Radar } from 'lucide-react'
+import { InspectApp, CheckPinning, ListPackages, ScanAppPrivacy } from '../../lib/wails'
import { notify } from '../../lib/notify'
-import type { AppInspection, PackageInfo } from '../../lib/types'
+import { CodeView } from '../../lib/syntax'
+import type { AppInspection, PackageInfo, PrivacyReport } from '../../lib/types'
+
+// Privacy grade -> tailwind text/badge colour.
+const GRADE_COLOR: Record
+ {!privacy && (
+ = {
+// Display safety includes 'unknown' for device packages not in the UAD database.
+type RowSafety = Safety | 'unknown'
+
+const UNCATEGORIZED = 'Uncategorized'
+
+const SAFETY_CONFIG: Record = {
safe: { label: 'Safe', cls: 'badge-green', icon: >(new Set())
const [search, setSearch] = useState('')
- const [safetyFilter, setSafety] = useState('all')
+ const [safetyFilter, setSafety] = useState('all')
const [mfrFilter, setMfrFilter] = useState('all')
const [openCats, setOpenCats] = useState>(new Set())
const [operating, setOperating] = useState(false)
const [stateFilter, setStateFilter] = useState<'installed' | 'enabled' | 'disabled' | 'notinstalled' | 'all'>('installed')
+ // pkg -> UAD database entry (with its category). Built once; first match wins.
+ const dbIndex = useMemo(() => {
+ const m = new Map()
+ for (const cat of DEBLOAT_CATEGORIES) {
+ for (const p of cat.packages) {
+ if (!m.has(p.pkg)) {
+ m.set(p.pkg, {
+ pkg: p.pkg, label: p.label, description: p.description, safety: p.safety,
+ category: cat.name, deps: p.deps, neededBy: p.neededBy,
+ isInstalled: false, isDisabled: false,
+ })
+ }
+ }
+ }
+ return m
+ }, [])
+
const loadInstalled = async () => {
setLoading(true)
setInstalled(new Set())
@@ -36,11 +85,9 @@ export default function ViewDebloater() {
const names = new Set((pkgs || []).map((p: PackageInfo) => p.packageName))
setInstalled(names)
setDisabled(new Set((pkgs || []).filter((p: PackageInfo) => !p.isEnabled).map((p: PackageInfo) => p.packageName)))
- // Auto-open categories that have installed packages
+ // Auto-open every category that has at least one package on the device.
const withInstalled = new Set()
- DEBLOAT_CATEGORIES.forEach(cat => {
- if (cat.packages.some(p => names.has(p.pkg))) withInstalled.add(cat.name)
- })
+ names.forEach(name => withInstalled.add(dbIndex.get(name)?.category ?? UNCATEGORIZED))
setOpenCats(withInstalled)
} catch (e: any) {
notify.error(e)
@@ -51,38 +98,62 @@ export default function ViewDebloater() {
useEffect(() => { loadInstalled() }, [])
- const manufacturers = useMemo(() => ['all', ...DEBLOAT_CATEGORIES.map(c => c.name)], [])
+ const manufacturers = useMemo(() => ['all', ...CATEGORY_ORDER], [])
+
+ // The unified row set: every device package (enriched or uncategorized), plus
+ // database-only packages so the "Not installed" / "All" filters can browse the
+ // full UAD catalogue.
+ const allRows = useMemo(() => {
+ const rows: Row[] = []
+ installed.forEach(name => {
+ const e = dbIndex.get(name)
+ if (e) {
+ rows.push({ ...e, isInstalled: true, isDisabled: disabled.has(name) })
+ } else {
+ rows.push({
+ pkg: name, label: shortLabel(name),
+ description: 'Not in the debloat database — likely an OEM, carrier, or region-specific package. Safety unknown; research before removing.',
+ safety: 'unknown', category: UNCATEGORIZED,
+ isInstalled: true, isDisabled: disabled.has(name),
+ })
+ }
+ })
+ dbIndex.forEach((e, pkg) => {
+ if (!installed.has(pkg)) rows.push({ ...e, isInstalled: false, isDisabled: false })
+ })
+ return rows
+ }, [installed, disabled, dbIndex])
const visibleCategories = useMemo(() => {
- return DEBLOAT_CATEGORIES
- .filter(cat => mfrFilter === 'all' || cat.name === mfrFilter)
- .map(cat => ({
- ...cat,
- packages: cat.packages.filter(p => {
- if (safetyFilter !== 'all' && p.safety !== safetyFilter) return false
- const inst = installed.has(p.pkg)
- const dis = disabled.has(p.pkg)
- switch (stateFilter) {
- case 'installed': if (!inst) return false; break
- case 'enabled': if (!inst || dis) return false; break
- case 'disabled': if (!dis) return false; break
- case 'notinstalled': if (inst) return false; break
- // 'all' → no state restriction
- }
- if (search) {
- const q = search.toLowerCase()
- return p.pkg.toLowerCase().includes(q) || p.label.toLowerCase().includes(q) || p.description.toLowerCase().includes(q)
- }
- return true
- })
- }))
- .filter(cat => cat.packages.length > 0)
- }, [search, safetyFilter, mfrFilter, installed, disabled, stateFilter])
+ const q = search.toLowerCase()
+ const byCat = new Map()
+ for (const r of allRows) {
+ if (mfrFilter !== 'all' && r.category !== mfrFilter) continue
+ if (safetyFilter !== 'all' && r.safety !== safetyFilter) continue
+ switch (stateFilter) {
+ case 'installed': if (!r.isInstalled) continue; break
+ case 'enabled': if (!r.isInstalled || r.isDisabled) continue; break
+ case 'disabled': if (!r.isDisabled) continue; break
+ case 'notinstalled': if (r.isInstalled) continue; break
+ // 'all' → no state restriction
+ }
+ if (q && !(r.pkg.toLowerCase().includes(q) || r.label.toLowerCase().includes(q) || r.description.toLowerCase().includes(q))) continue
+ if (!byCat.has(r.category)) byCat.set(r.category, [])
+ byCat.get(r.category)!.push(r)
+ }
+ return CATEGORY_ORDER
+ .filter(name => byCat.has(name))
+ .map(name => ({ name, packages: byCat.get(name)!.sort((a, b) => a.pkg.localeCompare(b.pkg)) }))
+ }, [allRows, search, safetyFilter, mfrFilter, stateFilter])
- const totalInstalled = useMemo(() =>
- DEBLOAT_CATEGORIES.reduce((n, cat) => n + cat.packages.filter(p => installed.has(p.pkg)).length, 0),
- [installed]
- )
+ // Device counts — mirror the Packages tab (deviceCount) and explain the gap.
+ const deviceCount = installed.size
+ const cataloguedCount = useMemo(() => {
+ let n = 0
+ installed.forEach(name => { if (dbIndex.has(name)) n++ })
+ return n
+ }, [installed, dbIndex])
+ const uncategorizedCount = deviceCount - cataloguedCount
const toggleCat = (name: string) => setOpenCats(prev => {
const next = new Set(prev)
@@ -97,11 +168,8 @@ export default function ViewDebloater() {
})
const selectAllVisible = () => {
- const selectable = visibleCategories
- .flatMap(c => c.packages)
- .filter(p => installed.has(p.pkg) && p.safety !== 'keep')
- .map(p => p.pkg)
- if (selected.size === selectable.length) {
+ const selectable = visibleCategories.flatMap(c => c.packages).map(p => p.pkg)
+ if (selected.size > 0 && selected.size >= selectable.length) {
setSelected(new Set())
} else {
setSelected(new Set(selectable))
@@ -134,24 +202,26 @@ export default function ViewDebloater() {
(null) // image filename being viewed
const [imgLoading, setImgLoading] = useState(false)
const [imgError, setImgError] = useState(false)
+ const [textView, setTextView] = useState<{ name: string; content: string } | null>(null)
+ const [textLoading, setTextLoading] = useState(false)
const progRef = useRef<{ label: string; t0: number } | null>(null)
// Remembered path per source + the last device dir (push destination default).
const remembered = useRef>({ device: '/sdcard', local: '' })
@@ -260,6 +263,32 @@ export default function ViewFiles() {
)
const openViewer = (name: string) => { setViewer(name); setImgLoading(true); setImgError(false) }
+ // Text preview: fetch the file's bytes via the same /__file route the image
+ // viewer uses (works for device and local), cap the size, and show highlighted.
+ const openText = async (name: string) => {
+ setTextView({ name, content: '' })
+ setTextLoading(true)
+ try {
+ const res = await fetch(fileURL(name))
+ let t = await res.text()
+ if (t.length > 400000) t = t.slice(0, 400000) + '\n\n… (truncated at 400 KB)'
+ setTextView({ name, content: t })
+ } catch (e: any) {
+ notify.error(e)
+ setTextView(null)
+ } finally {
+ setTextLoading(false)
+ }
+ }
+
+ // Esc closes the text viewer.
+ useEffect(() => {
+ if (!textView) return
+ const onKey = (e: KeyboardEvent) => { if (e.key === 'Escape') setTextView(null) }
+ window.addEventListener('keydown', onKey)
+ return () => window.removeEventListener('keydown', onKey)
+ }, [textView])
+
const stepViewer = useCallback((delta: number) => {
setViewer(cur => {
if (!cur) return cur
@@ -288,6 +317,7 @@ export default function ViewFiles() {
const open = (entry: FileEntry) => {
if (entry.type === 'Directory' || entry.type === 'Symlink') navigate(entry)
else if (isImage(entry.name)) openViewer(entry.name)
+ else if (isText(entry.name)) openText(entry.name)
}
const formatSize = (size: string) => {
@@ -602,6 +632,33 @@ export default function ViewFiles() {
)}
+ {/* Text viewer — highlighted preview for text/code/config files */}
+ {textView && (
+
diff --git a/frontend/src/components/views/ViewSettings.tsx b/frontend/src/components/views/ViewSettings.tsx
index b375368..7384047 100644
--- a/frontend/src/components/views/ViewSettings.tsx
+++ b/frontend/src/components/views/ViewSettings.tsx
@@ -4,6 +4,7 @@ import { GetBinaryInfo, SetAdbPath, SetFastbootPath, AppLockStatus, SetAppPasswo
import { notify } from '../../lib/notify'
import { refreshAppLockStatus } from '../../lib/applock'
import { applyTheme, getTheme, THEMES, type Theme } from '../../lib/theme'
+import { getCustomAccent, setCustomAccent, getCustomFont, setCustomFont, FONT_OPTIONS } from '../../lib/appearance'
import { getSidebarPosition, setSidebarPosition, SIDEBAR_POSITIONS, getSidebarLabels, setSidebarLabels, type SidebarPosition } from '../../lib/layout'
import { getRootTools, setRootTools, getHiddenViews, setHiddenViews, TOGGLEABLE_VIEWS, getMuteNoDevice, setMuteNoDevice } from '../../lib/featureflags'
import { resetDismissed } from '../../lib/dismissible'
@@ -18,7 +19,12 @@ export default function ViewSettings() {
const [sidebarLabels, setSidebarLabelsState] = useState
+
+ )}
+
+ {privacy && (
+ <>
+ {/* Score header */}
+ + Scans the app's bytecode for known tracker / analytics / ad SDKs and + cross-references dangerous permissions to compute a privacy score. + Pulls the APK off the device — may take a few seconds. +
+ +
+
+ )}
+
{activeTab === 'permissions' && (
+ {privacy.grade}
+
+
+
+
+ {/* Trackers */}
+
+ {privacy.score}
+ / 100 privacy score
+
+ + {privacy.trackerCount} tracker{privacy.trackerCount === 1 ? '' : 's'} ·{' '} + {privacy.dangerousPermissions.length} dangerous permission{privacy.dangerousPermissions.length === 1 ? '' : 's'} + {privacy.apkSize > 0 && <> · {(privacy.apkSize / 1048576).toFixed(1)} MB APK} +
+ {/* Score bar */} +
+
+
+ = 70 ? 'bg-accent-green' : privacy.score >= 40 ? 'bg-warn' : 'bg-danger'}`}
+ style={{ width: `${privacy.score}%` }}
+ />
+
+
+
+
+ {/* Dangerous permissions */}
+ Trackers ({privacy.trackerCount})
+ {privacy.trackerCount === 0 && ( +
+
+ {privacy.trackers.map(t => (
+
+
+
+ ))}
+
+
+
+ Dangerous permissions ({privacy.dangerousPermissions.length})
+ {privacy.dangerousPermissions.length === 0 && ( +None declared.
+ )} +
+ {privacy.dangerousPermissions.map(p => (
+
+
+
+ ))}
+ + Heuristic: matches known SDK package signatures in DEX bytecode (string + constants aren't decrypted, so obfuscated/encrypted trackers may be missed) + and counts declared Android "dangerous" permissions. A lower score means more + trackers / invasive permissions. +
+ + )} +
{result.permissions?.length === 0 && (
@@ -295,9 +416,11 @@ export default function ViewAppInspect() {
{showManifest ? 'Hide' : 'Show'} full package dump ({result.manifestDump?.split('\n').length} lines)
{showManifest && (
-
)}
diff --git a/frontend/src/components/views/ViewDebloater.tsx b/frontend/src/components/views/ViewDebloater.tsx
index b1d0578..69f2978 100644
--- a/frontend/src/components/views/ViewDebloater.tsx
+++ b/frontend/src/components/views/ViewDebloater.tsx
@@ -1,5 +1,5 @@
import { useState, useEffect, useMemo } from 'react'
-import { Shield, RefreshCw, Search, Trash2, PowerOff, Zap, RotateCcw, AlertTriangle, Check, X, ChevronDown, ChevronRight } from 'lucide-react'
+import { Shield, RefreshCw, Search, Trash2, PowerOff, Zap, RotateCcw, AlertTriangle, Check, X, HelpCircle, ChevronDown, ChevronRight } from 'lucide-react'
import { ListPackages, DisableMultiplePackages, UninstallMultiplePackages, UninstallAndDisableMultiplePackages, RestoreMultiplePackages } from '../../lib/wails'
import { ensureDangerUnlocked } from '../../lib/applock'
import { notify } from '../../lib/notify'
@@ -8,10 +8,42 @@ import { DEBLOAT_CATEGORIES } from '../../lib/debloat_db'
import type { Safety } from '../../lib/debloat_db'
import type { PackageInfo } from '../../lib/types'
-const SAFETY_CONFIG: Record
- {result.manifestDump}
-
+
- {(['all', 'safe', 'caution', 'keep'] as const).map(f => (
+ {(['all', 'safe', 'caution', 'keep', 'unknown'] as const).map(f => (
diff --git a/frontend/src/components/views/ViewFiles.tsx b/frontend/src/components/views/ViewFiles.tsx
index 9f2e19c..c71f30c 100644
--- a/frontend/src/components/views/ViewFiles.tsx
+++ b/frontend/src/components/views/ViewFiles.tsx
@@ -10,6 +10,7 @@ import {
SelectFileForPush, CancelOperation
} from '../../lib/wails'
import { notify } from '../../lib/notify'
+import { CodeView, detectLang } from '../../lib/syntax'
import type { FileEntry } from '../../lib/types'
// Wails runtime is injected on window['runtime'] (same access as ViewLogcat).
@@ -41,6 +42,8 @@ export default function ViewFiles() {
const [viewer, setViewer] = useState setTextView(null)}>
+
+ )}
+
{/* Status bar */}
+ {textView.name}
+
+
+ e.stopPropagation()}>
+
+
+ {textLoading ? (
+
+
+
+
+ ) : (
+
@@ -638,3 +695,7 @@ function formatEta(ms: number): string {
function isImage(name: string): boolean {
return /\.(png|jpe?g|gif|webp|bmp|ico)$/i.test(name)
}
+
+function isText(name: string): boolean {
+ return /\.(txt|xml|json|prop|conf|cfg|ini|env|log|sh|bash|rc|smali|java|kt|gradle|ya?ml|md|csv|html?|css|js|ts|toml|properties|list)$/i.test(name)
+}
diff --git a/frontend/src/components/views/ViewGsiLoader.tsx b/frontend/src/components/views/ViewGsiLoader.tsx
new file mode 100644
index 0000000..2964d84
--- /dev/null
+++ b/frontend/src/components/views/ViewGsiLoader.tsx
@@ -0,0 +1,256 @@
+import { useState, useEffect } from 'react'
+import { HardDriveDownload, Boxes, Zap, RefreshCw, Check, X, AlertTriangle, FileUp, Play, Power, Trash2, RotateCcw } from 'lucide-react'
+import {
+ GsiCompat, GsiDsuStatus, InstallDsu, DsuEnable, DsuDisable, DsuWipe,
+ FlashGsiSystem, SelectFileForFlash, Reboot,
+} from '../../lib/wails'
+import { notify } from '../../lib/notify'
+import { ensureDangerUnlocked } from '../../lib/applock'
+import type { GsiCompat as GsiCompatT } from '../../lib/types'
+
+const GIB = 1073741824
+
+export default function ViewGsiLoader() {
+ const [tab, setTab] = useState<'dsu' | 'flash'>('dsu')
+ const [compat, setCompat] = useState(null)
+ const [compatLoading, setCompatLoading] = useState(false)
+
+ // DSU
+ const [dsuImage, setDsuImage] = useState('')
+ const [systemSize, setSystemSize] = useState(0) // bytes; 0 = auto for raw .img
+ const [userdataGiB, setUserdataGiB] = useState(8)
+ const [installing, setInstalling] = useState(false)
+ const [pushPct, setPushPct] = useState(-1)
+ const [dsuStatus, setDsuStatus] = useState('')
+
+ // Flash
+ const [flashImage, setFlashImage] = useState('')
+ const [vbmeta, setVbmeta] = useState('')
+ const [opts, setOpts] = useState({ fastbootd: true, wipeData: true, disableVerity: false, deleteProduct: false, slot: '' })
+ const [dryRun, setDryRun] = useState('')
+ const [flashing, setFlashing] = useState(false)
+ const [flashOut, setFlashOut] = useState('')
+
+ const loadCompat = async () => {
+ setCompatLoading(true)
+ try { setCompat(await GsiCompat()) } catch (e: any) { notify.error(e) } finally { setCompatLoading(false) }
+ }
+ useEffect(() => { loadCompat() }, [])
+
+ // Push progress for the DSU image upload.
+ useEffect(() => {
+ const rt = () => (window as any)['runtime']
+ const onProg = (t: any) => { if (t?.label?.includes('atk-dsu') || t?.kind === 'push') setPushPct(t.percent) }
+ const onDone = () => setPushPct(-1)
+ const off1 = rt()?.EventsOn?.('transfer:progress', onProg)
+ const off2 = rt()?.EventsOn?.('transfer:done', onDone)
+ return () => { rt()?.EventsOff?.('transfer:progress'); rt()?.EventsOff?.('transfer:done'); off1?.(); off2?.() }
+ }, [])
+
+ const pickImage = async (setter: (p: string) => void) => {
+ try { const p = await SelectFileForFlash(); if (p) setter(p) } catch (e: any) { notify.error(e) }
+ }
+
+ const refreshStatus = async () => {
+ try { setDsuStatus((await GsiDsuStatus()) || '(no status)') } catch (e: any) { notify.error(e) }
+ }
+
+ const install = async () => {
+ if (!dsuImage) { notify.error('Select a GSI image first'); return }
+ setInstalling(true); setPushPct(0)
+ const id = notify.loading('Preparing & pushing GSI (this can take a while)...')
+ try {
+ const out = await InstallDsu(dsuImage, systemSize, userdataGiB * GIB)
+ notify.dismiss(id); notify.success('DSU install launched'); setDsuStatus(out)
+ } catch (e: any) { notify.dismiss(id); notify.error(e) } finally { setInstalling(false); setPushPct(-1) }
+ }
+
+ const gsiTool = async (fn: () => Promise, label: string) => {
+ try { const out = await fn(); notify.success(`${label}: ${out || 'ok'}`); refreshStatus() } catch (e: any) { notify.error(e) }
+ }
+
+ const previewFlash = async () => {
+ if (!flashImage) { notify.error('Select a GSI system image first'); return }
+ try { setDryRun(await FlashGsiSystem(flashImage, { ...opts, vbmetaPath: vbmeta, dryRun: true })) } catch (e: any) { notify.error(e) }
+ }
+
+ const doFlash = async () => {
+ if (!flashImage) { notify.error('Select a GSI system image first'); return }
+ if (!confirm('Permanently flash this GSI to the system partition?\n\nThis ERASES system, wipes userdata, and requires an unlocked bootloader. If the GSI is incompatible the device may not boot. Continue?')) return
+ if (!(await ensureDangerUnlocked())) return
+ setFlashing(true)
+ const id = notify.loading('Flashing GSI via fastboot...')
+ try {
+ const out = await FlashGsiSystem(flashImage, { ...opts, vbmetaPath: vbmeta, dryRun: false })
+ notify.dismiss(id); notify.success('GSI flashed'); setFlashOut(out)
+ } catch (e: any) { notify.dismiss(id); notify.error(e); setFlashOut(String(e?.message || e)) } finally { setFlashing(false) }
+ }
+
+ const trebleOk = compat?.trebleEnabled
+ const baseName = (p: string) => p.split('/').pop() || p
+
+ return (
+ ([])
+ const [pkgsLoaded, setPkgsLoaded] = useState(false)
+ const [selected, setSelected] = useState('')
+ const [activities, setActivities] = useState([])
+ const [loading, setLoading] = useState(false)
+ const [actFilter, setActFilter] = useState('')
+ const [lastResult, setLastResult] = useState('')
+
+ // Free-form implicit-intent launcher
+ const [action, setAction] = useState('android.intent.action.VIEW')
+ const [data, setData] = useState('')
+
+ const loadPackages = async () => {
+ if (pkgsLoaded) return
+ try {
+ const pkgs = await ListPackages('all')
+ setPackages(pkgs || [])
+ setPkgsLoaded(true)
+ } catch {}
+ }
+
+ // Populate the picker on open so it isn't empty until the search box is focused.
+ useEffect(() => { loadPackages() }, [])
+
+ const loadActivities = async (pkg: string) => {
+ if (!pkg.trim()) return
+ setSelected(pkg.trim())
+ setLoading(true)
+ setActivities([])
+ setLastResult('')
+ try {
+ const acts = await ListActivities(pkg.trim())
+ setActivities(acts || [])
+ } catch (e: any) {
+ notify.error(e)
+ } finally {
+ setLoading(false)
+ }
+ }
+
+ const launch = async (component: string) => {
+ const id = notify.loading(`Launching ${component}...`)
+ try {
+ const out = await StartActivity(component)
+ notify.dismiss(id)
+ notify.success(out || 'Started')
+ setLastResult(`✓ ${component}\n${out}`)
+ } catch (e: any) {
+ notify.dismiss(id)
+ notify.error(e)
+ setLastResult(`✗ ${component}\n${e?.message || e}`)
+ }
+ }
+
+ const launchIntent = async () => {
+ if (!action.trim()) { notify.error('Enter an action'); return }
+ const id = notify.loading('Launching intent...')
+ try {
+ const out = await StartIntentAction(action.trim(), data.trim())
+ notify.dismiss(id)
+ notify.success(out || 'Started')
+ setLastResult(`✓ ${action}${data ? ' ' + data : ''}\n${out}`)
+ } catch (e: any) {
+ notify.dismiss(id)
+ notify.error(e)
+ setLastResult(`✗ ${action}\n${e?.message || e}`)
+ }
+ }
+
+ const filteredPkgs = packages.filter(p => p.packageName.toLowerCase().includes(search.toLowerCase()))
+ const filteredActs = activities.filter(a =>
+ a.name.toLowerCase().includes(actFilter.toLowerCase()) ||
+ a.component.toLowerCase().includes(actFilter.toLowerCase())
+ )
+
+ return (
+ (() => loadHighlightRules())
+ const [newPattern, setNewPattern] = useState('')
+ const [newMode, setNewMode] = useState<'contains' | 'regex'>('contains')
+ const [newColor, setNewColor] = useState('red')
+ const [scrubExport, setScrubExport] = useState(true)
const mapSinkRef = useRef<((l: LogcatLine) => void) | null>(null)
const bottomRef = useRef(null)
const containerRef = useRef(null)
@@ -146,15 +158,40 @@ export default function ViewLogcat() {
}
}
- const saveLog = () => {
- const text = lines.map(l => l.raw).join('\n')
- const blob = new Blob([text], { type: 'text/plain' })
- const url = URL.createObjectURL(blob)
- const a = document.createElement('a')
- a.href = url
- a.download = `logcat_${Date.now()}.txt`
- a.click()
- URL.revokeObjectURL(url)
+ const saveLog = async () => {
+ // Export the currently-visible (filtered) lines, optionally scrubbing
+ // sensitive identifiers (IMEIs, phone numbers, SIM serials, MACs, emails).
+ let text = filteredLines.map(l => l.raw).join('\n')
+ if (scrubExport) text = scrubSensitive(text)
+ const stamp = new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-')
+ const name = `logcat_${stamp}${scrubExport ? '_scrubbed' : ''}.txt`
+ try {
+ const saved = await SaveTextFile(name, text)
+ if (saved) notify.success(`Saved ${scrubExport ? '(scrubbed) ' : ''}to ${saved}`)
+ } catch (e: any) {
+ notify.error(e)
+ }
+ }
+
+ // Compiled highlight matchers (recompiled only when rules change).
+ const compiled = useMemo(() => compileRules(hiRules), [hiRules])
+ const highlightFor = useCallback((raw: string): string => {
+ for (const c of compiled) if (c.test(raw)) return c.style
+ return ''
+ }, [compiled])
+
+ const addRule = () => {
+ if (!newPattern.trim()) return
+ const rule: HighlightRule = {
+ id: `${Date.now()}-${Math.round(Math.random() * 1e6)}`,
+ pattern: newPattern.trim(), mode: newMode, color: newColor,
+ }
+ const next = [...hiRules, rule]
+ setHiRules(next); saveHighlightRules(next); setNewPattern('')
+ }
+ const removeRule = (id: string) => {
+ const next = hiRules.filter(r => r.id !== id)
+ setHiRules(next); saveHighlightRules(next)
}
const filteredLines = lines.filter(line => {
@@ -212,9 +249,31 @@ export default function ViewLogcat() {
)}
- {filteredLines.map((line, i) => (
-
+ {/* Header + tabs */}
+
+ )
+}
diff --git a/frontend/src/components/views/ViewIntentLab.tsx b/frontend/src/components/views/ViewIntentLab.tsx
new file mode 100644
index 0000000..157627e
--- /dev/null
+++ b/frontend/src/components/views/ViewIntentLab.tsx
@@ -0,0 +1,216 @@
+import { useState, useEffect } from 'react'
+import { Search, Rocket, Play, Terminal, Package } from 'lucide-react'
+import { ListActivities, StartActivity, StartIntentAction, ListPackages } from '../../lib/wails'
+import { notify } from '../../lib/notify'
+import type { IntentActivity, PackageInfo } from '../../lib/types'
+
+export default function ViewIntentLab() {
+ const [search, setSearch] = useState('')
+ const [packages, setPackages] = useState
+
+
+ {/* Compatibility panel */}
+
+
+
+
+
+
+
+ Compatibility
+ {!compat && {compatLoading ? 'Checking…' : 'No device / unknown'}}
+ {compat && (
+ <>
+
+ {trebleOk ?
+
+
+ {tab === 'dsu' ? (
+
+
+
+ ) : (
+ + Installs a GSI as a temporary guest OS via Dynamic System Updates — no unlock, + no data wipe. Pick a raw (unsparsed) GSI system.img or a + .gz you made from one. After install, tap Restart in the device notification to boot it. +
+ + {/* Image picker */} +
+
+ {dsuImage ? baseName(dsuImage) : 'no file selected'}
+
+
+
+
+
+ {pushPct >= 0 && (
+
+
+ Userdata size (GiB)
+ setUserdataGiB(Math.max(1, Number(e.target.value)))} /> +
+
+ System size (bytes) — auto for raw .img, required for .gz
+ setSystemSize(Math.max(0, Number(e.target.value)))} placeholder="0 = auto (raw .img)" /> +
+
+ )}
+
+
+
+
+ {pushPct}%
+
+
+
+
+
+ {/* gsi_tool management */}
+
+
+ DSU management (gsi_tool)
+
+
+
+
+
+
+ {dsuStatus && {dsuStatus}}
+
+
+ )}
+
+
+
+ + Destructive & permanent. Erases the system partition, wipes userdata, and needs an + unlocked bootloader. An incompatible GSI can leave the device unbootable — keep the stock factory image to recover. GSIs don't support rollback. +
+
+
+ {flashImage ? baseName(flashImage) : 'no file selected'}
+
+
+
+ {([
+ ['fastbootd', 'Reboot to fastbootd first (dynamic partitions)'],
+ ['wipeData', 'Wipe userdata (fastboot -w)'],
+ ['disableVerity', 'Disable Verified Boot (flash vbmeta)'],
+ ['deleteProduct', 'Delete product partition (free space)'],
+ ] as const).map(([key, label]) => (
+
+ ))}
+
+
+ {(opts.disableVerity) && (
+
+
+ {vbmeta ? baseName(vbmeta) : 'required for disable-verity'}
+
+ )}
+
+ {(opts.deleteProduct) && (
+
+ Active slot suffix:
+
+
+ )}
+
+
+
+
+
+
+ {dryRun && (
+
+
+ )}
+ {flashOut && (
+ Command preview
+{dryRun}
+
+
+ )}
+ Output
+{flashOut}
+
+ {/* Left: package picker */}
+
+ )
+}
diff --git a/frontend/src/components/views/ViewLogcat.tsx b/frontend/src/components/views/ViewLogcat.tsx
index c9b776c..7749fc9 100644
--- a/frontend/src/components/views/ViewLogcat.tsx
+++ b/frontend/src/components/views/ViewLogcat.tsx
@@ -1,9 +1,15 @@
-import { useState, useEffect, useRef, useCallback } from 'react'
-import { Play, Square, Trash2, Download, Filter, ChevronDown, List, Share2 } from 'lucide-react'
-import { StartLogcat, StopLogcat, ClearLogcat } from '../../lib/wails'
+import { useState, useEffect, useRef, useCallback, useMemo } from 'react'
+import { Play, Square, Trash2, Download, Filter, ChevronDown, List, Share2, Highlighter, Plus, X } from 'lucide-react'
+import { StartLogcat, StopLogcat, ClearLogcat, SaveTextFile } from '../../lib/wails'
import { notify } from '../../lib/notify'
import LogcatMap from './LogcatMap'
import type { LogcatLine } from '../../lib/types'
+import {
+ loadHighlightRules, saveHighlightRules, compileRules, scrubSensitive,
+ HI_SWATCH, type HighlightRule, type HiColor,
+} from '../../lib/logcat_tools'
+
+const HI_COLORS: HiColor[] = ['red', 'amber', 'green', 'blue', 'purple', 'pink']
// @ts-ignore
const { EventsOn, EventsOff } = window['runtime'] || {}
@@ -42,6 +48,12 @@ export default function ViewLogcat() {
const [search, setSearch] = useState('')
const [showFilters, setShowFilters] = useState(false)
const [viewMode, setViewMode] = useState<'text' | 'map'>('text')
+ const [showHighlights, setShowHighlights] = useState(false)
+ const [hiRules, setHiRules] = useState
+
+
+ {/* Right: launcher */}
+
+
+ Intent Lab
+
+
+
+
+ {filteredPkgs.map(p => (
+
+ ))}
+ {!pkgsLoaded && (
+
+ Focus the box to load the package list
+ )} +
+ {!selected && !loading && (
+
+
+
+ )}
+
+ {(selected || loading) && (
+ <>
+ {/* Free-form implicit-intent launcher */}
+ Pick an app to see its launchable activities
+
+
+
+ {/* Activities */}
+
+ setAction(e.target.value)}
+ />
+ setData(e.target.value)}
+ onKeyDown={e => e.key === 'Enter' && launchIntent()}
+ />
+
+
+
+
+
+
+
+
+ {loading && (
+
+
+ {/* Last result */}
+ {lastResult && (
+
+
+
+ )}
+ {!loading && filteredActs.length === 0 && (
+ + No launchable activities{activities.length > 0 ? ' match the filter' : ' — this app exports none, or requires root to reach its internal screens'}. +
+ )} + {!loading && filteredActs.map(act => ( +
+
+ ))}
+
+
+ {act.exported && exported}
+
+ {act.name}
+{act.component}
+
+
+ )}
+
+ )}
+ {lastResult}
+
- {line.time}
- {line.pid}
-
- {line.level}
-
- {line.tag}
-
- {line.message || line.raw}
-
-
- ))}
+ {filteredLines.map((line, i) => {
+ const hi = highlightFor(line.raw)
+ return (
+
+ {line.time}
+ {line.pid}
+
+ {line.level}
+
+ {line.tag}
+
+ {line.message || line.raw}
+
+
+ )
+ })}
{t.hint}
+ {/* Swatch preview: base · surface · accent · text */} + +{t.hint}
))} + {/* Custom accent colour + font — system-wide overrides on top of the theme */} +
+
+
+
+ Custom accent colour (overrides the theme accent everywhere)
+
+ changeAccent(e.target.value)}
+ className="h-8 w-12 rounded border border-bg-border bg-bg-raised cursor-pointer p-0.5"
+ title="Pick a custom accent colour"
+ />
+ {customAccent || 'theme default'}
+ {customAccent && (
+
+ )}
+
+
+
+ Font (applied app-wide)
+ +Sidebar position. Applies instantly and is remembered.
{SIDEBAR_POSITIONS.map(p => (
diff --git a/frontend/src/components/views/ViewShell.tsx b/frontend/src/components/views/ViewShell.tsx
index 9492263..5a69d79 100644
--- a/frontend/src/components/views/ViewShell.tsx
+++ b/frontend/src/components/views/ViewShell.tsx
@@ -2,6 +2,7 @@ import { useState, useRef, useEffect } from 'react'
import { Terminal, Trash2, ChevronRight, ChevronDown, Library, Search, Copy, Save } from 'lucide-react'
import { RunShellCommand, RunAdbHostCommand, SaveTextFile } from '../../lib/wails'
import { notify } from '../../lib/notify'
+import { CodeView, detectLang } from '../../lib/syntax'
import { CATEGORIES, type Command } from './ViewUtilities'
interface HistoryEntry {
@@ -233,13 +234,17 @@ export default function ViewShell() {
{entry.cmd}
)}
-
- {entry.output}
-
+ {entry.error ? (
+
+ {entry.output}
+
+ ) : (
+ {code}
+ return (
+
+ {toks.map((t, i) => (t.c ? {t.t} : {t.t}))}
+
+ )
+}
diff --git a/frontend/src/lib/theme.ts b/frontend/src/lib/theme.ts
index b7c647e..855b668 100644
--- a/frontend/src/lib/theme.ts
+++ b/frontend/src/lib/theme.ts
@@ -1,22 +1,56 @@
// Theme management. Palettes are defined in src/styles/global.css and selected
// by the data-theme attribute on . Choice is persisted in localStorage.
+//
+// The catalogue below is the single source of truth: adding a palette here
+// (plus its CSS block in global.css) makes it appear in the Settings picker
+// automatically. The `swatch` tuple ([base, surface, accent, text]) drives the
+// preview shown on each theme card.
-export type Theme = 'dark' | 'frappe' | 'latte'
+export interface ThemeDef {
+ id: string
+ label: string
+ hint: string
+ swatch: [string, string, string, string]
+}
-export const THEMES: { id: Theme; label: string; hint: string }[] = [
- { id: 'dark', label: 'Dark', hint: 'Terminal green on black' },
- { id: 'frappe', label: 'Frappé', hint: 'Catppuccin — soft pastels, dark' },
- { id: 'latte', label: 'Latte', hint: 'Catppuccin — soft pastels, light (default)' },
+export const THEMES: ThemeDef[] = [
+ // ATK originals
+ { id: 'dark', label: 'Dark', hint: 'Terminal green on black', swatch: ['#0a0a0f', '#111118', '#00ff88', '#e8e8f0'] },
+ { id: 'frappe', label: 'Frappé', hint: 'Catppuccin — pastels, dark', swatch: ['#303446', '#292c3c', '#a6d189', '#c6d0f5'] },
+ { id: 'latte', label: 'Latte', hint: 'Catppuccin — pastels, light', swatch: ['#eff1f5', '#e6e9ef', '#40a02b', '#4c4f69'] },
+ // Ported from Notas
+ { id: 'dracula', label: 'Dracula', hint: 'Purple & pink on charcoal', swatch: ['#282a36', '#343746', '#bd93f9', '#f8f8f2'] },
+ { id: 'catppuccin-macchiato', label: 'Catppuccin Macchiato', hint: 'Catppuccin — pastels, medium-dark', swatch: ['#24273a', '#363a4f', '#c6a0f6', '#cad3f5'] },
+ { id: 'catppuccin-mocha', label: 'Catppuccin Mocha', hint: 'Catppuccin — pastels, darkest', swatch: ['#1e1e2e', '#313244', '#cba6f7', '#cdd6f4'] },
+ { id: 'vintage-light', label: 'Vintage Light', hint: 'Warm sepia paper, light', swatch: ['#f6efe1', '#efe5d0', '#b07d3a', '#46392b'] },
+ { id: 'neon-tessera', label: 'Neon Tessera', hint: 'Cyan & magenta neon on black', swatch: ['#0a0e14', '#11161f', '#00e5ff', '#d8e6f2'] },
+ { id: 'adventure-time', label: 'Adventure Time', hint: 'Playful purple & orange', swatch: ['#1f1d45', '#2a2755', '#e7741e', '#f8dcc0'] },
+ { id: 'borland', label: 'Borland', hint: 'Retro blue IDE', swatch: ['#0000a4', '#0a1ab0', '#ffff4e', '#ffff80'] },
+ { id: 'c64', label: 'Commodore 64', hint: 'Commodore 64 blues', swatch: ['#40318d', '#4d3ea0', '#bfce72', '#cabdf2'] },
+ { id: 'fairy-floss-dark', label: 'Fairy Floss Dark', hint: 'Cotton-candy pastels', swatch: ['#3b364c', '#4a4564', '#ffb8d1', '#f8f8f2'] },
+ { id: 'flat', label: 'Flat', hint: 'Flat-UI slate & blue', swatch: ['#2c3e50', '#34495e', '#3498db', '#ecf0f1'] },
+ { id: 'gogh', label: 'Gogh — Starry Night', hint: 'Starry Night blues & gold', swatch: ['#0d1b34', '#14264a', '#f4cd3a', '#e8eeff'] },
+ { id: 'grass', label: 'Grass', hint: 'Green field & amber', swatch: ['#13773d', '#1c8a4a', '#e7b000', '#fff0a5'] },
+ { id: 'gruvbox-material', label: 'Gruvbox Material', hint: 'Warm retro earth tones', swatch: ['#282828', '#32302f', '#d8a657', '#d4be98'] },
+ { id: 'homebrew', label: 'Homebrew', hint: 'Green-on-black terminal', swatch: ['#000000', '#0c140c', '#00ff00', '#00d000'] },
+ { id: 'ocean', label: 'Ocean', hint: 'Muted blue-grey', swatch: ['#2b303b', '#343d46', '#8fa1b3', '#c0c5ce'] },
+ { id: 'kokuban', label: 'Kokuban', hint: 'Chalkboard green', swatch: ['#1f3526', '#274030', '#f2e9c8', '#f0f0e8'] },
+ { id: 'mono-cyan', label: 'Mono Cyan', hint: 'Monochrome cyan glow', swatch: ['#081414', '#0e1f1f', '#00d0d0', '#c8f0f0'] },
]
+export type Theme = string
+
const STORAGE_KEY = 'atk-theme'
+const VALID_IDS = new Set(THEMES.map(t => t.id))
+const DEFAULT_THEME: Theme = 'gruvbox-material'
export function getTheme(): Theme {
const t = localStorage.getItem(STORAGE_KEY)
- return t === 'frappe' || t === 'latte' || t === 'dark' ? t : 'latte'
+ return t && VALID_IDS.has(t) ? t : DEFAULT_THEME
}
export function applyTheme(theme: Theme): void {
- document.documentElement.setAttribute('data-theme', theme)
- localStorage.setItem(STORAGE_KEY, theme)
+ const t = VALID_IDS.has(theme) ? theme : DEFAULT_THEME
+ document.documentElement.setAttribute('data-theme', t)
+ localStorage.setItem(STORAGE_KEY, t)
}
diff --git a/frontend/src/lib/types.ts b/frontend/src/lib/types.ts
index b287e7a..84118a9 100644
--- a/frontend/src/lib/types.ts
+++ b/frontend/src/lib/types.ts
@@ -190,6 +190,38 @@ export interface AppInspection {
manifestDump: string
}
+export interface IntentActivity {
+ name: string
+ component: string
+ exported: boolean
+}
+
+export interface GsiCompat {
+ trebleEnabled: boolean
+ abi: string
+ gsiArch: string
+ vndkIsolated: boolean
+ androidRelease: string
+ sdk: string
+ dsuStatus: string
+}
+
+export interface PrivacyTracker {
+ name: string
+ category: string
+ matches: number
+}
+
+export interface PrivacyReport {
+ packageName: string
+ score: number // 0-100, higher = more private
+ grade: string // A-F
+ trackerCount: number
+ trackers: PrivacyTracker[]
+ dangerousPermissions: string[]
+ apkSize: number
+}
+
export interface CertInfo {
filename: string
subject: string
@@ -223,6 +255,8 @@ export type View =
| 'shell'
| 'logcat'
| 'appinspect'
+ | 'intentlab'
+ | 'gsiloader'
| 'apkaudit'
| 'certs'
| 'backup'
diff --git a/frontend/src/lib/wails.ts b/frontend/src/lib/wails.ts
index a686511..6279314 100644
--- a/frontend/src/lib/wails.ts
+++ b/frontend/src/lib/wails.ts
@@ -185,6 +185,29 @@ export const LogcatProcessNames = (): Promise