@timqi/pier 0.0.3 → 0.0.4

package/README.md

@@ -26,7 +26,7 @@ versioned from `0.0.1` on — earlier databases are not migrated. Read
 
 ```sh
 npm install -g @timqi/pier
-pier
+pier serve
 ```
 
 It listens on `127.0.0.1:3141` (`PORT`, `HOST`) and keeps everything under
@@ -57,7 +57,7 @@ installation. By default it is `$PIER_HOME/pi` (`~/.pier/pi`). Set
 an existing Pi setup:
 
 ```sh
-PI_CODING_AGENT_DIR="$HOME/.pi/agent" pier
+PI_CODING_AGENT_DIR="$HOME/.pi/agent" pier serve
 ```
 
 Console → Settings is the normal setup path:
@@ -68,8 +68,9 @@ Console → Settings is the normal setup path:
 - **Agent files** edits `SYSTEM.md`, `AGENTS.md`, `settings.json`, and advanced
   `models.json` structure in the Pi agent directory — globally, or per project
   scope, where it also shows that project's `.pi/skills` and `.pi/extensions`
-  resources. Changes apply when a session next opens; `pier reload` recycles
-  idle, unwatched sessions so their next message uses the current files.
+  resources. Changes apply when a session next opens; saving here recycles the
+  idle ones for you, and **Settings → Instance → Reload** does it for files
+  something else changed — an agent, or an editor on the box.
 
 On first credential access, Pier imports an existing `auth.json` into its sealed
 store and renames the source to `auth.json.imported`. Literal provider keys left
@@ -109,8 +110,9 @@ find a version-managed one), a memory drop-in it never rewrites afterwards, and
 turns on linger so scheduled tasks survive your logout. Install also records the
 exact npm executable in a separate updater unit. Re-run `pier service install
 --force` after changing the service settings or its Node/npm installation; this
-rewrites both units and restarts Pier. On macOS run `pier` in a terminal, or
-under whatever supervisor you already use.
+rewrites both units and restarts Pier. On macOS run `pier serve` in a terminal,
+or under whatever supervisor you already use — `pier` on its own only prints
+the usage.
 
 `docs/deploy.md` is the same thing written out by hand, plus what the memory
 limits mean, how updates work (and why the updater is a second unit), how to

package/dist/cli.js

