preflite 1.0.1

package/dist/infrastructure/persistence/InMemoryRepositories.js

@@ -0,0 +1,94 @@
+import { LeaseStatus } from "../../shared-kernel/enums/index.js";
+export class InMemoryAgentRepository {
+    agent = null;
+    async save(agent) {
+        this.agent = agent;
+    }
+    async get() {
+        return this.agent;
+    }
+}
+export class InMemoryResourceRepository {
+    resources = new Map();
+    async list() {
+        return Array.from(this.resources.values());
+    }
+    async getById(id) {
+        return this.resources.get(id) ?? null;
+    }
+    async saveAll(resources) {
+        this.resources = new Map(resources.map((resource) => [resource.id, resource]));
+    }
+    async save(resource) {
+        this.resources.set(resource.id, resource);
+    }
+}
+export class InMemoryLeaseRepository {
+    leases = new Map();
+    async save(lease) {
+        this.leases.set(lease.id, lease);
+    }
+    async getById(id) {
+        return this.leases.get(id) ?? null;
+    }
+    async getActiveByResourceId(resourceId) {
+        const lease = Array.from(this.leases.values()).find((item) => item.resourceId === resourceId &&
+            item.status === LeaseStatus.ACTIVE &&
+            new Date(item.expiresAt).getTime() > Date.now());
+        return lease ?? null;
+    }
+}
+export class InMemorySessionRepository {
+    executionSessions = new Map();
+    debugSessions = new Map();
+    async saveExecution(session) {
+        this.executionSessions.set(session.id, session);
+    }
+    async saveDebug(session) {
+        this.debugSessions.set(session.id, session);
+    }
+    async getExecutionById(id) {
+        return this.executionSessions.get(id) ?? null;
+    }
+    async getDebugById(id) {
+        return this.debugSessions.get(id) ?? null;
+    }
+    async listDebugSessions() {
+        return Array.from(this.debugSessions.values());
+    }
+}
+export class InMemoryTaskRepository {
+    tasks = new Map();
+    async save(task) {
+        this.tasks.set(task.id, task);
+    }
+    async getById(id) {
+        return this.tasks.get(id) ?? null;
+    }
+    async list() {
+        return Array.from(this.tasks.values());
+    }
+}
+export class InMemoryArtifactRepository {
+    artifacts = new Map();
+    async saveMany(artifacts) {
+        if (artifacts.length === 0)
+            return;
+        const taskId = artifacts[0].taskId;
+        const list = this.artifacts.get(taskId) ?? [];
+        list.push(...artifacts);
+        this.artifacts.set(taskId, list);
+    }
+    async listByTaskId(taskId) {
+        return this.artifacts.get(taskId) ?? [];
+    }
+}
+export class InMemoryEventRepository {
+    events = [];
+    async append(event) {
+        this.events.push(event);
+    }
+    async list() {
+        return this.events;
+    }
+}

package/dist/infrastructure/resilience/DeliveryIdDeduper.js

@@ -0,0 +1,26 @@
+/** 近期已确认处理过的 deliveryId，用于幂等；LRU 淘汰 */
+export class DeliveryIdDeduper {
+    maxSize;
+    order = [];
+    seen = new Set();
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+    }
+    isProcessed(deliveryId) {
+        return deliveryId !== "" && this.seen.has(deliveryId);
+    }
+    /** 标记为已处理（成功处理路径上调用） */
+    markProcessed(deliveryId) {
+        if (!deliveryId)
+            return;
+        if (this.seen.has(deliveryId))
+            return;
+        this.seen.add(deliveryId);
+        this.order.push(deliveryId);
+        while (this.order.length > this.maxSize) {
+            const evict = this.order.shift();
+            if (evict)
+                this.seen.delete(evict);
+        }
+    }
+}

package/dist/infrastructure/system/CommandRunner.js

