toolroll 0.9.45 → 0.9.47

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 0.9.47 — 2026-10-07
+
+- **Live tasks.** Task pages update live and show who else is viewing.
+- **Last activity.** Running tasks say what the agent did last and when
+  ("Ran the tests · 40 s ago"). After 5 minutes of silence they turn amber,
+  and they say "Worker offline" when it is.
+- **Flow cards** show their task's state: "Building · step 3 of 6",
+  "Stuck: …", "Waiting on you".
+- **Teammates.** People limited to some projects now get live flows and
+  presence.
+- **Refresh.** The task list, task pages and home refresh on their own,
+  with or without the chat open.
+- **One badge.** The Needs-you count is the same everywhere, and says which
+  projects it covers.
+
+## 0.9.46 — 2026-10-07
+
+- **Tokens from the terminal.** `toolroll tokens create|list|revoke|rotate`.
+  Creating or rotating asks for your password and shows the secret once.
+  Tokens can be limited to projects and always expire; rotating never
+  extends one. You're warned 7 days and 1 day before expiry.
+- **Request limits per token.** Too many requests get a 429 with
+  Retry-After. Owners change the limits in the console.
+- **`toolroll audit`** and the People page show who did what remotely, with
+  which token, and how it went. People see only their own.
+- **A real domain, safely.** HSTS only on the https public host. Tokens are
+  refused over plain HTTP from outside this machine or your tailnet.
+  `toolroll serve check-public` checks the setup; see docs/team-server.md.
+- **Agents sign in instead of pasting a token.** OAuth with PKCE and a
+  consent screen, short-lived tokens, and reuse detection. Pasted tokens
+  still work.
+- Still to come: `brief` and `spend` remotely for limited access.
+
 ## 0.9.45 — 2026-10-07
 
 - **Your projects, your lists.** People with access to some projects can now

package/dist/activity-line.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What a running agent did last, in one line (live tasks): "Ran a command ·
+ * 40 s ago". Pure and shared: the server sends the facts, and each page words
+ * them against its own clock, so the age keeps counting between reads.
+ *
+ * After five minutes with no word the line turns amber and says so; a worker
+ * whose heartbeat stopped says that instead, because a quiet agent and a
+ * machine that went away need different help.
+ */
+/** The facts behind the line: our own words for the last thing done (never a tool's arguments), when, and whether
+ * the worker running it still answers. */
+export type RunActivity = {
+    what: string;
+    at: string;
+    worker: "online" | "offline";
+};
+export declare const QUIET_AFTER_MS: number;
+/** The words for each fixed activity kind (live.ts's vocabulary) and for a progress checkpoint. */
+export declare const ACTIVITY_WORDS: Readonly<Record<string, string>>;
+/** "just now", "40 s ago", "3 min ago", "2 h ago". */
+export declare function agoWords(ms: number): string;
+/** The line itself, and whether it is quiet (amber): silent five minutes or more, or the worker is offline. */
+export declare function activityLine(activity: RunActivity, now: number): {
+    text: string;
+    quiet: boolean;
+};

package/dist/activity-line.js

