hive-am 1.0.0 → 1.2.0

package/server/dist/errors.js

@@ -0,0 +1,11 @@
+export class DomainError extends Error {
+    kind;
+    code;
+    constructor(message, kind = 'invalid', code) {
+        super(message);
+        this.kind = kind;
+        this.code = code;
+    }
+}
+/** The HTTP status a kind maps to. */
+export const STATUS_OF_KIND = { invalid: 400, forbidden: 403, not_found: 404, conflict: 409, unavailable: 503 };

package/server/dist/git/browse.js

@@ -0,0 +1,99 @@
+import { execFile } from 'node:child_process';
+import { filesFromDiffTree, repoOf, resolveRef, run } from './ops.js';
+import { gitEnv, imageType, PathError, safePath } from './repo.js';
+const MAX_REFS = 1000;
+export async function gitRefs(cwd) {
+    const { root } = await repoOf(cwd);
+    const [heads, tags] = await Promise.all([
+        run(root, ['for-each-ref', '--sort=-committerdate', `--count=${MAX_REFS}`, '--format=%(refname)%1f%(refname:short)%1f%(objectname)%1f%(committerdate:iso-strict)%1f%(contents:subject)%1f%(HEAD)', 'refs/heads', 'refs/remotes']),
+        // For an annotated tag %(*objectname) is its commit; for a lightweight one %(objectname) already is.
+        run(root, ['for-each-ref', '--sort=-creatordate', `--count=${MAX_REFS}`, '--format=%(refname:strip=2)%1f%(*objectname)%1f%(objectname)%1f%(creatordate:iso-strict)%1f%(contents:subject)', 'refs/tags']),
+    ]);
+    const res = { current: null, branches: [], remotes: [], tags: [] };
+    for (const line of heads.out.split('\n').filter(Boolean)) {
+        const [ref, name, sha, date, subject, head] = line.split('\x1f');
+        if (ref.startsWith('refs/heads/')) {
+            res.branches.push({ name, sha, date, subject });
+            if (head === '*')
+                res.current = name;
+        }
+        else if (!ref.endsWith('/HEAD'))
+            res.remotes.push({ name, sha, date, subject });
+    }
+    for (const line of tags.out.split('\n').filter(Boolean)) {
+        const [name, peeled, direct, date, subject] = line.split('\x1f');
+        res.tags.push({ name, sha: peeled || direct, date, subject });
+    }
+    return res;
+}
+const MAX_COMPARE_FILES = 500, MAX_COMPARE_COMMITS = 100;
+/** What changed going from `base` to `head`: the files, and the commits in between. */
+export async function gitCompare(cwd, base, head) {
+    const { root } = await repoOf(cwd);
+    const [b, h] = [await resolveRef(root, base), await resolveRef(root, head)];
+    const [names, nums, ahead, behind, log] = await Promise.all([
+        run(root, ['diff-tree', '-r', '-M', '--name-status', '-z', '--no-commit-id', b, h], { raw: true }),
+        run(root, ['diff-tree', '-r', '-M', '--histogram', '--numstat', '-z', '--no-commit-id', b, h], { raw: true }),
+        run(root, ['rev-list', '--count', `${b}..${h}`]),
+        run(root, ['rev-list', '--count', `${h}..${b}`]),
+        run(root, ['log', `--max-count=${MAX_COMPARE_COMMITS + 1}`, '--format=%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1e', `${b}..${h}`]),
+    ]);
+    const files = filesFromDiffTree(names.out, nums.out);
+    const commits = log.out.split('\x1e').map((r) => r.trim()).filter(Boolean).map((r) => { const [sha, short, author, date, subject] = r.split('\x1f'); return { sha, short, author, date, subject }; });
+    return {
+        base: { ref: base, sha: b }, head: { ref: head, sha: h }, ahead: Number(ahead.out) || 0, behind: Number(behind.out) || 0,
+        commits: commits.slice(0, MAX_COMPARE_COMMITS), commitsTruncated: commits.length > MAX_COMPARE_COMMITS,
+        files: files.slice(0, MAX_COMPARE_FILES), truncated: files.length > MAX_COMPARE_FILES,
+    };
+}
+export async function gitCompareDiff(cwd, base, head, rel, oldRel) {
+    const { root } = await repoOf(cwd);
+    const [b, h] = [await resolveRef(root, base), await resolveRef(root, head)];
+    await safePath(cwd, root, rel, false);
+    if (oldRel)
+        await safePath(cwd, root, oldRel, false);
+    const { out } = await run(root, ['diff', '--histogram', '--no-color', '--no-ext-diff', '-M', '-U3', b, h, '--', ...(oldRel ? [oldRel, rel] : [rel])]);
+    const MAX = 600_000;
+    return { path: rel, diff: out.length > MAX ? out.slice(0, MAX) : out, truncated: out.length > MAX, binary: /^Binary files .* differ$/m.test(out) || /^GIT binary patch/m.test(out) };
+}
+const MAX_HITS = 300;
+/** Lines of the working files (tracked and new, never ignored ones) that contain `q`. */
+export async function gitGrep(cwd, q, caseSensitive = false) {
+    const { root, scope } = await repoOf(cwd);
+    const text = q.trim().slice(0, 200);
+    if (text.length < 2)
+        return { hits: [], truncated: false };
+    const { out } = await run(root, ['grep', '-n', '-I', '--null', '--fixed-strings', '--no-color', '--untracked', '--exclude-standard', ...(caseSensitive ? [] : ['-i']), '-e', text, '--', scope || '.'], { okCodes: [1], raw: true });
+    const hits = [];
+    let truncated = false;
+    for (const l of out.split('\n')) {
+        if (!l)
+            continue;
+        if (hits.length >= MAX_HITS) {
+            truncated = true;
+            break;
+        }
+        // With --null both the file name and the line number are followed by a NUL: `path NUL line NUL text`.
+        const [path, line, ...text] = l.split('\0');
+        if (!path || text.length === 0)
+            continue;
+        hits.push({ path, line: Number(line) || 0, text: text.join('\0').slice(0, 300) });
+    }
+    return { hits, truncated };
+}
+/* ------------------------------------------------------------------ pictures at a version */
+const MAX_IMAGE = 20 * 1024 * 1024;
+/** The bytes of a picture as it was at a commit, served only as an inert image (see the route). */
+export async function gitImageAt(cwd, ref, rel) {
+    const { root } = await repoOf(cwd);
+    const type = imageType(rel);
+    if (!type)
+        throw new PathError('Not an image');
+    const sha = await resolveRef(root, ref);
+    if (!rel || rel.includes('\0') || rel.startsWith('/') || rel.split('/').includes('..'))
+        throw new PathError('Invalid path');
+    const bytes = await new Promise((resolve, reject) => {
+        execFile('git', ['cat-file', 'blob', `${sha}:${rel}`], { cwd: root, encoding: 'buffer', maxBuffer: MAX_IMAGE, env: gitEnv(), timeout: 30_000 }, (err, stdout) => (err ? reject(new PathError('Picture not found at that version')) : resolve(stdout)));
+    });
+    return { bytes, type };
+}

