preflite 1.0.1

package/dist/application/health/HealthMetricsService.js

@@ -0,0 +1,47 @@
+export class HealthMetricsService {
+    heartbeats = 0;
+    wsReconnectCount = 0;
+    wsLastReconnectDelayMs = null;
+    wsPendingDroppedTotal = 0;
+    wsConnectionState = "disconnected";
+    pendingSendQueueDepth = 0;
+    pollLastOkAt = null;
+    pollLastErrorAt = null;
+    markHeartbeat() {
+        this.heartbeats += 1;
+    }
+    setWsConnectionState(state) {
+        this.wsConnectionState = state;
+    }
+    setPendingSendDepth(depth) {
+        this.pendingSendQueueDepth = depth;
+    }
+    onReconnectScheduled(delayMs) {
+        this.wsReconnectCount += 1;
+        this.wsLastReconnectDelayMs = delayMs;
+    }
+    onPendingDropped(count) {
+        this.wsPendingDroppedTotal += count;
+    }
+    markPollOk() {
+        this.pollLastOkAt = new Date().toISOString();
+        this.pollLastErrorAt = null;
+    }
+    markPollError() {
+        this.pollLastErrorAt = new Date().toISOString();
+    }
+    snapshot() {
+        return {
+            healthy: true,
+            heartbeats: this.heartbeats,
+            wsConnected: this.wsConnectionState === "open",
+            wsConnectionState: this.wsConnectionState,
+            wsReconnectCount: this.wsReconnectCount,
+            wsLastReconnectDelayMs: this.wsLastReconnectDelayMs,
+            wsPendingDroppedTotal: this.wsPendingDroppedTotal,
+            pendingSendQueueDepth: this.pendingSendQueueDepth,
+            pollLastOkAt: this.pollLastOkAt,
+            pollLastErrorAt: this.pollLastErrorAt,
+        };
+    }
+}

package/dist/application/lease/LeaseApplicationService.js

@@ -0,0 +1,79 @@
+import { Lease } from "../../domain/lease/Lease.js";
+import { LeaseConflictError, LeaseRequiredError } from "../../shared-kernel/errors/index.js";
+import { EventType, LeaseStatus } from "../../shared-kernel/enums/index.js";
+import { asLeaseId, asResourceId, } from "../../shared-kernel/ids/index.js";
+export class LeaseApplicationService {
+    leaseRepository;
+    reporter;
+    constructor(leaseRepository, reporter) {
+        this.leaseRepository = leaseRepository;
+        this.reporter = reporter;
+    }
+    async emitLeaseChanged(lease) {
+        if (!this.reporter)
+            return;
+        await this.reporter.emit(EventType.LEASE_CHANGED, {
+            leaseId: lease.id,
+            resourceId: lease.resourceId,
+            status: lease.status,
+        });
+    }
+    async acquire(leaseId, resourceId, ownerId, ownerType, ttlSeconds, occupant) {
+        const rid = asResourceId(resourceId);
+        const activeLease = await this.leaseRepository.getActiveByResourceId(rid);
+        const now = new Date();
+        if (activeLease && activeLease.isActive(now)) {
+            throw new LeaseConflictError(resourceId);
+        }
+        if (activeLease) {
+            activeLease.status = LeaseStatus.REJECTED;
+            await this.leaseRepository.save(activeLease);
+            await this.emitLeaseChanged(activeLease);
+        }
+        const expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+        const ou = occupant?.username?.trim();
+        const od = occupant?.displayName?.trim();
+        const lease = new Lease(asLeaseId(leaseId), rid, ownerId, ownerType, LeaseStatus.ACTIVE, expiresAt, ou || undefined, od || undefined);
+        await this.leaseRepository.save(lease);
+        await this.emitLeaseChanged(lease);
+        return lease;
+    }
+    async release(leaseId) {
+        const lease = await this.leaseRepository.getById(leaseId);
+        if (!lease)
+            return null;
+        lease.status = LeaseStatus.RELEASED;
+        await this.leaseRepository.save(lease);
+        await this.emitLeaseChanged(lease);
+        return lease;
+    }
+    async renew(leaseId, ttlSeconds) {
+        const lease = await this.leaseRepository.getById(leaseId);
+        if (!lease)
+            return null;
+        lease.expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+        await this.leaseRepository.save(lease);
+        await this.emitLeaseChanged(lease);
+        return lease;
+    }
+    /**
+     * 按资源撤销当前活跃租约（与 ReleaseLeaseCommand 等效，但只需 resourceId）。
+     * 无活跃租约时返回 null（调用方仍可视为成功）。
+     */
+    async revokeByResourceId(resourceId) {
+        const rid = asResourceId(resourceId);
+        const lease = await this.leaseRepository.getActiveByResourceId(rid);
+        if (!lease)
+            return null;
+        lease.status = LeaseStatus.RELEASED;
+        await this.leaseRepository.save(lease);
+        await this.emitLeaseChanged(lease);
+        return lease;
+    }
+    async ensureActive(resourceId) {
+        const lease = await this.leaseRepository.getActiveByResourceId(resourceId);
+        if (!lease || !lease.isActive(new Date()))
+            throw new LeaseRequiredError(resourceId);
+        return lease;
+    }
+}

