@ours.network/fleet 1.1.5 → 1.2.0-nightly.10

package/dist/cli.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import { waitForRoleDaemon } from './startup-readiness.js';
+import { SupervisorOursTools } from './application/supervisor-ours-tools.js';
+import { runTempSupervisor, TEMP_RECYCLE_EXIT } from './temp-supervisor-recovery.js';
 import { spawn as spawnChild } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, statSync } from 'node:fs';
@@ -9,7 +12,7 @@ import { Command } from 'commander';
 import { VERSION } from './version.js';
 import { INIT_COMPLETION_GUIDANCE } from './init-guidance.js';
 import { migrateLegacyStarterPresets, migratePackagedRoleDefaults } from './preset-migration.js';
-import { executeInitWizard, isInteractiveTerminal, publishSetup, TerminalPrompter, } from './init-wizard.js';
+import { executeInitAnswers, executeInitWizard, isInteractiveTerminal, publishSetup, readInitSettings, TerminalPrompter, } from './init-wizard.js';
 import { analyzeInstalls, buildInfo, buildLabel, discoverInstalls, runningLabel, } from './provenance.js';
 import { agentDir, agentsRoot, tmpRoot, logsRoot, deriveXdgRuntimeDir, defaultConfigPath } from './paths.js';
 import { findRole, loadConfig, ROLE_NAME_RE } from './config.js';
@@ -17,7 +20,7 @@ import { formatDuration } from './duration.js';
 import { redactSensitive, resolvedPlan, resolvedRolePlan } from './resolved-plan.js';
 import { pickBackend } from './supervisor/index.js';
 import { up, down } from './ops.js';
-import { readRestartLedger, runSupervised, runTemp } from './runner.js';
+import { readRestartLedger, runSupervised, runTemp, SupervisorRecycleRequiredError } from './runner.js';
 import { executeWatchdogRun, runWatchdogAgent } from './watchdog/run.js';
 import { readSchedulerState, resetSchedulerState, runScheduler } from './watchdog/scheduler.js';
 import { partitionRestartNames } from './watchdog/config.js';
@@ -495,6 +498,40 @@ program.command('peek <name> [lines]').description('pane snapshot without attach
         die(controlFailure(name, 'peek', e));
     }
 });
+const oursToolsCommand = program.command('ours').description('invoke tools through a named agent supervisor and its fixed identity');
+oursToolsCommand.command('tools <agent>').description('list the same tools and schemas exposed to the agent MCP')
+    .action(async (agent) => {
+    try {
+        console.log(JSON.stringify(await new SupervisorOursTools().list(agent), null, 2));
+    }
+    catch (error) {
+        die(error);
+    }
+});
+oursToolsCommand.command('call <agent> <tool>').description('call a supervisor MCP tool without prompting the agent')
+    .option('--args-file <path>', 'JSON object arguments from a private file; omitted means {}')
+    .action(async (agent, tool, options) => {
+    try {
+        let args = {};
+        if (options.argsFile) {
+            try {
+                args = JSON.parse(readFileSync(options.argsFile, 'utf8'));
+            }
+            catch {
+                throw new Error('cannot read tool arguments: expected a readable JSON object file');
+            }
+        }
+        const response = await new SupervisorOursTools().call(agent, { tool, arguments: args });
+        console.log(JSON.stringify(response, null, 2));
+        if ('isError' in response.result && response.result.isError)
+            throw new FleetCliExit(1, 'runtime', 'unknown');
+    }
+    catch (error) {
+        if (error instanceof FleetCliExit)
+            throw error;
+        die(error);
+    }
+});
 program.command('send <name> [text...]').description("type into the agent's console")
     .action(async (name, text, opts) => {
     const stateDir = acpStateDir(name);
@@ -1269,13 +1306,14 @@ cOpt(program.command('doctor').description('prerequisite report'))
     if (!rep.ok)
         throw new FleetCliExit(1);
 });