package/server/dist/git/ops.js

@@ -1,13 +1,14 @@
 import { execFile } from 'node:child_process';
 import { writeFile } from 'node:fs/promises';
 import { findRepo, gitEnv, hasHead, isPathError, parseNumstat, PathError, repoState, safePath } from './repo.js';
+import { DomainError } from '../errors.js';
 /**
  * Git actions for the explorer: history (reads) and commit / pull / push / fetch / branches (writes).
  * Same rules as git.ts: `execFile` with no shell, user input only ever as an argument value (messages after -m,
  * paths after `--`, branch names validated), never `--force`, and no command that can prompt for credentials.
  */
 export { isPathError };
-export class GitOpError extends Error {
+export class GitOpError extends DomainError {
 }
 const LOCAL_TIMEOUT = 30_000;
 const NET_TIMEOUT = 120_000;
@@ -54,41 +55,74 @@ export async function exclusive(root, fn) {
             locks.delete(root);
     }
 }
-const SHA = /^[0-9a-f]{4,40}$/i;
+export const SHA = /^[0-9a-f]{4,40}$/i;
 export async function validBranch(root, name) {
     if (!name || name.startsWith('-') || name.includes('\0'))
         throw new GitOpError('Invalid branch name');
     await run(root, ['check-ref-format', '--branch', name]).catch(() => { throw new GitOpError(`"${name}" is not a valid branch name`); });
 }
