@prohost/cli 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+Versions follow [semver](https://semver.org/). Publishing is automated: merging
+a version bump to `main` triggers `.github/workflows/npm-publish-cli.yml`, which
+builds via `prepack`, runs the suite, publishes, and tags `cli-v<version>`.
+
+## 0.1.2
+
+The release that carries 0.1.1's fix to users. 0.1.1 was tagged in the monorepo
+but never reached npm — there was no publish pipeline — so every `npx
+@prohost/cli` install was still resolving 0.1.0 and still 403-looping after
+pairing. This version exists so the fix ships.
+
+- **Stale v1 credential files heal themselves.** `~/.prohost/agent.json` written
+  by 0.1.0 records the wrong websocket host, and the stored URL wins over any
+  client-side default — so upgrading the CLI alone would not have unbroken those
+  installs. `CREDENTIALS_VERSION` is now `2`; a v1 file is recognised as
+  untrustworthy and its socket URL is re-derived from `base_url` (which the
+  server did report, and which is correct even in a v1 file). Already-paired
+  agents recover on the next `agent run` without re-pairing.
+- Added the publish workflow itself, so a version bump on `main` is the whole
+  release process.
+
+## 0.1.1
+
+Never published to npm — superseded by 0.1.2.
+
+- **The websocket host comes from the server.** Pairing now stores the `ws_url`
+  the server reports instead of composing one from a hardcoded constant. 0.1.0's
+  constant named a host that rejects the pairing credential, so `agent run`
+  connected, took a 403, and retried forever.
+
+## 0.1.0
+
+First publish. Broken on `agent run` — the hardcoded `wss://` host 403-loops
+after pairing. Do not use.
+
+- `prohost agent pair` / `prohost agent run` — run a local agent as a ProhostAI
+  teammate.
+- `prohost listen` — forward account webhooks to a local HTTP endpoint.

package/README.md

@@ -72,10 +72,11 @@ You can also pass the code as `$PROHOST_PAIRING_CODE`.
 npx @prohost/cli agent run --exec 'claude -p'
 ```
 
-Leave it running. On every mention you'll see:
+Leave it running. Each time ProhostAI asks this agent for work — an `@`-mention
+in a team thread, a 1:1 DM, a task comment, a trigger — you'll see:
 
 ```
-14:22:07 ● connected as "Ada" — waiting for mentions (exec: claude -p)
+14:22:07 ● connected as "Ada" — waiting for agent.run_requested (exec: claude -p)
 14:24:31 ▶ run 01JQ8Z4K2M started (conversation 9f3c…)
 14:24:58 ✓ run 01JQ8Z4K2M replied in 26.4s (412 chars)
 ```
@@ -131,12 +132,12 @@ command.)
 
 | Flag | Default | What it does |
 | --- | --- | --- |
-| `--exec` | *(required)* | Command to run for each mention. Prompt arrives on stdin. |
+| `--exec` | *(required)* | Command to run for each requested run. Prompt arrives on stdin. |
 | `--timeout` | `300` | Seconds one run may take before the command is killed. |
 | `--dry-run` | off | Print the reply that would be posted; write nothing. |
 | `--cwd` | current dir | Working directory for the command. |
 | `--machine` | OS hostname | Name shown next to the connection in ProhostAI. |
-| `--url` | paired value | Websocket endpoint override. |
+| `--url` | paired value | Websocket endpoint override. Pairing stores the URL the server reports, so you should not normally need this. |
 | `--allow-unverified` | off | Run events whose signature can't be verified. See below. |
 
 ### `agent pair` flags
@@ -197,7 +198,7 @@ your handler sees the same shape as a production delivery.
 | --- | --- | --- |
 | `--forward-to` | *(required)* | Local URL each payload is POSTed to. |
 | `--api-key` | `$PROHOST_API_KEY` | ProhostAI API key (`ph_live_…`). |
-| `--url` | `wss://api.prohost.ai/ws/webhooks` | Websocket endpoint. |
+| `--url` | `wss://connect.prohost.ai/ws/webhooks` | Websocket endpoint. |
 | `--machine` | OS hostname | Name displayed in the UI. |
 | `--subscription-id` | none | Stamp `connected_from` on a specific subscription. |
 
@@ -208,6 +209,10 @@ your handler sees the same shape as a production delivery.
 Email [support@prohost.ai](mailto:support@prohost.ai). Include the output of
 `npx @prohost/cli --version`.
 
+What changed between versions is in `CHANGELOG.md`, shipped alongside this file
+in the package. **If `--version` reports `0.1.0`, upgrade** — that build cannot
+connect after pairing.
+
 The source lives in ProhostAI's (private) backend monorepo under
 `packages/prohost-cli`; there is no public issue tracker.
 

package/dist/agent/credentials.d.ts

@@ -39,7 +39,31 @@ export interface AgentCredentials {
     agent: StoredAgent;
     paired_at: string;
 }
-export declare const CREDENTIALS_VERSION = 1;
+/**
+ * On-disk credential schema version.
+ *
+ * ``2`` means "``ws_url`` is trustworthy". Version ``1`` files were written by
+ * a CLI that composed that URL from a hardcoded constant, and 0.1.0 shipped a
+ * constant naming the wrong host — so a v1 file may carry a socket URL that can
+ * only ever 403. Upgrading the CLI alone would not have helped those installs:
+ * {@link streamUrlFor} prefers the stored value, so the bad URL would keep
+ * being used until the operator re-paired. The version bump is what lets a new
+ * build recognise a stale file and re-derive instead.
+ */
+export declare const CREDENTIALS_VERSION = 2;
+/**
+ * Websocket URL to use for a stored credential.
+ *
+ * For a current (v2+) file this is just ``ws_url`` — the value the server
+ * reported at pair time. For a v1 file the stored URL is not trusted: it came
+ * from a client-side constant, and 0.1.0's was wrong. It is re-derived from
+ * ``base_url``, which the server did report (via ``mcp_url``) and which is
+ * therefore right even in a v1 file.
+ *
+ * @param credentials Stored credentials.
+ * @param fallback Used when neither the stored URL nor ``base_url`` is usable.
+ */
+export declare function streamUrlFor(credentials: AgentCredentials, fallback: string): string;
 /** Directory holding CLI state. Overridable with ``$PROHOST_HOME`` for tests. */
 export declare function prohostHome(env?: NodeJS.ProcessEnv): string;
 /** Absolute path of the credential file. */

package/dist/agent/credentials.js

@@ -8,7 +8,61 @@
 import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-export const CREDENTIALS_VERSION = 1;
+/**
+ * On-disk credential schema version.
+ *
+ * ``2`` means "``ws_url`` is trustworthy". Version ``1`` files were written by
+ * a CLI that composed that URL from a hardcoded constant, and 0.1.0 shipped a
+ * constant naming the wrong host — so a v1 file may carry a socket URL that can
+ * only ever 403. Upgrading the CLI alone would not have helped those installs:
+ * {@link streamUrlFor} prefers the stored value, so the bad URL would keep
+ * being used until the operator re-paired. The version bump is what lets a new
+ * build recognise a stale file and re-derive instead.
+ */
+export const CREDENTIALS_VERSION = 2;
+/**
+ * Websocket URL to use for a stored credential.
+ *
+ * For a current (v2+) file this is just ``ws_url`` — the value the server
+ * reported at pair time. For a v1 file the stored URL is not trusted: it came
+ * from a client-side constant, and 0.1.0's was wrong. It is re-derived from
+ * ``base_url``, which the server did report (via ``mcp_url``) and which is
+ * therefore right even in a v1 file.
+ *
+ * @param credentials Stored credentials.
+ * @param fallback Used when neither the stored URL nor ``base_url`` is usable.
+ */
+export function streamUrlFor(credentials, fallback) {
+    if ((credentials.version ?? 1) >= 2 && credentials.ws_url)
+        return credentials.ws_url;
+    // Truthiness, not `??`: a hand-edited or truncated file can hold `""`, which
+    // is not a URL but is not nullish either, so `??` would return it.
+    return wsUrlFromBaseUrl(credentials.base_url) || credentials.ws_url || fallback;
+}
+/**
+ * Turn an API base URL into the websocket URL on the same host.
+ *
+ * Mirrors the server's derivation (`shared/agents/connections.py`
+ * ``pairing_endpoints``): only plain ``http`` maps to ``ws``, so a local dev
+ * base keeps working and nothing else can downgrade a socket that carries an
+ * API key. Returns ``undefined`` for anything not parseable as a URL.
+ */
+function wsUrlFromBaseUrl(baseUrl) {
+    if (!baseUrl)
+        return undefined;
+    let parsed;
+    try {
+        parsed = new URL(baseUrl);
+    }
+    catch {
+        return undefined;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+        return undefined;
+    const scheme = parsed.protocol === 'http:' ? 'ws' : 'wss';
+    const prefix = parsed.pathname.replace(/\/+$/, '');
+    return `${scheme}://${parsed.host}${prefix}/ws/webhooks`;
+}
 /** Directory holding CLI state. Overridable with ``$PROHOST_HOME`` for tests. */
 export function prohostHome(env = process.env) {
     return env.PROHOST_HOME ?? path.join(os.homedir(), '.prohost');

package/dist/agent/pair.d.ts

@@ -15,7 +15,11 @@ export interface PairOptions {
     code: string;
     /** Public API base. Defaults to production. */
     baseUrl?: string;
-    /** Websocket endpoint stored for `prohost agent run`. */
+    /**
+     * Explicit websocket endpoint to store for `prohost agent run` (`--url` /
+     * `$PROHOST_WS_URL`). An operator override, so it beats what the server
+     * reports; leave it unset and the server's `ws_url` is used.
+     */
     wsUrl?: string;
     /**
      * HTTPS endpoint to ALSO deliver agent events to. Optional and rarely

package/dist/agent/pair.js

@@ -24,6 +24,25 @@ function isUuid(value) {
 function baseFromMcpUrl(mcpUrl, fallback) {
     return mcpUrl.endsWith('/mcp') ? mcpUrl.slice(0, -'/mcp'.length) : fallback;
 }
+/**
+ * The websocket URL the server told us to use, or ``undefined``.
+ *
+ * ``undefined`` covers both "this server predates the field" and "the value is
+ * not a websocket URL". A cosmetic bad value must not fail a redeem — the code
+ * is already spent by the time we read the body — so the caller falls back to
+ * {@link DEFAULT_WS_URL} and says so.
+ */
+function serverWsUrl(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        return undefined;
+    try {
+        const protocol = new URL(value).protocol;
+        return protocol === 'ws:' || protocol === 'wss:' ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Redeem ``code`` and persist the resulting credentials.
  *
@@ -33,7 +52,6 @@ export async function runPair(options) {
     const fetchImpl = options.fetchImpl ?? fetch;
     const onLine = options.onLine ?? ((line) => process.stdout.write(`${line}\n`));
     const baseUrl = (options.baseUrl ?? DEFAULT_API_BASE_URL).replace(/\/+$/, '');
-    const wsUrl = options.wsUrl ?? DEFAULT_WS_URL;
     if (options.webhookUrl && !options.webhookUrl.startsWith('https://')) {
         throw new PairError('--webhook-url must be an https:// URL');
     }
@@ -111,6 +129,16 @@ export async function runPair(options) {
                     'redeem and has been removed.'
                 : '  Nothing was saved.'));
     }
+    // Where the websocket host comes from, in order:
+    //
+    //   1. `--url` / `$PROHOST_WS_URL` — an explicit operator override, and the
+    //      escape hatch that let the field work around 0.1.0's bad default.
+    //   2. The server's `ws_url`, derived server-side from the same setting as
+    //      `mcp_url` (`shared/agents/connections.py::pairing_endpoints`). This is
+    //      the normal path, and the reason a host move no longer needs a release.
+    //   3. `DEFAULT_WS_URL`, for a server that predates the field.
+    const fromServer = serverWsUrl(body.ws_url);
+    const wsUrl = options.wsUrl ?? fromServer ?? DEFAULT_WS_URL;
     const credentials = {
         version: CREDENTIALS_VERSION,
         base_url: baseFromMcpUrl(body.mcp_url ?? '', baseUrl),
@@ -129,10 +157,22 @@ export async function runPair(options) {
     onLine(`  API key      ${maskSecret(body.api_key)}  (stored, never printed in full)`);
     onLine(`  Credentials  ${file}  (chmod 600)`);
     onLine(`  MCP URL      ${body.mcp_url}`);
+    // Printed because 0.1.0's wrong websocket host was invisible here: pairing
+    // reported success and the mismatch only surfaced as a 403 reconnect loop in
+    // a different command. Showing it makes a bad host obvious at pair time.
+    onLine(`  Stream URL   ${credentials.ws_url}`);
     onLine(`  Events       ${credentials.events.join(', ') || '(none)'}`);
     onLine(`  Delivery     ${credentials.stream_only
         ? 'stream-only — events arrive over the websocket, nothing is POSTed to you'
         : `over the websocket, and POSTed to ${options.webhookUrl ?? 'your registered endpoint'}`}`);
+    if (body.ws_url && !fromServer && !options.wsUrl) {
+        // Present but not a ws:// or wss:// URL. Don't fail the redeem over it —
+        // the code is spent — but don't let the fallback look like the server's
+        // answer either.
+        onLine('');
+        onLine(`  ! The server reported an unusable stream URL (${JSON.stringify(body.ws_url)}).`);
+        onLine(`    Using ${DEFAULT_WS_URL} instead — override with --url if that is wrong.`);
+    }
     if (!credentials.webhook_secret) {
         // Without a secret the runner can't prove an event came from ProhostAI,
         // and a run event makes this machine execute a command — so it refuses to

package/dist/agent/run.js

@@ -21,6 +21,7 @@ import os from 'node:os';
 import WebSocket from 'ws';
 import { completeRun, postReply } from './api.js';
 import { EVENT_AGENT_RUN_REQUESTED, EVENT_MENTION_CREATED, EVENT_MESSAGE_TEAM_CHAT, eventData, parseRunRequest, } from './contract.js';
+import { streamUrlFor } from './credentials.js';
 import { execAgent } from './exec.js';
 import { buildPrompt, replyFromStdout } from './prompt.js';
 import { RunStore } from './runstore.js';
@@ -189,8 +190,16 @@ export async function runAgentHarness(options) {
     const Ctor = options.webSocketCtor ?? WebSocket;
     const sleep = options.sleepImpl ?? defaultSleep;
     const machine = options.machine ?? os.hostname();
-    const url = options.url ?? options.credentials.ws_url ?? DEFAULT_WS_URL;
+    const url = options.url ?? streamUrlFor(options.credentials, DEFAULT_WS_URL);
     const metrics = newMetrics();
+    // A credential file written by 0.1.0 stores a socket URL on a host that only
+    // ever answers 403. Upgrading the CLI would not have fixed those installs on
+    // its own — the stored value wins over the constant — so say what happened
+    // rather than silently using a different URL than the file names.
+    if (!options.url && options.credentials.ws_url && url !== options.credentials.ws_url) {
+        log(`${timestamp()} ! stored stream URL ${options.credentials.ws_url} predates this build ` +
+            `and is not used; connecting to ${url} instead (re-pair to refresh the file)`);
+    }
     const api = {
         baseUrl: options.credentials.base_url,
         apiKey: options.credentials.api_key,
@@ -274,7 +283,14 @@ export async function runAgentHarness(options) {
                 if (f.type === 'auth_ok') {
                     authed = true;
                     const name = options.credentials.agent?.name ?? 'agent';
-                    log(`${timestamp()} ● connected as "${name}" — waiting for mentions (exec: ${options.exec})`);
+                    // Names the event, not "mentions". A mention is one of several things
+                    // that make the server request a run — a 1:1 DM to this agent is
+                    // another, and it carries no mention at all — so "waiting for
+                    // mentions" describes a narrower trigger than the one this harness
+                    // actually waits on, and sends anyone debugging a silent agent to
+                    // read mention code instead of the run dispatcher.
+                    log(`${timestamp()} ● connected as "${name}" — waiting for ` +
+                        `${EVENT_AGENT_RUN_REQUESTED} (exec: ${options.exec})`);
                     return;
                 }
                 if (f.type === 'auth_error') {
@@ -307,7 +323,12 @@ export async function runAgentHarness(options) {
                 };
                 if (frame.event !== EVENT_AGENT_RUN_REQUESTED) {
                     if (frame.event === EVENT_MENTION_CREATED || frame.event === EVENT_MESSAGE_TEAM_CHAT) {
-                        log(`${timestamp()} ◦ ${frame.event} (no action — runs are triggered by mentions)`);
+                        // "runs are triggered by mentions" was wrong twice over: the gate
+                        // is the `agent.run_requested` event, and this very frame can BE a
+                        // mention — so the line claimed a mention triggers a run while
+                        // ignoring a mention. State the gate instead.
+                        log(`${timestamp()} ◦ ${frame.event} (no action — this harness runs on ` +
+                            `${EVENT_AGENT_RUN_REQUESTED}, which the server sends separately)`);
                     }
                     metrics.ignored += 1;
                     ack(ACK_IGNORED);

package/dist/index.js

@@ -29,7 +29,7 @@ function printHelp() {
         'listen flags:',
         '  --forward-to     Local URL to POST each webhook payload to (required)',
         '  --api-key        ProhostAI API key. Defaults to $PROHOST_API_KEY.',
-        '  --url            Websocket endpoint. Defaults to wss://api.prohost.ai/ws/webhooks.',
+        '  --url            Websocket endpoint. Defaults to wss://connect.prohost.ai/ws/webhooks.',
         '  --machine        Machine name displayed in the UI. Defaults to the OS hostname.',
         '  --subscription-id  Stamp connected_from on a specific subscription row.',
         '',

package/dist/listen.d.ts

@@ -38,7 +38,19 @@ export interface ListenMetrics {
     eventsForwarded: number;
     forwardErrors: number;
 }
-export declare const DEFAULT_WS_URL = "wss://api.prohost.ai/ws/webhooks";
+/**
+ * `/ws/webhooks` is served by **api_public**, which is `connect.prohost.ai` —
+ * the same host as {@link DEFAULT_API_BASE_URL}. It is NOT on `api.prohost.ai`
+ * (the main ECS API), which answers the handshake with a bare 403.
+ *
+ * 0.1.0 shipped `api.prohost.ai` here while the REST base correctly pointed at
+ * `connect.prohost.ai`, so every paired agent redeemed its code fine and then
+ * failed to connect, reconnecting forever against a host that does not serve
+ * this route. Mentions dispatched, no runtime was listening, and the thread sat
+ * on "…is thinking" until the delivery expired. Keep this host in step with
+ * `DEFAULT_API_BASE_URL`.
+ */
+export declare const DEFAULT_WS_URL = "wss://connect.prohost.ai/ws/webhooks";
 /**
  * Run the listener until the abort signal fires or the socket closes.
  *

package/dist/listen.js

@@ -5,7 +5,19 @@
 import os from 'node:os';
 import WebSocket from 'ws';
 import { forwardEvent, isWebhookEvent } from './forward.js';
-export const DEFAULT_WS_URL = 'wss://api.prohost.ai/ws/webhooks';
+/**
+ * `/ws/webhooks` is served by **api_public**, which is `connect.prohost.ai` —
+ * the same host as {@link DEFAULT_API_BASE_URL}. It is NOT on `api.prohost.ai`
+ * (the main ECS API), which answers the handshake with a bare 403.
+ *
+ * 0.1.0 shipped `api.prohost.ai` here while the REST base correctly pointed at
+ * `connect.prohost.ai`, so every paired agent redeemed its code fine and then
+ * failed to connect, reconnecting forever against a host that does not serve
+ * this route. Mentions dispatched, no runtime was listening, and the thread sat
+ * on "…is thinking" until the delivery expired. Keep this host in step with
+ * `DEFAULT_API_BASE_URL`.
+ */
+export const DEFAULT_WS_URL = 'wss://connect.prohost.ai/ws/webhooks';
 /**
  * Run the listener until the abort signal fires or the socket closes.
  *

package/dist/version.d.ts

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export declare const CLI_VERSION = "0.1.0";
+export declare const CLI_VERSION = "0.1.2";
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
-export declare const USER_AGENT = "prohost-cli/0.1.0";
+export declare const USER_AGENT = "prohost-cli/0.1.2";

package/dist/version.js

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export const CLI_VERSION = '0.1.0';
+export const CLI_VERSION = '0.1.2';
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
 export const USER_AGENT = `prohost-cli/${CLI_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prohost/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Run your own AI agent as a ProhostAI teammate, and stream your account's webhooks to your laptop.",
   "type": "module",
   "license": "MIT",
@@ -15,6 +15,7 @@
   "files": [
     "dist",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "scripts": {