package/dist/application/query/ObservationQueryService.js

@@ -0,0 +1,48 @@
+import { asLeaseId, asSessionId, asTaskId } from "../../shared-kernel/ids/index.js";
+export class ObservationQueryService {
+    taskRepository;
+    sessionRepository;
+    leaseRepository;
+    artifactRepository;
+    eventRepository;
+    constructor(taskRepository, sessionRepository, leaseRepository, artifactRepository, eventRepository) {
+        this.taskRepository = taskRepository;
+        this.sessionRepository = sessionRepository;
+        this.leaseRepository = leaseRepository;
+        this.artifactRepository = artifactRepository;
+        this.eventRepository = eventRepository;
+    }
+    async getTask(taskId) {
+        return this.taskRepository.getById(asTaskId(taskId));
+    }
+    async getSession(sessionId) {
+        const id = asSessionId(sessionId);
+        const execution = await this.sessionRepository.getExecutionById(id);
+        if (execution)
+            return { sessionType: "execution", session: execution };
+        const debug = await this.sessionRepository.getDebugById(id);
+        if (debug)
+            return { sessionType: "debug", session: debug };
+        return null;
+    }
+    async getLease(leaseId) {
+        return this.leaseRepository.getById(asLeaseId(leaseId));
+    }
+    async listArtifacts(taskId) {
+        return this.artifactRepository.listByTaskId(asTaskId(taskId));
+    }
+    async listEvents(params) {
+        const events = await this.eventRepository.list();
+        const filtered = events.filter((event) => {
+            const byType = params.type ? event.type === params.type : true;
+            const payloadTaskId = event.payload && typeof event.payload === "object" && "taskId" in event.payload
+                ? String(event.payload.taskId ?? "")
+                : "";
+            const byTaskId = params.taskId ? payloadTaskId === params.taskId : true;
+            return byType && byTaskId;
+        });
+        if (!params.limit || params.limit <= 0)
+            return filtered;
+        return filtered.slice(-params.limit);
+    }
+}

package/dist/application/reporter/ReporterApplicationService.js

@@ -0,0 +1,41 @@
+import { AgentEvent } from "../../domain/event/AgentEvent.js";
+import { nowIso } from "../../shared-kernel/time/index.js";
+import { EventType } from "../../shared-kernel/enums/index.js";
+export class ReporterApplicationService {
+    eventRepository;
+    publisher;
+    constructor(eventRepository, publisher) {
+        this.eventRepository = eventRepository;
+        this.publisher = publisher;
+    }
+    async emit(type, payload) {
+        const event = new AgentEvent(type, nowIso(), payload);
+        await this.eventRepository.append(event);
+        await this.publisher.publish(event);
+    }
+    async emitLiveDebugFrame(payload) {
+        const capturedAt = payload.capturedAt ?? nowIso();
+        const frameData = Buffer.from(payload.dataBase64, "base64");
+        const event = new AgentEvent(EventType.LIVE_DEBUG_FRAME, nowIso(), {
+            sessionId: payload.sessionId,
+            resourceId: payload.resourceId,
+            mimeType: payload.mimeType,
+            capturedAt,
+            byteLength: frameData.byteLength,
+            sourceUri: payload.sourceUri ?? "",
+            ...(payload.foregroundApp ? { foregroundApp: payload.foregroundApp } : {}),
+        });
+        await this.eventRepository.append(event);
+        await this.publisher.publish(event);
+        if (this.publisher.publishLiveDebugFrame) {
+            await this.publisher.publishLiveDebugFrame(event, {
+                mimeType: payload.mimeType,
+                data: frameData,
+                capturedAt,
+                sessionId: payload.sessionId,
+                resourceId: payload.resourceId,
+                ...(payload.foregroundApp ? { foregroundApp: payload.foregroundApp } : {}),
+            });
+        }
+    }
+}