-export async function gitLog(cwd, skip = 0) {
+export async function gitLog(cwd, skip = 0, f = {}) {
     const { root, scope } = await repoOf(cwd);
     if (!(await hasHead(root)))
         return { commits: [], hasMore: false };
-    const { out } = await run(root, ['log', `--skip=${Math.max(0, Math.floor(skip))}`, `--max-count=${LOG_PAGE + 1}`, '--decorate=short',
-        '--format=%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1f%D%x1f%P%x1e', '--', scope || '.']);
+    const q = (f.q ?? '').trim().slice(0, 200);
+    const args = ['log', `--skip=${Math.max(0, Math.floor(skip))}`, `--max-count=${LOG_PAGE + 1}`, '--decorate=short', '--format=%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1f%D%x1f%P%x1e'];
+    if (f.ref === 'all')
+        args.push('--all');
+    else if (f.ref && f.ref !== 'HEAD')
+        args.push(await resolveRef(root, f.ref));
+    if (q) {
+        // A hash (or the start of one) finds that commit directly.
+        if (/^[0-9a-f]{7,40}$/i.test(q) && (!f.by || f.by === 'message')) {
+            const hit = (await run(root, ['rev-parse', '--verify', '--quiet', `${q}^{commit}`], { okCodes: [1] })).out.trim();
+            if (SHA.test(hit))
+                return gitLogOne(root, hit);
+        }
+        if (f.by === 'author')
+            args.push('--regexp-ignore-case', '--fixed-strings', `--author=${q}`);
+        else if (f.by === 'content')
+            args.push('--regexp-ignore-case', '-S', q);
+        else
+            args.push('--regexp-ignore-case', '--fixed-strings', `--grep=${q}`);
+    }
+    let spec = scope || '.';
+    if (f.path) {
+        if (f.path.includes('\0') || f.path.startsWith('/') || f.path.split('/').includes('..'))
+            throw new PathError('Invalid path');
+        args.push('--follow');
+        spec = f.path;
+    }
+    const { out } = await run(root, [...args, '--', spec]);
+    return { ...parseLog(out) };
+}
+function parseLog(out) {
     const all = out.split('\x1e').map((r) => r.trim()).filter(Boolean).map((r) => {
         const [sha, short, author, date, subject, refs, parents] = r.split('\x1f');
         return { sha, short, author, date, subject, refs: (refs ?? '').split(', ').map((x) => x.replace(/^HEAD -> /, '').trim()).filter((x) => x && x !== 'HEAD'), merge: (parents ?? '').trim().split(' ').filter(Boolean).length > 1 };
     });
     return { commits: all.slice(0, LOG_PAGE), hasMore: all.length > LOG_PAGE };
 }
+async function gitLogOne(root, sha) {
+    const { out } = await run(root, ['log', '-1', '--decorate=short', '--format=%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1f%D%x1f%P%x1e', sha]);
+    return { ...parseLog(out), hasMore: false };
+}
+/** A branch, tag, remote branch, commit or HEAD~N from the browser, resolved to the commit it names (never an option, never a path). */
+export async function resolveRef(root, ref) {
+    if (!ref || ref.length > 200 || !/^[\w][\w./@+~^-]*$/.test(ref) || ref.includes('..'))
+        throw new PathError('Invalid reference');
+    const r = await run(root, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], { okCodes: [1] });
+    const sha = r.out.trim();
+    if (!SHA.test(sha))
+        throw new PathError(`"${ref}" was not found`);
+    return sha;
+}
 const isMergeCommit = async (root, sha) => (await run(root, ['rev-list', '--parents', '-n', '1', sha])).out.trim().split(' ').length > 2;
 const MAX_COMMIT_FILES = 500;
