agent-device 0.3.0 → 0.3.2

package/src/utils/retry.ts

@@ -8,6 +8,47 @@ type RetryOptions = {
   shouldRetry?: (error: unknown, attempt: number) => boolean;
 };
 
+export type RetryPolicy = {
+  maxAttempts: number;
+  baseDelayMs: number;
+  maxDelayMs: number;
+  jitter: number;
+  shouldRetry?: (error: unknown, attempt: number) => boolean;
+};
+
+export type RetryAttemptContext = {
+  attempt: number;
+  maxAttempts: number;
+  deadline?: Deadline;
+};
+
+export type TimeoutProfile = {
+  startupMs: number;
+  operationMs: number;
+  totalMs: number;
+};
+
+export type RetryTelemetryEvent = {
+  phase?: string;
+  event: 'attempt_failed' | 'retry_scheduled' | 'succeeded' | 'exhausted';
+  attempt: number;
+  maxAttempts: number;
+  delayMs?: number;
+  elapsedMs?: number;
+  remainingMs?: number;
+  reason?: string;
+};
+
+export function isEnvTruthy(value: string | undefined): boolean {
+  return ['1', 'true', 'yes', 'on'].includes((value ?? '').toLowerCase());
+}
+
+export const TIMEOUT_PROFILES: Record<string, TimeoutProfile> = {
+  ios_boot: { startupMs: 120_000, operationMs: 20_000, totalMs: 120_000 },
+  ios_runner_connect: { startupMs: 120_000, operationMs: 15_000, totalMs: 120_000 },
+  android_boot: { startupMs: 60_000, operationMs: 10_000, totalMs: 60_000 },
+};
+
 const defaultOptions: Required<Pick<RetryOptions, 'attempts' | 'baseDelayMs' | 'maxDelayMs' | 'jitter'>> = {
   attempts: 3,
   baseDelayMs: 200,
@@ -15,30 +56,119 @@ const defaultOptions: Required<Pick<RetryOptions, 'attempts' | 'baseDelayMs' | '
   jitter: 0.2,
 };
 
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  options: RetryOptions = {},
+export class Deadline {
+  private readonly startedAtMs: number;
+  private readonly expiresAtMs: number;
+
+  private constructor(startedAtMs: number, timeoutMs: number) {
+    this.startedAtMs = startedAtMs;
+    this.expiresAtMs = startedAtMs + Math.max(0, timeoutMs);
+  }
+
+  static fromTimeoutMs(timeoutMs: number, nowMs = Date.now()): Deadline {
+    return new Deadline(nowMs, timeoutMs);
+  }
+
+  remainingMs(nowMs = Date.now()): number {
+    return Math.max(0, this.expiresAtMs - nowMs);
+  }
+
+  elapsedMs(nowMs = Date.now()): number {
+    return Math.max(0, nowMs - this.startedAtMs);
+  }
+
+  isExpired(nowMs = Date.now()): boolean {
+    return this.remainingMs(nowMs) <= 0;
+  }
+}
+
+export async function retryWithPolicy<T>(
+  fn: (context: RetryAttemptContext) => Promise<T>,
+  policy: Partial<RetryPolicy> = {},
+  options: {
+    deadline?: Deadline;
+    phase?: string;
+    classifyReason?: (error: unknown) => string | undefined;
+    onEvent?: (event: RetryTelemetryEvent) => void;
+  } = {},
 ): Promise<T> {
-  const attempts = options.attempts ?? defaultOptions.attempts;
-  const baseDelayMs = options.baseDelayMs ?? defaultOptions.baseDelayMs;
-  const maxDelayMs = options.maxDelayMs ?? defaultOptions.maxDelayMs;
-  const jitter = options.jitter ?? defaultOptions.jitter;
+  const merged: RetryPolicy = {
+    maxAttempts: policy.maxAttempts ?? defaultOptions.attempts,
+    baseDelayMs: policy.baseDelayMs ?? defaultOptions.baseDelayMs,
+    maxDelayMs: policy.maxDelayMs ?? defaultOptions.maxDelayMs,
+    jitter: policy.jitter ?? defaultOptions.jitter,
+    shouldRetry: policy.shouldRetry,
+  };
   let lastError: unknown;
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+  for (let attempt = 1; attempt <= merged.maxAttempts; attempt += 1) {
+    if (options.deadline?.isExpired() && attempt > 1) break;
     try {
-      return await fn();
+      const result = await fn({ attempt, maxAttempts: merged.maxAttempts, deadline: options.deadline });
+      options.onEvent?.({
+        phase: options.phase,
+        event: 'succeeded',
+        attempt,
+        maxAttempts: merged.maxAttempts,
+        elapsedMs: options.deadline?.elapsedMs(),
+        remainingMs: options.deadline?.remainingMs(),
+      });
+      return result;
     } catch (err) {
       lastError = err;
-      if (attempt >= attempts) break;
-      if (options.shouldRetry && !options.shouldRetry(err, attempt)) break;
-      const delay = computeDelay(baseDelayMs, maxDelayMs, jitter, attempt);
-      await sleep(delay);
+      const reason = options.classifyReason?.(err);
+      options.onEvent?.({
+        phase: options.phase,
+        event: 'attempt_failed',
+        attempt,
+        maxAttempts: merged.maxAttempts,
+        elapsedMs: options.deadline?.elapsedMs(),
+        remainingMs: options.deadline?.remainingMs(),
+        reason,
+      });
+      if (attempt >= merged.maxAttempts) break;
+      if (merged.shouldRetry && !merged.shouldRetry(err, attempt)) break;
+      const delay = computeDelay(merged.baseDelayMs, merged.maxDelayMs, merged.jitter, attempt);
+      const boundedDelay = options.deadline ? Math.min(delay, options.deadline.remainingMs()) : delay;
+      if (boundedDelay <= 0) break;
+      options.onEvent?.({
+        phase: options.phase,
+        event: 'retry_scheduled',
+        attempt,
+        maxAttempts: merged.maxAttempts,
+        delayMs: boundedDelay,
+        elapsedMs: options.deadline?.elapsedMs(),
+        remainingMs: options.deadline?.remainingMs(),
+        reason,
+      });
+      await sleep(boundedDelay);
     }
   }
+  options.onEvent?.({
+    phase: options.phase,
+    event: 'exhausted',
+    attempt: merged.maxAttempts,
+    maxAttempts: merged.maxAttempts,
+    elapsedMs: options.deadline?.elapsedMs(),
+    remainingMs: options.deadline?.remainingMs(),
+    reason: options.classifyReason?.(lastError),
+  });
   if (lastError) throw lastError;
   throw new AppError('COMMAND_FAILED', 'retry failed');
 }
 
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {},
+): Promise<T> {
+  return retryWithPolicy(() => fn(), {
+    maxAttempts: options.attempts,
+    baseDelayMs: options.baseDelayMs,
+    maxDelayMs: options.maxDelayMs,
+    jitter: options.jitter,
+    shouldRetry: options.shouldRetry,
+  });
+}
+
 function computeDelay(base: number, max: number, jitter: number, attempt: number): number {
   const exp = Math.min(max, base * 2 ** (attempt - 1));
   const jitterAmount = exp * jitter;

package/src/utils/version.ts

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export function readVersion(): string {
+  try {
+    const root = findProjectRoot();
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')) as {
+      version?: string;
+    };
+    return pkg.version ?? '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+export function findProjectRoot(): string {
+  const start = path.dirname(fileURLToPath(import.meta.url));
+  let current = start;
+  for (let i = 0; i < 6; i += 1) {
+    const pkgPath = path.join(current, 'package.json');
+    if (fs.existsSync(pkgPath)) return current;
+    current = path.dirname(current);
+  }
+  return start;
+}

package/dist/src/861.js

@@ -1 +0,0 @@
-import{spawn as e}from"node:child_process";function t(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}class n extends Error{constructor(e,n,o,r){super(n),t(this,"code",void 0),t(this,"details",void 0),t(this,"cause",void 0),this.code=e,this.details=o,this.cause=r}}function o(e){return e instanceof n?e:e instanceof Error?new n("UNKNOWN",e.message,void 0,e):new n("UNKNOWN","Unknown error",{err:e})}async function r(t,o,d={}){return new Promise((r,i)=>{let s=e(t,o,{cwd:d.cwd,env:d.env,stdio:["pipe","pipe","pipe"]}),u="",a=d.binaryStdout?Buffer.alloc(0):void 0,c="";d.binaryStdout||s.stdout.setEncoding("utf8"),s.stderr.setEncoding("utf8"),void 0!==d.stdin&&s.stdin.write(d.stdin),s.stdin.end(),s.stdout.on("data",e=>{d.binaryStdout?a=Buffer.concat([a??Buffer.alloc(0),Buffer.isBuffer(e)?e:Buffer.from(e)]):u+=e}),s.stderr.on("data",e=>{c+=e}),s.on("error",e=>{"ENOENT"===e.code?i(new n("TOOL_MISSING",`${t} not found in PATH`,{cmd:t},e)):i(new n("COMMAND_FAILED",`Failed to run ${t}`,{cmd:t,args:o},e))}),s.on("close",e=>{let s=e??1;0===s||d.allowFailure?r({stdout:u,stderr:c,exitCode:s,stdoutBuffer:a}):i(new n("COMMAND_FAILED",`${t} exited with code ${s}`,{cmd:t,args:o,stdout:u,stderr:c,exitCode:s}))})})}async function d(e){try{var t;let{shell:n,args:o}=(t=e,"win32"===process.platform?{shell:"cmd.exe",args:["/c","where",t]}:{shell:"bash",args:["-lc",`command -v ${t}`]}),d=await r(n,o,{allowFailure:!0});return 0===d.exitCode&&d.stdout.trim().length>0}catch{return!1}}function i(t,n,o={}){e(t,n,{cwd:o.cwd,env:o.env,stdio:"ignore",detached:!0}).unref()}async function s(t,o,r={}){return new Promise((d,i)=>{let s=e(t,o,{cwd:r.cwd,env:r.env,stdio:["pipe","pipe","pipe"]}),u="",a="",c=r.binaryStdout?Buffer.alloc(0):void 0;r.binaryStdout||s.stdout.setEncoding("utf8"),s.stderr.setEncoding("utf8"),void 0!==r.stdin&&s.stdin.write(r.stdin),s.stdin.end(),s.stdout.on("data",e=>{if(r.binaryStdout){c=Buffer.concat([c??Buffer.alloc(0),Buffer.isBuffer(e)?e:Buffer.from(e)]);return}let t=String(e);u+=t,r.onStdoutChunk?.(t)}),s.stderr.on("data",e=>{let t=String(e);a+=t,r.onStderrChunk?.(t)}),s.on("error",e=>{"ENOENT"===e.code?i(new n("TOOL_MISSING",`${t} not found in PATH`,{cmd:t},e)):i(new n("COMMAND_FAILED",`Failed to run ${t}`,{cmd:t,args:o},e))}),s.on("close",e=>{let s=e??1;0===s||r.allowFailure?d({stdout:u,stderr:a,exitCode:s,stdoutBuffer:c}):i(new n("COMMAND_FAILED",`${t} exited with code ${s}`,{cmd:t,args:o,stdout:u,stderr:a,exitCode:s}))})})}function u(t,o,r={}){let d=e(t,o,{cwd:r.cwd,env:r.env,stdio:["ignore","pipe","pipe"]}),i="",s="";d.stdout.setEncoding("utf8"),d.stderr.setEncoding("utf8"),d.stdout.on("data",e=>{i+=e}),d.stderr.on("data",e=>{s+=e});let a=new Promise((e,u)=>{d.on("error",e=>{"ENOENT"===e.code?u(new n("TOOL_MISSING",`${t} not found in PATH`,{cmd:t},e)):u(new n("COMMAND_FAILED",`Failed to run ${t}`,{cmd:t,args:o},e))}),d.on("close",d=>{let a=d??1;0===a||r.allowFailure?e({stdout:i,stderr:s,exitCode:a}):u(new n("COMMAND_FAILED",`${t} exited with code ${a}`,{cmd:t,args:o,stdout:i,stderr:s,exitCode:a}))})});return{child:d,wait:a}}export{fileURLToPath,pathToFileURL}from"node:url";export{default as node_net}from"node:net";export{default as node_fs,promises}from"node:fs";export{default as node_os}from"node:os";export{default as node_path}from"node:path";export{o as asAppError,n as errors_AppError,r as runCmd,u as runCmdBackground,i as runCmdDetached,s as runCmdStreaming,d as whichCmd};