OpenPLUTO

I Put Bear Inside Obsidian

img

This started, as a lot of my projects do, with a half-baked idea and a sentence that was doing a lot of heavy lifting:

What if I could manage my Bear blogs from inside Obsidian?

I did not have a technical plan. I had a vault full of old blog posts, an API key, and a growing dislike of bouncing between my writing environment and a web dashboard every time I wanted to change something.

So I explained the idea to Codex.

The result is now sitting inside my Obsidian vault as a QuickAdd command.

Bear, without leaving the vault

The command connects directly to Bear's API. It gives me a searchable list of every post, draft, and page on the selected blog, even when the list spans multiple API pages.

I can select a post and import its full contents into a dedicated folder. The local note keeps Bear's permanent UID, publication state, tags, date, URL, and other useful metadata. If that UID already exists somewhere in the vault, the command opens the existing note instead of creating a duplicate.

From there I can work in the place where I already write.

I can turn a local note into a remote Bear draft. I can update a draft that already exists. I can update a published post, although the command makes it very obvious when I am about to touch something live and asks me to confirm it first.

I can also change the publication date from the note's frontmatter, so backdating a post or adjusting a scheduled one does not require a trip to the dashboard.

There is still an edit link in the frontmatter for those times when I need Bear's editor. Bear's website still has a place in the workflow, but ordinary writing and maintenance no longer have to pass through it.

It knows when to be careful

I appreciate the restraint even more than the importing.

Before updating anything, the command checks Bear's remote last_modified value against the version stored in my note. If the post changed elsewhere, I get a conflict warning instead of silently stomping over newer work.

It also distinguishes among drafts, scheduled posts, and live posts. A scheduled post gets a different warning because moving its date into the past could make it public immediately. Live posts require explicit confirmation before they change.

The integration only patches fields I actually edited, which means settings changed elsewhere are preserved. It flags Obsidian-only links and local image embeds that Bear would not know how to render. New posts are always created as drafts. There is no accidental-publish button hiding in the workflow.

The API keys never enter a note or the script. They are requested in a masked field and kept only in memory for the current Obsidian session. I use Espanso to make entering them painless without planting them inside the vault.

The result is automation with a few healthy trust issues.

Then one blog became three

Once the first version worked for my personal blog, I wanted to see how far it could stretch.

The same command now supports separate profiles for my personal site, OpenPLUTO, and ElliottCraft. Each blog has its own original Bear subdomain, API key session, import directory, UIDs, and sync metadata. The profiles are isolated so I cannot casually send an OpenPLUTO post to the wrong Bear account.

This particular post is being written in the OpenPLUTO folder, ready to become an OpenPLUTO draft through the very integration it is describing.

That kind of recursion pleases me more than it probably should.

How this was made

I did not sit down and design a polished publishing application. I described the friction in plain English.

Codex read Bear's API documentation, inspected how this particular Obsidian vault is organized, found the existing QuickAdd setup, and built around it. When I explained that my old local copies lived elsewhere, we changed the folder structure. When I asked about backdating, the workflow expanded. When two more blogs entered the picture, it became a profile system.

The project grew through conversation: idea, working version, real-world use, new annoyance, better version.

OpenPLUTO is becoming a record of what happens when I bring an incomplete idea to an AI capable of working directly with the tools and files around me. It documents the small systems we build to remove friction from my life.

Sometimes the starting point is barely more sophisticated than, Wouldn't it be cool if…?

Apparently that can be enough.

Would Bear users want this?

I am not publishing the integration as a ready-to-install package today. It was built around my vault, my folder conventions, and the way I use Bear. Turning it into something another person could safely install would require more documentation, configuration, testing, and thought than simply dumping a script online.

But I am curious how this would fit into somebody else's setup.

If you write in Obsidian and publish with Bear, would a bridge like this change your workflow? I would especially like to know whether importing and updating are enough, or whether another part of the Bear dashboard belongs inside your notes too.

If there is enough interest, we can take the next step and work out what a public version should look like.

For now, I am going to enjoy the fact that a half-baked idea turned into a button. Better yet, the button actually works.