dcc-mcp-openscreen 0.1.1__tar.gz

dcc_mcp_openscreen-0.1.1/.github/workflows/release.yml

@@ -0,0 +1,212 @@
+name: Release
+
+# Batched release cadence.
+#
+# release-please runs on a fixed daily window instead of on every push to main,
+# so a single version carries every feat/fix merged since the previous tag
+# rather than one version per merge. `workflow_dispatch` stays available as the
+# emergency release and asset-backfill channel.
+#
+# release-please creates tags from merged-but-untagged release PRs, so the
+# GitHub Release is cut on the first window after the release PR is merged
+# instead of on the merge push itself.
+on:
+  schedule:
+    # 03:29 UTC daily. Deliberately off the hour: GitHub queues scheduled
+    # runs and on-the-hour crons are the most delayed during peak load.
+    # CONTRACT: this window stays AFTER the dcc-mcp-core release window
+    # (01:13 UTC) so a release never packages a stale core.
+    - cron: "29 3 * * *"
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: "Tag name for manual asset build, for example v0.1.0. Leave empty to only run release-please."
+        required: false
+        default: ""
+      publish_to_pypi:
+        description: "Publish rebuilt dist artifacts for tag_name to PyPI. Use to backfill an existing GitHub release."
+        required: false
+        type: boolean
+        default: false
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name }}${{ inputs.tag_name && format('-{0}', inputs.tag_name) || '' }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+
+jobs:
+  release-please:
+    name: Release Please
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+    permissions:
+      contents: write
+      pull-requests: write
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.target.outputs.tag_name }}
+      tag_sha: ${{ steps.target.outputs.tag_sha }}
+      version: ${{ steps.target.outputs.version }}
+    steps:
+      # A PAT (user-owned) is required: PRs opened with the default
+      # GITHUB_TOKEN do not trigger pull_request workflows, so CI would never
+      # run on release PRs.
+      - uses: googleapis/release-please-action@v5
+        id: release
+        # On an explicit dispatch target the requested tag is authoritative.
+        # Running release-please here can create a new release whose tag then
+        # silently wins over the requested one in RELEASE_TAG below, so the
+        # operator asking to backfill v0.1.5 would get v0.1.6 published instead.
+        if: github.event_name != 'workflow_dispatch' || inputs.tag_name == ''
+        with:
+          token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+      - name: Resolve immutable release target
+        id: target
+        if: steps.release.outputs.release_created == 'true' || (github.event_name == 'workflow_dispatch' && inputs.tag_name != '')
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ steps.release.outputs.tag_name || inputs.tag_name }}
+          RELEASE_VERSION: ${{ steps.release.outputs.version }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          if [[ ! "$RELEASE_TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "Release target must be a canonical vMAJOR.MINOR.PATCH tag." >&2
+            exit 1
+          fi
+          version="${RELEASE_TAG#v}"
+          if [[ -n "$RELEASE_VERSION" && "$RELEASE_VERSION" != "$version" ]]; then
+            echo "Release Please version does not match its tag." >&2
+            exit 1
+          fi
+          object_type="$(gh api "repos/${GITHUB_REPOSITORY}/git/ref/tags/${RELEASE_TAG}" --jq .object.type)"
+          object_sha="$(gh api "repos/${GITHUB_REPOSITORY}/git/ref/tags/${RELEASE_TAG}" --jq .object.sha)"
+          for _ in 1 2 3 4; do
+            if [[ "$object_type" == "commit" ]]; then
+              break
+            fi
+            if [[ "$object_type" != "tag" ]]; then
+              echo "Release tag does not resolve to a commit." >&2
+              exit 1
+            fi
+            tag_json="$(gh api "repos/${GITHUB_REPOSITORY}/git/tags/${object_sha}")"
+            object_type="$(jq -r .object.type <<<"$tag_json")"
+            object_sha="$(jq -r .object.sha <<<"$tag_json")"
+          done
+          if [[ "$object_type" != "commit" || ! "$object_sha" =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Release tag commit identity is invalid." >&2
+            exit 1
+          fi
+          echo "tag_name=$RELEASE_TAG" >> "$GITHUB_OUTPUT"
+          echo "tag_sha=$object_sha" >> "$GITHUB_OUTPUT"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+
+  build:
+    name: Build wheel and sdist
+    runs-on: ubuntu-latest
+    needs: release-please
+    if: needs.release-please.outputs.release_created == 'true' || (github.event_name == 'workflow_dispatch' && inputs.tag_name != '')
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ needs.release-please.outputs.tag_name }}
+          fetch-depth: 0
+      - name: Verify immutable release target
+        env:
+          EXPECTED_TAG: ${{ needs.release-please.outputs.tag_name }}
+          EXPECTED_SHA: ${{ needs.release-please.outputs.tag_sha }}
+          EXPECTED_VERSION: ${{ needs.release-please.outputs.version }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          actual_sha="$(git rev-parse HEAD)"
+          tag_sha="$(git rev-parse "${EXPECTED_TAG}^{commit}")"
+          if [[ "$actual_sha" != "$EXPECTED_SHA" || "$tag_sha" != "$EXPECTED_SHA" ]]; then
+            echo "Checked-out release identity does not match the resolved tag." >&2
+            exit 1
+          fi
+          python - <<'PY'
+          import json
+          import os
+          import re
+          from pathlib import Path
+
+          expected = os.environ["EXPECTED_VERSION"]
+          manifest = json.loads(Path(".release-please-manifest.json").read_text(encoding="utf-8"))["."]
+          source = Path("pyproject.toml").read_text(encoding="utf-8")
+          match = re.search(r'^version = "([0-9]+\.[0-9]+\.[0-9]+)"', source, re.MULTILINE)
+          if match is None or manifest != expected or match.group(1) != expected:
+              raise SystemExit("Checked-out package version does not match the release target.")
+          PY
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - name: Install build tools
+        run: python -m pip install --upgrade pip build twine
+      - name: Build package
+        run: python -m build
+      - name: Check package
+        run: python -m twine check dist/*
+      - name: Upload dist artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    needs: [release-please, build]
+    if: needs.release-please.outputs.release_created == 'true' || (github.event_name == 'workflow_dispatch' && inputs.tag_name != '' && inputs.publish_to_pypi == true)
+    environment:
+      name: pypi
+      url: https://pypi.org/p/dcc-mcp-openscreen
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ needs.release-please.outputs.tag_name }}
+          fetch-depth: 0
+      - name: Verify immutable release target
+        env:
+          EXPECTED_TAG: ${{ needs.release-please.outputs.tag_name }}
+          EXPECTED_SHA: ${{ needs.release-please.outputs.tag_sha }}
+          EXPECTED_VERSION: ${{ needs.release-please.outputs.version }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          actual_sha="$(git rev-parse HEAD)"
+          tag_sha="$(git rev-parse "${EXPECTED_TAG}^{commit}")"
+          if [[ "$actual_sha" != "$EXPECTED_SHA" || "$tag_sha" != "$EXPECTED_SHA" ]]; then
+            echo "Checked-out release identity does not match the resolved tag." >&2
+            exit 1
+          fi
+          python - <<'PY'
+          import json
+          import os
+          import re
+          from pathlib import Path
+
+          expected = os.environ["EXPECTED_VERSION"]
+          manifest = json.loads(Path(".release-please-manifest.json").read_text(encoding="utf-8"))["."]
+          source = Path("pyproject.toml").read_text(encoding="utf-8")
+          match = re.search(r'^version = "([0-9]+\.[0-9]+\.[0-9]+)"', source, re.MULTILINE)
+          if match is None or manifest != expected or match.group(1) != expected:
+              raise SystemExit("Checked-out package version does not match the release target.")
+          PY
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+      - name: Publish to PyPI with trusted publishing
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
+        with:
+          verbose: true
+          print-hash: true

dcc_mcp_openscreen-0.1.1/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+dist/
+build/
+*.egg-info/

dcc_mcp_openscreen-0.1.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.1.1"
+}

dcc_mcp_openscreen-0.1.1/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## [0.1.1](https://github.com/dcc-mcp/dcc-mcp-openscreen/compare/v0.1.0...v0.1.1) (2026-09-27)
+
+
+### Features
+
+* add OpenScreen MCP adapter ([f12c9eb](https://github.com/dcc-mcp/dcc-mcp-openscreen/commit/f12c9ebe72d7ab2371c5d8bba94c197308854f1a))
+* expand OpenScreen tools and diagnostics ([dc49cde](https://github.com/dcc-mcp/dcc-mcp-openscreen/commit/dc49cdea522af0207fa9052c42effc36f9a3b350))
+
+
+### Bug Fixes
+
+* clean up hung OpenScreen process trees ([354e603](https://github.com/dcc-mcp/dcc-mcp-openscreen/commit/354e6037c08b4ccca954cc41c473457672743f40))
+* make OpenScreen server module executable ([3dc4815](https://github.com/dcc-mcp/dcc-mcp-openscreen/commit/3dc4815a76113696ecc3ae53c32cee0a7a5853cf))
+* repair OpenScreen CLI runner syntax ([e27adc6](https://github.com/dcc-mcp/dcc-mcp-openscreen/commit/e27adc60f1cb0e2131c46fee10857afcd7e6ddd6))
+* stop recordings cooperatively on Windows ([2adedfc](https://github.com/dcc-mcp/dcc-mcp-openscreen/commit/2adedfca815a4a08dfc02c5e1b62eb13e1ef2b34))

dcc_mcp_openscreen-0.1.1/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: dcc-mcp-openscreen
+Version: 0.1.1
+Summary: OpenScreen recording and demo export adapter for DCC-MCP
+Author-email: Long Hao <hal.long@outlook.com>
+License: MIT
+Requires-Python: >=3.7
+Requires-Dist: dcc-mcp-core<1.0.0,>=0.20.14
+Description-Content-Type: text/markdown
+
+# dcc-mcp-openscreen
+
+Standalone DCC-MCP adapter for [OpenScreen](https://github.com/getopenscreen/openscreen).
+
+The adapter exposes only typed, bounded CLI operations. Set `DCC_MCP_OPENSCREEN_PATH` when the executable is not on `PATH`. It does not automate the desktop UI; DCC window selection and unsupported UI actions remain owned by `dcc-cua` / `ui-control`.
+
+## Run
+
+```powershell
+python -m pip install -e .
+dcc-mcp-openscreen
+```
+
+Tools: `openscreen__sources`, `openscreen__record`, and `openscreen__export`.
+
+## License
+
+MIT

dcc_mcp_openscreen-0.1.1/README.md

@@ -0,0 +1,18 @@
+# dcc-mcp-openscreen
+
+Standalone DCC-MCP adapter for [OpenScreen](https://github.com/getopenscreen/openscreen).
+
+The adapter exposes only typed, bounded CLI operations. Set `DCC_MCP_OPENSCREEN_PATH` when the executable is not on `PATH`. It does not automate the desktop UI; DCC window selection and unsupported UI actions remain owned by `dcc-cua` / `ui-control`.
+
+## Run
+
+```powershell
+python -m pip install -e .
+dcc-mcp-openscreen
+```
+
+Tools: `openscreen__sources`, `openscreen__record`, and `openscreen__export`.
+
+## License
+
+MIT

dcc_mcp_openscreen-0.1.1/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["hatchling>=1.27,<1.30"]
+build-backend = "hatchling.build"
+[project]
+name = "dcc-mcp-openscreen"
+version = "0.1.1"
+description = "OpenScreen recording and demo export adapter for DCC-MCP"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.7"
+authors = [{name = "Long Hao", email = "hal.long@outlook.com"}]
+dependencies = ["dcc-mcp-core>=0.20.14,<1.0.0"]
+[project.scripts]
+dcc-mcp-openscreen = "dcc_mcp_openscreen.server:main"
+[project.entry-points."dcc_mcp.adapters"]
+openscreen = "dcc_mcp_openscreen:OpenScreenMcpServer"
+[tool.hatch.build.targets.wheel]
+packages = ["src/dcc_mcp_openscreen"]
+artifacts = ["src/dcc_mcp_openscreen/skills/**"]
+[tool.pytest.ini_options]
+pythonpath = ["src"]

dcc_mcp_openscreen-0.1.1/release-please-config.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+  "packages": {
+    ".": {
+      "release-type": "python",
+      "package-name": "dcc-mcp-openscreen",
+      "include-component-in-tag": false,
+      "changelog-path": "CHANGELOG.md",
+      "bump-minor-pre-major": true,
+      "bump-patch-for-minor-pre-major": true,
+      "extra-files": [
+        {
+          "type": "toml",
+          "path": "pyproject.toml",
+          "jsonpath": "$.project.version"
+        }
+      ]
+    }
+  }
+}

dcc_mcp_openscreen-0.1.1/src/dcc_mcp_openscreen/__init__.py

@@ -0,0 +1,2 @@
+from .server import OpenScreenMcpServer
+__all__ = ["OpenScreenMcpServer"]

dcc_mcp_openscreen-0.1.1/src/dcc_mcp_openscreen/server.py

@@ -0,0 +1,20 @@
+"""Standalone OpenScreen MCP adapter."""
+from __future__ import annotations
+import argparse, os, signal, threading
+from pathlib import Path
+from dcc_mcp_core import DccServerOptions
+from dcc_mcp_core.server_base import DccServerBase
+class OpenScreenMcpServer(DccServerBase):
+    def __init__(self, *, port: int | None = None):
+        options = DccServerOptions.from_env("openscreen", Path(__file__).parent / "skills", port=port, server_name="dcc-mcp-openscreen", instance_type="standalone", adapter_version="0.1.0", standalone_main_thread=False)
+        super().__init__(options=options)
+def main(argv=None):
+    p=argparse.ArgumentParser(); p.add_argument("--mcp-port", type=int); a=p.parse_args(argv)
+    server=OpenScreenMcpServer(port=a.mcp_port); server.register_builtin_actions(); server.start()
+    stopped=threading.Event(); signal.signal(signal.SIGINT, lambda *_: stopped.set())
+    if hasattr(signal,"SIGTERM"): signal.signal(signal.SIGTERM, lambda *_: stopped.set())
+    try: stopped.wait()
+    finally: server.stop()
+
+if __name__ == '__main__':
+    main()

dcc_mcp_openscreen-0.1.1/src/dcc_mcp_openscreen/skills/openscreen/scripts/_client.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+import json, os, subprocess, time
+from pathlib import Path
+
+def executable() -> str:
+    return os.getenv("DCC_MCP_OPENSCREEN_PATH", "openscreen")
+
+def _events(stdout: str) -> list[dict]:
+    out=[]
+    for line in stdout.splitlines():
+        try: out.append(json.loads(line))
+        except json.JSONDecodeError: pass
+    return out
+
+def run(args: list[str], *, timeout: float = 900.0) -> dict:
+    try:
+        proc=subprocess.run([executable(), *args, "--json"], capture_output=True, text=True, timeout=timeout, check=False)
+    except subprocess.TimeoutExpired as exc:
+        raise RuntimeError(f"OpenScreen CLI timed out after {timeout:.0f}s; verify permissions and headless build") from exc
+    return _finish(proc.returncode, proc.stdout, proc.stderr)
+
+def record(args: list[str], *, duration: int, timeout: float) -> dict:
+    proc=subprocess.Popen([executable(), "record", *args, "--json"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    try:
+        time.sleep(duration)
+        if proc.poll() is None and proc.stdin:
+            proc.stdin.write("stop\n"); proc.stdin.flush()
+        stdout, stderr=proc.communicate(timeout=max(10.0, timeout-duration))
+    except subprocess.TimeoutExpired as exc:
+        if os.name == "nt":\n            subprocess.run(["taskkill", "/PID", str(proc.pid), "/T", "/F"], capture_output=True, check=False)\n        else:\n            proc.kill()\n        proc.communicate()
+        raise RuntimeError("OpenScreen recording did not stop after a cooperative stop request") from exc
+    return _finish(proc.returncode, stdout, stderr)
+
+def _finish(code: int, stdout: str, stderr: str) -> dict:
+    events=_events(stdout)
+    done=next((e for e in reversed(events) if e.get("event")=="done"), None)
+    if code != 0 or not done or done.get("success") is False:
+        detail=(stderr or "OpenScreen command failed").strip()
+        if not events and not detail: detail="OpenScreen produced no JSON events; verify a headless-capable build"
+        raise RuntimeError(detail[-2000:])
+    return done
+
+def path_arg(value: str) -> str:
+    path=Path(value).expanduser().resolve()
+    if len(str(path))>4096: raise ValueError("path too long")
+    return str(path)
+

dcc_mcp_openscreen-0.1.1/src/dcc_mcp_openscreen/skills/openscreen/scripts/captions.py

@@ -0,0 +1,4 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+from ._client import run, path_arg
+@skill_entry
+def main(project, min_words=2, max_words=7, **_): return skill_success("OpenScreen captions generated.", **run(["captions", path_arg(project), "--min-words", str(min_words), "--max-words", str(max_words)], timeout=1800))

dcc_mcp_openscreen-0.1.1/src/dcc_mcp_openscreen/skills/openscreen/scripts/export.py

@@ -0,0 +1,7 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+from ._client import run, path_arg
+@skill_entry
+def main(project, output=None, quality="source", **_):
+    args=["export",path_arg(project),"--quality",quality]
+    if output: args += ["--out",path_arg(output)]
+    return skill_success("OpenScreen export completed.", **run(args, timeout=1800))

dcc_mcp_openscreen-0.1.1/src/dcc_mcp_openscreen/skills/openscreen/scripts/info.py

@@ -0,0 +1,4 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+from ._client import run, path_arg
+@skill_entry
+def main(project, **_): return skill_success("OpenScreen project inspected.", **run(["info", path_arg(project)]))

dcc_mcp_openscreen-0.1.1/src/dcc_mcp_openscreen/skills/openscreen/scripts/pack.py

@@ -0,0 +1,4 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+from ._client import run, path_arg
+@skill_entry
+def main(project, output, **_): return skill_success("OpenScreen project packed.", **run(["pack", path_arg(project), "--out", path_arg(output)], timeout=600))

dcc_mcp_openscreen-0.1.1/src/dcc_mcp_openscreen/skills/openscreen/scripts/record.py

@@ -0,0 +1,11 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+from ._client import record, path_arg
+@skill_entry
+def main(duration=30, window=None, display=0, project=None, mic=False, system_audio=False, **_):
+    if not isinstance(duration,int) or duration<1 or duration>3600: raise ValueError("duration must be 1..3600 seconds")
+    args=["--display",str(display)]
+    if window: args += ["--window",str(window)]
+    if project: args += ["--project",path_arg(project)]
+    if mic: args += ["--mic"]
+    if system_audio: args += ["--system-audio"]
+    return skill_success("OpenScreen recording completed.", **record(args,duration=duration,timeout=duration+120))

dcc_mcp_openscreen-0.1.1/src/dcc_mcp_openscreen/skills/openscreen/scripts/sources.py

@@ -0,0 +1,4 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+from ._client import run
+@skill_entry
+def main(**_): return skill_success("OpenScreen sources enumerated.", **run(["sources"]))

dcc_mcp_openscreen-0.1.1/src/dcc_mcp_openscreen/skills/openscreen/tools.yaml

@@ -0,0 +1,67 @@
+skill: openscreen
+version: "0.1.0"
+description: Record and export OpenScreen projects through its typed headless CLI.
+tools:
+  - name: sources
+    description: List available displays, windows, and microphones.
+    source_file: scripts/sources.py
+    input_schema: {type: object, additionalProperties: false}
+    execution: sync
+    affinity: any
+    annotations: {read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false}
+  - name: record
+    description: Record a bounded display or window capture to an optional OpenScreen project.
+    source_file: scripts/record.py
+    input_schema:
+      type: object
+      additionalProperties: false
+      properties:
+        duration: {type: integer, minimum: 1, maximum: 3600, default: 30}
+        window: {type: string, minLength: 1, maxLength: 256}
+        display: {type: integer, minimum: 0, maximum: 32, default: 0}
+        project: {type: string, maxLength: 4096}
+        mic: {type: boolean, default: false}
+        system_audio: {type: boolean, default: false}
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 3720
+    annotations: {read_only_hint: false, destructive_hint: true, idempotent_hint: false, open_world_hint: false}
+  - name: export
+    description: Render an OpenScreen project to MP4 or GIF.
+    source_file: scripts/export.py
+    input_schema:
+      type: object
+      required: [project]
+      additionalProperties: false
+      properties:
+        project: {type: string, minLength: 1, maxLength: 4096}
+        output: {type: string, maxLength: 4096}
+        quality: {enum: [medium, good, source], default: source}
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 1800
+    annotations: {read_only_hint: false, destructive_hint: true, idempotent_hint: true, open_world_hint: false}
+  - name: info
+    description: Inspect a project and verify referenced media.
+    source_file: scripts/info.py
+    input_schema: {type: object, required: [project], additionalProperties: false, properties: {project: {type: string, minLength: 1, maxLength: 4096}}}
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 60
+    annotations: {read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false}
+  - name: pack
+    description: Pack a project and referenced media into a portable folder.
+    source_file: scripts/pack.py
+    input_schema: {type: object, required: [project, output], additionalProperties: false, properties: {project: {type: string, minLength: 1, maxLength: 4096}, output: {type: string, minLength: 1, maxLength: 4096}}}
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 600
+    annotations: {read_only_hint: false, destructive_hint: true, idempotent_hint: true, open_world_hint: false}
+  - name: captions
+    description: Generate local Whisper captions for a project with bounded word grouping.
+    source_file: scripts/captions.py
+    input_schema: {type: object, required: [project], additionalProperties: false, properties: {project: {type: string, minLength: 1, maxLength: 4096}, min_words: {type: integer, minimum: 1, maximum: 20, default: 2}, max_words: {type: integer, minimum: 1, maximum: 20, default: 7}}}
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 1800
+    annotations: {read_only_hint: false, destructive_hint: true, idempotent_hint: true, open_world_hint: false}

dcc_mcp_openscreen-0.1.1/tests/test_server.py

@@ -0,0 +1,5 @@
+from dcc_mcp_openscreen.server import OpenScreenMcpServer
+
+def test_server_constructs():
+    server = OpenScreenMcpServer(port=0)
+    assert server is not None