CLI Dev Resource

CLIDevResource(cli)

Bases: BaseCLIResource

CLI resource for developer/debugging tools.

Attributes:

Name	Type	Description
_cli		Reference to the parent ObsidianCLI instance.

Source code in src/aiobsidian/cli/_base.py

def __init__(self, cli: ObsidianCLI) -> None:
    self._cli = cli

devtools() async

Toggle Electron DevTools.

Source code in src/aiobsidian/cli/dev.py

async def devtools(self) -> None:
    """Toggle Electron DevTools."""
    await self._cli._execute("devtools")

eval(code) async

Execute JavaScript in the Obsidian API context.

Parameters:

Name	Type	Description	Default
code	str	JavaScript code to evaluate.	required

Returns:

Type	Description
str	Evaluation result as a string.

Source code in src/aiobsidian/cli/dev.py

async def eval(self, code: str) -> str:
    """Execute JavaScript in the Obsidian API context.

    Args:
        code: JavaScript code to evaluate.

    Returns:
        Evaluation result as a string.
    """
    return await self._cli._execute("eval", params={"code": code})

console(*, limit=None) async

Show console messages.

Parameters:

Name	Type	Description	Default
limit	int | None	Maximum number of messages to return.	None

Returns:

Type	Description
list[dict[str, Any]]	List of console message objects.

Source code in src/aiobsidian/cli/dev.py

async def console(self, *, limit: int | None = None) -> list[dict[str, Any]]:
    """Show console messages.

    Args:
        limit: Maximum number of messages to return.

    Returns:
        List of console message objects.
    """
    params: dict[str, str] = {}
    if limit is not None:
        params["limit"] = str(limit)
    output = await self._cli._execute("dev:console", params=params or None)
    result: list[dict[str, Any]] = json.loads(output)
    return result

errors() async

Show JavaScript errors.

Returns:

Type	Description
list[dict[str, Any]]	List of error objects.

Source code in src/aiobsidian/cli/dev.py

async def errors(self) -> list[dict[str, Any]]:
    """Show JavaScript errors.

    Returns:
        List of error objects.
    """
    output = await self._cli._execute("dev:errors")
    result: list[dict[str, Any]] = json.loads(output)
    return result

screenshot(path) async

Capture a screenshot (base64 PNG).

Parameters:

Name	Type	Description	Default
path	str	File path for the screenshot.	required

Returns:

Type	Description
str	Base64-encoded PNG data.

Source code in src/aiobsidian/cli/dev.py

async def screenshot(self, path: str) -> str:
    """Capture a screenshot (base64 PNG).

    Args:
        path: File path for the screenshot.

    Returns:
        Base64-encoded PNG data.
    """
    return await self._cli._execute("dev:screenshot", params={"path": path})

dom(selector, *, match_all=False, text=False, attr=None, css=None) async

Inspect DOM elements.

Parameters:

Name	Type	Description	Default
selector	str	CSS selector for the element(s).	required
match_all	bool	If True, match all elements instead of just the first.	False
text	bool	If True, return text content only.	False
attr	str | None	Return this attribute value from matched elements.	None
css	str | None	Return this CSS property value from matched elements.	None

Returns:

Type	Description
str	DOM inspection result.

Source code in src/aiobsidian/cli/dev.py

async def dom(
    self,
    selector: str,
    *,
    match_all: bool = False,
    text: bool = False,
    attr: str | None = None,
    css: str | None = None,
) -> str:
    """Inspect DOM elements.

    Args:
        selector: CSS selector for the element(s).
        match_all: If ``True``, match all elements instead of just the first.
        text: If ``True``, return text content only.
        attr: Return this attribute value from matched elements.
        css: Return this CSS property value from matched elements.

    Returns:
        DOM inspection result.
    """
    params: dict[str, str] = {"selector": selector}
    if attr is not None:
        params["attr"] = attr
    if css is not None:
        params["css"] = css
    flags: list[str] = []
    if match_all:
        flags.append("--all")
    if text:
        flags.append("--text")
    return await self._cli._execute("dev:dom", params=params, flags=flags or None)

css(selector, *, prop=None) async

Inspect CSS styles.

Parameters:

Name	Type	Description	Default
selector	str	CSS selector for the element.	required
prop	str | None	Specific CSS property to retrieve.	None

Returns:

Type	Description
str	CSS inspection result.

Source code in src/aiobsidian/cli/dev.py

async def css(self, selector: str, *, prop: str | None = None) -> str:
    """Inspect CSS styles.

    Args:
        selector: CSS selector for the element.
        prop: Specific CSS property to retrieve.

    Returns:
        CSS inspection result.
    """
    params: dict[str, str] = {"selector": selector}
    if prop is not None:
        params["prop"] = prop
    return await self._cli._execute("dev:css", params=params)

mobile(*, on) async

Toggle mobile emulation.

Parameters:

Name	Type	Description	Default
on	bool	True to enable, False to disable.	required

Source code in src/aiobsidian/cli/dev.py

async def mobile(self, *, on: bool) -> None:
    """Toggle mobile emulation.

    Args:
        on: ``True`` to enable, ``False`` to disable.
    """
    flags = ["--on"] if on else ["--off"]
    await self._cli._execute("dev:mobile", flags=flags)

debug(*, on) async

Start or stop console capture.

Parameters:

Name	Type	Description	Default
on	bool	True to start, False to stop capture.	required

Source code in src/aiobsidian/cli/dev.py

async def debug(self, *, on: bool) -> None:
    """Start or stop console capture.

    Args:
        on: ``True`` to start, ``False`` to stop capture.
    """
    flags = ["--on"] if on else ["--off"]
    await self._cli._execute("dev:debug", flags=flags)

cdp(method, params) async

Execute a Chrome DevTools Protocol command.

Parameters:

Name	Type	Description	Default
method	str	CDP method name.	required
params	str	JSON-encoded parameters.	required

Returns:

Type	Description
str	CDP command result.

Source code in src/aiobsidian/cli/dev.py

async def cdp(self, method: str, params: str) -> str:
    """Execute a Chrome DevTools Protocol command.

    Args:
        method: CDP method name.
        params: JSON-encoded parameters.

    Returns:
        CDP command result.
    """
    return await self._cli._execute(
        "dev:cdp", params={"method": method, "params": params}
    )