presubmit 0.1.0

package/dist/apps/server/src/session-changes.js

@@ -0,0 +1,181 @@
+import { execFile } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { isRecordedFileChange, } from '../../../packages/protocol/src/session-changes.js';
+const exec = promisify(execFile);
+const MAX_BYTES = 20 * 1024 * 1024;
+const MAX_RECORDS = 1000;
+const quotedPath = (path) => (/^[\w./-]+$/.test(path) ? path : JSON.stringify(path));
+async function groupDiff(group, directory) {
+    if (group.before === group.after)
+        return '';
+    const before = join(directory, `${group.id}-before`);
+    const after = join(directory, `${group.id}-after`);
+    await Promise.all([writeFile(before, group.before ?? ''), writeFile(after, group.after ?? '')]);
+    let output;
+    try {
+        ({ stdout: output } = await exec('git', [
+            'diff',
+            '--no-index',
+            '--no-ext-diff',
+            '--no-textconv',
+            '--text',
+            '--unified=3',
+            '--',
+            before,
+            after,
+        ], {
+            cwd: directory,
+            maxBuffer: 4 * 1024 * 1024,
+            encoding: 'utf8',
+            env: {
+                ...process.env,
+                GIT_CONFIG_NOSYSTEM: '1',
+                GIT_CONFIG_GLOBAL: '/dev/null',
+                GIT_PAGER: 'cat',
+            },
+        }));
+    }
+    catch (error) {
+        const result = error;
+        if (result.code !== 1 || typeof result.stdout !== 'string')
+            throw error;
+        output = result.stdout;
+    }
+    const hunk = output.indexOf('\n@@ ');
+    const left = quotedPath('a/' + group.file);
+    const right = quotedPath('b/' + group.file);
+    return `diff --git ${left} ${right}\n${group.before === null ? 'new file mode 100644\n' : group.after === null ? 'deleted file mode 100644\n' : ''}--- ${group.before === null ? '/dev/null' : left}\n+++ ${group.after === null ? '/dev/null' : right}\n${hunk < 0 ? '' : output.slice(hunk + 1)}`;
+}
+/** Per-session provenance, kept outside AppState and the conversation journal. */
+export class SessionChanges {
+    store;
+    cached;
+    constructor(store) {
+        this.store = store;
+        store.db.exec(`CREATE TABLE IF NOT EXISTS file_changes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, run_id TEXT NOT NULL, tool_id TEXT NOT NULL,
+      write_index INTEGER NOT NULL, file TEXT NOT NULL, before_text TEXT, after_text TEXT,
+      omitted TEXT, bytes INTEGER NOT NULL, UNIQUE(run_id, tool_id, write_index)
+    );`);
+        if (store.get('file-change-tracking') === undefined) {
+            store.put('file-change-tracking', {
+                earlierHistory: !!store.get('state')?.runs.length,
+            });
+        }
+    }
+    /** Call within the event transaction. Duplicate deliveries do not add another edit. */
+    record(runId, change) {
+        if (!isRecordedFileChange(change))
+            throw new Error('Invalid recorded file change');
+        if (this.store.db
+            .prepare('SELECT 1 FROM file_changes WHERE run_id=? AND tool_id=? AND write_index=?')
+            .get(runId, change.toolCallId, change.index))
+            return false;
+        const usage = this.store.db
+            .prepare('SELECT COUNT(*) AS count, COALESCE(SUM(bytes),0) AS bytes FROM file_changes')
+            .get();
+        if (usage.count >= MAX_RECORDS) {
+            if (this.store.get('file-changes-limited'))
+                return false;
+            this.store.put('file-changes-limited', true);
+            this.cached = undefined;
+            return true;
+        }
+        const bytes = change.omitted
+            ? 0
+            : Buffer.byteLength(change.before ?? '') + Buffer.byteLength(change.after ?? '');
+        const omitted = change.omitted ?? (usage.bytes + bytes > MAX_BYTES ? 'storage' : null);
+        this.store.db
+            .prepare(`INSERT INTO file_changes(run_id,tool_id,write_index,file,before_text,after_text,omitted,bytes) VALUES(?,?,?,?,?,?,?,?)`)
+            .run(runId, change.toolCallId, change.index, change.file, omitted ? null : (change.before ?? null), omitted ? null : (change.after ?? null), omitted, omitted ? 0 : bytes);
+        this.cached = undefined;
+        return true;
+    }
+    view() {
+        const revision = JSON.stringify(this.store.db.prepare('SELECT MAX(id) AS id FROM file_changes').get()) +
+            !!this.store.get('file-changes-limited');
+        if (this.cached?.revision === revision)
+            return this.cached.value;
+        const value = this.build();
+        this.cached = { revision, value };
+        void value.catch(() => {
+            if (this.cached?.value === value)
+                this.cached = undefined;
+        });
+        return value;
+    }
+    async build() {
+        const rows = this.store.db
+            .prepare('SELECT id,file,before_text,after_text,omitted FROM file_changes ORDER BY id')
+            .all();
+        const groups = [];
+        const last = new Map();
+        let partial = !!this.store.get('file-changes-limited');
+        const earlierHistory = !!this.store.get('file-change-tracking')
+            ?.earlierHistory;
+        for (const row of rows) {
+            if (row.omitted) {
+                partial = true;
+                last.delete(row.file);
+                continue;
+            }
+            const previous = last.get(row.file);
+            // Intervening edits by another writer must never appear as this session's additions.
+            if (previous && previous.after === row.before_text) {
+                previous.after = row.after_text;
+                previous.edits++;
+            }
+            else {
+                const group = {
+                    id: row.id,
+                    file: row.file,
+                    before: row.before_text,
+                    after: row.after_text,
+                    edits: 1,
+                };
+                groups.push(group);
+                last.set(row.file, group);
+            }
+        }
+        const directory = await mkdtemp(join(tmpdir(), 'presubmit-session-diff-'));
+        try {
+            const diffs = new Map();
+            let next = 0;
+            const results = await Promise.allSettled(Array.from({ length: Math.min(4, groups.length) }, async () => {
+                while (next < groups.length) {
+                    const group = groups[next++];
+                    diffs.set(group.id, await groupDiff(group, directory));
+                }
+            }));
+            for (const result of results)
+                if (result.status === 'rejected')
+                    throw result.reason;
+            const files = new Map();
+            let bytes = 0;
+            for (const group of groups) {
+                const diff = diffs.get(group.id);
+                if (!diff)
+                    continue;
+                bytes += Buffer.byteLength(diff);
+                if (bytes > MAX_BYTES) {
+                    partial = true;
+                    break;
+                }
+                const file = files.get(group.file) ?? { path: group.file, groups: [] };
+                file.groups.push({ id: group.id, edits: group.edits, diff });
+                files.set(group.file, file);
+            }
+            return {
+                files: [...files.values()].sort((a, b) => a.path.localeCompare(b.path)),
+                partial,
+                earlierHistory,
+            };
+        }
+        finally {
+            await rm(directory, { recursive: true, force: true });
+        }
+    }
+}

