@astrosheep/square 0.4.0 → 0.4.1

package/dist/plugins/opencode/delivery.js

@@ -1,223 +0,0 @@
-import { createHash } from 'node:crypto';
-import { squareWakeProjection } from '../../wake-preview.js';
-import { channelArtifact, createArtifactPort } from '../../artifact.js';
-import { deliverPending } from '../../delivery-operations.js';
-import { nativePendingSource, observeSessionPending, projectSessionSeats } from '../../inbox.js';
-import { automaticWakeEligible, nativePendingHead, presentationBlocksWake } from '../../delivery.js';
-import { harnessOwner, decodeHarnessOwner } from '../../owner.js';
-import { formatMessageId, parseMessageId } from '../../message.js';
-import { indexedSquareEntries } from '../../square-index.js';
-import { asSeatRef } from '../../seats.js';
-import { restoreSessionSeats } from '../../session-lifecycle.js';
-import { presentPending } from '../../presentation-operations.js';
-import { createNativeInputId, sendNativeText } from '../../packages/agent-delivery/src/opencode-native.js';
-const routeKind = 'opencode-server';
-const ownerFor = (sessionId) => harnessOwner({ channel: 'opencode', session: sessionId });
-const payloadHash = (payload) => createHash('sha256').update(payload).digest('hex');
-export async function indexedOpenCodeSessions(env) {
-    return [...new Set((await indexedSquareEntries({}, env)).flatMap((entry) => {
-            const coordinate = decodeHarnessOwner(entry.owner);
-            return coordinate?.channel === 'opencode' ? [coordinate.session] : [];
-        }))];
-}
-export async function discoverOpenCodeSeats(sessionId, env, signal) {
-    return projectSessionSeats({ owner: ownerFor(sessionId), env }, signal);
-}
-function sameSeat(left, right) {
-    return left !== undefined && left.attachment === 'attached' && left.generation === right.generation && left.owner === right.owner;
-}
-function createOpenCodeWakeTransport(target, lifetime) {
-    return {
-        probe: async (route) => !lifetime.aborted && route.kind === routeKind
-            && route.address.sessionId === target.sessionId,
-        async attempt(request, timeoutMs, beforeSend) {
-            const presentation = request.presentation;
-            if (request.claimToken === undefined || parseMessageId(request.message) === undefined || presentation === undefined
-                || request.route.kind !== routeKind || request.route.address.sessionId !== target.sessionId) {
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention has no matching artifact claim or session.' };
-            }
-            const signal = AbortSignal.any([lifetime, AbortSignal.timeout(timeoutMs)]);
-            const started = Date.now();
-            if (signal.aborted || !await beforeSend())
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention changed before send.' };
-            const inputId = createNativeInputId();
-            const correlation = { harness: 'opencode', token: inputId, payloadHash: payloadHash(presentation.payload) };
-            if (!await request.channel.prepare({ correlation,
-                coverage: presentation.coverage, ...(presentation.description === undefined ? {} : { description: presentation.description }) }, signal))
-                return { outcome: 'not-capable', diagnostic: 'OpenCode delivery claim is no longer current.' };
-            if (signal.aborted || !await beforeSend())
-                return { outcome: 'not-capable', diagnostic: 'OpenCode attention was consumed before send.' };
-            const result = await sendNativeText(target, presentation.payload, {
-                inputId, delivery: 'steer', timeoutMs: Math.max(1, timeoutMs - (Date.now() - started)), signal,
-            });
-            if (result.state === 'accepted')
-                return { outcome: 'accepted' };
-            if (result.state === 'unavailable')
-                return { outcome: 'failed', signature: result.code };
-            return { outcome: 'unknown', signature: result.code };
-        },
-    };
-}
-function textMessage(message) {
-    if (message.role !== 'user' || message.id === undefined || !message.content.every((part) => part.type === 'text' && typeof part.text === 'string'))
-        return undefined;
-    return message.content.map((part) => part.text).join('');
-}
-/** The exact prepared native message can authorize artifact-backed presentation once. */
-export async function observeOpenCodeContext(sessionId, messages, env, signal) {
-    const observed = new Map(messages.flatMap((message) => {
-        const text = textMessage(message);
-        return text === undefined ? [] : [[message.id, payloadHash(text)]];
-    }));
-    if (observed.size === 0 || signal.aborted)
-        return;
-    for (const { location, seat } of await discoverOpenCodeSeats(sessionId, env, signal)) {
-        if (signal.aborted)
-            return;
-        const artifact = createArtifactPort(location, undefined, signal);
-        try {
-            const { value: matches } = await artifact.read((facts) => {
-                if (!sameSeat(facts.seat(seat.participant), seat))
-                    return [];
-                return facts.deliveryEvidence(seat.participant, seat.generation).flatMap((evidence) => {
-                    const token = evidence.correlation?.harness === 'opencode' ? evidence.correlation.token : undefined;
-                    const hash = token === undefined ? undefined : observed.get(token);
-                    const index = parseMessageId(evidence.message), now = Date.now();
-                    if (token === undefined || hash === undefined || evidence.claimToken === undefined || index === undefined
-                        || evidence.route === undefined || !['dispatching', 'unknown', 'accepted'].includes(evidence.outcome)
-                        || evidence.correlation?.payloadHash !== hash
-                        || evidence.route.kind !== routeKind
-                        || presentationBlocksWake(facts.deliveryEvidence(seat.participant, seat.generation, evidence.message), now))
-                        return [];
-                    const source = nativePendingSource(facts, { location, participant: seat.participant, generation: seat.generation,
-                        owner: seat.owner, index, route: evidence.route, now });
-                    if (source === undefined)
-                        return [];
-                    return [{ evidence, index, hash, clipped: evidence.coverage === 'clipped' }];
-                });
-            }, signal);
-            for (const { evidence, index, hash, clipped } of matches) {
-                if (signal.aborted || evidence.claimToken === undefined)
-                    return;
-                await presentPending({ artifact, location, participant: seat.participant,
-                    message: formatMessageId(index), seat: asSeatRef(seat), observationOf: evidence.claimToken, sink: { present() { } }, markSeen: !clipped, signal,
-                    current: (facts) => {
-                        const correlation = facts.deliveryByToken(evidence.claimToken);
-                        return nativePendingHead(facts, { location, participant: seat.participant, generation: seat.generation,
-                            owner: seat.owner, index, route: evidence.route, now: Date.now() }) !== undefined
-                            && ['dispatching', 'unknown', 'accepted'].includes(correlation?.outcome ?? '')
-                            && correlation?.correlation?.harness === 'opencode'
-                            && correlation.correlation.token !== undefined
-                            && correlation.correlation.payloadHash === hash;
-                    },
-                });
-            }
-        }
-        finally {
-            await artifact.close();
-        }
-    }
-}
-/** The native receiver owns no claims outside the artifact; HOME is used only for discovery. */
-export async function receiveOpenCodePending(target, env, signal) {
-    const observer = await observeSessionPending(ownerFor(target.sessionId), env);
-    const transport = createOpenCodeWakeTransport(target, signal);
-    let waiting;
-    try {
-        while (!signal.aborted) {
-            const armed = new Promise((resolve) => {
-                waiting = observer.wait(Infinity, { signal, skipImmediate: true, onChangeArmed: resolve });
-                void waiting.catch(() => resolve(false));
-            });
-            if (!await armed) {
-                await waiting;
-                break;
-            }
-            for (const membership of await observer.read({ signal })) {
-                const { location, seat } = membership;
-                if (signal.aborted)
-                    return;
-                const artifact = createArtifactPort(location, undefined, signal);
-                try {
-                    const { value: notifications } = await artifact.read((facts) => {
-                        if (!sameSeat(facts.seat(seat.participant), seat))
-                            return [];
-                        return membership.notifications.filter((note) => automaticWakeEligible(facts.deliveryEvidence(seat.participant, seat.generation, formatMessageId(note.messageIndex)), Date.now()));
-                    }, signal);
-                    for (const note of notifications) {
-                        if (signal.aborted)
-                            return;
-                        await deliverPending({ artifact: channelArtifact(artifact), preparePresentation: squareWakeProjection(artifact), transport, location, message: formatMessageId(note.messageIndex), now: Date.now() });
-                    }
-                }
-                catch (error) {
-                    if (signal.aborted)
-                        throw signal.reason ?? error;
-                    // A candidate that became unreadable cannot authorize sending; the shared observer
-                    // keeps its subscription and will reconsider the artifact after repair.
-                }
-                finally {
-                    await artifact.close();
-                }
-            }
-            await waiting;
-            waiting = undefined;
-        }
-    }
-    catch (error) {
-        if (!signal.aborted)
-            throw error;
-    }
-    finally {
-        observer.close();
-        await waiting?.catch(() => { });
-    }
-}
-/** Publish the native address into current artifact seats; the legacy route projection is not read. */
-export async function publishOpenCodeAddress(sessionId, env, signal) {
-    await restoreSessionSeats(ownerFor(sessionId), env, { kind: routeKind, address: { sessionId } }, signal);
-    const seats = (await discoverOpenCodeSeats(sessionId, env, signal)).filter(({ seat }) => seat.attachment === 'attached');
-    for (const { location, seat } of seats) {
-        if (signal.aborted)
-            return false;
-        const artifact = createArtifactPort(location, undefined, signal);
-        try {
-            await artifact.transactAs({ kind: 'participant', seat: asSeatRef(seat) }, (facts) => facts.updateWakeAddress(asSeatRef(seat), { kind: routeKind, address: { sessionId } }));
-        }
-        finally {
-            await artifact.close();
-        }
-    }
-    return seats.length > 0;
-}
-export async function cancelOpenCodeDeliveries(sessionId, env, signal) {
-    for (const { location, seat } of await discoverOpenCodeSeats(sessionId, env, signal)) {
-        if (signal.aborted)
-            return;
-        if (seat.attachment !== 'attached')
-            continue;
-        const artifact = createArtifactPort(location, undefined, signal);
-        try {
-            const { value: through } = await artifact.read((facts) => facts.channel.header().lastMessageIndex, signal);
-            if (through >= 0)
-                await artifact.cancelDeliveries(asSeatRef(seat), through, signal);
-        }
-        finally {
-            await artifact.close();
-        }
-    }
-}
-export async function endOpenCodeSession(sessionId, env, signal) {
-    for (const { location, seat } of await discoverOpenCodeSeats(sessionId, env, signal)) {
-        if (signal.aborted)
-            return;
-        const { Square } = await import('../../square-api.js');
-        const square = await Square.at({ path: location, env });
-        try {
-            await square.endHeld(seat.participant, { owner: seat.owner, generation: seat.generation });
-        }
-        finally {
-            await square.close();
-        }
-    }
-}

