@ai-ecoverse/slicc 1.67.11 → 1.67.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/README.md +1 -1
  2. package/package.json +7 -7
package/README.md CHANGED
@@ -1000,7 +1000,7 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
1000
1000
  - **Session-wide settings are refused on every relay session, including ordinary pages.** `Network.setExtraHTTPHeaders`, `Network.setUserAgentOverride`, `Emulation.setUserAgentOverride`, `Emulation.setLocaleOverride`, `Emulation.setTimezoneOverride`, `Network.setCacheDisabled`, `Network.emulateNetworkConditions`, `Network.emulateNetworkConditionsByRule`, `Network.overrideNetworkState`, `Network.setBlockedURLs`, and every method matching `/^Emulation\.(set|add|update|remove)[A-Z]/` other than the four display admits above receive `slicc: refused: settings for a whole session (headers, user agent, locale, time zone, cache, network conditions, blocked URLs, emulation) could reach seven’s pages or the vault, so the guard doesn’t allow them; change a request through Fetch instead`. These calls are never forwarded or answered with fake success.
1001
1001
  - **Browser-side inheriting navigation is refused.** `Page.navigate` to any `about:` URL, including `about:blank` and `about:srcdoc`, receives `slicc: refused: a browser-side navigation to about: gives the page the origin of whatever drives the browser, so the guard doesn’t send it; open a new tab on about:blank instead`. An absent or unparseable navigation URL receives the same error. Creating a fresh tab with `Target.createTarget` on `about:blank` remains available.
1002
1002
 
