PHP - BlogFlock

The State of PHP 2025 - PhpStorm : The IDE that empowers PHP developers | The JetBrains Blog

2025-10-15T14:00:04.000Z

The State of PHP 2025 examines how developers use, prefer, and rely on PHP, showing how this long-standing web language continues to modernize through new frameworks, improved tooling, and AI-assisted workflows.

In this report, we present findings from the Developer Ecosystem Survey 2025. Alongside the numbers, you’ll also hear commentary from Brent Roose, JetBrains Developer Advocate for PHP, and insights from other community experts explaining what’s shaping PHP today and where the ecosystem is heading.

If you’d like to see what the ecosystem looked like just a year ago, check out the State of PHP 2024.

Participants

This year, we collected responses from 1,720 developers who indicated PHP as their main programming language, with the largest populations living in Japan, the United States, Russia, China, and France.

88% of PHP developers have more than three years of experience, with the largest single group falling in the six-to-ten-year range.

Team size and work environment

More than half of PHP developers (56%) work in small teams of two to seven people, while 12% work independently.

Language adoption and usage

The majority of PHP developers (58%) do not plan to migrate to other languages in the next year. For those who do, Go and Python are the most attractive alternatives.

The share of newcomers is slowly growing: 4% have been using PHP for less than six months (up from 2% last year), and 6% for less than one year. Still, almost three-quarters (72%) of developers report over four years of PHP usage, underlining the ecosystem’s maturity.

“Important to note is that these numbers aren’t talking about people leaving PHP – they are about adopting languages besides PHP. I think it’s great to see so many PHP developers who are adding other languages to their toolbelt. PHP has areas where it shines, but there are also problems that are better solved with languages like Go or Rust. Working together across those language barriers leads to great results.”

Brent Roose JetBrains Developer Advocate for PHP

“It’s great to see more newcomers in PHP. It’s not surprising given the amount of positive buzz around PHP for the past couple of years, but it’s nice to see the numbers proving this trend as well.”

Brent Roose JetBrains Developer Advocate for PHP

The trend toward modernization continues: PHP 8.x dominates with 89% usage, while PHP 7.x has dropped to 33%. Legacy versions (5.6 and earlier) are now down to 8%, though not entirely gone. Read Brent’s blog post for a more in-depth analysis of PHP versions’ usage.

“I think the open-source community plays a vital role in pushing the PHP community forward to adopt more secure and performant versions. The best part is that by using tools like Rector, upgrading becomes almost trivial. I speak from experience: The yearly upgrade is so well worth it.”

Brent Roose JetBrains Developer Advocate for PHP

PHP frameworks and CMSs

No major shifts occurred in framework adoption: Laravel continues to lead with 64% usage, followed by WordPress (25%) and Symfony (23%). Other frameworks like CodeIgniter, Yii, and CakePHP hold smaller but stable shares.

“We’re thrilled to see Laravel adoption continuing to grow, driven by innovations like Laravel Cloud and AI integrations such as Laravel Boost and MCP. Laravel remains focused on providing a comprehensive, modern full-stack solution that makes PHP development more productive and accessible than ever.”

Taylor Otwell Creator of Laravel

“Symfony contributors continue to push the boundaries of what can be expressed through type annotations, creating a virtuous cycle where codebases, static analyzers, and IDEs continuously improve to enhance developer experience and verifiability. Informal communication channels between all stakeholders make this progress even smoother and more efficient.”

Nicolas Grekas Core Developer at Symfony

PHP development environments

Most used IDE or editor

One of the most striking changes is in tooling: The share of those using either PhpStorm or IntelliJ IDEA with the PHP plugin has gone up by 10 percentage points, to 68%. Visual Studio Code’s share has dropped to 23%, while new players like Cursor (6%) have also entered the scene.

Satisfaction with coding tools

We also asked PHP developers how satisfied they are with their primary IDE. Among them, 53% of PhpStorm users gave their IDE the highest possible rating, compared to just 26% of VS Code users.

IDE or editor of choice per framework

PhpStorm dominates in Symfony (83%) and leads in Laravel (62%), while WordPress developers remain more split, with VS Code remaining a popular choice (37%).

Did you know Laravel support is now free for all PhpStorm users? This blog post has the full story.

Debugging and testing

When it comes to debugging, most developers still rely on var_dump-style approaches (59%), though debugger adoption (e.g. Xdebug) has risen slightly to 39%.

“Xdebug’s usage seems to be pretty stable throughout the years and across several surveys: between 30% and 35%. While I definitely still do my fair share of “dd” or “log” debugging, there are times where having a debugger at hand and knowing how to use it saves so much time. It’s a skill that takes practicing and doesn’t come overnight – which is why I made this short video to help folks get started with Xdebug.”

Brent Roose JetBrains Developer Advocate for PHP

PHPUnit (50%) remains the standard, but Pest adoption has gained four percentage points to reach 17%, showing momentum toward modern, developer-friendly testing frameworks.

“I’m super-happy to see more and more people choosing Pest as their go-to testing framework – the growth in this year’s survey really reflects the quality of our recent releases.

Since the survey, we’ve actually released Pest 4, which introduces test sharding, profanity checking, and the revolutionary browser testing. Having proper browser testing in the PHP world is truly a game-changer, so I expect adoption to increase even more next year!”

Nuno Maduro Creator of Pest

However, 32% of developers still don’t write tests at all, which highlights a persistent gap in testing culture.

Code quality tools

The clear winner in 2025 is PHPStan, which jumped to 36% usage, up nine percentage points from last year. Tools like PHP CS Fixer (30%) and PHP_CodeSniffer (22%) remain widely used, while Rector (10%) continues its steady rise. Still, 42% of respondents don’t use any code quality tools regularly, leaving room for further improvement.

💡Have you tried JetBrains Qodana? This static analysis and codebase auditing tool brings inspections from PhpStorm into your CI/CD pipeline, along with unique and custom code-quality and security checks. Use it to clean up and secure your team’s code before merging to the main branch.

Adoption of AI

AI has gone mainstream: 95% of developers have tried at least one AI tool, and 80% regularly use AI assistants or AI-powered editors.

ChatGPT leads daily use with 49%, though its share has dropped since 2024. GitHub Copilot (29%) and JetBrains AI Assistant (20%) follow, with the latter tripling its adoption since last year.

“AI is here to stay. It’s great to see the increased adoption of AI overall, and the drop in ChatGPT usage in favor of more specialized tooling. We can expect more of this moving forward, with new tools entering the scene, and the ones giving us the best boost earning their place in our daily stack.”

Ashley Hindle AI Engineer at Laravel

Looking ahead, 72% of respondents are likely to try AI coding agents in the next year, while only 8% say it’s unlikely.

To support developers in this shift, earlier this year JetBrains introduced an AI coding agent called Junie. Unlike other coding assistants, Junie is built to work directly with your JetBrains IDE, project context, and team practices, delivering actionable and trustworthy support. With AI agents rapidly becoming part of everyday workflows, Junie brings the reliability, integration, and developer focus you expect from JetBrains to this new wave of tools.