@@ -0,0 +1,128 @@
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import path from "node:path";
+/**
+ * 在子进程 PATH 前插入常见 CLI 目录（adb / ideviceinfo / brew 等），避免 GUI/Cursor 启动的 Node
+ * 未继承 zsh PATH 时找不到命令。最前可由 `AGENT_EXTRA_PATH` 或 `AUTOMATION_AGENT_EXTRA_PATH` 覆盖（与 OS 相同的 PATH 分隔符）。
+ * 若 `options.env` 显式传入 `PATH`，则不再改写，由调用方完全控制。
+ */
+export function augmentPathForShellCommands(basePath) {
+    const sep = path.delimiter;
+    const extraEnv = process.env.AGENT_EXTRA_PATH?.trim() || process.env.AUTOMATION_AGENT_EXTRA_PATH?.trim();
+    const customHead = extraEnv
+        ? extraEnv
+            .split(sep)
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : [];
+    const home = homedir();
+    const sdkRoot = process.env.ANDROID_HOME?.trim() || process.env.ANDROID_SDK_ROOT?.trim();
+    const prepend = [
+        ...customHead,
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+        ...(sdkRoot ? [path.join(sdkRoot, "platform-tools")] : []),
+        path.join(home, "Library/Android/sdk/platform-tools"),
+        "/usr/bin",
+        "/bin",
+    ];
+    const seen = new Set();
+    const ordered = [];
+    for (const p of prepend) {
+        const n = path.normalize(p);
+        if (!n || seen.has(n))
+            continue;
+        seen.add(n);
+        ordered.push(n);
+    }
+    for (const p of (basePath ?? "").split(sep)) {
+        const n = p.trim();
+        if (!n)
+            continue;
+        const norm = path.normalize(n);
+        if (seen.has(norm))
+            continue;
+        seen.add(norm);
+        ordered.push(n);
+    }
+    return ordered.join(sep);
+}
+export class NodeCommandRunner {
+    async run(command, timeoutMs = 60_000, signal, options) {
+        return new Promise((resolve) => {
+            const optEnv = options?.env ?? {};
+            const merged = {
+                ...process.env,
+                ...optEnv,
+            };
+            if (!("PATH" in optEnv)) {
+                merged.PATH = augmentPathForShellCommands(process.env.PATH);
+            }
+            const child = spawn("sh", ["-lc", command], {
+                stdio: ["ignore", "pipe", "pipe"],
+                env: merged,
+            });
+            let stdout = "";
+            let stderr = "";
+            let killedByTimeout = false;
+            let killedByAbort = false;
+            const timer = setTimeout(() => {
+                killedByTimeout = true;
+                child.kill("SIGTERM");
+            }, timeoutMs);
+            const abortHandler = () => {
+                killedByAbort = true;
+                child.kill("SIGTERM");
+            };
+            signal?.addEventListener("abort", abortHandler, { once: true });
+            child.stdout.on("data", (chunk) => {
+                const t = chunk.toString();
+                stdout += t;
+                options?.onStdoutChunk?.(t);
+            });
+            child.stderr.on("data", (chunk) => {
+                const t = chunk.toString();
+                stderr += t;
+                options?.onStderrChunk?.(t);
+            });
+            child.on("close", (code) => {
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", abortHandler);
+                if (killedByAbort) {
+                    resolve({
+                        ok: false,
+                        exitCode: -1,
+                        stdout,
+                        stderr: `${stderr}\ncommand cancelled`,
+                    });
+                    return;
+                }
+                if (killedByTimeout) {
+                    resolve({
+                        ok: false,
+                        exitCode: -1,
+                        stdout,
+                        stderr: `${stderr}\ncommand timeout after ${timeoutMs}ms`,
+                    });
+                    return;
+                }
+                resolve({
+                    ok: code === 0,
+                    exitCode: code ?? -1,
+                    stdout,
+                    stderr,
+                });
+            });
+            child.on("error", (error) => {
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", abortHandler);
+                resolve({
+                    ok: false,
+                    exitCode: -1,
+                    stdout,
+                    stderr: `${stderr}\n${error.message}`,
+                });
+            });
+        });
+    }
+}

package/dist/infrastructure/transport/http/AgentEventHttpIngestClient.js

