@withbuddi/buddi 0.1.0-pre.42 → 0.1.0-pre.44

package/node_modules/parse5/dist/tree-adapters/interface.d.ts

@@ -0,0 +1,255 @@
+import type { DOCUMENT_MODE, NS } from '../common/html.js';
+import type { Attribute, ElementLocation } from '../common/token.js';
+export interface TreeAdapterTypeMap<Node = unknown, ParentNode = unknown, ChildNode = unknown, Document = unknown, DocumentFragment = unknown, Element = unknown, CommentNode = unknown, TextNode = unknown, Template = unknown, DocumentType = unknown> {
+    node: Node;
+    parentNode: ParentNode;
+    childNode: ChildNode;
+    document: Document;
+    documentFragment: DocumentFragment;
+    element: Element;
+    commentNode: CommentNode;
+    textNode: TextNode;
+    template: Template;
+    documentType: DocumentType;
+}
+/**
+ * Tree adapter is a set of utility functions that provides minimal required abstraction layer beetween parser and a specific AST format.
+ * Note that `TreeAdapter` is not designed to be a general purpose AST manipulation library. You can build such library
+ * on top of existing `TreeAdapter` or use one of the existing libraries from npm.
+ *
+ * @see Have a look at the default tree adapter for reference.
+ */
+export interface TreeAdapter<T extends TreeAdapterTypeMap = TreeAdapterTypeMap> {
+    /**
+     * Copies attributes to the given element. Only attributes that are not yet present in the element are copied.
+     *
+     * @param recipient - Element to copy attributes into.
+     * @param attrs - Attributes to copy.
+     */
+    adoptAttributes(recipient: T['element'], attrs: Attribute[]): void;
+    /**
+     * Appends a child node to the given parent node.
+     *
+     * @param parentNode - Parent node.
+     * @param newNode -  Child node.
+     */
+    appendChild(parentNode: T['parentNode'], newNode: T['childNode']): void;
+    /**
+     * Creates a comment node.
+     *
+     * @param data - Comment text.
+     */
+    createCommentNode(data: string): T['commentNode'];
+    /**
+     * Creates a text node.
+     *
+     * @param value - Text.
+     */
+    createTextNode(value: string): T['textNode'];
+    /**
+     * Creates a document node.
+     */
+    createDocument(): T['document'];
+    /**
+     * Creates a document fragment node.
+     */
+    createDocumentFragment(): T['documentFragment'];
+    /**
+     * Creates an element node.
+     *
+     * @param tagName - Tag name of the element.
+     * @param namespaceURI - Namespace of the element.
+     * @param attrs - Attribute name-value pair array. Foreign attributes may contain `namespace` and `prefix` fields as well.
+     */
+    createElement(tagName: string, namespaceURI: NS, attrs: Attribute[]): T['element'];
+    /**
+     * Removes a node from its parent.
+     *
+     * @param node - Node to remove.
+     */
+    detachNode(node: T['childNode']): void;
+    /**
+     * Returns the given element's attributes in an array, in the form of name-value pairs.
+     * Foreign attributes may contain `namespace` and `prefix` fields as well.
+     *
+     * @param element - Element.
+     */
+    getAttrList(element: T['element']): Attribute[];
+    /**
+     * Returns the given node's children in an array.
+     *
+     * @param node - Node.
+     */
+    getChildNodes(node: T['parentNode']): T['childNode'][];
+    /**
+     * Returns the given comment node's content.
+     *
+     * @param commentNode - Comment node.
+     */
+    getCommentNodeContent(commentNode: T['commentNode']): string;
+    /**
+     * Returns [document mode](https://dom.spec.whatwg.org/#concept-document-limited-quirks).
+     *
+     * @param document - Document node.
+     */
+    getDocumentMode(document: T['document']): DOCUMENT_MODE;
+    /**
+     * Returns the given document type node's name.
+     *
+     * @param doctypeNode - Document type node.
+     */
+    getDocumentTypeNodeName(doctypeNode: T['documentType']): string;
+    /**
+     * Returns the given document type node's public identifier.
+     *
+     * @param doctypeNode - Document type node.
+     */
+    getDocumentTypeNodePublicId(doctypeNode: T['documentType']): string;
+    /**
+     * Returns the given document type node's system identifier.
+     *
+     * @param doctypeNode - Document type node.
+     */
+    getDocumentTypeNodeSystemId(doctypeNode: T['documentType']): string;
+    /**
+     * Returns the first child of the given node.
+     *
+     * @param node - Node.
+     */
+    getFirstChild(node: T['parentNode']): T['childNode'] | null;
+    /**
+     * Returns the given element's namespace.
+     *
+     * @param element - Element.
+     */
+    getNamespaceURI(element: T['element']): NS;
+    /**
+     * Returns the given node's source code location information.
+     *
+     * @param node - Node.
+     */
+    getNodeSourceCodeLocation(node: T['node']): ElementLocation | undefined | null;
+    /**
+     * Returns the given node's parent.
+     *
+     * @param node - Node.
+     */
+    getParentNode(node: T['node']): T['parentNode'] | null;
+    /**
+     * Returns the given element's tag name.
+     *
+     * @param element - Element.
+     */
+    getTagName(element: T['element']): string;
+    /**
+     * Returns the given text node's content.
+     *
+     * @param textNode - Text node.
+     */
+    getTextNodeContent(textNode: T['textNode']): string;
+    /**
+     * Returns the `<template>` element content element.
+     *
+     * @param templateElement - `<template>` element.
+     */
+    getTemplateContent(templateElement: T['template']): T['documentFragment'];
+    /**
+     * Inserts a child node to the given parent node before the given reference node.
+     *
+     * @param parentNode - Parent node.
+     * @param newNode -  Child node.
+     * @param referenceNode -  Reference node.
+     */
+    insertBefore(parentNode: T['parentNode'], newNode: T['childNode'], referenceNode: T['childNode']): void;
+    /**
+     * Inserts text into a node. If the last child of the node is a text node, the provided text will be appended to the
+     * text node content. Otherwise, inserts a new text node with the given text.
+     *
+     * @param parentNode - Node to insert text into.
+     * @param text - Text to insert.
+     */
+    insertText(parentNode: T['parentNode'], text: string): void;
+    /**
+     * Inserts text into a sibling node that goes before the reference node. If this sibling node is the text node,
+     * the provided text will be appended to the text node content. Otherwise, inserts a new sibling text node with
+     * the given text before the reference node.
+     *
+     * @param parentNode - Node to insert text into.
+     * @param text - Text to insert.
+     * @param referenceNode - Node to insert text before.
+     */
+    insertTextBefore(parentNode: T['parentNode'], text: string, referenceNode: T['childNode']): void;
+    /**
+     * Determines if the given node is a comment node.
+     *
+     * @param node - Node.
+     */
+    isCommentNode(node: T['node']): node is T['commentNode'];
+    /**
+     * Determines if the given node is a document type node.
+     *
+     * @param node - Node.
+     */
+    isDocumentTypeNode(node: T['node']): node is T['documentType'];
+    /**
+     * Determines if the given node is an element.
+     *
+     * @param node - Node.
+     */
+    isElementNode(node: T['node']): node is T['element'];
+    /**
+     * Determines if the given node is a text node.
+     *
+     * @param node - Node.
+     */
+    isTextNode(node: T['node']): node is T['textNode'];
+    /**
+     * Sets the [document mode](https://dom.spec.whatwg.org/#concept-document-limited-quirks).
+     *
+     * @param document - Document node.
+     * @param mode - Document mode.
+     */
+    setDocumentMode(document: T['document'], mode: DOCUMENT_MODE): void;
+    /**
+     * Sets the document type. If the `document` already contains a document type node, the `name`, `publicId` and `systemId`
+     * properties of this node will be updated with the provided values. Otherwise, creates a new document type node
+     * with the given properties and inserts it into the `document`.
+     *
+     * @param document - Document node.
+     * @param name -  Document type name.
+     * @param publicId - Document type public identifier.
+     * @param systemId - Document type system identifier.
+     */
+    setDocumentType(document: T['document'], name: string, publicId: string, systemId: string): void;
+    /**
+     * Attaches source code location information to the node.
+     *
+     * @param node - Node.
+     */
+    setNodeSourceCodeLocation(node: T['node'], location: ElementLocation | null): void;
+    /**
+     * Updates the source code location information of the node.
+     *
+     * @param node - Node.
+     */
+    updateNodeSourceCodeLocation(node: T['node'], location: Partial<ElementLocation>): void;
+    /**
+     * Sets the `<template>` element content element.
+     *
+     * @param templateElement - `<template>` element.
+     * @param contentElement -  Content element.
+     */
+    setTemplateContent(templateElement: T['template'], contentElement: T['documentFragment']): void;
+    /**
+     * Optional callback for elements being pushed to the stack of open elements.
+     *
+     * @param element The element being pushed to the stack of open elements.
+     */
+    onItemPush?: (item: T['element']) => void;
+    /**
+     * Optional callback for elements being popped from the stack of open elements.
+     *
+     * @param item The element being popped.
+     */
+    onItemPop?: (item: T['element'], newTop: T['parentNode']) => void;
+}

