@sealant/mend 0.1.1 → 0.3.0

package/README.md

@@ -31,14 +31,25 @@ mend sessions [--all] [--project p] [--json]
 mend status                           active sessions (alias of mend sessions)
 ```
 
+## Signing in
+
+```
+mend login                 # asks for the email + password of your Mend account, saves a token
+mend login --url https://mend.example.com --email you@example.com
+mend logout
+```
+
+The token is stored 0600 in the CLI config below; every command uses it until `mend logout`. On a
+dev instance with `MEND_STATIC_TOKEN` set, `MEND_TOKEN=<that value>` also works.
+
 ## Configuration
 
-| Source             | What                                              |
-| ------------------ | ------------------------------------------------- |
-| `MEND_URL`         | The Mend server (default `http://localhost:3105`) |
-| `MEND_TOKEN`       | Bearer token for that server                      |
-| `MEND_DETACH_KEY`  | Set to `none` when an outer multiplexer detaches  |
-| `~/.mend/cli.json` | `{ "url": ..., "token": ... }` — env vars win     |
+| Source                    | What                                                                                      |
+| ------------------------- | ----------------------------------------------------------------------------------------- |
+| `MEND_URL`                | The Mend server (default `http://localhost:3105`)                                         |
+| `MEND_TOKEN`              | Bearer token for that server (normally written by `mend login`)                           |
+| `MEND_DETACH_KEY`         | Set to `none` when an outer multiplexer detaches                                          |
+| `~/.config/mend/cli.json` | `{ "url": ..., "token": ... }` — env vars win; a pre-XDG `~/.mend/cli.json` keeps working |
 
 ## Herdr
 

package/dist/dashboard.js

@@ -43,8 +43,21 @@ const timeAgo = (iso) => {
 const WORKBENCH_KEY = ["workbench"];
 const fetchWorkbench = async (ctx) => {
     const projects = await ctx.api("GET", "/projects");
-    const fetched = await Promise.all(projects.map((project) => ctx.api("GET", `/projects/${project.id}`)));
-    return { projects, details: new Map(fetched.map((detail) => [detail.project.id, detail])) };
+    const [fetched, services] = await Promise.all([
+        Promise.all(projects.map((project) => ctx.api("GET", `/projects/${project.id}`))),
+        ctx.api("GET", "/services"),
+    ]);
+    const servicesBySession = new Map();
+    for (const service of services) {
+        const bucket = servicesBySession.get(service.sessionId) ?? [];
+        bucket.push(service);
+        servicesBySession.set(service.sessionId, bucket);
+    }
+    return {
+        projects,
+        details: new Map(fetched.map((detail) => [detail.project.id, detail])),
+        servicesBySession,
+    };
 };
 const itemKey = (item) => item.kind === "session"
     ? item.session.id
@@ -84,6 +97,7 @@ const deriveItems = (view, data) => {
             kind: "session",
             session,
             annotation: detail.annotations.find((a) => a.sessionId === session.id),
+            services: data.servicesBySession.get(session.id) ?? [],
         }));
     }
     const resuming = view.session;
@@ -100,7 +114,9 @@ const deriveItems = (view, data) => {
                 kind: "harness",
                 harness,
                 label: harness,
-                hint: "the conversation crosses as a distilled prompt",
+                hint: harness === "shell"
+                    ? "a bash in the worktree — resume either agent from inside"
+                    : "the conversation crosses as a distilled prompt",
             })),
         ];
     }
@@ -108,7 +124,9 @@ const deriveItems = (view, data) => {
         kind: "harness",
         harness,
         label: harness,
-        hint: `mend ${harness} — new worktree, recorded session`,
+        hint: harness === "shell"
+            ? "a plain bash session — new worktree, recorded"
+            : `mend ${harness} — new worktree, recorded session`,
     }));
 };
 // ─── rows: JSX spans instead of StyledText chunks ───────────────────────────
