@xopcai/xopc 0.0.411 → 0.0.413

package/dist/src/phone/interactive-session.js

@@ -0,0 +1,164 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+//#region src/phone/interactive-session.ts
+init_contracts();
+/** Shared device source with bounded video gating and ordered, fenced input. */
+var PhoneInteractiveSession = class {
+	viewers = /* @__PURE__ */ new Map();
+	queue = Promise.resolve();
+	pending = 0;
+	seq = /* @__PURE__ */ new Map();
+	packets = [];
+	bytes = 0;
+	checkedAt = 0;
+	allowed = false;
+	closed = false;
+	timer;
+	unsubscribe;
+	config;
+	started;
+	gesture;
+	verification;
+	constructor(provider, checkScreen, authorize, onGesture = () => {}) {
+		this.provider = provider;
+		this.checkScreen = checkScreen;
+		this.authorize = authorize;
+		this.onGesture = onGesture;
+	}
+	start() {
+		return this.started ??= (async () => {
+			await this.checkScreen();
+			this.checkedAt = Date.now();
+			this.allowed = true;
+			this.unsubscribe = this.provider.subscribe((packet) => {
+				if (packet.config) this.config = packet;
+				this.packets.push(packet);
+				this.bytes += packet.data.length;
+				if (this.bytes > 2 * 1024 * 1024) {
+					this.packets = [];
+					this.bytes = 0;
+					for (const viewer of this.viewers.values()) viewer.key = false;
+				}
+			});
+			await this.provider.start();
+			this.poll();
+		})();
+	}
+	verifyScreen() {
+		return this.verification ??= this.checkScreen().then(() => {
+			this.checkedAt = Date.now();
+			this.allowed = true;
+		}, (error) => {
+			this.allowed = false;
+			throw error;
+		}).finally(() => {
+			this.verification = void 0;
+		});
+	}
+	async poll() {
+		if (this.closed) return;
+		const packets = this.packets;
+		this.packets = [];
+		this.bytes = 0;
+		try {
+			const wasAllowed = this.allowed;
+			await this.verifyScreen();
+			if (this.closed) return;
+			if (!wasAllowed) this.provider.refresh();
+			for (const packet of packets) for (const viewer of this.viewers.values()) {
+				if (packet.geometry && packet.geometry.version !== this.provider.geometry.version) continue;
+				if (packet.config) {
+					viewer.key = false;
+					viewer.packet(packet);
+				} else if (packet.key || viewer.key) {
+					if (!viewer.key && this.config) viewer.packet(this.config);
+					viewer.key = true;
+					viewer.packet(packet);
+				}
+			}
+		} catch (error) {
+			this.allowed = false;
+			this.packets = [];
+			this.bytes = 0;
+			await this.revoke().catch(() => {});
+			const code = error instanceof PhoneError ? error.code : "PHONE_VIDEO_DISCONNECTED";
+			for (const viewer of this.viewers.values()) {
+				viewer.key = false;
+				viewer.fault(code);
+			}
+		}
+		if (!this.closed) this.timer = setTimeout(() => void this.poll(), 35);
+	}
+	subscribe(client, packet, fault) {
+		if (this.viewers.has(client) || this.viewers.size >= 4) throw new PhoneError("PHONE_VIEW_BUSY", "Phone viewer connection limit reached", 409);
+		this.viewers.set(client, {
+			packet,
+			fault,
+			key: false
+		});
+		this.provider.refresh();
+		return () => {
+			this.viewers.delete(client);
+			this.seq.delete(client);
+		};
+	}
+	input(client, input) {
+		this.authorize(client, input.epoch);
+		if (this.closed || !this.allowed) throw new PhoneError("PHONE_SCREEN_UNVERIFIED", "Wait for an authorized phone frame", 409);
+		if (input.seq <= (this.seq.get(client) ?? 0)) throw new PhoneError("PHONE_INPUT_SEQUENCE", "Stale input sequence", 409);
+		if (this.pending >= 8) throw new PhoneError("PHONE_INPUT_BACKPRESSURE", "Input queue full; release and start a new gesture", 409);
+		this.seq.set(client, input.seq);
+		this.pending++;
+		const work = this.queue.catch(() => {}).then(async () => {
+			this.authorize(client, input.epoch);
+			if (Date.now() - this.checkedAt > 300) await this.verifyScreen();
+			this.authorize(client, input.epoch);
+			if (!this.allowed || this.closed) throw new PhoneError("PHONE_APP_DENIED", "Phone screen is unavailable", 403);
+			await this.provider.pointer(input);
+			if (input.phase === "down") this.gesture = {
+				x: input.x,
+				y: input.y,
+				at: Date.now()
+			};
+			else if (input.phase === "up" || input.phase === "cancel") {
+				const start = this.gesture;
+				this.gesture = void 0;
+				if (start) this.onGesture(Math.hypot(start.x - input.x, start.y - input.y) > 18 ? "swipe" : Date.now() - start.at > 600 ? "longPress" : "tap");
+			}
+		}).finally(() => {
+			this.pending--;
+		});
+		this.queue = work;
+		return work;
+	}
+	async revoke() {
+		const work = this.queue.catch(() => {}).then(async () => {
+			await this.provider.revoke();
+			this.gesture = void 0;
+		});
+		this.queue = work;
+		await work;
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		clearTimeout(this.timer);
+		await this.revoke().catch(() => {});
+		this.unsubscribe?.();
+		for (const viewer of this.viewers.values()) viewer.fault("PHONE_VIDEO_ENDED");
+		this.viewers.clear();
+		this.packets = [];
+		this.config = void 0;
+		await this.provider.close();
+	}
+	get viewerCount() {
+		return this.viewers.size;
+	}
+	verifyGeometry(version) {
+		return this.allowed && Date.now() - this.checkedAt < 300 && version === this.provider.geometry.version;
+	}
+	authorizeClient(client, epoch) {
+		this.authorize(client, epoch);
+	}
+};
+//#endregion
+export { PhoneInteractiveSession };