-cOpt(program.command('init').description('interactively add missing Fleet defaults while preserving existing configuration'))
+cOpt(program.command('init').description('add missing Fleet defaults while preserving existing configuration')
+    .option('--settings <file>', 'validated InitAnswers JSON; runs without interactive questions'))
     .action(async (opts) => {
     const configuration = opts.configuration ?? defaultConfigPath();
-    if (!isInteractiveTerminal(process.stdin, process.stdout))
+    if (!opts.settings && !isInteractiveTerminal(process.stdin, process.stdout))
         die('ours-fleet init requires an interactive terminal; no host setup ran and no configuration changed');
     try {
-        const result = await executeInitWizard(new TerminalPrompter(process.stdin, process.stdout), configuration, {
+        const initDeps = {
             async hostSetup() {
                 for (const d of [agentsRoot(), tmpRoot(), logsRoot()])
                     mkdirSync(d, { recursive: true });
@@ -1283,10 +1321,13 @@ cOpt(program.command('init').description('interactively add missing Fleet defaul
                     console.log(message);
             },
             publish: publishSetup,
-        });
+        };
+        const result = opts.settings
+            ? await executeInitAnswers(readInitSettings(opts.settings), configuration, initDeps)
+            : await executeInitWizard(new TerminalPrompter(process.stdin, process.stdout), configuration, initDeps);
         if (!result) {
             console.log('Fleet setup cancelled. No host setup ran and no configuration changed.');
-            return;
+            throw new FleetCliExit(1);
         }
         const prior = result.manifestExisted && result.rootExisted ? 'manifest and split configuration'
             : result.manifestExisted ? 'manifest only'
@@ -1297,6 +1338,8 @@ cOpt(program.command('init').description('interactively add missing Fleet defaul
         console.log(INIT_COMPLETION_GUIDANCE);
     }
     catch (error) {
+        if (error instanceof FleetCliExit)
+            throw error;
         die(error);
     }
 });
@@ -1537,6 +1580,16 @@ function configureWebAccess(opts) {
 registerTemplateCommands(program, cOpt);
 registerTaskCommands(program, cOpt);
 registerRoomCommands(program, cOpt);
+program.command('_wait-daemon <name>', { hidden: true }).description('internal: service startup readiness')
+    .option('-c, --configuration <file>')
+    .action(async (name, opts) => {
+    try {
+        await waitForRoleDaemon(name, opts.configuration);
+    }
+    catch (e) {
+        die(e);
+    }
+});
 program.command('_run <name>', { hidden: true }).description('internal: supervisor entrypoint')
     .option('-c, --configuration <file>')
     .action(async (name, opts) => {
@@ -1552,12 +1605,24 @@ program.command('_run <name>', { hidden: true }).description('internal: supervis
 program.command('_run-temp <name>', { hidden: true }).description('internal: temp-agent entrypoint')
     .action(async (name) => {
     try {
-        await runTemp(name);
+        await runTempSupervisor(name, process.argv[1]);
     }
     catch (e) {
         die(e);
     }
 });
+program.command('_run-temp-worker <name>', { hidden: true })
+    .action(async (name) => {
+    try {
+        await runTemp(name);
+    }
+    catch (error) {
+        if (error instanceof SupervisorRecycleRequiredError)
+            process.exitCode = TEMP_RECYCLE_EXIT;
+        else
+            die(error);
+    }
+});
 program.command('_run-watchdog <name>', { hidden: true })
     .description('internal: one watchdog agent run (no cleanup — parent harvests)')
     .action(async (name) => {
@@ -1593,6 +1658,8 @@ async function parseFleetCli() {
         await program.parseAsync(process.argv);
     }
     catch (error) {
+        if (error instanceof FleetCliExit)
+            throw error;
         const commander = error;
         if (commander.exitCode === 0)
             return;

package/dist/client-profile.d.ts

@@ -0,0 +1,18 @@
+export interface ExplicitClientProfile {
+    readonly endpoint: string;
+    readonly expectedInstanceId: string;
+    readonly credentialPath: string;
+    readonly configPath: string;
+    readonly serverUrl?: string;
+}
+export declare class ClientProfileError extends Error {
+    constructor(message: string);
+}
+export declare function clientConfigPath(env: NodeJS.ProcessEnv): string;
+/**
+ * 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 declare function readClientProfile(env: NodeJS.ProcessEnv): ExplicitClientProfile | undefined;
+export declare function clientProfileKey(profile: ExplicitClientProfile): string;

package/dist/client-profile.js

@@ -0,0 +1,130 @@
+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,
+    });
+}
+export function clientProfileKey(profile) {
+    return `${profile.endpoint}#${profile.expectedInstanceId}`;
+}

package/dist/config.d.ts

@@ -178,6 +178,7 @@ export interface AgentTemplateInstance {
 }
 /** Internal first-boot payload for a Fleet-provisioned Cowork room member. */
 export interface RoomMemberStartup {
+    workspace?: import('./rooms-tasks/workspace.js').OwnedWorkspace;
     room_id: string;
     room_identity_cid: string;
     identity_name: string;

package/dist/creation.d.ts

@@ -121,7 +121,7 @@ export type IdentityGuarantee = {
     detail: string;
 };
 /** Reconcile every permanent identity a role's supervisor owns before launch. */
-export declare function reconcilePermanentRoleIdentities(role: ResolvedRole, provisioner?: IdentityProvisioner, log?: (line: string) => void, knownRoleGuarantee?: IdentityGuarantee['state']): Promise<'verified' | 'created'>;
+export declare function reconcilePermanentRoleIdentities(role: ResolvedRole, provisioner?: IdentityProvisioner, log?: (line: string) => void, knownRoleGuarantee?: IdentityGuarantee['state']): Promise<'verified' | 'created' | 'unverified'>;
 /**
  * Establish the identity before the role's service is enabled.
  *

package/dist/creation.js

@@ -1,9 +1,11 @@
+import { preparePermanentAssignment } from './agent-ours/service.js';
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { attachOursClient, } from '@ours.network/sdk/client';
 import { replaceFileAtomically, withFileLock } from './atomic-file.js';
 import { stateRoot } from './paths.js';
+import { readClientProfile } from './client-profile.js';
 import { buildInfo, UNKNOWN_BUILD } from './provenance.js';
 /**
  * One creation transaction: role name and ours identity reserved together,
@@ -149,19 +151,7 @@ const requireGuaranteedIdentity = (role, identity, result) => {
 };
 /** Reconcile every permanent identity a role's supervisor owns before launch. */
 export async function reconcilePermanentRoleIdentities(role, provisioner = daemonIdentityProvisioner(), log = () => { }, knownRoleGuarantee) {
-    const roleResult = knownRoleGuarantee
-        ? {
-            state: knownRoleGuarantee,
-            evidence: knownRoleGuarantee === 'verified' ? 'verified' : 'missing',
-            detail: `identity was ${knownRoleGuarantee} by the creation transaction`,
-        }
-        : await ensureIdentity(role.identity, {
-            bio: role.bio,
-            persona: role.persona,
-            exposeLocal: true,
-            localAutoAccept: true,
-        }, provisioner, log);
-    const roleGuarantee = requireGuaranteedIdentity(role, role.identity, roleResult);
+    const guarantee = await preparePermanentAssignment(role);
     if (role.owner_channel) {
         const channelIdentity = role.owner_channel.identity;
         const channel = await ensureIdentity(channelIdentity, {
@@ -171,7 +161,7 @@ export async function reconcilePermanentRoleIdentities(role, provisioner = daemo
         }, provisioner, log);
         requireGuaranteedIdentity(role, channelIdentity, channel);
     }
-    return roleGuarantee.state;
+    return guarantee;
 }
 /**
  * Establish the identity before the role's service is enabled.
@@ -221,12 +211,17 @@ 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 ? {
+            endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath, sessionMode: 'external', leaseToken, env: {},
+        } : { env, leaseToken, clientPid: process.pid });
+    };
     const provisioner = {
         async exists(name) {
             try {
-                const client = await attachClient({
-                    env, leaseToken: `ours-fleet-identity-preflight-${process.pid}`, clientPid: process.pid,
-                });
+                const client = await connect(`ours-fleet-identity-preflight-${process.pid}`);
                 const identities = await client.identities();
                 if (!Array.isArray(identities))
                     return 'unknown';
@@ -248,10 +243,7 @@ export function daemonIdentityProvisioner(env = process.env, attachClient = atta
     if (options.createPermanent === false)
         return provisioner;
     provisioner.create = async (name, profile) => {
-        const client = await attachClient({
-            env, leaseToken: `ours-fleet-identity-create-${process.pid}-${randomUUID()}`,
-            clientPid: process.pid,
-        });
+        const client = await connect(`ours-fleet-identity-create-${process.pid}-${randomUUID()}`);
         if (!client.listIdentities || !client.createIdentity || !client.releaseLease)
             throw new Error('the selected ours SDK client cannot create permanent identities');
         try {

package/dist/daemon-recovery.d.ts

@@ -1,3 +1,4 @@
+import { type AttachOursClientOptions, type OursClient } from '@ours.network/sdk/client';
 import { type FetchLike } from './monitor.js';
 export declare const DAEMON_RECOVERY_MAX_ATTEMPTS = 6;
 export declare const DAEMON_RECOVERY_INITIAL_BACKOFF_MS = 1000;
@@ -31,6 +32,7 @@ export type DaemonGenerationObservation = {
 interface GenerationProbeDeps {
     readText?(path: string): string;
     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

package/dist/daemon-recovery.js

@@ -1,7 +1,9 @@
 import { readFileSync, realpathSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { createHash } from 'node:crypto';
-import { resolveEndpoint } from './monitor.js';
+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;
 export const DAEMON_RECOVERY_INITIAL_BACKOFF_MS = 1_000;
@@ -50,6 +52,9 @@ function canonical(path, deps) {
  * stale `ready` file can outlive the process that wrote it.
  */
 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 {
@@ -141,6 +146,52 @@ export async function probeDaemonGeneration(fetch, env, deps = {}) {
         },
     };
 }
+/** Container selection uses public SDK reads; daemon paths/PIDs remain opaque metadata. */
+async function probeSelectedDaemon(env, 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 ? {
+            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 });
+        if (info.name !== 'ours' || !positiveInteger(info.pid)
+            || typeof info.stateDir !== 'string' || !info.stateDir)
+            return { state: 'unavailable', reason: 'DAEMON_INFO_INVALID' };
+        const progress = startupProgress(info.startup);
+        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' };
+        const identities = await client.identities();
+        if (!Array.isArray(identities))
+            return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_INVALID' };
+        if (!identities.length)
+            return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_NOT_READY' };
+        return { state: 'ready', generation: {
+                bootId: progress.bootId, pid: progress.pid, startedAt: progress.startedAt, stateDir: info.stateDir,
+            } };
+    }
+    catch {
+        // Failed selection, auth or transport is unavailable, never owner death.
+        return { state: 'unavailable', reason: 'DAEMON_SELECTED_PROBE_UNAVAILABLE' };
+    }
+    finally {
+        await client?.close();
+    }
+}
 export class DaemonGenerationObserver {
     current;
     unavailable = false;