package/dist/apps/server/src/session-router-settings.js

@@ -0,0 +1,198 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { defaultSessionRouterSettings, parseSessionRouterSettings, } from '../../../packages/protocol/src/session-router.js';
+const endpoint = 'https://api.typesafe.ai/v1/models';
+const settingsPath = (authPath) => join(dirname(authPath), 'typesafe.json');
+async function read(authPath) {
+    try {
+        const value = JSON.parse(await readFile(settingsPath(authPath), 'utf8'));
+        return {
+            version: typeof value.version === 'string' ? value.version : '0',
+            apiKey: typeof value.apiKey === 'string' && value.apiKey ? value.apiKey : undefined,
+            settings: parseSessionRouterSettings(value.settings ?? defaultSessionRouterSettings),
+            models: Array.isArray(value.models)
+                ? value.models.map(parseModel).filter((item) => !!item)
+                : [],
+        };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {
+                version: '0',
+                settings: { ...defaultSessionRouterSettings },
+                models: [],
+            };
+        throw new Error('Could not read TypeSafe session routing settings.');
+    }
+}
+function parseModel(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const input = value;
+    const id = typeof input.id === 'string' ? input.id : input.name;
+    if (typeof id !== 'string' || !id.trim())
+        return undefined;
+    return {
+        id: id.trim(),
+        ...(typeof input.description === 'string' ? { description: input.description } : {}),
+        ...(typeof input.releaseDate === 'string'
+            ? { releaseDate: input.releaseDate }
+            : typeof input.release_date === 'string'
+                ? { releaseDate: input.release_date }
+                : {}),
+    };
+}
+async function catalog(apiKey, request) {
+    const response = await request(endpoint, {
+        headers: { Authorization: `Bearer ${apiKey}`, Accept: 'application/json' },
+        signal: AbortSignal.timeout(5000),
+    });
+    if (!response.ok)
+        throw new Error(response.status === 401
+            ? 'TypeSafe rejected this API key.'
+            : `Could not load TypeSafe models (${response.status}).`);
+    const value = (await response.json());
+    if (!Array.isArray(value.models))
+        throw new Error('TypeSafe returned an invalid model catalog.');
+    const models = value.models.map(parseModel).filter((item) => !!item);
+    if (!models.length)
+        throw new Error('No TypeSafe models are available for this account.');
+    return models;
+}
+async function write(authPath, saved) {
+    const path = settingsPath(authPath);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temp = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temp, JSON.stringify(saved), { mode: 0o600 });
+        await rename(temp, path);
+    }
+    finally {
+        await rm(temp, { force: true });
+    }
+}
+function publicState(saved) {
+    const environment = process.env.TYPESAFE_API_KEY?.trim();
+    return {
+        version: saved.version,
+        settings: saved.settings,
+        connected: Boolean(environment || saved.apiKey),
+        ...(environment
+            ? { source: 'environment' }
+            : saved.apiKey
+                ? { source: 'saved' }
+                : {}),
+        models: saved.models,
+        ...(environment
+            ? { message: 'Connected using TYPESAFE_API_KEY from the server environment.' }
+            : {}),
+    };
+}
+export async function sessionRouterState(authPath) {
+    return publicState(await read(authPath));
+}
+export async function sessionRouterConfig(authPath, request = fetch) {
+    try {
+        const saved = await read(authPath);
+        const apiKey = process.env.TYPESAFE_API_KEY?.trim() || saved.apiKey;
+        if (!apiKey ||
+            (!saved.settings.enabled &&
+                !saved.settings.taskRoutingEnabled &&
+                !saved.settings.agentConsultEnabled &&
+                !saved.settings.shellSafetyShadowEnabled))
+            return undefined;
+        return {
+            apiKey,
+            model: saved.settings.model,
+            sessionRoutingEnabled: saved.settings.enabled,
+            routeConfidence: saved.settings.routeConfidence,
+            taskRoutingEnabled: saved.settings.taskRoutingEnabled,
+            taskMinConfidence: saved.settings.taskMinConfidence,
+            agentConsultEnabled: saved.settings.agentConsultEnabled,
+            agentConsultMinConfidence: saved.settings.agentConsultMinConfidence,
+            shellSafetyShadowEnabled: saved.settings.shellSafetyShadowEnabled,
+            fetch: request,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function updateSessionRouter(authPath, input, request = fetch) {
+    const path = settingsPath(authPath);
+    const lock = `${path}.lock`;
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    try {
+        await mkdir(lock);
+    }
+    catch {
+        throw new Error('Session routing settings are being saved elsewhere. Reload and retry.');
+    }
+    try {
+        const saved = await read(authPath);
+        const action = input.action;
+        if (action === 'connect') {
+            const apiKey = typeof input.apiKey === 'string' ? input.apiKey.trim() : '';
+            if (!apiKey || apiKey.length > 8192 || /[\x00-\x1f\x7f]/.test(apiKey))
+                throw new Error('Enter a valid TypeSafe API key.');
+            const models = await catalog(apiKey, request);
+            const next = { ...saved, version: randomUUID(), apiKey, models };
+            await write(authPath, next);
+            return publicState(next);
+        }
+        if (action === 'refresh') {
+            const apiKey = process.env.TYPESAFE_API_KEY?.trim() || saved.apiKey;
+            if (!apiKey)
+                throw new Error('Connect TypeSafe before refreshing models.');
+            const next = { ...saved, version: randomUUID(), models: await catalog(apiKey, request) };
+            await write(authPath, next);
+            return publicState(next);
+        }
+        if (action === 'save') {
+            if (input.version !== saved.version)
+                throw new Error('Session routing settings changed. Reload and retry.');
+            const settings = parseSessionRouterSettings(input.settings);
+            if ((settings.enabled ||
+                settings.taskRoutingEnabled ||
+                settings.agentConsultEnabled ||
+                settings.shellSafetyShadowEnabled) &&
+                !process.env.TYPESAFE_API_KEY?.trim() &&
+                !saved.apiKey)
+                throw new Error('Connect TypeSafe before enabling Jev decisions.');
+            const next = { ...saved, version: randomUUID(), settings };
+            await write(authPath, next);
+            return publicState(next);
+        }
+        if (action === 'disconnect') {
+            const environment = process.env.TYPESAFE_API_KEY?.trim();
+            const next = {
+                ...saved,
+                version: randomUUID(),
+                apiKey: undefined,
+                settings: environment
+                    ? saved.settings
+                    : {
+                        ...saved.settings,
+                        enabled: false,
+                        taskRoutingEnabled: false,
+                        agentConsultEnabled: false,
+                        shellSafetyShadowEnabled: false,
+                    },
+            };
+            await write(authPath, next);
+            return {
+                ...publicState(next),
+                ...(environment
+                    ? {
+                        message: 'Saved credentials removed. TypeSafe remains connected through TYPESAFE_API_KEY; remove it from the environment and restart to disconnect.',
+                    }
+                    : {}),
+            };
+        }
+        throw new Error('Invalid session routing settings action.');
+    }
+    finally {
+        await rm(lock, { recursive: true, force: true });
+    }
+}

package/dist/apps/server/src/session-workspaces.js

@@ -0,0 +1,135 @@
+import { isGitWorkspace } from './workspace.js';
+import { execFile } from 'node:child_process';
+import { lstat, mkdir, realpath } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execute = promisify(execFile);
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+async function git(repository, args, operation) {
+    try {
+        const result = await execute('git', args, {
+            cwd: repository,
+            encoding: 'utf8',
+            maxBuffer: 64 * 1024,
+            timeout: 60_000,
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        });
+        return result.stdout.endsWith('\0') ? result.stdout : result.stdout.trim();
+    }
+    catch (error) {
+        // Git stderr can contain hook output and credentials. Keep public errors contextual,
+        // but never propagate arbitrary subprocess output to the browser.
+        const code = error.code;
+        const status = typeof code === 'number' ? ` (exit ${code})` : '';
+        throw new Error(`Cannot ${operation}: Git failed${status}. Check the repository and filesystem permissions.`);
+    }
+}
+export async function listSessionBranches(repository) {
+    if (!(await isGitWorkspace(repository)))
+        return { branches: [], current: null, uncommittedFiles: 0 };
+    const [refs, current, status] = await Promise.all([
+        git(repository, ['for-each-ref', '--format=%(refname:strip=2)', 'refs/heads/'], 'list branches'),
+        git(repository, ['rev-parse', '--abbrev-ref', 'HEAD'], 'read current branch'),
+        git(repository, ['status', '--porcelain=v1', '-z'], 'inspect uncommitted files'),
+    ]);
+    const entries = status.split('\0').filter(Boolean);
+    let uncommittedFiles = 0;
+    for (let i = 0; i < entries.length; i++) {
+        uncommittedFiles++;
+        if (/^[RC]|^.[RC]/.test(entries[i]))
+            i++;
+    }
+    return {
+        branches: refs ? refs.split('\n') : [],
+        current: current === 'HEAD' ? null : current,
+        uncommittedFiles,
+    };
+}
+async function resolveBranch(repository, branch) {
+    await git(repository, ['check-ref-format', `refs/heads/${branch}`], 'validate branch name');
+    return git(repository, ['rev-parse', '--verify', `refs/heads/${branch}^{commit}`], 'resolve selected branch');
+}
+export async function selectSessionBranch(repository, branch, busy) {
+    if (!(await isGitWorkspace(repository)))
+        throw new Error('Branch selection requires a Git repository.');
+    await resolveBranch(repository, branch);
+    const state = await listSessionBranches(repository);
+    if (state.current === branch)
+        return;
+    if (busy())
+        throw new Error('Wait for active sessions to finish before switching the shared checkout branch.');
+    if (state.uncommittedFiles)
+        throw new Error('Commit or stash uncommitted changes before switching the shared checkout branch, or use a worktree.');
+    await git(repository, ['switch', '--no-guess', '--', branch], 'switch branch; it may be in use by another worktree');
+}
+export async function createSessionWorkspace(options) {
+    if (!(await isGitWorkspace(options.repository)))
+        throw new Error('Worktrees require a Git repository. Use Local for this folder.');
+    if (!UUID.test(options.id))
+        throw new Error('Session ID must be a UUID generated by randomUUID.');
+    const branch = `presubmit/${options.id}`;
+    await mkdir(options.directory, { recursive: true, mode: 0o700 });
+    const workspace = path.join(await realpath(options.directory), options.id);
+    try {
+        await lstat(workspace);
+        throw new Error('Session workspace path already exists. Choose a new session ID.');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const existing = await git(options.repository, ['for-each-ref', '--format=%(refname)', `refs/heads/${branch}`], 'inspect session branch');
+    if (existing)
+        throw new Error('Session branch already exists. Choose a new session ID.');
+    if (options.baseCommit && !/^[a-f0-9]{40,64}$/i.test(options.baseCommit))
+        throw new Error('Invalid pinned base commit.');
+    const commit = options.baseCommit ??
+        (options.branch
+            ? await resolveBranch(options.repository, options.branch)
+            : await git(options.repository, ['rev-parse', '--verify', 'HEAD^{commit}'], 'resolve repository HEAD; create an initial commit first'));
+    // -b is intentionally non-forcing: Git also checks collisions atomically. Never
+    // delete branches or directories on failure, since they may contain user work.
+    await git(options.repository, ['worktree', 'add', '-b', branch, workspace, commit], 'create session worktree');
+    return { workspace, branch };
+}
+/** Validate saved sessions on restart. Missing worktrees must never be recreated. */
+export async function validateSessionWorkspace(repository, workspace, branch) {
+    if (!branch.startsWith('presubmit/') || !UUID.test(branch.slice('presubmit/'.length)))
+        throw new Error('Invalid saved session branch.');
+    let canonical;
+    try {
+        canonical = await realpath(workspace);
+    }
+    catch {
+        throw new Error('Session workspace is missing or inaccessible. Restore its worktree to resume this session.');
+    }
+    const [root, repositoryCommon, workspaceCommon] = await Promise.all([
+        git(canonical, ['rev-parse', '--show-toplevel'], 'locate session worktree'),
+        git(repository, ['rev-parse', '--path-format=absolute', '--git-common-dir'], 'identify repository'),
+        git(canonical, ['rev-parse', '--path-format=absolute', '--git-common-dir'], 'identify session repository'),
+    ]);
+    if ((await realpath(root)) !== canonical)
+        throw new Error('Saved session workspace is not a worktree root.');
+    if ((await realpath(repositoryCommon)) !== (await realpath(workspaceCommon)))
+        throw new Error('Saved session workspace belongs to a different repository.');
+    // Branch switches and detached HEAD are legitimate user actions in this worktree.
+}
+/** Resolve once at human batch approval; execution uses the immutable object ID. */
+export async function resolveSessionCommit(repository, ref) {
+    if (!ref || ref.length > 200 || ref.startsWith('-') || /[\0\r\n]/.test(ref))
+        throw new Error('Invalid base ref.');
+    return git(repository, ['rev-parse', '--verify', '--end-of-options', `${ref}^{commit}`], 'resolve task base');
+}
+export async function inspectTaskWorkspace(workspace) {
+    if (!(await isGitWorkspace(workspace)))
+        return {};
+    const [commit, status] = await Promise.all([
+        resolveSessionCommit(workspace, 'HEAD'),
+        git(workspace, ['status', '--porcelain=v1', '-z'], 'inspect task changes'),
+    ]);
+    return { commit, dirty: !!status };
+}
+export async function commitContains(repository, base, commit) {
+    const ancestor = await git(repository, ['merge-base', base, commit], 'check prerequisite integration');
+    return ancestor === commit;
+}