pikiloom 0.4.26 → 0.4.27

package/dist/core/git.js

@@ -1,22 +1,5 @@
-/**
- * Git working-tree status as a cross-platform OS primitive.
- *
- * One bounded `git status --porcelain=v2 --branch` invocation, parsed into a
- * structured {@link GitStatus}. Porcelain v2 is machine-stable across git
- * versions and locales, so we count entry lines rather than scraping human
- * output. A single reader feeds both the IM `/status` command and the Dashboard
- * workspace view — no git logic is duplicated in the channels or the SPA.
- */
 import { spawnSync } from 'node:child_process';
 import { GIT_STATUS_TIMEOUT_MS } from './constants.js';
-/**
- * Read the git status of `dir`. Returns `null` for a non-repo, a missing git
- * binary, or a timeout — callers simply omit the git section. Never throws.
- *
- * Walks up from `dir` like git itself, so a workspace nested below the repo root
- * is still recognised. Uses `GIT_OPTIONAL_LOCKS=0` to avoid contending with
- * other git processes for the index lock.
- */
 export function readGitStatus(dir) {
     if (!dir)
         return null;
@@ -35,7 +18,6 @@ export function readGitStatus(dir) {
         return null;
     }
 }
-/** Parse `git status --porcelain=v2 --branch` output. Exported for testing. */
 export function parseGitStatusV2(stdout) {
     let branch = null;
     let detached = false;
@@ -75,7 +57,6 @@ export function parseGitStatusV2(stdout) {
             }
         }
         else if (line.startsWith('1 ') || line.startsWith('2 ')) {
-            // Ordinary / renamed entry: field 2 is the XY status (X=index, Y=worktree).
             const xy = line.split(' ')[1] || '..';
             if (xy[0] && xy[0] !== '.')
                 staged++;
@@ -83,7 +64,6 @@ export function parseGitStatusV2(stdout) {
                 unstaged++;
         }
         else if (line.startsWith('u ')) {
-            // Unmerged (conflict) — count as a working-tree change.
             unstaged++;
         }
         else if (line.startsWith('? ')) {
@@ -103,17 +83,6 @@ export function parseGitStatusV2(stdout) {
         changed: staged + unstaged + untracked,
     };
 }
-/**
- * Render a {@link GitStatus} into a single friendly line (no channel-specific
- * markup), e.g.:
- *
- *   main  ↑2 ↓1  ·  5 changed (3 staged · 2 untracked)
- *   feature/x  ·  no upstream  ·  clean
- *   (detached a1b2c3d)  ·  1 changed
- *
- * Returns `null` when there is no git status to show, so callers can omit the
- * line entirely.
- */
 export function formatGitStatusLine(git) {
     if (!git)
         return null;

package/dist/core/legacy-compat.js

@@ -1,24 +1,7 @@
-/**
- * One-time backward-compat shims for the project rename.
- *
- * The orchestrator shipped as `pikiclaw` and is now `pikiloom`. Both run once at
- * process startup — BEFORE any config is read or any lock / PID file is taken —
- * so existing `pikiclaw` installs keep their settings, credentials, managed
- * browser profile and skills with zero user action.
- *
- * Remove this file (and the LEGACY_* constants) a couple of releases after the
- * rename has propagated.
- */
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { STATE_DIR_NAME, LEGACY_STATE_DIR_NAMES, ENV_PREFIX, LEGACY_ENV_PREFIXES, } from './constants.js';
-/**
- * Mirror every legacy-prefixed env var (`PIKICLAW_*`) onto the matching
- * `PIKILOOM_*` name when the new name is unset. Covers user-set vars (shell
- * profiles, docker-compose, systemd units) AND internal ones a still-old parent
- * process may have set across an upgrade boundary.
- */
 export function hydrateLegacyEnv() {
     for (const legacy of LEGACY_ENV_PREFIXES) {
         for (const [key, value] of Object.entries(process.env)) {
@@ -32,14 +15,6 @@ export function hydrateLegacyEnv() {
         }
     }
 }
-/**
- * Migrate the legacy state dir (`~/.pikiclaw`) → `~/.pikiloom`, exactly once.
- *
- * No-op when the new dir already exists (migrated or fresh install) or no legacy
- * dir is present (brand-new user). A same-volume rename is atomic; on a
- * cross-device failure we fall back to a recursive copy and deliberately leave
- * the old dir in place so a partial/failed copy can never lose user data.
- */
 export function migrateLegacyStateDir() {
     try {
         const home = os.homedir();
@@ -54,13 +29,11 @@ export function migrateLegacyStateDir() {
                 fs.renameSync(prev, next);
             }
             catch {
-                // Cross-device or in-use: copy and keep the original as a safety net.
                 fs.cpSync(prev, next, { recursive: true });
             }
-            return; // migrated from the newest available legacy dir
+            return;
         }
     }
     catch {
-        // Best-effort only — never block startup on migration.
     }
 }

package/dist/core/logging.js

@@ -1,6 +1,3 @@
-/**
- * Structured logging with scoped writers and file retention.
- */
 import fs from 'node:fs';
 import path from 'node:path';
 const LOG_LEVEL_WEIGHT = {

package/dist/core/platform.js

@@ -1,23 +1,12 @@
-/**
- * Cross-platform primitives. All OS-dependent behavior must route through here
- * so the rest of the codebase stays platform-neutral.
- */
 import os from 'node:os';
 import path from 'node:path';
 import which from 'which';
 export const IS_WIN = process.platform === 'win32';
 export const IS_MAC = process.platform === 'darwin';
 export const IS_LINUX = process.platform === 'linux';
-/**
- * User home directory. Re-reads each call so runtime `$HOME`/`$USERPROFILE`
- * overrides (and tests that mutate them) stay honored. Works on Windows
- * where `$HOME` is not set by default — `os.homedir()` falls back to
- * `$USERPROFILE`.
- */
 export function getHome() {
     return os.homedir();
 }
-/** Expand a leading `~` (or `~/`, `~\`) to the user's home directory. */
 export function expandTilde(p) {
     if (!p || p[0] !== '~')
         return p;
@@ -29,31 +18,14 @@ export function expandTilde(p) {
     }
     return p;
 }
-/** Locate an executable on PATH, honoring PATHEXT on Windows. */
 export function whichSync(cmd) {
     return which.sync(cmd, { nothrow: true }) || null;
 }
-/**
- * Encode an absolute workdir path as a single directory-name segment.
- * Mirrors Claude Code's scheme under `~/.claude/projects/`: every non
- * alphanumeric character collapses to `-`. Critically that includes
- * underscores and dots (e.g. `/path/to/harness_ppt` → `-path-to-harness-ppt`),
- * which matches the encoding Claude Code uses on disk. Replacing only path
- * separators leaves a workdir whose name contains `_` (or `.`) pointing at
- * a directory that does not exist, so session JSONL lookups silently fall
- * back to an empty/truncated result.
- */
 export function encodePathAsDirName(p) {
     return p.replace(/[^a-zA-Z0-9]/g, '-');
 }
-/**
- * Match a path segment regardless of separator. Useful for probing whether a
- * resolved script path runs under a given binary (e.g. `tsx`, `ts-node`)
- * without hardcoding `/` — which fails on Windows.
- */
 export function pathContainsSegment(p, segment) {
     const escaped = segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     return new RegExp(`[\\\\/]${escaped}([\\\\/]|$)`).test(p);
 }
-/** Null-redirect suffix for shell commands. */
 export const DEV_NULL_REDIRECT = IS_WIN ? '2>nul' : '2>/dev/null';

package/dist/core/process-control.js

@@ -1,6 +1,3 @@
-/**
- * Process lifecycle: restart coordination, watchdog, and process tree termination.
- */
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -10,7 +7,6 @@ import { STATE_DIR_NAME } from './constants.js';
 export const PROCESS_RESTART_EXIT_CODE = 75;
 export const PROCESS_RESTART_STATE_FILE_ENV = 'PIKILOOM_RESTART_STATE_FILE';
 const DAEMON_PID_FILENAME = 'pikiloom.pid';
-/** Path to the daemon PID file used by `pikiloom stop`. */
 export function getDaemonPidFilePath() {
     return path.join(os.homedir(), STATE_DIR_NAME, DAEMON_PID_FILENAME);
 }
@@ -38,7 +34,6 @@ export function readDaemonPidFile() {
         return null;
     }
 }
-/** True if a process with `pid` is currently running (POSIX kill -0 / win32 tasklist). */
 export function isProcessAlive(pid) {
     if (!pid || pid <= 0)
         return false;
@@ -48,7 +43,6 @@ export function isProcessAlive(pid) {
     }
     catch (err) {
         const code = err?.code;
-        // EPERM means the process exists but we cannot signal it — still alive.
         return code === 'EPERM';
     }
 }
@@ -100,7 +94,6 @@ export function getDefaultRestartCmd() {
         const parts = isTsxLoader ? ['tsx', argv1] : process.argv.slice(0, 2);
         return parts.map(arg => arg.includes(' ') ? `"${arg}"` : arg).join(' ');
     }
-    // Running from an installed package (e.g. npm install -g) — reuse the same entry point
     if (argv1.endsWith('.js') && (argv1.includes('pikiloom') || argv1.includes('pikiloom'))) {
         const nodeBin = argv0.includes(' ') ? `"${argv0}"` : argv0;
         const entry = argv1.includes(' ') ? `"${argv1}"` : argv1;
@@ -216,7 +209,6 @@ function buildRestartEnvForSpawn(extraEnv) {
     return env;
 }
 function spawnReplacementProcess(bin, args, env, log) {
-    // npx/npx.cmd needs shell resolution; node.exe does not
     const needsShell = process.platform === 'win32' && !bin.endsWith('node.exe');
     const child = spawn(needsShell ? `"${bin}"` : bin, args, {
         stdio: 'inherit',

package/dist/core/secrets/index.js

@@ -1,23 +1,9 @@
-/**
- * Barrel for the pikiloom credential vault.
- *
- * Pikiloom owns its own credential layer rather than delegating to per-agent
- * config files: when an agent is spawned, the active Profile's credentials
- * are resolved on the fly and injected as env vars / generated config files.
- * This means setting.json never holds a raw secret in the default flow, and
- * adding a new agent (Hermes, OpenCode, …) does not duplicate credential UX.
- */
 export { KEYCHAIN_SERVICE, isCredentialRef, describeCredentialRef } from './ref.js';
 export { resolveCredential, tryResolveCredential } from './resolver.js';
 export { isKeychainAvailable, readKeychain, writeKeychain, deleteKeychain, } from './store.js';
 export { sealInline, unsealInline } from './inline-seal.js';
 import { writeKeychain, deleteKeychain, isKeychainAvailable } from './store.js';
 import { sealInline } from './inline-seal.js';
-/**
- * Convenience: store a freshly-pasted secret using the safest available
- * backend. Returns the CredentialRef the caller should persist alongside
- * the Provider record.
- */
 export async function persistSecret(account, plaintext) {
     if (await isKeychainAvailable()) {
         try {
@@ -25,12 +11,10 @@ export async function persistSecret(account, plaintext) {
             return { source: 'keychain', account };
         }
         catch {
-            // fall through to inline seal
         }
     }
     return { source: 'inline', sealed: sealInline(plaintext) };
 }
-/** Best-effort cleanup when a Provider is deleted. */
 export async function forgetSecret(ref) {
     if (ref.source === 'keychain') {
         try {
@@ -38,5 +22,4 @@ export async function forgetSecret(ref) {
         }
         catch { }
     }
-    // env / command / inline references have nothing to clean
 }

package/dist/core/secrets/inline-seal.js

@@ -1,9 +1,3 @@
-/**
- * Machine-bound AES-256-GCM seal for credential values when no OS keychain
- * is available. The derived key mixes hostname + a per-install random salt
- * stored alongside ~/.pikiloom/setting.json, so a sealed blob copied to a
- * different machine will not decrypt.
- */
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -35,7 +29,6 @@ function deriveKey() {
     ]);
     return crypto.createHash('sha256').update(material).digest();
 }
-/** Returns base64 string `v1:<iv>:<ciphertext>:<tag>`. */
 export function sealInline(plaintext) {
     const key = deriveKey();
     const iv = crypto.randomBytes(12);

package/dist/core/secrets/ref.js

@@ -1,22 +1,4 @@
-/**
- * Credential reference — never store raw secrets in setting.json.
- *
- * Each credential is described by a small reference that can be dereferenced
- * at use time:
- *   - keychain: stored in OS keychain, looked up by service+account
- *   - env:      read from process.env at use time
- *   - command:  exec a command and use its stdout (e.g. `op read`, `gh auth token`)
- *   - inline:   AES-GCM sealed blob bound to this machine (fallback)
- */
-/** Stable service name used when writing to the OS keychain. */
 export const KEYCHAIN_SERVICE = 'pikiloom';
-/**
- * Legacy keychain service names this build still reads from. The project was
- * renamed (pikiclaw → pikiloom); credentials written under the old service are
- * orphaned because lookups now use `KEYCHAIN_SERVICE`. `readKeychain` falls
- * back to these on a miss and lazily re-writes the secret under the current
- * service, so each orphaned item self-heals on first use.
- */
 export const LEGACY_KEYCHAIN_SERVICES = ['pikiclaw'];
 export function isCredentialRef(value) {
     if (!value || typeof value !== 'object')
@@ -30,7 +12,6 @@ export function isCredentialRef(value) {
         default: return false;
     }
 }
-/** Short, non-sensitive description of a credential reference for UI display. */
 export function describeCredentialRef(ref) {
     switch (ref.source) {
         case 'keychain': return `keychain:${ref.account}`;

package/dist/core/secrets/resolver.js

@@ -1,10 +1,3 @@
-/**
- * Resolve a CredentialRef to a plaintext secret.
- *
- * Resolved values are returned to the caller and immediately consumed (e.g.
- * injected into a child process env at spawn time). Pikiloom never persists
- * the resolved plaintext in long-lived state.
- */
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { readKeychain } from './store.js';
@@ -54,7 +47,6 @@ export async function resolveCredential(ref, opts = {}) {
         }
     }
 }
-/** Resolve to null on error rather than throwing — useful for status checks. */
 export async function tryResolveCredential(ref, opts = {}) {
     try {
         return await resolveCredential(ref, opts);

package/dist/core/secrets/store.js

@@ -1,15 +1,9 @@
-/**
- * OS keychain access — lazy import of @napi-rs/keyring (optional dep).
- * If keychain is unavailable, callers fall back to inline-seal.
- */
 import { KEYCHAIN_SERVICE, LEGACY_KEYCHAIN_SERVICES } from './ref.js';
-let keyringModule; // undefined = not tried, null = failed
+let keyringModule;
 async function loadKeyring() {
     if (keyringModule !== undefined)
         return keyringModule;
     try {
-        // Optional dep — tsc can't see it without the package installed; use a
-        // dynamic, untyped import so the build succeeds with or without it.
         const importer = new Function('m', 'return import(m)');
         const mod = await importer('@napi-rs/keyring');
         keyringModule = mod;
@@ -19,7 +13,6 @@ async function loadKeyring() {
     }
     return keyringModule;
 }
-/** Reset the cached module — used by tests. */
 export function _resetKeychainCache() {
     keyringModule = undefined;
 }
@@ -37,7 +30,6 @@ export async function readKeychain(account) {
             return typeof value === 'string' && value.length > 0 ? value : null;
         }
         catch (e) {
-            // keyring-rs returns NoEntry as an error — treat as missing
             if (/NoEntry|no.such|not.found/i.test(e?.message || ''))
                 return null;
             throw e;
@@ -46,8 +38,6 @@ export async function readKeychain(account) {
     const current = readUnder(KEYCHAIN_SERVICE);
     if (current != null)
         return current;
-    // Pre-rename fallback: recover orphaned items and migrate them forward so the
-    // legacy lookup only ever happens once per account.
     for (const legacy of LEGACY_KEYCHAIN_SERVICES) {
         const value = readUnder(legacy);
         if (value == null)
@@ -56,7 +46,6 @@ export async function readKeychain(account) {
             new mod.Entry(KEYCHAIN_SERVICE, account).setPassword(value);
         }
         catch {
-            // best-effort migration — return the recovered secret regardless
         }
         return value;
     }

package/dist/core/utils.js

@@ -1,13 +1,6 @@
-/**
- * Pure utility functions shared across all layers. No filesystem side effects, no state dependencies.
- */
 import fs from 'node:fs';
 import path from 'node:path';
 import { whichSync as platformWhichSync } from './platform.js';
-/**
- * If `dir` has a .gitignore, ignore managed `.pikiloom` state without hiding
- * `.pikiloom/skills`, which may be committed as project skills.
- */
 export function ensureGitignore(dir) {
     try {
         const gi = path.join(dir, '.gitignore');
@@ -34,7 +27,7 @@ export function ensureGitignore(dir) {
             return;
         fs.writeFileSync(gi, next);
     }
-    catch { /* best-effort */ }
+    catch { }
 }
 export function envBool(name, def) {
     const raw = process.env[name];
@@ -82,38 +75,12 @@ export function shellSplit(str) {
     return args;
 }
 export const whichSync = platformWhichSync;
-/**
- * Strip ANSI terminal control sequences from a string. Covers the families
- * pikiloom runs into when scraping PTY screens (cursor positioning, SGR
- * colour / bold / italic, OSC titles, plus orphaned ESC bytes):
- *
- *   CSI:  ESC [ ...                — colours, cursor moves, line clears
- *   OSC:  ESC ] ... (BEL | ESC \)  — set window title, hyperlinks
- *   Other: ESC <single char>       — single-char escapes (RIS, IND, …)
- *
- * Some IM channels strip the raw ESC byte but pass through the trailing
- * `[3G` / `[1m` / `[38;2;…m` payload, which is how the user ends up seeing
- * "[3G你把" in Feishu. The regex matches with-or-without the leading ESC so
- * already-mangled output still gets cleaned. The leading-bracket fallback is
- * conservative — it only fires for known control verbs (digits/`;` then a
- * SGR/cursor letter), so legitimate text like "[3 second timeout]" survives.
- */
 export function stripAnsiEscapes(input) {
     if (!input)
         return input;
-    // Drop OSC (operating system command) sequences first so their payload
-    // doesn't confuse the CSI matcher.
     let out = input.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '');
-    // CSI with the leading ESC byte — match any final byte, even param-less
-    // (e.g. `\x1b[A` cursor-up, `\x1b[m` reset SGR). The ESC byte unambiguously
-    // signals a control sequence so we can be liberal here.
     out = out.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');
-    // CSI without the ESC byte (some IM channels strip the raw \x1b but pass
-    // through the `[3G` / `[38;2;…m` payload). Require at least one digit /
-    // semicolon in the params so legitimate text like "see [issue #42]" or
-    // "[3 second timeout]" doesn't get nibbled.
     out = out.replace(/\[[0-9;?]+[A-Za-z]/g, '');
-    // Any remaining ESC + single byte (RIS, IND, NEL, …).
     out = out.replace(/\x1b[@-Z\\-_]/g, '');
     return out;
 }
@@ -153,8 +120,6 @@ export function parseAllowedChatIds(raw) {
         if (!v)
             continue;
         const n = parseInt(v, 10);
-        // If the string is purely numeric, store as number for backward compat (Telegram).
-        // Otherwise store as string (Feishu, Discord, etc.).
         if (!Number.isNaN(n) && String(n) === v)
             ids.add(n);
         else if (v)
@@ -204,7 +169,6 @@ export function buildPrompt(text, files) {
         return text;
     return `${text || 'Please analyze this.'}\n\n[Files: ${files.map(f => path.basename(f)).join(', ')}]`;
 }
-/** Race a promise against a timeout, resolving with `fallback` on timeout or rejection. */
 export function withTimeoutFallback(promise, timeoutMs, fallback) {
     return new Promise(resolve => {
         let settled = false;

package/dist/core/version.js

@@ -1,6 +1,3 @@
-/**
- * Reads the package version from package.json at startup.
- */
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';

package/dist/dashboard/platform.js

@@ -1,23 +1,12 @@
-/**
- * Platform detection helpers.
- *
- * macOS permission checks, terminal detection, JXA scripts, and other OS-level utilities.
- */
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { execFileSync, execSync } from 'node:child_process';
 import { DASHBOARD_PERMISSION_TIMEOUTS, DASHBOARD_PERMISSION_CACHE_TTL_MS, } from '../core/constants.js';
-// ---------------------------------------------------------------------------
-// Permission pane URLs (macOS)
-// ---------------------------------------------------------------------------
 const permissionPaneUrls = {
     screenRecording: 'x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture',
     fullDiskAccess: 'x-apple.systempreferences:com.apple.preference.security?Privacy_AllFiles',
 };
-// ---------------------------------------------------------------------------
-// JXA helpers
-// ---------------------------------------------------------------------------
 function runJxa(script, timeout = DASHBOARD_PERMISSION_TIMEOUTS.jxaDefault) {
     try {
         return String(execFileSync('osascript', ['-l', 'JavaScript', '-e', script], { encoding: 'utf8', timeout })).trim().toLowerCase();
@@ -59,9 +48,6 @@ function openPermissionSettings(permission) {
         return false;
     }
 }
-// ---------------------------------------------------------------------------
-// Permission checks
-// ---------------------------------------------------------------------------
 export function checkPermissions() {
     const r = {};
     if (process.platform !== 'darwin') {
@@ -84,15 +70,6 @@ export function checkPermissions() {
     }
     return r;
 }
-// ---------------------------------------------------------------------------
-// Cached probes for the polling dashboard
-// ---------------------------------------------------------------------------
-// `/api/state` is polled (~1.5s while a channel validates) and both probes below
-// spawn subprocesses — checkPermissions() runs screencapture + an `ls` shell,
-// detectHostTerminalApp() runs a `ps` process-tree walk — so they must never run
-// per request. The host terminal is fixed for the process lifetime; permission
-// grants change rarely, so a short TTL is plenty and requestPermission()
-// invalidates the cache so a user-driven grant surfaces on the next poll.
 let permissionsCache = null;
 let hostTerminalAppCache = null;
 export function getPermissionsStatus() {
@@ -109,7 +86,7 @@ export function getHostTerminalApp() {
     return hostTerminalAppCache.value;
 }
 export function requestPermission(permission) {
-    permissionsCache = null; // a request can change grant state — force the next poll to re-probe
+    permissionsCache = null;
     if (process.platform !== 'darwin') {
         return {
             ok: false,
@@ -154,17 +131,10 @@ export function requestPermission(permission) {
 export function isValidPermissionKey(value) {
     return value in permissionPaneUrls;
 }
-// ---------------------------------------------------------------------------
-// Terminal detection
-// ---------------------------------------------------------------------------
-/** Walk the process tree upward to find the host terminal / IDE that launched pikiloom. Works on macOS and Linux. */
 export function detectHostTerminalApp() {
     if (process.platform !== 'darwin' && process.platform !== 'linux')
         return null;
     try {
-        // Patterns to match in the comm/exe name (case-insensitive on Linux where names vary)
-        // macOS: Terminal, iTerm2, Warp; Linux: gnome-terminal, konsole, xfce4-terminal, xterm, tilix, foot, sakura, terminology
-        // Cross-platform: Alacritty, kitty, WezTerm, Hyper, VS Code, Cursor, Windsurf
         const patterns = [
             'Terminal', 'iTerm', 'Warp',
             'Alacritty', 'alacritty', 'kitty', 'WezTerm', 'wezterm', 'Hyper',
@@ -176,18 +146,14 @@ export function detectHostTerminalApp() {
         if (!output)
             return null;
         const base = path.basename(output);
-        // Map comm name → human-readable display name
         const nameMap = [
-            // macOS
             ['iTerm', 'iTerm2'],
             ['Code Helper', 'VS Code'],
             ['Cursor Helper', 'Cursor'],
             ['Windsurf Helper', 'Windsurf'],
-            // Cross-platform IDE wrappers (Linux uses "code" binary directly)
             ['code', 'VS Code'],
             ['cursor', 'Cursor'],
             ['windsurf', 'Windsurf'],
-            // Terminal emulators
             ['gnome-terminal', 'GNOME Terminal'],
             ['xfce4-terminal', 'Xfce Terminal'],
             ['Terminal', 'Terminal'],