At the same time, not every company is ready to embrace AI yet. 11% respondents report that their organization is unlikely to try AI coding agents in the next 12 months. Apart from the data privacy and security concerns (44%) and intellectual property questions (24%), many companies also struggle with a lack of knowledge about such tools (22%).

Ecosystem highlights 2025

FrankenPHP

“One of my personal highlights in PHP this year is FrankenPHP becoming a project backed by the PHP Foundation. I think there’s a lot of potential for the project to become the de-facto standard runtime for PHP, which would be huge. FrankenPHP has a lot of performance optimizations that work out of the box for any PHP application, it’s portable across systems, and it has worker mode, which allows for asynchronous request handling in PHP, which can speed up applications by a factor of three compared to using PHP FPM.”

Brent Roose JetBrains Developer Advocate for PHP

Learn more about FrankenPHP from Kévin Dunglas on PHPverse 2025:

PHPverse

This year also marked a special milestone – PHP turned 30 years old. We celebrated with JetBrains PHPverse, an online birthday event that drew more than 26,000 viewers worldwide. If you missed it, don’t worry – the recordings are available to watch on demand:

Catch the next edition of PHPverse – sign up here to be the first to know when registration opens.

Get event updates

What this means for PHP

The 2025 results confirm that PHP remains a stable, professional, and evolving ecosystem. Its strong developer base, continued dominance of Laravel and WordPress, increasing adoption of modern tooling, and rapid embrace of AI-powered workflows show that PHP is far from being “legacy”.

Disclaimer: Despite all the measures we’ve taken to secure a representative pool of respondents, these results might be slightly skewed toward users of JetBrains products, as they might have been more likely to take the survey. Read more about our methodology.

Appending text to Obsidan via Shortcuts - Rob Allen

2025-10-14T10:00:00.000Z

Sometimes it's helpful to add some text to my current Obsidian daily note without having to switch to Obsidian, find the daily note and then type my text.

To do this, we can use the magic of Obsidian's obsidian:// URI schema and automate the text capture in Apple Shortcuts, with an assigned keyboard shortcut to activate it.

This is the Shortcut:

There's a number of steps in the Shortcut. Firstly we Ask For some text which will display a dialog box for us to type in. Then we Replace any trailing whitespace, add then use a Text action to prepend the current time as a third level heading. This is the text to be added, so we URL Encode it and use another Text action to create the full obsidian:// URI to be Opened.

The URI is:

obsidian://daily?vault=General&append=1&content={URL Encoded Text}

The daily endpoint only works if the Daily notes core plugin is enabled. We then need to specify which vault we're using. The content is the URL encoded text to be appended and the append parameter tells obsidian to place the text at the end of the note.

I've assigned it to ⌃⌥⌘= and pressing that key combination runs it for me.

Now I have a simple way to add some text to the current note without interrupting my context.

If this shortcut would be useful to you, you can download it here.

mac-volume: A CLI to control device volume - Rob Allen

2025-10-07T10:00:00.000Z

I've set my Mac up such that video calls such as Zoom use the microphone and earphones attached to my Behringer UMC204HD, which all other audio plays through the my normal speakers which are the default.

One issue I have with this is that it's quite hard to change the volume when a call as the volume buttons on the Mac are connected to the default output. This finally annoyed me enough that I looked into how to control the volume of a device and wrote a little command line utility for this, so that I could attach it to buttons on my StreamDeck using Keyboard Maestro.

Changing the volume

The way to control the volume on a Mac programmatically is to use Core Audio, specifically AudioObjectSetPropertyData(). This function takes a deviceID and some other properties, including volume. The deviceID is of type AudioDeviceID and the volume is a floating point number between 0 and 1.

It's not easy to remember device IDs, so I decided to use the device name instead and map the volume to between 0 and 100. This makes it easy to say set the volume to 10%:

mac-volume "MacBook Pro Speakers" set 10

To get the list of device names, I wrote a list-devices command. The list is available from AudioObjectGetPropertyData() which returns list of AudioDeviceID items. The name is in the kAudioObjectPropertyName selector, so that's easy enough.

The main trouble is that CoreAudio is a C API and so dealing with it from Swift involves use of references and UnsafeMutablePointer which is a bit hairy as it's been a while since I've had to worry about pointers!

Increment and decrement

While you can get the current volume, add to it and then set to increase the volume, it's easier to let the app do it, so mac-volume also supports incrementing and decrementing by an amount. These are the two command that I bind to StreamDeck keys.

I found that a step size of 3 was a good choice for raising/lowering the volume with a reasonable number of presses of the key.

It's on GitHub

If you need to control the volume of a non-default audio device from the command line, mac-volume is on GitHub at akrabat/mac-volume.

Moving PHP open source forward - PhpStorm : The IDE that empowers PHP developers | The JetBrains Blog

2025-10-02T09:10:34.000Z

At JetBrains, we want the PHP community to shine. First and foremost, we do this by building PhpStorm, the best IDE for PHP development; but we also support and help drive the PHP Foundation; have just organised PHPverse, accessible for everyone worldwide; and recently we made the Laravel Idea plugin free for all.

On top of that, we support open-source projects that we believe impact the PHP community or have the potential to do so, and which will benefit from our financial support.

Our support includes free PhpStorm licenses for active open source maintainers, but also financial sponsorships. With this blog post, we’d like to announce a new round of sponsorships, as well as a more structured approach towards new open source sponsorships in the future.

Sponsorships 2025-2026

Our strategy from now on is to sponsor around five open-source projects and maintainers per year. Each year we’ll select new projects to diversify our support.

Here are the people we’ll sponsor for the coming year:

Saif Eddin Gmati, who’s building a very promising new linter and static analyzer for PHP in Rust: Mago.
Markus Staab, who’s involved in tons of existing open-source projects like PHPStan, Rector, and PHPUnit.
Kyrian Obikwelu, who’s actively exploring AI and MCP possibilities in PHP.
Sjon Hortensius, who’s responsible for 3v4l.org, an online shell for PHP that’s very popular within the PHP community.

You may have noticed there’s still one spot open. Maybe you know just the right person or project to add to this list? Feel free to reach out to brent.roose@jetbrains.com with your suggestions, or leave a comment below this blog post!

Apart from sponsoring individual projects, we also stay committed to sponsoring the PHP Foundation, and encourage as many organizations to do so as well.

Sponsor PHP Foundation

Finally, because of this new yearly system, we also stopped sponsoring two projects we’ve supported for many years. Not because we don’t believe in them anymore, but because we want to make sure we can support as many different projects as possible over time. Maybe this is a good time to take a look if you or your company can pick up new sponsorships as well?

Derick Rethans, who’s working on Xdebug
Juliette Reinders Folmer, who’s working on CodeSniffer

We believe in the power of open-source. We want to support it and encourage you to do the same if you have the means to do so.

Let’s work together to make PHP even better!

Opening Slack Jira Cloud links in the right browser - Rob Allen

2025-09-30T10:00:00.000Z