@@ -0,0 +1,47 @@
+/**
+ * What a running agent did last, in one line (live tasks): "Ran a command ·
+ * 40 s ago". Pure and shared: the server sends the facts, and each page words
+ * them against its own clock, so the age keeps counting between reads.
+ *
+ * After five minutes with no word the line turns amber and says so; a worker
+ * whose heartbeat stopped says that instead, because a quiet agent and a
+ * machine that went away need different help.
+ */
+export const QUIET_AFTER_MS = 5 * 60_000;
+/** The words for each fixed activity kind (live.ts's vocabulary) and for a progress checkpoint. */
+export const ACTIVITY_WORDS = {
+    session: "Started work",
+    message: "Wrote an update",
+    edit: "Edited files",
+    command: "Ran a command",
+    read: "Read the code",
+    search: "Searched the code",
+    lookup: "Looked something up",
+    plan: "Updated its plan",
+    delegate: "Handed a step to a helper",
+    tool: "Used a tool",
+    progress: "Reported progress",
+    started: "Started",
+};
+/** "just now", "40 s ago", "3 min ago", "2 h ago". */
+export function agoWords(ms) {
+    const seconds = Math.max(0, Math.floor(ms / 1000));
+    if (seconds < 10)
+        return "just now";
+    if (seconds < 60)
+        return `${seconds} s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    return `${Math.floor(minutes / 60)} h ago`;
+}
+/** The line itself, and whether it is quiet (amber): silent five minutes or more, or the worker is offline. */
+export function activityLine(activity, now) {
+    const at = Date.parse(activity.at);
+    const since = Number.isNaN(at) ? 0 : Math.max(0, now - at);
+    if (activity.worker === "offline")
+        return { text: `Worker offline · last word ${agoWords(since)}`, quiet: true };
+    if (since >= QUIET_AFTER_MS)
+        return { text: `No word for ${Math.floor(since / 60_000)} min`, quiet: true };
+    return { text: `${activity.what} · ${agoWords(since)}`, quiet: false };
+}

package/dist/api-tokens.d.ts

@@ -1,4 +1,11 @@
 export type TokenAccess = "read" | "act";
+export type TokenPurpose = "api" | "mcp";
+export declare const MCP_ROTATION_REFUSAL = "Reconnect the MCP client to renew this token. You can still revoke it here.";
+/** Missing purpose is an old ordinary token; an unrecognised stored purpose is never treated as ordinary. */
+export declare const tokenPurpose: (value: unknown) => TokenPurpose;
+export declare const tokenRotationProblem: (token: {
+    purpose: TokenPurpose;
+}) => string | null;
 export declare const TOKEN_DAYS: readonly [30, 90, 365];
 export declare function mintApiToken(): {
     id: string;
@@ -14,3 +21,29 @@ export declare function parseApiToken(presented: string): {
 } | null;
 /** Whether the secret is the one whose hash was kept, in constant time. */
 export declare function secretMatches(secret: string, keptHash: string): boolean;
+/** v111: how long a rotated token keeps working beside its replacement, by default and at most. */
+export declare const ROTATION_OVERLAP_MINUTES = 10;
+export declare const ROTATION_OVERLAP_MAX_MINUTES = 60;
+/** v111: the person is told this many days before a token expires, once each. */
+export declare const EXPIRY_NOTICE_DAYS: readonly [7, 1];
+type TokenState = {
+    revokedAt: string | null;
+    expiresAt: string;
+    overlapUntil: string | null;
+};
+/** Whether a token signs anyone in at `now`: unrevoked, unexpired, and (once replaced) inside its overlap. */
+export declare function tokenLive(token: TokenState, now: number): boolean;
+/**
+ * The projects a token's person may use through it now: the person's current access, narrowed by the token's limit.
+ * Null is every project. A limit never widens access, and a project the person has lost stays lost.
+ */
+export declare function tokenProjects(account: readonly string[] | null, token: readonly string[] | null): string[] | null;
+/** Whether `projects` (a principal's) stays inside the token's limit. A limited token never stands for every project. */
+export declare function withinTokenLimit(projects: readonly string[] | null, limit: readonly string[] | null): boolean;
+/** Whole days until a token expires, rounded up (0 once it has). */
+export declare const daysLeft: (expiresAt: string, now: number) => number;
+/** The expiry notice a token is due at `now` (7 or 1 days), or null. Replaced and revoked tokens get none. */
+export declare function expiryNoticeDue(token: TokenState & {
+    replacedBy: string | null;
+}, now: number): (typeof EXPIRY_NOTICE_DAYS)[number] | null;
+export {};

package/dist/api-tokens.js

@@ -8,6 +8,10 @@
  * stay a person's act in the console.
  */
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+export const MCP_ROTATION_REFUSAL = "Reconnect the MCP client to renew this token. You can still revoke it here.";
+/** Missing purpose is an old ordinary token; an unrecognised stored purpose is never treated as ordinary. */
+export const tokenPurpose = (value) => value === undefined || value === "api" ? "api" : "mcp";
+export const tokenRotationProblem = (token) => token.purpose === "api" ? null : MCP_ROTATION_REFUSAL;
 export const TOKEN_DAYS = [30, 90, 365];
 const SHAPE = /^so_([a-f0-9]{12})_([A-Za-z0-9_-]{43})$/;
 export function mintApiToken() {
@@ -25,3 +29,38 @@ export function secretMatches(secret, keptHash) {
     const a = Buffer.from(hashSecret(secret), "hex"), b = Buffer.from(keptHash, "hex");
     return a.length === b.length && timingSafeEqual(a, b);
 }
+/** v111: how long a rotated token keeps working beside its replacement, by default and at most. */
+export const ROTATION_OVERLAP_MINUTES = 10;
+export const ROTATION_OVERLAP_MAX_MINUTES = 60;
+/** v111: the person is told this many days before a token expires, once each. */
+export const EXPIRY_NOTICE_DAYS = [7, 1];
+/** Whether a token signs anyone in at `now`: unrevoked, unexpired, and (once replaced) inside its overlap. */
+export function tokenLive(token, now) {
+    if (token.revokedAt !== null || !(Date.parse(token.expiresAt) > now))
+        return false;
+    return token.overlapUntil === null || Date.parse(token.overlapUntil) > now;
+}
+/**
+ * The projects a token's person may use through it now: the person's current access, narrowed by the token's limit.
+ * Null is every project. A limit never widens access, and a project the person has lost stays lost.
+ */
+export function tokenProjects(account, token) {
+    if (token === null)
+        return account === null ? null : [...account];
+    return token.filter(repo => account === null || account.includes(repo));
+}
+/** Whether `projects` (a principal's) stays inside the token's limit. A limited token never stands for every project. */
+export function withinTokenLimit(projects, limit) {
+    if (limit === null)
+        return true;
+    return projects !== null && projects.every(repo => limit.includes(repo));
+}
+/** Whole days until a token expires, rounded up (0 once it has). */
+export const daysLeft = (expiresAt, now) => Math.max(0, Math.ceil((Date.parse(expiresAt) - now) / 86_400_000));
+/** The expiry notice a token is due at `now` (7 or 1 days), or null. Replaced and revoked tokens get none. */
+export function expiryNoticeDue(token, now) {
+    if (token.replacedBy !== null || !tokenLive(token, now))
+        return null;
+    const left = Date.parse(token.expiresAt) - now;
+    return EXPIRY_NOTICE_DAYS.filter(days => left <= days * 86_400_000).at(-1) ?? null;
+}

package/dist/audit-cli.d.ts

@@ -0,0 +1,17 @@
+import type { RemoteRun } from "./remote-run.js";
+import { type AuditAction, type AuditReader } from "./remote-audit.js";
+import type { Store } from "./store.js";
+export declare const AUDIT_USAGE = "Use audit [--person <name>] [--token <name>] [--source api|mcp] [--since <days>d] [--limit <n>] [--cursor <id>] [--json].";
+type AuditContext = {
+    store: Store;
+    write: (s: string) => void;
+    json: boolean;
+    now: Date;
+    principal?: RemoteRun;
+};
+/** The reader a run is: the machine's owner locally, else the remote caller with their role and projects. */
+export declare function readerOf(store: Store, remote: RemoteRun | undefined): AuditReader;
+export declare function auditCommand(positional: readonly string[], flags: Map<string, string | true>, context: AuditContext): number;
+/** One line per action: outcome first, then who, token, source, what and where. */
+export declare function auditLine(action: AuditAction): string;
+export {};

package/dist/audit-cli.js

@@ -0,0 +1,86 @@
+/**
+ * `toolroll audit`: who did what on this server with their API tokens (remote-audit.ts). On the server's own machine
+ * it lists everyone; run remotely it is the caller's own view — an approver sees everyone within their projects, a
+ * viewer only themselves. `--token` names a token locally; remotely, where `--token` is always a refused credential
+ * flag, the same filter is `--token-name`.
+ */
+import { basename } from "node:path";
+import { checkedEnvelopeJson } from "./contracts/cli.js";
+import { AUDIT_LIMIT, AUDIT_SOURCES, cursorOf, OWNER_READER, remoteAudit, sinceOf } from "./remote-audit.js";
+const EXIT = { ok: 0, usage: 2, refused: 3 };
+const COMMAND = "audit";
+const FLAGS = new Set(["person", "token", "token-name", "source", "since", "limit", "cursor", "json", "db"]);
+export const AUDIT_USAGE = "Use audit [--person <name>] [--token <name>] [--source api|mcp] [--since <days>d] [--limit <n>] [--cursor <id>] [--json].";
+/** The reader a run is: the machine's owner locally, else the remote caller with their role and projects. */
+export function readerOf(store, remote) {
+    if (remote === undefined)
+        return OWNER_READER;
+    const role = store.accountOf(remote.account)?.role ?? "viewer";
+    const all = remote.allows(null);
+    return { self: remote.account, everyone: role === "approver", repos: all ? null : store.knownRepos().filter(repo => remote.allows(repo)), unplaced: all };
+}
+export function auditCommand(positional, flags, context) {
+    const fail = (reason, message, code) => {
+        context.write(context.json ? checkedEnvelopeJson({ ok: false, command: COMMAND, reason, message }) : message);
+        return code;
+    };
+    const usage = (message) => fail("usage", `${message} ${AUDIT_USAGE}`, EXIT.usage);
+    for (const name of flags.keys())
+        if (!FLAGS.has(name))
+            return usage(`--${name} is not an audit option.`);
+    if (positional.length > 0)
+        return usage("audit takes no arguments.");
+    const value = (name) => {
+        const one = flags.get(name);
+        return one === undefined ? null : typeof one === "string" && one !== "" ? one : undefined;
+    };
+    const person = value("person"), source = value("source"), since = value("since"), limit = value("limit"), cursor = value("cursor");
+    const tokenFlag = value("token"), tokenName = value("token-name");
+    for (const [name, one] of [["person", person], ["token", tokenFlag], ["token-name", tokenName], ["source", source], ["since", since], ["limit", limit], ["cursor", cursor]]) {
+        if (one === undefined)
+            return usage(`--${name} needs a value.`);
+    }
+    if (tokenFlag !== null && tokenName !== null && tokenFlag !== tokenName)
+        return usage("Name one token.");
+    const token = tokenFlag ?? tokenName ?? null;
+    if (token !== null && /^so_[a-f0-9]{12}_/.test(token))
+        return usage("Name the token (as shown in Settings), never its secret.");
+    if (source !== null && !AUDIT_SOURCES.includes(source))
+        return usage("--source is api or mcp.");
+    const from = since === null ? null : sinceOf(since, context.now);
+    if (since !== null && from === null)
+        return usage("--since is a number of days, like 7d.");
+    const size = limit === null ? AUDIT_LIMIT.default : /^[1-9][0-9]{0,2}$/.test(limit) && Number(limit) <= AUDIT_LIMIT.max ? Number(limit) : null;
+    if (size === null)
+        return usage(`--limit is 1 to ${AUDIT_LIMIT.max}.`);
+    const before = cursor === null ? null : cursorOf(cursor);
+    if (cursor !== null && before === null)
+        return usage("--cursor is the nextCursor of an earlier page.");
+    const filters = { person: person ?? null, token, source: (source ?? null), since: from };
+    const page = remoteAudit(context.store, readerOf(context.store, context.principal), filters, { limit: size, before });
+    if (!page.ok)
+        return fail(page.reason, page.message, EXIT.refused);
+    if (context.json) {
+        context.write(checkedEnvelopeJson({ ok: true, command: COMMAND, filters, actions: page.actions, limit: page.limit, nextCursor: page.nextCursor }));
+        return EXIT.ok;
+    }
+    const lines = page.actions.length === 0 ? ["No remote actions."] : page.actions.map(auditLine);
+    if (page.nextCursor !== null)
+        lines.push(`Older: toolroll audit --cursor ${page.nextCursor}${flagsAgain(flags)}`);
+    context.write(lines.join("\n"));
+    return EXIT.ok;
+}
+/** One line per action: outcome first, then who, token, source, what and where. */
+export function auditLine(action) {
+    const outcome = action.outcome === "ok" ? "ok" : `${action.outcome}${action.reason === null ? "" : ` (${action.reason})`}`;
+    const where = action.repo === null ? "" : `  ${basename(action.repo)}`;
+    return `${action.at.slice(0, 16).replace("T", " ")}  ${outcome}  ${action.person}  ${action.token ?? "unknown token"}  ${action.source}  ${action.name}${where}`;
+}
+/** The filters again for the next page, quoted when they need it. */
+function flagsAgain(flags) {
+    const quote = (one) => /^[A-Za-z0-9_./:@-]+$/.test(one) ? one : `'${one.replaceAll("'", "'\\''")}'`;
+    return ["person", "token", "token-name", "source", "since", "limit"].flatMap(name => {
+        const one = flags.get(name);
+        return typeof one === "string" ? [` --${name} ${quote(one)}`] : [];
+    }).join("");
+}