@paxnax/berliner 0.3.0 → 0.4.0

package/README.md

@@ -21,7 +21,7 @@ With Bun, run `bunx --bun @paxnax/berliner@latest setup`. To install only the co
    npx @paxnax/berliner@latest setup
    ```
 
-   It shows what it will do and asks once, then opens your browser so you can approve the connection. After you approve, it saves the token, installs the CLI globally, and installs the agent skill and a reporting hook for each of Claude Code, Codex and OpenCode that it finds. `--yes` skips the question, `--no-install` skips the global install, and `--no-browser` only prints the URL (over SSH, for example). Run `berliner setup` again to update the skill.
+   It shows what it will do and asks once, then opens your browser so you can approve the connection. After you approve, it saves the token, installs the CLI globally, and installs the agent skill and a reporting hook for each of Claude Code, Codex and OpenCode that it finds. `--yes` skips the question, `--no-install` skips the global install, and `--no-browser` only prints the URL (over SSH, for example). Run `berliner upgrade` to update the CLI and the skill to the latest release: it shows its plan and asks first, and a second question (or `--no-skill`) keeps your skill as it is.
 
 3. From then on, the hooks report each session's cost, model, repository, commits and start and end times after every reply. Your agent adds the task, pull requests, coverage and evidence with `berliner report`, as the skill tells it to. Codex runs a new hook only once you trust it: open `codex` once in a terminal and trust the Berliner hook.
 4. On **Settings**, list the subscriptions you pay for. Overview then compares each one with the sessions that ran on it.
@@ -118,6 +118,7 @@ Other commands:
 - `berliner delete <session-id>`: delete a session, or one item with `--evidence <id>`. Asks to confirm unless `--yes`.
 - `berliner evidence public <id>`: let anyone with the link view one file, and print its public URL and Markdown line. `berliner evidence private <id>` makes it private again. `berliner session` shows the ids, and the URL of each public file.
 - `berliner skill`: print the agent skill (`SKILL.md`) to install in your agent.
+- `berliner upgrade [--yes] [--no-skill]`: install the latest CLI and skill. It shows its plan (the versions, the exact install command and each skill file) and asks before changing anything; a second question, or `--no-skill`, leaves your skill as it is. Your token, config and hooks are never touched.
 - `berliner hook <tool>`: run by the hooks setup installs, with the tool's payload on stdin. It never prints, never fails and never makes the agent wait; errors go to `${XDG_STATE_HOME:-~/.local/state}/berliner/hook.log`.
 
 `report` and `update` exit 0 even when something fails, printing a warning that starts with `berliner:` to stderr, so reporting never breaks an agent's pipeline. Pass `--strict` to make them exit 1 on failure. The other commands exit 1 on failure.

package/dist/args.js

@@ -23,6 +23,7 @@ const config = {
         yes: { type: "boolean" },
         "no-install": { type: "boolean" },
         "no-browser": { type: "boolean" },
+        "no-skill": { type: "boolean" },
         run: { type: "string" },
         ci: { type: "string" },
         merge: { type: "string" },

package/dist/commands/setup.js

@@ -10,17 +10,23 @@ import { describeClaudeHooks, describeCodexHooks, describeOpenCodePlugin, instal
 import { claudeDir, codexDir, detectTools, onPath, opencodeDir, skillTargets } from "../setup/targets.js";
 // The same command the web guide shows.
 const TEST_REPORT = 'berliner report --session-id try-1 --title "First report" --repo you/app --cost 0.10 --model test --plan pro';
-const tilde = (p) => (p.startsWith(`${homedir()}/`) ? `~${p.slice(homedir().length)}` : p);
-export async function confirm(input, output) {
+export const tilde = (p) => (p.startsWith(`${homedir()}/`) ? `~${p.slice(homedir().length)}` : p);
+export async function confirm(input, output, question = "Continue? [Y/n] ") {
     const rl = createInterface({ input, output });
     // Ctrl+C and Ctrl+D reject the question without ending the line; both mean no.
-    const answer = await rl.question("Continue? [Y/n] ").catch(() => {
+    const answer = await rl.question(question).catch(() => {
         output.write("\n");
         return "n";
     });
     rl.close();
     return /^(y|yes)?$/i.test(answer.trim());
 }
+// Pinned to one version, so the command shown is the one run.
+export const installCommand = (version) => [...(process.versions.bun ? ["bun", "add", "-g"] : ["npm", "install", "-g"]), `@paxnax/berliner@${version}`];
+export function showPlan(title, steps) {
+    const plan = steps.flatMap((s, i) => [`  ${i + 1}. ${s.label}`, ...s.detail.map((d) => `       ${d}`)]);
+    console.log(["", title, "", "This will:", ...plan, ""].join("\n"));
+}
 // The login of the saved token, or null when there is none or the server no longer accepts it.
 async function savedLogin(url, token) {
     if (!token)
@@ -47,7 +53,7 @@ export async function setup(env, values) {
     };
     const hooks = tools.filter((t) => t.found).map((t) => ({ ...t, ...hookFiles[t.id] }));
     const version = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
-    const install = [...(process.versions.bun ? ["bun", "add", "-g"] : ["npm", "install", "-g"]), `@paxnax/berliner@${version}`];
+    const install = installCommand(version);
     // The plan is data, built and shown before anything changes.
     const steps = [
         ...(login
@@ -78,8 +84,7 @@ export async function setup(env, values) {
             }),
         },
     ];
-    const plan = steps.flatMap((s, i) => [`  ${i + 1}. ${s.label}`, ...s.detail.map((d) => `       ${d}`)]);
-    console.log(["", "Berliner setup", "", "This will:", ...plan, ""].join("\n"));
+    showPlan("Berliner setup", steps);
     if (!values.yes) {
         if (!process.stdin.isTTY)
             throw new CliError("There is no terminal to ask on. Run setup again with --yes to continue without asking.", "usage");

package/dist/commands/upgrade.js

@@ -0,0 +1,116 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { CliError } from "../client.js";
+import { detectTools, skillTargets } from "../setup/targets.js";
+import { confirm, installCommand, showPlan, tilde } from "./setup.js";
+async function latestVersion(env) {
+    const registry = (env.npm_config_registry || "https://registry.npmjs.org").replace(/\/+$/, "");
+    try {
+        const res = await fetch(`${registry}/@paxnax/berliner/latest`);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const { version } = (await res.json());
+        if (typeof version !== "string")
+            throw new Error("no version in the reply");
+        return version;
+    }
+    catch (err) {
+        throw new CliError(`Could not look up the latest berliner on ${registry} (${err.message}). Nothing was changed.`, "network");
+    }
+}
+// The skill text comes from the release being installed, so the plan's "already up to date" and what is written match it.
+function skillOf(version, bundled) {
+    if (bundled)
+        return readFileSync(new URL("../../skill/SKILL.md", import.meta.url), "utf8");
+    // --bun keeps the CLI on Bun: its shebang prefers node when both exist.
+    const [cmd, ...pre] = process.versions.bun ? ["bunx", "--bun"] : ["npx", "--yes"];
+    const run = spawnSync(cmd, [...pre, `@paxnax/berliner@${version}`, "skill"], { encoding: "utf8" });
+    if (run.status !== 0 || !run.stdout)
+        throw new CliError(`Could not read the skill of berliner ${version} (${(run.error?.message ?? run.stderr).trim() || `exited with ${run.status}`}). Nothing was changed.`, "network");
+    return run.stdout;
+}
+// Release versions only (x.y.z): the registry's latest tag never points at a prerelease.
+const newer = (a, b) => {
+    const [x, y] = [a, b].map((v) => v.split("-")[0].split(".").map(Number));
+    const i = x.findIndex((n, j) => n !== y[j]);
+    return i >= 0 && x[i] > y[i];
+};
+const sameAs = (path, text) => {
+    try {
+        return readFileSync(path, "utf8") === text;
+    }
+    catch {
+        return false;
+    }
+};
+// Only the command and the skill: the token, config and hooks are setup's, and stay as they are.
+export async function upgrade(env, values) {
+    const current = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
+    const latest = await latestVersion(env);
+    // A CLI ahead of the registry (a local build, a release still propagating) is never taken backwards, nor is its skill.
+    const installing = newer(latest, current);
+    const target = installing ? latest : current;
+    const install = installCommand(latest);
+    const tools = detectTools(env);
+    const targets = values["no-skill"] ? [] : skillTargets(tools, env);
+    const skill = targets.length ? skillOf(target, !installing) : "";
+    let stale = targets.filter((t) => !sameAs(t.path, skill));
+    if (!installing && !stale.length) {
+        console.log(`Already up to date. berliner ${current} is ${current === latest ? "the latest release" : `newer than the latest release (${latest})`}.`);
+        return;
+    }
+    showPlan("Berliner upgrade", [
+        {
+            label: installing
+                ? `Upgrade the berliner command from ${current} to ${latest}:  ${install.join(" ")}`
+                : current === latest
+                    ? `berliner ${current} is already the latest, nothing to install`
+                    : `berliner ${current} is newer than the latest release (${latest}), nothing to install`,
+            detail: [],
+        },
+        values["no-skill"]
+            ? { label: "Leave the Berliner skill as it is (--no-skill)", detail: [] }
+            : {
+                label: `Upgrade the Berliner skill to ${target} for:`,
+                detail: tools.map((tool) => {
+                    const target = targets.find((t) => t.tool === tool.id);
+                    const where = target ? `${tilde(target.path)}${stale.includes(target) ? "" : " (already up to date)"}` : "not found, skipped";
+                    return `${tool.name.padEnd(14)}${where}`;
+                }),
+            },
+    ]);
+    if (!values.yes) {
+        if (!process.stdin.isTTY)
+            throw new CliError("There is no terminal to ask on. Run upgrade again with --yes to continue without asking.", "usage");
+        if (!(await confirm(process.stdin, process.stdout)))
+            throw new CliError("Cancelled. Nothing was changed.", "usage");
+        // Without an install, the skill is all Continue covered.
+        if (installing && stale.length && !(await confirm(process.stdin, process.stdout, "Upgrade the skill too? [Y/n] ")))
+            stale = [];
+        console.log();
+    }
+    if (installing) {
+        const run = spawnSync(install[0], install.slice(1), { encoding: "utf8" });
+        if (run.status !== 0) {
+            console.error(`✗ Could not install the berliner command:\n${(run.error?.message ?? run.stdout + run.stderr).trimEnd()}`);
+            throw new CliError(`The skill was left as it is. Install the command yourself, then run upgrade again:  ${install.join(" ")}`, "usage");
+        }
+        console.log(`✓ Installed berliner ${latest}`);
+    }
+    // A file that can't be written (read-only, say) is reported and skipped, so the other tools still get theirs.
+    let unwritten = false;
+    for (const t of stale) {
+        const what = `${tools.find((tool) => tool.id === t.tool).name} skill`;
+        try {
+            mkdirSync(dirname(t.path), { recursive: true });
+            writeFileSync(t.path, skill);
+            console.log(`✓ ${what}: ${tilde(t.path)}`);
+        }
+        catch (err) {
+            unwritten = true;
+            console.error(`✗ ${what}: ${tilde(t.path)} can't be written (${err.message.split(",")[0]})`);
+        }
+    }
+    console.log(unwritten ? "\nSome files can't be written. Fix the ones marked ✗ above, then run upgrade again." : "\nDone.");
+}

