@astrosheep/square 0.4.7 → 0.4.9

package/dist/claude-hook.js

@@ -1,232 +0,0 @@
-import { createHash } from 'node:crypto';
-import { DeliveryLedger, deliveryLedgerLocation } from './delivery-ledger.js';
-import { claudeBoundaryStore } from './claude-boundary-state.js';
-import { harnessOwner } from './owner.js';
-import { attachDeliverySessionRoutes, detachDeliverySession } from './session-lifecycle.js';
-import { presentPendingAtBoundary } from './boundary-presentation.js';
-import { renderDeliveryReminder } from './delivery-frame.js';
-import { beginClaudeMcpCall, endClaudeMcpCallForSession } from './claude-mcp-context.js';
-import { retainDeliveryLedger } from './delivery-lifetime.js';
-import { z } from 'zod/v4';
-const nativeId = z.string().min(1).max(4096).regex(/^[^\x00-\x1f\x7f]+$/u);
-const hookInput = z.object({
-    hook_event_name: nativeId, session_id: nativeId, cwd: z.string().optional(),
-    prompt_id: nativeId.optional().catch(undefined), prompt: z.string().optional(),
-    tool_use_id: nativeId.optional().catch(undefined), tool_name: z.string().optional(), agent_id: nativeId.optional(),
-});
-const route = 'claude-async-hook';
-const ownerFor = (input) => harnessOwner({ channel: 'claude-code', session: input.session_id });
-function parseInput(text) {
-    try {
-        const value = hookInput.safeParse(JSON.parse(text));
-        return value.success ? value.data : undefined;
-    }
-    catch {
-        return;
-    }
-}
-function observedFrames(prompt) {
-    const prefix = renderDeliveryReminder([''], { tagged: false });
-    const result = [];
-    for (const match of prompt.matchAll(/\[square-delivery:([a-f0-9-]+)\]\n[\s\S]*?\n\[\/square-delivery:\1\]/g)) {
-        const start = match.index - prefix.length;
-        if (start < 0 || prompt.slice(start, match.index) !== prefix)
-            continue;
-        result.push({ token: match[1], payloadHash: createHash('sha256').update(prefix + match[0]).digest('hex') });
-    }
-    return result;
-}
-function claudeFrame(card, token) {
-    return renderDeliveryReminder([`[square-delivery:${token}]\n${card.text}\n[/square-delivery:${token}]`], { tagged: false });
-}
-export async function runClaudeHook(text, env = process.env, sink = value => { process.stdout.write(value); }) {
-    const input = parseInput(text);
-    if (!input) {
-        let raw;
-        try {
-            raw = JSON.parse(text);
-        }
-        catch {
-            return '';
-        }
-        if (raw?.hook_event_name === 'PreToolUse' && typeof raw.tool_name === 'string' && raw.tool_name.startsWith('mcp__plugin_square_square__'))
-            await denyMcpTool(sink);
-        return '';
-    }
-    const signal = AbortSignal.timeout(4500);
-    const boundaries = claudeBoundaryStore(input.session_id, env);
-    const mainOwner = ownerFor(input);
-    const owner = harnessOwner({ channel: 'claude-code', session: input.session_id, ...(input.agent_id === undefined ? {} : { agent: input.agent_id }) });
-    if (input.hook_event_name === 'SessionStart') {
-        await boundaries.start(async () => {
-            const session = await attachDeliverySessionRoutes(mainOwner, env, [{ kind: route, address: { sessionId: input.session_id } }], signal);
-            if (!session)
-                return false;
-            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal });
-            try {
-                await ledger.updateRoutes({ owner: mainOwner, generation: session.generation, routes: session.routes.filter(item => item.kind !== 'claude-native') }, signal);
-            }
-            finally {
-                await ledger.close();
-            }
-            return session.generation;
-        }, signal);
-        return '';
-    }
-    if (input.hook_event_name === 'SessionEnd') {
-        const captured = await boundaries.end(signal);
-        if (captured)
-            await detachDeliverySession(mainOwner, captured.generation, env, signal);
-        return '';
-    }
-    if (input.hook_event_name === 'UserPromptSubmit') {
-        await boundaries.prompt(input.prompt_id, signal);
-        if (!input.prompt_id)
-            return '';
-        if (input.prompt) {
-            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal });
-            try {
-                for (const frame of observedFrames(input.prompt)) {
-                    const handoff = await ledger.handoff(frame.token, signal);
-                    if (!handoff || handoff.owner !== owner || handoff.routeKind !== route || handoff.payloadHash !== frame.payloadHash)
-                        continue;
-                    await ledger.observePresentation(handoff, undefined, signal);
-                }
-            }
-            finally {
-                await ledger.close();
-            }
-        }
-        await presentPendingAtBoundary(owner, async (context) => {
-            await sink(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: context } })}\n`);
-        }, env, signal);
-        return '';
-    }
-    if (input.hook_event_name === 'PreToolUse' && input.tool_name?.startsWith('mcp__plugin_square_square__')) {
-        if (!input.tool_use_id || !input.cwd) {
-            await denyMcpTool(sink);
-            return '';
-        }
-        try {
-            await beginClaudeMcpCall({ toolUseId: input.tool_use_id, sessionId: input.session_id, cwd: input.cwd, agentId: input.agent_id }, env, signal);
-        }
-        catch {
-            await denyMcpTool(sink);
-            return '';
-        }
-    }
-    if ((input.hook_event_name === 'PostToolUse' || input.hook_event_name === 'PostToolUseFailure')
-        && input.tool_name?.startsWith('mcp__plugin_square_square__') && input.tool_use_id) {
-        await endClaudeMcpCallForSession(input.tool_use_id, input.session_id, env, input.agent_id, signal).catch(() => undefined);
-    }
-    if (input.hook_event_name === 'PostToolUse') {
-        await presentPendingAtBoundary(owner, async (context) => {
-            await sink(`${JSON.stringify({ hookSpecificOutput: { hookEventName: input.hook_event_name, additionalContext: context } })}\n`);
-        }, env, signal);
-    }
-    return '';
-}
-async function denyMcpTool(sink) {
-    try {
-        await sink(`${JSON.stringify({ hookSpecificOutput: {
-                hookEventName: 'PreToolUse', permissionDecision: 'deny',
-                permissionDecisionReason: 'Square MCP call identity is unavailable; this call did not run.',
-            } })}\n`);
-    }
-    catch {
-        process.exitCode = 2;
-    }
-}
-export async function runClaudeWatch(text, env = process.env, signal, output = frame => new Promise((resolve, reject) => {
-    process.stderr.write(frame, error => error ? reject(error) : resolve());
-})) {
-    const input = parseInput(text);
-    if (!input || input.hook_event_name !== 'Stop' || !input.prompt_id)
-        return '';
-    const owner = ownerFor(input);
-    const boundaries = claudeBoundaryStore(input.session_id, env);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 86_400_000);
-    const stop = () => controller.abort();
-    process.once('SIGTERM', stop);
-    process.once('SIGINT', stop);
-    const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
-    try {
-        const captured = await boundaries.capture(input.prompt_id, combined);
-        if (!captured)
-            return '';
-        await boundaries.watch(combined, async () => {
-            if (!await boundaries.current(captured, combined))
-                return;
-            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal: combined });
-            const lifetime = retainDeliveryLedger(ledger);
-            const observer = await ledger.observe(owner);
-            try {
-                while (!combined.aborted) {
-                    let version = await observer.read(combined);
-                    const live = await boundaries.current(captured, combined);
-                    const session = await ledger.session(owner, combined);
-                    if (!live || session?.state !== 'attached' || session.generation !== captured.generation || !session.routes.some(item => item.kind === route))
-                        return;
-                    const cards = await ledger.pending(owner, { generation: captured.generation }, combined);
-                    const held = new Set((await ledger.handoffs(owner, { generation: captured.generation }, combined))
-                        .filter(attempt => !['failed', 'released'].includes(attempt.outcome)).map(attempt => attempt.seq));
-                    for (const card of cards) {
-                        if (held.has(card.seq))
-                            continue;
-                        const transport = {
-                            kind: route,
-                            async send(deliveryCard, address, context) {
-                                if (address.sessionId !== input.session_id)
-                                    return 'not-capable';
-                                const frame = claudeFrame(deliveryCard, context.token);
-                                const payloadHash = createHash('sha256').update(frame).digest('hex');
-                                if (!await context.prepare({ token: context.token, messageId: context.token, payloadHash }))
-                                    return 'not-capable';
-                                const currentSession = await ledger.session(owner, context.signal);
-                                if (currentSession?.state !== 'attached' || currentSession.generation !== captured.generation
-                                    || !currentSession.routes.some(item => item.kind === route) || !await context.beforeSend())
-                                    return 'not-capable';
-                                const native = await boundaries.current(captured, context.signal);
-                                if (!native || context.signal.aborted || Date.now() >= context.deadline)
-                                    return 'not-capable';
-                                try {
-                                    await output(frame);
-                                }
-                                finally {
-                                    await boundaries.consume(captured, AbortSignal.timeout(5000));
-                                }
-                                process.exitCode = 2;
-                                return 'unknown';
-                            },
-                        };
-                        const result = await ledger.dispatchHandoff(owner, card.key, transport, {
-                            generation: captured.generation, timeoutMs: 5000, signal: combined,
-                        });
-                        lifetime.track(result);
-                        if (result.outcome === 'unknown' || result.outcome === 'accepted' || result.outcome === 'presented')
-                            return;
-                        // Drain our own unsuccessful claim/settlement edge before waiting;
-                        // a not-capable route must not make filesystem hints a retry loop.
-                        version = await observer.read(combined);
-                    }
-                    await observer.changed(version, 1000, combined);
-                }
-            }
-            finally {
-                observer.close();
-                await lifetime.close();
-            }
-        });
-    }
-    catch {
-        if (!combined.aborted)
-            return '';
-    }
-    finally {
-        clearTimeout(timer);
-        process.off('SIGTERM', stop);
-        process.off('SIGINT', stop);
-    }
-    return '';
-}

package/dist/packages/agent-delivery/src/claude-auth.d.ts

@@ -1,13 +0,0 @@
-import { type LocalEndpoint } from './local-endpoint.js';
-export interface ClaudeAuthOptions {
-    readonly endpoint: LocalEndpoint | string;
-    readonly token?: string;
-    readonly claudeHome?: string;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly platform?: NodeJS.Platform;
-}
-/**
- * Explicit token, then the environment token bound to this exact endpoint, then
- * the newest readable peer key for it. Windows requires a token; POSIX does not.
- */
-export declare function resolveClaudeToken(options: ClaudeAuthOptions, signal?: AbortSignal): Promise<string | undefined>;

package/dist/packages/agent-delivery/src/claude-auth.js

@@ -1,75 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readdir, readFile, stat } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { DeliveryError } from './errors.js';
-import { parseLocalEndpoint } from './local-endpoint.js';
-const TOKEN = /^[0-9a-f]{32}$/;
-const KEY = /^(\d+)\.([0-9a-f]{64})\.key$/;
-function validToken(value) { return typeof value === 'string' && TOKEN.test(value); }
-/**
- * Explicit token, then the environment token bound to this exact endpoint, then
- * the newest readable peer key for it. Windows requires a token; POSIX does not.
- */
-export async function resolveClaudeToken(options, signal) {
-    signal?.throwIfAborted();
-    const endpoint = typeof options.endpoint === 'string' ? parseLocalEndpoint(options.endpoint) : options.endpoint;
-    const platform = options.platform ?? process.platform;
-    const env = options.env ?? process.env;
-    if (options.token !== undefined) {
-        if (!validToken(options.token))
-            throw new DeliveryError('authentication_failed', false);
-        return options.token;
-    }
-    if (validToken(env.CLAUDE_CODE_MESSAGING_TOKEN) && env.CLAUDE_CODE_MESSAGING_SOCKET !== undefined) {
-        try {
-            if (parseLocalEndpoint(env.CLAUDE_CODE_MESSAGING_SOCKET).canonical === endpoint.canonical)
-                return env.CLAUDE_CODE_MESSAGING_TOKEN;
-        }
-        catch { /* an unrelated malformed environment coordinate is ignored */ }
-    }
-    const home = options.claudeHome ?? env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude');
-    const digest = createHash('sha256').update(endpoint.canonical).digest('hex');
-    const keys = [];
-    try {
-        for (const name of await readdir(join(home, 'sessions'))) {
-            signal?.throwIfAborted();
-            const match = KEY.exec(name);
-            if (!match || match[2] !== digest)
-                continue;
-            try {
-                keys.push({ name, pid: Number(match[1]), mtimeMs: (await stat(join(home, 'sessions', name))).mtimeMs });
-            }
-            catch { /* unreadable entries are skipped */ }
-        }
-    }
-    catch { /* no registry is not an error; it only means no peer key */ }
-    signal?.throwIfAborted();
-    keys.sort((a, b) => Number(isAlive(b.pid)) - Number(isAlive(a.pid)) || b.mtimeMs - a.mtimeMs);
-    for (const key of keys) {
-        signal?.throwIfAborted();
-        try {
-            const value = JSON.parse(await readFile(join(home, 'sessions', key.name), { encoding: 'utf8', signal }));
-            if (value && typeof value === 'object' && validToken(value.peerToken)) {
-                return value.peerToken;
-            }
-        }
-        catch { /* the next readable matching key wins */ }
-    }
-    signal?.throwIfAborted();
-    if (platform === 'win32')
-        throw new DeliveryError('authentication_failed', false);
-    return undefined;
-}
-/** A pid that exists, including one owned by another user, holds a live inbox. */
-function isAlive(pid) {
-    if (!Number.isSafeInteger(pid) || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error.code === 'EPERM';
-    }
-}

package/dist/packages/agent-delivery/src/claude-native.d.ts

@@ -1,30 +0,0 @@
-/** Plain native coordinate; no Square facts, credentials or claimed authority. */
-export interface ClaudeNativeTarget {
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly token?: string;
-    readonly claudeHome?: string;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly platform?: NodeJS.Platform;
-    readonly messageId?: string;
-}
-export interface ClaudeNativeControl {
-    readonly deadline: number;
-    readonly signal?: AbortSignal;
-    /** Final asynchronous eligibility check after connecting, before writing bytes. */
-    readonly beforeSend?: () => Promise<boolean>;
-}
-export type NativeWriteResult = {
-    readonly outcome: 'written';
-    readonly message?: never;
-} | {
-    readonly outcome: 'unknown';
-    readonly code: 'aborted' | 'timeout' | 'transport';
-    readonly message: string;
-} | {
-    readonly outcome: 'unavailable';
-    readonly code: 'aborted' | 'timeout' | 'endpoint_unavailable' | 'invalid_arguments' | 'authentication_failed';
-    readonly message: string;
-};
-/** Submit once. Written means local bytes only, never native admission or consumption. */
-export declare function writeClaudeNative(target: ClaudeNativeTarget, text: string, control: ClaudeNativeControl): Promise<NativeWriteResult>;

package/dist/packages/agent-delivery/src/claude-native.js

@@ -1,75 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { deadline } from './deadline.js';
-import { DeliveryError } from './errors.js';
-import { connectLocal, LocalEndpointError, parseLocalEndpoint, writeFrames } from './local-endpoint.js';
-import { resolveClaudeToken } from './claude-auth.js';
-const detail = (code) => code === 'aborted' ? 'Native inbox write aborted.'
-    : code === 'timeout' ? 'Native inbox write deadline elapsed.'
-        : code === 'authentication_failed' ? 'Claude authentication failed.'
-            : 'Native inbox endpoint unavailable.';
-/** Submit once. Written means local bytes only, never native admission or consumption. */
-export async function writeClaudeNative(target, text, control) {
-    const remaining = control?.deadline - Date.now();
-    let endpoint;
-    try {
-        endpoint = parseLocalEndpoint(target?.endpoint);
-    }
-    catch {
-        return { outcome: 'unavailable', code: 'invalid_arguments', message: 'Invalid native inbox arguments.' };
-    }
-    if (!target || typeof target.sessionId !== 'string' || !target.sessionId.trim() ||
-        typeof text !== 'string' || !text.length || !control ||
-        !Number.isFinite(control.deadline) || control.deadline <= 0 || remaining > 2_147_483_647 ||
-        (control.signal !== undefined && !(control.signal instanceof AbortSignal))) {
-        return { outcome: 'unavailable', code: 'invalid_arguments', message: 'Invalid native inbox arguments.' };
-    }
-    if (control.signal?.aborted)
-        return { outcome: 'unavailable', code: 'aborted', message: detail('aborted') };
-    if (remaining <= 0)
-        return { outcome: 'unavailable', code: 'timeout', message: detail('timeout') };
-    const scope = deadline(control.deadline - Date.now(), control.signal);
-    let socket;
-    try {
-        scope.check();
-        const token = await scope.wait(resolveClaudeToken({ endpoint, token: target.token, claudeHome: target.claudeHome, env: target.env, platform: target.platform }, scope.signal));
-        const messageId = target.messageId ?? randomUUID();
-        const frames = [
-            ...(token === undefined ? [] : [{ type: 'auth', token }]),
-            // Claude's SDK custody events echo uuid, not the peer-protocol msg_id.
-            { msgV: 1, msg_id: messageId, uuid: messageId, type: 'user', session_id: target.sessionId, message: { role: 'user', content: text }, priority: 'next' },
-        ];
-        scope.check();
-        if (Date.now() >= control.deadline)
-            throw new LocalEndpointError('timeout');
-        socket = await connectLocal(endpoint, { signal: scope.signal });
-        scope.check();
-        if (Date.now() >= control.deadline)
-            throw new LocalEndpointError('timeout');
-        if (control.beforeSend && !await scope.wait(control.beforeSend()))
-            return { outcome: 'unavailable', code: 'aborted', message: 'Native inbox write suppressed.' };
-        scope.check();
-        if (Date.now() >= control.deadline)
-            throw new LocalEndpointError('timeout');
-        // A receiver that never drains must not hold the caller past its deadline.
-        await scope.wait(writeFrames(socket, frames));
-        scope.check();
-        return { outcome: 'written' };
-    }
-    catch (error) {
-        const local = error instanceof LocalEndpointError ? error : undefined;
-        const code = scope.code ?? (error instanceof DeliveryError ? error.code : local?.code);
-        if (code === 'authentication_failed') {
-            return { outcome: 'unavailable', code, message: detail(code) };
-        }
-        if (code === 'aborted' || code === 'timeout') {
-            return { outcome: socket ? 'unknown' : 'unavailable', code, message: detail(code) };
-        }
-        if (socket)
-            return { outcome: 'unknown', code: 'transport', message: 'Native inbox write unconfirmed.' };
-        return { outcome: 'unavailable', code: 'endpoint_unavailable', message: detail('unavailable') };
-    }
-    finally {
-        socket?.destroy();
-        scope.close();
-    }
-}

package/dist/packages/agent-delivery/src/claude.d.ts

@@ -1,5 +0,0 @@
-import type { ClaudeConnectOptions, ClaudeDeliveryResult, ClaudeSendTextOptions, ClaudeTarget } from './types.js';
-/** Resolve an explicitly identified existing Claude native inbox; never discovers or starts one. */
-export declare function connectExisting(options: ClaudeConnectOptions): Promise<ClaudeTarget>;
-/** Write once to Claude's next native boundary; local write is never native admission. */
-export declare function sendText(target: ClaudeTarget, text: string, options?: ClaudeSendTextOptions): Promise<ClaudeDeliveryResult>;

package/dist/packages/agent-delivery/src/claude.js

@@ -1,66 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { deadline, validSignal, validTimeout } from './deadline.js';
-import { ConnectionError, DeliveryError } from './errors.js';
-import { isIdentity, isRecord } from './guards.js';
-import { parseLocalEndpoint } from './local-endpoint.js';
-import { writeClaudeNative } from './claude-native.js';
-import { resolveClaudeToken } from './claude-auth.js';
-const coordinates = new WeakMap();
-/** Resolve an explicitly identified existing Claude native inbox; never discovers or starts one. */
-export async function connectExisting(options) {
-    if (!isRecord(options) || options.harness !== 'claude' || !isIdentity(options.sessionId) ||
-        typeof options.endpoint !== 'string' || options.endpoint.includes('\0') ||
-        !validTimeout(options.timeoutMs) || !validSignal(options.signal))
-        throw new ConnectionError('invalid_arguments');
-    let endpoint;
-    try {
-        endpoint = parseLocalEndpoint(options.endpoint);
-    }
-    catch {
-        throw new ConnectionError('invalid_arguments');
-    }
-    if (!(process.platform === 'darwin' || process.platform === 'linux' || process.platform === 'win32'))
-        throw new ConnectionError('unsupported_platform');
-    if (process.platform === 'win32' ? endpoint.kind !== 'pipe' : endpoint.kind !== 'unix')
-        throw new ConnectionError('invalid_arguments');
-    const scope = deadline(options.timeoutMs, options.signal);
-    try {
-        scope.check();
-        // The ambient environment and platform are the only auth coordinates here.
-        const token = await scope.wait(resolveClaudeToken({ endpoint, token: options.token, claudeHome: options.claudeHome }, scope.signal));
-        scope.check();
-        const target = Object.freeze({ harness: 'claude', sessionId: options.sessionId });
-        coordinates.set(target, { endpoint: options.endpoint, token, claudeHome: options.claudeHome });
-        return target;
-    }
-    catch (error) {
-        if (scope.code !== undefined)
-            throw new ConnectionError(scope.code);
-        if (error instanceof ConnectionError)
-            throw error;
-        if (error instanceof DeliveryError)
-            throw new ConnectionError(error.code);
-        throw new ConnectionError('invalid_response');
-    }
-    finally {
-        scope.close();
-    }
-}
-/** Write once to Claude's next native boundary; local write is never native admission. */
-export async function sendText(target, text, options = {}) {
-    const coordinate = isRecord(target) ? coordinates.get(target) : undefined;
-    if (!coordinate || target.harness !== 'claude' || !isIdentity(target.sessionId) || typeof text !== 'string' || !text.length || !isRecord(options) ||
-        (options.delivery !== undefined && options.delivery !== 'steer') || options.inputId !== undefined ||
-        !validTimeout(options.timeoutMs) || !validSignal(options.signal))
-        throw new TypeError('Invalid Claude sendText arguments.');
-    const messageId = randomUUID();
-    const result = await writeClaudeNative({ ...coordinate, sessionId: target.sessionId, messageId }, text, { deadline: Date.now() + (options.timeoutMs ?? 5_000), signal: options.signal });
-    const attempt = { harness: 'claude', sessionId: target.sessionId };
-    if (result.outcome === 'written')
-        return { ...attempt, state: 'written', messageId };
-    if (result.outcome === 'unknown')
-        return { ...attempt, state: 'unknown', code: result.code };
-    if (result.code === 'invalid_arguments')
-        throw new TypeError('Invalid Claude sendText arguments.');
-    return { ...attempt, state: 'unavailable', code: result.code };
-}