@ours.network/fleet 1.2.0-nightly.4 → 1.2.0-nightly.5

package/README.md

@@ -1694,3 +1694,19 @@ provisioning or automatic reverse-proxy configuration. Existing local HTTP and
 SSH-tunnel profiles continue to work.
 
 See [supervisor-owned ours and migration](docs/supervisor-ours.md) for the runtime contract and review build instructions.
+
+### One-server gateway profile
+
+A private client profile may include `serverUrl`, for example
+`https://ours.example/base`, together with `endpoint` set to
+`https://ours.example/base/daemon`, the existing `expectedInstanceId`, and the
+absolute private `credentialPath`. Fleet preserves that daemon prefix for doctor
+and monitoring and derives `/cowork/management/rpc` from `serverUrl` for room
+management. Requests use the issued server credential, reject redirects, have
+bounded bodies/deadlines, and never replay mutations. This capability is declared
+as `cowork.http-management-v1` in the built artifact.
+
+Explicit Cowork socket, config or state-directory overrides continue to select
+local Unix management. Profiles without `serverUrl` retain legacy behavior. The
+HTTP API grants operator room authority; use the installer's supported private
+or authenticated external gateway entry, and keep its backend ports private.

package/dist/build-info.json

@@ -1,10 +1,11 @@
 {
-  "version": "1.2.0-nightly.4",
-  "buildId": "10dccae7a337",
-  "commit": "2192785d3823d7a2cae1f3b5c7060bd97175340e",
+  "version": "1.2.0-nightly.5",
+  "buildId": "4d7255bd137c",
+  "commit": "273d3bec2505bd1a4244c6b00b836238faaac99e",
   "dirty": true,
-  "builtAt": "2026-09-21T20:49:10.393Z",
+  "builtAt": "2026-09-22T18:42:44.399Z",
   "capabilities": [
+    "cowork.http-management-v1",
     "monitor.interrupt.after_tool"
   ]
 }

package/dist/capabilities.d.ts

@@ -14,7 +14,8 @@
  */
 /** `monitor.interrupt: after_tool` — cancel at the next tool boundary (#67). */
 export declare const CAP_MONITOR_INTERRUPT_AFTER_TOOL = "monitor.interrupt.after_tool";
-export declare const CAPABILITIES: readonly ["monitor.interrupt.after_tool"];
+export declare const CAP_HTTP_COWORK = "cowork.http-management-v1";
+export declare const CAPABILITIES: readonly ["cowork.http-management-v1", "monitor.interrupt.after_tool"];
 export type Capability = (typeof CAPABILITIES)[number];
 /** Does this build declare `token`? */
 export declare const hasCapability: (token: string) => boolean;

package/dist/capabilities.js

@@ -14,7 +14,9 @@
  */
 /** `monitor.interrupt: after_tool` — cancel at the next tool boundary (#67). */
 export const CAP_MONITOR_INTERRUPT_AFTER_TOOL = 'monitor.interrupt.after_tool';
+export const CAP_HTTP_COWORK = 'cowork.http-management-v1';
 export const CAPABILITIES = [
+    CAP_HTTP_COWORK,
     CAP_MONITOR_INTERRUPT_AFTER_TOOL,
 ];
 /** Does this build declare `token`? */

package/dist/client-profile.d.ts