I use OpenIn to open links in a given browser when I click on them in other applications. This is really helpful to keep various work related stuff in different browsers or profiles and I find it very helpful.

One thing that's bothered me is that links from the Jira Cloud Slack App ignore my OpenIn rules and always open in Safari and I finally sat down to work out why.

The investigation

I create a new OpenIn rule and enabled multiple browsers so that OpenIn would present a choice window to me.

It looks like this

At the bottom, we can see the link that OpenIn has received.

Even though the presented URL in the Slack app is https://my-client.atlassian.net/browser/PROJ-123, and if you right click and copy link, that's what you get in your clipboard, when you click on the link, you get a slack.com link.

Copying that link, it's of the form: https://slack.com/openid/connect/login_initiate_redirect?login_hint=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.blah.blah.

That's interesting! I've seen that eyJhbGci prefix often enough to know on sight that it's the start of base64 encoded JWT and sure enough, base64 decoding it proved that it was.

The format of JWT is {header}.{payload}.{signature} and it's unencrypted, so we can inspect the payload easily enough. This is redacted, but it's of the form:

{
  "aud" : "123456789.123456789",
  "auth_time" : 1758615553,
  "exp" : 1758619153,
  "https://slack.com/target_uri" : "https://{my-client}.atlassian.net/browse/PROJ-123",
  "https://slack.com/team_id" : "ABCDEFGHI",
  "https://slack.com/user_id" : "U01AB2CDEF3",
  "iat" : 1758615553,
  "iss" : "https://slack.com",
  "sub" : "rob@{my-client}.com"
}

We can see that the URL that we want to go to is in the payload's "https://slack.com/target_uri" property, so we just need to set up OpenIn to use that URL and pick the appropriate browser.

OpenIn's custom scripts

One really nice feature of OpenIn is that you can write custom scripts for a rule, so we can use this to extract the payload and pick the browser.

So I read the web page and wrote some Javascript!

The work we need to do is:

Extract the payload from the query parameter
JSON decode it
Read the target_uri
Choose browser based on target_uri

This needs a few helper functions

Helper functions

Extracting the payload is straightforward JS. We need the text between the two .s:

function extractJwtPayload(str) {
    const parts = str.split('.');
    return parts.length >= 3 ? parts[1] : '';
}

As OpenIn uses WebKit's JavaScriptCore, we can decode base64 using Uint8Array.fromBase64():

function base64Decode(str) {
    const uint8Array = Uint8Array.fromBase64(str);
    return String.fromCharCode(...uint8Array);
}

We also need to select the browser that we want the link to open in. This is done in OpenIn by setting all the "visible" browsers to false, except the one you want:

function selectBrowser(browser) {
    let apps = ctx.getApps()
    apps.forEach(function (app) {
        app.visible = (app.name == browser)
    })
}

Do the work

Having set everything up, we can now find the target_uri and choose the browser.

Firstly we only want to do this work if the source app is Slack and that we have a login_hint parameter:

if (ctx.getSourceApp().path.startsWith("/Applications/Slack.app") 
    && ctx.url.searchParams.has('login_hint')) {

Extracting the target_uri is a case of using the functions we've written:

const login_hint = ctx.url.searchParams.get('login_hint');
const jwtPayload = extractJwtPayload(login_hint);
const payload = base64Decode(jwtPayload).replace(/\0/g, '');
const data = JSON.parse(payload);
const target_uri = data['https://slack.com/target_uri'];

Note that I discovered some null bytes during testing, so removed them from the decoded string.

Now we set OpenIn's URI and select the browser we want:

// Set OpenIn's URL
ctx.url.href=target_uri;

// Select the browser
if (target_uri.includes("my-client-1")) {
    selectBrowser("Firefox");
    return;
}

if (target_uri.includes("my-client-2")) {
    selectBrowser("Firefox");
    return;
}

// Default to Safari
selectBrowser("Safari");
return;

and we're done.

That's it

That's it! Whenever I click on a Jira link in Slack, the correct browser opens directly to where I want to go.

The full script is here: openin-slack-app-link.js

Disabling the Zoom mini window on Linux - Blog entries :: mwop.net

2025-09-23T14:20:27.000Z

Zoom used to have a strange behavior, one I'm sure they thought would be useful, but in reality was infuriating: if you moved between virtual workspaces, Zoom would minimize to a thumbnail window that followed you around to workspaces.

At some point, it went away, thankfully... but after a recent release, it turned back on, and it's been a huge pain for me. There's a bug in that the mini window follows me to the initial virtual workspace, but then doesn't follow around from there, requiring me to use the workspace tools to move it to the workspace I want, and then re-maximize it, only to have to do the whole thing again if I switch screens.

The solution turns out to be relatively simple, if incredibly unintuitive.

Zoom does NOT have a GUI setting for this, for some reason. But evidently it creates the file $HOME/.config/zoomus.conf, which is where all configuration is stored.

This file is in INI format. Find the entry enableMiniWindow, and set it to false:

enableMiniWindow=false

Restart Zoom, and you're set.

Disabling the Zoom mini window on Linux was originally published 23 September 2025 on https://mwop.net by Matthew Weier O'Phinney.

Fixing PostgreSQL collation version mismatch - Rob Allen

2025-09-23T10:00:00.000Z

After pulling a new version of the Docker PostgreSQL container, I started getting this warning:

WARNING:  database "dev" has a collation version mismatch
DETAIL:  The database was created using collation version 2.36, but the operating system provides version 2.41.
HINT:  Rebuild all objects in this database that use the default collation and run ALTER DATABASE dev REFRESH COLLATION VERSION, or build PostgreSQL with the right library version.

This seems to have occurred because the underlying OS was changed to Trixie from Bullseye for the default image. i.e. I used:

image: postgres:17

Rather than:

image: postgres:17-bookworm

This is on my dev machine, so it's not a major problem as usually I can just blow away the database and recreate it. However, I have some test data that I don't want to lose quite yet, so I took a backup using pg_dump and then did this instead:

REINDEX DATABASE dev;
ALTER DATABASE dev REFRESH COLLATION VERSION;

The warning's now gone.

Of course, in production, you'll want to be a bit more careful and a pg_dump and load is more likely to avoid any risks of corruption. As ever, YMMV.

Jumping to the end of bash's history - Rob Allen

2025-09-16T10:00:00.000Z

I use bash's history all the time, via ctrl+r and also with the up and down keys; it's wonderful.

Sometimes, I want to get back to the end of my history and I recently discovered that there's a shortcut for this: meta+>. It doesn't matter where you are in your history, pressing meta+> jumps you to the end and you have a blank prompt again.

I use iTerm2 on my Mac and have my right hand option key set to meta. This is done in Settings→Profiles→Keys, setting "Right Option (C) key:" to "Esc+".

However, to press meta+>, I need to do right-option+shift+. which isn't as easy as right-option+., so let's rebind!

To rebind, I looked up the bash command for this functionality (`end-of-history`), and then added this to my .bashrc:

bind '"\e.": end-of-history'

All done. Now I just press right-option+. and I'm back at the end of history as if I'd never navigated it.

Understanding All Relations Between Classes, Interfaces, Traits, and Enums in PHP - Exakat

2025-09-15T20:29:11.000Z

Understanding Relationships Between Classes, Interfaces, Traits, and Enums in PHP

Modern PHP offers four major code structures — classes, interfaces, traits, and enums — each with its own purpose and rules. But the real power of PHP comes from how these structures can interact with each other. This page gathers all relations between classes in PHP.

If you’ve ever wondered “Can an enum use a trait?” or “Can a trait implement an interface?”, the answer lies in PHP’s keywords: extends, implements, and use. These keywords define the legal relationships between the building blocks of your code.

To make this crystal clear, here’s a matrix showing who can interact with whom — and with which keyword.

Can interact with…	class	interface	trait	enum
class	extends one class(single inheritance); Or composition	extends one or multiple interface	use one or multiple traits	Cannot extend an enum (no inheritance), can only call its cases
interface	Cannot extend a class	extends one or multiple interfaces	Cannot use a trait	Cannot implement or extend an enum
trait	Cannot extend a class	Cannot implement an interface	useother traitsinside a trait	Cannot use an enum
enum	Cannot extend a class	implementsone or multiple interfaces	use one or multiple traits	Cannot extend another enum

Key Takeaways

Classes are the most versatile: they can extend a class, implement interfaces, and use traits.
Interfaces can only extend other interfaces — nothing else.
Traits are like reusable code fragments. They can be used in classes and enums and even use other traits, but cannot stand alone.
Enums (introduced in PHP 8.1) behave like special classes: they cannot extend other classes or enums, but they can implement interfaces and use traits.

The post Understanding All Relations Between Classes, Interfaces, Traits, and Enums in PHP appeared first on Exakat.

Converting JWKS JSON to PEM using Python - Rob Allen

2025-09-09T10:00:00.000Z

Following on from my earlier exploration of JWKS (RFC7517), I found myself needing to convert the JWKS into PEM format.

This time I turned to Python with my preference of using uv with inline script metadata and created jwks-to-pem.py.

The really nice thing about inline script metadata is that we can use the cryptography package to do all the hard work with RSA and serialisation. We just have to remember that the base64 encoded values are base64 URL encoded and account for it.

As a single file python script, I make it executable with chmod +x jwks-to-pem.py and made it so that I can pipe the output of a curl call to it, or pass in a JSON file. I prefer to use the curl solution though with:

curl -s https://example.com/.well-known/jwks.json | jwks-to-pem.py

Example

Here's an example from the University of Cambridge.

On the day I wrote this article, the JWKS looks like this:

$ curl -s https://api.apps.cam.ac.uk/oauth2/v1/.well-known/jwks.json
{
  "keys": [
    {
      "alg": "RS256",
      "e": "AQAB",
      "n": "6kKjjctVPalX0ypJ2irwog8xIXS9JTABqrSnK_n3YJ4q0aH2-1bjGbWz8p1CaCUqDxQSDuqzvOgMdNGvZrxlNJ-G8hfc39jrb_KnB0T3ZsuxFz6X0mDzmHhdiPjSDK3M0syC4qg5_PB7xwKail5VWOcY0SypIYCPD6Ct5DGnQ_XONGXIVG7eaJAHdxJp2BOz0n3BVEFnZUgM5JcfGrSFfGqb0ZotX2AblwjZKQc58E0EVVykJw8gxW1Bob8rbaVXlMHssfY-9Jx0zua7ZrjO5C4OMmt9J6zYbVnGVwf62ehGtcLSP6iCG4_XM2sAMQwqJnPBss0U9WwDERk17FMHvb_FBwxAFxRygd0DclWmQmCYr5uFYck57KGARtyoxrNNAf4AFUHuObjbV24TyInYEgMhKi3SAML_4ke3dbbG-mjchXPN9OqNd4fydnQIP39WFHmFNk_nIlqvYnALI4xPE-w09T9jCvjU8hYHHlVMRvRluBnUzJkFnxLse5W-agC6ITe3wYvKH7SHVp6MYQWVD_0I2rCLV4gqjSpXzKIMs5eejjTQQq0VYumgL_f1ETvzDoewzXLOC8GGu2LZDwDbP0ea6DchReWjZfj4nJx23uQyGAj1h_uPI1jCd9oeJhbN8jFz2ltYgXYBp51qdSzsbtdec9BPPBVeXjI--c0AWU8",
      "kid": "70e0ed3c",
      "kty": "RSA",
      "use": "sig"
    }
  ]
}

They very kindly pretty-print it too!

We can then get the PEM version by piping to jwks-to-pem.py:

$ curl -s https://api.apps.cam.ac.uk/oauth2/v1/.well-known/jwks.json | jwks-to-pem.py
# Key 0 (kid: 70e0ed3c)
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA6kKjjctVPalX0ypJ2irw
og8xIXS9JTABqrSnK/n3YJ4q0aH2+1bjGbWz8p1CaCUqDxQSDuqzvOgMdNGvZrxl
NJ+G8hfc39jrb/KnB0T3ZsuxFz6X0mDzmHhdiPjSDK3M0syC4qg5/PB7xwKail5V
WOcY0SypIYCPD6Ct5DGnQ/XONGXIVG7eaJAHdxJp2BOz0n3BVEFnZUgM5JcfGrSF
fGqb0ZotX2AblwjZKQc58E0EVVykJw8gxW1Bob8rbaVXlMHssfY+9Jx0zua7ZrjO
5C4OMmt9J6zYbVnGVwf62ehGtcLSP6iCG4/XM2sAMQwqJnPBss0U9WwDERk17FMH
vb/FBwxAFxRygd0DclWmQmCYr5uFYck57KGARtyoxrNNAf4AFUHuObjbV24TyInY
EgMhKi3SAML/4ke3dbbG+mjchXPN9OqNd4fydnQIP39WFHmFNk/nIlqvYnALI4xP
E+w09T9jCvjU8hYHHlVMRvRluBnUzJkFnxLse5W+agC6ITe3wYvKH7SHVp6MYQWV
D/0I2rCLV4gqjSpXzKIMs5eejjTQQq0VYumgL/f1ETvzDoewzXLOC8GGu2LZDwDb
P0ea6DchReWjZfj4nJx23uQyGAj1h/uPI1jCd9oeJhbN8jFz2ltYgXYBp51qdSzs
btdec9BPPBVeXjI++c0AWU8CAwEAAQ==
-----END PUBLIC KEY-----

The script

This is the script in case anyone else finds it useful:

#!/usr/bin/env -S uv run --script --quiet
# /// script
# dependencies = [
#   "cryptography",
# ]
# ///

"""Convert JWK keys to PEM format.

This script reads .well-known/jwks.json and outputs PEM encoded versions
of the public keys in that file.

Usage:
    curl -s https://example.com/.well-known/jwks.json | jwks-to-pem.py
    uv run jwks-to-pem.py jwks.json
    uv run jwks-to-pem.py < jwks.json

Requirements:
    - uv (https://github.com/astral-sh/uv)
    - cryptography library

Author:
    Rob Allen 
    Copyright 2025

License:
    MIT License - https://opensource.org/licenses/MIT
"""

import json
import base64
import sys
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa

def base64url_decode(data):
    """Decode base64url to bytes"""
    # Add padding if needed
    padding = 4 - len(data) % 4
    if padding != 4:
        data += '=' * padding

    # Replace URL-safe chars
    data = data.replace('-', '+').replace('_', '/')

    # Decode
    return base64.b64decode(data)

def jwk_to_pem(jwk_key):
    """Convert JWK to PEM format"""
    if jwk_key['kty'] != 'RSA':
        raise ValueError("Only RSA keys are supported")

    # Decode the modulus (n) and exponent (e) to int
    n = int.from_bytes(base64url_decode(jwk_key['n']), 'big')
    e = int.from_bytes(base64url_decode(jwk_key['e']), 'big')

    # Create RSA public key
    public_key = rsa.RSAPublicNumbers(e, n).public_key()

    # Serialize to PEM
    pem = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    return pem.decode()

def main():
    if len(sys.argv) > 2:
        print("Usage: jwk_to_pem.py [jwks.json]")
        print("If no file is provided, reads from stdin")
        sys.exit(1)

    if len(sys.argv) == 2 and sys.argv[1] != '-':
        # Read from file
        with open(sys.argv[1], 'r') as f:
            jwks = json.load(f)
    else:
        # Read from stdin
        jwks = json.load(sys.stdin)

    # Convert each key
    for i, key in enumerate(jwks['keys']):
        kid = key.get('kid', f'key-{i}')
        print(f"# Key {i} (kid: {kid})")
        print(jwk_to_pem(key))

if __name__ == "__main__":
    main()

Connect MCP Servers to Junie in PhpStorm - PhpStorm : The IDE that empowers PHP developers | The JetBrains Blog

2025-09-05T14:47:16.000Z

The Model Context Protocol (MCP) is an open standard introduced by Anthropic. Think of it as a USB-C port for AI: a consistent way to plug the AI models your AI agent uses into specific tools and data sources.

You can connect Junie, the AI coding agent by JetBrains, to a wide variety of officially provided or community built MCP servers, or build your own MCP server using one of the available SDKs – including the brand-new MCP PHP SDK.

About MCP PHP SDK

MCP SDKs are lightweight frameworks that handle the protocol details so that developers can focus on the application functionality that AI agents will use.

MCP PHP SDK is the official MCP SDK built as a joint effort by the PHP Foundation, Anthropic’s MCP team, and Symfony. The goal of the project is to provide a framework-agnostic, production-ready reference implementation the PHP ecosystem can rely on. For details about using MCP PHP SDK or contributing to it, see modelcontextprotocol/php-sdk.

Junie + MCP

Whether you are building your own MCP server or using an existing one, here’s how to make it work with the Junie AI agent in PhpStorm:

Make sure that the MCP server can be accessed and started.
The specific way of starting an MCP server depends on this server’s implementation – please refer to the MCP server documentation for instructions.
Configure Junie in PhpStorm to connect.
To add the MCP server to Junie, press ⇧Shift twice to open the search window and search for “MCP Settings”. On the MCP Settings page, you can see the list of connected servers and add or edit JSON configurations for the MCP servers in the ~/.junie/mcp.json file.

To configure an MCP server at the project level, manually add an mcp.json file with your desired server configurations to the .junie/mcp folder in the project root.

To view the list of actions that Junie can perform through a configured MCP server, locate the server in the MCP Settings list and expand the Status drop-down list.

For example, with the Laravel Boost MCP server, Junie gets useful tools for working with Laravel projects, such as listing Artisan commands, routes, or config files, reading logs, querying the database, or searching versioned documentation.

This is where MCP shines: It bridges the gap between LLMs and dynamic, framework- and project-specific context and data.
Start using new commands and context inside your IDE.
When running a prompt, Junie analyzes what commands registered with the configured MCP servers are relevant, and executes them through the respective MCP server.

The Junie coding agent keeps evolving. Join the conversation in our Junie Discord community and help shape what’s next for Junie.

New chapter for MCP servers in PHP

While you could use any SDK implementation to create MCP servers for PHP projects, the official MCP PHP SDK boosts the contribution of the PHP community into the AI ecosystem, both within the PHP realm and beyond.

The PHP SDK maintainers encourage PHP developers to submit their MCP integrations for PHP frameworks and tools – Laravel, Symfony, WordPress, custom APIs, and more – to be listed in the SDK GitHub repo.

Stop in-place editing of bash history items - Rob Allen

2025-09-02T10:00:00.000Z

Recently, since getting a new computer, I've noticed that I've been losing bash history items and it took a while to work out what was going on, though I'm still not completely sure as it never seemed to be so much of a problem.

I regularly use the up and down keys with context specific history. For example, I will type ma and then press up to search back through all the make commands I've used recently and then press enter to run it.

Sometimes, I'll realise that I don't actually want this command and edit it and press enter. Sometimes I'll decide halfway through editing that really I should use a docker compose command instead and I'll just back out of my edit via some key stroke that works. I'm not sure what I do here though, probably up/down, or maybe ctrl+c. Whatever I do, sometimes, the history for that line is now my edited mess and not the original command. Then later, when I go to try and find it via the up arrow, it's missing.

This happened infrequently enough that I thought I was misremembering what was in the history, or that maybe it was another tab I was thinking about.

I never want the bash history to be editable; if I cancel out, then I want it back to what it was.

Fixing with revert-all-at-newline

This finally annoyed me enough that I sat down with the Internet to work out how to fix it with the revert-all-at-newline setting.

The revert-all-at-newline option in bash controls whether readline reverts any changes made to a history line when you press Enter. Note that this is part of readline's behavior, so it affects command line editing in bash and other programs that use readline.

The simplest thing is to add this to .bashrc:

bind 'set revert-all-at-newline on'

Alternatively, you can create a .inputrc file with this in it:

$include /etc/inputrc
set revert-all-at-newline on

To view the current value of revert-all-at-newline, use:

bind -V | grep revert-all-at-newline

It solved my problem, and I've not yet found a case when I want it set the other way.

Extending an OpenAPI Component Schema - Rob Allen

2025-08-26T10:00:00.000Z

One project that I'm working on uses RFC 9457 Problem Details for HTTP APIs for its error responses.

In the OpenAPI spec, we can define this as a component and use in the relevant paths as appropriate:

components:
  schemas:
    ProblemDetails:
      type: object
      properties:
        type:
          type: string
          format: uri-reference
          description: A URI reference that identifies the problem type
          default: about:blank
          example: https://example.com/probs/out-of-credit
        title:
          type: string
          description: A short, human-readable summary of the problem type
          example: You do not have enough credit.
        status:
          type: integer
          format: int32
          description: The HTTP status code for this occurrence of the problem
          minimum: 100
          maximum: 599
          example: 403
        detail:
          type: string
          description: A human-readable explanation specific to this occurrence of the problem
          example: Your current balance is 30, but that costs 50.
        instance:
          type: string
          format: uri-reference
          description: A URI reference that identifies the specific occurrence of the problem
          example: /account/12345/msgs/abc
      additionalProperties: true

When we return a validation error, we add an errors property. Rather than repeating the ProblemDetails properties into ValidationError, we can add the errors using allOf:

    ValidationError:
      allOf:
        - $ref: '#/components/schemas/ProblemDetails'
        - type: object
          properties:
            errors:
              type: object
              description: Field-specific validation error messages
              additionalProperties:
                type: string
              example:
                name: "name must be provided"
                dateOfBirth: "date must be in the past"

This is quite handy!

Saving the current URL to a Note - Rob Allen

2025-08-19T10:00:00.000Z

Inspired by John Gruber mentioning on the Cortex podcast that he has a shortcut that saves links to a note in Tot, I thought I'd do something similar for saving to a note in Apple Notes.

I want to store as a bullet item containing the name of the page, the link and the date. Something like this:

(Funny that the spellchecker doesn't know that Thu is the short form for Thursday)

The Save Links to Notes Shortcut

This is the shortcut that I created to do it:

You can download it here:
https://www.icloud.com/shortcuts/6c12e888f9da431d9977985b229d636b

Breaking down the actions

To get the URL into the shortcut, we want:

Show in Share Sheet so that it's available on iOS/iPadOS
Receive What's Onscreen so that when a browser is focussed on Mac, it finds the URL
Use as a Quick Action so that we can assign a keyboard shortcut (⌃⌥⌘U in case)

We can then use Get Contents of web page along with Get Details of Safari Web Page to get the pages's title which Shortcuts calls Name for some reason.

There's an action for Current Date, so we add that to get the variable.

Creating formatted text in a note is a little involved. Firstly we use a Text action to set out the Markdown that we want. I used the date format EEE, dd MMM yyyy as it's short and clear to me.

There's a Make Rich Text from Markdown action which processes the Markdown for us, but if you just append it to the note, it doesn't work. The workaround is to add it to a List action and then append the list to the note.

That's it

All we need to do now is show a notification including the Shortcut Input variable as that's the URL that we've just saved.

With this shortcut, I can add a new entry to my note from both my Mac, iPad and iPhone with minimal effort.

I like it.

Accessing Longplay info for SwiftBar - Rob Allen

2025-08-12T10:00:00.000Z

One app that I find incredibly useful is SwiftBar and one use I have is to display track info for the currently playing song in Apple Music.

SwiftBar plugins work as shell scripts that execute on a timer and echo specially formatted text which SwiftBar then turns into an item on the menu bar with an attached menu

I use a heavily modified Now Playing plugin that was originally written by Adam Kenyon, so all the hard work was done by them.

Recently, I've been using Longplay to play albums and wanted the same functionality.

Now Playing uses AppleScript to determine if a music player is playing and what the track info is:

app_playing=$(osascript -e "tell application \"$i\" to player state as string")

And

track=$(osascript -e "tell application \"$app\" to name of current track")
artist=$(osascript -e "tell application \"$app\" to artist of current track")

When looking at adding Longplay, I was pleased to discover that it has AppleScript support, but perusing the Dictionary, I discovered that it doesn't support the features I need here.

Upon emailing the developer, they very helpfully pointed out that Longplay also has Shortcuts support and that I could probably use that instead. They were right.

I knocked up a couple of shortcuts:

and

With these set-up, I can now run them from the command line using shortcuts:

app_playing=$(shortcuts run "Longplay status");

This will set $app_playing to either "Yes" or "No" as strings as it is defined as boolean in Shortcuts.

track=$(shortcuts run "Longplay now playing");

This simply sets $track to the string of the currently playing track.

Updated Now Playing script

With the ability to get the info I needed from the command line, I ~~hacked~~ updated my copy of the Now Playing script and all is good.

I've updated it a bit over the years, so I've uploaded my version to Gist: nowplaying.5s.sh.

PhpStorm 2025.2 Is Now Available - PhpStorm : The IDE that empowers PHP developers | The JetBrains Blog

2025-08-05T13:45:17.000Z

Along with making Laravel Idea part of PhpStorm, this release brings improvements to the remote development experience, JetBrains AI tools, and more.

Download PhpStorm 2025.2

Junie coding agent

MCP support

Support for the Model Context Protocol (MCP) allows you to connect Junie to external sources like databases, file systems, and APIs. You can now add or edit the configuration for MCP servers at a global or project level in the IDE settings (Tools | Junie | MCP Settings).

WSL 2 support

Junie can now work with projects that are located under the WSL 2 file system (\\wsl$\... or \\wsl.localhost\.. ) and opened in PhpStorm directly (via File | Open).

Remote development with Junie

With support for remote development environments, you can use the Junie plugin even if the IDE’s backend is running on a remote host.

30% speed increase

Junie can execute simple assignments, but it really shines when handling more complicated tasks, now with an up to 30% increase in prompt processing speed.

Use Code mode to let Junie work on tasks autonomously, or switch to Ask mode to brainstorm about new features or solutions without making changes to your codebase.

Try Junie

Junie on GitHub EAP

We are excited to announce the opening of the EAP program for Junie on GitHub!

Triggered from GitHub issues or issue comments, the Junie agent on GitHub has increased processing power and can handle multiple tasks simultaneously and without requiring the user to open the IDE.

Join the waitlist

AI Assistant

JetBrains AI Assistant has also got a major upgrade. Whether you’re working online or offline, AI Assistant is now more capable, more flexible, and still free to use.

All JetBrains AI features are available for free, with unlimited code completion, powerful local workflows, and limited cloud-based features.

Here’s what’s new:

Smarter completion across all supported languages, now with support for SQL, YAML, JSON, Markdown, and more.

Expanded offline flexibility – connect any OpenAI-compatible model server like llama.cpp or LiteLLM.
Project rules that give you the option to instruct AI to comply with your team’s coding conventions and business logic.

Get started

PHP

Remote development in PhpStorm, now out of Beta

PhpStorm’s remote development functionality is out of Beta in version 2025.2, which means the experience of working with remotely hosted PhpStorm projects is steadily approaching that of working with source code locally. The removal of the Beta label comes along with quality improvements to:

Remote editing.
Debugger performance.
Tool windows and dialogs, including the terminal, the VSC widget, Search Everywhere, and Find in Files.
Support for Windows host machines via the JetBrains Toolbox App.

Reworked PHP Include Path dialog

In PhpStorm 2025.2, we’ve reworked the Include Path settings dialog to make it easier to exclude PHP library folders from indexing by improving navigation and search.

Despite being excluded from error checks, PHP libraries are still indexed. On the Include Path settings page, you can exclude specific folders within PHP libraries from indexing.

Now the Include Path list shows only parent directories by default, and to exclude a specific child directory from indexing, you need to select its parent in the list and click the Exclude Under This Path icon on the toolbar.

PHPUnit 12 support

PhpStorm 2025.2 supports all the changes and deprecations introduced in PHPUnit 12. The IDE’s warnings and inspections will help you seamlessly upgrade projects to the latest version of the testing framework.

Other improvements

The PHP Architecture and Robo Support plugins are now unbundled, meaning they are no longer shipped with PhpStorm out of the box. If you need project architecture inspections or the functionality of the Robo task runner, you can install these plugins from JetBrains Marketplace.

The class-string<T> type inference now properly displays the expected inferred type.

PhpStorm 2025.2 further improves the .env file support with reference-aware renaming of nested variables.

Configuration options for PhpStorm’s built-in server, the always-running web server for static content like JavaScript, CSS, and HTML, have been moved to Tools | Web Browsers and Preview in the IDE settings.

JavaScript and TypeScript

Experimental TypeScript-Go language server support

PhpStorm 2025.2 introduces experimental support for the new TypeScript-Go language server, bringing improved performance and modern architecture for TypeScript development.
You can enable it in your project by installing the @typescript/native-preview package as a dependency in place of typescript.

Baseline support

PhpStorm 2025.2 now displays Web Platform Baseline information directly in quick documentation.When you hover over a web platform API, you’ll see details about when the feature became reliably available across major browsers, based on web.dev’s Baseline data.

Bun improvements

PhpStorm 2025.2 introduces smarter integration for Bun. When a bun.lockb or bun.lock file is present in your project, PhpStorm will automatically detect Bun and set it as the package manager. All relevant actions, such as running bun install, using context menu options for package.json, and resolving dependency suggestions, will default to Bun.

User experience

Parameter Info popup improvements

PhpStorm 2025.2 introduces several improvements that make the Parameter Info popup easier to read and navigate.

Databases

Ability to attach database objects to the AI chat

The database context you provide to the AI Assistant’s chat can now be more specific. Previously, only the whole schema could be attached. Now, you can attach the database object you need to work with – for example, a table or a view.
To attach a database object, type @ or # in the input field, select or type dbObject:, then select the object you want to attach from the list.

[SQLite] WSL database file path

PhpStorm now supports WSL file paths for SQLite database files.
This means that you can now access your SQLite database in WSL and work with it without the database file being locked for you. To do this, go to the Data Sources and Drivers dialog and use the following file path format: \\wsl$\<os>\home\<username>\<database_file_name>.sqlite. For example, \\wsl.localhost\Ubuntu-24.04\home\john.smith\identifier.sqlite.

Responding to StreamDeck buttons with Keyboard Maestro - Rob Allen

2025-08-05T10:00:00.000Z

I run Apple Music on my Mac desktop and send the output to my HomePod minis. To control the volume, you need to manipulate the Apple Music volume slider rather than the global volume controls for the Mac.

It's easier to press buttons than use a mouse, so I used Keyboard Maestro to respond to two buttons on my Stream Deck instead.

This is possible because Keyboard Maestro has a Stream Deck Plugin, so you need to install that first.

Setting up the Stream Deck button

You can now assign Keyboard Maestro to a button in the Stream Deck software:

This is the configuration for my volume down button, as you can tell by the icon I chose. The Button ID defaults to the row and column number of where you have placed it on the Stream Deck.

Responding to the button in Keyboard Maestro

On the Keyboard Maestro side, we need a macro that is trigged by the Stream Deck button. This is easy to do as it looks like a USB device key and you can press the button the Stream Deck and Keyboard Maestro will recognise it and fill in the correct details.

Upon clicking the button, we simply run some AppleScript to control the Music app's volume.

That's it

That's all there is to responding to a button on the Stream Deck on a Mac. In this case, I'm using AppleScript, but Keyboard Maestro lets you do practically anything on the computer!

The Laravel Idea Plugin is Now Free for PhpStorm Users - PhpStorm : The IDE that empowers PHP developers | The JetBrains Blog

2025-07-30T16:53:03.000Z

Starting July 30, 2025, we’re making Laravel Idea free for PhpStorm users. If you already have the Laravel Idea plugin installed, you get full access to all plugin features at no extra cost.

Laravel Idea is the smartest Laravel development environment based on PhpStorm. Developed by Adel Faizrakhmanov, the plugin has 1.5M+ downloads from JetBrains Marketplace and is highly appreciated by Laravel developers. It extends PhpStorm’s built-in Laravel support with a variety of developer productivity features, including:

Powerful code generation.
Advanced routing, validation, request fields, gates and policies, configs, translations, views, and a lot of other completion features.
Excellent understanding of the Eloquent ORM.
Full Blade component support.
Support for Livewire, Inertia.js, Dusk, Laravel modules, and other third-party packages.

“When I started Laravel Idea, I couldn’t even dream that it would be included in PhpStorm! And now… It’s happening! I’m very happy that it has become more accessible for Laravel developers.

My team and I will continue working on Laravel Idea the same way as before. Besides that, we will work closely with the PhpStorm team on many features, like AI, native support for Laravel magic, etc.”

Adel Faizrakhmanov Creator of Laravel Idea

To install the Laravel Idea plugin in PhpStorm, go to Settings | Plugins and search for the plugin in the Marketplace tab.

After installation, you can configure the plugin settings via Settings | Languages & Frameworks | Laravel Idea.

Why PhpStorm IDE for Laravel development?

PhpStorm is recommended by Laravel for working on Laravel projects. Besides the Laravel Idea plugin, PhpStorm provides Laravel developers with loads of developer productivity features out of the box, including:

Junie, your AI coding agent by JetBrains for professional tasks.
Built-in support for Laravel Pint, Pest, Larastan, and Artisan CLI commands.
Syntax highlighting and code completion in Blade templates and .env files.
IDE support for JavaScript/TypeScript frameworks, including Tailwind, Vue, and React, and databases.
Best-in-class tools for code navigation and refactoring.

The Laravel Idea plugin will eventually be bundled with PhpStorm and available to the IDE users out of the box.

“I’m really excited that full Laravel support is now more accessible than ever for our users. We’ve worked hard to make PhpStorm the best IDE for Laravel development, and making Laravel Idea available for free is a big step forward.”

Artemy Pestretsov Product Leader at PhpStorm

Learn more about Laravel support in PhpStorm on our website.

FAQ

I have an IntelliJ Ultimate subscription, do I also get the Laravel Idea plugin for free?

Yes, the Laravel Idea plugin is now also available to IntelliJ Ultimate users for free.

Is there any compensation for already purchased Laravel Idea licenses?

Individual PhpStorm users who purchased a monthly or yearly personal Laravel Idea license on May 1, 2025, or later are eligible for compensation in the form of a 50% discount on the next renewal of their personal PhpStorm subscription. This compensatory discount will be applied in your JetBrains Account automatically at the billing date of the next subscription renewal.

Why aren’t all active Laravel Idea subscriptions eligible for compensation?

May 1, 2025, marks the date we internally decided to make the Laravel Idea plugin part of PhpStorm and started working on it. We believe it’s fair to provide compensation to the users who purchased licenses after that date, as we had not announced this decision publicly at that time. Users who purchased the yearly license before did so when we were still operating under the third-party plugin business terms.

Can I get a refund for my Laravel Idea purchase?

Yes, you can apply for a refund. To do so, please contact our Sales team and send us the order reference number, invoice number, or other purchase-related information. For more information about refunds, see the Licensing and Purchasing FAQ page.

My licensing case is not addressed in this FAQ. What should I do?

Please contact our Support team at phpstorm-support@jetbrains.com and provide the details of your case.

Step-debugging Docker Compose NestJS services - Rob Allen

2025-07-29T10:00:00.000Z

I'm working on a NestJS project that uses monorepo mode. It consists of a number of separate microservice applications that each have their own Docker container that are managed in development using Docker Compose.

I like step-debugging in my IDE and so needed to set it up for this application. This is what I did.

The application setup

Each service in our project has its own container in docker-compose.yaml and we use a reverse proxy to have a single endpoint that routes requests to the correct microservice. Each custom Dockerfile runs ppm run start:dev:{service name}> which is defined in package.json like this:

"start:dev:service1": "nest start service1 --watch --tsc --watchOptions.poll=1000 --preserveWatchOutput",

Using --watchOptions.poll=1000 is just more reliable when running in Docker with volumes mounted into the container. We also set the --preserveWatchOutput flag to ensure that the service doesn't take control of the terminal as this is unhelpful when you have multiple services in play.

Set the apps up for debugging

We need to make some modification for step debugging. Firstly, I created a set of start:debug:{service name} scripts in package.json that look like this:

"start:debug:service1": "nest start service1 --debug 0.0.0.0:9229 --watch --tsc --watchOptions.poll=1000 --preserveWatchOutput",

We enabled the --debug flag to enable node's --inspect flag so that port 9229 is available to the debugger. However, buy default this is bound to 127.0.0.1 which is not useful in a container, so we bind to 0.0.0.0:9229 so that it's available outside the container.

Next, we need to our new start:debug:{service name} scripts and expose port 92229 to our local environment for each service. We do this in docker-compose.override.yaml:

services:
  service1:
    ports:
      - "9230:9229"
    command: pnpm run start:debug:service1

  service2:
    ports:
      - "9231:9229"
    command: pnpm run start:debug:service2

I don't tend to like binding to the default port as that invariably confuses me when I run some test thing locally, so I've picked ports starting from 9230 onwards for my services.

Running docker compose up will now start the containers.

Debugging in WebStorm

To set up WebStorm for step debugging, create a Run/Debug configuration entry of type Attach to Node.js/Chrome for each container.

The settings for service1 are:

Name: Debug service1
Host: localhost
Port: 9230

For the other services, change the name and port.

From the Debugging dropdown at in the title bar select the service and press the green "bug" button. You'll see a "Debugger attached." message in the Docker logs.

Attach a breakpoint and access the endpoint using curl or another HTTP client and the IDE should stop execution at the breakpoint.

Debugging in VS Code

To set up VS Code for step debugging, create a .vscode/launch.json file in your project. It should look like this:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug service1",
      "type": "node",
      "request": "attach",
      "port": 9230,
      "address": "localhost",
      "localRoot": "${workspaceFolder}",
      "remoteRoot": "/usr/src/app",
      "restart": true
    },
    {
      "name": "Debug service2",
      "type": "node",
      "request": "attach",
      "port": 9231,
      "address": "localhost",
      "localRoot": "${workspaceFolder}",
      "remoteRoot": "/usr/src/app",
      "restart": true
    }
  ]
}

