# PowerCloud Center

> The desktop app for Windows and macOS - creating a cluster or connecting to one, adding nodes, the cluster's keys, each node's history, notifications, triage that learns what you do about what needs attention, and Claude, asked about what it isn't sure of or working with you through Center's MCP server.

PowerCloud Center is the desktop app for your PowerCloud cluster, on Windows and macOS. It shows everything [the web console](https://powercloud.unidatum.com/docs/console.md) shows, in a window of its own, and adds what someone starting out needs: creating a cluster, connecting this computer to one, and adding nodes, without the command line. It keeps a history of each node and tells you when something needs attention. It also learns what you do about each kind of problem, and can ask Claude about the ones it hasn't seen.

Center does what `pcctl` does, with the same configuration. A computer connected with `pcctl` is connected for Center too, and the other way round.

## Installing

Center has releases of its own, apart from the OS's, named `center-vYYYY.MM.DD`. Each carries:

| File | What it is |
|---|---|
| `PowerCloudCenter-macos.dmg` | For Macs with Apple silicon. Signed and notarized by Apple: open it and drag the app to Applications. |
| `PowerCloudCenter-windows-amd64.exe` | For Windows on x64. Signed: run it, no installer. |
| `PowerCloudCenter-windows-arm64.exe` | For Windows on Arm. Signed: run it, no installer. |
| `PowerCloudCenter_VERSION.msixbundle` | The package for the Microsoft Store listing. |
| `SHA256SUMS` | Checksums of every file. |

Check what you download with `sha256sum -c SHA256SUMS --ignore-missing`. Intel Macs aren't supported: the Unidatum engine inside the app has no build for them.

## What runs where

```mermaid
%% alt: On the admin's computer, PowerCloud Center holds the console, the cluster's keys for 30 minutes when unlocked, and a Unidatum engine keeping the history and the triage decision; it reaches each node with the admin certificate. Claude Code reaches Center through its MCP server; claude -p is run by Center when it asks.
flowchart TB
  subgraph pc ["Your computer"]
    center["PowerCloud Center<br/>console, admin certificate"]
    keys["Cluster keys<br/>30 minutes when unlocked"]
    engine["Unidatum engine<br/>history, triage"]
    cc["Claude Code<br/>center --mcp"]
    cp["claude -p<br/>when Center asks"]
  end
  subgraph cluster ["Your nodes"]
    n1["home-1"]
    n2["colo-1"]
  end
  center --- keys
  center --- engine
  cc -->|"local API, token"| center
  center -->|"asks"| cp
  center -->|"mutual TLS"| n1
  center -->|"mutual TLS"| n2
```

- **The window** is the console, served by the app itself. No port is opened for it, and the nodes serve no web page.
- **The admin certificate** in pcctl's configuration directory is how Center reaches the nodes, as `pcctl` does.
- **The cluster's keys** are needed only to create a cluster, connect a computer, add a node or publish a cluster app. Unlocked with your passphrase, they stay in Center's memory and lock again after 30 minutes, or when you lock them or quit.
- **A Unidatum engine inside the app** keeps the nodes' history and the triage decision, in its own library under pcctl's configuration directory, next to the app's other files. It opens no port and syncs with nothing.

## Getting started

The first time Center opens on a computer that isn't connected to a cluster, it offers two ways in.

### Create a new cluster

**Create a new cluster** asks for:

- **Storage locations.** Each is a folder (`C:\pc`, `/srv/pc`) or a bucket (`s3://bucket/prefix?endpoint=...&region=...&creds=NAME`). Your data is encrypted on your computer and kept in every location. Two or more, on different providers, mean losing any one loses nothing. **Check** tries a location before you commit to it.
- **Credentials for the s3:// locations,** as `NAME_ACCESS_KEY_ID=` and `NAME_SECRET_ACCESS_KEY=` lines, where NAME is the location's `creds=`. They're used for this step only and never saved.
- **A passphrase.**

Center then shows the cluster's **recovery key**, once. It opens the cluster if the passphrase is ever lost. Write it down, or keep it in a password manager away from this computer. PowerCloud keeps no copy. **Done** stays disabled until you tick that you've kept it.

### Connect to an existing cluster

**Connect to an existing cluster** asks for the passphrase, the storage locations and their credentials. This computer then gets its own admin certificate and learns every node. It's the same as `pcctl --repo ... login` on the command line.

### Add a node

Once connected, **Add a node** (in the node list, or **Add your first node** on an empty cluster) asks for the cluster's keys if they're locked, then offers two ways:

- **Enroll a booted node.** Give the node's name and the address this computer reaches it at. Add the enrollment code shown on the node's console, and its public mesh endpoint if it has a public address. Center enrolls it, as `pcctl node enroll` does.
- **Provision a join bundle**, for a machine that joins at first boot with nobody at its console: a cloud VM, or a QEMU guest. Center asks where to save the bundle, writes it readable by you only, and shows how to give it to the machine on AWS, Google Cloud, Azure and QEMU. The bundle holds the node's private keys and disk key, so delete it once the node is up, and its user data too where the provider allows it.

See [Enrolling nodes](https://powercloud.unidatum.com/docs/enroll.md) for what happens underneath.

## The cluster's keys

The **Unlock keys** button in the top bar asks for the passphrase. The keys can be reached through a node that serves the cluster's storage, or from the storage locations themselves. Once unlocked, the button shows until when they're unlocked, and locks them at once if you press it. Without the keys, Center still shows and manages every node and app with the admin certificate. See [Unlocking](https://powercloud.unidatum.com/docs/unlock.md).

## History

Select a node, and below its resources Center draws its **last 24 hours**:

- **CPU**: how busy it was.
- **Memory**: how full it was.
- **Answering**: a strip showing when it answered and when it didn't.

Center samples every node once a minute while it's open, and keeps 30 days. The samples stay on your computer, in the engine's library.

## Notifications

While Center is open, even in the background, it looks at what needs attention once a minute. Anything new gets a system notification: a node that stops answering, an app that isn't running, a certificate close to expiry, a storage sync that didn't finish. On a Mac, Center asks once whether it may notify you.

What already needed attention when Center opened is on the page, so it isn't announced. An item that changes only in its numbers or its error text isn't news either. A certificate that expires in 9 days, the day after it expired in 10, is the same item.

## Triage: what you usually do

Center learns what you do about each kind of item that needs attention. It counts what you do from Center or through Claude Code:

| What you do | What Center learns |
| --- | --- |
| Restart the app | restart |
| Read the app's logs | logs: the cause wasn't clear |
| Remove the app | remove |
| Deploy the app again | deploy |
| Nothing, and the item goes away | wait: it clears up by itself |

Each is an example for a **Unidatum decision** kept in the engine inside Center. The decision is trained again as examples come. Once it's sure, the page shows beside an item what you usually do about ones like it, for instance *you usually restart it (94%)*, and so do the notifications. For an app you usually restart, the **Restart** button is right there.

The decision starts from a few examples that come with Center, so it has an opinion from the first item. Your own actions then outweigh them. One more answer, **pcctl**, means the item needs the command line, as it says: renewing a certificate, for example.

Items are compared by their words. Numbers are made alike, so *home-1: app db is exited (exit status 1)* teaches about *home-2: app db is exited (exit status 137)* too. Nothing leaves your computer for this, and there's no model to download.

## Claude

The **Claude** button sets what Center does with an item the decision isn't sure about yet. It can ask Claude, and Claude's answer shows beside the item, for instance *Claude suggests reading its logs*. Center learns from that answer as from your own. There are four choices:

- **Claude Code, when it asks** (the default). The question waits in Center until Claude Code, given Center's MCP server, reads it and answers. Nothing is sent anywhere by itself.
- **Claude on this computer, at once.** Center runs `claude -p` on this computer, with your Claude account, for each question. It runs in an empty directory with no tools and no MCP servers, so the question is all it reads. Each question costs a fraction of a cent on a small model. Claude Code must be installed. **Model** picks the model; it's left empty for the default.
- **Claude on the Unidatum hub, at once.** With a PowerCloud licence, the Unidatum engine inside Center sends the question over a Unidatum channel to the hub the licence names, where Claude answers it. Nothing is needed on this computer but the licence, which is free: type your email under this choice and press **Email me a licence**. Your browser opens Unidatum's page with the address filled in; confirm there, and the licence arrives by email. Open the email on this computer and click its button, then **Open in PowerCloud Center**: Center comes forward and offers the licence, and **Activate** turns it on. (Or paste the licence from the email under **Or paste a licence**.) It's kept in the engine's library, so it's activated once. The engine dials out to the hub and nothing dials in. Only the item's text is sent, never a key, a certificate or a log. **Remove licence** closes the channel.
- **Nobody.** Only what you do teaches the decision.

The open questions are listed in the same dialog, and you can answer them yourself.

### Center's MCP server, for Claude Code

The Claude dialog shows the line that gives Claude Code Center's MCP server, with the app's path filled in. Run it once in a terminal:

```sh
claude mcp add powercloud -- "/Applications/PowerCloud Center.app/Contents/MacOS/PowerCloudCenter" --mcp
```

On Windows, the app from the Microsoft Store is started by its alias:

```sh
claude mcp add powercloud -- PowerCloudCenter.exe --mcp
```

Claude Code then sees your cluster as Center does, with this computer's admin certificate:

| Tool | What it does |
| --- | --- |
| `powercloud_status` | Every node and its apps, what needs attention, and what you usually do about each item |
| `powercloud_logs` | The end of an app's output |
| `powercloud_history` | A node's samples, up to 30 days |
| `powercloud_restart` | Restarts an app, data kept; Center learns from it |
| `powercloud_questions` | What the triage decision is asking about |
| `powercloud_answer` | Answers a question: Center shows the answer and learns from it |

Claude Code asks your permission before it calls a tool, as it does for any MCP server. A good start is asking it: *look at my PowerCloud cluster, and answer Center's open questions*.

`center --mcp` reaches the running Center through a local API on a loopback port, guarded by a random token. The token is in a file in pcctl's configuration directory that only your user can read. A web page can't send it, so no web site can use the API. When Center isn't open, the tools say so.

For working with PowerCloud from Claude Code more broadly, deploying designs and running `pcctl` for you, see [Claude Code](https://powercloud.unidatum.com/docs/claude-code.md).

## Center and pcctl console

| | PowerCloud Center | pcctl console |
| --- | --- | --- |
| Runs on | Windows, macOS | wherever pcctl runs |
| Shows and manages nodes and apps | yes | yes |
| Creates a cluster, connects, adds nodes | yes | no: pcctl commands |
| Cluster keys | unlocked in the app, 30 minutes | with `--repo` |
| History, notifications, triage | yes | no |
| Claude through MCP | yes | no |
| Reached from another machine | no | through an SSH tunnel |

## If something's wrong

- **No notifications on a Mac.** Allow them for PowerCloud Center in System Settings, Notifications.
- **"claude isn't installed on this computer".** Install Claude Code, or choose *Claude Code, when it asks*.
- **The Claude Code tools say Center isn't running.** Open PowerCloud Center. The MCP server reaches the open app.
- **A suggestion you disagree with.** Do what you think is right: the decision learns from that too, and changes its mind as your actions outnumber the examples it started from.