@astrosheep/square 0.3.27 → 0.3.29

package/dist/file-lock.js

@@ -1,13 +1,11 @@
 import { randomUUID } from 'node:crypto';
-import fs from 'node:fs';
+import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
-const lockWait = new Int32Array(new SharedArrayBuffer(4));
-const heldSyncLocks = new Set();
-function ownerState(lockPath) {
+async function ownerState(lockPath) {
     let pid;
     try {
-        pid = Number.parseInt(fs.readFileSync(lockPath, 'utf8').split('\n')[0], 10);
+        pid = Number.parseInt((await fs.readFile(lockPath, 'utf8')).split('\n')[0], 10);
     }
     catch {
         return 'unknown';
@@ -22,10 +20,10 @@ function ownerState(lockPath) {
         return error.code === 'ESRCH' ? 'dead' : 'alive';
     }
 }
-function createLock(lockPath) {
+async function createLock(lockPath) {
     let fd;
     try {
-        fd = fs.openSync(lockPath, 'wx', 0o600);
+        fd = await fs.open(lockPath, 'wx', 0o600);
     }
     catch (error) {
         if (error.code === 'EEXIST')
@@ -34,79 +32,53 @@ function createLock(lockPath) {
     }
     const token = `${process.pid}\n${Date.now()}\n${randomUUID()}\n`;
     try {
-        fs.writeFileSync(fd, token, 'utf8');
+        await fd.writeFile(token, 'utf8');
         return token;
     }
     catch (error) {
-        try {
-            fs.unlinkSync(lockPath);
-        }
-        catch { }
+        await fs.unlink(lockPath).catch(() => undefined);
         throw error;
     }
     finally {
-        fs.closeSync(fd);
+        await fd.close();
     }
 }
-function reclaimLock(lockPath, staleMs) {
+async function reclaimLock(lockPath, staleMs) {
     try {
-        const stale = Date.now() - fs.statSync(lockPath).mtimeMs > staleMs;
-        if (ownerState(lockPath) !== 'dead' && !stale)
+        const stale = Date.now() - (await fs.stat(lockPath)).mtimeMs > staleMs;
+        if (await ownerState(lockPath) !== 'dead' && !stale)
             return false;
-        fs.unlinkSync(lockPath);
+        await fs.unlink(lockPath);
         return true;
     }
     catch (error) {
         return error.code === 'ENOENT';
     }
 }
-function releaseLock(lockPath, token) {
+async function releaseLock(lockPath, token) {
     try {
-        if (fs.readFileSync(lockPath, 'utf8') === token)
-            fs.unlinkSync(lockPath);
+        if (await fs.readFile(lockPath, 'utf8') === token)
+            await fs.unlink(lockPath);
     }
     catch { }
 }
-function prepare(lockPath) {
-    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-}
-export function withFileLockSync(lockPath, options, fn) {
-    if (heldSyncLocks.has(lockPath))
-        throw new Error(`Reentrant file lock: ${lockPath}`);
-    prepare(lockPath);
-    let token;
-    while (token === undefined) {
-        token = createLock(lockPath);
-        if (token !== undefined)
-            break;
-        if (reclaimLock(lockPath, options.staleMs))
-            continue;
-        Atomics.wait(lockWait, 0, 0, options.retryMs);
-    }
-    heldSyncLocks.add(lockPath);
-    try {
-        return fn();
-    }
-    finally {
-        heldSyncLocks.delete(lockPath);
-        releaseLock(lockPath, token);
-    }
-}
 export async function withFileLock(lockPath, options, fn) {
-    prepare(lockPath);
+    await fs.mkdir(path.dirname(lockPath), { recursive: true });
     let token;
     while (token === undefined) {
-        token = createLock(lockPath);
+        if (options.signal?.aborted)
+            throw options.signal.reason ?? new Error('File lock acquisition aborted');
+        token = await createLock(lockPath);
         if (token !== undefined)
             break;
-        if (reclaimLock(lockPath, options.staleMs))
+        if (await reclaimLock(lockPath, options.staleMs))
             continue;
-        await sleep(options.retryMs);
+        await sleep(options.retryMs, undefined, { signal: options.signal });
     }
     try {
         return await fn();
     }
     finally {
-        releaseLock(lockPath, token);
+        await releaseLock(lockPath, token);
     }
 }

package/dist/harness-links.d.ts

@@ -11,7 +11,8 @@ export type OpenCodeCommandRunner = (homeDir: string, args: string[]) => {
     stdout: string;
     stderr: string;
 };
+export declare function installOpenCodePlugin(homeDir: string, force?: boolean, run?: OpenCodeCommandRunner): string[];
+export declare function uninstallOpenCodePlugin(homeDir: string): string[];
 /** Verify that OpenCode accepts its resolved runtime configuration after links are installed. */
 export declare function verifyOpenCodeRuntime(homeDir: string, run?: OpenCodeCommandRunner): string;
 export declare function skillLinks(homeDir?: string, parents?: Array<'.claude' | '.agents'>): HarnessLink[];
-export declare function opencodeExtensionLink(homeDir?: string): HarnessLink;

package/dist/harness-links.js

@@ -1,8 +1,9 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
 import crossSpawn from 'cross-spawn';
+import { SQUARE_IDENTITY } from './identity.js';
 function packageRoot() {
     // Emitted modules live in dist; package assets are one level above them.
     return fileURLToPath(new URL('../', import.meta.url));
@@ -83,6 +84,42 @@ function runOpenCode(homeDir, args) {
         throw result.error;
     return { status: result.status ?? 1, stdout: result.stdout || '', stderr: result.stderr || '' };
 }
+function requireOpenCodeSuccess(result, action) {
+    if (result.status === 0)
+        return;
+    throw new Error(`OpenCode ${action} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
+}
+export function installOpenCodePlugin(homeDir, force = false, run = runOpenCode) {
+    const args = ['plugin', SQUARE_IDENTITY.packageName, '--global'];
+    if (force)
+        args.push('--force');
+    requireOpenCodeSuccess(run(homeDir, args), 'plugin install');
+    return [SQUARE_IDENTITY.packageName];
+}
+function configPath(homeDir) {
+    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(homeDir, '.config');
+    return path.join(configHome, 'opencode', 'opencode.jsonc');
+}
+function removeConfiguredPlugin(homeDir) {
+    const target = configPath(homeDir);
+    let source;
+    try {
+        source = fs.readFileSync(target, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    const escaped = SQUARE_IDENTITY.packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const packageLine = new RegExp(`^\\s*"${escaped}(?:@[^"\\n]+)?"\\s*,?\\s*$`, 'm');
+    const next = source.replace(packageLine, '');
+    if (next === source)
+        return false;
+    fs.writeFileSync(target, next);
+    return true;
+}
+export function uninstallOpenCodePlugin(homeDir) {
+    return removeConfiguredPlugin(homeDir) ? [SQUARE_IDENTITY.packageName] : [];
+}
 /** Verify that OpenCode accepts its resolved runtime configuration after links are installed. */
 export function verifyOpenCodeRuntime(homeDir, run = runOpenCode) {
     try {
@@ -98,10 +135,10 @@ export function verifyOpenCodeRuntime(homeDir, run = runOpenCode) {
             return '✕ OpenCode debug config returned invalid JSON';
         }
         const plugin = config.config?.plugin;
-        const expected = pathToFileURL(opencodeExtensionLink(homeDir).target).href;
+        const expected = SQUARE_IDENTITY.packageName;
         if (Array.isArray(plugin) && plugin.includes(expected))
-            return '✓ OpenCode debug config loaded';
-        return `○ OpenCode plugin not loaded: ${expected}`;
+            return '✓ OpenCode npm plugin loaded';
+        return `○ OpenCode npm plugin not loaded: ${expected}`;
     }
     catch (error) {
         return `○ OpenCode runtime unavailable (${error instanceof Error ? error.message : String(error)})`;
@@ -114,11 +151,3 @@ export function skillLinks(homeDir = os.homedir(), parents = ['.claude', '.agent
         kind: 'skill',
     })));
 }
-export function opencodeExtensionLink(homeDir = os.homedir()) {
-    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(homeDir, '.config');
-    return {
-        source: path.join(packageRoot(), 'extensions', 'square-opencode.js'),
-        target: path.join(configHome, 'opencode', 'plugins', 'square.js'),
-        kind: 'extension',
-    };
-}

package/dist/harness.js

@@ -4,7 +4,7 @@ import { wakeGraceMs } from './notifications.js';
 import { doctorClaudePlugin, installClaudePlugin, uninstallClaudePlugin, } from './harness-claude.js';
 import { doctorCodexPlugin, installCodexPlugin, uninstallCodexPlugin, } from './harness-codex.js';
 import { doctorPiPackage, installPiPackage, uninstallPiPackage, } from './harness-pi.js';
-import { doctorHarnessLinks, installHarnessLinks, opencodeExtensionLink, skillLinks, uninstallHarnessLinks, verifyOpenCodeRuntime, } from './harness-links.js';
+import { doctorHarnessLinks, installHarnessLinks, installOpenCodePlugin, skillLinks, uninstallOpenCodePlugin, uninstallHarnessLinks, verifyOpenCodeRuntime, } from './harness-links.js';
 function result(lines, notes = []) {
     return { lines, notes };
 }
@@ -17,7 +17,7 @@ async function doctorHost(label, inspect) {
     }
 }
 function openCodeLinks(homeDir) {
-    return [opencodeExtensionLink(homeDir), ...skillLinks(homeDir, ['.agents'])];
+    return skillLinks(homeDir, ['.agents']);
 }
 function readableSquarePath(squarePath) {
     if (squarePath === undefined)
@@ -65,9 +65,15 @@ const TARGETS = [
     {
         name: 'opencode',
         capabilities: ['install', 'uninstall', 'doctor'],
-        install: ({ homeDir, force }) => result(installHarnessLinks(openCodeLinks(homeDir), force)),
-        uninstall: ({ homeDir }) => result(uninstallHarnessLinks(openCodeLinks(homeDir))),
-        doctor: ({ homeDir }) => result([...doctorHarnessLinks(openCodeLinks(homeDir)), verifyOpenCodeRuntime(homeDir)]),
+        install: async ({ homeDir, force }) => result([
+            ...installOpenCodePlugin(homeDir, force),
+            ...installHarnessLinks(openCodeLinks(homeDir), force),
+        ]),
+        uninstall: ({ homeDir }) => result([
+            ...uninstallOpenCodePlugin(homeDir),
+            ...uninstallHarnessLinks(openCodeLinks(homeDir)),
+        ]),
+        doctor: ({ homeDir }) => result([verifyOpenCodeRuntime(homeDir), ...doctorHarnessLinks(openCodeLinks(homeDir))]),
     },
     {
         name: 'pi',

package/dist/inbox.js

@@ -18,7 +18,7 @@ function withoutExcluded(inbox, excludeKeys) {
 }
 export async function sessionInbox(sessionId) {
     const inbox = [];
-    for (const binding of lookupSessionBindings(sessionId)) {
+    for (const binding of await lookupSessionBindings(sessionId)) {
         let square;
         try {
             square = await openSquare(binding.squarePath);
@@ -53,7 +53,7 @@ export async function waitForSessionPending(sessionId, timeoutMs, options = {})
     }
     if (timeoutMs <= 0 || options.signal?.aborted)
         return [];
-    const bindings = lookupSessionBindings(sessionId);
+    const bindings = await lookupSessionBindings(sessionId);
     const paths = [...new Set(bindings.map((binding) => binding.squarePath))];
     let aborted = false;
     let projectAfterReady = !options.skipImmediate;

package/dist/list.js

@@ -15,12 +15,12 @@ function contextLines(lines) {
 async function readSquareListItem(filePath, root) {
     let stat;
     try {
-        stat = fs.statSync(filePath);
+        stat = await fs.promises.stat(filePath);
     }
     catch {
         return null;
     }
-    const square = probeSquare(filePath);
+    const square = await probeSquare(filePath);
     if (square === undefined)
         return null;
     const projection = await listPresentation(square).finally(() => closeOpenSquare(square));
@@ -38,7 +38,7 @@ async function collectSquareList(root, maxDepth) {
     async function walk(dir, depth) {
         let entries;
         try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
+            entries = await fs.promises.readdir(dir, { withFileTypes: true });
         }
         catch {
             // Directory vanished or became unreadable mid-walk — skip it, don't abort the scan.

package/dist/notifications.d.ts

@@ -28,6 +28,6 @@ export interface SweepPendingNotificationsOptions extends WorkerLaunchOptions {
     limit?: number;
 }
 /** Select sweep candidates from one frozen snapshot and one delivery replay. */
-export declare function pendingNotificationSweepFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, limit: number, deriveDelivery?: (snapshot: SquareState) => DeliveryModel): number[];
+export declare function pendingNotificationSweepFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, limit: number, deriveDelivery?: (snapshot: SquareState) => DeliveryModel): Promise<number[]>;
 /** Reconsider old pending attention at a bounded action boundary using the existing worker. */
 export declare function sweepPendingNotifications(squarePath: string, opts?: SweepPendingNotificationsOptions): Promise<number[]>;

package/dist/notifications.js

@@ -53,7 +53,7 @@ function renderWakePayload(request, body, kind) {
     ].join('\n');
 }
 async function waitForCatch(route, request, body) {
-    const binding = lookupParticipant(request.squarePath, request.recipient)
+    const binding = (await lookupParticipant(request.squarePath, request.recipient))
         .find((item) => item.ownerId === route.ownerId);
     const activeCatch = binding && (await sessionInbox(binding.sessionId))
         .find((item) => item.name === request.recipient)?.catchLease;
@@ -68,7 +68,7 @@ async function waitForCatch(route, request, body) {
     while (Date.now() < deadline) {
         if (await hasDeliveredNotification(request.squarePath, request.recipient, request.actIndex))
             return true;
-        const currentBinding = lookupParticipant(request.squarePath, request.recipient)
+        const currentBinding = (await lookupParticipant(request.squarePath, request.recipient))
             .find((item) => item.ownerId === route.ownerId);
         const lease = currentBinding && (await sessionInbox(currentBinding.sessionId))
             .find((item) => item.name === request.recipient)?.catchLease;
@@ -101,7 +101,7 @@ export async function hasAttentionNotification(squarePath, name, ref, env = proc
     try {
         const recipient = (await resolveParticipant(square, name)).name;
         const index = notificationIndex(ref);
-        return await notificationDelivered(square, recipient, index) || hasPresentedAttention(squarePath, recipient, index, env);
+        return await notificationDelivered(square, recipient, index) || await hasPresentedAttention(squarePath, recipient, index, env);
     }
     finally {
         await closeOpenSquare(square);
@@ -162,7 +162,7 @@ async function processNotification(squarePath, notification, opts) {
         return;
     }
     if (claim.type === 'ambiguous') {
-        const recovered = recordRecoveredUnknown(attention, claim.lease, env);
+        const recovered = await recordRecoveredUnknown(attention, claim.lease, env);
         if (recovered !== undefined) {
             await releaseNotifyLease(square, notification.recipient, notification.item.index, claim.lease.leaseId);
         }
@@ -185,7 +185,7 @@ async function processNotification(squarePath, notification, opts) {
             route: notification.route,
         };
         await port.dispatch(evidence.attemptableRoutes, (route) => renderWakePayload(request, notification.item.body, route.kind), {
-            nextAttemptN: () => nextWakeAttemptNumber(attention, { env, now: now() }),
+            nextAttemptN: async () => nextWakeAttemptNumber(attention, { env, now: now() }),
             beforeSend: async (route, attemptN) => {
                 if (await waitForCatch(route, request, notification.item.body))
                     return false;
@@ -207,7 +207,7 @@ async function processNotification(squarePath, notification, opts) {
                     await transitionNotifyLease(square, notification.recipient, notification.item.index, leaseId, 'claimed');
                     releaseLease = true;
                 }
-                recordWakeAttempt({
+                await recordWakeAttempt({
                     attention,
                     routeKind: route.kind,
                     outcome: outcome.outcome,
@@ -224,7 +224,7 @@ async function processNotification(squarePath, notification, opts) {
                     releaseLease = true;
             },
             invalidate: async (route) => {
-                retireWakeRoute(route, { env, at: now() });
+                await retireWakeRoute(route, { env, at: now() });
             },
         });
     }
@@ -257,10 +257,10 @@ export function wakeNotifierForSquare(squarePath, env = process.env) {
     };
 }
 /** Select sweep candidates from one frozen snapshot and one delivery replay. */
-export function pendingNotificationSweepFromState(squarePath, state, now, env, limit, deriveDelivery = deriveDeliveryModel) {
+export async function pendingNotificationSweepFromState(squarePath, state, now, env, limit, deriveDelivery = deriveDeliveryModel) {
     const delivery = deriveDelivery(state);
     const pending = pendingDeliveriesFromState(state, delivery);
-    const evidence = wakeEvidenceProjectionFromState(squarePath, state, now, env, delivery);
+    const evidence = await wakeEvidenceProjectionFromState(squarePath, state, now, env, delivery);
     const indexes = new Set();
     for (const recipient of pending) {
         for (const note of recipient.notifications) {
@@ -288,7 +288,7 @@ export async function sweepPendingNotifications(squarePath, opts = {}) {
     finally {
         await closeOpenSquare(square);
     }
-    const selected = pendingNotificationSweepFromState(squarePath, state, now, env, limit);
+    const selected = await pendingNotificationSweepFromState(squarePath, state, now, env, limit);
     const workerPath = fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url));
     for (const actIndex of selected) {
         (opts.launchWorker ?? launchWorker)(workerPath, ['--location', squarePath, '--act-index', String(actIndex)]);

package/dist/opencode.d.ts

@@ -0,0 +1,19 @@
+/** OpenCode's server plugin entrypoint for the published Square package. */
+export default function squareOpenCodePlugin(): Promise<{
+    event: ({ event }: {
+        event: {
+            type?: string;
+            properties?: Record<string, any>;
+        };
+    }) => Promise<void>;
+    'shell.env': (input: {
+        sessionID?: string;
+    }, output: {
+        env: Record<string, string>;
+    }) => Promise<void>;
+    'tool.execute.after': (input: {
+        sessionID: string;
+    }, output: {
+        output: string;
+    }) => Promise<void>;
+}>;

package/dist/opencode.js

@@ -0,0 +1,49 @@
+import { presentPendingAtBoundary } from './boundary-presentation.js';
+import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
+/** OpenCode's server plugin entrypoint for the published Square package. */
+export default async function squareOpenCodePlugin() {
+    const joining = new Map();
+    return {
+        event: async ({ event }) => {
+            if (event.type === 'session.created' || event.type === 'session.updated') {
+                const sessionID = event.properties?.sessionID;
+                const cwd = event.properties?.info?.directory || process.cwd();
+                if (sessionID) {
+                    try {
+                        const context = await automaticSessionStart('opencode', sessionID, cwd);
+                        if (context)
+                            joining.set(sessionID, context);
+                    }
+                    catch { /* startup remains bounded */ }
+                }
+            }
+            else if (event.type === 'session.deleted') {
+                const sessionID = event.properties?.sessionID;
+                const cwd = event.properties?.info?.directory || process.cwd();
+                if (sessionID) {
+                    joining.delete(sessionID);
+                    await automaticSessionEnd('opencode', sessionID, cwd);
+                }
+            }
+        },
+        'shell.env': async (input, output) => {
+            if (input.sessionID)
+                output.env.OPENCODE_SESSION_ID = input.sessionID;
+        },
+        'tool.execute.after': async (input, output) => {
+            try {
+                const joined = joining.get(input.sessionID);
+                if (joined) {
+                    joining.delete(input.sessionID);
+                    output.output = `${output.output}${output.output === '' ? '' : '\n\n'}${joined}`;
+                }
+                await presentPendingAtBoundary(input.sessionID, (context) => {
+                    output.output = `${output.output}${output.output === '' ? '' : '\n\n'}${context}`;
+                });
+            }
+            catch {
+                // A failed admission remains available at a later boundary.
+            }
+        },
+    };
+}

package/dist/presented.d.ts

@@ -6,16 +6,8 @@ export interface PresentedAttention {
     actIndex: number;
 }
 export declare function presentedPath(env?: NodeJS.ProcessEnv): string;
-/** Read the current presentation facts once for a derived evidence projection. */
-export declare function readPresentedAttentions(env?: NodeJS.ProcessEnv, now?: number): PresentedAttention[];
-export declare function hasPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): boolean;
-/** True when any current participant owner has already received this attention. */
-export declare function hasPresentedAttention(squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): boolean;
-/** Record presentation by a transport that delivered the bounded attention body. */
-export declare function recordPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, at?: number): void;
-/**
- * Serialize presentation only for the affected participants. Delivery runs
- * outside the short ledger-write lock, so unrelated owners never wait on an
- * adapter. A throwing or rejecting callback leaves no row and remains unpresented.
- */
-export declare function presentOnce<T>(sessionId: string, lookup: (sessionId: string) => InboxMembership[] | Promise<InboxMembership[]>, deliver: (inbox: InboxMembership[]) => T | Promise<T>, env?: NodeJS.ProcessEnv, at?: number): Promise<T | undefined>;
+export declare function readPresentedAttentions(env?: NodeJS.ProcessEnv, now?: number): Promise<PresentedAttention[]>;
+export declare function hasPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): Promise<boolean>;
+export declare function hasPresentedAttention(squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, now?: number): Promise<boolean>;
+export declare function recordPresentedForOwner(ownerId: string, squarePath: string, name: string, actIndex: number, env?: NodeJS.ProcessEnv, at?: number): Promise<void>;
+export declare function presentOnce<T>(sessionId: string, lookup: (sessionId: string) => InboxMembership[] | Promise<InboxMembership[]>, deliver: (inbox: InboxMembership[]) => T | Promise<T>, env?: NodeJS.ProcessEnv, at?: number, signal?: AbortSignal): Promise<T | undefined>;