-export async function gitCommitDetail(cwd, sha) {
-    if (!SHA.test(sha))
-        throw new PathError('Invalid commit');
-    const { root } = await repoOf(cwd);
-    const isMerge = await isMergeCommit(root, sha);
-    // A merge commit has no diff of its own; show what it brought in relative to the branch it was made on (first parent).
-    const range = isMerge ? [`${sha}^1`, sha] : ['--root', sha];
-    const [meta, names, nums] = await Promise.all([
-        run(root, ['show', '-s', '--format=%H%x1f%an%x1f%ae%x1f%aI%x1f%B', sha]),
-        run(root, ['diff-tree', '-r', '-M', '--name-status', '-z', '--no-commit-id', ...range]),
-        run(root, ['diff-tree', '-r', '-M', '--histogram', '--numstat', '-z', '--no-commit-id', ...range]),
-    ]);
-    const counts = parseNumstat(nums.out);
+/** The files of a `diff-tree --name-status -z` plus its `--numstat -z`, as the explorer lists them (renames and counts included). */
+export function filesFromDiffTree(namesOut, numsOut) {
+    const counts = parseNumstat(numsOut);
     const files = [];
-    const st = names.out.split('\0');
+    const st = namesOut.split('\0');
     for (let i = 0; i < st.length; i++) {
         const code = st[i];
         if (!code)
@@ -105,6 +139,21 @@ export async function gitCommitDetail(cwd, sha) {
             files.push({ path, status: k === 'A' ? 'added' : k === 'D' ? 'deleted' : k === 'T' ? 'typechange' : 'modified', additions: c?.a ?? null, deletions: c?.d ?? null });
         }
     }
+    return files;
+}
+export async function gitCommitDetail(cwd, sha) {
+    if (!SHA.test(sha))
+        throw new PathError('Invalid commit');
+    const { root } = await repoOf(cwd);
+    const isMerge = await isMergeCommit(root, sha);
+    // A merge commit has no diff of its own; show what it brought in relative to the branch it was made on (first parent).
+    const range = isMerge ? [`${sha}^1`, sha] : ['--root', sha];
+    const [meta, names, nums] = await Promise.all([
+        run(root, ['show', '-s', '--format=%H%x1f%an%x1f%ae%x1f%aI%x1f%B', sha]),
+        run(root, ['diff-tree', '-r', '-M', '--name-status', '-z', '--no-commit-id', ...range]),
+        run(root, ['diff-tree', '-r', '-M', '--histogram', '--numstat', '-z', '--no-commit-id', ...range]),
+    ]);
+    const files = filesFromDiffTree(names.out, nums.out);
     const [h, author, email, date, ...msg] = meta.out.split('\x1f');
     return { sha: h, author, email, date, message: msg.join('\x1f').trim(), files: files.slice(0, MAX_COMMIT_FILES), truncated: files.length > MAX_COMMIT_FILES };
 }
@@ -174,6 +223,58 @@ export async function gitBranches(cwd) {
     }
     return res;
 }
