@paxnax/berliner 0.2.1 → 0.3.0

package/README.md

@@ -104,6 +104,8 @@ berliner report \
 
 Reporting again with the same `--session-id` replaces the values, adds PR URLs and skips evidence already uploaded. `--plan` is required unless `BERLINER_PLAN` is set.
 
+Evidence is private: only you can see it, signed in. Add `--public` to also make each `--evidence` file, new or already uploaded, viewable by anyone with its link. The report then prints one line per file to paste into a pull request body: a Markdown image (`![caption](https://berliner.app/v1/public/evidence/<id>)`), or the bare URL for a video, which GitHub does not embed from other hosts. With `--json` they are in `evidence.published`. Browsers and GitHub may keep a copy of a public file for up to 5 minutes after you make it private again.
+
 Inside Claude Code, Codex or OpenCode, leave out `--session-id`, `--repo`, `--cost`, `--model` and `--plan`. The CLI fills in the session id, cost and model from the tool's own records and the repository from git, and ignores an explicit `--session-id`, `--cost` or `--model` with one warning. The plan comes from `BERLINER_PLAN` or your subscriptions, as above. A report there without `--title` keeps the existing title; a new session takes the first line of your first prompt, cut to 80 characters.
 
 Other commands:
@@ -114,6 +116,7 @@ Other commands:
 - `berliner session <session-id>`: show one session.
 - `berliner summary [filters]`: totals for the same filters as `sessions`, then one line per subscription.
 - `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 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`.
 

package/dist/args.js

@@ -16,6 +16,7 @@ const config = {
         coverage: { type: "string" },
         pr: { type: "string", multiple: true },
         evidence: { type: "string", multiple: true },
+        public: { type: "boolean" },
         json: { type: "boolean" },
         strict: { type: "boolean" },
         help: { type: "boolean" },

package/dist/client.js

@@ -9,6 +9,7 @@ export class CliError extends Error {
         this.details = details;
     }
 }
