@ours.network/fleet 1.2.0-nightly.6 → 1.2.0-nightly.61

package/dist/client-profile.js

@@ -1,130 +1,7 @@
-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';
-const PROFILE_FIELDS = ['endpoint', 'expectedInstanceId', 'credentialPath'];
-const LOWERCASE_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-const LEGACY_CONFIG_FIELDS = ['apiToken', 'stateDir', 'port'];
-const LEGACY_ENV_FIELDS = ['OURS_API_TOKEN', 'OURS_STATE_DIR', 'OURS_PORT', 'OURS_DAEMON_ID'];
-export class ClientProfileError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ClientProfileError';
-    }
-}
-export function clientConfigPath(env) {
-    if (env.OURS_CONFIG !== undefined)
-        return env.OURS_CONFIG;
-    const managedPath = join(env.HOME || homedir(), '.ours-client', 'profile.json');
-    try {
-        lstatSync(managedPath);
-        return managedPath;
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw invalid(managedPath, 'could not be read');
-        return join(homedir(), '.ours', 'config.json');
-    }
-}
-function invalid(path, detail) {
-    return new ClientProfileError(`ours client profile ${JSON.stringify(path)} ${detail}`);
-}
-/**
- * Read Fleet's selected host-client profile without opening its credential.
- * A legacy daemon config remains legacy only when none of the profile fields is
- * present. Explicit and managed selections fail closed on invalid input.
- */
-export function readClientProfile(env) {
-    const configPath = clientConfigPath(env);
-    const managed = configPath === join(env.HOME || homedir(), '.ours-client', 'profile.json');
-    const named = env.OURS_CONFIG !== undefined || managed;
-    let text;
-    try {
-        text = readFileSync(configPath, 'utf8');
-    }
-    catch {
-        if (named)
-            throw invalid(configPath, 'could not be read');
-        return undefined;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch {
-        if (named)
-            throw invalid(configPath, 'is not valid JSON');
-        return undefined;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        if (named)
-            throw invalid(configPath, 'must contain a JSON object');
-        return undefined;
-    }
-    const row = parsed;
-    if (!PROFILE_FIELDS.some(field => Object.prototype.hasOwnProperty.call(row, field))) {
-        if (managed)
-            throw invalid(configPath, 'must contain a complete client profile');
-        return undefined;
-    }
-    let metadata;
-    try {
-        metadata = statSync(configPath);
-    }
-    catch {
-        throw invalid(configPath, 'could not be inspected');
-    }
-    if (!metadata.isFile())
-        throw invalid(configPath, 'must be a regular file');
-    const getuid = process.getuid;
-    if (getuid && metadata.uid !== getuid())
-        throw invalid(configPath, 'must be owned by this user');
-    if ((metadata.mode & 0o077) !== 0)
-        throw invalid(configPath, 'must not be accessible by group or other users');
-    for (const field of PROFILE_FIELDS)
-        if (typeof row[field] !== 'string' || !row[field].trim())
-            throw invalid(configPath, `has an invalid or missing ${field}`);
-    for (const field of LEGACY_CONFIG_FIELDS)
-        if (Object.prototype.hasOwnProperty.call(row, field))
-            throw invalid(configPath, `cannot combine ${field} with explicit profile selection`);
-    for (const field of LEGACY_ENV_FIELDS)
-        if (env[field]?.trim())
-            throw invalid(configPath, `cannot combine ${field} with explicit profile selection`);
-    const endpoint = row.endpoint.trim();
-    let url;
-    try {
-        url = new URL(endpoint);
-    }
-    catch {
-        throw invalid(configPath, 'has an invalid endpoint');
-    }
-    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 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({
-        ...(serverUrl === undefined ? {} : { serverUrl }),
-        endpoint: normalizeDaemonEndpoint(endpoint), expectedInstanceId, credentialPath, configPath,
-    });
-}
+import { clientProfilePath, readGatewayClientProfile } from '@ours.network/sdk/client';
+export { ClientProfileError } from '@ours.network/sdk/client';
+export const clientConfigPath = clientProfilePath;
+export const readClientProfile = readGatewayClientProfile;
 export function clientProfileKey(profile) {
     return `${profile.endpoint}#${profile.expectedInstanceId}`;
 }

package/dist/config.d.ts

@@ -2,6 +2,7 @@ import { type ConfigDiagnostic, type YamlMode } from './config-yaml.js';
 import type { IsolationConfig, WrapContext } from './isolation/types.js';
 import type { ResolvedWatchdog } from './watchdog/config.js';
 import type { AgentLoopsConfig, ResolvedLoop, ResolvedRoleLoop } from './loops/config.js';
+import { validateRoomsConfig } from './rooms-tasks/config.js';
 export interface OverseeEntry {
     agent: string;
     interval: string;
@@ -35,6 +36,23 @@ export type FilesystemMode = 'read-only' | 'workspace' | 'unrestricted';
 export type UnattendedMode = 'deny' | 'wait';
 /** Monitor wake policy: preserve legacy booleans and add one explicit safe boundary. */
 export type MonitorInterrupt = boolean | 'after_tool';
+/**
+ * Workflows Fleet prepares native harness execution policy for. Declared per
+ * Agent; never inferred from a role's name or persona, and never inherited.
+ */
+export declare const MANAGED_CLI_WORKFLOW_IDS: readonly ["task-workflow"];
+export type ManagedCliWorkflowId = (typeof MANAGED_CLI_WORKFLOW_IDS)[number];
+/** Retired opt-in. Both keys are accepted so existing manifests load, and neither has any effect. */
+export interface FileDeliveryConfig {
+    enabled?: boolean;
+    directory?: string;
+}
+/**
+ * Current-chat file delivery is on for every Agent and takes the path the Agent
+ * provides. A legacy block is shape-checked only: `enabled: false` does not turn
+ * delivery off and `directory` does not restrict or create anything.
+ */
+export declare function validateFileDelivery(value: unknown): FileDeliveryConfig | undefined;
 export interface CommonPermissions {
     approval: ApprovalMode;
     filesystem: FilesystemMode;
@@ -145,6 +163,10 @@ export interface RoleConfig {
     owner_channel?: OwnerChannelConfigInput;
     worklog?: WorklogPolicyInput;
     auth_proxy?: Partial<AuthProxyConfig>;
+    /** Fleet-prepared CLI workflows this role may run outside its command sandbox. */
+    managed_cli?: ManagedCliWorkflowId[];
+    /** Retired and ignored; current-chat file delivery needs no Agent setting. */
+    file_delivery?: FileDeliveryConfig;
 }
 export type AgentSelection<T extends Record<string, unknown> = Record<string, unknown>> = {
     ref: string;
@@ -166,6 +188,10 @@ export interface AgentDefinition {
     owner_channel?: OwnerChannelConfigInput;
     worklog?: WorklogPolicyInput;
     auth_proxy?: Partial<AuthProxyConfig>;
+    /** Fleet-prepared CLI workflows this Agent may run outside its command sandbox. */
+    managed_cli?: ManagedCliWorkflowId[];
+    /** Retired and ignored; current-chat file delivery needs no Agent setting. */
+    file_delivery?: FileDeliveryConfig;
     /** Scheduled turns scoped only to temporary launches; persistent Agents reject this field. */
     loops?: AgentLoopsConfig;
 }
@@ -178,6 +204,9 @@ export interface AgentTemplateInstance {
 }
 /** Internal first-boot payload for a Fleet-provisioned Cowork room member. */
 export interface RoomMemberStartup {
+    /** Task ownership; absent for standalone rooms and legacy snapshots. */
+    task_id?: string;
+    workspace?: import('./rooms-tasks/workspace.js').OwnedWorkspace;
     room_id: string;
     room_identity_cid: string;
     identity_name: string;
@@ -298,6 +327,8 @@ export declare function validateBrainValue(value: BarePreset, file: string, poin
 export declare function validateEffectiveAgentTemplate(definition: AgentTemplateDefinition, id?: string): AgentTemplateDefinition;
 export declare function assertBareKeys(value: unknown, allowed: string[], label: string): BarePreset;
 export declare function splitRootFor(base: string): string;
+/** Read only room connection/owner settings for an existing layout. */
+export declare function loadRoomsConfig(configPath?: string): ReturnType<typeof validateRoomsConfig>;
 /** Load a v2 manifest and bare Agent/Role/Brain documents from its stem directory. */
 export declare function loadConfig(configPath?: string, options?: {
     yamlMode?: YamlMode;
@@ -307,6 +338,8 @@ export declare function loadConfig(configPath?: string, options?: {
         temporary?: boolean;
     };
     skipWatchdogs?: boolean;
+    /** The one Owner invitation file that tunnel setup writes itself and that may therefore still be absent. */
+    deferredOwnerInviteFile?: string;
 }): FleetConfig;
 /** Full read-only Agent resolution used by launch dry-runs and room plan validation. */
 export declare function resolveAgentDefinitionDryRun(configPath: string, id: string, definition: AgentDefinition): ResolvedRole;
@@ -331,10 +364,22 @@ export declare function resolvePermissions(defaults: unknown, role: Partial<Comm
  * malformed block so a typo fails loudly rather than silently disarming a monitor.
  * Exported so temp-spawn (which builds a ResolvedRole by hand) resolves identically.
  */
+/**
+ * A monitor without an explicit `interrupt` steers wakes at the next tool
+ * boundary. Hermes cannot, so its default stays non-interrupting; sessions
+ * without tool-boundary steering fall back to non-cancelling delivery.
+ */
+export declare function defaultMonitorInterrupt(harness: string | undefined): MonitorInterrupt;
+/**
+ * Resolve a persisted temporary-role monitor. A snapshot written before
+ * monitor.interrupt existed keeps the non-interrupting delivery it ran with.
+ */
+export declare function resolveSnapshotMonitor(monitor: unknown): MonitorConfig;
 export declare function resolveMonitorConfig(defMonitor: unknown, roleMonitor?: Partial<MonitorConfig>, labels?: {
     base?: string;
     file?: string;
     name?: string;
+    harness?: string;
 }): MonitorConfig;
 export declare function findRole(cfg: FleetConfig, name: string): ResolvedRole;
 export {};

package/dist/config.js

@@ -24,6 +24,25 @@ export const NOTIFY_EVENT_TYPES = [
     'message_received', 'file_received', 'sibling_contact_added', 'local_contact_request',
     'pending_message', 'contact_restored', 'inbound_error', 'state_import_failed',
 ];
+/**
+ * Workflows Fleet prepares native harness execution policy for. Declared per
+ * Agent; never inferred from a role's name or persona, and never inherited.
+ */
+export const MANAGED_CLI_WORKFLOW_IDS = ['task-workflow'];
+/**
+ * Current-chat file delivery is on for every Agent and takes the path the Agent
+ * provides. A legacy block is shape-checked only: `enabled: false` does not turn
+ * delivery off and `directory` does not restrict or create anything.
+ */
+export function validateFileDelivery(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isPlainObject(value) || Object.keys(value).some(k => !['enabled', 'directory'].includes(k))
+        || (value.enabled !== undefined && typeof value.enabled !== 'boolean')
+        || (value.directory !== undefined && typeof value.directory !== 'string'))
+        throw new ConfigError('file_delivery is retired and ignored; it accepts only the legacy enabled:boolean and directory:string keys');
+    return value;
+}
 /** Default wake sources when a role does not list its own. */
 export const DEFAULT_WAKE_SOURCES = ['message_received', 'file_received', 'local_contact_request', 'pending_message'];
 const MONITOR_KEYS = [
@@ -139,7 +158,7 @@ export const ROLE_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
 const ROLE_KEYS = [
     'harness', 'session', 'session_options', 'permissions', 'identity', 'cwd', 'coordinator', 'mission', 'persona', 'bio',
     'briefing_file', 'model', 'effort', 'model_chain', 'max_tokens', 'autocompact_pct', 'env', 'oversee', 'harness_options',
-    'isolation', 'monitor', 'owner_channel', 'worklog', 'auth_proxy',
+    'isolation', 'monitor', 'owner_channel', 'worklog', 'auth_proxy', 'managed_cli', 'file_delivery',
 ];
 export const ROLE_PRESET_KEYS = ['mission', 'persona', 'bio', 'briefing_file'];
 export const BRAIN_PRESET_KEYS = [
@@ -148,7 +167,7 @@ export const BRAIN_PRESET_KEYS = [
 ];
 export const AGENT_KEYS = [
     'role', 'brain', 'permissions', 'identity', 'cwd', 'coordinator', 'env', 'oversee',
-    'isolation', 'monitor', 'owner_channel', 'worklog', 'auth_proxy', 'loops',
+    'isolation', 'monitor', 'owner_channel', 'worklog', 'auth_proxy', 'loops', 'managed_cli', 'file_delivery',
 ];
 const AGENT_INSTANCE_KEYS = ['template', 'overrides'];
 const TEMPLATE_FORBIDDEN_KEYS = ['identity'];
@@ -194,6 +213,7 @@ export function validateBrainValue(value, file, pointer) {
 }
 /** Pure launch-boundary validation for a fully resolved temporary Agent definition. */
 export function validateEffectiveAgentTemplate(definition, id = 'room-member') {
+    validateFileDelivery(definition.file_delivery);
     const value = structuredClone(definition);
     const bad = Object.keys(value).filter(key => !AGENT_KEYS.includes(key));
     if (bad.length)
@@ -236,6 +256,12 @@ function validateAgentScalars(value, file, id) {
         if (current !== undefined && (typeof current !== 'string' || !current.trim()))
             schemaError(file, `/agents/${id}/${key}`, 'must be a non-blank string');
     }
+    if (value.managed_cli !== undefined) {
+        const ids = value.managed_cli;
+        if (!Array.isArray(ids) || ids.some(entry => !MANAGED_CLI_WORKFLOW_IDS.includes(entry))
+            || new Set(ids).size !== ids.length)
+            schemaError(file, `/agents/${id}/managed_cli`, `must be a list of distinct workflow IDs; supported: ${MANAGED_CLI_WORKFLOW_IDS.join(', ')}`);
+    }
     if (value.coordinator !== undefined
         && (typeof value.coordinator !== 'string' || !ROLE_NAME_RE.test(value.coordinator)))
         schemaError(file, `/agents/${id}/coordinator`, 'must be a valid Agent ID');
@@ -575,6 +601,13 @@ function deepSub(v, vars) {
         return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, deepSub(x, vars)]));
     return v;
 }
+/** Read only room connection/owner settings for an existing layout. */
+export function loadRoomsConfig(configPath = defaultConfigPath()) {
+    assertTrustedPath(configPath, 'file');
+    const doc = parseFleetDocument(configPath, readFileSync(configPath, 'utf8')).value;
+    const vars = (doc.vars ?? {});
+    return validateRoomsConfig(deepSub(doc.rooms, vars), vars, configPath);
+}
 /** Load a v2 manifest and bare Agent/Role/Brain documents from its stem directory. */
 export function loadConfig(configPath, options = {}) {
     const base = configPath ?? defaultConfigPath();
@@ -628,6 +661,7 @@ export function loadConfig(configPath, options = {}) {
             const bad = Object.keys(r).filter(k => !ROLE_KEYS.includes(k));
             if (bad.length)
                 throw new ConfigError(`${file}: role '${name}' has unknown key(s) ${bad.join(', ')}; allowed: ${ROLE_KEYS.join(', ')}`);
+            validateFileDelivery(r.file_delivery);
             const isolation = r.isolation ?? defaults.isolation;
             const session = resolveSession(r.session ?? defaults.session, file, name);
             const sessionOptions = resolveSessionOptions(defaults.session_options, r.session_options, session, file, name);
@@ -649,11 +683,11 @@ export function loadConfig(configPath, options = {}) {
                 if (problems.length)
                     throw new ConfigError(`${file}: role '${name}' ${problems.join('; ')}`);
             }
-            const monitor = resolveMonitorConfig(defaults.monitor, r.monitor, { base, file, name });
+            const harness = r.harness ?? defaults.harness ?? 'claude-code';
+            const monitor = resolveMonitorConfig(defaults.monitor, r.monitor, { base, file, name, harness });
             const ownerChannel = resolveOwnerChannelConfig(defaults.owner_channel, r.owner_channel, session, file, name);
             const worklog = resolveWorklogPolicy(defaults.worklog, r.worklog, file, name);
             const authProxy = resolveAuthProxy(defaults.auth_proxy, r.auth_proxy, file, name);
-            const harness = r.harness ?? defaults.harness ?? 'claude-code';
             if (session === 'codex-app-server' && harness !== 'codex')
                 throw new ConfigError(`${file}: role '${name}' session: codex-app-server requires harness: codex`);
             const defaultHarness = defaults.harness ?? 'claude-code';
@@ -757,7 +791,7 @@ export function loadConfig(configPath, options = {}) {
         if (doc.rooms !== undefined) {
             if (rooms)
                 throw new ConfigError(`rooms: defined in multiple files; last: ${file}`);
-            const validated = validateRoomsConfig(deepSub(doc.rooms, vars), vars, file);
+            const validated = validateRoomsConfig(deepSub(doc.rooms, vars), vars, file, options.deferredOwnerInviteFile);
             ownerInviteFingerprint = validated._invite?.fingerprint;
             ownerInvite = validated._invite?.value;
             const { _invite: _, ...clean } = validated;
@@ -1135,6 +1169,23 @@ function resolveStartStaggerMs(raw, base) {
  * malformed block so a typo fails loudly rather than silently disarming a monitor.
  * Exported so temp-spawn (which builds a ResolvedRole by hand) resolves identically.
  */
+/**
+ * A monitor without an explicit `interrupt` steers wakes at the next tool
+ * boundary. Hermes cannot, so its default stays non-interrupting; sessions
+ * without tool-boundary steering fall back to non-cancelling delivery.
+ */
+export function defaultMonitorInterrupt(harness) {
+    return harness === 'hermes' ? false : 'after_tool';
+}
+/**
+ * Resolve a persisted temporary-role monitor. A snapshot written before
+ * monitor.interrupt existed keeps the non-interrupting delivery it ran with.
+ */
+export function resolveSnapshotMonitor(monitor) {
+    if (!isPlainObject(monitor))
+        return resolveMonitorConfig(undefined, monitor);
+    return resolveMonitorConfig(undefined, { interrupt: false, ...monitor });
+}
 export function resolveMonitorConfig(defMonitor, roleMonitor, labels = {}) {
     const where = labels.file && labels.name ? `${labels.file}: role '${labels.name}' ` : '';
     if (defMonitor !== undefined && !isPlainObject(defMonitor))
@@ -1169,7 +1220,7 @@ export function resolveMonitorConfig(defMonitor, roleMonitor, labels = {}) {
         wake_sources: merged.wake_sources ?? [...DEFAULT_WAKE_SOURCES],
         batch_ms: merged.batch_ms ?? MONITOR_DEFAULT_BATCH_MS,
         inject: merged.inject ?? 'notification',
-        interrupt: merged.interrupt ?? false,
+        interrupt: merged.interrupt ?? defaultMonitorInterrupt(labels.harness),
         ...(merged.stall_recovery !== undefined ? { stall_recovery: merged.stall_recovery } : {}),
         ...(merged.stall_timeout_ms !== undefined ? { stall_timeout_ms: merged.stall_timeout_ms } : {}),
         turn_fail_threshold: merged.turn_fail_threshold ?? MONITOR_DEFAULT_TURN_FAIL_THRESHOLD,

package/dist/creation.d.ts

@@ -153,7 +153,7 @@ export interface DaemonIdentityProvisionerOptions {
 export declare function daemonIdentityProvisioner(env?: NodeJS.ProcessEnv, attachClient?: (options: AttachOursClientOptions) => Promise<IdentityInventoryClient>, options?: DaemonIdentityProvisionerOptions): IdentityProvisioner;
 /** Inventory-only variant for session-owned temporary identity lifecycles. */
 export declare function daemonIdentityInventoryProvisioner(env?: NodeJS.ProcessEnv, attachClient?: (options: AttachOursClientOptions) => Promise<IdentityInventoryClient>): IdentityProvisioner;
-/** Atomically write a bare Agent file, journalling it for rollback. */
+/** Atomically write an owner-private Agent file, journalling it for rollback. */
 export declare function writeRoleFile(tx: CreationTransaction, file: string, contents: string): void;
 /** Where a setting's effective value came from. */
 export type ProvenanceSource = 'cli' | 'agent-template' | 'fleet-default' | 'caller-role' | 'built-in';

package/dist/creation.js

@@ -213,10 +213,10 @@ export async function ensureIdentity(name, profile, provisioner, log = () => { }
 export function daemonIdentityProvisioner(env = process.env, attachClient = attachOursClient, options = {}) {
     const connect = (leaseToken) => {
         const profile = readClientProfile(env);
-        return attachClient(profile ? {
+        return attachClient({
             endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
             credentialPath: profile.credentialPath, sessionMode: 'external', leaseToken, env: {},
-        } : { env, leaseToken, clientPid: process.pid });
+        });
     };
     const provisioner = {
         async exists(name) {
@@ -294,10 +294,10 @@ export function daemonIdentityInventoryProvisioner(env = process.env, attachClie
         acceptTemporaryExisting: true,
     });
 }
-/** Atomically write a bare Agent file, journalling it for rollback. */
+/** Atomically write an owner-private Agent file, journalling it for rollback. */
 export function writeRoleFile(tx, file, contents) {
     const existed = existsSync(file);
-    replaceFileAtomically(file, contents, 0o644);
+    replaceFileAtomically(file, contents, 0o600);
     tx.record({
         stage: `Agent file ${file}`,
         // Only remove what THIS transaction created; never delete a file the

package/dist/daemon-recovery.d.ts

@@ -34,14 +34,7 @@ interface GenerationProbeDeps {
     canonicalize?(path: string): string;
     attachClient?(options: AttachOursClientOptions): Pick<OursClient, 'version' | 'identities' | 'close'> | Promise<Pick<OursClient, 'version' | 'identities' | 'close'>>;
 }
-/**
- * Corroborate the loopback daemon's unauthenticated `/info`, its credentialed
- * identity-index readiness route, and its local boot-generation record. The
- * index enforces auth when the daemon visibility requires it; open visibility
- * deliberately does not. No source is sufficient
- * alone: `/info` has no boot id, the identity index has no generation, and a
- * stale `ready` file can outlive the process that wrote it.
- */
+/** Read generation and readiness through the selected gateway. Server paths are opaque. */
 export declare function probeDaemonGeneration(fetch: FetchLike, env: NodeJS.ProcessEnv, deps?: GenerationProbeDeps): Promise<DaemonGenerationProbe>;
 export declare class DaemonGenerationObserver {
     private current?;

package/dist/daemon-recovery.js

@@ -1,8 +1,7 @@
-import { readFileSync, realpathSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { attachOursClient, } from '@ours.network/sdk/client';
-import { readDaemonConfig, resolveEndpoint } from './monitor.js';
 import { readClientProfile } from './client-profile.js';
 import { replaceFileAtomically } from './atomic-file.js';
 export const DAEMON_RECOVERY_MAX_ATTEMPTS = 6;
@@ -39,129 +38,25 @@ function startupProgress(value) {
         return undefined;
     return row;
 }
-function canonical(path, deps) {
-    const absolute = resolve(path);
-    return deps.canonicalize?.(absolute) ?? realpathSync.native(absolute);
-}
-/**
- * Corroborate the loopback daemon's unauthenticated `/info`, its credentialed
- * identity-index readiness route, and its local boot-generation record. The
- * index enforces auth when the daemon visibility requires it; open visibility
- * deliberately does not. No source is sufficient
- * alone: `/info` has no boot id, the identity index has no generation, and a
- * stale `ready` file can outlive the process that wrote it.
- */
+/** Read generation and readiness through the selected gateway. Server paths are opaque. */
 export async function probeDaemonGeneration(fetch, env, deps = {}) {
-    const profile = readClientProfile(env);
-    if (profile || env.OURS_DAEMON_ID)
-        return probeSelectedDaemon(env, deps, profile);
-    const endpoint = resolveEndpoint(env);
-    let response;
-    try {
-        response = await fetch(`${endpoint.origin}/info`, { headers: endpoint.headers });
-    }
-    catch {
-        return { state: 'unavailable', reason: 'DAEMON_INFO_UNREACHABLE' };
-    }
-    if (!response.ok)
-        return {
-            state: 'unavailable',
-            reason: response.status === 401 ? 'DAEMON_INFO_UNAUTHORIZED' : 'DAEMON_INFO_HTTP_ERROR',
-        };
-    let info;
-    try {
-        const value = await response.json();
-        if (!value || typeof value !== 'object' || Array.isArray(value))
-            throw new Error('shape');
-        info = value;
-    }
-    catch {
-        return { state: 'unavailable', reason: 'DAEMON_INFO_INVALID' };
-    }
-    if (info.name !== 'ours' || !positiveInteger(info.pid)
-        || typeof info.stateDir !== 'string' || info.stateDir.length === 0)
-        return { state: 'unavailable', reason: 'DAEMON_INFO_INVALID' };
-    let reportedStateDir;
-    let expectedStateDir;
-    try {
-        reportedStateDir = canonical(info.stateDir, deps);
-        expectedStateDir = canonical(endpoint.stateDir, deps);
-    }
-    catch {
-        return { state: 'unavailable', reason: 'DAEMON_STATE_DIR_UNAVAILABLE' };
-    }
-    if (reportedStateDir !== expectedStateDir)
-        return { state: 'unavailable', reason: 'DAEMON_STATE_DIR_MISMATCH' };
-    // `/identities` is the daemon's credential-capable readiness route. A
-    // valid-but-empty index is a documented intermediate startup state, never
-    // proof of readiness.
-    let identitiesResponse;
-    try {
-        identitiesResponse = await fetch(`${endpoint.origin}/identities`, { headers: endpoint.headers });
-    }
-    catch {
-        return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_UNREACHABLE' };
-    }
-    if (!identitiesResponse.ok)
-        return {
-            state: 'unavailable',
-            reason: identitiesResponse.status === 401
-                ? 'DAEMON_IDENTITIES_UNAUTHORIZED' : 'DAEMON_IDENTITIES_HTTP_ERROR',
-        };
-    try {
-        const body = await identitiesResponse.json();
-        if (!body || typeof body !== 'object' || Array.isArray(body)
-            || !Array.isArray(body.identities))
-            return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_INVALID' };
-        if (body.identities.length === 0)
-            return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_NOT_READY' };
-    }
-    catch {
-        return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_INVALID' };
-    }
-    let progress;
     try {
-        const text = deps.readText?.(join(reportedStateDir, 'startup-progress.json'))
-            ?? readFileSync(join(reportedStateDir, 'startup-progress.json'), 'utf8');
-        progress = startupProgress(JSON.parse(text));
+        return await probeSelectedDaemon(deps, readClientProfile(env));
     }
     catch {
-        return { state: 'unavailable', reason: 'DAEMON_PROGRESS_UNAVAILABLE' };
+        return { state: 'unavailable', reason: 'CLIENT_GATEWAY_PROFILE_INVALID' };
     }
-    if (!progress)
-        return { state: 'unavailable', reason: 'DAEMON_PROGRESS_INVALID' };
-    if (progress.phase !== 'ready')
-        return { state: 'unavailable', reason: 'DAEMON_PROGRESS_NOT_READY' };
-    if (progress.pid !== info.pid)
-        return { state: 'unavailable', reason: 'DAEMON_GENERATION_MISMATCH' };
-    return {
-        state: 'ready',
-        generation: {
-            // Keep bootId opaque. Its current writer uses `${pid}-${startedAt}`, but
-            // equality—not its formatting—is the generation contract Fleet needs.
-            bootId: progress.bootId,
-            pid: progress.pid,
-            startedAt: progress.startedAt,
-            stateDir: reportedStateDir,
-        },
-    };
 }
 /** Container selection uses public SDK reads; daemon paths/PIDs remain opaque metadata. */
-async function probeSelectedDaemon(env, deps, profile) {
+async function probeSelectedDaemon(deps, profile) {
     // Defer credential-file access to SDK selection, which checks the configured
     // daemon identity/capability before it reads or sends the credential.
-    const endpoint = profile ? undefined : resolveEndpoint(env, false);
-    const token = profile ? undefined : env.OURS_API_TOKEN?.trim() || readDaemonConfig(env).apiToken;
     let client;
     try {
-        const options = profile ? {
+        const options = {
             endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
             credentialPath: profile.credentialPath,
             sessionMode: 'external', leaseToken: randomUUID(), env: {},
-        } : {
-            endpoint: endpoint.origin, expectedInstanceId: env.OURS_DAEMON_ID,
-            sessionMode: 'external', leaseToken: randomUUID(),
-            ...(token ? { token } : { credentialPath: join(endpoint.stateDir, 'daemon-token') }),
         };
         client = await (deps.attachClient?.(options) ?? attachOursClient(options));
         const info = await client.version({ startup: true });
@@ -189,7 +84,7 @@ async function probeSelectedDaemon(env, deps, profile) {
         return { state: 'unavailable', reason: 'DAEMON_SELECTED_PROBE_UNAVAILABLE' };
     }
     finally {
-        await client?.close();
+        await client?.close().catch(() => undefined);
     }
 }
 export class DaemonGenerationObserver {