@@ -15,7 +15,7 @@ const version = currentVersion();
 const HELP = `pier ${version} — a self-hosted workspace for coding agents
 
 Usage
-  pier                        run the workbench in this terminal
+  pier serve                  run the workbench in this terminal
   pier service install        write and start a systemd user unit (Linux)
   pier service uninstall      stop it and remove the unit
   pier service status         what systemd thinks of it
@@ -76,7 +76,15 @@ else if (values.version || command === "version") {
     process.stdout.write(`${version}\n`);
 }
 else if (!command) {
-    allowOnly([], "pier");
+    // Typing the bare name is how someone finds out what this is, so it answers
+    // that and nothing else: it used to start a server, which is a surprising
+    // amount to have done by accident.
+    process.stdout.write(HELP);
+}
+else if (command === "serve") {
+    if (subcommand)
+        fail(`unexpected argument "${subcommand}"`);
+    allowOnly([], "pier serve");
     // The server starts on import; this file stays a dispatcher.
     await import("./main.js");
 }
@@ -191,8 +199,8 @@ async function service(action = "status") {
     const systemdAction = action === "install" || action === "uninstall";
     if (systemdAction && process.platform !== "linux") {
         process.stderr.write(`pier service is systemd, so Linux only — this is ${process.platform}.\n` +
-            `Run "pier" in a terminal, or under whatever supervisor you already use;\n` +
-            `it needs no arguments and keeps its state in $PIER_HOME (~/.pier).\n`);
+            `Run "pier serve" in a terminal, or under whatever supervisor you already\n` +
+            `use; it takes no arguments and keeps its state in $PIER_HOME (~/.pier).\n`);
         process.exit(2);
     }
     switch (action) {
@@ -211,6 +219,9 @@ async function service(action = "status") {
             if (!install({
                 execPath: process.execPath,
                 npmPath: commandPath("npm"),
+                // This command is typed in the operator's shell, so its PATH is the one
+                // they expect a turn's commands to see; the unit records it.
+                shellPath: process.env.PATH,
                 entry: fileURLToPath(new URL("./main.js", import.meta.url)),
                 host,
                 port,

package/dist/main.js

@@ -135,6 +135,16 @@ const startChannels = async () => {
     await deliverLedger(restartLedger, (entry) => channels.notify(entry.channelId, entry.conversationId, entry.note))
         .catch((err) => log.error("restart-note delivery failed", err));
 };
+/** What "reload" means, in one place: the adapters re-read their configuration
+ * and sessions are let go, so the next message re-opens them with the current
+ * skills, extensions, prompts and credentials — all applied at attach, none
+ * stored in a transcript. SIGHUP (`pier reload`) and the Console's Reload are
+ * both this call; `includeWatched` is the only difference, and only because the
+ * Console knows a person asked from the session they are looking at. */
+const reloadInstance = async (includeWatched = false) => {
+    await channels.reload();
+    return router.evictIdle(0, Date.now(), { includeWatched });
+};
 void secrets.unlock().then(startChannels, (err) => log.error("secrets locked — channels not started; unlock from Console → Settings → Security, or repair master.key", err));
 // Replacing Pier is systemd's job, not this process's: the oneshot unit stops
 // the service, snapshots the database, installs and starts it again. Without
@@ -261,6 +271,7 @@ app.route("/", createServer({
     updater,
     // Unlocked from the Console: start the channels boot held back.
     onUnlocked: () => void startChannels(),
+    reload: () => reloadInstance(true),
     backgroundRuns: (id) => tasks.backgroundRuns(id),
 }));
 const port = Number(process.env.PORT ?? 3141);
@@ -327,19 +338,16 @@ process.on("SIGUSR2", () => {
         .catch((err) => log.error("drain failed — shutting down anyway", err))
         .then(() => shutdown(false));
 });
-// Reload without a restart (`pier reload`): adapters re-read their config, and
-// idle sessions are let go so the next message re-opens them with the current
-// skills, extensions and prompts — all applied at attach, none stored in a
-// transcript. Streaming or watched sessions pick the change up at their next
-// natural eviction. Only under systemd (the CLI signals through systemctl):
-// a foreground `pier` keeps SIGHUP's default, dying with its terminal instead
-// of surviving as an orphan that holds the port.
+// Reload without a restart (`pier reload`): reloadInstance above, leaving the
+// sessions someone is watching alone — nobody asked from a browser here.
+// Only under systemd (the CLI signals through systemctl): a foreground `pier
+// serve` keeps SIGHUP's default, dying with its terminal instead of surviving
+// as an orphan that holds the port.
 if (process.env.INVOCATION_ID) {
     process.on("SIGHUP", () => {
         log.info("SIGHUP received, reloading channels and recycling idle sessions");
-        void channels.reload();
-        void router.evictIdle(0)
+        void reloadInstance()
             .then((n) => log.info(`recycled ${String(n)} idle session(s)`))
-            .catch((err) => log.error("session recycle failed", err));
+            .catch((err) => log.error("reload failed", err));
     });
 }

package/dist/service.js

@@ -36,8 +36,22 @@ function quote(value, command = false) {
     return `"${escaped}"`;
 }
 const environment = (key, value) => `Environment=${quote(`${key}=${value}`)}`;
