pi2web 0.2.0 → 0.2.6

package/dist/auth.js

@@ -1,31 +1,96 @@
-import { randomBytes, createHash, timingSafeEqual } from 'node:crypto';
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
 import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 const hash = (token) => createHash('sha256').update(token).digest('hex');
+const validateToken = (token) => {
+    if (!/^[A-Za-z0-9._~-]{16,128}$/.test(token)) {
+        throw Object.assign(new Error('Access token must be 16-128 URL-safe characters (letters, digits, dot, underscore, tilde or hyphen)'), { code: 'INVALID_ACCESS_TOKEN' });
+    }
+};
 export class AuthStore {
     dir;
     constructor(dir) {
         this.dir = dir;
     }
-    get file() { return path.join(this.dir, 'auth.json'); }
-    async init() { await mkdir(this.dir, { recursive: true }); try {
-        await readFile(this.file);
-        return {};
+    get file() {
+        return path.join(this.dir, 'auth.json');
+    }
+    async init() {
+        await mkdir(this.dir, { recursive: true });
+        try {
+            await readFile(this.file);
+            return {};
+        }
+        catch {
+            const token = randomBytes(32).toString('base64url');
+            await this.save({ tokenHash: hash(token), createdAt: new Date().toISOString() });
+            return { token };
+        }
+    }
+    async save(data) {
+        await mkdir(this.dir, { recursive: true });
+        await writeFile(this.file, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+        await chmod(this.file, 0o600);
+    }
+    async verify(token) {
+        try {
+            const data = JSON.parse(await readFile(this.file, 'utf8'));
+            const actual = Buffer.from(hash(token));
+            const expected = Buffer.from(data.tokenHash);
+            return actual.length === expected.length && timingSafeEqual(actual, expected);
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Only the pairing code verifies as a full-power token. */
+    async role(token) {
+        try {
+            const data = JSON.parse(await readFile(this.file, 'utf8'));
+            const same = (expected) => {
+                if (!expected)
+                    return false;
+                const actual = Buffer.from(hash(token)), stored = Buffer.from(expected);
+                return actual.length === stored.length && timingSafeEqual(actual, stored);
+            };
+            if (same(data.tokenHash))
+                return 'full';
+            if (same(data.voiceTokenHash))
+                return 'voice';
+        }
+        catch {
+            /* absent credential */
+        }
+        return undefined;
     }
-    catch {
+    async rotateVoice() {
+        const old = JSON.parse(await readFile(this.file, 'utf8'));
         const token = randomBytes(32).toString('base64url');
-        await this.save({ tokenHash: hash(token), createdAt: new Date().toISOString() });
-        return { token };
-    } }
-    async save(data) { await writeFile(this.file, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 }); await chmod(this.file, 0o600); }
-    async verify(token) { try {
-        const data = JSON.parse(await readFile(this.file, 'utf8'));
-        const a = Buffer.from(hash(token));
-        const b = Buffer.from(data.tokenHash);
-        return a.length === b.length && timingSafeEqual(a, b);
-    }
-    catch {
-        return false;
-    } }
-    async rotate() { const token = randomBytes(32).toString('base64url'); const old = JSON.parse(await readFile(this.file, 'utf8')); await this.save({ ...old, tokenHash: hash(token), rotatedAt: new Date().toISOString() }); return token; }
+        await this.save({ ...old, voiceTokenHash: hash(token), voiceTokenCreatedAt: new Date().toISOString() });
+        return token;
+    }
+    async revokeVoice() {
+        const old = JSON.parse(await readFile(this.file, 'utf8'));
+        delete old.voiceTokenHash;
+        delete old.voiceTokenCreatedAt;
+        await this.save(old);
+    }
+    async rotate() {
+        const token = randomBytes(32).toString('base64url');
+        const old = JSON.parse(await readFile(this.file, 'utf8'));
+        await this.save({ ...old, tokenHash: hash(token), rotatedAt: new Date().toISOString() });
+        return token;
+    }
+    async setToken(token) {
+        validateToken(token);
+        let data;
+        try {
+            data = JSON.parse(await readFile(this.file, 'utf8'));
+        }
+        catch {
+            await this.save({ tokenHash: hash(token), createdAt: new Date().toISOString() });
+            return;
+        }
+        await this.save({ ...data, tokenHash: hash(token), rotatedAt: new Date().toISOString() });
+    }
 }

package/dist/collab/baseline.js

@@ -0,0 +1,84 @@
+import { execFile, spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+/** Anchors every round to an immutable code state so round N+1 verdicts are not made against round N's memory. */
+export const gitBaseline = async ({ cwd, subject }) => {
+    const git = async (args) => (await run('git', args, { cwd })).stdout;
+    try {
+        const commit = (await git(['rev-parse', 'HEAD'])).trim();
+        let dirtyHash;
+        const status = await git(['status', '--porcelain', '-z']);
+        if (status) {
+            const untracked = (await git(['ls-files', '--others', '--exclude-standard', '-z']))
+                .split('\0')
+                .filter(Boolean)
+                .sort();
+            // Hashed as a stream, never buffered. A working tree diff can be tens of megabytes, and a diff dropped for
+            // exceeding a buffer would leave a hash of nothing but file names - identical before and after an edit to
+            // those same files, which is exactly what `assertBaselineCurrent()` exists to catch.
+            const hash = createHash('sha256').update(status);
+            await hashStream(hash, spawn('git', ['diff', 'HEAD', '--binary'], { cwd, stdio: ['ignore', 'pipe', 'ignore'] }));
+            for (const relative of untracked) {
+                hash.update(relative).update('\0');
+                // A file removed during capture is already represented by status.
+                await hashStream(hash, createReadStream(path.join(cwd, relative))).catch(() => { });
+            }
+            dirtyHash = `sha256:${hash.digest('hex')}`;
+        }
+        // A commit range such as `main...feature` is only a name: either endpoint can move while HEAD and the
+        // working tree stay identical, which would silently change the code under review. Resolve both endpoints
+        // so the pinned identity covers the range, not just its spelling.
+        let rangeResolved;
+        if (subject.type === 'commit_range') {
+            const expression = subject.value.trim();
+            const endpoints = expression.includes('...')
+                ? expression.split('...')
+                : expression.includes('..')
+                    ? expression.split('..')
+                    : [expression];
+            const resolved = [];
+            for (const endpoint of endpoints) {
+                const name = endpoint.trim();
+                resolved.push(name
+                    ? (await git(['rev-parse', '--verify', `${name}^{commit}`]).catch(() => '')).trim() ||
+                        `unresolved:${name}`
+                    : 'HEAD');
+            }
+            rangeResolved = resolved.join('...');
+        }
+        return {
+            vcs: 'git',
+            commit,
+            range: subject.type === 'commit_range' ? subject.value : undefined,
+            rangeResolved,
+            dirtyHash,
+            paths: subject.type === 'paths'
+                ? subject.value
+                    .split(/[\n,]/)
+                    .map(value => value.trim())
+                    .filter(Boolean)
+                : []
+        };
+    }
+    catch {
+        // Not a git checkout (or git is missing). The hub still works; it just cannot prove code identity.
+        return { vcs: 'none', paths: [] };
+    }
+};
+/** Feeds one stream into a hash, rejecting on failure so a partial read can never pass as "nothing changed". */
+function hashStream(hash, source) {
+    const process = 'stdout' in source ? source : undefined, stream = (process ? process.stdout : source);
+    return new Promise((resolve, reject) => {
+        if (!stream)
+            return reject(new Error('Stream is not readable'));
+        stream.on('data', chunk => hash.update(chunk));
+        stream.on('error', reject);
+        if (!process)
+            return void stream.on('end', resolve);
+        process.on('error', reject);
+        process.on('close', code => (code === 0 ? resolve() : reject(new Error(`git exited with ${code}`))));
+    });
+}

package/dist/collab/dispatcher.js

@@ -0,0 +1,221 @@
+const BUSY_STATES = ['starting', 'streaming', 'waiting_for_user', 'stopping'];
+/** How long after a session finished a still-undelivered closing note is worth retrying. */
+const CLOSING_NOTE_RETRY_WINDOW_MS = 24 * 3600_000;
+export class CollabDispatcher {
+    hub;
+    deps;
+    unsubscribe;
+    pending = new Map();
+    inFlight = new Map();
+    /** Last delivered task key per participant, so a re-emitted assignment does not spam the agent. */
+    delivered = new Map();
+    closed = false;
+    constructor(hub, deps) {
+        this.hub = hub;
+        this.deps = deps;
+    }
+    start() {
+        if (this.unsubscribe || this.closed)
+            return;
+        this.unsubscribe = this.hub.subscribe(event => this.onEvent(event));
+        this.resumePending();
+    }
+    /**
+     * Wake-ups are triggered by events, and events are not replayed after a restart. Without this,
+     * a managed agent whose task was queued before the restart would wait forever. Recently finished sessions are
+     * scanned too: a crash between `announceFinish()` and the delayed dispatch would otherwise leave the closing
+     * note undelivered. A delivered note is acked, so this never re-fires for a note that did arrive.
+     */
+    resumePending() {
+        try {
+            this.hub.recoverEarlyIssueVotes();
+            const cutoff = Date.now() - CLOSING_NOTE_RETRY_WINDOW_MS;
+            const finished = this.hub.store.listSessions({ status: 'finished', limit: 50 });
+            for (const session of [...this.hub.store.listSessions({ status: 'active', limit: 200 }), ...finished]) {
+                const stale = session.status !== 'active' && Date.parse(session.updatedAt) < cutoff;
+                for (const participant of this.hub.store.listParticipants(session.sessionId)) {
+                    if (!participant.agentId || participant.state !== 'active')
+                        continue;
+                    const pending = this.hub.store.listInbox(participant.participantId);
+                    const last = pending[pending.length - 1];
+                    // A finished session only ever has one deliverable left: its closing note.
+                    if (!last || (session.status !== 'active' && last.type !== 'session_result'))
+                        continue;
+                    // Past the retry window nobody is waiting any more: stop re-trying.
+                    if (stale) {
+                        this.hub.completeDelivery(participant.participantId, 'session_result');
+                        continue;
+                    }
+                    this.schedule(session.sessionId, participant.participantId, last.type);
+                }
+            }
+        }
+        catch (error) {
+            this.deps.log?.(`Collab dispatch resume failed: ${error.message}`);
+        }
+    }
+    async stop() {
+        this.closed = true;
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        for (const timer of this.pending.values())
+            clearTimeout(timer);
+        this.pending.clear();
+        await Promise.allSettled([...this.inFlight.values()]);
+    }
+    /** Test seam: waits until every scheduled wake-up has been attempted. */
+    async drain() {
+        for (let guard = 0; guard < 50 && (this.pending.size || this.inFlight.size); guard++) {
+            await Promise.allSettled([...this.inFlight.values()]);
+            if (this.pending.size)
+                await new Promise(resolve => setTimeout(resolve, (this.deps.delayMs ?? 150) + 10));
+        }
+        await Promise.allSettled([...this.inFlight.values()]);
+    }
+    onEvent(event) {
+        if (event.type !== 'task_assigned')
+            return;
+        const participantId = String(event.payload.participantId ?? ''), task = String(event.payload.task ?? '');
+        if (!participantId || !task)
+            return;
+        this.schedule(event.sessionId, participantId, task);
+    }
+    schedule(sessionId, participantId, task) {
+        if (this.closed)
+            return;
+        const existing = this.pending.get(participantId);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            this.pending.delete(participantId);
+            void this.enqueue(sessionId, participantId, task);
+        }, this.deps.delayMs ?? 150);
+        timer.unref?.();
+        this.pending.set(participantId, timer);
+    }
+    /** One wake-up at a time per participant: two overlapping prompts would race inside the agent. */
+    enqueue(sessionId, participantId, task) {
+        const previous = this.inFlight.get(participantId) ?? Promise.resolve();
+        const job = previous.catch(() => { }).then(() => this.wake(sessionId, participantId, task));
+        const tracked = job.finally(() => {
+            if (this.inFlight.get(participantId) === tracked)
+                this.inFlight.delete(participantId);
+        });
+        this.inFlight.set(participantId, tracked);
+        return tracked;
+    }
+    async wake(sessionId, participantId, task) {
+        let participant;
+        try {
+            participant = this.hub.store.getParticipant(participantId);
+        }
+        catch {
+            return;
+        }
+        const agentId = participant.agentId;
+        if (!agentId) {
+            // only a pre-managed-only row can get here
+            this.hub.logDispatch(sessionId, 'dispatch_failed', { participantId, task, reason: 'NO_AGENT_BOUND' });
+            return;
+        }
+        if (participant.state !== 'active')
+            return; // left or out of budget: a human has to act
+        if (this.deps.isCollabAgent?.(agentId) === false) {
+            // undefined: the check is not wired up
+            this.hub.logDispatch(sessionId, 'dispatch_failed', {
+                participantId,
+                agentId,
+                task,
+                reason: 'COLLAB_PROFILE_REQUIRED'
+            });
+            this.deps.log?.(`Collab dispatch skipped for ${participant.displayName}: the Agent is not profile=collab.`);
+            return;
+        }
+        const session = this.hub.store.findSession(sessionId);
+        // A human may reopen a review while the previous closing note is still scheduled. Never deliver that stale
+        // "finished" message into a new active cycle, and do not retire the freshly rotated credential with it.
+        const terminal = task === 'session_result';
+        if (!session)
+            return;
+        if (terminal && session.status !== 'finished') {
+            this.hub.completeDelivery(participantId, task);
+            return;
+        }
+        if (!terminal && session.status !== 'active')
+            return;
+        // Delivery is serialised per seat and a `command()` only resolves when the agent's turn ends, so a wake-up
+        // queued at the start of a phase can arrive after the panel has already moved past it. Waking an agent to
+        // tell it "nothing to do" costs a full model turn, so the queued item is retired instead.
+        if (!terminal && this.hub.currentTaskFor(participantId) === 'wait') {
+            this.hub.completeDelivery(participantId, task);
+            this.delivered.delete(participantId);
+            this.hub.logDispatch(sessionId, 'dispatch_skipped', {
+                participantId,
+                agentId,
+                task,
+                reason: 'NOTHING_OWED',
+                phase: session.phase,
+                round: session.round
+            });
+            return;
+        }
+        // The bound agent is part of the identity of a delivery: after a rebind the *new* agent has received
+        // nothing, so a key without it matches the old delivery and leaves the replacement agent idle.
+        const key = `${agentId}:${task}:${session.phase}:${session.round}:${session.debateRound}`;
+        // The prompt was already accepted in this process. Keep the durable item until collab_get_task actually
+        // collects it: followUp() only queues work and may be lost if the process stops before the next turn.
+        if (this.delivered.get(participantId) === key)
+            return;
+        const status = this.deps.agentStatus(agentId);
+        const kind = status && BUSY_STATES.includes(status) ? 'follow-up' : 'prompt';
+        try {
+            await this.deps.command(agentId, kind, toolBriefing({ session, participant, task }));
+            this.delivered.set(participantId, key);
+            this.hub.logDispatch(sessionId, 'agent_dispatched', {
+                participantId,
+                agentId,
+                task,
+                kind,
+                phase: session.phase,
+                round: session.round
+            });
+            // Normal work is acknowledged by collab_get_task, not here: followUp() returning means queued, not run.
+            // A closing note has no tool collection step, so successful completion remains its acknowledgement.
+            if (terminal) {
+                this.hub.completeDelivery(participantId, task);
+                this.delivered.delete(participantId);
+            }
+        }
+        catch (error) {
+            this.hub.logDispatch(sessionId, 'dispatch_failed', {
+                participantId,
+                agentId,
+                task,
+                reason: error.message
+            });
+            this.deps.log?.(`Collab dispatch to agent ${agentId} failed: ${error.message}`);
+            // The note did NOT arrive, so the item stays unacked: a restart retries it inside
+            // CLOSING_NOTE_RETRY_WINDOW_MS.
+        }
+    }
+}
+/** The only dispatcher prompt. Transport credentials/URLs, opaque ids, and task JSON stay in the Pi extension; the human-authored review request is repeated here deliberately. */
+export function toolBriefing(input) {
+    if (input.task === 'session_result') {
+        const verdict = typeof input.session.outcome?.verdict === 'string' ? ` Result: ${input.session.outcome.verdict}.` : '';
+        return `[pi2web collaboration] This local code collaboration is finished.${verdict} Nothing further is required; end your turn.`;
+    }
+    return [
+        '[pi2web collaboration] You have a local code collaboration task.',
+        `role: ${input.participant.role}; action: ${input.task}; working directory: ${input.session.cwd}`,
+        `user request: ${input.session.subject.value}`,
+        ...(input.session.subject.notes ? [`user notes: ${input.session.subject.notes}`] : []),
+        ...(input.task === 'implement'
+            ? []
+            : [
+                'This is a non-mutating task. You may use bash to inspect (for example git diff/log), but do not create, delete, rename, or modify anything under the working directory, including redirected output, scratch files, generated files, caches, or formatter changes.'
+            ]),
+        'Call collab_get_task first. It repeats the request, supplies the pinned baseline and activates the exact collab_submit_* tool; use that tool to record the complete result.',
+        'Do not use curl, construct URLs, handle credentials, contact other agents, sleep, or poll. End your turn after submitting.'
+    ].join('\n');
+}