@@ -0,0 +1,52 @@
+/**
+ * WS 不可用时的 Agent 事件 HTTP 投递（与 WS 文本帧同构 JSON）。
+ * 实况调试二进制帧不走此通道，仍仅通过 {@link WsEventPublisher}。
+ */
+export class AgentEventHttpIngestClient {
+    opts;
+    base;
+    fetchImpl;
+    timeoutMs;
+    constructor(opts) {
+        this.opts = opts;
+        this.base = opts.baseUrl?.trim() || undefined;
+        this.fetchImpl = opts.fetchImpl ?? fetch;
+        const t = opts.timeoutMs;
+        this.timeoutMs = t != null && Number.isFinite(t) && t > 0 ? t : 12_000;
+    }
+    isEnabled() {
+        return !!this.base;
+    }
+    async postEvent(event) {
+        if (!this.base)
+            return;
+        const url = `${this.base.replace(/\/+$/, "")}/api/agents/${encodeURIComponent(this.opts.agentId)}/events`;
+        const headers = {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        };
+        if (this.opts.authToken)
+            headers.Authorization = `Bearer ${this.opts.authToken}`;
+        const body = JSON.stringify({
+            type: event.type,
+            timestamp: event.timestamp,
+            payload: event.payload,
+        });
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), this.timeoutMs);
+        try {
+            const resp = await this.fetchImpl(url, {
+                method: "POST",
+                headers,
+                body,
+                signal: ac.signal,
+            });
+            if (!resp.ok) {
+                throw new Error(`event ingest HTTP ${resp.status}`);
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}

package/dist/infrastructure/transport/http/CallbackOutboxStore.js

@@ -0,0 +1,106 @@
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { isCallbackNotFoundError, } from "./PlatformCallbackClient.js";
+const OUTBOX_NAME = "callback-outbox";
+/** 出站队列某条记录连续失败后，下次最早尝试时间（指数退避，避免平台短时不可用仍高频 POST） */
+function outboxBackoffBaseMs() {
+    const raw = Number(process.env.CALLBACK_OUTBOX_BACKOFF_BASE_MS ?? "2000");
+    return Number.isFinite(raw) && raw >= 200 ? Math.floor(raw) : 2000;
+}
+function outboxBackoffMaxMs() {
+    const raw = Number(process.env.CALLBACK_OUTBOX_BACKOFF_MAX_MS ?? "300000");
+    return Number.isFinite(raw) && raw >= 1000 ? Math.floor(raw) : 300000;
+}
+function defaultOutboxDir() {
+    return path.join(process.env.CALLBACK_OUTBOX_DIR?.trim() || path.join(homedir(), ".preflight-agent"), OUTBOX_NAME);
+}
+export class CallbackOutboxStore {
+    dir;
+    nextEligibleAt = new Map();
+    consecutiveFails = new Map();
+    constructor(dir = defaultOutboxDir()) {
+        this.dir = dir;
+    }
+    async pathFor(id) {
+        return path.join(this.dir, id);
+    }
+    async ensureReady() {
+        await mkdir(this.dir, { recursive: true });
+    }
+    async enqueue(record) {
+        const id = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}.json`;
+        const full = { v: 1, ...record };
+        await this.ensureReady();
+        const filePath = await this.pathFor(id);
+        await writeFile(filePath, JSON.stringify(full), "utf8");
+        return { id };
+    }
+    async processWith(client, limit = 50) {
+        let processed = 0;
+        let failed = 0;
+        let files;
+        try {
+            files = await readdir(this.dir);
+        }
+        catch {
+            return { processed, failed };
+        }
+        const sorted = files.filter((f) => f.endsWith(".json")).sort();
+        for (const name of sorted) {
+            if (processed + failed >= limit)
+                break;
+            const fp = path.join(this.dir, name);
+            const eligibleAt = this.nextEligibleAt.get(fp) ?? 0;
+            if (Date.now() < eligibleAt)
+                continue;
+            let raw;
+            try {
+                raw = await readFile(fp, "utf8");
+            }
+            catch {
+                continue;
+            }
+            let rec;
+            try {
+                rec = JSON.parse(raw);
+            }
+            catch {
+                continue;
+            }
+            try {
+                if (rec.kind === "log") {
+                    await client.pushTaskLog(rec.taskId, rec.payload);
+                }
+                else if (rec.kind === "report") {
+                    await client.pushTaskReport(rec.taskId, rec.payload);
+                }
+                else {
+                    await client.pushTaskStatus(rec.taskId, rec.payload);
+                }
+                await rm(fp, { force: true });
+                this.nextEligibleAt.delete(fp);
+                this.consecutiveFails.delete(fp);
+                processed += 1;
+            }
+            catch (e) {
+                if (isCallbackNotFoundError(e)) {
+                    await rm(fp, { force: true });
+                    this.nextEligibleAt.delete(fp);
+                    this.consecutiveFails.delete(fp);
+                    processed += 1;
+                    console.warn(`[CallbackOutbox] dropped ${name} taskId=${rec.taskId} (callback 404, removed from outbox)`);
+                    continue;
+                }
+                failed += 1;
+                const n = (this.consecutiveFails.get(fp) ?? 0) + 1;
+                this.consecutiveFails.set(fp, n);
+                const rawDelay = outboxBackoffBaseMs() * 2 ** Math.min(n - 1, 14);
+                const delay = Math.min(outboxBackoffMaxMs(), rawDelay);
+                this.nextEligibleAt.set(fp, Date.now() + delay);
+                console.warn(`[CallbackOutbox] redelivery failed ${name} taskId=${rec.taskId} fail#=${n} nextEligibleIn=${delay}ms`);
+            }
+        }
+        return { processed, failed };
+    }
+}

