@tapflowio/ios-agent 0.19.0 → 0.20.1

package/dist/SimulatorNetwork.d.ts

@@ -0,0 +1,414 @@
+import type { NetworkStatePayload } from '@tapflowio/agent-core';
+/**
+ * Take one simulator off the network, or put it back (#607).
+ *
+ * A simulator has no NIC to switch off — it is host processes sharing the Mac's network stack — so
+ * "offline" is assembled from three mechanisms, and the whole point of this class is that they are
+ * never applied separately:
+ *
+ *  1. **the host content filter** (`ios-netfilter`) drops the simulator's flows at the kernel
+ *  2. **the injected dylib** tells the app its path is unsatisfied, and cuts the connections it is
+ *     already holding
+ *  3. **the status bar** stops showing service
+ *
+ * Each alone produces a false result a tester would sign off on. Layer 1 alone leaves the app
+ * believing it is online — measured: traffic dead, `NWPathMonitor` reporting satisfied for the life
+ * of the process — and leaves a pooled connection working. Layer 2 alone blocks nothing: faking
+ * `nw_path_get_status` does not stop `URLSession`, which reads the kernel's real path. Layer 3 alone
+ * is pixels.
+ */
+export interface SimulatorNetworkOptions {
+    /** The container app that owns the system extension. Absent or not installed means layer 1 cannot
+     *  be applied, which this class reports rather than works around. */
+    filterHostBinary?: string;
+    /** Where the dylib looks for its per-simulator flag. The host's `/tmp` is visible at the same path
+     *  inside every simulator on the Mac, which is why the file name carries the udid. */
+    conditionDir?: string;
+    /** Where the dylib writes what its self-check found. */
+    verdictDir?: string;
+    /** The injected library. Overridable so a test never arms a real simulator. */
+    nethookDylib?: string;
+    /** Where the provider's state file may be, most likely first. Overridable so a test can point at a
+     *  file it writes rather than at whatever the Mac's real filter is doing. */
+    filterStateFiles?: string[];
+    /** Called when a device that was offline stops being enforced. The agent turns this into an
+     *  unsolicited `network:state`; nothing here knows about the wire. */
+    onEnforcementLost?: (udid: string) => void;
+    /** How often liveness is checked. Overridable so a test does not have to spend seconds of wall
+     *  clock proving that a stale file is noticed; the threshold itself comes from the file. */
+    livenessIntervalMs?: number;
+    /** How long the state-file fallback waits for the provider to publish. Same reason as the interval
+     *  above: proving that a file which never catches up is refused should not cost three seconds. */
+    filterConfirmDeadlineMs?: number;
+}
+/**
+ * How long after a launch an absent verdict is still ordinary (#629).
+ *
+ * **Derived from the dylib rather than picked.** Its verdict is written from a
+ * `__attribute__((constructor))`, which reads as "milliseconds" and is wrong: the constructor runs
+ * `tf_self_check()` first, and that waits on a semaphore for up to **3 seconds** for a path update
+ * (`network-hook.m`). So a perfectly healthy install produces no verdict for three seconds after the
+ * process starts, plus whatever the launch itself took.
+ *
+ * 10s is that plus room for a loaded Mac starting a large app. Generous on purpose: past this the
+ * answer changes from "waiting" to "this cannot work", and being early would put that verdict on an
+ * install that was about to succeed. The cost of being late is that a tester sees `awaiting-app` for a
+ * few seconds longer — which is the true answer for those seconds.
+ */
+export declare const LAUNCH_VERDICT_DEADLINE_MS = 10000;
+/** The simctl calls this needs. Narrower than `SimctlWrapper` so a test can stand in for it. */
+interface SimctlForNetwork {
+    setStatusBarOffline(udid: string, offline: boolean): Promise<void>;
+    setSimulatorEnv(udid: string, name: string, value: string): Promise<void>;
+}
+export declare class SimulatorNetwork {
+    private readonly simctl;
+    private readonly hostBinary;
+    private readonly conditionDir;
+    private readonly verdictDir;
+    private readonly dylib;
+    /** Every simulator currently offline. The filter takes the whole set on each call — it has no
+     *  add/remove — so this is the authority for what the rule should say, not a cache of it. */
+    private readonly offline;
+    /** Devices whose injection is actually in place. Separates "nothing was delivered" from "delivered,
+     *  no app has run under it yet" — two states with different remedies, and a reason each. */
+    private readonly armed;
+    /** Serialises **whole operations**, not just the host run. See `serialize`. */
+    private filterQueue;
+    /** Set while a liveness check is queued, so a slow toggle does not let ticks pile up behind it. */
+    private livenessQueued;
+    /** What layer 1 was last found doing, per device. See `FilterVerdict` for why it is remembered. */
+    private readonly filterVerdict;
+    /** When each device's offline rule was confirmed, in whole seconds. Read by `checkLiveness` to tell
+     *  a file that disagrees from one that is simply older than the write. */
+    private readonly offlineSince;
+    /**
+     * The drop count last reported for each offline device (#654).
+     *
+     * **Two things need it.** The liveness check runs every second, so a device with any drops at all
+     * would otherwise repeat the same line 600 times in a ten-minute session — into the stream where
+     * the enforcement-lost report a person is actually looking for arrives. And the provider's count is
+     * per episode but the *file* is a snapshot: only an increase since the last read is news.
+     *
+     * Cleared wherever `offlineSince` is, so a device that goes offline again starts from nothing —
+     * an absent entry reads as zero, and the provider prunes its own counts per episode too, so both
+     * ends forget together.
+     */
+    private readonly dropsReported;
+    /**
+     * When a launch was last issued for each device (#629).
+     *
+     * A timestamp rather than a timer: `state()` is synchronous and called from several paths, and there
+     * is nothing to cancel — a second launch overwrites this, and a verdict arriving makes it
+     * irrelevant. A timer would have to be cancelled on both.
+     */
+    private readonly launchedAt;
+    /** The pid of the last launch that actually started a process, per device. See `markLaunched`. */
+    private readonly launchedPid;
+    /** Runs only while something is offline. See `updateLiveness`. */
+    private liveness;
+    /** Set by `dispose`. Without it, work that was already in flight puts the interval back: both
+     *  `setOffline` and `checkLiveness` call `updateLiveness()` *after* their awaits, so a dispose
+     *  landing in between was undone by whichever of them resumed next.
+     *
+     *  **No test reaches this flag, and one that appeared to was deleted rather than kept.** The
+     *  scenario it needs — a dispose landing mid-operation, then a state file that makes the watcher
+     *  report on its next tick — did not report even with the flag removed *and* `clearInterval` taken
+     *  out of `dispose`, so the assertion was green against every mutation of the thing it named.
+     *  Observing the watcher stop needs a seam this class does not have (#664). The flag stays because
+     *  it is correct and costs one comparison; what it does not have is coverage, and saying so here is
+     *  cheaper than a test that says otherwise. */
+    private disposed;
+    private readonly stateFiles;
+    private readonly confirmDeadlineMs;
+    private enforcementLost;
+    private readonly livenessIntervalMs;
+    constructor(simctl: SimctlForNetwork, opts?: SimulatorNetworkOptions);
+    /**
+     * Put the injection in place for a device that has just booted.
+     *
+     * **Clearing comes first, and it is not tidiness.** The condition file and the verdict both outlive
+     * the simulator that wrote them — they are on the host, keyed only by udid — so a device that boots
+     * into a leftover condition file is offline before anyone asked, and a leftover verdict answers for
+     * hooks that belong to a process which no longer exists.
+     *
+     * The library is armed here and the target app is not, because the target is not known yet. Until
+     * `target()` names one the dylib loads into every process in the simulator and hooks none of them,
+     * which is its designed default.
+     */
+    arm(udid: string): Promise<void>;
+    private armLocked;
+    /**
+     * Name the app the hooks may touch.
+     *
+     * **Must be called before the app is launched.** dyld reads the environment when a process starts,
+     * so naming the target afterwards arms the *next* launch and leaves the running one unhooked —
+     * reporting `available: true` for an app that would never see a path update.
+     *
+     * **The previous app's verdict goes with it.** A verdict is one process's report that its own hooks
+     * took, and that process has exited by the time a second app is launched. Leaving the file behind
+     * answered for the new app on the old one's evidence: `available: true` before the new process had
+     * written anything, and — if its hooks fail — for as long as it runs. The gap where `state()`
+     * answers `awaiting-app` for a launch already in flight is the correct reading of that moment;
+     * inheriting a stale `ok` is not.
+     */
+    target(udid: string, bundleId: string): Promise<void>;
+    /**
+     * A process started, so a verdict is now owed — `markLaunched` opens the window `state()` measures.
+     *
+     * **Called after the launch, not before it, and that is a correction.** The mark was first set at
+     * the top of `target()`, which put `simctl spawn … launchctl setenv`, `simctl launch` and the app's
+     * whole dyld load *inside* the budget — none of it measured — and left the mark standing when the
+     * launch failed outright, so a launch that never happened reported the hooks as broken ten seconds
+     * later.
+     *
+     * **Only for a pid that is new.** `simctl launch` is issued without `--terminate-running-process`,
+     * so launching a bundle that is already running returns the existing pid and starts nothing. The
+     * verdict is written from a dyld constructor — once per process — so nothing will rewrite the file
+     * `target()` just deleted, and starting a deadline there would report a permanently dead control
+     * over an app whose hooks are live and watching. That case stays what it was before this change,
+     * which is wrong but harmless; #692 has the decision it needs.
+     */
+    markLaunched(udid: string, pid: number | null): void;
+    /**
+     * **Layer 1 leads in both directions, and the order is measured rather than chosen.**
+     *
+     * Going offline, the dylib cuts the app's open sockets the moment the flag file appears. If the
+     * filter were not already dropping new flows at that instant, the app would simply reconnect —
+     * reproduced exactly that way while stepping the layers separately, and the reconnected socket then
+     * survived the rest of the session.
+     *
+     * Coming back, the filter has to stop dropping before the app is told the path is satisfied, or the
+     * first thing it does with the good news is fail.
+     *
+     * The status bar goes last either way: it reports, so it should not claim a state before the state
+     * is true.
+     */
+    setOffline(udid: string, offline: boolean): Promise<NetworkStatePayload>;
+    /** The body of `setOffline`, running with the queue held. Calls `runFilterHost` directly: going
+     *  through `serialize` again from in here would wait on a slot this call already owns. */
+    private setOfflineLocked;
+    /**
+     * Write the rule and **ask the provider whether it is holding it.**
+     *
+     * The write's exit code cannot answer that. The container app exits when the framework accepts the
+     * save — 27ms for the whole run — and the running provider is handed the configuration afterwards
+     * with nothing coming back. Measured propagation is under 55ms and a probe measured the ask itself
+     * at 0.26–0.74ms, which is what makes asking cheaper than the six-second wait an earlier draft
+     * proposed in place of it.
+     *
+     * **The predicate is per-device membership, not set equality.** The filter is host-wide and this
+     * agent is not guaranteed to be its only writer; comparing whole sets would report every device as
+     * unenforced the moment somebody else's device appeared in the rule.
+     *
+     * **`wanted` is the value the caller asked for, and it is a parameter for that reason.** Reading it
+     * back off `this.offline` here compares the provider's answer against whatever the set says *now*,
+     * which is not necessarily what this call wrote — so a second toggle landing in between made a
+     * confirmation agree with a rule its own request had not asked for, and the success path then
+     * applied layers 2 and 3 for the wrong direction.
+     *
+     * A mismatch is logged **with what was actually read**, and with the channel it was read from.
+     * Two agents writing the same rule cannot be told apart afterwards from a log that only records
+     * what each one expected — each is internally consistent and one of them is stale.
+     */
+    private applyAndConfirm;
+    /**
+     * What the filter is enforcing — **asked first, and read from the file when the asking is gone.**
+     *
+     * `--confirm` is the fast and precise channel: 0.26–0.74ms, and it answers from the process the
+     * kernel is actually consulting. It stays the primary for exactly that reason, so the healthy Mac
+     * this class runs on most of the time is untouched by any of this.
+     *
+     * **But it disappears after every system-extension replace, and stays gone.** The retired extension
+     * sits `[terminated waiting to uninstall on reboot]` still owning the mach name, so the new
+     * provider's `NSXPCListener.resume()` fails with `Operation not permitted` — silently, because
+     * `resume()` returns void. `--confirm` then answers `no listener` in 9ms while the filter is
+     * genuinely enforcing and publishing a fresh state file. Measured 2026-09-03; the provider survives
+     * `--off`/`--install` on the same pid, so the listener is never re-vended and the loss lasts as long
+     * as the provider does.
+     *
+     * Taking that as "not confirmed" is what put `filter-unavailable` in front of a tester whose filter
+     * was working, on every Mac that had upgraded. The CLI reached the same conclusion earlier and for a
+     * different reason (`net-filter.ts`: a stale binary turns a flag it does not know into a rule
+     * write); this is the agent following it.
+     *
+     * `undefined` for every way of not finding out — the remedy is the same whether the filter is
+     * absent, disabled, or restarting.
+     */
+    private confirmEnforcement;
+    /** The XPC channel. Its own failures are all the same answer, so none of them are distinguished. */
+    private askProvider;
+    /**
+     * The file channel, polled until it answers or the deadline passes.
+     *
+     * **Three outcomes, and the middle one is the reason this is a loop rather than a read.** This runs
+     * immediately after a rule write, so the ordinary state for up to a pulse is a file that is fresh,
+     * correct, and about the *previous* rule — `checkLivenessLocked` says the same thing about the same
+     * window, and reading it as a disagreement would fire on every toggle.
+     *
+     * - The rule matches what was asked for: answered, whenever it was published.
+     * - It does not match and was published *after* the baseline: the provider has spoken and it
+     *   disagrees. That is a real mismatch and is returned so the caller can log it.
+     * - It does not match and was published at or before the baseline: it has not published since the
+     *   write. Wait.
+     *
+     * A stale file is never any of the three: a provider that died left it there, so it is skipped
+     * rather than believed, and `Heartbeat.remove()` means absence is what a *stopped* filter leaves.
+     */
+    private readConfirmation;
+    /** Layers 2 and 3, taken down together. Layer 3 is swallowed for the reason `forget` gives: it only
+     *  reports, and failing it would abandon the cleanup that matters. */
+    private takeDownLayers;
+    /**
+     * What the device is doing and whether tapflow can still steer it.
+     *
+     * `offline` describes the **device**, not the last request: a simulator taken offline and then left
+     * unsteerable is still offline, and saying otherwise would draw "online" over an app that can reach
+     * nothing.
+     */
+    state(udid: string): NetworkStatePayload;
+    /** Called when a device goes away, so a shutdown simulator does not keep a rule alive that names
+     *  it — the filter would carry the udid for the rest of the host's uptime. */
+    forget(udid: string): Promise<void>;
+    private forgetLocked;
+    /**
+     * Point the report somewhere after construction.
+     *
+     * **The constructor option alone left this untestable, which a review found by mutating the wiring
+     * away and watching the whole suite stay green.** `IOSAgent` builds its own `SimulatorNetwork` only
+     * when one was not injected, and every test injects one — so the handler was attached on exactly the
+     * path no test takes. The one channel that tells a tester their finished check was invalidated had
+     * no coverage at all, while the refusal path beside it had five tests.
+     */
+    setEnforcementLostHandler(fn: (udid: string) => void): void;
+    /**
+     * Stop watching. **Nothing else clears the interval**, so an agent that shuts down while a device
+     * is offline would otherwise keep a timer alive for the life of the process — which is what
+     * happened, because for a while this had no caller outside the tests at all. `IOSAgent.disconnect`
+     * owns it, beside the resources timer and the tree reader it already stops.
+     */
+    dispose(): void;
+    /**
+     * Undo `dispose`, because an agent that disconnected can connect again on the same instance.
+     *
+     * **A one-way disposed flag is a bug with the shape of the one it fixes**, and this codebase has
+     * already shipped it once: the provider's `Heartbeat.stopped` was set by a stop and cleared by
+     * nothing, so the first `stopFilter` in a process killed the state file for good while the filter
+     * went on filtering. Here it would be quieter and worse — `connect()` is public and reuses the
+     * network, so a reconnect after a disconnect would leave the watcher off, and the one report that
+     * tells a tester their check was invalidated would simply never come.
+     */
+    resume(): void;
+    /**
+     * Watch only while something is offline, because that is the only time there is anything to lose.
+     *
+     * The interval is `unref`'d: this must not be the reason a process stays alive.
+     */
+    private updateLiveness;
+    /**
+     * Notice that a device stopped being enforced, and say so.
+     *
+     * **Why this exists at all, given the confirmation on the write.** The confirmation answers the
+     * moment of the request; enforcement can stop at any point afterwards, and when it does the tester
+     * is looking at a control that still says offline. Measured on the reference Mac: killing the
+     * provider leaves the kernel passing that simulator's traffic for about 5.8 seconds before launchd
+     * has it back, and 23 to 27 requests got through each time. The tester's sign-off covers requests
+     * that succeeded.
+     *
+     * **The threshold comes out of the file.** Three pulses, at whatever rate the provider says it is
+     * pulsing — 1s while it is enforcing, so about three seconds. Hard-coding fifteen (three of the old
+     * five-second pulses) is what made the outage above arithmetically invisible: the gap closes before
+     * the threshold expires and nothing is ever reported.
+     *
+     * **A timestamp in the future is not freshness, it is a file that cannot be trusted.** Clocks move
+     * backwards — NTP corrections, a sleeping Mac — and treating `at > now` as "very fresh" would make
+     * a stale file look perfect for as long as the skew lasted.
+     */
+    private checkLiveness;
+    /**
+     * **Three questions per device, and each one is a different piece of evidence.** A single "is the
+     * file stale" test read against the whole set could not answer them, and the gap it left is
+     * measured: the provider publishes its pulse rate *as of the rule it held when it wrote*, so the
+     * last write before a device went offline says `pulseSeconds: 5`. A provider dying in the second
+     * after a toggle therefore leaves a file that is not stale by its own declared rate for fifteen
+     * seconds, and does not name the device either — both predicates false, nothing reported, and the
+     * kernel passing that simulator's traffic for the whole of it.
+     */
+    private checkLivenessLocked;
+    /** The first candidate that parses wins. A file that is present but unreadable is not evidence of
+     *  anything, so it is treated as absent rather than as a reason to stop looking. */
+    private readFilterState;
+    /**
+     * **Serialised, and bounded in time.**
+     *
+     * The host takes the whole offline set on each run and the last writer wins, so two of these in
+     * flight at once decide the rule by which subprocess happens to finish last rather than by which
+     * request came last. Two devices toggled in the same second is enough — and the set each one reads
+     * is correct, which is what makes the wrong outcome hard to see afterwards: both runs are internally
+     * consistent and one of them is stale.
+     *
+     * **What is serialised is the whole operation, and an earlier version serialised only the host
+     * run.** That version released the queue the moment the rule was written, so the confirmation that
+     * follows ran outside it — and a review found two ways that breaks. A liveness tick landing between
+     * a device joining the offline set and its confirmation declared that device's enforcement lost,
+     * rewrote the rule without it, took layers 2 and 3 down, and told every session; the confirmation
+     * then came back, compared against a set the tick had already edited, agreed with itself, and put
+     * layers 2 and 3 **back on** over a kernel rule that no longer named the device. Two toggles of the
+     * same device overlapping produced the mirror image: a fully healthy-looking offline control with
+     * layer 2 taken down under it. Both end in the state this class exists to prevent — the app told it
+     * is offline while its requests succeed — so the boundary has to contain the confirmation, and
+     * every reader and writer of `offline` has to be inside it.
+     *
+     * The timeout covers a host that never returns. It waits on `OSSystemExtensionRequest`, and one of
+     * its outcomes is a System Settings dialog nobody is standing in front of; the binary now exits
+     * itself on that path, but a timeout here is what keeps a wedge from taking the queue with it —
+     * everything after it is waiting on this chain.
+     */
+    private serialize;
+    /**
+     * The container app writes the rule and exits.
+     *
+     * **Its exit is not the confirmation.** Zero means the container app launched and the framework
+     * accepted the save — the whole run is 27ms, measured — and the running provider is handed the new
+     * configuration afterwards, with nothing coming back to say it has it. So this answers "nothing
+     * refused"; whether the device is actually offline is answered by `state()`, from evidence the
+     * dylib wrote inside the simulator.
+     */
+    /**
+     * **Names the devices it is changing, and nothing else.**
+     *
+     * This used to write `[...this.offline]` — the whole set — and the host replaced the rule with it.
+     * The rule is host-wide, so that made every run an assertion about devices this agent had never
+     * heard of: a second agent starting knows of no offline device, and `arm()` runs on every device
+     * boot, so **starting one put every device the other had taken offline back online**, silently,
+     * while its tester watched an offline control over working traffic.
+     *
+     * A delta cannot say anything about a device it does not name. The cleanup the whole-set write used
+     * to provide is not lost, only made precise: `armLocked` names the udid that just booted in
+     * `remove`, and a rule left behind by a dead process is cleared the next time that device comes up
+     * rather than by wiping the host's.
+     */
+    private runFilterHost;
+    private conditionPath;
+    private setCondition;
+    /**
+     * `missing`, `failed` and `unreadable` are three different answers and a tester needs all of them.
+     *
+     * Missing is not by itself an answer — it is the same file being absent whether the injection was
+     * never delivered or is simply waiting for its first app, which is why `state` reads it against
+     * `armed` rather than reporting it directly. Failed means the dylib ran and proved by trying that
+     * its hooks did not take, which no amount of relaunching will change.
+     *
+     * Unreadable is neither, and folding it into `failed` was this reader claiming evidence it does not
+     * have: a file this reader cannot parse says nothing about whether the hooks took. **The library
+     * now writes it with `rename` and no longer produces torn ones (#653)**, which removes the cause
+     * that was reachable on a healthy session — not the member. A simulator still running an app that
+     * was launched by an older dylib writes the old way, and a file whose shape this reader does not
+     * recognise is unreadable however it got there. Unlike the other two it is **not** resolved against
+     * `armed` — see `state` for why that would be worse than the problem.
+     */
+    private verdictPath;
+    private readVerdict;
+}
+export {};
+//# sourceMappingURL=SimulatorNetwork.d.ts.map

package/dist/SimulatorNetwork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimulatorNetwork.d.ts","sourceRoot":"","sources":["../src/SimulatorNetwork.ts"],"names":[],"mappings":"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"}