@wenathlan/devthink 2.0.12 → 2.0.14

package/dist/commands.d.ts

@@ -0,0 +1,310 @@
+/** The commands module of the 1.1.90 consolidation: every correlated variation of the background command executors for tabs, files, clipboard, downloads and navigation interned in this one file, so the module family carries one surface without duplicate variations. */
+import type { artifactinventoryentry, capturename, cleanuprule, clipentry, closedtabrecord, deeplinkpattern, downloadrecord, downloadstate, linkbatch, mimefilter, navpause, navtrailentry, netlogrecord, planprogress, preconnecttarget, prefetchplan, quarantineentry, ratelimitwindow, safetyverdict, scanverdict, tabgrouprecord, tablayout, tabquery, tabwatchevent, toolstep, urlvisit } from "./types.js";
+/**
+ * Tabs and windows command logics for reviewed steps.
+ * Every correlated rule for tab queries, clone detection, group membership, layouts, snapshots, watchers, badges, discard candidates, switcher order, zoom steps and the task tab budget lives in this file.
+ */
+/** One serializable live tab shape resolved against the browser tab set. */
+export interface tabshape {
+    tabid: number;
+    url: string;
+    title: string;
+    index: number;
+    windowid: number;
+    active: boolean;
+    pinned: boolean;
+    audible: boolean;
+    muted: boolean;
+    discarded: boolean;
+}
+/** One serializable live window shape with bounds, state and profile kind. */
+export interface windowshape {
+    windowid: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    state: "normal" | "maximized" | "minimized" | "fullscreen";
+    incognito: boolean;
+    focused: boolean;
+}
+/** Reads the reviewed tabquery of a tabs and windows command step; null when the step reviews none. */
+export declare function parsetabquery(step: toolstep): tabquery | null;
+/** Matches one reviewed wildcard pattern against a url; `*` spans one path segment and `**` spans any part. The walk stays linear on adversarial patterns because a token table with one dynamic programming pass replaces the compiled regular expression a star storm would catastrophically backtrack. */
+export declare function tabpatternmatches(pattern: string, url: string): boolean;
+/** Resolves one reviewed tabquery against the live tab set: every matcher that exists must hold. */
+export declare function querymatches(query: tabquery, tabs: tabshape[]): tabshape[];
+/** Normalizes one url for clone comparison by dropping the fragment and trailing slashes. */
+export declare function normalizedtaburl(url: string): string;
+/** One clone warning: a normalized url shared by more than one open tab. */
+export interface clonewarning {
+    url: string;
+    tabids: number[];
+}
+/** Detects duplicate tabs by normalized url comparison and returns every url held by more than one tab. */
+export declare function clonetabs(tabs: tabshape[]): clonewarning[];
+/** Searches across open tabs by title and url, case insensitive, returning matches in live order. */
+export declare function searchtabmatches(tabs: tabshape[], text: string): tabshape[];
+/** Lists the tabs that are playing audio: audible or muted but still playing. */
+export declare function audiotabs(tabs: tabshape[]): tabshape[];
+/** Returns the inactive, unpinned and not yet discarded tabs a discardtab step may release. */
+export declare function discardcandidates(tabs: tabshape[]): tabshape[];
+/** Restores discarded tabs on demand without losing their urls; every discarded tab keeps its url for reload. */
+export declare function restorediscarded(tabs: tabshape[]): Array<{
+    tabid: number;
+    url: string;
+}>;
+/** Captures one tab layout with name, tabs, groups, positions and window bounds from the live browser state. */
+export declare function buildlayout(name: string, tabs: tabshape[], windows: windowshape[], groups: tabgrouprecord[], scratchwindowids: number[], at: number): tablayout;
+/** Plans the restore of one saved layout: only urls that are not already open come back, in layout order. */
+export declare function layoutrestoreplan(layout: tablayout, openurls: string[]): string[];
+/** Keeps tabgroup membership through moves: member ids survive, their order follows the live tab order and closed members drop out. */
+export declare function regroupaftermoves(groups: tabgrouprecord[], tabs: tabshape[], at: number): tabgrouprecord[];
+/** Renames one stored tab group while keeping its color choice, member tabs and collapse state. */
+export declare function renamegroup(groups: tabgrouprecord[], name: string, newname: string, at: number): tabgrouprecord[];
+/** Counts the task tabs that live inside one window so the close gate can demand review. */
+export declare function tasktabsinwindow(tabs: tabshape[], windowid: number, tasktabids: number[]): number;
+/** Selects the tabs a reviewed closepattern may close; the session tab itself is always refused protection. */
+export declare function closeselection(query: tabquery, tabs: tabshape[], sessiontabid: number): {
+    targets: tabshape[];
+    refused: tabshape[];
+};
+/** Applies one reviewed zoom step with no code ceiling; a step never crosses zero, so it keeps the current zoom instead. */
+export declare function zoomstep(current: number, direction: "in" | "out", step: number): number;
+/** Resolves the neighbor tab index a switchtab step activates, wrapping at both ends of the window. */
+export declare function switchtarget(tabs: tabshape[], direction: "next" | "previous", currentindex: number): number | undefined;
+/** Orders the quick switcher list by recency with filter keys; unseen tabs follow in live index order. */
+export declare function switcherlist(tabs: tabshape[], recency: Array<{
+    tabid: number;
+    at: number;
+}>, filter: string): tabshape[];
+/** Dispatches the tab events of one watchtab registration into the step result, honoring the reviewed event filters. */
+export declare function watchtabdispatch(events: tabwatchevent[], watchid: string, filters: string[]): tabwatchevent[];
+/** Computes the per task badge from the live progress state of the task. */
+export declare function badgefromprogress(completed: number, total: number): {
+    label: string;
+    done: boolean;
+};
+/** Grades the concurrent task tab budget: a user configured ceiling refuses, an absent ceiling never refuses. */
+export declare function tasktabgauge(used: number, ceiling: number | undefined): {
+    used: number;
+    ceiling: number | undefined;
+    over: boolean;
+};
+/** True when a window profile inherits the session origin grants; incognito windows stay separated. */
+export declare function windowprofilegrants(profile: "normal" | "incognito" | "scratch"): boolean;
+/** Assigns every task tab of the plan progress, used when tabmeta routing records a tab for the plan steps. */
+export declare function assigntasktabs(progress: planprogress | undefined, planid: string, tabids: number[], now: number): planprogress;
+/** Returns the task tabs tracked by one plan progress, used for window close review and badge refresh. */
+export declare function trackedtasktabs(progress: planprogress | undefined, planid: string): number[];
+/** True when the batch queue allows the transition between two download states. */
+export declare function transitionallowed(from: downloadstate, to: downloadstate): boolean;
+/** Applies one batch queue state transition with its path, bytes, checksum and browser download id evidence; impossible transitions leave the record untouched. */
+export declare function advancedownload(record: downloadrecord, state: downloadstate, at: number, evidence?: {
+    path?: string;
+    bytes?: number;
+    checksum?: string;
+    downloadid?: number;
+}): downloadrecord;
+/** True when the batch queue may start another download under the user configured concurrent choice; an absent window never blocks. */
+export declare function concurrentwindow(running: number, ceiling: number | undefined): boolean;
+/** Resolves a filename conflict with a sequence suffix while keeping the extension intact. */
+export declare function conflictfree(filename: string, taken: string[]): string;
+/** Derives the download filename of one reviewed url from the spec filename rule or the url basename. */
+export declare function downloadfilename(url: string, rule: string | undefined): string;
+/** Verifies one completed download against the reviewed size and checksum expectations. */
+export declare function verifybytes(record: downloadrecord, expected: {
+    bytes?: number;
+    checksum?: string;
+}): {
+    ok: boolean;
+    summary: string;
+    matches: {
+        state: boolean;
+        size: boolean;
+        checksum: boolean;
+    };
+};
+/** True when the mime type passes the reviewed filter: exclude wins, then include, then the default for unlisted mime types. */
+export declare function mimeallowed(filter: mimefilter, mime: string): boolean;
+/** Redacts every header value of a captured request so exported netlogs never leak them. */
+export declare function redactheaders(headers: Record<string, string>): Record<string, string>;
+/** Builds one netlog record correlated with its step through the request id. */
+export declare function netlogentry(input: {
+    url: string;
+    method: string;
+    status: number;
+    timing: number;
+    requestid: string;
+    stepid: string;
+    at: number;
+}): netlogrecord;
+/** Returns the netlog records of one step, oldest first, correlated through the request ids. */
+export declare function netlogforstep(records: netlogrecord[], stepid: string): netlogrecord[];
+/** Builds one clipboard entry from the payload hash and length; the payload text itself never persists. */
+export declare function clipentryof(kind: clipentry["kind"], payload: {
+    hash: string;
+    length: number;
+}, origin: string, stepid: string, at: number): clipentry;
+/** Hashes one clipboard payload so audits and memory carry the hash only. */
+export declare function cliphash(payload: string): string;
+/** Routes a quarantined path outside the downloads folder until release; traversal segments and backslashes never enter the routed path so the quarantine folder never opens onto another folder. */
+export declare function quarantinedpath(filename: string): string;
+/** Builds one quarantine entry outside the downloads folder with a pending scan verdict. */
+export declare function newquarantine(id: string, filename: string, reason: string, at: number): quarantineentry;
+/** Applies one scan verdict to a quarantined entry; hook failures stay pending instead of releasing. */
+export declare function scanresult(entry: quarantineentry, verdict: scanverdict, at: number): quarantineentry;
+/** Maps one scanning hook response to its verdict; absent or malformed responses stay pending as hook failures. */
+export declare function scanverdictof(response: unknown): scanverdict;
+/** Stamps the release ref of one quarantined entry after the policy gate approved it. */
+export declare function released(entry: quarantineentry, ref: string, at: number): quarantineentry;
+/** Builds one consistent capture filename from its task, step and sequence parts. */
+export declare function capturefilename(name: capturename, extension: string): string;
+/** Advances the capture naming counter of one step base and returns the stamped sequence. */
+export declare function advancecounter(counters: Record<string, number>, base: string): {
+    sequence: number;
+    counters: Record<string, number>;
+};
+/** Stamps consistent capture names for the steps of one task with per task counters. */
+export declare function capturenames(counters: Record<string, number>, task: string, steps: string[], extension: string): {
+    names: string[];
+    counters: Record<string, number>;
+};
+/** Collects the artifact references of open review cards so the cleanup sweeper keeps them. */
+export declare function referencedartifacts(plan: {
+    steps: Array<{
+        id: string;
+        kind: string;
+        value?: string;
+    }>;
+} | undefined, completed: string[]): string[];
+/** Plans one cleanup sweep by age and kind while keeping referenced artifacts and honoring the keep policies. */
+export declare function sweepplan(entries: artifactinventoryentry[], rules: cleanuprule[], now: number, keeprefs: string[]): {
+    remove: string[];
+    keep: string[];
+};
+/** Reads the step ids a namecaptures step should stamp from its options or the plan steps. */
+export declare function capturesteps(options: Record<string, unknown>, plan: {
+    steps: toolstep[];
+}): string[];
+/** Predicts the next urls of an approved plan: the navigation values of the steps are read in step order, the urlhistory of the run weighs every candidate by how often the run already visited it, and the predictions rank by the combined step order and history confidence so the reviewer reads exactly which pages the plan is about to need. */
+export declare function navintent(input: {
+    id: string;
+    steps: toolstep[];
+    visits?: urlvisit[];
+    now: number;
+}): prefetchplan;
+/** Warms the predicted next pages through speculative dns: the warming set keeps only the urls the session grants cover, a stored plan whose planid differs from the live plan drops every prediction it carried because stale predictions never warm a page the new plan no longer visits, and the module itself issues no request at all — the page world resolves the dns hints read only while no mutating request ever fires during the warming. */
+export declare function prefetchpage(input: {
+    id: string;
+    planid: string;
+    urls: string[];
+    grants: string[];
+    stored?: prefetchplan;
+    now: number;
+}): {
+    plan: prefetchplan;
+    allowed: string[];
+    refused: string[];
+    dropped: string[];
+};
+/** Opens the read only sockets of the expected origins ahead of the steps that need them: only the origins the session grants cover may preconnect, every target carries the time its connection is expected, and every socket stays read only and revocable because a preconnect warms the transport and never carries a request of its own. */
+export declare function preconnectorigin(input: {
+    origins: string[];
+    grants: string[];
+    now: number;
+}): {
+    targets: preconnecttarget[];
+    refused: string[];
+};
+/** Builds one deep link url of a common web app from its route pattern and the reviewed parameters: the app name resolves into its deeplinkpattern, the first pattern whose named parameters the reviewed step supplies wins, a missing parameter refuses loudly instead of building a half url, and every substituted value encodes so the route stays exactly what the pattern names. */
+export declare function deeplinkapp(input: {
+    app: string;
+    params: Record<string, string>;
+    patterns?: deeplinkpattern[];
+}): {
+    url: string;
+    pattern: deeplinkpattern;
+};
+/** Restores one recently closed tab from its closedtabrecord: the most recent record the user closed comes back first, an explicit url restores its own record, a record whose origin lost its grant refuses loudly instead of silently reopening, and a reopened record never reopens twice while the retention window keeps it for the audit trail. */
+export declare function reopentab(input: {
+    records: closedtabrecord[];
+    grants: string[];
+    url?: string;
+    now: number;
+}): closedtabrecord;
+/** Rebuilds the navigation trail of one run from its urlhistory for the audit: the visits of the run order by their time, consecutive duplicates fold so the trail reads as the path the run walked, and repeated restores of the same history return the same entries so a replayed trail never doubles itself; the fresh tab replay stays an on demand operation of the executor because the trail itself stays a read only record. */
+export declare function restoretrail(input: {
+    visits: urlvisit[];
+    runid?: string;
+}): navtrailentry[];
+/** Freezes navigation while a consent prompt is open: the pause carries its reason in plain language, a navigation that arrives while the freeze holds queues its url as the pending navigation of the record, and the queued navigation waits for the answer of the prompt instead of dropping silently. */
+export declare function pausenavconsent(input: {
+    reason?: string;
+    url?: string;
+    stepid?: string;
+    stored?: navpause;
+    now: number;
+}): navpause;
+/** Resumes the frozen navigation and hands the queued navigation back: the resume returns the pending url the pause held so the executor continues exactly where the consent prompt stopped it, and a resume without a stored pause changes nothing. */
+export declare function resumenavconsent(input: {
+    stored?: navpause;
+    now: number;
+}): {
+    resumed: boolean;
+    queued?: navpause;
+};
+/** Tracks the navigation count of one domain inside the sliding window: every navigation stamps its hit into the window, the hits older than the user configured window size age out as the window slides forward, a full window delays the navigation for the milliseconds the oldest hit needs to age out and never drops it silently, and an absent window size or ceiling leaves the counting manual because both stay user choices with no code default. */
+export declare function navratelimit(input: {
+    stored?: ratelimitwindow;
+    url: string;
+    now: number;
+    window?: number;
+    ceiling?: number;
+}): {
+    window: ratelimitwindow;
+    allowed: boolean;
+    waitms: number;
+    reason: string;
+};
+/** Reads one url from the clipboard text of an explicit user action: the text must parse into an HTTPS url, the origin of the url must sit inside the session grants before anything opens, and a clipboard that holds anything else refuses loudly instead of guessing. */
+export declare function openclipboardurl(input: {
+    text: string;
+    grants: string[];
+}): {
+    url: string;
+};
+/** Verifies one url for safety: the scheme must stay HTTPS, the url carries no embedded credentials, the host is no private network or raw address, and a host that imitates a granted origin — the granted host embedded in a longer host, joined through hyphens or squatting through punycode — refuses with the reason the ui shows before anything opens. */
+export declare function checksafeurl(input: {
+    url: string;
+    granted?: string[];
+    now: number;
+}): safetyverdict;
+/** Opens one curated list of links with one tab per link: every url verifies through checksafeurl before anything opens and one unsafe url refuses the whole batch as a curated record that waits for review, the batch size never passes the user configured ceiling because the bound stays a user choice only, and the per domain sliding windows account every open across the whole batch while a full window moves its url into the waits the caller delays on and never drops silently. */
+export declare function batchopenlinks(input: {
+    id: string;
+    urls: string[];
+    grants: string[];
+    windows: ratelimitwindow[];
+    now: number;
+    window?: number;
+    sizelimit?: number;
+}): {
+    batch: linkbatch;
+    open: Array<{
+        url: string;
+        verdict: safetyverdict;
+    }>;
+    refused: Array<{
+        url: string;
+        reasons: string[];
+    }>;
+    ordered: string[];
+    waits: Array<{
+        url: string;
+        waitms: number;
+    }>;
+    windows: ratelimitwindow[];
+    reason: string;
+};
+//# sourceMappingURL=commands.d.ts.map

package/dist/compatibility.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared TypeScript compatibility primitives derived from the converted docs logic.
+ * These helpers intentionally exclude browser automation, CAPTCHA handling and credential capture.
+ */
+/** Identifies the public wire formats normalized by DevThink. */
+export type ProviderProtocol = "openai" | "anthropic" | "google";
+/** Returns bounded exponential retry timing for a transient request failure. */
+export declare function retryDelay(attempt: number, baseMs?: number, maximumMs?: number): number;
+/** Removes a bearer value from an error message before it reaches a terminal or browser surface. */
+export declare function redactProviderError(message: string): string;
+/** Accepts a browser origin only when it exactly matches an explicit local configuration entry. */
+export declare function isAllowedOrigin(origin: string | undefined, allowedOrigins: readonly string[] | undefined): boolean;
+/** Verifies that a user-operated synchronization endpoint uses HTTPS. */
+export declare function isSecureRemoteEndpoint(value: string | undefined): boolean;
+/** Normalizes a static-site base path for repository-scoped GitHub Pages deployments. */
+export declare function normalizeBasePath(value: string | undefined, repository: string): string;
+//# sourceMappingURL=compatibility.d.ts.map