package/dist/application/resource/ResourceOccupationReleaseService.js

@@ -0,0 +1,49 @@
+import { SessionStatus, TaskStatus } from "../../shared-kernel/enums/index.js";
+/**
+ * 与 `/resources` 合并逻辑对齐：占用可能来自调试会话、RUNNING 任务、或仅有租约。
+ * 强制解除须三者一并回收，否则列表仍显示 DEBUGGING / RUNNING。
+ */
+export class ResourceOccupationReleaseService {
+    taskService;
+    debugService;
+    leaseService;
+    sessionRepo;
+    taskRepo;
+    constructor(taskService, debugService, leaseService, sessionRepo, taskRepo) {
+        this.taskService = taskService;
+        this.debugService = debugService;
+        this.leaseService = leaseService;
+        this.sessionRepo = sessionRepo;
+        this.taskRepo = taskRepo;
+    }
+    async forceRelease(resourceIdRaw) {
+        const resourceId = resourceIdRaw.trim();
+        if (!resourceId)
+            throw new Error("resourceId required");
+        const matchesResource = (stored) => String(stored) === resourceId;
+        const listDebug = this.sessionRepo.listDebugSessions?.bind(this.sessionRepo);
+        if (listDebug) {
+            for (const s of await listDebug()) {
+                if (s.status === SessionStatus.CLOSED)
+                    continue;
+                if (!matchesResource(s.resourceId))
+                    continue;
+                await this.debugService.close(s.id);
+            }
+        }
+        const listTasks = this.taskRepo.list?.bind(this.taskRepo);
+        if (listTasks) {
+            for (const t of await listTasks()) {
+                if (t.status !== TaskStatus.RUNNING || !t.sessionId)
+                    continue;
+                const exec = await this.sessionRepo.getExecutionById(t.sessionId);
+                if (!exec)
+                    continue;
+                if (!matchesResource(exec.resourceId))
+                    continue;
+                await this.taskService.cancel(t.id);
+            }
+        }
+        await this.leaseService.revokeByResourceId(resourceId);
+    }
+}

package/dist/application/resource/ResourceRegistryService.js

