This commit is contained in:
goals
@@ -102,7 +102,7 @@ mosaic yolo pi # Launch Pi in yolo mode
|
||||
The launcher:
|
||||
|
||||
1. Verifies `~/.config/mosaic` exists
|
||||
2. Verifies `SOUL.md` exists (auto-runs `mosaic init` if missing)
|
||||
2. Resolves identity: standalone launches auto-run `mosaic init` when `SOUL.md` is missing; exact roster-owned fleet launches atomically seed only missing `SOUL.md`/`USER.md` from generic `defaults/` and never prompt
|
||||
3. Injects `AGENTS.md` into the runtime
|
||||
4. Forwards all arguments to the runtime CLI
|
||||
|
||||
|
||||
@@ -0,0 +1,153 @@
|
||||
import {
|
||||
chmodSync,
|
||||
existsSync,
|
||||
mkdirSync,
|
||||
mkdtempSync,
|
||||
lstatSync,
|
||||
readFileSync,
|
||||
readdirSync,
|
||||
rmSync,
|
||||
statSync,
|
||||
symlinkSync,
|
||||
writeFileSync,
|
||||
} from 'node:fs';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { dirname, join } from 'node:path';
|
||||
import { afterEach, describe, expect, it } from 'vitest';
|
||||
import {
|
||||
linkIdentityContractNoClobber,
|
||||
seedFleetIdentityDefaults,
|
||||
} from './fleet-first-start-identity.js';
|
||||
|
||||
const roots: string[] = [];
|
||||
const DEFAULT_SOUL = '# Generic soul\n';
|
||||
const DEFAULT_USER = '# Generic user\n';
|
||||
|
||||
function writeFixture(path: string, content: string | Buffer, mode: number = 0o600): void {
|
||||
mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
|
||||
writeFileSync(path, content, { mode });
|
||||
chmodSync(path, mode);
|
||||
}
|
||||
|
||||
function createMosaicHome(): string {
|
||||
const root = mkdtempSync(join(tmpdir(), 'mosaic-identity-seed-'));
|
||||
roots.push(root);
|
||||
const mosaicHome = join(root, 'home', '.config', 'mosaic');
|
||||
writeFixture(join(mosaicHome, 'defaults', 'SOUL.md'), DEFAULT_SOUL);
|
||||
writeFixture(join(mosaicHome, 'defaults', 'USER.md'), DEFAULT_USER);
|
||||
return mosaicHome;
|
||||
}
|
||||
|
||||
function temporarySeeds(mosaicHome: string): string[] {
|
||||
return readdirSync(mosaicHome).filter((entry) => entry.includes('.fleet-seed-'));
|
||||
}
|
||||
|
||||
afterEach((): void => {
|
||||
for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
describe('linkIdentityContractNoClobber', () => {
|
||||
it('returns false and preserves a destination that already exists', () => {
|
||||
const mosaicHome = createMosaicHome();
|
||||
const source = join(mosaicHome, 'source.tmp');
|
||||
const destination = join(mosaicHome, 'destination.md');
|
||||
writeFixture(source, 'candidate\n');
|
||||
writeFixture(destination, 'operator\n');
|
||||
|
||||
expect(linkIdentityContractNoClobber(source, destination)).toBe(false);
|
||||
expect(readFileSync(destination, 'utf8')).toBe('operator\n');
|
||||
});
|
||||
|
||||
it('does not misclassify an unexpected link failure as a concurrent winner', () => {
|
||||
const mosaicHome = createMosaicHome();
|
||||
const missingSource = join(mosaicHome, 'missing.tmp');
|
||||
|
||||
expect(() =>
|
||||
linkIdentityContractNoClobber(missingSource, join(mosaicHome, 'destination.md')),
|
||||
).toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe('seedFleetIdentityDefaults', () => {
|
||||
it('publishes complete owner-private default snapshots', () => {
|
||||
const mosaicHome = createMosaicHome();
|
||||
|
||||
expect(seedFleetIdentityDefaults(mosaicHome)).toEqual(['SOUL.md', 'USER.md']);
|
||||
|
||||
for (const [entry, expected] of [
|
||||
['SOUL.md', DEFAULT_SOUL],
|
||||
['USER.md', DEFAULT_USER],
|
||||
] as const) {
|
||||
const path = join(mosaicHome, entry);
|
||||
expect(readFileSync(path, 'utf8')).toBe(expected);
|
||||
expect(statSync(path).mode & 0o777).toBe(0o600);
|
||||
}
|
||||
expect(temporarySeeds(mosaicHome)).toEqual([]);
|
||||
});
|
||||
|
||||
it('preserves an existing regular contract byte-for-byte and mode-for-mode', () => {
|
||||
const mosaicHome = createMosaicHome();
|
||||
const customSoul = '# Operator-owned soul\n';
|
||||
writeFixture(join(mosaicHome, 'SOUL.md'), customSoul, 0o640);
|
||||
|
||||
expect(seedFleetIdentityDefaults(mosaicHome)).toEqual(['USER.md']);
|
||||
expect(readFileSync(join(mosaicHome, 'SOUL.md'), 'utf8')).toBe(customSoul);
|
||||
expect(statSync(join(mosaicHome, 'SOUL.md')).mode & 0o777).toBe(0o640);
|
||||
});
|
||||
|
||||
it('is idempotent after both installed contracts exist', () => {
|
||||
const mosaicHome = createMosaicHome();
|
||||
|
||||
expect(seedFleetIdentityDefaults(mosaicHome)).toEqual(['SOUL.md', 'USER.md']);
|
||||
expect(seedFleetIdentityDefaults(mosaicHome)).toEqual([]);
|
||||
expect(temporarySeeds(mosaicHome)).toEqual([]);
|
||||
});
|
||||
|
||||
it('validates every required source before publishing any destination', () => {
|
||||
const mosaicHome = createMosaicHome();
|
||||
const missing = join(mosaicHome, 'defaults', 'USER.md');
|
||||
rmSync(missing);
|
||||
|
||||
expect(() => seedFleetIdentityDefaults(mosaicHome)).toThrow(
|
||||
`fleet identity default is unavailable or unsafe: ${missing}`,
|
||||
);
|
||||
expect(existsSync(join(mosaicHome, 'SOUL.md'))).toBe(false);
|
||||
expect(existsSync(join(mosaicHome, 'USER.md'))).toBe(false);
|
||||
});
|
||||
|
||||
it('refuses a symlinked default instead of following it', () => {
|
||||
const mosaicHome = createMosaicHome();
|
||||
const source = join(mosaicHome, 'defaults', 'SOUL.md');
|
||||
rmSync(source);
|
||||
symlinkSync(join(mosaicHome, 'defaults', 'USER.md'), source);
|
||||
|
||||
expect(() => seedFleetIdentityDefaults(mosaicHome)).toThrow(
|
||||
`fleet identity default is unavailable or unsafe: ${source}`,
|
||||
);
|
||||
expect(existsSync(join(mosaicHome, 'SOUL.md'))).toBe(false);
|
||||
});
|
||||
|
||||
it('refuses an existing symlinked destination without replacing it', () => {
|
||||
const mosaicHome = createMosaicHome();
|
||||
const destination = join(mosaicHome, 'SOUL.md');
|
||||
symlinkSync(join(mosaicHome, 'defaults', 'SOUL.md'), destination);
|
||||
|
||||
expect(() => seedFleetIdentityDefaults(mosaicHome)).toThrow(
|
||||
`fleet identity installed is unavailable or unsafe: ${destination}`,
|
||||
);
|
||||
expect(lstatSync(destination).isSymbolicLink()).toBe(true);
|
||||
expect(existsSync(join(mosaicHome, 'USER.md'))).toBe(false);
|
||||
});
|
||||
|
||||
it('rejects an oversized source before publishing a partial identity', () => {
|
||||
const mosaicHome = createMosaicHome();
|
||||
const source = join(mosaicHome, 'defaults', 'USER.md');
|
||||
writeFixture(source, Buffer.alloc(256 * 1024 + 1, 0x61));
|
||||
|
||||
expect(() => seedFleetIdentityDefaults(mosaicHome)).toThrow(
|
||||
`fleet identity default is unavailable or unsafe: ${source}`,
|
||||
);
|
||||
expect(existsSync(join(mosaicHome, 'SOUL.md'))).toBe(false);
|
||||
expect(existsSync(join(mosaicHome, 'USER.md'))).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,82 @@
|
||||
import { randomBytes } from 'node:crypto';
|
||||
import { existsSync, linkSync, rmSync, writeFileSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { readRegularFileSecure } from '../fleet/secure-file.js';
|
||||
|
||||
const MAX_IDENTITY_CONTRACT_BYTES = 256 * 1024;
|
||||
export const FLEET_IDENTITY_DEFAULTS = ['SOUL.md', 'USER.md'] as const;
|
||||
|
||||
function isAlreadyExistsError(error: unknown): boolean {
|
||||
return error instanceof Error && 'code' in error && error.code === 'EEXIST';
|
||||
}
|
||||
|
||||
/** @internal Publish a complete temporary file without replacing any path. */
|
||||
export function linkIdentityContractNoClobber(source: string, destination: string): boolean {
|
||||
try {
|
||||
linkSync(source, destination);
|
||||
return true;
|
||||
} catch (error: unknown) {
|
||||
if (isAlreadyExistsError(error)) return false;
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
function readIdentityContract(
|
||||
mosaicHome: string,
|
||||
path: string,
|
||||
kind: 'default' | 'installed',
|
||||
): Buffer {
|
||||
try {
|
||||
return readRegularFileSecure(path, {
|
||||
root: mosaicHome,
|
||||
maxBytes: MAX_IDENTITY_CONTRACT_BYTES,
|
||||
}).content;
|
||||
} catch (error: unknown) {
|
||||
const reason = error instanceof Error ? error.message : String(error);
|
||||
throw new Error(`fleet identity ${kind} is unavailable or unsafe: ${path} (${reason})`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Seed the generic identity base required by unattended fleet launches.
|
||||
*
|
||||
* Exact seat identity remains roster-owned and is injected later by the
|
||||
* runtime composer. Each destination appears atomically through a hard link to
|
||||
* a complete owner-private temporary file; a concurrent first seat may win the
|
||||
* link without allowing either process to overwrite operator content.
|
||||
*/
|
||||
export function seedFleetIdentityDefaults(mosaicHome: string): string[] {
|
||||
const snapshots = new Map<(typeof FLEET_IDENTITY_DEFAULTS)[number], Buffer>();
|
||||
|
||||
for (const entry of FLEET_IDENTITY_DEFAULTS) {
|
||||
const destination = join(mosaicHome, entry);
|
||||
if (existsSync(destination)) {
|
||||
readIdentityContract(mosaicHome, destination, 'installed');
|
||||
continue;
|
||||
}
|
||||
const source = join(mosaicHome, 'defaults', entry);
|
||||
snapshots.set(entry, readIdentityContract(mosaicHome, source, 'default'));
|
||||
}
|
||||
|
||||
const seeded: string[] = [];
|
||||
for (const [entry, content] of snapshots) {
|
||||
const destination = join(mosaicHome, entry);
|
||||
const temporary = join(
|
||||
mosaicHome,
|
||||
`.${entry}.fleet-seed-${process.pid.toString()}-${randomBytes(6).toString('hex')}`,
|
||||
);
|
||||
let temporaryCreated = false;
|
||||
try {
|
||||
writeFileSync(temporary, content, { flag: 'wx', mode: 0o600 });
|
||||
temporaryCreated = true;
|
||||
if (linkIdentityContractNoClobber(temporary, destination)) seeded.push(entry);
|
||||
} finally {
|
||||
if (temporaryCreated) rmSync(temporary, { force: true });
|
||||
}
|
||||
}
|
||||
|
||||
for (const entry of FLEET_IDENTITY_DEFAULTS) {
|
||||
readIdentityContract(mosaicHome, join(mosaicHome, entry), 'installed');
|
||||
}
|
||||
return seeded;
|
||||
}
|
||||
@@ -0,0 +1,359 @@
|
||||
import { spawn, spawnSync, type SpawnSyncReturns } from 'node:child_process';
|
||||
import {
|
||||
chmodSync,
|
||||
existsSync,
|
||||
mkdirSync,
|
||||
mkdtempSync,
|
||||
readFileSync,
|
||||
readdirSync,
|
||||
rmSync,
|
||||
statSync,
|
||||
symlinkSync,
|
||||
writeFileSync,
|
||||
} from 'node:fs';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { dirname, join } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { afterEach, describe, expect, it } from 'vitest';
|
||||
|
||||
const CLI_PATH = fileURLToPath(new URL('../../dist/cli.js', import.meta.url));
|
||||
const DEFAULT_SOUL_PATH = fileURLToPath(
|
||||
new URL('../../framework/defaults/SOUL.md', import.meta.url),
|
||||
);
|
||||
const DEFAULT_USER_PATH = fileURLToPath(
|
||||
new URL('../../framework/defaults/USER.md', import.meta.url),
|
||||
);
|
||||
|
||||
interface GreenfieldFixture {
|
||||
readonly root: string;
|
||||
readonly home: string;
|
||||
readonly mosaicHome: string;
|
||||
readonly binDir: string;
|
||||
readonly capturePath: string;
|
||||
}
|
||||
|
||||
interface AsyncLaunchResult {
|
||||
readonly status: number | null;
|
||||
readonly signal: NodeJS.Signals | null;
|
||||
readonly stdout: string;
|
||||
readonly stderr: string;
|
||||
}
|
||||
|
||||
const fixtures: string[] = [];
|
||||
|
||||
function writeFixture(path: string, content: string, mode: number = 0o600): void {
|
||||
mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
|
||||
writeFileSync(path, content, { encoding: 'utf8', mode });
|
||||
chmodSync(path, mode);
|
||||
}
|
||||
|
||||
function createGreenfieldFixture(): GreenfieldFixture {
|
||||
const root = mkdtempSync(join(tmpdir(), 'mosaic-first-start-'));
|
||||
fixtures.push(root);
|
||||
const home = join(root, 'home');
|
||||
const mosaicHome = join(home, '.config', 'mosaic');
|
||||
const binDir = join(root, 'bin');
|
||||
const capturePath = join(root, 'runtime-boundary.json');
|
||||
|
||||
mkdirSync(binDir, { recursive: true, mode: 0o700 });
|
||||
writeFixture(join(mosaicHome, 'AGENTS.md'), '# Agent dispatcher\n');
|
||||
writeFixture(join(mosaicHome, 'runtime', 'pi', 'RUNTIME.md'), '# Pi runtime\n');
|
||||
writeFixture(join(mosaicHome, 'defaults', 'SOUL.md'), readFileSync(DEFAULT_SOUL_PATH, 'utf8'));
|
||||
writeFixture(join(mosaicHome, 'defaults', 'USER.md'), readFileSync(DEFAULT_USER_PATH, 'utf8'));
|
||||
writeFixture(
|
||||
join(mosaicHome, 'fleet', 'roster.yaml'),
|
||||
`version: 1
|
||||
transport: tmux
|
||||
tmux:
|
||||
socket_name: mosaic-fleet
|
||||
holder_session: _holder
|
||||
defaults:
|
||||
working_directory: ~
|
||||
runtimes:
|
||||
pi:
|
||||
reset_command: /new
|
||||
agents:
|
||||
- name: unattended-seat
|
||||
runtime: pi
|
||||
class: worker
|
||||
`,
|
||||
);
|
||||
writeFixture(
|
||||
join(mosaicHome, 'tools', 'tmux', 'agent-send.sh'),
|
||||
'#!/usr/bin/env bash\nexit 0\n',
|
||||
0o755,
|
||||
);
|
||||
writeFixture(
|
||||
join(mosaicHome, 'tools', 'lease-broker', 'launch-runtime.py'),
|
||||
`#!/usr/bin/env python3
|
||||
import json
|
||||
import os
|
||||
import pathlib
|
||||
import sys
|
||||
pathlib.Path(os.environ["MOSAIC_TEST_RUNTIME_CAPTURE"]).write_text(
|
||||
json.dumps({"argv": sys.argv[1:]}), encoding="utf-8"
|
||||
)
|
||||
`,
|
||||
0o755,
|
||||
);
|
||||
// checkRuntime() must find Pi, while the fake broker boundary prevents this
|
||||
// executable from running or making a provider call.
|
||||
writeFixture(join(binDir, 'pi'), '#!/usr/bin/env bash\nexit 97\n', 0o755);
|
||||
|
||||
return { root, home, mosaicHome, binDir, capturePath };
|
||||
}
|
||||
|
||||
function launchEnvironment(
|
||||
fixture: GreenfieldFixture,
|
||||
capturePath: string,
|
||||
fleet: boolean = true,
|
||||
agentName: string = 'unattended-seat',
|
||||
): NodeJS.ProcessEnv {
|
||||
return {
|
||||
HOME: fixture.home,
|
||||
MOSAIC_HOME: fixture.mosaicHome,
|
||||
...(fleet
|
||||
? {
|
||||
MOSAIC_AGENT_NAME: agentName,
|
||||
MOSAIC_AGENT_CLASS: 'worker',
|
||||
}
|
||||
: {}),
|
||||
MOSAIC_TEST_RUNTIME_CAPTURE: capturePath,
|
||||
PATH: `${fixture.binDir}:/usr/bin:/bin`,
|
||||
};
|
||||
}
|
||||
|
||||
function launchSync(
|
||||
fixture: GreenfieldFixture,
|
||||
options: {
|
||||
readonly capturePath?: string;
|
||||
readonly fleet?: boolean;
|
||||
readonly agentName?: string;
|
||||
} = {},
|
||||
): SpawnSyncReturns<string> {
|
||||
const capturePath = options.capturePath ?? fixture.capturePath;
|
||||
return spawnSync(process.execPath, [CLI_PATH, 'yolo', 'pi'], {
|
||||
cwd: fixture.root,
|
||||
encoding: 'utf8',
|
||||
input: '',
|
||||
timeout: 10_000,
|
||||
env: launchEnvironment(
|
||||
fixture,
|
||||
capturePath,
|
||||
options.fleet ?? true,
|
||||
options.agentName ?? 'unattended-seat',
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
function launchAsync(fixture: GreenfieldFixture, capturePath: string): Promise<AsyncLaunchResult> {
|
||||
return new Promise<AsyncLaunchResult>((resolve, reject): void => {
|
||||
const child = spawn(process.execPath, [CLI_PATH, 'yolo', 'pi'], {
|
||||
cwd: fixture.root,
|
||||
env: launchEnvironment(fixture, capturePath),
|
||||
stdio: ['pipe', 'pipe', 'pipe'],
|
||||
});
|
||||
let stdout = '';
|
||||
let stderr = '';
|
||||
child.stdout.setEncoding('utf8');
|
||||
child.stderr.setEncoding('utf8');
|
||||
child.stdout.on('data', (chunk: string): void => {
|
||||
stdout += chunk;
|
||||
});
|
||||
child.stderr.on('data', (chunk: string): void => {
|
||||
stderr += chunk;
|
||||
});
|
||||
child.on('error', reject);
|
||||
child.on('close', (status: number | null, signal: NodeJS.Signals | null): void => {
|
||||
resolve({ status, signal, stdout, stderr });
|
||||
});
|
||||
child.stdin.end();
|
||||
});
|
||||
}
|
||||
|
||||
function outputOf(result: { readonly stdout: string; readonly stderr: string }): string {
|
||||
return `${result.stdout}${result.stderr}`;
|
||||
}
|
||||
|
||||
function assertPrivateDefaultSeeds(fixture: GreenfieldFixture): void {
|
||||
const soul = join(fixture.mosaicHome, 'SOUL.md');
|
||||
const user = join(fixture.mosaicHome, 'USER.md');
|
||||
expect(readFileSync(soul, 'utf8')).toBe(readFileSync(DEFAULT_SOUL_PATH, 'utf8'));
|
||||
expect(readFileSync(user, 'utf8')).toBe(readFileSync(DEFAULT_USER_PATH, 'utf8'));
|
||||
expect(statSync(soul).mode & 0o777).toBe(0o600);
|
||||
expect(statSync(user).mode & 0o777).toBe(0o600);
|
||||
}
|
||||
|
||||
function capturedArguments(path: string): string[] {
|
||||
const capture = JSON.parse(readFileSync(path, 'utf8')) as { argv: string[] };
|
||||
return capture.argv;
|
||||
}
|
||||
|
||||
afterEach((): void => {
|
||||
for (const root of fixtures.splice(0)) {
|
||||
rmSync(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
describe('fleet unattended first start (#1264)', () => {
|
||||
it('reaches the runtime boundary without a TTY or identity wizard on a clean install', () => {
|
||||
const fixture = createGreenfieldFixture();
|
||||
const result = launchSync(fixture);
|
||||
const output = outputOf(result);
|
||||
|
||||
expect(result.error, output).toBeUndefined();
|
||||
expect(result.status, output).toBe(0);
|
||||
expect(output).toContain('Initialized unattended fleet identity defaults: SOUL.md, USER.md');
|
||||
expect(output).not.toContain('Running setup wizard');
|
||||
expect(output).not.toContain('What would you like to do?');
|
||||
expect(existsSync(fixture.capturePath), output).toBe(true);
|
||||
assertPrivateDefaultSeeds(fixture);
|
||||
|
||||
const argv = capturedArguments(fixture.capturePath);
|
||||
expect(argv).toContain('--runtime');
|
||||
expect(argv.join('\n')).toContain('Agent/session: `unattended-seat`');
|
||||
expect(argv.join('\n')).toContain('Role/class: `worker`');
|
||||
});
|
||||
|
||||
it('preserves existing operator identity bytes without requiring defaults', () => {
|
||||
const fixture = createGreenfieldFixture();
|
||||
const customSoul = '# Operator soul\nNever replace this.\n';
|
||||
const customUser = '# Operator user\nNever replace this either.\n';
|
||||
writeFixture(join(fixture.mosaicHome, 'SOUL.md'), customSoul, 0o640);
|
||||
writeFixture(join(fixture.mosaicHome, 'USER.md'), customUser, 0o600);
|
||||
rmSync(join(fixture.mosaicHome, 'defaults'), { recursive: true, force: true });
|
||||
|
||||
const first = launchSync(fixture);
|
||||
const secondCapture = join(fixture.root, 'runtime-boundary-second.json');
|
||||
const second = launchSync(fixture, { capturePath: secondCapture });
|
||||
|
||||
expect(first.status, outputOf(first)).toBe(0);
|
||||
expect(second.status, outputOf(second)).toBe(0);
|
||||
expect(readFileSync(join(fixture.mosaicHome, 'SOUL.md'), 'utf8')).toBe(customSoul);
|
||||
expect(readFileSync(join(fixture.mosaicHome, 'USER.md'), 'utf8')).toBe(customUser);
|
||||
expect(statSync(join(fixture.mosaicHome, 'SOUL.md')).mode & 0o777).toBe(0o640);
|
||||
expect(existsSync(fixture.capturePath)).toBe(true);
|
||||
expect(existsSync(secondCapture)).toBe(true);
|
||||
});
|
||||
|
||||
it('seeds only the missing identity contract and leaves a custom SOUL byte-exact', () => {
|
||||
const fixture = createGreenfieldFixture();
|
||||
const customSoul = '# Exact custom soul bytes\n';
|
||||
writeFixture(join(fixture.mosaicHome, 'SOUL.md'), customSoul, 0o640);
|
||||
|
||||
const result = launchSync(fixture);
|
||||
|
||||
expect(result.status, outputOf(result)).toBe(0);
|
||||
expect(outputOf(result)).toContain('Initialized unattended fleet identity defaults: USER.md');
|
||||
expect(readFileSync(join(fixture.mosaicHome, 'SOUL.md'), 'utf8')).toBe(customSoul);
|
||||
expect(statSync(join(fixture.mosaicHome, 'SOUL.md')).mode & 0o777).toBe(0o640);
|
||||
expect(readFileSync(join(fixture.mosaicHome, 'USER.md'), 'utf8')).toBe(
|
||||
readFileSync(DEFAULT_USER_PATH, 'utf8'),
|
||||
);
|
||||
});
|
||||
|
||||
it('fails closed without a wizard or partial seed when a required default is missing', () => {
|
||||
const fixture = createGreenfieldFixture();
|
||||
const missingDefault = join(fixture.mosaicHome, 'defaults', 'USER.md');
|
||||
rmSync(missingDefault);
|
||||
|
||||
const result = launchSync(fixture);
|
||||
const output = outputOf(result);
|
||||
|
||||
expect(result.status, output).toBe(1);
|
||||
expect(output).toContain('unattended fleet identity initialization failed');
|
||||
expect(output).toContain(missingDefault);
|
||||
expect(output).not.toContain('Running setup wizard');
|
||||
expect(output).not.toContain('What would you like to do?');
|
||||
expect(existsSync(fixture.capturePath)).toBe(false);
|
||||
expect(existsSync(join(fixture.mosaicHome, 'SOUL.md'))).toBe(false);
|
||||
expect(existsSync(join(fixture.mosaicHome, 'USER.md'))).toBe(false);
|
||||
});
|
||||
|
||||
it('rejects a symlinked identity default without following it or prompting', () => {
|
||||
const fixture = createGreenfieldFixture();
|
||||
const soulDefault = join(fixture.mosaicHome, 'defaults', 'SOUL.md');
|
||||
rmSync(soulDefault);
|
||||
symlinkSync(DEFAULT_SOUL_PATH, soulDefault);
|
||||
|
||||
const result = launchSync(fixture);
|
||||
const output = outputOf(result);
|
||||
|
||||
expect(result.status, output).toBe(1);
|
||||
expect(output).toContain(`fleet identity default is unavailable or unsafe: ${soulDefault}`);
|
||||
expect(output).not.toContain('Running setup wizard');
|
||||
expect(existsSync(fixture.capturePath)).toBe(false);
|
||||
});
|
||||
|
||||
it('refuses an unknown ambient fleet name before seeding or prompting', () => {
|
||||
const fixture = createGreenfieldFixture();
|
||||
|
||||
const result = launchSync(fixture, { agentName: 'not-in-the-roster' });
|
||||
const output = outputOf(result);
|
||||
|
||||
expect(result.status, output).toBe(1);
|
||||
expect(output).toContain('canonical fleet identity is unavailable');
|
||||
expect(output).toContain('Agent "not-in-the-roster" is not in the fleet roster');
|
||||
expect(output).not.toContain('Running setup wizard');
|
||||
expect(existsSync(fixture.capturePath)).toBe(false);
|
||||
expect(existsSync(join(fixture.mosaicHome, 'SOUL.md'))).toBe(false);
|
||||
expect(existsSync(join(fixture.mosaicHome, 'USER.md'))).toBe(false);
|
||||
});
|
||||
|
||||
it.each([' unattended-seat', 'unattended-seat ', ''])(
|
||||
'refuses non-exact ambient fleet name %j before seeding',
|
||||
(agentName: string) => {
|
||||
const fixture = createGreenfieldFixture();
|
||||
|
||||
const result = launchSync(fixture, { agentName });
|
||||
const output = outputOf(result);
|
||||
|
||||
expect(result.status, output).toBe(1);
|
||||
expect(output).toContain(
|
||||
'MOSAIC_AGENT_NAME must be a non-empty exact roster name with no surrounding whitespace',
|
||||
);
|
||||
expect(output).not.toContain('Running setup wizard');
|
||||
expect(existsSync(fixture.capturePath)).toBe(false);
|
||||
expect(existsSync(join(fixture.mosaicHome, 'SOUL.md'))).toBe(false);
|
||||
expect(existsSync(join(fixture.mosaicHome, 'USER.md'))).toBe(false);
|
||||
},
|
||||
);
|
||||
|
||||
it('keeps the interactive wizard path for a standalone launch', () => {
|
||||
const fixture = createGreenfieldFixture();
|
||||
|
||||
const result = launchSync(fixture, { fleet: false });
|
||||
const output = outputOf(result);
|
||||
|
||||
expect(result.status, output).toBe(1);
|
||||
expect(output).toContain('[mosaic] SOUL.md not found. Running setup wizard...');
|
||||
expect(output).toContain('What would you like to do?');
|
||||
expect(output).toContain('[mosaic] Setup failed. Run: mosaic wizard');
|
||||
expect(existsSync(fixture.capturePath)).toBe(false);
|
||||
expect(existsSync(join(fixture.mosaicHome, 'SOUL.md'))).toBe(false);
|
||||
});
|
||||
|
||||
it('allows concurrent no-TTY seats to initialize the same defaults without clobber or residue', async () => {
|
||||
const fixture = createGreenfieldFixture();
|
||||
const captures = Array.from({ length: 4 }, (_, index) =>
|
||||
join(fixture.root, `runtime-boundary-${index.toString()}.json`),
|
||||
);
|
||||
|
||||
const results = await Promise.all(
|
||||
captures.map(
|
||||
async (capturePath): Promise<AsyncLaunchResult> => launchAsync(fixture, capturePath),
|
||||
),
|
||||
);
|
||||
|
||||
for (const result of results) {
|
||||
expect(result.status, outputOf(result)).toBe(0);
|
||||
expect(result.signal, outputOf(result)).toBeNull();
|
||||
expect(outputOf(result)).not.toContain('Running setup wizard');
|
||||
}
|
||||
assertPrivateDefaultSeeds(fixture);
|
||||
expect(captures.every((capturePath) => existsSync(capturePath))).toBe(true);
|
||||
expect(
|
||||
readdirSync(fixture.mosaicHome).filter((entry) => entry.includes('.fleet-seed-')),
|
||||
).toEqual([]);
|
||||
});
|
||||
});
|
||||
@@ -30,6 +30,7 @@ import { readRegularFileSecure } from '../fleet/secure-file.js';
|
||||
import { readPersonaContractBlock } from '../fleet/persona-contract.js';
|
||||
import { canonicalizeRoleClass } from './fleet-personas.js';
|
||||
import { launchClaudex, type ClaudexHarnessAdapter } from './claudex.js';
|
||||
import { seedFleetIdentityDefaults } from './fleet-first-start-identity.js';
|
||||
import { runLeaseEnforcementDoctorCheck } from './lease-doctor-check.js';
|
||||
|
||||
const MOSAIC_HOME = process.env['MOSAIC_HOME'] ?? join(homedir(), '.config', 'mosaic');
|
||||
@@ -232,6 +233,37 @@ function checkRuntime(cmd: string): void {
|
||||
|
||||
function checkSoul(): void {
|
||||
const soulPath = join(MOSAIC_HOME, 'SOUL.md');
|
||||
const fleetAgentName = process.env['MOSAIC_AGENT_NAME'];
|
||||
if (fleetAgentName !== undefined) {
|
||||
try {
|
||||
if (fleetAgentName.length === 0 || fleetAgentName !== fleetAgentName.trim()) {
|
||||
throw new Error(
|
||||
'MOSAIC_AGENT_NAME must be a non-empty exact roster name with no surrounding whitespace',
|
||||
);
|
||||
}
|
||||
const fleetIdentity = resolveFleetIdentity(MOSAIC_HOME, fleetAgentName);
|
||||
if (!fleetIdentity.ok || !fleetIdentity.identity) {
|
||||
throw new Error(
|
||||
`canonical fleet identity is unavailable: ${fleetIdentity.error ?? 'exact roster member was not resolved'}`,
|
||||
);
|
||||
}
|
||||
const seeded = seedFleetIdentityDefaults(MOSAIC_HOME);
|
||||
if (seeded.length > 0) {
|
||||
console.log(
|
||||
`[mosaic] Initialized unattended fleet identity defaults: ${seeded.join(', ')}. Exact seat identity remains roster-owned.`,
|
||||
);
|
||||
}
|
||||
return;
|
||||
} catch (error: unknown) {
|
||||
const reason = error instanceof Error ? error.message : String(error);
|
||||
console.error(`[mosaic] ERROR: unattended fleet identity initialization failed: ${reason}`);
|
||||
console.error(
|
||||
`[mosaic] Repair the shipped identity defaults under ${join(MOSAIC_HOME, 'defaults')} and retry this exact roster member.`,
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
if (!existsSync(soulPath)) {
|
||||
console.log('[mosaic] SOUL.md not found. Running setup wizard...');
|
||||
|
||||
|
||||
Reference in New Issue
Block a user