@ai-ecoverse/slicc 1.68.5 → 1.69.0

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 -0
  2. package/package.json +7 -7
package/README.md CHANGED
@@ -925,6 +925,7 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
925
925
  - **Refused**, with `{"id":…,"sessionId"?:…,"error":{"code":-32000,"message":"slicc: refused: target is on seven's origin"}}`, never forwarded: `Target.createTarget`, `Page.navigate` and anything else whose `url` is protected (one that doesn't parse is refused with `slicc: refused: slicc can't parse this URL, so it could be a protected page`, see above); `Page.navigateToHistoryEntry` to an entry whose URL is protected (the node looks it up with `Page.getNavigationHistory`); `Target.attachToTarget`, `activateTarget`, `autoAttachRelated`, `Browser.getWindowForTarget` and any other command whose `targetId` or `frameId` is a protected target (except `Target.closeTarget` on a protected `page` or `tab` that this stream created, touched, or opened after the touch — a popup or tab whose `Target.targetCreated` saw an opener or openerFrame this stream had already touched (`navTargets`) or already marked stream-opened; that decision is made once at creation and never walks the opener chain at close time, so a vault or seven tab the user opened from a page before this stream attached to that page stays refused even after the attach; for example attaching and navigating or restoring onto a protected origin, including a sticky error page: that close is forwarded so seven can dismiss a leftover it itself produced, except a live seven-UI page (a catalog seven origin or a guard extra origin under `/os/`, other than `/os/callback.html`) or a vault page (`vault.sliccy.ai` and `vault-*` previews, every path), in any spelling the protect package already judges (view-source wrapping, a `blob:` minted by such an origin, userinfo, and an inheriting URL such as `about:blank` whose security origin or kept latch is such a page), and except while a navigation's in-flight destination is unknown or such a URL, or while the committed document is still such a URL (unknown in-flight destination refuses close even when the committed document is ordinary; before that refusal the close path fetches a fresh frame tree, and a snapshot that shows Chrome's error page for a protected URL with no later navigation request is treated as a recorded error page and stays closable); closing a protected tab this stream never touched or opened, a live vault or seven-UI tab even when this stream touched it, the link's own seven page when slicc itself set up the link over CDP in that browser (the tab `slicc attach` / default mode signalled through — `attach --signal stdio`, loopback, and tray/`follow --cdp` have no host page the guard tracks, even when `--cdp` points at a browser that hosts seven), the browser target, workers and every other non-page/tab type stay refused); and every command on a session whose target is protected, or became so. `Target.getTargetInfo` and `Target.detachFromTarget` stay allowed, except `Target.getTargetInfo` on a hidden target (see *Listing*). An ordinary iframe whose ancestry is unknown, pending, cyclic or deeper than the ancestor limit is hidden and refused with `slicc: refused: unresolved ancestry`.
926
926
  - **Origins and storage.** A command whose `origin`, `securityOrigin`, `ownerOrigin`, `issuerOrigin`, `topLevelOrigin`, `topLevelSite`, `embeddedOrigin`, `requestingOrigin`, `scopeURL` or `manifestId` is protected, or whose `storageKey` or `cacheId` names seven's storage, is refused the same way. This covers `Storage.*`, `IndexedDB.*`, `CacheStorage.*`, `DOMStorage.*`, `FileSystem.*`, `ServiceWorker.*`, `PWA.*`, `Browser.setPermission` and `Browser.grantPermissions`. Free-form values (`expression`, `arguments`, `value`, `headers`, `postData` and the like) aren't searched.
927
927
  - **Cookies.** `Network.getCookies`, `Network.getAllCookies`, `Storage.getCookies` and `Page.getCookies` answer without the cookies whose domain is protected (`sliccy.ai` and every subdomain, and each extra origin's host and its parents: cookies ignore ports), and, when the browser supplies partition data, without partitioned cookies whose `partitionKey.topLevelSite` is such a site (see "Where those promises stop" below). `Network.setCookie`, `setCookies`, `deleteCookies`, `Storage.setCookies` and `Page.deleteCookie` for such a domain, a URL on such a host, or a partition key under such a site, are refused with `slicc: refused: cookies on seven's origin`. So are `Network.clearBrowserCookies` and `Storage.clearCookies`, except in a browser context this stream created with `Target.createBrowserContext`.
928
+ - **Sign-in origins.** The identity-provider origins seven signs in with are protected for export only. The CLI keeps a hardcoded floor of `https://ims-na1.adobelogin.com` and `https://ims-na1-stg1.adobelogin.com` (same floor as bios / slicc-cdp), unioned with slicc-browsers' `catalog.credentialOrigins.origins` so the catalog can only add hosts — a later catalog edit that drops a host cannot reopen its export. An empty or unreadable catalog list still yields the floor. The refusal text comes from `catalog.credentialOrigins.refusal` (today `slicc: refused: this origin holds sign-in credentials`); if that text is empty or missing the `slicc: refused: ` prefix, the fallback is `slicc: refused: this origin holds sign-in credentials`. The guard withholds their cookies and web storage and refuses writes to them, on every route, failing closed. A URL, `origin` or `securityOrigin` counts when its host is one of those hosts (`http` or `https`, any port; a subdomain of one does not count), a cookie `domain` when it covers one of them (`.adobelogin.com` does, `.adobe.com` does not), a `partitionKey.topLevelSite` when its host covers one, and a storage key when its origin counts or its top-level site (after `^0`) covers one. Cookie answers leave those cookies out; cookie writes and deletes naming them are refused with that refusal text, and `clearBrowserCookies` and `Storage.clearCookies` keep the rule above. `Network.*` and `Fetch.*` events lose `Cookie` and `Set-Cookie` (header maps, raw header texts and cookie lists) for requests and WebSockets to those origins, for a `Set-Cookie` whose `Domain` covers one, and `associatedCookies`, `blockedCookies` and `exemptedCookies` lose those cookies on any request, judged by an entry's `cookie` and by every `Domain` attribute of its `cookieLine` (any covering one counts; an entry whose line has a control character or a `Domain` that isn't an ASCII host is dropped too). `Storage.*`, `IndexedDB.*`, `CacheStorage.*`, `DOMStorage.*` and `FileSystem.*` commands naming such an origin, storage key or `cacheId` (`getUsageAndQuota`, `getSharedStorageEntries`, `getSharedStorageMetadata` and `getInterestGroupDetails` included) are refused with the same text; `Storage.getTrustTokens` and `getAffectedUrlsForThirdPartyCookieMetadata` answer without them, `getStorageKeyForFrame` is answered, and storage events naming them are dropped. `Audits.issueAdded` is dropped when its `rawCookieLine`, `cookieUrl`, cookie `domain`, request or any URL, origin or site in it names a protected or sign-in origin, or when a cookie issue names none of cookie `domain`, `cookieUrl` and request URL. Refusals and debug lines name no origin, URL or value. `Fetch.fulfillRequest` and `Fetch.continueResponse` that plant a `Set-Cookie` or `Set-Cookie2` (including via `binaryResponseHeaders`; a non-string value, a NUL part with a control other than tab, a part that starts with a space or tab (an obsolete fold), a first part that is neither an HTTP status line nor a header, or a later part without a colon, fails closed) are refused with the same text when the paused request's URL is a sign-in origin (any such header, host-only included) or when a `Domain` attribute covers a sign-in host (including on a sub-host of an entry); `Fetch.continueRequest` with a `Cookie` request header is request-side injection, not a jar write, and is not refused by this rule. Pages on those origins stay fully drivable (listing, attach, navigate, `Runtime.*`, `DOM.*`, `Input.*`, `Page.*`), because stock clients sign in by driving the IdP page with script. So in-page script (`Runtime.evaluate`, Playwright locators) can still read their non-`HttpOnly` cookies, `localStorage`, `sessionStorage` and IndexedDB; response bodies, OAuth codes in URLs and `Authorization` headers on a drivable sign-in page are not withheld. Not covered (their pages drivable, their cookies and storage exportable): Adobe's login UI hosts such as `auth.services.adobe.com` and `adobeid-na1.services.adobe.com`, because a `Domain=.adobe.com` cookie would then cover an entry and every `.adobe.com` cookie would be withheld, and federated corporate SSO, MFA and consent hosts, which can't be listed.
928
929
  - **Requests a page makes to seven.** For a request whose URL is protected, `Network.*` and `Fetch.*` events lose their `Cookie`, `Set-Cookie`, `Authorization` and `Proxy-Authorization` headers (in the header maps and as lines of the raw header texts, which otherwise stay, their URLs cut as everywhere) and their cookie lists, and `requestWillBeSentExtraInfo` drops seven's cookies from `associatedCookies` for any request. Chrome can send `requestWillBeSentExtraInfo` and `responseReceivedExtraInfo` before the event that names the request's URL, so the node holds them until the request is found to be protected, gets its response, finishes or fails (a WebSocket or WebTransport once it is created); one still held after 2 seconds is passed on stripped, as for a protected request. For a WebSocket, WebTransport or EventSource on a protected origin (`ws:` and `wss:` count as `http:` and `https:`), `webSocketWillSendHandshakeRequest`, `webSocketHandshakeResponseReceived`, `webSocketFrameError`, `eventSourceMessageReceived` and `dataReceived` are dropped. Reading such a request's body (`Network.getResponseBody`, `Fetch.getResponseBody`, `takeResponseBody…AsStream`, `Audits.getEncodedResponse` and the like) is refused. A request paused at the response stage whose response headers name a protected URL (an ordinary redirect into seven, say) counts as such a request too. `Fetch.continueRequest` and `Network.continueInterceptedRequest` with a `url` that the node has seen redirect into a protected origin on that target are refused with `slicc: refused: that URL redirects to seven's origin`. So is reading a stylesheet or script that came from a protected URL, directly or through a redirect: `Page.getResourceContent` and `Page.searchInResource` for its URL, and any command naming its `styleSheetId` or `scriptId`. CSS rules and styles from it reach the page with only their `styleSheetId` and `origin`. In a dedicated, shared or service worker, the node keeps its own guard session (Network only), and the worker's commands, `Runtime.runIfWaitingForDebugger` included, wait until that session's `Network.enable` answers, within the same bounds as a page's guard. A worker script other than the worker's own is readable only if that guard saw its whole redirect chain and none of it was protected; an import from before the guard attached, such as in a worker that was already running, is refused. In a page, a stylesheet or script loaded before the node attached to the tab has no redirect chain the node saw, so it stays readable even if it came through a redirect from a protected origin (a known residual). The node also checks the answer, because the page may ask before the node has seen the request. When `Network.getResponseBody`, `searchInResponseBody`, `streamResourceContent`, `getResponseBodyForInterception`, `takeResponseBodyForInterceptionAsStream`, `getRequestPostData`, `Fetch.getResponseBody`, `Fetch.takeResponseBodyAsStream` or `Audits.getEncodedResponse` answers, the node holds the answer until the request has a response (for `getRequestPostData`, until it is sent; for an intercepted request, until it is paused). If the request is protected by then, the answer is refused, and a stream it handed out is closed. If the node still hasn't seen the request after 2 seconds, the answer is refused with `slicc: refused: slicc hasn't seen this request, so it could be seven's`. `Network.replayXHR` is never forwarded: for a protected or unknown request it keeps the body-getter refusal; for a known ordinary request it is refused with `slicc: refused: Network.replayXHR follows redirects inside the browser, so it could send a request to seven's pages or the vault`. Chrome's native replay cannot classify each redirect before sending it. This does not block page-initiated fetches, XHR or subresources, including their redirects into protected origins; C5 allows those requests while the content and credential protections still apply. A URL override through `Fetch.continueRequest`, a redirect supplied through `Fetch.fulfillRequest` or `Fetch.continueResponse`, and `Fetch.continueWithAuth` make the request client-issued. The guard correlates its network ID on that target and fails a protected hop before sending it; an unmodified page continuation does not establish client ownership. Missing correlation, an unguarded worker or exhausted ownership tracking refuses the client mutation. `Network.continueInterceptedRequest` with `url` or `rawResponse` is always refused, whatever the destination; use Fetch instead. Chrome 156 removed `Network.setRequestInterception`, so its compatibility refusal has committed wire coverage rather than a native control. `IO.read` is refused, with `slicc: refused: slicc didn't hand out this stream, so it could be seven's`, unless the node passed that handle to the page in an allowed answer (`take…AsStream`, `Page.printToPDF`, or `IO.resolveBlob` as `blob:<uuid>`). - **Paused requests to seven.** A page session's own interception never gets to touch a request whose URL is protected, whatever its kind (a document, `fetch()`, XHR, an image or any other subresource), at either stage. The node keeps `Fetch.requestPaused`, `Fetch.authRequired` and the deprecated `Network.requestIntercepted` for such a request from the page and settles it itself:
929
930
  - a document request is failed (`Fetch.failRequest` with `BlockedByClient`, or `Network.continueInterceptedRequest` with `errorReason: BlockedByClient`);
930
931
  - any other request continues untouched (`Fetch.continueRequest`, or `Network.continueInterceptedRequest` with only its `interceptionId`);
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ai-ecoverse/slicc",
3
- "version": "1.68.5",
3
+ "version": "1.69.0",
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.68.5",
22
- "@ai-ecoverse/slicc-darwin-amd64": "1.68.5",
23
- "@ai-ecoverse/slicc-linux-arm64": "1.68.5",
24
- "@ai-ecoverse/slicc-linux-amd64": "1.68.5",
25
- "@ai-ecoverse/slicc-windows-arm64": "1.68.5",
26
- "@ai-ecoverse/slicc-windows-amd64": "1.68.5",
21
+ "@ai-ecoverse/slicc-darwin-arm64": "1.69.0",
22
+ "@ai-ecoverse/slicc-darwin-amd64": "1.69.0",
23
+ "@ai-ecoverse/slicc-linux-arm64": "1.69.0",
24
+ "@ai-ecoverse/slicc-linux-amd64": "1.69.0",
25
+ "@ai-ecoverse/slicc-windows-arm64": "1.69.0",
26
+ "@ai-ecoverse/slicc-windows-amd64": "1.69.0",
27
27
  "@ai-ecoverse/slicc-jerk": "^1.9.1"
28
28
  }
29
29
  }