@zeluizr/lattice 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project adheres
 to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] — 2026-06-24
+
+### Added
+- **GIT panel reports the host of each repo.** A new `HOST` column tags every
+  repo by where its `origin` lives — **GitHub**, the self-hosted **zgit** server,
+  another host, or `local` (no remote) — parsed from the remote URL.
+- **zgit server listing.** A footer line in the GIT panel lists the bare repos on
+  the self-hosted zgit Docker container (`docker exec -u git <container> ls
+  /repos`). Local-only, no network; fails soft (the line is hidden) when Docker
+  or the container is unavailable. Container name via `--zgit` / config
+  `zgitContainer` (default `zgit`).
+
+### Changed
+- **The GIT panel is now cwd-independent.** It scans a fixed, configured list of
+  paths instead of the parent of the current directory, so the report is the
+  same in every terminal/tab. Each `--repos` entry may be a repo itself or a
+  folder whose subdirectories are repos; entries are merged and de-duplicated.
+- `--repos` now accepts a comma-separated list and is persisted to
+  `~/.config/lattice/config.json` (`repoRoots`). With no flag and no saved list,
+  it falls back to the parent of the cwd (previous behaviour).
+
 ## [1.0.0] — 2026-06-24
 
 First open-source release as **lattice** — a full rewrite of the project

package/README.md

@@ -21,7 +21,14 @@ your Mac.
 
 ## Install & run
 
-No install needed — run it straight from npm:
+`@zeluizr/lattice` is a **private** npm package. Log in to an npm account that
+has access to it first:
+
+```bash
+npm login
+```
+
+Then run it straight from npm:
 
 ```bash
 npx @zeluizr/lattice
@@ -34,6 +41,10 @@ npm i -g @zeluizr/lattice
 lattice
 ```
 
+> **Access:** the package is published with `access: restricted`. The owner
+> grants teammates access with `npm access grant read-only <user> @zeluizr/lattice`
+> (or by publishing under an npm **org** scope and adding them to a team).
+
 On first run, lattice asks for your language (English · Español · Português) and
 remembers it. Watts need `sudo` (see below); everything else works without it.
 

package/dist/app.js

@@ -5,6 +5,7 @@ import { Panel } from "./components/Panel.js";
 import { SystemCollector } from "./collectors/system.js";
 import { DisksCollector } from "./collectors/disks.js";
 import { GitCollector } from "./collectors/git.js";
+import { ZgitCollector } from "./collectors/zgit.js";
 import { readGpu } from "./collectors/gpu.js";
 import { readSensors } from "./collectors/sensors.js";
 import { PowerCollector } from "./collectors/power.js";