Set remoteRoot to the directory within the Docker container where the project is mounted.

Start debugging by selecting the Run and Debug pane in the left hand toolbar and choose the service from the dropdown at the top. Then press the green Start debugging button (or press F5).You'll see a "Debugger attached." message in the Docker logs.

Attach a breakpoint and access the endpoint using curl or another HTTP client and the IDE should stop execution at the breakpoint.

That's it

Having done this, I can now enjoy step debugging this new-to-me codebase and understand what it does!

QuickSS: Screenshot the active window on Mac - Rob Allen

2025-07-22T09:00:00.000Z

Back in 2016, I wrote about using QuickGrab to take a screenshot of the active window via a single key press with no mouse use required.

It's now 2025 and I'm still using this and Apple has announced that Rosetta 2 will be phased out in a couple of years. As QuickGrab is one of the few Intel-only apps I still use, I thought I'd recompile for Apple Silicon and it was then that I ran into trouble:

$ gcc -framework cocoa -x objective-c -o quickgrab quickgrab.m
quickgrab.m:92:26: error: 'CGWindowListCreateImage' is unavailable:
obsoleted in macOS 15.0 - Please use ScreenCaptureKit instead.

Obsoleted in macOS 15.0 isn't something you want to see! The APIs that QuickGrab use are no longer part of the SDK and so it cannot be compiled. Hence I decided to replace it with a Swift version and also take the opportunity to add additional features that I wanted.