package/dist/presentation-operations.d.ts

@@ -1,5 +0,0 @@
-import type { PresentationResult, PresentPendingInput } from './ports.js';
-/** Prepare custody before any external effect. A batch prepares every included item first. */
-export declare function preparePendingPresentation(input: Omit<PresentPendingInput, 'sink'>): Promise<import("./delivery-effects.js").PreparedPresentation<import("./channel-ports.js").MessageFact> | undefined>;
-/** A sink error cannot prove that content was never injected. */
-export declare function presentPending(input: PresentPendingInput): Promise<PresentationResult>;

package/dist/presentation-operations.js

@@ -1,86 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { formatMessageId, parseMessageId } from './message.js';
-import { isSquareError } from './model.js';
-import { pendingHead, sameJoin } from './delivery.js';
-import { deliveryDeferralExpiry } from './delivery-deferral.js';
-import { asSeatRef } from './seats.js';
-import { preparePresentation, presentPrepared } from './delivery-effects.js';
-/** Prepare custody before any external effect. A batch prepares every included item first. */
-export async function preparePendingPresentation(input) {
-    const named = input.message;
-    const index = typeof named === 'number' ? named : parseMessageId(named);
-    if (index === undefined)
-        return undefined;
-    const initial = await input.artifact.read((facts) => {
-        const seat = facts.channel.endpoint(input.participant);
-        if (seat === undefined || seat.attachment !== 'attached' || input.generation !== undefined && input.generation !== seat.generation
-            || input.seat !== undefined && (input.seat.generation !== seat.generation || input.seat.owner !== seat.owner)
-            || input.current?.(facts) === false || !pendingHead(facts, input.participant, index)
-            || deliveryDeferralExpiry(facts.channel, seat, index, input.now ?? Date.now()) !== undefined)
-            return undefined;
-        const item = facts.channel.message(index);
-        return item === undefined ? undefined : { participant: { name: input.participant, generation: seat.generation }, seat, item };
-    }, input.signal).catch(() => undefined);
-    if (initial?.value === undefined)
-        return undefined;
-    const { participant, seat, item } = initial.value;
-    const ref = asSeatRef(seat);
-    const owns = (facts) => {
-        const current = facts.seat(seat.participant);
-        return current !== undefined && current.attachment === 'attached' && current.owner === seat.owner && current.generation === seat.generation
-            && sameJoin(facts, participant);
-    };
-    const claimToken = randomUUID();
-    return preparePresentation({
-        payload: item, coverage: input.markSeen === false ? 'clipped' : 'full',
-        port: {
-            async claim(signal) {
-                const claimed = await input.artifact.claimDelivery({ seat: ref, message: formatMessageId(index), kind: 'presentation',
-                    observationOf: input.observationOf, at: input.now ?? Date.now(), leaseMs: input.timeoutMs ?? 5000, claimToken }, signal).catch(() => ({ status: 'stale' }));
-                return claimed.status === 'acquired' ? { token: claimToken, ordinal: claimed.attemptN } : undefined;
-            },
-            async current(signal) {
-                return (await input.artifact.read(facts => owns(facts) && input.current?.(facts) !== false
-                    && pendingHead(facts, participant.name, index) !== undefined
-                    && deliveryDeferralExpiry(facts.channel, seat, index, input.now ?? Date.now()) === undefined, signal ?? input.signal)).value;
-            },
-            async settle(claim, completion) {
-                const success = completion.outcome === 'presented' || completion.outcome === 'clipped';
-                const { value } = await input.artifact.settleAs({ kind: 'participant', seat: ref }, facts => {
-                    // Captured ownership fences truth; post-effect policy/cancellation cannot veto it.
-                    if (!owns(facts))
-                        return false;
-                    if (!facts.channel.completeDelivery({ seat: ref, message: formatMessageId(index), claimToken: claim.token,
-                        outcome: completion.outcome, at: success ? input.now ?? Date.now() : Date.now(),
-                        ...(completion.reason === 'threw' ? { messageText: completion.error instanceof Error ? completion.error.message : String(completion.error) } : {}),
-                    }))
-                        return false;
-                    if (completion.outcome === 'presented')
-                        facts.channel.markSeen(participant.name, [index], input.now ?? Date.now());
-                    return true;
-                }).catch(error => {
-                    if (!success || isSquareError(error) && error.code === 'already_joined')
-                        return { value: false };
-                    throw error;
-                });
-                return value;
-            },
-        },
-    }, { signal: input.signal });
-}
-/** A sink error cannot prove that content was never injected. */
-export async function presentPending(input) {
-    const prepared = await preparePendingPresentation(input);
-    if (prepared === undefined)
-        return { presented: false };
-    const report = await presentPrepared(prepared, message => input.sink.present(message), {
-        signal: input.signal,
-    });
-    if (report.observation.kind === 'threw')
-        throw report.observation.error;
-    const result = report.settlements[0].result;
-    if (result.persistence.status === 'error')
-        throw result.persistence.error;
-    return report.observation.kind === 'returned' && result.persistence.status === 'recorded'
-        ? { presented: true, message: prepared.payload } : { presented: false };
-}

package/dist/sqlite-channel.d.ts

@@ -1,15 +0,0 @@
-import type { DatabaseSync } from 'node:sqlite';
-import type { ChannelWrite, MessageAddressFact, EndpointFact, ReceiveClaimFact, ChannelDeliveryEvidence } from './channel-ports.js';
-import { type DeliveryDeferralFact } from './delivery-deferral.js';
-import { type EndpointGeneration } from './message.js';
-import { type Row } from './sqlite-values.js';
-export declare function messageAddress(row: Row): MessageAddressFact;
-export declare function endpointGeneration(value: unknown): EndpointGeneration;
-export declare function endpoint(row: Row): EndpointFact;
-export declare function deliveryEvidence(row: Row, payload?: Record<string, unknown>): ChannelDeliveryEvidence;
-export declare function deliveryDeferral(row: Row): DeliveryDeferralFact;
-export declare function receiveClaim(row: Row): ReceiveClaimFact;
-export declare function createChannelSqlite(db: DatabaseSync): ChannelWrite & {
-    readonly changed: boolean;
-    readonly deliveryChanged: boolean;
-};