+export const absolute = (cfg, path) => cfg.url.replace(/\/+$/, "") + path;
 export async function request(cfg, method, path, body, opts = {}) {
     const { timeoutMs = 10_000, retries = 3, deadlineMs = 15_000, auth = true } = opts;
     if (auth && !cfg.token)
@@ -22,7 +23,7 @@ export async function request(cfg, method, path, body, opts = {}) {
         const canRetry = () => attempt < retries && Date.now() + backoffMs < deadline;
         let res;
         try {
-            res = await fetch(cfg.url.replace(/\/+$/, "") + path, {
+            res = await fetch(absolute(cfg, path), {
                 method,
                 headers: {
                     ...(auth ? { Authorization: `Bearer ${cfg.token}` } : {}),

package/dist/commands/delete.js

@@ -8,7 +8,7 @@ export async function del(cfg, values, positionals) {
     if (evidenceId) {
         // Evidence ids are global, so the session named on the command line must actually hold this one.
         const { json } = await request(cfg, "GET", `/v1/sessions/${encodeURIComponent(id)}`);
-        if (!json.session.evidence.some((e) => String(e.id) === evidenceId)) {
+        if (!json.session.evidence.some((e) => e.id === evidenceId)) {
             throw new CliError(`evidence ${evidenceId} is not part of session ${id}`, "usage");
         }
     }

package/dist/commands/evidence.js

@@ -0,0 +1,14 @@
+import { absolute, CliError, request } from "../client.js";
+import { embed, print } from "../output.js";
+export async function evidence(cfg, values, positionals) {
+    const [action, id] = positionals;
+    if (positionals.length !== 2 || (action !== "public" && action !== "private")) {
+        throw new CliError("usage: berliner evidence public|private <id> [--json]", "usage");
+    }
+    const { json } = await request(cfg, "PATCH", `/v1/evidence/${encodeURIComponent(id)}`, { public: action === "public" });
+    const e = json.evidence;
+    const url = e.public_url && absolute(cfg, e.public_url);
+    const markdown = url && embed(e, url);
+    const text = !url ? `Evidence ${e.id} is private.` : markdown === url ? url : `${url}\n${markdown}`;
+    print({ data: json, text }, values.json === true);
+}

package/dist/commands/report.js

@@ -17,6 +17,8 @@ export async function report(cfg, values, positionals, env) {
     const missing = required.filter((flag) => values[flag] === undefined && !(flag === "plan" && cfg.plan) && !(tool && (flag === "plan" || flag === "cost")));
     if (missing.length)
         throw new CliError(`missing required flag(s): ${missing.map((f) => `--${f}`).join(", ")}`, "usage");
+    if (values.public && !values.evidence?.length)
+        throw new CliError("--public needs --evidence", "usage");
     const body = { ...sessionBody(values), plan: cfg.plan ?? values.plan };
     const id = values["session-id"];
     const path = `/v1/sessions/${encodeURIComponent(id)}`;
@@ -37,11 +39,14 @@ export async function report(cfg, values, positionals, env) {
             print({ data: json, text }, true);
         return;
     }
-    const result = await uploadEvidence(cfg, id, values.evidence.map(parseEvidence));
+    const result = await uploadEvidence(cfg, id, values.evidence.map(parseEvidence), undefined, values.public === true);
     if (json_)
         print({ data: { ...json, evidence: result }, text }, true);
-    else
+    else {
         console.log(`Evidence: ${result.uploaded} uploaded, ${result.existing} already uploaded, ${result.skipped.length} skipped.`);
+        for (const p of result.published ?? [])
+            console.log(p.markdown);
+    }
     for (const s of result.skipped)
         warn(`${s.path}: ${s.reason}`);
 }

package/dist/commands/session.js

@@ -1,4 +1,4 @@
-import { CliError, request } from "../client.js";
+import { absolute, CliError, request } from "../client.js";
 import { mergeLabel, print } from "../output.js";
 export async function session(cfg, values, positionals) {
     if (positionals.length !== 1)
@@ -28,6 +28,6 @@ export async function session(cfg, values, positionals) {
         lines.push(`  ${p.url}  merge=${p.merge_state} ci=${p.ci_state}${p.tracked ? "" : " (not tracked)"}`);
     lines.push(`Evidence: ${s.evidence.length || "none"}`);
     for (const e of s.evidence)
-        lines.push(`  #${e.id} ${e.kind} ${e.filename}${e.caption ? ` - ${e.caption}` : ""}${e.status === "ready" ? "" : ` (${e.status})`}`);
+        lines.push(`  ${e.id} ${e.kind} ${e.filename}${e.caption ? ` - ${e.caption}` : ""}${e.status === "ready" ? "" : ` (${e.status})`}${e.public_url ? ` public ${absolute(cfg, e.public_url)}` : ""}`);
     print({ data: json, text: lines.join("\n") }, values.json === true);
 }

package/dist/commands/update.js

@@ -10,6 +10,8 @@ export async function update(cfg, values, positionals, env) {
     }
     if (values.evidence?.length)
         throw new CliError("update does not upload evidence; use report --evidence", "usage");
+    if (values.public)
+        throw new CliError("update does not publish evidence; use report --evidence --public, or berliner evidence public <id>", "usage");
     if (tool)
         values = await fromTool(tool, { ...values, "session-id": positionals[0] ?? values["session-id"] }, env, "update");
     const id = tool ? tool.sessionId : positionals[0];

package/dist/index.js

@@ -3,6 +3,7 @@
 import { parse } from "./args.js";
 import { CliError } from "./client.js";
 import { del } from "./commands/delete.js";
+import { evidence } from "./commands/evidence.js";
 import { hook } from "./commands/hook.js";
 import { report } from "./commands/report.js";
 import { session } from "./commands/session.js";
@@ -19,7 +20,7 @@ Commands:
   setup                 connect this terminal, install the CLI and skill [--yes --no-install --no-browser]
   report --session-id <id> --title <t> --repo <owner/name> --cost <usd> --model <m> --plan <p>
          [--task --task-url --project --started-at --ended-at --commits --coverage]
-         [--pr <url>[,merge=<state>][,ci=<state>]]... [--evidence <path>[::caption]]... [--json] [--strict]
+         [--pr <url>[,merge=<state>][,ci=<state>]]... [--evidence <path>[::caption]]... [--public] [--json] [--strict]
          inside Claude Code, Codex or OpenCode the session id, cost, model and repo are filled in,
          and the server picks the plan (BERLINER_PLAN overrides it)
   update <session-id>   same flags as report, all optional (no session id inside those tools)
@@ -27,6 +28,8 @@ Commands:
   session <session-id>  [--json]
   summary               same filters as sessions [--json]
   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]
   skill                 print the bundled SKILL.md
   hook <tool>           run by the hooks of claude-code, codex or opencode; reads the payload on stdin
 
@@ -34,7 +37,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", "skill", "hook"]);
+const handled = new Set(["setup", "report", "update", "sessions", "session", "summary", "delete", "evidence", "skill", "hook"]);
 const cfg = () => readConfig(process.env);
 try {
     if (args.values.help)
@@ -58,6 +61,8 @@ try {
         await summary(cfg(), args.values);
     else if (args.command === "delete")
         await del(cfg(), args.values, args.positionals);
+    else if (args.command === "evidence")
+        await evidence(cfg(), args.values, args.positionals);
     else if (args.command === "skill")
         skill();
     else

package/dist/output.js

@@ -5,6 +5,8 @@ export function print(result, json) {
 export function warn(msg) {
     console.error(`berliner: ${msg.replace(/\s*\n\s*/g, " ")}`);
 }
+// GitHub renders an image from Markdown but not a video from another host, so a video is its bare URL.
+export const embed = (e, url) => e.kind === "video" ? url : `![${(e.caption || e.filename).replace(/[[\]]/g, "\\$&")}](${url})`;
 // Same wording as the web's mergeLabel (app/src/web/format.ts).
 const MERGE = { open: "Open", merged: "Merged", closed: "Closed", none: "No PRs" };
 export const mergeLabel = (s) => s.pr_count > 1 ? `${s.merged_count} of ${s.pr_count} merged` : (MERGE[s.merge] ?? s.merge);

package/dist/upload.js

@@ -2,7 +2,8 @@ import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { open, stat } from "node:fs/promises";
 import path from "node:path";
-import { CliError, request } from "./client.js";
+import { absolute, CliError, request } from "./client.js";
+import { embed } from "./output.js";
 const TYPES = {
     ".png": "image/png",
     ".jpg": "image/jpeg",
@@ -15,23 +16,37 @@ const TYPES = {
 };
 // Evidence uploads are exempt from the 15 s report deadline (ruling R25).
 const LONG = { timeoutMs: 120_000, deadlineMs: 120_000 };
-export async function uploadEvidence(cfg, sessionId, files, budget = LONG) {
-    const result = { uploaded: 0, existing: 0, skipped: [] };
+export async function uploadEvidence(cfg, sessionId, files, budget = LONG, publish = false) {
+    const result = { uploaded: 0, existing: 0, skipped: [], ...(publish ? { published: [] } : {}) };
     let unreachable = null;
     for (const file of files) {
         if (unreachable) {
             result.skipped.push({ path: file.path, reason: unreachable });
             continue;
         }
+        let stage = "";
         try {
-            if (await uploadOne(cfg, sessionId, file, budget))
+            const { created, id } = await uploadOne(cfg, sessionId, file, budget);
+            if (created)
                 result.uploaded++;
             else
                 result.existing++;
+            if (result.published) {
+                stage = "not made public: ";
+                const { json } = await request(cfg, "PATCH", `/v1/evidence/${encodeURIComponent(id)}`, { public: true }, budget);
+                const url = absolute(cfg, json.evidence.public_url);
+                result.published.push({
+                    path: file.path,
+                    id,
+                    url,
+                    // The caption given now, since the server keeps an existing file's first caption.
+                    markdown: embed({ ...json.evidence, caption: file.caption ?? json.evidence.caption }, url),
+                });
+            }
         }
         catch (err) {
             // One bad file never fails the report.
-            const reason = err instanceof Error ? err.message : String(err);
+            const reason = stage + (err instanceof Error ? err.message : String(err));
             result.skipped.push({ path: file.path, reason });
             // The next file would wait out the same budget against the same server (anti-goal 1).
             if (err instanceof CliError && err.kind === "network")
@@ -40,7 +55,7 @@ export async function uploadEvidence(cfg, sessionId, files, budget = LONG) {
     }
     return result;
 }
-// Resolves true when uploaded, false when the server already had the content.
+// created is false when the server already had the content.
 async function uploadOne(cfg, sessionId, file, budget) {
     const contentType = TYPES[path.extname(file.path).toLowerCase()];
     if (!contentType)
@@ -60,9 +75,10 @@ async function uploadOne(cfg, sessionId, file, budget) {
         sha256: hash.digest("hex"),
         caption: file.caption,
     }, budget);
+    const id = json.evidence.id;
     if (json.status === "exists")
-        return false;
-    const base = `/v1/evidence/${json.evidence.id}`;
+        return { created: false, id };
+    const base = `/v1/evidence/${id}`;
     const handle = await open(file.path);
     try {
         const slice = async (start, length) => {
@@ -90,5 +106,5 @@ async function uploadOne(cfg, sessionId, file, budget) {
     finally {
         await handle.close();
     }
-    return true;
+    return { created: true, id };
 }

package/package.json

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

package/skill/SKILL.md

@@ -50,10 +50,21 @@ Report again with the same `--session-id` whenever something changes.
 - `--coverage <percent>`: from the test run's coverage summary.
 - `--pr <url>[,merge=<open|merged|closed>][,ci=<pending|running|passed|failed|none>]`: repeat per PR. URL from `gh pr view --json url`.
 - `--evidence <path>[::caption]`: repeat per screenshot or video.
+- `--public`: with `--evidence`, also make those files viewable without sign-in. See below.
 - `--task <id>`, `--task-url <url>`, `--project <name>`, `--started-at <ISO>`, `--ended-at <ISO>`.
 
 Quote any value that contains spaces.
 
+## Evidence in a pull request body
+
+Evidence is private by default: only the user can see it, signed in. GitHub can show only public files. To embed screenshots or videos in a PR body, report them with `--public`:
+
+```sh
+berliner report --evidence "./shots/after.png::Login page after the fix" --public
+```
+
+After the evidence line, it prints one line per file: `![Login page after the fix](https://berliner.app/v1/public/evidence/<id>)` for an image, the bare URL for a video. Paste those lines into the PR body as printed. Anyone with a link can view the file, so publish only what belongs in the PR. `berliner evidence private <id>` makes one private again; `berliner evidence public <id>` publishes one already uploaded. `berliner session <id>` lists the ids.
+
 ## Environment
 
 `berliner setup` stores the API token in a config file, so `BERLINER_TOKEN` is only needed to override it (a token from the Settings page at https://berliner.app). `BERLINER_URL` overrides the server address. `BERLINER_PLAN`, when the user sets it, replaces any `--plan`.
@@ -68,7 +79,7 @@ The session is saved first, then evidence is uploaded. Allow at least 10 minutes
 
 - Success prints what was saved, then an evidence line such as `Evidence: 1 uploaded, 0 already uploaded, 0 skipped.`
 - A line starting `berliner:` on stderr is a warning: the report may be incomplete (server unreachable, a file skipped). The command still exits 0, so it never fails your work (`--strict` makes failures exit 1). Re-run the same command; it is safe to repeat.
-- `--json` prints the saved session as JSON, plus an `evidence` field with `uploaded`, `existing` and `skipped` results when `--evidence` was given.
+- `--json` prints the saved session as JSON, plus an `evidence` field with `uploaded`, `existing` and `skipped` results when `--evidence` was given, and `published` (`path`, `id`, `url`, `markdown`) with `--public`.
 - To change a field later without resending everything, use `berliner update --commits 5` inside the tools, or `berliner update <session-id> --commits 5` outside them.
 
 ## Examples