@@ -3,6 +3,7 @@ export interface ExplicitClientProfile {
     readonly expectedInstanceId: string;
     readonly credentialPath: string;
     readonly configPath: string;
+    readonly serverUrl?: string;
 }
 export declare class ClientProfileError extends Error {
     constructor(message: string);

package/dist/client-profile.js

@@ -1,3 +1,4 @@
+import { normalizeDaemonEndpoint } from '@ours.network/sdk/client';
 import { lstatSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { isAbsolute, join } from 'node:path';
@@ -97,17 +98,31 @@ export function readClientProfile(env) {
     catch {
         throw invalid(configPath, 'has an invalid endpoint');
     }
-    if ((url.protocol !== 'http:' && url.protocol !== 'https:') || url.username || url.password || url.pathname !== '/'
+    if ((url.protocol !== 'http:' && url.protocol !== 'https:') || url.username || url.password
         || url.search || url.hash)
-        throw invalid(configPath, 'endpoint must be an HTTP or HTTPS origin');
+        throw invalid(configPath, 'endpoint must be an HTTP or HTTPS base URL');
     const expectedInstanceId = row.expectedInstanceId.trim();
     if (!LOWERCASE_UUID.test(expectedInstanceId))
         throw invalid(configPath, 'expectedInstanceId must be a lowercase UUID');
     const credentialPath = row.credentialPath.trim();
     if (!isAbsolute(credentialPath))
         throw invalid(configPath, 'credentialPath must be absolute');
+    let serverUrl;
+    if (Object.hasOwn(row, 'serverUrl')) {
+        if (typeof row.serverUrl !== 'string' || /[\s\\?#]/.test(row.serverUrl))
+            throw invalid(configPath, 'serverUrl must be a safe HTTP or HTTPS base URL');
+        try {
+            serverUrl = normalizeDaemonEndpoint(row.serverUrl);
+        }
+        catch {
+            throw invalid(configPath, 'serverUrl must be a safe HTTP or HTTPS base URL');
+        }
+        if (normalizeDaemonEndpoint(endpoint) !== serverUrl + '/daemon')
+            throw invalid(configPath, 'endpoint must select serverUrl/daemon');
+    }
     return Object.freeze({
-        endpoint: url.origin, expectedInstanceId, credentialPath, configPath,
+        ...(serverUrl === undefined ? {} : { serverUrl }),
+        endpoint: normalizeDaemonEndpoint(endpoint), expectedInstanceId, credentialPath, configPath,
     });
 }
 export function clientProfileKey(profile) {

package/dist/doctor.d.ts

@@ -3,7 +3,7 @@ import { type Exec } from './exec.js';
 import type { YamlMode } from './config-yaml.js';
 import { type FetchLike } from './monitor.js';
 import type { PrereqReport } from './harness/types.js';
-type DoctorDaemonClient = Pick<OursClient, 'version'>;
+type DoctorDaemonClient = Pick<OursClient, 'version' | 'close'>;
 type AttachDoctorDaemon = (options: AttachOursClientOptions) => Promise<DoctorDaemonClient>;
 /** Host-level + per-harness prerequisite report with actionable messages. */
 export declare function doctor(opts?: {

package/dist/doctor.js

@@ -1,4 +1,5 @@
-import { userInfo } from 'node:os';
+import { join } from 'node:path';
+import { userInfo, homedir } from 'node:os';
 import { existsSync, readFileSync } from 'node:fs';
 import { attachOursClient, } from '@ours.network/sdk/client';
 import { realExec } from './exec.js';
@@ -272,21 +273,39 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
         }
         catch { /* state dir may not exist yet */ }
     }
+    let managedSelection = false;
     try {
-        const client = await attachDaemon({
-            env: process.env,
+        // Mark explicit selection before validation so a damaged managed profile does
+        // not produce advice to start an unrelated local daemon.
+        managedSelection = process.env.OURS_CONFIG !== undefined
+            || existsSync(join(process.env.HOME || homedir(), '.ours-client', 'profile.json'));
+        const selected = readClientProfile(process.env);
+        managedSelection = selected !== undefined;
+        const client = await attachDaemon(selected ? {
+            endpoint: selected.endpoint, expectedInstanceId: selected.expectedInstanceId,
+            credentialPath: selected.credentialPath, env: {}, sessionMode: 'external',
             leaseToken: `ours-fleet-doctor-${process.pid}`,
-            clientPid: process.pid,
+        } : {
+            env: process.env, leaseToken: `ours-fleet-doctor-${process.pid}`, clientPid: process.pid,
         });
-        const info = await client.version();
-        if (info.name !== 'ours' || typeof info.version !== 'string')
-            throw new Error('the selected endpoint did not return a valid ours daemon identity');
-        checks.push({ name: 'ours daemon', ok: true, detail: `running (${info.version})` });
+        let daemonVersion;
+        try {
+            const info = await client.version();
+            if (info.name !== 'ours' || typeof info.version !== 'string')
+                throw new Error('the selected endpoint did not return a valid ours daemon identity');
+            daemonVersion = info.version;
+        }
+        finally {
+            await client.close();
+        }
+        checks.push({ name: 'ours daemon', ok: true, detail: `running (${daemonVersion})` });
     }
     catch (error) {
         checks.push({
             name: 'ours daemon', ok: false,
-            detail: `not reachable through the SDK — start it with: ours-daemon start `
+            detail: (managedSelection
+                ? 'selected client profile failed — check its endpoint, instance and issued credential '
+                : 'not reachable through the SDK — start it with: ours-daemon start ')
                 + `[${error?.message ?? String(error)}]`,
         });
     }

package/dist/rooms-tasks/cowork-adapter.js

@@ -8,6 +8,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { createConnection } from 'node:net';
+import { readClientProfile } from '../client-profile.js';
+import { coworkHttpCall } from './cowork-http.js';
 const RPC_VERSION = 1;
 const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
@@ -275,10 +277,15 @@ function rpcCall(socketPath, method, params, timeoutMs, connect) {
     });
 }
 export function createCoworkAdapter(options = {}) {
-    const socketPath = resolveCoworkSocketPath(options);
+    const env = options.env ?? process.env;
+    const explicitLocal = options.socketPath !== undefined || options.configPath !== undefined
+        || env.OURS_COWORK_CONFIG !== undefined || !!env.OURS_COWORK_STATE_DIR;
+    const profile = explicitLocal ? undefined : readClientProfile({ ...env, HOME: options.home ?? env.HOME });
+    const remote = profile?.serverUrl ? profile : undefined;
+    const socketPath = remote ? undefined : resolveCoworkSocketPath(options);
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const connect = options.connect ?? ((path) => createConnection(path));
-    const call = (method, params) => rpcCall(socketPath, method, params, timeoutMs, connect);
+    const call = (method, params) => remote ? coworkHttpCall(remote, method, params, timeoutMs) : rpcCall(socketPath, method, params, timeoutMs, connect);
     return {
         async available() {
             try {

package/dist/rooms-tasks/cowork-http.d.ts

@@ -0,0 +1,3 @@
+import type { ExplicitClientProfile } from '../client-profile.js';
+/** Same RPC protocol as the local socket; never replay a possibly delivered mutation. */
+export declare function coworkHttpCall(profile: ExplicitClientProfile, method: string, params: Record<string, unknown>, timeoutMs: number): Promise<unknown>;

package/dist/rooms-tasks/cowork-http.js

@@ -0,0 +1,70 @@
+import { randomUUID } from 'node:crypto';
+import { attachOursClient } from '@ours.network/sdk/client';
+import { readPrivateFile } from '@ours.network/sdk/connector';
+import { CoworkProtocolError, CoworkUnavailableError } from './cowork-adapter.js';
+/** Same RPC protocol as the local socket; never replay a possibly delivered mutation. */
+export async function coworkHttpCall(profile, method, params, timeoutMs) {
+    const id = randomUUID();
+    const signal = AbortSignal.timeout(timeoutMs);
+    const body = JSON.stringify({ version: 1, id, method, params });
+    if (Buffer.byteLength(body) > 1024 * 1024)
+        throw new CoworkProtocolError(method, 'request exceeded 1 MiB');
+    try {
+        const client = await attachOursClient({ endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath, sessionMode: 'external', leaseToken: `fleet-cowork-check-${id}`, env: {}, requestSignal: signal });
+        await client.close();
+        const token = readPrivateFile(profile.credentialPath, 4096).toString('utf8').trim();
+        const response = await fetch(profile.serverUrl + '/cowork/management/rpc', {
+            method: 'POST', redirect: 'error', signal,
+            headers: { 'content-type': 'application/json', 'x-ours-api-token': token },
+            body,
+        });
+        if (response.status === 401 || response.status === 403) {
+            await response.body?.cancel();
+            throw new CoworkProtocolError(method, 'server credential was rejected', 'unauthorized');
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new CoworkProtocolError(method, 'empty HTTP response');
+        const chunks = [];
+        let size = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.length;
+                if (size > 4 * 1024 * 1024)
+                    throw new CoworkProtocolError(method, 'response exceeded 4 MiB');
+                chunks.push(value);
+            }
+        }
+        finally {
+            await reader.cancel();
+        }
+        let rpc;
+        try {
+            rpc = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        }
+        catch {
+            throw new CoworkProtocolError(method, 'server returned malformed JSON');
+        }
+        if (!rpc || Array.isArray(rpc) || rpc.version !== 1 || rpc.id !== id
+            || Object.hasOwn(rpc, 'result') === Object.hasOwn(rpc, 'error'))
+            throw new CoworkProtocolError(method, 'server returned an invalid RPC response');
+        if (Object.hasOwn(rpc, 'error')) {
+            const error = rpc.error;
+            if (!error || typeof error.code !== 'string' || typeof error.message !== 'string')
+                throw new CoworkProtocolError(method, 'server returned an invalid RPC error');
+            throw new CoworkProtocolError(method, error.message, error.code);
+        }
+        if (!response.ok)
+            throw new CoworkProtocolError(method, `management answered HTTP ${response.status}`);
+        return rpc.result;
+    }
+    catch (error) {
+        if (error instanceof CoworkProtocolError)
+            throw error;
+        throw new CoworkUnavailableError('Cowork HTTP management failed; check the selected server and credential', { cause: error });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.2.0-nightly.4",
+  "version": "1.2.0-nightly.5",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",