@@ -0,0 +1,113 @@
+import { DeviceResource, } from "../../domain/resource/DeviceResource.js";
+import { EventType, ResourceStatus, SessionStatus, TaskStatus } from "../../shared-kernel/enums/index.js";
+export class ResourceRegistryService {
+    resourceRepository;
+    adapters;
+    reporter;
+    leaseRepository;
+    taskRepository;
+    sessionRepository;
+    refreshInFlight = null;
+    constructor(resourceRepository, adapters, reporter, leaseRepository, taskRepository, sessionRepository) {
+        this.resourceRepository = resourceRepository;
+        this.adapters = adapters;
+        this.reporter = reporter;
+        this.leaseRepository = leaseRepository;
+        this.taskRepository = taskRepository;
+        this.sessionRepository = sessionRepository;
+    }
+    async refresh() {
+        if (this.refreshInFlight)
+            return this.refreshInFlight;
+        this.refreshInFlight = (async () => {
+            const previous = await this.resourceRepository.list();
+            const previousMap = new Map(previous.map((item) => [item.id, item.status]));
+            const discovered = await Promise.all(this.adapters.map((adapter) => adapter.discover()));
+            const resources = discovered.flat();
+            await this.resourceRepository.saveAll(resources);
+            if (this.reporter) {
+                for (const resource of resources) {
+                    const prevStatus = previousMap.get(resource.id);
+                    if (prevStatus == null || prevStatus !== resource.status) {
+                        await this.reporter.emit(EventType.RESOURCE_CHANGED, {
+                            resourceId: resource.id,
+                            status: resource.status,
+                        });
+                    }
+                }
+            }
+            return resources;
+        })();
+        try {
+            return await this.refreshInFlight;
+        }
+        finally {
+            this.refreshInFlight = null;
+        }
+    }
+    async list() {
+        const raw = await this.resourceRepository.list();
+        return this.mergeActivityIntoResourceStatus(raw);
+    }
+    /**
+     * `/resources` 的物理发现结果始终为 ONLINE；租约与任务/调试状态单独存放。
+     * 列出时合并：**调试会话未结束 → DEBUGGING**，**任务 RUNNING → RUNNING**，**仅有活跃租约 → LEASED**。
+     */
+    async mergeActivityIntoResourceStatus(resources) {
+        const leaseRepo = this.leaseRepository;
+        const taskRepo = this.taskRepository;
+        const sessionRepo = this.sessionRepository;
+        if (!leaseRepo || !taskRepo || !sessionRepo) {
+            return resources;
+        }
+        const listTasks = taskRepo.list?.bind(taskRepo);
+        const listDebugSessions = sessionRepo.listDebugSessions?.bind(sessionRepo);
+        if (!listTasks || !listDebugSessions) {
+            return resources;
+        }
+        const byResource = new Map();
+        for (const s of await listDebugSessions()) {
+            if (s.status === SessionStatus.CLOSED)
+                continue;
+            byResource.set(String(s.resourceId), ResourceStatus.DEBUGGING);
+        }
+        for (const t of await listTasks()) {
+            if (t.status !== TaskStatus.RUNNING || !t.sessionId)
+                continue;
+            const exec = await sessionRepo.getExecutionById(t.sessionId);
+            if (!exec)
+                continue;
+            const rid = String(exec.resourceId);
+            if (byResource.get(rid) === ResourceStatus.DEBUGGING)
+                continue;
+            byResource.set(rid, ResourceStatus.RUNNING);
+        }
+        const now = new Date();
+        const out = [];
+        for (const r of resources) {
+            const rid = String(r.id);
+            let next = byResource.get(rid);
+            const lease = await leaseRepo.getActiveByResourceId(r.id);
+            if (!next && lease?.isActive(now)) {
+                next = ResourceStatus.LEASED;
+            }
+            let occupancy;
+            if (lease?.isActive(now)) {
+                occupancy = {
+                    leaseId: String(lease.id),
+                    ownerId: lease.ownerId,
+                    ownerType: lease.ownerType,
+                    ...(lease.occupantUsername?.trim()
+                        ? { occupantUsername: lease.occupantUsername.trim() }
+                        : {}),
+                    ...(lease.occupantDisplayName?.trim()
+                        ? { occupantDisplayName: lease.occupantDisplayName.trim() }
+                        : {}),
+                };
+            }
+            const mergedStatus = next && next !== r.status ? next : r.status;
+            out.push(new DeviceResource(r.id, r.platform, mergedStatus, r.capability, r.deviceDetails, occupancy));
+        }
+        return out;
+    }
+}

package/dist/application/session/SessionApplicationService.js

@@ -0,0 +1,39 @@
+import { DebugSession } from "../../domain/session/DebugSession.js";
+import { ExecutionSession } from "../../domain/session/ExecutionSession.js";
+import { asLeaseId, asResourceId, asSessionId, } from "../../shared-kernel/ids/index.js";
+import { SessionStatus } from "../../shared-kernel/enums/index.js";
+export class SessionApplicationService {
+    sessionRepository;
+    constructor(sessionRepository) {
+        this.sessionRepository = sessionRepository;
+    }
+    async createExecution(sessionId, resourceId, leaseId, ownerId, ownerType) {
+        const session = new ExecutionSession(asSessionId(sessionId), resourceId, leaseId, ownerId, ownerType, SessionStatus.CREATED);
+        await this.sessionRepository.saveExecution(session);
+        return session;
+    }
+    async createDebug(sessionId, resourceId, leaseId, ownerId, ownerType) {
+        const session = new DebugSession(asSessionId(sessionId), asResourceId(resourceId), asLeaseId(leaseId), ownerId, ownerType, SessionStatus.CREATED);
+        await this.sessionRepository.saveDebug(session);
+        return session;
+    }
+    async closeExecution(sessionId) {
+        const session = await this.sessionRepository.getExecutionById(sessionId);
+        if (!session)
+            return null;
+        session.status = SessionStatus.CLOSED;
+        await this.sessionRepository.saveExecution(session);
+        return session;
+    }
+    async closeDebug(sessionId) {
+        const session = await this.sessionRepository.getDebugById(sessionId);
+        if (!session)
+            return null;
+        session.status = SessionStatus.CLOSED;
+        await this.sessionRepository.saveDebug(session);
+        return session;
+    }
+    async getDebug(sessionId) {
+        return this.sessionRepository.getDebugById(sessionId);
+    }
+}