1003
- - **Listing.** The origin-only rule covers page and tab targets only. `Target.getTargets`, `Target.getTargetInfo`, `Target.targetCreated` and `Target.targetInfoChanged` still show protected page and tab targets, so seven knows its tab exists, but their `url` and `title` are only the origin (`https://seven.sliccy.ai`, `chrome://settings`, `chrome-extension://<id>`, or `about:blank`), or only the scheme for a URL without a host (`file:`). An iframe target is protected when its own URL is protected or when its `parentFrame`, or any ancestor frame or target, is a protected target or a protected recorded frame (from `Target.*` `parentFrameId`/`parentId` and `Page.frameAttached`/`frameNavigated`); once protected, that decision sticks for the iframe's life. A protected iframe is never listed, never answered by `Target.getTargetInfo`, never attachable, and commands that name it are refused. An auto-attached iframe whose parent target is not known yet, or whose parent target's navigation is still unresolved, is held the same way an unresolved worker is: left out of listings, not attached, and if the hold times out while that parent target is still unknown it is resumed and detached without being shown. Separately, an auto-attached iframe that still has no URL of its own stays held until that URL (or a protected decision from ancestry) is known; ancestry settling alone must not deliver a URL-less iframe. `Target.attachToTarget` and `Target.getTargetInfo` sent on the browser session for an iframe while one of those holds is on wait for the hold instead of being answered at once, so a client that looks an iframe up as soon as `Target.targetCreated` announces it gets the decision rather than a refusal the guard hasn't made yet. They are answered, in arrival order, the moment the hold settles: through the normal rules when the iframe was delivered or turned protected (a protected iframe is refused, and `Target.getTargetInfo` says `No target with given id found`), and refused with `slicc: refused: unresolved ancestry` (or `No target with given id found`) when the hold ends any other way: it times out, its page session is detached or stops auto-attaching, Chrome detaches it, the iframe is destroyed, or the stream closes. They never wait past the hold's own deadline (the hold timeout from the first auto-attach of that iframe), a later attach of the same iframe doesn't extend it, and a call after that deadline is refused at once. At most 8 calls wait per iframe, 32 per page and 256 per stream; one more is refused at once with `slicc: refused: unresolved ancestry`. Other commands don't queue behind them. `Target.attachToTarget` and `Target.getTargetInfo` that name an iframe while either hold is on wait until it settles (the iframe is delivered, hidden, cut with its page session, destroyed, or its hold times out) and then get the answer they would get at that moment, so a client that looks up an iframe as soon as `Target.targetCreated` announces it is neither told it doesn't exist nor refused for a decision the guard hasn't made yet. A missing `parentFrameId`/`parentId` is not treated as ordinary: the guard still walks recorded frame ancestry (`Page.frameAttached` / `frameNavigated` / the frame tree), and while that ancestry is unknown the iframe stays held or hidden from `Target.getTargets`, `Target.getTargetInfo`, target events and attach-by-id. An ordinary iframe whose ancestry is unknown, pending, cyclic or deeper than the ancestor limit is hidden and refused with `slicc: refused: unresolved ancestry`. Extension-frame targets (`chrome-extension://` iframes) keep the existing extension-frame rule from main: not auto-attached, answered by `Target.getTargetInfo` in redacted `about:blank` form, and gated for screenshot/Input; parent-protection only adds further hide (listings/`getTargetInfo` missing) when a parent or ancestor is protected, and never delivers or un-hides what that rule already keeps out of auto-attach. After an iframe was shown, protection still follows it: an explicit attach from the browser session is cut or refused as soon as its owner page or any ancestor turns protected or held, and on every command the guard checks both the target parent chain and the attaching session (if they disagree, the iframe is treated as protected). `parentFrameId` names a frame inside that parent, not a target; the guard resolves ancestry from the attach parent target and from recorded frames, and does not hold merely because `parentFrameId` is not a target id. A worker (`worker`, `shared_worker` or `service_worker`) is protected when its own URL is protected or a protected frame or target created it, including a `blob:` or `data:` URL and a worker auto-attached on an out-of-process iframe's session. Every `data:` worker created by a sub-frame stays hidden: for a `data:` worker every creator field must be a known ordinary target, and any sub-frame creator field (`openerFrame` or `parentFrame`) keeps it hidden, so only a `data:` worker whose sole creator is an ordinary target the guard already knows is ordinary is listed. Once a worker is classified protected, that decision sticks for the worker's life even if its creator later navigates away or drops out of the frame map. That protected worker is not auto-attached and not listed at all: `Target.getTargets` leaves it out, its `targetCreated`, `targetInfoChanged` and `targetDestroyed` are dropped, and `Target.getTargetInfo` answers `No target with given id found`, the same answer an unknown target gets. An auto-attached worker whose URL and creator frame are not known yet is held the same way a page without a URL is: the page does not get `attachedToTarget`, the worker stays paused when `waitForDebuggerOnStart` was requested (so it does not run ahead of the decision), and it is left out of listings until its URL or that frame is known. Without `waitForDebuggerOnStart`, a held ordinary worker can run and emit early events (console, network) that the page never sees, because those events arrive while the session is still held; slicc-cdp accepts that for ordinary workers. Learning the creator frame decides the worker then, even when the worker was recorded first. If the creator is still unknown when the hold times out, the worker is resumed and detached without being shown. Detaching that page session, or turning auto-attach off on it (`autoAttach` false, `waitForDebuggerOnStart` false, `flatten` true, and no filter), does the same at once. `Target.attachToTarget` for a worker that is protected or still unresolved is refused. An ordinary worker the page learned outside listings (for example a `targetId` from `ServiceWorker.workerVersionUpdated`) may be attached by id even if it was never listed; `targetDestroyed` for a worker the page was never shown is still dropped until that attach or a listing shows it. A target whose URL slicc can't parse isn't listed at all, since it has no origin to show: `Target.getTargets` leaves it out, and its `targetCreated` and `targetInfoChanged` are dropped. A target of a `targetTypes` type (`browser_ui`) is never shown: `Target.getTargets` leaves it out, its `targetCreated`, `targetInfoChanged`, `targetDestroyed` and `targetCrashed` are dropped, and `Target.getTargetInfo` on its id is refused like any other command that names it. Service worker registrations and versions on a protected origin are left out of `ServiceWorker` events, and `Storage`, `DOMStorage` and `BackgroundService` events that name a protected origin are dropped.
1003
+ - **Listing.** The origin-only rule covers page and tab targets only. `Target.getTargets`, `Target.getTargetInfo`, `Target.targetCreated` and `Target.targetInfoChanged` still show protected page and tab targets, so seven knows its tab exists, but their `url` and `title` are only the origin (`https://seven.sliccy.ai`, `chrome://settings`, `chrome-extension://<id>`, or `about:blank`), or only the scheme for a URL without a host (`file:`). An iframe target is protected when its own URL is protected or when its `parentFrame`, or any ancestor frame or target, is a protected target or a protected recorded frame (from `Target.*` `parentFrameId`/`parentId` and `Page.frameAttached`/`frameNavigated`); once protected, that decision sticks for the iframe's life. A protected iframe is never listed, never answered by `Target.getTargetInfo`, never attachable, and commands that name it are refused. An auto-attached iframe whose parent target is not known yet, or whose parent target's navigation is still unresolved, is held the same way an unresolved worker is: left out of listings, not attached, and if the hold times out while that parent target is still unknown it is resumed and detached without being shown. Separately, an auto-attached iframe that still has no URL of its own stays held until that URL (or a protected decision from ancestry) is known; ancestry settling alone must not deliver a URL-less iframe. `Target.attachToTarget` and `Target.getTargetInfo` sent on the browser session for an iframe while one of those holds is on wait for the hold instead of being answered at once, so a client that looks an iframe up as soon as `Target.targetCreated` announces it gets the decision rather than a refusal the guard hasn't made yet. They are answered, in arrival order, the moment the hold settles: through the normal rules when the iframe was delivered or turned protected (a protected iframe is refused, and `Target.getTargetInfo` says `No target with given id found`), and refused with `slicc: refused: unresolved ancestry` (or `No target with given id found`) when the hold ends any other way: it times out, its page session is detached or stops auto-attaching, Chrome detaches it, the iframe is destroyed, or the stream closes. They never wait past the hold's own deadline (the hold timeout from the first auto-attach of that iframe), a later attach of the same iframe doesn't extend it, and a call after that deadline is refused at once. At most 8 calls wait per iframe, 32 per page and 256 per stream; one more is refused at once with `slicc: refused: unresolved ancestry`. Other commands don't queue behind them. `Target.attachToTarget` and `Target.getTargetInfo` that name an iframe while either hold is on wait until it settles (the iframe is delivered, hidden, cut with its page session, destroyed, or its hold times out) and then get the answer they would get at that moment, so a client that looks up an iframe as soon as `Target.targetCreated` announces it is neither told it doesn't exist nor refused for a decision the guard hasn't made yet. A missing `parentFrameId`/`parentId` is not treated as ordinary: the guard still walks recorded frame ancestry (`Page.frameAttached` / `frameNavigated` / the frame tree), and while that ancestry is unknown the iframe stays held or hidden from `Target.getTargets`, `Target.getTargetInfo`, target events and attach-by-id. An ordinary iframe whose ancestry is unknown, pending, cyclic or deeper than the ancestor limit is hidden and refused with `slicc: refused: unresolved ancestry`. Extension-frame targets (`chrome-extension://` iframes) keep the existing extension-frame rule from main: not auto-attached, answered by `Target.getTargetInfo` in redacted `about:blank` form, and gated for screenshot/Input; parent-protection only adds further hide (listings/`getTargetInfo` missing) when a parent or ancestor is protected, and never delivers or un-hides what that rule already keeps out of auto-attach. After an iframe was shown, protection still follows it: an explicit attach from the browser session is cut or refused as soon as its owner page or any ancestor turns protected or held, and on every command the guard checks both the target parent chain and the attaching session (if they disagree, the iframe is treated as protected). A dispute is raised only when the recorded frameParents chain does not reach the attaching owner after resolving a `tab` owner to the page under it (same `browserContextId`, or the same URL when the tab has no context id); a `browser` owner never raises a dispute by itself. Page and iframe owners still dispute when the chain misses them (the #739 rule). Unknown owner types keep the old fail-closed dispute. Page content cannot forge `tab` or `browser` attach parents: those target types are Chrome's, not script-created. `parentFrameId` names a frame inside that parent, not a target; the guard resolves ancestry from the attach parent target and from recorded frames, and does not hold merely because `parentFrameId` is not a target id. A worker (`worker`, `shared_worker` or `service_worker`) is protected when its own URL is protected or a protected frame or target created it, including a `blob:` or `data:` URL and a worker auto-attached on an out-of-process iframe's session. Every `data:` worker created by a sub-frame stays hidden: for a `data:` worker every creator field must be a known ordinary target, and any sub-frame creator field (`openerFrame` or `parentFrame`) keeps it hidden, so only a `data:` worker whose sole creator is an ordinary target the guard already knows is ordinary is listed. Once a worker is classified protected, that decision sticks for the worker's life even if its creator later navigates away or drops out of the frame map. That protected worker is not auto-attached and not listed at all: `Target.getTargets` leaves it out, its `targetCreated`, `targetInfoChanged` and `targetDestroyed` are dropped, and `Target.getTargetInfo` answers `No target with given id found`, the same answer an unknown target gets. An auto-attached worker whose URL and creator frame are not known yet is held the same way a page without a URL is: the page does not get `attachedToTarget`, the worker stays paused when `waitForDebuggerOnStart` was requested (so it does not run ahead of the decision), and it is left out of listings until its URL or that frame is known. Without `waitForDebuggerOnStart`, a held ordinary worker can run and emit early events (console, network) that the page never sees, because those events arrive while the session is still held; slicc-cdp accepts that for ordinary workers. Learning the creator frame decides the worker then, even when the worker was recorded first. If the creator is still unknown when the hold times out, the worker is resumed and detached without being shown. Detaching that page session, or turning auto-attach off on it (`autoAttach` false, `waitForDebuggerOnStart` false, `flatten` true, and no filter), does the same at once. `Target.attachToTarget` for a worker that is protected or still unresolved is refused. An ordinary worker the page learned outside listings (for example a `targetId` from `ServiceWorker.workerVersionUpdated`) may be attached by id even if it was never listed; `targetDestroyed` for a worker the page was never shown is still dropped until that attach or a listing shows it. A target whose URL slicc can't parse isn't listed at all, since it has no origin to show: `Target.getTargets` leaves it out, and its `targetCreated` and `targetInfoChanged` are dropped. A target of a `targetTypes` type (`browser_ui`) is never shown: `Target.getTargets` leaves it out, its `targetCreated`, `targetInfoChanged`, `targetDestroyed` and `targetCrashed` are dropped, and `Target.getTargetInfo` on its id is refused like any other command that names it. Service worker registrations and versions on a protected origin are left out of `ServiceWorker` events, and `Storage`, `DOMStorage` and `BackgroundService` events that name a protected origin are dropped.
1004
1004
  - **Protected URLs in what the page gets.** In every event and result the page gets, a URL field that holds a protected URL is cut to its origin, at any depth: every key ending in `url`, `urls`, `origin` or `origins` (any case, so `documentURL`, `unreachableUrl` and `securityOrigin` too), `referrer`, `location`, `href` and `src`, and every header value in `headers`, `requestHeaders` and `responseHeaders`. That covers `Page.frameRequestedNavigation`, `Page.frameNavigated`, `Network.requestWillBeSent`, `Page.windowOpen`, `Page.getFrameTree` and the rest. Every other string (header values such as `Link` and `Refresh`, `headersText` and `requestHeadersText`, cookie and storage values, DOM attributes) keeps its text, but each protected URL inside it (a `scheme://` run up to whitespace, a quote, `<` or `>`, a URL that doesn't parse included, a percent-encoded run decoded repeatedly to a fixed point through at most five layers, and an unschemed protected `host[:port]/path` run) is cut to its origin (or host for an unschemed run); if percent-decoding still changes a string after five layers, the whole string is blanked, and next to a protected URL field every field ending in `Fragment` (`urlFragment` of a request or frame) is blanked to `""`, while ordinary URLs keep theirs, so a redirect from an ordinary page to seven's `/auth/callback?code=…` shows the page only seven's origin, wherever it names that URL. Unprotected URLs stay intact. Everything inside a `value`, `preview`, `customPreview`, `arguments` or `returnValue` (evaluation results and their previews) is left alone.
1005
1005
  - **Limits.**
1006
1006
  - On Chromium, the filter relies on site isolation. A seven frame inside a page of another site is a target of its own (`iframe`), which the node protects. Frame reads, DOM, paint and input on its page ancestor are locked too, including compound frames whose protected child shares an ordinary iframe's renderer. An iframe's lock belongs to its parent root document: a different root loader stops a cached document's frames from locking the new page, and restoring that loader locks again before content commands are answered. Without generation evidence the page stays locked, unless `DOM.getFrameOwner` on the node's private page session explicitly says a directly parented iframe is absent from the current document. Missing replies, ambiguous parents and other errors keep the lock; root commits, restores and frame attachments invalidate negative ownership evidence. A same-site frame shares its parent's process and isn't a target. Every `sliccy.ai` host is protected, so this only matters for an extra origin, such as one port of `127.0.0.1` framed by a page on another.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ai-ecoverse/slicc",
3
- "version": "1.67.11",
3
+ "version": "1.67.12",
4
4
  "description": "SLICC's command line for seven: links a machine's network, compute and browsers to seven over WebRTC",
5
5
  "license": "Apache-2.0",
6
6
  "repository": {
@@ -18,12 +18,12 @@
18
18
  "node": ">=18"
19
19
  },
20
20
  "optionalDependencies": {
21
- "@ai-ecoverse/slicc-darwin-arm64": "1.67.11",
22
- "@ai-ecoverse/slicc-darwin-amd64": "1.67.11",
23
- "@ai-ecoverse/slicc-linux-arm64": "1.67.11",
24
- "@ai-ecoverse/slicc-linux-amd64": "1.67.11",
25
- "@ai-ecoverse/slicc-windows-arm64": "1.67.11",
26
- "@ai-ecoverse/slicc-windows-amd64": "1.67.11",
21
+ "@ai-ecoverse/slicc-darwin-arm64": "1.67.12",
22
+ "@ai-ecoverse/slicc-darwin-amd64": "1.67.12",
23
+ "@ai-ecoverse/slicc-linux-arm64": "1.67.12",
24
+ "@ai-ecoverse/slicc-linux-amd64": "1.67.12",
25
+ "@ai-ecoverse/slicc-windows-arm64": "1.67.12",
26
+ "@ai-ecoverse/slicc-windows-amd64": "1.67.12",
27
27
  "@ai-ecoverse/slicc-jerk": "^1.9.1"
28
28
  }
29
29
  }