@@ -18,11 +19,12 @@ function timeStr() {
     return d.toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit", second: "2-digit" });
 }
 export function App(props) {
-    const { t, pal, icon, usePower, useVtex, gitDir, topN } = props;
+    const { t, pal, icon, usePower, useVtex, repoRoots, zgitContainer, topN } = props;
     const { exit } = useApp();
     const [sys, setSys] = useState(null);
     const [disks, setDisks] = useState(null);
     const [git, setGit] = useState(null);
+    const [zgit, setZgit] = useState(null);
     const [gpu, setGpu] = useState(null);
     const [sensors, setSensors] = useState(null);
     const [power, setPower] = useState(null);
@@ -40,6 +42,7 @@ export function App(props) {
     const sysRef = useRef(null);
     const disksRef = useRef(null);
     const gitRef = useRef(null);
+    const zgitRef = useRef(null);
     const tokRef = useRef(null);
     const powerRef = useRef(null);
     const pausedRef = useRef(false);
@@ -52,7 +55,8 @@ export function App(props) {
         mounted.current = true;
         sysRef.current = new SystemCollector(topN);
         disksRef.current = new DisksCollector();
-        gitRef.current = new GitCollector(gitDir);
+        gitRef.current = new GitCollector(repoRoots);
+        zgitRef.current = new ZgitCollector(zgitContainer);
         tokRef.current = new TokenCollector();
         if (usePower) {
             powerRef.current = new PowerCollector(Math.round(props.interval * 1000));
@@ -98,16 +102,18 @@ export function App(props) {
     const refreshAux = useCallback(async () => {
         if (pausedRef.current || !tokRef.current)
             return;
-        const [tk, vx, gt] = await Promise.all([
+        const [tk, vx, gt, zg] = await Promise.all([
             tokRef.current.read(),
             useVtex ? readVtex() : Promise.resolve(null),
             gitRef.current ? gitRef.current.read() : Promise.resolve(null),
+            zgitRef.current ? zgitRef.current.read() : Promise.resolve(null),
         ]);
         if (!mounted.current)
             return;
         setTokens(tk);
         setVtex(vx);
         setGit(gt);
+        setZgit(zg);
     }, [useVtex]);
     useEffect(() => {
         refreshData();
@@ -164,6 +170,22 @@ export function App(props) {
     const util = gpu?.utilPct ?? 0;
     const diskRows = disks?.disks ?? [];
     const gitRepos = git?.repos ?? [];
+    const zgitServer = zgit?.available ? zgit : null;
+    const showGit = gitRepos.length > 0 || !!zgitServer;
+    const hostLabel = (r) => r.hostKind === "github"
+        ? "GitHub"
+        : r.hostKind === "zgit"
+            ? "zgit"
+            : r.hostKind === "none"
+                ? t("git.local")
+                : r.host || "—";
+    const hostColor = (r) => r.hostKind === "github"
+        ? pal.purple
+        : r.hostKind === "zgit"
+            ? pal.orange
+            : r.hostKind === "none"
+                ? pal.comment
+                : pal.cyan;
     const tokTotal = tokens ? tokens.input + tokens.output + tokens.cacheW + tokens.cacheR : 0;
     const modelItems = Object.entries(tokens?.byModel ?? {}).sort((a, b) => b[1].cost - a[1].cost);
     const modelParts = modelItems.slice(0, 2).map(([k, v]) => `${k} $${v.cost.toFixed(2)}`);
@@ -189,8 +211,14 @@ export function App(props) {
                                     total: fmtTok(tokTotal),
                                     input: fmtTok(tokens?.input),
                                     output: fmtTok(tokens?.output),
-                                }) }), _jsx(Text, { wrap: "truncate", children: t("tokens.cache", { cw: fmtTok(tokens?.cacheW), cr: fmtTok(tokens?.cacheR) }) }), _jsx(Text, { wrap: "truncate", color: pal.comment, children: t("tokens.byModel", { models }) })] }), useVtex && (_jsx(Panel, { title: `${icon("vtex")} ${t("panel.vtex")}`, color: pal.purple, width: col2, children: !vtex ? (_jsx(Text, { color: pal.comment, children: t("spark.collecting") })) : !vtex.installed ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [t("vtex.status"), ": ", _jsx(Text, { color: pal.red, children: t("vtex.notInstalled") })] }), _jsx(Text, { wrap: "truncate", color: pal.comment, children: t("vtex.install") })] })) : vtex.loggedIn ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [t("vtex.status"), ": ", _jsx(Text, { color: pal.green, children: t("vtex.connected") })] }), _jsxs(Text, { wrap: "truncate", children: [t("vtex.account"), ": ", _jsx(Text, { bold: true, children: vtex.account })] }), _jsxs(Text, { wrap: "truncate", children: [t("vtex.user"), ": ", vtex.login || "—"] }), _jsxs(Text, { wrap: "truncate", children: [t("vtex.workspace"), ": ", vtex.workspace || "master"] })] })) : (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [t("vtex.status"), ": ", _jsx(Text, { color: pal.yellow, children: t("vtex.notConnected") })] }), _jsx(Text, { wrap: "truncate", color: pal.comment, children: t("vtex.signin") })] })) }))] }), gitRepos.length > 0 && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: pal.green, paddingX: 1, marginRight: 1, width: fullW, children: [_jsxs(Text, { color: pal.green, bold: true, wrap: "truncate", children: [icon("git"), " ", t("panel.git"), git?.truncated ? _jsx(Text, { color: pal.comment, children: " (+)" }) : null] }), _jsxs(Text, { color: pal.purple, bold: true, wrap: "truncate", children: [t("git.repo").padEnd(20), t("git.branch").padEnd(22), t("git.state")] }), gitRepos.map((r) => {
+                                }) }), _jsx(Text, { wrap: "truncate", children: t("tokens.cache", { cw: fmtTok(tokens?.cacheW), cr: fmtTok(tokens?.cacheR) }) }), _jsx(Text, { wrap: "truncate", color: pal.comment, children: t("tokens.byModel", { models }) })] }), useVtex && (_jsx(Panel, { title: `${icon("vtex")} ${t("panel.vtex")}`, color: pal.purple, width: col2, children: !vtex ? (_jsx(Text, { color: pal.comment, children: t("spark.collecting") })) : !vtex.installed ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [t("vtex.status"), ": ", _jsx(Text, { color: pal.red, children: t("vtex.notInstalled") })] }), _jsx(Text, { wrap: "truncate", color: pal.comment, children: t("vtex.install") })] })) : vtex.loggedIn ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [t("vtex.status"), ": ", _jsx(Text, { color: pal.green, children: t("vtex.connected") })] }), _jsxs(Text, { wrap: "truncate", children: [t("vtex.account"), ": ", _jsx(Text, { bold: true, children: vtex.account })] }), _jsxs(Text, { wrap: "truncate", children: [t("vtex.user"), ": ", vtex.login || "—"] }), _jsxs(Text, { wrap: "truncate", children: [t("vtex.workspace"), ": ", vtex.workspace || "master"] })] })) : (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [t("vtex.status"), ": ", _jsx(Text, { color: pal.yellow, children: t("vtex.notConnected") })] }), _jsx(Text, { wrap: "truncate", color: pal.comment, children: t("vtex.signin") })] })) }))] }), showGit && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: pal.green, paddingX: 1, marginRight: 1, width: fullW, children: [_jsxs(Text, { color: pal.green, bold: true, wrap: "truncate", children: [icon("git"), " ", t("panel.git"), git?.truncated ? _jsx(Text, { color: pal.comment, children: " (+)" }) : null] }), gitRepos.length > 0 && (_jsxs(Text, { color: pal.purple, bold: true, wrap: "truncate", children: [t("git.repo").padEnd(20), t("git.branch").padEnd(18), t("git.state").padEnd(10), t("git.host")] })), gitRepos.map((r) => {
                         const label = r.detached ? "(detached)" : r.branch;
-                        return (_jsxs(Text, { wrap: "truncate", children: [r.name.slice(0, 19).padEnd(20), label.slice(0, 21).padEnd(22), _jsxs(Text, { color: r.dirty ? pal.yellow : pal.green, children: ["\u25CF ", r.dirty ? t("git.dirty") : t("git.clean")] }), r.ahead > 0 ? _jsxs(Text, { color: pal.comment, children: ["  ", "\u2191", r.ahead] }) : null, r.behind > 0 ? _jsxs(Text, { color: pal.comment, children: ["  ", "\u2193", r.behind] }) : null] }, r.name));
-                    })] })), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: pal.comment, paddingX: 1, marginRight: 1, width: fullW, children: [_jsxs(Text, { color: pal.comment, bold: true, children: [icon("proc"), " ", t("panel.procs")] }), _jsxs(Text, { color: pal.purple, bold: true, wrap: "truncate", children: [t("proc.cpu").padEnd(6), t("proc.mem").padEnd(9), t("proc.pid").padEnd(8), t("proc.name")] }), (sys?.procs ?? []).map((p) => (_jsxs(Text, { wrap: "truncate", children: [`${p.cpu.toFixed(0)}%`.padEnd(6), humanBytes(p.rss).padEnd(9), String(p.pid).padEnd(8), p.name.slice(0, 30)] }, p.pid)))] }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: pal.comment, children: [_jsx(Text, { color: pal.pink, children: "q" }), " ", t("key.quit"), " \u00B7 ", _jsx(Text, { color: pal.pink, children: "p" }), " ", t("key.pause"), " \u00B7", " ", _jsx(Text, { color: pal.pink, children: "+/-" }), " ", t("key.faster"), "/", t("key.slower"), " \u00B7 ", interval.toFixed(2), "s"] }) })] }));
+                        return (_jsxs(Text, { wrap: "truncate", children: [r.name.slice(0, 19).padEnd(20), label.slice(0, 17).padEnd(18), _jsx(Text, { color: r.dirty ? pal.yellow : pal.green, children: "\u25CF" }), ` ${r.dirty ? t("git.dirty") : t("git.clean")}`.padEnd(9), _jsx(Text, { color: hostColor(r), children: hostLabel(r).slice(0, 10).padEnd(10) }), r.ahead > 0 ? _jsxs(Text, { color: pal.comment, children: [" \u2191", r.ahead] }) : null, r.behind > 0 ? _jsxs(Text, { color: pal.comment, children: [" \u2193", r.behind] }) : null] }, r.path));
+                    }), zgitServer && (_jsx(Text, { color: pal.comment, wrap: "truncate", children: zgitServer.repos.length
+                            ? t("git.server", {
+                                container: zgitServer.container,
+                                list: zgitServer.repos.join(", "),
+                                n: zgitServer.repos.length,
+                            })
+                            : t("git.serverEmpty", { container: zgitServer.container }) }))] })), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: pal.comment, paddingX: 1, marginRight: 1, width: fullW, children: [_jsxs(Text, { color: pal.comment, bold: true, children: [icon("proc"), " ", t("panel.procs")] }), _jsxs(Text, { color: pal.purple, bold: true, wrap: "truncate", children: [t("proc.cpu").padEnd(6), t("proc.mem").padEnd(9), t("proc.pid").padEnd(8), t("proc.name")] }), (sys?.procs ?? []).map((p) => (_jsxs(Text, { wrap: "truncate", children: [`${p.cpu.toFixed(0)}%`.padEnd(6), humanBytes(p.rss).padEnd(9), String(p.pid).padEnd(8), p.name.slice(0, 30)] }, p.pid)))] }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: pal.comment, children: [_jsx(Text, { color: pal.pink, children: "q" }), " ", t("key.quit"), " \u00B7 ", _jsx(Text, { color: pal.pink, children: "p" }), " ", t("key.pause"), " \u00B7", " ", _jsx(Text, { color: pal.pink, children: "+/-" }), " ", t("key.faster"), "/", t("key.slower"), " \u00B7 ", interval.toFixed(2), "s"] }) })] }));
 }

