@astrosheep/square 0.4.0 → 0.4.2

package/dist/square-index.js

@@ -1,106 +0,0 @@
-import { promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { withFileLock } from './file-lock.js';
-import { canonicalPath } from './canonical-path.js';
-import { observeFileMetadata } from './file-changes.js';
-import { validateOwner } from './neutral.js';
-export function squareIndexPath(env = process.env) {
-    const configured = env.SQUARE_INDEX?.trim();
-    return path.resolve(configured ?? path.join(os.homedir(), '.square', 'index.ndjsonl'));
-}
-function lockPath(index) {
-    return `${index}.lock`;
-}
-function validEntry(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const row = value;
-    if (typeof row.location !== 'string' || !path.isAbsolute(row.location) || typeof row.owner !== 'string')
-        return undefined;
-    try {
-        validateOwner(row.owner);
-    }
-    catch {
-        return undefined;
-    }
-    if (Object.keys(row).some((key) => !['location', 'owner'].includes(key)))
-        return undefined;
-    return { location: row.location, owner: row.owner };
-}
-async function readEntries(index) {
-    let content;
-    try {
-        content = await fs.readFile(index, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-    const entries = [];
-    for (const line of content.split('\n')) {
-        if (line.trim() === '')
-            continue;
-        try {
-            const entry = validEntry(JSON.parse(line));
-            if (entry !== undefined)
-                entries.push(entry);
-        }
-        catch { /* Disposable discovery input. */ }
-    }
-    return entries;
-}
-function matches(entry, query) {
-    return query.owner === undefined || entry.owner === query.owner;
-}
-export async function indexedSquareEntries(query = {}, env = process.env) {
-    const entries = await readEntries(squareIndexPath(env));
-    const result = [];
-    const seen = new Set();
-    for (const entry of entries) {
-        if (!matches(entry, query))
-            continue;
-        let location;
-        try {
-            location = await canonicalPath(entry.location);
-        }
-        catch {
-            continue;
-        }
-        const key = JSON.stringify([location, entry.owner]);
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        result.push({ location, owner: entry.owner });
-    }
-    return result;
-}
-export async function indexedSquarePaths(query = {}, env = process.env) {
-    return [...new Set((await indexedSquareEntries(query, env)).map((entry) => entry.location))];
-}
-/** Best-effort discovery only: a busy index skips publication, never queues or delays artifact work. */
-export async function rememberSquarePath(location, owner, index) {
-    validateOwner(owner);
-    const canonical = await canonicalPath(location);
-    await fs.mkdir(path.dirname(index), { recursive: true });
-    return await withFileLock(lockPath(index), { retryMs: 10, skipIfBusy: true }, async () => {
-        const entries = await readEntries(index);
-        if (entries.some((entry) => entry.location === canonical && entry.owner === owner))
-            return false;
-        const next = [...entries, { location: canonical, owner }];
-        const temporary = `${index}.${process.pid}.${randomUUID()}.tmp`;
-        try {
-            await fs.writeFile(temporary, next.map((entry) => JSON.stringify(entry)).join('\n') + '\n', { flag: 'wx', mode: 0o600 });
-            await fs.rename(temporary, index);
-        }
-        finally {
-            await fs.rm(temporary, { force: true });
-        }
-        return true;
-    }) ?? false;
-}
-export function observeSquareIndex(env = process.env) {
-    return observeFileMetadata(squareIndexPath(env));
-}

package/dist/wake-preview.d.ts

@@ -1,7 +0,0 @@
-import type { WakeProjectionContext, WakeProjection, SquareArtifactPort } from './ports.js';
-export declare function squareWakeProjection(artifact: SquareArtifactPort): WakeProjection;
-/** Agora-framed projection over the narrow captured delivery context. */
-export declare function wakePreview(facts: import('./ports.js').SquareRead, request: WakeProjectionContext): {
-    payload: string;
-    coverage: "full" | "clipped";
-} | undefined;

package/dist/wake-preview.js

@@ -1,15 +0,0 @@
-import { parseMessageId } from './message.js';
-import { nativePendingPreview } from './inbox.js';
-import { canonicalPathSync } from './canonical-path.js';
-export function squareWakeProjection(artifact) {
-    return async (context) => (await artifact.read(facts => wakePreview(facts, context))).value;
-}
-/** Agora-framed projection over the narrow captured delivery context. */
-export function wakePreview(facts, request) {
-    const index = parseMessageId(request.message);
-    if (index === undefined)
-        return undefined;
-    const preview = nativePendingPreview(facts, { location: canonicalPathSync(request.location), participant: request.participant,
-        generation: request.seat.generation, owner: request.seat.owner, index, route: request.route, now: Date.now() });
-    return preview === undefined ? undefined : { payload: preview.payload, coverage: preview.clipped ? 'clipped' : 'full' };
-}

package/plugins/claude/hooks/register.js

@@ -1,132 +0,0 @@
-// Claude Code mod. No Node imports, shell interpolation, or child credentials.
-const hasToken = (text) => typeof text === 'string' && /(?:^|\n)\[square-inbox:[a-zA-Z0-9-]+\](?:\n|$)/.test(text);
-
-async function coordinate($) {
-  return { sessionId: await $.session.id(), cwd: await $.session.cwd(), version: (await $.session.version()).version, endpoint: await $.env.get('CLAUDE_CODE_MESSAGING_SOCKET') };
-}
-async function bridge($, value, budget = 2800) {
-  const result = await $.process.run(['square', 'claude-mod'], { cwd: value.cwd, stdin: JSON.stringify(value), timeoutMs: Math.max(1, Math.min(2800, budget)) });
-  if (result.exitCode !== 0 || result.isStdoutTruncated) throw new Error('Square native inbox bridge unavailable');
-  return JSON.parse(result.stdout);
-}
-async function snapshot($, id) { return (await $.state.get({ plugin: 'square', key: 'inbox', id })).value; }
-async function cancellation($, id) { return (await $.state.get({ plugin: 'square', key: 'cancelAt', id })).value; }
-function confirmLater($, c, operation, text) {
-  // State reads are dispatch snapshots. This ONE fresh timer dispatch is not polling.
-  // Reload cancels it; lost evidence stays unknown and is never blindly replayed.
-  try { $.clock.after(0, () => {
-    (async () => {
-      if (await $.session.id() !== c.sessionId) return;
-      const old = await snapshot($, c.sessionId);
-      const cancelled = await cancellation($, c.sessionId);
-      await bridge($, { ...c, cancelAt: cancelled?.at, cancelledBindings: cancelled?.bindings, bindings: old?.bindings, operation, text });
-    })().catch(() => undefined);
-  }); } catch { /* denied scheduling leaves evidence unknown, never a second next */ }
-}
-async function save($, id, update, version) {
-  return $.state.set({ plugin: 'square', key: 'inbox', id }, update, version === undefined ? undefined : { ifVersion: version });
-}
-async function reconcile($, sessionId, operation = 'start', resume = false) {
-  const read = await coordinate($);
-  const c = sessionId ? { ...read, sessionId } : read;
-  const held = await $.state.get({ plugin: 'square', key: 'inbox', id: c.sessionId });
-  const old = held.value;
-  const cancelled = await cancellation($, c.sessionId);
-  const result = await bridge($, { ...c, operation, cancelAt: cancelled?.at, cancelledBindings: cancelled?.bindings, bindings: old?.bindings, resume });
-  // A concurrent abort must win over a stale reconciliation write.
-  await save($, c.sessionId, { coordinate: c, bindings: result.bindings }, held.version);
-  if (!result.available) await $.ui.log(result.diagnostic);
-}
-
-async function cancel($) {
-  const c = await coordinate($);
-  const old = await snapshot($, c.sessionId);
-  const cancelAt = await $.clock.now();
-  const captured = old?.bindings ?? [];
-  await $.state.set({ plugin: 'square', key: 'cancelAt', id: c.sessionId }, { at: cancelAt, bindings: captured });
-  const result = await bridge($, { ...c, bindings: captured, cancelAt, cancelledBindings: captured, operation: 'cancel' });
-  try { $.clock.after(0, () => {
-    (async () => {
-      const held = await $.state.get({ plugin: 'square', key: 'cancelAt', id: c.sessionId });
-      if (held.value?.at === cancelAt) await $.state.set({ plugin: 'square', key: 'cancelAt', id: c.sessionId }, { at: cancelAt, bindings: result.cancelledBindings }, { ifVersion: held.version });
-    })().catch(() => undefined);
-  }); } catch { /* captured cancellation remains engine-owned */ }
-}
-
-export function register(on) {
-  on('session.start', async ($, e, next) => {
-    await reconcile($).catch(() => undefined);
-    return next(e);
-  });
-  on('classic.SessionStart', async ($, e, next) => {
-    await reconcile($, e.session_id, 'start', e.source === 'resume').catch(() => undefined);
-    return next(e);
-  });
-  on('tool.call', async ($, e, next) => {
-    try {
-      if (typeof e.tool !== 'string' || !e.tool.startsWith('mcp__plugin_square_square__')) return await next(e);
-      next.signal.throwIfAborted();
-      const c = await coordinate($);
-      const call = { ...c, toolUseId: e.tool_use_id, agentId: e.agentId };
-      const { token } = await bridge($, { ...call, operation: 'tool-begin' });
-      try {
-        next.signal.throwIfAborted();
-        // MCP receives the original business arguments; identity travels only by tool-use ID.
-        return await next(e);
-      } finally {
-        await bridge($, { ...call, token, operation: 'tool-end' }).catch(() => undefined);
-      }
-    }
-    finally { if (!e.agentId) await reconcile($, undefined, 'reconcile').catch(() => undefined); }
-  });
-  on('turn.start', async ($, e, next) => {
-    if (!e.agentId) await reconcile($, undefined, 'reconcile').catch(() => undefined);
-    return next(e);
-  });
-  on('session.end', async ($, e, next) => {
-    // Pinned old ID and captured seat generations, never a later current coordinate.
-    const endedAt = await $.clock.now().catch(() => undefined);
-    const held = await $.state.get({ plugin: 'square', key: 'inbox', id: e.sessionId }).catch(() => undefined);
-    const old = held?.value;
-    const c = old?.coordinate ?? await coordinate($).catch(() => undefined);
-    if (c) {
-      const result = await bridge($, { ...c, sessionId: e.sessionId, bindings: old?.bindings, endedAt, operation: 'end' }, next.budget.remainingMs).catch(() => undefined);
-      // Retired membership lives in the host ledger; conversation state may be cleared.
-      if (result) await save($, e.sessionId, { coordinate: { ...c, sessionId: e.sessionId }, bindings: [] }, held?.version).catch(() => undefined);
-    }
-    return next(e);
-  });
-  on('turn.abort', async ($, e, next) => {
-    await cancel($).catch(() => undefined);
-    return next(e);
-  });
-  on('turn.complete', async ($, e, next) => {
-    // Terminal Esc aborts are reported here, not through the plugin's turn.abort op.
-    if (!e.agentId && e.reason === 'aborted') await cancel($).catch(() => undefined);
-    return next(e);
-  });
-  on('session.receive', async ($, e, next) => {
-    if (e.agentId || e.origin?.kind !== 'peer' || !hasToken(e.text)) return next(e);
-    const c = await coordinate($).catch(() => undefined);
-    if (!c) return next(e);
-    const old = await snapshot($, c.sessionId).catch(() => undefined);
-    const cancelled = await cancellation($, c.sessionId).catch(() => undefined);
-    const guard = await bridge($, { ...c, cancelAt: cancelled?.at, cancelledBindings: cancelled?.bindings, bindings: old?.bindings, operation: 'guard', text: e.text }).catch(() => undefined);
-    if (guard?.recognized && !guard.current) return { consumed: 'Square delivery is stale or cancelled' };
-    // Preserve native policy: hold/refuse reject this gate; never call next twice.
-    const result = await next(e);
-    if (guard?.current && result.text === e.text) confirmLater($, c, 'admitted', result.text);
-    return result;
-  });
-  on('session.append', async ($, e, next) => {
-    if (e.agentId || e.origin?.kind !== 'peer') return next(e);
-    const c = await coordinate($).catch(() => undefined);
-    const result = await next(e);
-    if (!c || result.message?.role !== 'user') return result;
-    // Match a complete payload inside one returned stored text block, not entry text.
-    for (const block of result.message.content ?? []) {
-      if (block.type === 'text' && hasToken(block.text)) confirmLater($, c, 'stored', block.text);
-    }
-    return result;
-  });
-}

package/plugins/claude/types.d.ts

@@ -1,7 +0,0 @@
-export type SquareInboxBinding = { location: string; participant: string; session: string; generation?: string };
-export type SquareInboxCoordinate = { sessionId: string; cwd: string; version: string; endpoint?: string };
-export type SquareInboxCancellation = { at: number; bindings?: SquareInboxBinding[] };
-export type SquareInboxState = { coordinate: SquareInboxCoordinate; bindings?: SquareInboxBinding[] };
-declare module 'claude-code' {
-  interface PluginState { square: { inbox: StateFamily<SquareInboxState>; cancelAt: StateFamily<SquareInboxCancellation> } }
-}

package/plugins/opencode/delivery.ts

@@ -1,198 +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 { type Seat } from '../../model.js';
-import { harnessOwner, decodeHarnessOwner } from '../../owner.js';
-import type { WakeRequest, WakeTransportPort } from '../../ports.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, type OpenCodeNativeSession } from '../../packages/agent-delivery/src/opencode-native.js';
-
-const routeKind = 'opencode-server' as const;
-const ownerFor = (sessionId: string) => harnessOwner({ channel: 'opencode', session: sessionId });
-const payloadHash = (payload: string) => createHash('sha256').update(payload).digest('hex');
-export interface OpenCodeContextMessage { readonly id?: string; readonly role: string; readonly content: readonly { readonly type: string; readonly text?: string }[] }
-
-export async function indexedOpenCodeSessions(env: NodeJS.ProcessEnv): Promise<readonly string[]> {
-  return [...new Set((await indexedSquareEntries({ }, env)).flatMap((entry) => {
-    const coordinate = decodeHarnessOwner(entry.owner);
-    return coordinate?.channel === 'opencode' ? [coordinate.session] : [];
-  }))];
-}
-
-export async function discoverOpenCodeSeats(sessionId: string, env: NodeJS.ProcessEnv, signal?: AbortSignal) {
-  return projectSessionSeats({ owner: ownerFor(sessionId), env }, signal);
-}
-
-function sameSeat(left: Seat | undefined, right: Seat): boolean {
-  return left !== undefined && left.attachment === 'attached' && left.generation === right.generation && left.owner === right.owner;
-}
-
-function createOpenCodeWakeTransport(target: OpenCodeNativeSession, lifetime: AbortSignal): WakeTransportPort {
-  return {
-    probe: async (route) => !lifetime.aborted && route.kind === routeKind
-      && route.address.sessionId === target.sessionId,
-    async attempt(request: WakeRequest, timeoutMs: number, 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' as const, 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: OpenCodeContextMessage): string | undefined {
-  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: string, messages: readonly OpenCodeContextMessage[], env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void> {
-  const observed = new Map(messages.flatMap((message) => {
-    const text = textMessage(message);
-    return text === undefined ? [] : [[message.id!, payloadHash(text)] as const];
-  }));
-  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: OpenCodeNativeSession, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void> {
-  const observer = await observeSessionPending(ownerFor(target.sessionId), env);
-  const transport = createOpenCodeWakeTransport(target, signal);
-  let waiting: ReturnType<typeof observer.wait> | undefined;
-  try {
-    while (!signal.aborted) {
-      const armed = new Promise<boolean>((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: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<boolean> {
-  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: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void> {
-  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: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void> {
-  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(); }
-  }
-}