+/** The PATH both units carry: the recorded node first, then the shell that ran
+ * the install (`pier service install` is typed in that shell, so its own PATH
+ * *is* the login one), with the standard directories as a floor.
+ *
+ * Recorded at install rather than sourced from a login shell at start, which
+ * would hand a dotfile the power to decide whether Pier boots and which node
+ * npm installs into. Relative entries are dropped: they would resolve against
+ * WorkingDirectory, which is not where the operator was standing. */
+function pathEnv(execPath, shellPath) {
+    const seen = new Set();
+    return [dirname(execPath), ...(shellPath ?? "").split(":"), "/usr/local/bin", "/usr/bin", "/bin"]
+        .filter((dir) => dir.startsWith("/") && !/[\0\r\n]/.test(dir) && !seen.has(dir) && seen.add(dir))
+        .join(":");
+}
 export function renderUnit(options) {
-    const { execPath, entry, host, port, pierHome } = options;
+    const { execPath, entry, host, port, pierHome, shellPath } = options;
     return `[Unit]
 Description=Pier — agent workspace
 Documentation=https://github.com/timqi/pier
@@ -51,6 +65,10 @@ WorkingDirectory=%h
 # that installed Pier is usually not on it.
 ExecStart=${quote(execPath, true)} ${quote(entry, true)}
 ${environment("NODE_ENV", "production")}
+# Inherited by every command a turn runs, which is why it is here and not just
+# in the updater: an agent typing "npm test" on systemd's minimal PATH would be
+# told node does not exist on a machine that installed Pier with it.
+${environment("PATH", pathEnv(execPath, shellPath))}
 # Loopback by default. Put a reverse proxy in front before widening this —
 # whoever reaches this port can drive an agent that runs a shell.
 ${environment("HOST", host)}
@@ -89,7 +107,7 @@ function legacyOptions(home) {
 /** A separate cgroup stops Pier, takes a consistent backup, updates the exact
  * npm installation recorded at install time, and always starts Pier again. */
 export function renderUpdateUnit(options) {
-    const { execPath, npmPath, entry, pierHome } = options;
+    const { execPath, npmPath, entry, pierHome, shellPath } = options;
     const cli = join(dirname(entry), "cli.js");
     return `[Unit]
 Description=Update Pier to the latest published version
@@ -97,10 +115,14 @@ Documentation=https://github.com/timqi/pier
 
 [Service]
 Type=oneshot
+# The absolute node below answers npm's own shebang and nothing else: a
+# dependency's postinstall runs as "sh -c node scripts/postinstall", which
+# resolves node from PATH, and systemd's minimal PATH has no fnm/nvm node —
+# the install then dies with "node: not found" with the tree half written.
+${environment("PATH", pathEnv(execPath, shellPath))}
 ${pierHome ? `${environment("PIER_HOME", pierHome)}\n` : ""}ExecStart=systemctl --user stop ${UNIT_NAME}
 ExecStart=${quote(execPath, true)} ${quote(cli, true)} backup
-# npm runs under the recorded node: its shebang needs a node on PATH, and
-# systemd's minimal PATH has none for fnm/nvm installs.
+# npm runs under the recorded node: its shebang needs a node on PATH too.
 ExecStart=${quote(execPath, true)} ${quote(npmPath, true)} install -g @timqi/pier@latest
 # ExecStopPost runs on success and failure, so a failed backup or npm install
 # does not leave the previously working service stopped.

package/dist/web/explorer.js

@@ -92,13 +92,13 @@ export function registerExplorerRoutes(app) {
             return { name: line.slice(0, tab), subject: line.slice(tab + 1) };
         });
         // Unit/record separators, because a body is multi-line by nature.
-        const commits = (await git(root, "log", "-20", "--format=%h\u001f%at\u001f%an\u001f%s\u001f%b\u001e"))
+        const commits = (await git(root, "log", "-20", "--format=%h\u001f%at\u001f%an\u001f%ae\u001f%s\u001f%b\u001e"))
             .split("\u001e")
             .map((r) => r.trimStart())
             .filter(Boolean)
             .map((r) => {
-            const [hash = "", at = "", author = "", subject = "", body = ""] = r.split("\u001f");
-            return { hash, at: Number(at) * 1000, author, subject, body: body.trim() };
+            const [hash = "", at = "", author = "", email = "", subject = "", body = ""] = r.split("\u001f");
+            return { hash, at: Number(at) * 1000, author, email, subject, body: body.trim() };
         });
         return c.json({ branch, refs, commits });
     });