package/dist/index.js

@@ -12,6 +12,7 @@ import { setup } from "./commands/setup.js";
 import { skill } from "./commands/skill.js";
 import { summary } from "./commands/summary.js";
 import { update } from "./commands/update.js";
+import { upgrade } from "./commands/upgrade.js";
 import { readConfig } from "./config.js";
 import { warn } from "./output.js";
 const usage = `Usage: berliner <command> [flags]
@@ -30,6 +31,7 @@ Commands:
   delete <session-id>   [--evidence <id>] [--yes]
   evidence public <id>  let anyone with the link view one file; prints its URL and Markdown [--json]
   evidence private <id> make it viewable only by you again [--json]
+  upgrade               install the latest CLI and skill [--yes --no-skill]
   skill                 print the bundled SKILL.md
   hook <tool>           run by the hooks of claude-code, codex or opencode; reads the payload on stdin
 
@@ -37,7 +39,7 @@ Environment: BERLINER_TOKEN, BERLINER_URL, BERLINER_PLAN (replaces --plan)`;
 const args = parse(process.argv.slice(2));
 // Reporting must never fail the agent's own pipeline unless it asks to (anti-goal 1).
 const softFail = (args.command === "report" || args.command === "update") && !args.values.strict;
-const handled = new Set(["setup", "report", "update", "sessions", "session", "summary", "delete", "evidence", "skill", "hook"]);
+const handled = new Set(["setup", "report", "update", "sessions", "session", "summary", "delete", "evidence", "skill", "hook", "upgrade"]);
 const cfg = () => readConfig(process.env);
 try {
     if (args.values.help)
@@ -65,6 +67,8 @@ try {
         await evidence(cfg(), args.values, args.positionals);
     else if (args.command === "skill")
         skill();
+    else if (args.command === "upgrade")
+        await upgrade(process.env, args.values);
     else
         throw new CliError(args.command ? `unknown command "${args.command}"` : "missing command", "usage");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paxnax/berliner",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Report coding-agent sessions to Berliner",
   "type": "module",
   "engines": {