While on holiday, I wrote QuickSS. I spent some time playing around with ScreenCaptureKit, but couldn't get it to replicate the window shadows that the standard screenshot tool on shift+cmd+4 does. To solve this I decided to use screencapture to take the screenshot which is provided by macOS.

Screenshot to file

To save a screenshot of the active window directly to a file, just run quickss. You probably want to select cmd+tab to a different window, so prefix with sleep:

rob@Caledonia QuickGrab (master *) $ sleep 3; quickss 
Capturing window ID: 5940 [Safari: 'Rob Allen – Pragmatism in the real world']
Screenshot saved to: /Users/rob/Downloads/Screenshot 2025-07-22 at 11.00.00.png

As it's my app, I made some changes to match the way I work with it. Firstly it defaults to saving the file to the Downloads folder and names it the same as the default screenshot utility. You can use --file to override this should you need to and --quiet will output just the filename which is useful for onward scripting, or displaying in notifications.

Screenshot directly to clipboard

I also added the ability to put the screenshot directly onto the clipboard with --clipboard

$ sleep 3; quickss --clipboard
Capturing window ID: 5940 [Safari: 'Rob Allen – Pragmatism in the real world']
Screenshot copied to clipboard

I can now paste directly into Slack/Discord/Messages/Messenger/WhatsApp/Signal/etc. (Yes, there are far too many of these services nowadays!)

Keyboard shortcut

Obviously, the best way to run this is to use global keyboard shortcuts. My preference is to use ⌃⌥⌘4 to put the screenshot onto the clipboard and ⇧⌃⌥⌘4 to save it to file.

Using Shortcuts.app

You can use the Shortcuts app for this and create a shortcut for copying to clipboard like this:

The equivalent for saving to file is the same, except that you don't need the --clipboard parameter.

Using Alfred

I use Alfred for these sort of things, so I wrote a Workflow to do this based on the previous one:

It's downloadable from the QuickSS latest release page.

That's it

Over the years, I've found that having a global hotkey to screenshot the current active window is really helpful. I like it even more now that it goes directly to the clipboard.