+const MAX_TAGS = 1000;
+export async function gitTags(cwd) {
+    const { root } = await repoOf(cwd);
+    // %(*objectname) is the commit an annotated tag points to; a lightweight tag has none and %(objectname) is already the commit.
+    const { out } = await run(root, ['for-each-ref', '--sort=-creatordate', `--count=${MAX_TAGS + 1}`, '--format=%(refname:strip=2)%1f%(objecttype)%1f%(*objectname)%1f%(objectname)%1f%(creatordate:iso-strict)%1f%(contents:subject)', 'refs/tags']);
+    const all = out.split('\n').filter(Boolean).map((line) => {
+        const [name, type, peeled, direct, date, subject] = line.split('\x1f');
+        return { name, sha: peeled || direct, date, subject: subject ?? '', annotated: type === 'tag' };
+    });
+    return { tags: all.slice(0, MAX_TAGS), truncated: all.length > MAX_TAGS };
+}
+/** A tag name from the browser, resolved to the commit it points to. Only names that really are tags get through. */
+async function tagCommit(root, tag) {
+    if (!tag || tag.length > 200 || tag.startsWith('-') || /[\s\0~^:?*[\\]/.test(tag))
+        throw new PathError('Invalid tag');
+    const r = await run(root, ['rev-parse', '--verify', '--quiet', `refs/tags/${tag}^{commit}`], { okCodes: [1] });
+    const sha = r.out.trim();
+    if (!SHA.test(sha))
+        throw new PathError(`Tag "${tag}" not found`);
+    return sha;
+}
+export async function gitTagTree(cwd, tag) {
+    const { root, scope } = await repoOf(cwd);
+    const sha = await tagCommit(root, tag);
+    const { out } = await run(root, ['ls-tree', '-r', '--name-only', '-z', sha, '--', scope || '.'], { raw: true });
+    const files = out.split('\0').filter(Boolean);
+    const MAX = 30_000;
+    return { tag, sha, files: files.slice(0, MAX), truncated: files.length > MAX };
+}
+const MAX_TAG_FILE = 1_000_000;
+/** A file as it was at a commit (read-only, nothing is checked out). */
+export async function fileAtCommit(root, sha, rel, source) {
+    if (!rel || rel.includes('\0') || rel.startsWith('/') || rel.split('/').includes('..'))
+        throw new PathError('Invalid path');
+    // The path must be a file of that commit (not a folder, not a submodule).
+    const kind = (await run(root, ['ls-tree', '-z', sha, '--', rel], { raw: true })).out.split('\0')[0] ?? '';
+    if (!/^100\d{3} blob /.test(kind) && !/^120000 blob /.test(kind))
+        throw new PathError('File not found at that version');
+    const size = Number((await run(root, ['cat-file', '-s', `${sha}:${rel}`])).out) || 0;
+    const { out } = await run(root, ['show', `${sha}:${rel}`], { raw: true });
+    const binary = out.slice(0, 8000).includes('\0');
+    return { path: rel, size, binary, truncated: !binary && out.length > MAX_TAG_FILE, content: binary ? '' : out.slice(0, MAX_TAG_FILE), source };
+}
+export async function gitTagFile(cwd, tag, rel) {
+    const { root } = await repoOf(cwd);
+    return fileAtCommit(root, await tagCommit(root, tag), rel, 'tag');
+}
+/** Any version of a file: a branch, a tag or a commit. */
+export async function gitRefFile(cwd, ref, rel) {
+    const { root } = await repoOf(cwd);
+    return fileAtCommit(root, await resolveRef(root, ref), rel, 'ref');
+}
 export const done = (output) => ({ ok: true, output });
 export async function gitCommitChanges(cwd, message, paths) {
     const msg = message.trim();
@@ -230,6 +331,22 @@ export async function gitSwitch(cwd, branch, create = false) {
     await validBranch(root, branch);
     return exclusive(root, async () => done((await run(root, create ? ['switch', '-c', branch] : ['switch', branch])).out || `On ${branch}`));
 }
+/** Creates a branch at a tag, another branch or a commit WITHOUT switching to it: the working folder is not touched. */
+export async function gitBranchCreate(cwd, branch, from) {
+    const { root } = await repoOf(cwd);
+    await validBranch(root, branch);
+    const sha = await resolveRef(root, from);
+    return exclusive(root, async () => done((await run(root, ['branch', '--', branch, sha])).out || `Created ${branch}`));
+}
+/** Deletes a local branch. Without `force` git refuses when it has commits that are not merged anywhere. */
+export async function gitBranchDelete(cwd, branch, force = false) {
+    const { root } = await repoOf(cwd);
+    await validBranch(root, branch);
+    const cur = (await run(root, ['branch', '--show-current'])).out.trim();
+    if (cur === branch)
+        throw new GitOpError('You cannot delete the branch you are on. Switch to another one first.');
+    return exclusive(root, async () => done((await run(root, ['branch', force ? '-D' : '-d', '--', branch])).out || `Deleted ${branch}`));
+}
 export async function gitMerge(cwd, branch) {
     const { root } = await repoOf(cwd);
     if (!branch || branch.startsWith('-') || branch.includes('\0'))

package/server/dist/git/repo.js

@@ -2,6 +2,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { open, readdir, readFile, realpath, stat } from 'node:fs/promises';
 import { extname, isAbsolute, normalize, resolve, sep } from 'node:path';
+import { DomainError } from '../errors.js';
 /**
  * Read-only git access for the explorer (writes live in gitops.ts). Everything here only *reads*: no command writes to the repository,
  * and `GIT_OPTIONAL_LOCKS=0` keeps `git status` from touching the index while an agent is working in it.
@@ -239,7 +240,7 @@ export async function gitList(cwd, rel) {
         .map((d) => ({ name: d.name, dir: d.isDirectory() })).sort((a, b) => (a.dir === b.dir ? a.name.localeCompare(b.name) : a.dir ? -1 : 1));
     return { path: rel.replace(/\/+$/, ''), entries: entries.slice(0, MAX_LISTED), truncated: entries.length > MAX_LISTED };
 }
-export class PathError extends Error {
+export class PathError extends DomainError {
 }
 export const isPathError = (e) => e instanceof PathError;
 /** Repo-relative path → absolute path, guaranteed to be inside the agent's own folder (symlinks resolved). */

package/server/dist/history/claude.js

@@ -1,12 +1,15 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { estimateCost } from '../pricing.js';
+import { flattenText } from '../providers/spawn.js';
+import { stripInstructions } from '../providers/preamble.js';
+import { jsonLines } from './lines.js';
 const ROOT = join(homedir(), '.claude', 'projects');
 /** Claude encodes the project path by replacing both "/" and "." with "-". */
 const encode = (cwd) => cwd.replace(/[/.]/g, '-');
 /** An instructions update sent in front of a message (see providers/preamble.ts) is not part of what the user wrote. */
-const stripPreamble = (x) => x.replace(/^<instructions[^>]*>[\s\S]*?<\/instructions>\s*/, '');
+const stripPreamble = stripInstructions;
 export function claudeFile(cwd, sessionId) {
     if (!/^[\w-]+$/.test(sessionId))
         return null;
@@ -23,24 +26,41 @@ export function claudeFile(cwd, sessionId) {
     catch { /* no Claude data yet */ }
     return null;
 }
+/** Changes when the conversation changes (used to cache what is computed from it). */
+export function claudeSig(cwd, sessionId) {
+    const f = claudeFile(cwd, sessionId);
+    if (!f)
+        return null;
+    try {
+        const st = statSync(f);
+        return `${st.mtimeMs}:${st.size}`;
+    }
+    catch {
+        return null;
+    }
+}
+// Parsing a long transcript (tens of MB) takes about a second and the UI asks for it often: keep the last results while the file is unchanged.
+const cache = new Map();
 export function readClaude(cwd, sessionId) {
     const file = claudeFile(cwd, sessionId);
     if (!file)
         return [];
+    const st = statSync(file), sig = `${st.mtimeMs}:${st.size}`, hit = cache.get(file);
+    if (hit && hit.sig === sig)
+        return hit.msgs;
+    const msgs = parseClaude(file);
+    cache.delete(file);
+    cache.set(file, { sig, msgs });
+    if (cache.size > 8)
+        cache.delete(cache.keys().next().value);
+    return msgs;
+}
+function parseClaude(file) {
     const out = [];
     const byMsgId = new Map();
     const toolBlocks = new Map();
     const toolStart = new Map();
-    for (const line of readFileSync(file, 'utf8').split('\n')) {
-        if (!line)
-            continue;
-        let e;
-        try {
-            e = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
+    for (const e of jsonLines(file)) {
         if (e.isSidechain || e.isMeta || (e.type !== 'user' && e.type !== 'assistant'))
             continue;
         const m = e.message;
@@ -60,7 +80,7 @@ export function readClaude(cwd, sessionId) {
                     if (b.type === 'tool_result') {
                         const t = toolBlocks.get(b.tool_use_id);
                         if (t) {
-                            t.output = flat(b.content);
+                            t.output = flattenText(b.content);
                             t.error = !!b.is_error;
                             const st = toolStart.get(b.tool_use_id);
                             if (st && ts)
@@ -119,10 +139,3 @@ export function claudeMeta(file) {
     const st = statSync(file);
     return { mtime: st.mtimeMs, size: st.size };
 }
-function flat(c) {
-    if (typeof c === 'string')
-        return c;
-    if (Array.isArray(c))
-        return c.map((x) => (typeof x === 'string' ? x : x?.text ?? '')).join('\n');
-    return c == null ? '' : JSON.stringify(c);
-}

package/server/dist/history/index.js

@@ -1,19 +1,27 @@
-import { readClaude } from './claude.js';
-import { readOpencode } from './opencode.js';
-import { readKiro } from './kiro.js';
-/** The conversation lives in each CLI's own store; hive-am only keeps the pointer. */
+import { claudeSig, readClaude } from './claude.js';
+import { opencodeSig, readOpencode } from './opencode.js';
+import { kiroSig, readKiro } from './kiro.js';
+export const historyReaders = {
+    claude: { read: readClaude, sig: claudeSig },
+    opencode: { read: (_cwd, id) => readOpencode(id), sig: (_cwd, id) => opencodeSig(id) },
+    kiro: { read: (_cwd, id) => readKiro(id), sig: (_cwd, id) => kiroSig(id) },
+};
 export function readHistory(a, sessionId = a.session_id) {
     if (!sessionId)
         return [];
     try {
-        switch (a.provider) {
-            case 'claude': return readClaude(a.cwd, sessionId);
-            case 'opencode': return readOpencode(sessionId);
-            case 'kiro': return readKiro(sessionId);
-        }
+        return historyReaders[a.provider].read(a.cwd, sessionId);
     }
     catch (e) {
         console.error('[history]', a.provider, sessionId, e);
         return [];
     }
 }
+export function historySig(a, sessionId) {
+    try {
+        return historyReaders[a.provider].sig(a.cwd, sessionId);
+    }
+    catch {
+        return null;
+    }
+}

package/server/dist/history/kiro.js

@@ -1,8 +1,22 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { stripInstructions } from '../providers/preamble.js';
+import { jsonLines } from './lines.js';
 const DIR = join(homedir(), '.kiro', 'sessions', 'cli');
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Changes when the conversation changes (used to cache what is computed from it). */
+export function kiroSig(sessionId) {
+    if (!UUID.test(sessionId))
+        return null;
+    try {
+        const st = statSync(join(DIR, `${sessionId}.jsonl`));
+        return `${st.mtimeMs}:${st.size}`;
+    }
+    catch {
+        return null;
+    }
+}
 export function readKiro(sessionId) {
     if (!UUID.test(sessionId))
         return [];
@@ -16,16 +30,7 @@ export function readKiro(sessionId) {
     const flush = () => { if (lastAssistant && turnIdx >= 0 && turns[turnIdx])
         lastAssistant.meta = turns[turnIdx]; lastAssistant = null; };
     const tools = new Map();
-    for (const line of readFileSync(file, 'utf8').split('\n')) {
-        if (!line)
-            continue;
-        let e;
-        try {
-            e = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
+    for (const e of jsonLines(file)) {
         const d = e.data;
         if (!d)
             continue;
@@ -35,7 +40,7 @@ export function readKiro(sessionId) {
             turnIdx++;
             const text = (d.content ?? []).filter((b) => b.kind === 'text').map((b) => b.data).join('');
             if (text.trim())
-                out.push({ id: d.message_id, role: 'user', ts, blocks: [{ type: 'text', text: text.replace(/^<instructions[^>]*>[\s\S]*?<\/instructions>\s*/, '') }] });
+                out.push({ id: d.message_id, role: 'user', ts, blocks: [{ type: 'text', text: stripInstructions(text) }] });
         }
         else if (e.kind === 'AssistantMessage') {
             const blocks = [];

package/server/dist/history/lines.js

@@ -0,0 +1,12 @@
+import { readFileSync } from 'node:fs';
+/** The JSON objects of a JSONL transcript, in order. A line that is cut or damaged (a CLI still writing) is skipped, not fatal. */
+export function* jsonLines(file) {
+    for (const line of readFileSync(file, 'utf8').split('\n')) {
+        if (!line)
+            continue;
+        try {
+            yield JSON.parse(line);
+        }
+        catch { /* partial line */ }
+    }
+}

package/server/dist/history/opencode.js

@@ -3,7 +3,24 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { estimateCost } from '../pricing.js';
+import { stripInstructions as stripPreamble } from '../providers/preamble.js';
 const DB = join(homedir(), '.local', 'share', 'opencode', 'opencode.db');
+/** Changes when the conversation changes (used to cache what is computed from it). */
+export function opencodeSig(sessionId) {
+    if (!existsSync(DB))
+        return null;
+    const db = new Database(DB, { readonly: true, fileMustExist: true });
+    try {
+        const r = db.prepare('SELECT COUNT(*) n, COALESCE(MAX(time_created), 0) t FROM session_message WHERE session_id=?').get(sessionId);
+        return `${r.n}:${r.t}`;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        db.close();
+    }
+}
 export function readOpencode(sessionId) {
     if (!existsSync(DB))
         return [];
@@ -58,7 +75,7 @@ function stripInstructions(t) {
     let x = t.trim();
     if (x.length > 1 && x.startsWith('"') && x.endsWith('"'))
         x = x.slice(1, -1);
-    return x.replace(/^<instructions[^>]*>[\s\S]*?<\/instructions>\s*/, '').trim();
+    return stripPreamble(x).trim();
 }
 /** Folder OpenCode recorded for a session, or null if unknown. Used to avoid resuming a session that belongs to another folder. */
 export function opencodeSessionDir(sessionId) {

package/server/dist/http/body.js

@@ -0,0 +1,46 @@
+import { UPLOAD_MAX_BYTES, UPLOAD_MAX_FILES } from '../connections/files.js';
+import { bad, tooLarge } from './errors.js';
+/** Notes, skills, SQL, http files and settings are text: 2 MiB is far above what any of them needs. */
+export const JSON_LIMIT = 2 * 1024 * 1024;
+/** Files sent from the chat travel as base64 inside the JSON (4/3 of the bytes), up to UPLOAD_MAX_FILES of UPLOAD_MAX_BYTES each. */
+export const UPLOAD_LIMIT = Math.ceil(UPLOAD_MAX_FILES * UPLOAD_MAX_BYTES * 4 / 3) + JSON_LIMIT;
+const mb = (n) => `${Math.round(n / 1048576)} MB`;
+/** Raw bytes of the request, refusing (413) anything over `max`. Once over the limit the rest is read and dropped, so the answer can still be delivered. */
+export function readRaw(req, max) {
+    return new Promise((resolve, reject) => {
+        const declared = Number(req.headers['content-length']);
+        const chunks = [];
+        let size = 0, over = false;
+        const refuse = () => { if (over)
+            return; over = true; chunks.length = 0; reject(tooLarge(`The request is too big (limit ${mb(max)})`)); };
+        if (Number.isFinite(declared) && declared > max) {
+            refuse();
+            req.resume();
+            return;
+        }
+        req.on('data', (c) => { if (over)
+            return; size += c.length; if (size > max)
+            return refuse(); chunks.push(c); });
+        req.on('end', () => { if (!over)
+            resolve(Buffer.concat(chunks)); });
+        req.on('error', (e) => { if (!over) {
+            over = true;
+            reject(e);
+        } });
+    });
+}
+export async function body(req, max = JSON_LIMIT) {
+    const raw = await readRaw(req, max);
+    if (!raw.length)
+        return {};
+    let v;
+    try {
+        v = JSON.parse(raw.toString('utf8'));
+    }
+    catch {
+        throw bad('Request body is not valid JSON');
+    }
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        throw bad('Request body must be a JSON object');
+    return v;
+}

package/server/dist/http/errors.js

@@ -0,0 +1,21 @@
+import { DomainError, STATUS_OF_KIND } from '../errors.js';
+/** An error with the status the client should see. Its message is shown to the person, so it is in plain English. */
+export class HttpError extends Error {
+    status;
+    constructor(status, msg) {
+        super(msg);
+        this.status = status;
+    }
+}
+export const bad = (m) => new HttpError(400, m);
+export const forbidden = (m) => new HttpError(403, m);
+export const notFound = (m = 'Not found') => new HttpError(404, m);
+export const tooLarge = (m) => new HttpError(413, m);
+/** The one place where an error becomes a status and a message. `null` means "not ours": the caller logs it and answers 500. */
+export function toHttpError(e) {
+    if (e instanceof HttpError)
+        return e;
+    if (e instanceof DomainError)
+        return new HttpError(STATUS_OF_KIND[e.kind] ?? 400, e.message);
+    return null;
+}