package/dist/cli.js

@@ -19,8 +19,13 @@ const cli = meow(`
   Options
     --no-power        skip powermetrics/sudo (CPU/GPU/RAM/disk/net only)
     --no-vtex         hide the VTEX panel (for non-VTEX users)
-    --repos           folder of git repos to show branches for
-                      (default: the parent of the current directory)
+    --repos           comma-separated folders and/or repos the GIT panel always
+                      shows, regardless of where lattice is launched. A path
+                      that is itself a repo is shown directly; otherwise its
+                      subdirectories are scanned. Saved to config once set.
+                      (default: saved list, else the parent of the current dir)
+    --zgit            Docker container of the self-hosted zgit server to list
+                      (default: zgit; the line is hidden when unavailable)
     --interval, -i    refresh interval in seconds (default 1)
     --procs, -n       number of top processes to show (default 8)
     --icons           icon style: nerd | emoji | none (default nerd)
@@ -40,6 +45,7 @@ const cli = meow(`
         power: { type: "boolean", default: true },
         vtex: { type: "boolean", default: true },
         repos: { type: "string", default: "" },
+        zgit: { type: "string", default: "" },
         interval: { type: "number", shortFlag: "i", default: 1 },
         procs: { type: "number", shortFlag: "n", default: 8 },
         icons: { type: "string", default: "" },
@@ -88,10 +94,37 @@ function resolveIcons() {
     }
     return loadConfig().icons ?? "nerd";
 }
