pi2web 0.2.1 → 0.2.8

package/dist/auth.js

@@ -58,7 +58,9 @@ export class AuthStore {
             if (same(data.voiceTokenHash))
                 return 'voice';
         }
-        catch { /* absent credential */ }
+        catch {
+            /* absent credential */
+        }
         return undefined;
     }
     async rotateVoice() {

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

@@ -86,7 +86,10 @@ export class CollabDispatcher {
         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);
+        const timer = setTimeout(() => {
+            this.pending.delete(participantId);
+            void this.enqueue(sessionId, participantId, task);
+        }, this.deps.delayMs ?? 150);
         timer.unref?.();
         this.pending.set(participantId, timer);
     }
@@ -94,8 +97,10 @@ export class CollabDispatcher {
     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); });
+        const tracked = job.finally(() => {
+            if (this.inFlight.get(participantId) === tracked)
+                this.inFlight.delete(participantId);
+        });
         this.inFlight.set(participantId, tracked);
         return tracked;
     }
@@ -108,14 +113,21 @@ export class CollabDispatcher {
             return;
         }
         const agentId = participant.agentId;
-        if (!agentId) { // only a pre-managed-only row can get here
+        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' });
+        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;
         }
@@ -137,7 +149,14 @@ export class CollabDispatcher {
         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 });
+            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
@@ -152,7 +171,14 @@ export class CollabDispatcher {
         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 });
+            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) {
@@ -161,7 +187,12 @@ export class CollabDispatcher {
             }
         }
         catch (error) {
-            this.hub.logDispatch(sessionId, 'dispatch_failed', { participantId, agentId, task, reason: error.message });
+            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.
@@ -179,7 +210,11 @@ export function toolBriefing(input) {
         `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.']),
+        ...(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');