tapline-host 1.1.0 → 1.3.0

package/dist/tools.d.ts

@@ -178,6 +178,21 @@ export declare const toolShapes: {
         readonly name: z.ZodString;
         readonly update: z.ZodOptional<z.ZodBoolean>;
         readonly width: z.ZodOptional<z.ZodNumber>;
+        readonly threshold: z.ZodOptional<z.ZodNumber>;
+        readonly ignore: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            ref: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            index: z.ZodOptional<z.ZodNumber>;
+            x: z.ZodOptional<z.ZodNumber>;
+            y: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>>;
     };
     readonly filmstrip: {
         readonly frames: z.ZodOptional<z.ZodNumber>;
@@ -224,10 +239,33 @@ export declare const toolShapes: {
     };
     readonly logs: {
         readonly since: z.ZodOptional<z.ZodNumber>;
+        readonly level: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+            info: "info";
+        }>>;
+        readonly grep: z.ZodOptional<z.ZodString>;
+        readonly limit: z.ZodOptional<z.ZodNumber>;
+    };
+    readonly crash: {
+        readonly all: z.ZodOptional<z.ZodBoolean>;
     };
     readonly reload: {
         readonly look: z.ZodOptional<z.ZodBoolean>;
     };
+    readonly performance: {
+        readonly launch: z.ZodOptional<z.ZodBoolean>;
+        readonly seconds: z.ZodOptional<z.ZodNumber>;
+        readonly tap: z.ZodOptional<z.ZodObject<{
+            ref: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            index: z.ZodOptional<z.ZodNumber>;
+            x: z.ZodOptional<z.ZodNumber>;
+            y: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    };
     readonly wait: {
         readonly seconds: z.ZodNumber;
         readonly screenshot: z.ZodOptional<z.ZodBoolean>;
@@ -241,7 +279,11 @@ export declare const toolShapes: {
                 label: z.ZodOptional<z.ZodString>;
                 gone: z.ZodOptional<z.ZodBoolean>;
                 value: z.ZodOptional<z.ZodString>;
+                matches: z.ZodOptional<z.ZodString>;
+                threshold: z.ZodOptional<z.ZodNumber>;
+                ignore: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
                 timeout: z.ZodOptional<z.ZodNumber>;
+                under: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
             }, z.core.$strip>>;
         }, z.core.$loose>>;
         readonly trace: z.ZodOptional<z.ZodBoolean>;
@@ -360,11 +402,40 @@ export declare class TaplineTools {
     private personNotePending;
     private recording;
     private replaying;
+    /**
+     * While a script replays (AGENT-TOOLS 1.9 §14.3): the references folder next to it (looked in first), where a
+     * failed check puts its red picture, and whether the checks save instead of compare (`--update-references`).
+     */
+    private replayContext;
+    /** Where the latest failed check of the running batch saved its picture. */
+    private diffSaved;
+    /** What the last `performance` call measured, for the `under` limits of a `run` step. */
+    private lastPerf;
+    /** The elements the latest comparison painted its ignore list from: a recording saves its mask from the same list. */
+    private lastMaskElements;
     /** The screen size in points from the latest list or overlay, for the live viewer's 0..1 positions. */
     private lastScreen;
     private shotCount;
     private pairWrites;
+    /** Per app (by identity): crash events up to this one have been told to the agent. */
+    private readonly notedCrashSeqs;
+    /** Crash events up to this one happened before this agent's session: an app with no entry above starts here. */
+    private readonly crashBaseline;
+    /** Set inside a tool call (and everything it awaits), so a call within a call (`run`'s steps) adds no notes. */
+    private readonly noteScope;
     constructor(host: TaplineHost, options: ToolsOptions);
+    /**
+     * Runs a tool call and ends its answer with a note when the app stopped (AGENT-TOOLS 15.2): during this
+     * call, or earlier, with its time, once. Calls inside a call (`run`'s steps) add nothing of their own.
+     */
+    private noting;
+    /** What was told about this app's crashes so far: the crash events up to this number. */
+    private notedSeqOf;
+    /**
+     * The notes for the app this call used (the one at its start, the one at its end, or, with none connected, the
+     * one that dropped last). Other apps' events stay pending until that app is the one being driven.
+     */
+    private withCrashNotes;
     /** A person used the app: the next answer says so once, and `{ref}` targets are stale until the next full list. */
     private markPersonUsedApp;
     private notConnected;
@@ -381,6 +452,15 @@ export declare class TaplineTools {
     openApp(args: Shape<"open_app">): CallToolResult;
     look(args?: Shape<"look">): Promise<CallToolResult>;
     run(args: Shape<"run">): Promise<CallToolResult>;
+    /** The newest log time of a session (or of the app's current session), undefined without lines. */
+    private newestLogTs;
+    /**
+     * A session's buffered lines, also when it has ended. When the same app on the same phone came back as a new
+     * session, that session's lines follow. Another app's lines never stand in for it (Codex review of 1.3.0).
+     */
+    private sessionLogs;
+    /** AGENT-TOOLS §15.4: `Logs (since step <n>):` and up to 20 lines at warning or above since the step began. */
+    private failureLogs;
     /** `run` with dry_run (§11.4): the steps are checked already; step 1 is resolved, nothing is touched. */
     private dryRunBatch;
     /** One step of `run`, as its own tool call without a list. */
@@ -389,6 +469,7 @@ export declare class TaplineTools {
     private currentRoute;
     /** Null when the expectation holds within its time; else how it failed. */
     private expectMissed;
+    private textExpectMissed;
     inspect(args: Shape<"inspect">): Promise<CallToolResult>;
     audit(args?: Shape<"audit">): Promise<CallToolResult>;
     checkLayout(_args?: Shape<"check_layout">): Promise<CallToolResult>;
@@ -430,12 +511,52 @@ export declare class TaplineTools {
     private takeShot;
     /** Adds an image to a result: inline, or saved with its path in file mode. */
     private deliver;
+    /** Where this app's reference pictures are kept, or an error answer. */
+    private referenceFolder;
+    /** The element list for naming regions and masking, read as a peek: the agent's refs and baseline must stay as they are. */
+    private peekElements;
+    /**
+     * Takes the screen and compares it with the saved reference called `name`, never saving. `referencesDirs` are the
+     * folders to look in, in order. A missing reference hands back the screenshot, so the caller may save it.
+     */
+    private checkAgainstReference;
+    /** Why a check does not hold (for `run`, as a step or as `matches`), or null when it matches. */
+    private referenceReason;
+    /** Whether the screen matches the reference `name` now (`expect.matches`): null when it does, else the reason. */
+    private matchMissed;
+    /** Where a check looks for `<name>.jpg`: the folder next to a replayed script first, then the app's own store. */
+    private referencesDirs;
+    /** In a replay, a failed check leaves its red picture at `<script>.diff/<name>.jpg`. */
+    private keepDiff;
+    /** Takes the screen and saves it as the reference `name` in `dir`. */
+    private saveReferenceHere;
+    private writeReference;
+    /** A `compare_screen` step of `run`: it never saves; it holds on a match and stops the batch otherwise. */
+    private compareStep;
+    /**
+     * Saves a visual check that held as a `compareScreen` step of the recording, when one is running: the name, and the
+     * threshold, the ignore list (refs made stable) and the width when given. `update` is never written. Answers an
+     * error line when an ignore ref can't be kept in a script, else null (also when nothing is recording).
+     */
+    private recordCompare;
+    /**
+     * `ignore` as a script keeps it (AGENT-TOOLS 1.9 §14.2): a ref becomes the element's id, else label, else text,
+     * read from the list now. A string is the error answer when a ref can't be kept.
+     */
+    private stableIgnore;
     compareScreen(args: Shape<"compare_screen">): Promise<CallToolResult>;
+    private compareScreenNow;
     filmstrip(args: Shape<"filmstrip">): Promise<CallToolResult>;
     private scriptPath;
     record(args: Shape<"record">): Promise<CallToolResult>;
+    /** `<script dir>/<script name>.references` and `.diff` for a script file. */
+    private scriptSideFolder;
+    /** Copies each reference the steps use from the app's store next to the script; null when there are none. */
+    private copyReferences;
     private scriptList;
-    replay(args: Shape<"replay">): Promise<CallToolResult>;
+    replay(args: Shape<"replay">, options?: {
+        updateReferences?: boolean;
+    }): Promise<CallToolResult>;
     private withLook;
     /**
      * The element a result carries under `key`, for an answer's first line: without its actions, position or
@@ -486,7 +607,17 @@ export declare class TaplineTools {
     back(args: Shape<"back">): Promise<CallToolResult>;
     openUrl(args: Shape<"open_url">): Promise<CallToolResult>;
     logs(args: Shape<"logs">): Promise<CallToolResult>;
+    /** The newest fatal JS error of the app (`all`: the last 5). Reading them tells the agent what the notes did. */
+    crash(args?: Shape<"crash">): CallToolResult;
     reload(args: Shape<"reload">): Promise<CallToolResult>;
+    /**
+     * `launch`: a JavaScript reload (development builds), timed from the request to the new session's first
+     * settled screen. Stops with the answer when the reload can't be made or the app doesn't come back.
+     */
+    private timedReload;
+    /** One measuring window in the app: start, (the tap,) wait out `seconds`, stop. */
+    private measureWindow;
+    performance(args?: Shape<"performance">): Promise<CallToolResult>;
     wait(args: Shape<"wait">): Promise<CallToolResult>;
 }
 export {};