package/dist/infrastructure/transport/http/PlatformCallbackClient.js

@@ -0,0 +1,113 @@
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/** 单次请求超时（毫秒）；大报告体可调大 */
+function callbackHttpTimeoutMs() {
+    const raw = Number(process.env.PLATFORM_CALLBACK_HTTP_TIMEOUT_MS ?? "120000");
+    return Number.isFinite(raw) && raw >= 5000 ? Math.floor(raw) : 120000;
+}
+/** 同一请求内失败后的最大尝试次数（含首次） */
+function callbackMaxAttempts() {
+    const raw = Number(process.env.PLATFORM_CALLBACK_HTTP_MAX_ATTEMPTS ?? "3");
+    const n = Math.floor(raw);
+    return n >= 1 && n <= 10 ? n : 3;
+}
+/** 重试基础间隔（毫秒），实际为指数退避：base * 2^attempt */
+function callbackRetryBaseMs() {
+    const raw = Number(process.env.PLATFORM_CALLBACK_HTTP_RETRY_BASE_MS ?? "500");
+    return Number.isFinite(raw) && raw >= 50 ? Math.floor(raw) : 500;
+}
+function shouldRetryHttpStatus(status) {
+    if (status === 408 || status === 429)
+        return true;
+    if (status >= 500 && status <= 504)
+        return true;
+    return false;
+}
+/** 平台回调 HTTP 404（如 unknown agent task id）：无需再重试或保留 Outbox */
+export function isCallbackNotFoundError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /\bcallback failed: 404\b/.test(msg);
+}
+export class PlatformCallbackClient {
+    endpoint;
+    authToken;
+    constructor(options) {
+        this.endpoint = options.endpoint?.trim() || undefined;
+        this.authToken = options.authToken?.trim() || undefined;
+    }
+    async post(path, body) {
+        if (!this.endpoint)
+            return;
+        const url = `${this.endpoint.replace(/\/+$/, "")}${path}`;
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.authToken)
+            headers.Authorization = `Bearer ${this.authToken}`;
+        const timeoutMs = callbackHttpTimeoutMs();
+        const maxAttempts = callbackMaxAttempts();
+        const baseMs = callbackRetryBaseMs();
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const signal = AbortSignal.timeout(timeoutMs);
+            try {
+                const resp = await fetch(url, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(body),
+                    signal,
+                });
+                if (resp.ok)
+                    return;
+                const snippet = await resp.text().catch(() => "");
+                const status = resp.status;
+                const hint = status === 401
+                    ? "（请核对平台生成的 Token 与 Agent 侧 AGENT_HTTP_TOKEN 一致；PLATFORM_WS_TOKEN / PLATFORM_AGENT_CALLBACK_TOKEN 未填时会复用 AGENT_HTTP_TOKEN）"
+                    : status === 503
+                        ? "（平台未配置回调鉴权 token）"
+                        : "";
+                console.warn(`[PlatformCallback] POST ${path} -> ${status}${hint}${snippet ? ` body=${snippet.slice(0, 200)}` : ""}`);
+                if (!shouldRetryHttpStatus(status)) {
+                    throw new Error(`callback failed: ${status}`);
+                }
+                if (attempt < maxAttempts - 1) {
+                    const wait = baseMs * 2 ** attempt;
+                    console.warn(`[PlatformCallback] POST ${path} HTTP ${status} 可重试，${wait}ms 后进行第 ${attempt + 2}/${maxAttempts} 次尝试`);
+                    await sleep(wait);
+                    continue;
+                }
+                throw new Error(`callback failed: ${status}`);
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(String(e));
+                const hf = /^callback failed: (\d+)$/.exec(err.message);
+                if (hf) {
+                    const code = Number(hf[1]);
+                    if (!shouldRetryHttpStatus(code))
+                        throw err;
+                    if (attempt >= maxAttempts - 1)
+                        throw err;
+                }
+                const transient = err.name === "AbortError" ||
+                    err.name === "TimeoutError" ||
+                    /fetch failed|ECONNRESET|ECONNREFUSED|ETIMEDOUT/i.test(err.message);
+                if (!transient)
+                    throw err;
+                if (attempt >= maxAttempts - 1)
+                    throw err;
+                const wait = baseMs * 2 ** attempt;
+                console.warn(`[PlatformCallback] POST ${path} 传输失败 (${err.message})，${wait}ms 后重试 (${attempt + 2}/${maxAttempts})`);
+                await sleep(wait);
+            }
+        }
+    }
+    async pushTaskStatus(taskId, payload) {
+        await this.post(`/api/agent/callbacks/tasks/${encodeURIComponent(taskId)}/status`, payload);
+    }
+    async pushTaskLog(taskId, payload) {
+        await this.post(`/api/agent/callbacks/tasks/${encodeURIComponent(taskId)}/log`, { ...payload, taskId });
+    }
+    async pushTaskReport(taskId, payload) {
+        await this.post(`/api/agent/callbacks/tasks/${encodeURIComponent(taskId)}/report`, { ...payload, taskId });
+    }
+}