+/** The fixed set of folders/repos the GIT panel scans — independent of cwd. */
+function resolveRepoRoots() {
+    const flag = cli.flags.repos.trim();
+    if (flag) {
+        const roots = flag.split(",").map((s) => s.trim()).filter(Boolean);
+        if (roots.length) {
+            saveConfig({ repoRoots: roots });
+            return roots;
+        }
+    }
+    const saved = loadConfig().repoRoots;
+    if (saved && saved.length)
+        return saved;
+    // First run / no config: fall back to the parent of the cwd so the tool still
+    // works out of the box. Pass --repos once to pin a stable, cwd-independent list.
+    return [dirname(process.cwd())];
+}
+function resolveZgitContainer() {
+    const flag = cli.flags.zgit.trim();
+    if (flag) {
+        saveConfig({ zgitContainer: flag });
+        return flag;
+    }
+    return loadConfig().zgitContainer ?? "zgit";
+}
 async function main() {
     const lang = await resolveLang();
     const variant = resolveTheme();
     const iconMode = resolveIcons();
+    const repoRoots = resolveRepoRoots();
+    const zgitContainer = resolveZgitContainer();
     const t = makeT(lang);
     const pal = palette(variant);
     const icon = makeIcons(iconMode);
@@ -107,7 +140,7 @@ async function main() {
             usePower = false;
         }
     }
