@astrosheep/square 0.4.7 → 0.4.8

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 };
-}