package/dist/infrastructure/transport/http/PlatformCommandPollClient.js

@@ -0,0 +1,89 @@
+export class PlatformCommandPollClient {
+    opts;
+    base;
+    fetchImpl;
+    timeoutMs;
+    constructor(opts) {
+        this.opts = opts;
+        this.base = opts.baseUrl?.trim() || undefined;
+        this.fetchImpl = opts.fetchImpl ?? fetch;
+        const t = opts.timeoutMs;
+        this.timeoutMs = t != null && Number.isFinite(t) && t > 0 ? t : 15_000;
+    }
+    isEnabled() {
+        return !!this.base;
+    }
+    url(path) {
+        return `${this.base.replace(/\/+$/, "")}${path}`;
+    }
+    async fetchPending(limit) {
+        if (!this.base)
+            return [];
+        const lim = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 20;
+        const path = `/api/agents/${encodeURIComponent(this.opts.agentId)}/commands/pending?limit=${lim}`;
+        const headers = { Accept: "application/json" };
+        if (this.opts.authToken)
+            headers.Authorization = `Bearer ${this.opts.authToken}`;
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), this.timeoutMs);
+        try {
+            const resp = await this.fetchImpl(this.url(path), {
+                method: "GET",
+                headers,
+                signal: ac.signal,
+            });
+            if (!resp.ok) {
+                throw new Error(`poll pending failed: ${resp.status}`);
+            }
+            const body = (await resp.json());
+            const items = Array.isArray(body.items) ? body.items : [];
+            const out = [];
+            for (const row of items) {
+                if (!row || typeof row !== "object")
+                    continue;
+                const r = row;
+                const deliveryId = typeof r.deliveryId === "string" ? r.deliveryId.trim() : "";
+                const cmd = r.command;
+                if (!deliveryId || !cmd || typeof cmd !== "object" || typeof cmd.type !== "string") {
+                    continue;
+                }
+                out.push({
+                    deliveryId,
+                    issuedAt: typeof r.issuedAt === "string" ? r.issuedAt : undefined,
+                    command: cmd,
+                });
+            }
+            return out;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async ack(deliveryIds) {
+        if (!this.base || deliveryIds.length === 0)
+            return;
+        const path = `/api/agents/${encodeURIComponent(this.opts.agentId)}/commands/ack`;
+        const headers = {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        };
+        if (this.opts.authToken)
+            headers.Authorization = `Bearer ${this.opts.authToken}`;
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), this.timeoutMs);
+        try {
+            const resp = await this.fetchImpl(this.url(path), {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ deliveryIds }),
+                signal: ac.signal,
+            });
+            if (!resp.ok) {
+                throw new Error(`ack failed: ${resp.status}`);
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}