-    const { waitUntilExit } = render(_jsx(App, { t: t, pal: pal, icon: icon, lang: lang, usePower: usePower, useVtex: cli.flags.vtex, gitDir: cli.flags.repos || dirname(process.cwd()), interval: cli.flags.interval, topN: cli.flags.procs }));
+    const { waitUntilExit } = render(_jsx(App, { t: t, pal: pal, icon: icon, lang: lang, usePower: usePower, useVtex: cli.flags.vtex, repoRoots: repoRoots, zgitContainer: zgitContainer, interval: cli.flags.interval, topN: cli.flags.procs }));
     await waitUntilExit();
 }
 main().catch((e) => {

package/dist/collectors/git.js

@@ -1,10 +1,14 @@
 /**
- * Active git branches for the repos in a folder (no sudo).
+ * Active git branches for a fixed, configured set of repos (no sudo).
  *
- * Scans the immediate subdirectories of `root`, keeps the ones that are git
- * repositories, and reports each repo's current branch plus its state —
- * dirty/clean and ahead/behind its upstream — from a single
- * `git status --porcelain=v2 --branch` per repo.
+ * Each configured root is either a repo itself (it has a `.git`) or a folder
+ * whose immediate subdirectories are repos. Both shapes are merged and
+ * de-duplicated by absolute path, so the report is the SAME no matter which
+ * directory lattice was launched from — it does not depend on the cwd.
+ *
+ * Each repo reports its branch, dirty/ahead/behind state (from a single
+ * `git status --porcelain=v2 --branch`) and where its `origin` is hosted —
+ * GitHub vs the self-hosted zgit server vs another host — from its remote URL.
  *
  * Cheap to discover (one readdir + a stat per child) but each repo costs a git
  * invocation, so we cap the count, bound concurrency, and skip overlapping
@@ -19,24 +23,19 @@ const run = promisify(execFile);
 const MAX_REPOS = 24;
 const CONCURRENCY = 8;
 export class GitCollector {
-    root;
+    roots;
     inflight = false;
     last;
-    constructor(root) {
-        this.root = root;
-        this.last = { root, repos: [], truncated: false };
+    constructor(roots) {
+        this.roots = roots;
+        this.last = { roots, repos: [], truncated: false };
     }
     async read() {
         if (this.inflight)
             return this.last;
         this.inflight = true;
         try {
-            const entries = await readdir(this.root, { withFileTypes: true }).catch(() => []);
-            const dirs = entries
-                .filter((e) => e.isDirectory() && !e.name.startsWith("."))
-                .map((e) => join(this.root, e.name))
-                .filter((p) => existsSync(join(p, ".git")))
-                .sort();
+            const dirs = await this.discover();
             const truncated = dirs.length > MAX_REPOS;
             const pick = dirs.slice(0, MAX_REPOS);
             const repos = [];
@@ -48,7 +47,7 @@ export class GitCollector {
                         repos.push(r);
             }
             repos.sort((a, b) => a.name.localeCompare(b.name));
-            this.last = { root: this.root, repos, truncated };
+            this.last = { roots: this.roots, repos, truncated };
             return this.last;
         }
         catch {
@@ -58,17 +57,48 @@ export class GitCollector {
             this.inflight = false;
         }
     }
+    /** Resolve every configured root to a de-duplicated, sorted list of repo dirs. */
+    async discover() {
+        const seen = new Set();
+        const out = [];
+        const add = (p) => {
+            if (!seen.has(p)) {
+                seen.add(p);
+                out.push(p);
+            }
+        };
+        for (const root of this.roots) {
+            // A configured path can be a repo itself…
+            if (existsSync(join(root, ".git"))) {
+                add(root);
+                continue;
+            }
+            // …or a folder whose immediate children are repos.
+            const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+            for (const e of entries) {
+                if (!e.isDirectory() || e.name.startsWith("."))
+                    continue;
+                const p = join(root, e.name);
+                if (existsSync(join(p, ".git")))
+                    add(p);
+            }
+        }
+        return out.sort();
+    }
 }
 async function readRepo(dir) {
-    const { stdout } = await run("git", ["-C", dir, "status", "--porcelain=v2", "--branch"], {
-        maxBuffer: 1 << 20,
-    });
+    const [statusRes, urlRes] = await Promise.all([
+        run("git", ["-C", dir, "status", "--porcelain=v2", "--branch"], { maxBuffer: 1 << 20 }),
+        run("git", ["-C", dir, "remote", "get-url", "origin"], { maxBuffer: 1 << 16 }).catch(() => ({
+            stdout: "",
+        })),
+    ]);
     let branch = "?";
     let ahead = 0;
     let behind = 0;
     let detached = false;
     let dirty = false;
-    for (const ln of stdout.split("\n")) {
+    for (const ln of statusRes.stdout.split("\n")) {
         if (ln.startsWith("# branch.head ")) {
             branch = ln.slice("# branch.head ".length).trim();
             if (branch === "(detached)")
@@ -85,5 +115,21 @@ async function readRepo(dir) {
             dirty = true;
         }
     }
-    return { name: basename(dir), branch, ahead, behind, detached, dirty };
+    const { host, hostKind } = classifyHost(urlRes.stdout.trim());
+    return { name: basename(dir), path: dir, branch, ahead, behind, detached, dirty, host, hostKind };
+}
+/** Pull the hostname out of an origin URL and bucket it into a known host. */
+export function classifyHost(url) {
+    if (!url)
+        return { host: "", hostKind: "none" };
+    // https://host/…, ssh://git@host/…  or scp-like  git@host:path
+    const scheme = url.match(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?([^/:]+)/i);
+    const scp = url.match(/^[^/@]+@([^:/]+):/);
+    const host = (scheme?.[1] || scp?.[1] || "").toLowerCase();
+    let hostKind = "other";
+    if (host.endsWith("github.com"))
+        hostKind = "github";
+    else if (host.includes("zgit"))
+        hostKind = "zgit";
+    return { host, hostKind };
 }

package/dist/collectors/zgit.js

@@ -0,0 +1,42 @@
+/**
+ * Bare repos living on the self-hosted zgit server (a Docker container).
+ *
+ * Lists `/repos/*.git` from inside the container with a single
+ * `docker exec -u git <container> ls -1 /repos`. This is a local call (no
+ * network) and fails soft: if Docker is missing or the container is stopped,
+ * it reports `available: false` and the panel simply omits the server line.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const run = promisify(execFile);
+export class ZgitCollector {
+    container;
+    inflight = false;
+    last;
+    constructor(container) {
+        this.container = container;
+        this.last = { available: false, container, repos: [] };
+    }
+    async read() {
+        if (!this.container || this.inflight)
+            return this.last;
+        this.inflight = true;
+        try {
+            const { stdout } = await run("docker", ["exec", "-u", "git", this.container, "ls", "-1", "/repos"], { maxBuffer: 1 << 16, timeout: 4000 });
+            const repos = stdout
+                .split("\n")
+                .map((s) => s.trim())
+                .filter((s) => s.endsWith(".git"))
+                .map((s) => s.replace(/\.git$/, ""))
+                .sort();
+            this.last = { available: true, container: this.container, repos };
+        }
+        catch {
+            this.last = { available: false, container: this.container, repos: [] };
+        }
+        finally {
+            this.inflight = false;
+        }
+        return this.last;
+    }
+}

package/dist/config.js

@@ -20,6 +20,13 @@ export function loadConfig() {
             cfg.theme = raw.theme;
         if (raw.icons === "nerd" || raw.icons === "emoji" || raw.icons === "none")
             cfg.icons = raw.icons;
+        if (Array.isArray(raw.repoRoots)) {
+            const roots = raw.repoRoots.filter((r) => typeof r === "string" && r.length > 0);
+            if (roots.length)
+                cfg.repoRoots = roots;
+        }
+        if (typeof raw.zgitContainer === "string" && raw.zgitContainer)
+            cfg.zgitContainer = raw.zgitContainer;
         return cfg;
     }
     catch {

package/dist/i18n/en.js

@@ -39,8 +39,12 @@ export const en = {
     "git.repo": "REPO",
     "git.branch": "BRANCH",
     "git.state": "STATE",
+    "git.host": "HOST",
     "git.clean": "clean",
     "git.dirty": "dirty",
+    "git.local": "local",
+    "git.server": "— zgit server ({container}): {list} ({n})",
+    "git.serverEmpty": "— zgit server ({container}): no repos",
     "gpu.usage": "Usage",
     "gpu.mem": "mem {used}/{alloc}",
     "temp.unavailable": "sensors unavailable",

package/dist/i18n/es.js

@@ -38,8 +38,12 @@ export const es = {
     "git.repo": "REPO",
     "git.branch": "BRANCH",
     "git.state": "ESTADO",
+    "git.host": "HOST",
     "git.clean": "limpio",
     "git.dirty": "sucio",
+    "git.local": "local",
+    "git.server": "— servidor zgit ({container}): {list} ({n})",
+    "git.serverEmpty": "— servidor zgit ({container}): sin repos",
     "gpu.usage": "Uso",
     "gpu.mem": "mem {used}/{alloc}",
     "temp.unavailable": "sensores no disponibles",

package/dist/i18n/pt-BR.js

@@ -38,8 +38,12 @@ export const ptBR = {
     "git.repo": "REPO",
     "git.branch": "BRANCH",
     "git.state": "ESTADO",
+    "git.host": "HOST",
     "git.clean": "limpo",
     "git.dirty": "sujo",
+    "git.local": "local",
+    "git.server": "— servidor zgit ({container}): {list} ({n})",
+    "git.serverEmpty": "— servidor zgit ({container}): sem repos",
     "gpu.usage": "Uso",
     "gpu.mem": "mem {used}/{alloc}",
     "temp.unavailable": "sensores indisponíveis",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeluizr/lattice",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Real-time terminal dashboard for macOS Apple Silicon — GPU, power, temperatures/fans, per-disk I/O (incl. /Volumes), network, memory, processes, and AI token cost.",
   "type": "module",
   "bin": {
@@ -49,6 +49,9 @@
   "bugs": {
     "url": "https://github.com/zeluizr/lattice/issues"
   },
+  "publishConfig": {
+    "access": "restricted"
+  },
   "scripts": {
     "build": "tsc && node scripts/postbuild.mjs",
     "build:native": "bash native/build.sh",