package/node_modules/parse5/dist/tree-adapters/interface.js

@@ -0,0 +1 @@
+export {};

package/node_modules/parse5/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "parse5",
+    "type": "module",
+    "description": "HTML parser and serializer.",
+    "version": "7.3.0",
+    "author": "Ivan Nikulin <ifaaan@gmail.com> (https://github.com/inikulin)",
+    "contributors": "https://github.com/inikulin/parse5/graphs/contributors",
+    "homepage": "https://parse5.js.org",
+    "funding": "https://github.com/inikulin/parse5?sponsor=1",
+    "dependencies": {
+        "entities": "^6.0.0"
+    },
+    "keywords": [
+        "html",
+        "parser",
+        "html5",
+        "WHATWG",
+        "specification",
+        "fast",
+        "html parser",
+        "html5 parser",
+        "htmlparser",
+        "parse5",
+        "serializer",
+        "html serializer",
+        "htmlserializer",
+        "parse",
+        "serialize"
+    ],
+    "license": "MIT",
+    "main": "dist/cjs/index.js",
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        "import": "./dist/index.js",
+        "require": "./dist/cjs/index.js"
+    },
+    "scripts": {
+        "build:cjs": "tsc --noCheck --moduleResolution node10 --module CommonJS --target ES6 --outDir dist/cjs && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/inikulin/parse5.git"
+    },
+    "files": [
+        "dist/cjs/package.json",
+        "dist/**/*.js",
+        "dist/**/*.d.ts"
+    ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withbuddi/buddi",
-  "version": "0.1.0-pre.42",
+  "version": "0.1.0-pre.44",
   "type": "module",
   "description": "Your personal agents, on your computer",
   "repository": {
@@ -17,7 +17,7 @@
     "buddi": "packages/install/dist/launcher.js"
   },
   "buddi": {
-    "notes": "- buddi.app: the Dock icon and the menu-bar glyph are the Blob now, not a \"b\". The menu-bar Blob is dimmed while buddi starts or updates and carries a dot when it needs attention.\n- Pairing Chrome no longer goes stale half a minute in. Chrome put the extension to sleep while it waited for you to type its code, so the popup kept showing a code buddi was no longer waiting for (\"No browser is waiting to be paired\"). buddi now keeps the waiting extension awake, the extension keeps itself awake too, and the popup picks up a fresh code if the old one went.\n- Settings → Your Chrome always offers \"Enter the code\" until Chrome is paired: open the buddi icon in Chrome and type its six digits here, which is how you pair from the buddi.app window. Typing the code just as the page paired this Chrome by itself no longer shows an error. \"Install unpacked…\" shows only when buddi runs from a source checkout.\n- buddi's log has one line for every connection the Chrome extension makes: accepted or refused and why, waiting for its code, paired, or reconnected. Never the code or the token.\n- Settings → Where agents may look is now called **Browser & apps** in the sidebar and at the top of the page, with \"Where agents may look\" underneath. The extension popup, first run and the docs use the new name; old links still land there.\n- buddi.app answers `buddi://` links: `buddi://open` brings the window forward, `buddi://settings/<page>` opens that Settings page, and `buddi://settings/browser?code=123456` opens Browser & apps with the Chrome pairing code already typed in (you still press Pair). Any other link is ignored. The extension's **Open buddi settings** opens buddi.app this way on a Mac and falls back to the dashboard in a tab when the app doesn't answer; if that tab finds you signed out, it offers **Open buddi.app** first (on a Mac, for the buddi on the usual address; never on Linux or Windows) and shows the Terminal command only when the app didn't open, including after Cancel on Chrome's \"Open buddi.app?\" question (the popup says to allow it). The code travels only after the `#` in the address, never to the server, and leaves the address once Pair worked, so a reload or a restart of buddi.app doesn't type a used code in again. A link that arrives while the window is still loading is no longer lost, and a link with more than 8 parameters is ignored.\n- First run, linking your calendar: Sign in with Google opens Google's page on the first press (in buddi.app, in your default browser), instead of turning into \"Continue to Google\" and needing a second one. Its button carries an arrow out, not the \"unavailable\" circle. Opening the sheet no longer cancels a Google sign-in already waiting (it uses that one), leaving it never leaves a prepared sign-in behind, and a tab that sat in the background prepares a fresh one when you come back.\n- `buddi uninstall` with buddi stopped no longer refuses to take the last backup: it starts only the database for the backup (buddi itself stays stopped), then stops it again before removing anything — also when run through buddi.app's `buddi` command, and a Ctrl-C or a crash during that backup no longer leaves the database running (it stops within seconds, and after 30 minutes at most). A stray `BUDDI_SUPERVISE_BRIEFLY` in an env file can't keep the normal service from starting buddi. The Telegram bot's command menu is cleared before your secrets go, and even when the paired chats can't be read. While buddi.app is running the installation, uninstall says so and points you to buddi → Uninstall buddi… in the app (or quitting the app first); with the app quit, it ends by telling you to move buddi.app to the Trash.\n- Lock screen: a widget that couldn't refresh still shows its last good answer, but its title now says when that was (\"Top stories · from 9:12\", or \"from yesterday 9:12\" and \"from Mon 9:12\" when it wasn't today), so yesterday's headlines no longer pass for now. A widget that answers a little after its 5 seconds is kept for the next look instead of thrown away (never over a newer answer), and each widget that fails or times out leaves one line in buddi's log (which widget, how long it took)."
+    "notes": "- Cloudflare Access, \"Set it up for me\": buddi now runs Cloudflare's connector itself, as part of its own service, so the last step is \"Starting the connector…\" then \"Connected\" — no `sudo` command to copy. If cloudflared isn't installed, buddi downloads Cloudflare's official release and checks it against Cloudflare's published checksum before running it (or install it with `brew install cloudflared`). If an earlier setup left Cloudflare's system service on this computer, the step says so, explains why two connectors would fight, and gives the one line that removes it — or choose \"Use the system daemon instead\". Remove what buddi made stops the connector and deletes the copy of cloudflared buddi downloaded.\n- The lock screen has two new pictures: Peoria autumn waterfront and Golden streak. Settings → Lock screen → Background now shows Colours and Pictures as two rows, with the chosen picture's credit underneath. Phones get a picture's portrait version when it has one. Your own picture can have a second, portrait version for phones too.\n- Your front desk can now fill in everything Settings → Profile has, from what you tell it: your full name, pronouns, 12- or 24-hour time, how dates read, and places like Home and Work (it looks up the address, tells you which town it matched, and keeps that town's timezone), as well as your name, timezone, language, birthday and a few lines about you. It only records what you said, refuses what the Profile page refuses, and every agent uses it from its next message. When a task needs something missing (a letter needs your full name, \"how long to work?\" needs Work) it asks once, in one question; otherwise at most one \"knowing you\" question a week, never twice about the same thing, and \"don't ask\" is remembered. Agent Father sees what is missing too, and when you ask it or the front desk to become yours, it answers plainly: it can't change itself in place, but it can make a copy that's yours, same name and handle. From Claude Code, `buddi.profile_update` makes the same change as an approval card.\n- Releases are tagged by CI after the gate passes: `pnpm release pre.N` pushes a release commit to main, and the release workflow tags it and publishes once the full gate is green. A red gate is fixed with a normal push on top; nothing is tagged until then (docs/release.md).\n- One buddi mark everywhere: the Blob is the icon in your Dock, your browser tab, the extension and the site. At the smallest sizes it gets bigger eyes and a bigger coral tip so it still reads as Buddi; the extension's new icon arrives with its next store update.\n- Plugins now learn which of your model accounts can listen and speak: an OpenAI key and Gemini can, a ChatGPT subscription and Claude can't, and Ollama or another compatible server is \"try it and see\". Settings → Speech uses this to offer only accounts that work, with the reason beside the ones that don't. (Host API 1.30.)\n### Added\n\n- Mail: opening a conversation now reads it. Each message shows who wrote it (their initial, name and address), when, and who else got it under \"to …\"; the body looks the way it was sent, with earlier quoted messages folded behind \"··· earlier message\" and attachments you can open in Files (or fetch first). Pictures from the web stay hidden until you press Show images, which buddi remembers for that sender; tracking pixels never load. Above the thread, Mail Triage says what it made of the latest message and what it changed, with Undo; \"Needs a reply\" has a Done button; and the reply written for you shows as a message with Send and Edit. Older messages fold to one line until you open them, and the old summary (subject, state, people, count) is under Details at the bottom. The list shows the sender's name, a line of the latest message, unread conversations in bold and Mail Triage's label as a chip; ↑ and ↓ move through it and Enter opens one. New mail keeps its formatting from now on; mail that arrived before shows its text."
   },
   "files": [
     "packages",