package/dist/src/phone/live-provider.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+/** Vendor adapters own their media transport; the runtime always owns the lease. */
+export type PhoneMediaDescriptor = {
+    kind: 'scrcpy-h264';
+    protocolVersion: 1;
+    continuousTouch: true;
+    maxPointers: 1;
+} | {
+    kind: 'vendor-sdk';
+    provider: string;
+    sessionId: string;
+    expiresAt: number;
+    controlRevocation: 'confirmed' | 'ttl';
+} | {
+    kind: 'snapshot';
+    continuousTouch: false;
+};
+export declare const PhonePointerSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pointer">;
+    phase: z.ZodEnum<{
+        cancel: "cancel";
+        move: "move";
+        down: "down";
+        up: "up";
+    }>;
+    seq: z.ZodNumber;
+    epoch: z.ZodNumber;
+    geometry: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strict>;
+export type PhonePointer = z.infer<typeof PhonePointerSchema>;
+export type PhoneVideoPacket = {
+    data: Buffer;
+    config: boolean;
+    key: boolean;
+    pts: number;
+    geometry?: PhoneVideoGeometry;
+};
+export type PhoneVideoGeometry = {
+    width: number;
+    height: number;
+    version: number;
+    codec: string;
+};
+export interface PhoneInteractiveProvider {
+    readonly descriptor: PhoneMediaDescriptor;
+    readonly geometry: PhoneVideoGeometry;
+    foreground(signal: AbortSignal): Promise<string>;
+    start(): Promise<void>;
+    subscribe(packet: (packet: PhoneVideoPacket) => void): () => void;
+    pointer(input: PhonePointer): Promise<void>;
+    refresh(): void;
+    /** Must resolve only after the transport has released all accepted touches. */
+    revoke(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/src/phone/live-provider.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+//#region src/phone/live-provider.ts
+const PhonePointerSchema = z.object({
+	type: z.literal("pointer"),
+	phase: z.enum([
+		"down",
+		"move",
+		"up",
+		"cancel"
+	]),
+	seq: z.number().int().positive(),
+	epoch: z.number().int().positive(),
+	geometry: z.number().int().positive(),
+	x: z.number().finite().min(0).max(1e3),
+	y: z.number().finite().min(0).max(1e3)
+}).strict();
+//#endregion
+export { PhonePointerSchema };

package/dist/src/phone/live-state.d.ts

@@ -0,0 +1,28 @@
+import { type PhoneObservation } from './contracts.js';
+/** Active execution time excludes explicit human intervention. */
+export declare class PhoneOperationBudget {
+    readonly controller: AbortController;
+    private remaining;
+    constructor(durationMs?: number);
+    private started;
+    private timer?;
+    resume(): void;
+    pause(): void;
+    dispose(): void;
+}
+export type PhoneLiveFrame = Omit<PhoneObservation, 'elements' | 'frameId'> & {
+    seq: number;
+};
+export declare class PhoneFrameCache {
+    private history;
+    private frame?;
+    private seq;
+    set(observation: PhoneObservation): void;
+    get(): PhoneLiveFrame | undefined;
+    layout(observation: PhoneObservation): string;
+    metadata(seq: number | undefined): Omit<PhoneLiveFrame, "frame"> & {
+        layout: string;
+    };
+    invalidate(): void;
+    clear(): void;
+}

package/dist/src/phone/live-state.js

@@ -0,0 +1,71 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+import { createHash } from "node:crypto";
+//#region src/phone/live-state.ts
+init_contracts();
+/** Active execution time excludes explicit human intervention. */
+var PhoneOperationBudget = class {
+	controller = new AbortController();
+	remaining;
+	constructor(durationMs = 3e5) {
+		this.remaining = durationMs;
+	}
+	started = 0;
+	timer;
+	resume() {
+		if (this.timer || this.controller.signal.aborted) return;
+		this.started = Date.now();
+		this.timer = setTimeout(() => this.controller.abort(new PhoneError("PHONE_OPERATION_TIMEOUT", "The phone goal reached its active execution limit. The session is paused; inspect the current screen before continuing.", 409)), this.remaining);
+		this.timer.unref();
+	}
+	pause() {
+		if (!this.timer) return;
+		clearTimeout(this.timer);
+		this.timer = void 0;
+		this.remaining = Math.max(0, this.remaining - (Date.now() - this.started));
+	}
+	dispose() {
+		this.pause();
+	}
+};
+var PhoneFrameCache = class {
+	history = [];
+	frame;
+	seq = 0;
+	set(observation) {
+		this.frame?.frame.fill(0);
+		this.frame = {
+			seq: ++this.seq,
+			capturedAt: observation.capturedAt,
+			width: observation.width,
+			height: observation.height,
+			rotation: observation.rotation,
+			package: observation.package,
+			frame: Buffer.from(observation.frame)
+		};
+		const { frame: _pixels, ...metadata } = this.frame;
+		this.history.push({
+			...metadata,
+			layout: this.layout(observation)
+		});
+		this.history = this.history.filter((frame) => Date.now() - frame.capturedAt <= 1e4).slice(-128);
+	}
+	get() {
+		return this.frame;
+	}
+	layout(observation) {
+		return createHash("sha256").update(JSON.stringify(observation.elements)).digest("hex");
+	}
+	metadata(seq) {
+		return this.history.find((frame) => frame.seq === seq);
+	}
+	invalidate() {
+		this.frame?.frame.fill(0);
+		this.frame = void 0;
+	}
+	clear() {
+		this.invalidate();
+		this.history = [];
+	}
+};
+//#endregion
+export { PhoneFrameCache, PhoneOperationBudget };

package/dist/src/phone/model-adapter.d.ts

@@ -0,0 +1,25 @@
+import type { Config } from '../config/schema.js';
+import { type PhoneAction, type PhoneDecision, type PhoneObservation } from './contracts.js';
+export declare function phoneModelProfile(model: unknown): "autoglm-phone-v1" | "structured-phone-v1";
+export declare function validatePhoneModelChange(next: {
+    primary: string;
+} | null | undefined, previous?: {
+    primary: string;
+} | null): void;
+/** Parse only a function name and literal keyword arguments; model text is never executable code. */
+export declare function parseAutoGlmResponse(raw: string, allowedApps: string[]): PhoneDecision;
+export interface PhonePrediction {
+    goal: string;
+    observation: PhoneObservation;
+    allowedApps: string[];
+    history: PhoneAction['type'][];
+    scenario?: 'settings-about';
+}
+export interface PhoneModelAdapter {
+    predict(input: PhonePrediction, signal: AbortSignal): Promise<PhoneDecision>;
+}
+export declare function isAboutScreen(observation: PhoneObservation): boolean;
+export declare class MockPhoneModel implements PhoneModelAdapter {
+    predict(input: PhonePrediction, signal: AbortSignal): Promise<PhoneDecision>;
+}
+export declare function createPhoneModel(modelRef: string, config: Config, agentId: string): Promise<PhoneModelAdapter>;