@@ -122,13 +140,20 @@ const Facts = ({ facts }) => {
         _jsxs("span", { children: [index > 0 ? _jsx("span", { fg: FAINT, children: " \u00B7 " }) : null, fact] }, index))) }));
 };
 const SessionRow = ({ item, selected, }) => {
-    const { session, annotation } = item;
+    const { session, annotation, services } = item;
     const color = STATUS_COLOR[session.status] ?? MUTED;
     const glyph = STATUS_GLYPH[session.status] ?? "·";
     const facts = [];
     const age = timeAgo(session.createdAt);
     if (age !== "")
         facts.push(_jsx("span", { fg: FAINT, children: age }));
+    // What runs right now: name :port → host port, observed state colored.
+    for (const service of services.slice(0, 2)) {
+        facts.push(_jsx("span", { fg: service.status === "reachable" ? GREEN : AMBER, children: `${service.label ?? service.id.slice(0, 6)} :${service.workspacePort ?? "?"}${service.protocol === "udp" ? "u" : ""}→${service.hostPort ?? "?"} ${service.status}` }));
+    }
+    if (services.length > 2) {
+        facts.push(_jsx("span", { fg: FAINT, children: `+${services.length - 2} services` }));
+    }
     if (session.label !== null)
         facts.push(_jsx("span", { fg: MUTED, children: session.label }));
     if (annotation !== undefined && annotation.openComments > 0) {

package/dist/dotfiles.js

@@ -0,0 +1,90 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * Local dotfiles scanning for `mend dotfiles sync`. This runs on the machine that HAS the
+ * files — the whole point: the Mend server may be a VPS whose home directory is a service
+ * account's, so contents are captured here and streamed to the server's per-user dotfiles store.
+ *
+ * The candidate list mirrors the product's curated set (plain configuration only — never keys,
+ * credential stores, or histories). The CLI stays dependency-light by design, so the list is
+ * duplicated here rather than imported from a workspace package.
+ */
+export const DOTFILE_CANDIDATES = [
+    {
+        group: "shell",
+        paths: [
+            ".zshrc",
+            ".zshenv",
+            ".zprofile",
+            ".bashrc",
+            ".bash_profile",
+            ".profile",
+            ".aliases",
+            ".config/fish/config.fish",
+            ".config/starship.toml",
+        ],
+    },
+    {
+        group: "git",
+        paths: [".gitconfig", ".gitignore_global", ".config/git/config", ".config/git/ignore"],
+    },
+    {
+        group: "editors",
+        paths: [".vimrc", ".ideavimrc", ".editorconfig", ".config/helix/config.toml"],
+    },
+    {
+        group: "terminal",
+        paths: [".tmux.conf", ".config/tmux/tmux.conf", ".inputrc", ".dir_colors"],
+    },
+    {
+        group: "tools",
+        paths: [
+            ".ripgreprc",
+            ".config/bat/config",
+            ".config/lazygit/config.yml",
+            ".config/mise/config.toml",
+            ".config/atuin/config.toml",
+            ".config/zellij/config.kdl",
+        ],
+    },
+];
+/** The per-file cap the server enforces; checked here so a mistake fails before the upload. */
+export const MAX_FILE_BYTES = 1024 * 1024;
+const statFile = (home, relative) => {
+    try {
+        const stat = fs.statSync(path.join(home, relative));
+        return stat.isFile() ? stat : null;
+    }
+    catch {
+        return null;
+    }
+};
+/** Probe the curated candidates under `home`; only existing regular files appear. */
+export const scanDotfileCandidates = (home) => DOTFILE_CANDIDATES.flatMap(({ group, paths }) => paths.flatMap((relative) => {
+    const stat = statFile(home, relative);
+    return stat === null ? [] : [{ path: relative, group, bytes: stat.size }];
+}));
+/**
+ * Read the selected paths for upload. Explicitly requested paths must exist (a typo should fail,
+ * not silently sync nothing); oversized files fail with the server's own rule. Modes ride along
+ * so an executable script stays executable.
+ */
+export const readSyncFiles = (home, paths_) => {
+    const files = [];
+    for (const relative of paths_) {
+        const stat = statFile(home, relative);
+        if (stat === null) {
+            return { error: `${relative} is not a file under ${home}` };
+        }
+        if (stat.size > MAX_FILE_BYTES) {
+            return { error: `${relative} is over 1MB — dotfiles are text; trim the selection` };
+        }
+        files.push({
+            path: relative,
+            contentsBase64: fs.readFileSync(path.join(home, relative)).toString("base64"),
+            // eslint-disable-next-line no-bitwise -- permission bits are the point
+            mode: (stat.mode & 0o777).toString(8),
+        });
+    }
+    return { files };
+};

package/dist/env.js

@@ -0,0 +1,17 @@
+/**
+ * `mend env`: load a dotenv file into the project's env store, and show what is stored. Parsing
+ * AND routing happen SERVER-SIDE (one parser for the CLI and the browser); the CLI ships the file
+ * text once and prints the per-name report. Values are never printed.
+ */
+/** Render the report as terse status lines — names, lanes, actions, reasons; never a value. */
+export const formatLoadReport = (report, paint) => {
+    const width = Math.max(0, ...report.loaded.map((entry) => entry.name.length), ...report.rejected.map((entry) => entry.name.length));
+    const lines = [];
+    for (const entry of report.loaded) {
+        lines.push(`  ${entry.name.padEnd(width)}  ${entry.lane === "secret" ? "secret" : "configuration"} ${paint.dim(`· ${entry.action}${entry.lane === "configuration" ? " · plaintext" : ""}`)}`);
+    }
+    for (const entry of report.rejected) {
+        lines.push(`  ${entry.name.padEnd(width)}  ${paint.warn("rejected")} ${paint.dim(`· ${entry.reason}`)}`);
+    }
+    return lines;
+};