Compare commits
1 Commits
feat/fleet
...
feat/p4-1-
| Author | SHA1 | Date | |
|---|---|---|---|
| 02fdbccb39 |
@@ -1,32 +0,0 @@
|
||||
version: 1
|
||||
transport: tmux
|
||||
tmux:
|
||||
socket_name: mosaic-factory
|
||||
holder_session: _holder
|
||||
defaults:
|
||||
working_directory: ~
|
||||
runtimes:
|
||||
claude:
|
||||
reset_command: /clear
|
||||
pi:
|
||||
reset_command: /new
|
||||
agents:
|
||||
- name: orchestrator
|
||||
runtime: claude
|
||||
class: orchestrator
|
||||
persistent_persona: true
|
||||
- name: coder0
|
||||
runtime: pi
|
||||
class: implementer
|
||||
model_hint: openai-codex/gpt-5.5:high
|
||||
reset_between_tasks: true
|
||||
- name: coder1
|
||||
runtime: pi
|
||||
class: implementer
|
||||
model_hint: openai-codex/gpt-5.5:high
|
||||
reset_between_tasks: true
|
||||
- name: reviewer
|
||||
runtime: pi
|
||||
class: reviewer
|
||||
model_hint: openai-codex/gpt-5.5:high
|
||||
reset_between_tasks: true
|
||||
@@ -1,22 +0,0 @@
|
||||
version: 1
|
||||
transport: tmux
|
||||
tmux:
|
||||
socket_name: mosaic-factory
|
||||
holder_session: _holder
|
||||
defaults:
|
||||
working_directory: ~
|
||||
runtimes:
|
||||
claude:
|
||||
reset_command: /clear
|
||||
pi:
|
||||
reset_command: /new
|
||||
agents:
|
||||
- name: orchestrator
|
||||
runtime: claude
|
||||
class: orchestrator
|
||||
persistent_persona: true
|
||||
- name: generalist
|
||||
runtime: pi
|
||||
class: worker
|
||||
model_hint: openai-codex/gpt-5.5:high
|
||||
reset_between_tasks: true
|
||||
@@ -1,32 +0,0 @@
|
||||
version: 1
|
||||
transport: tmux
|
||||
tmux:
|
||||
socket_name: mosaic-factory
|
||||
holder_session: _holder
|
||||
defaults:
|
||||
working_directory: ~
|
||||
runtimes:
|
||||
claude:
|
||||
reset_command: /clear
|
||||
pi:
|
||||
reset_command: /new
|
||||
agents:
|
||||
- name: orchestrator
|
||||
runtime: claude
|
||||
class: orchestrator
|
||||
persistent_persona: true
|
||||
- name: coder0
|
||||
runtime: pi
|
||||
class: implementer
|
||||
model_hint: openai-codex/gpt-5.5:high
|
||||
reset_between_tasks: true
|
||||
- name: researcher0
|
||||
runtime: pi
|
||||
class: researcher
|
||||
model_hint: openai-codex/gpt-5.5:high
|
||||
reset_between_tasks: true
|
||||
- name: reviewer
|
||||
runtime: pi
|
||||
class: reviewer
|
||||
model_hint: openai-codex/gpt-5.5:high
|
||||
reset_between_tasks: true
|
||||
@@ -1,32 +0,0 @@
|
||||
version: 1
|
||||
transport: tmux
|
||||
tmux:
|
||||
socket_name: mosaic-factory
|
||||
holder_session: _holder
|
||||
defaults:
|
||||
working_directory: ~
|
||||
runtimes:
|
||||
claude:
|
||||
reset_command: /clear
|
||||
pi:
|
||||
reset_command: /new
|
||||
agents:
|
||||
- name: orchestrator
|
||||
runtime: claude
|
||||
class: orchestrator
|
||||
persistent_persona: true
|
||||
- name: researcher0
|
||||
runtime: pi
|
||||
class: researcher
|
||||
model_hint: openai-codex/gpt-5.5:high
|
||||
reset_between_tasks: true
|
||||
- name: researcher1
|
||||
runtime: pi
|
||||
class: researcher
|
||||
model_hint: openai-codex/gpt-5.5:high
|
||||
reset_between_tasks: true
|
||||
- name: analyst
|
||||
runtime: pi
|
||||
class: analyst
|
||||
model_hint: openai-codex/gpt-5.5:high
|
||||
reset_between_tasks: true
|
||||
@@ -4,7 +4,6 @@ import { dirname, join, resolve } from 'node:path';
|
||||
import { Command } from 'commander';
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest';
|
||||
import {
|
||||
addAgentToRoster,
|
||||
buildAgentSendCommand,
|
||||
buildAgentWatchAttachCommand,
|
||||
buildAgentWatchCommand,
|
||||
@@ -18,10 +17,8 @@ import {
|
||||
buildTmuxListPanesCommand,
|
||||
buildTmuxListSessionsCommand,
|
||||
classifySendResult,
|
||||
countOrchestrators,
|
||||
detectDrift,
|
||||
enableFleetUnits,
|
||||
FLEET_PROFILES,
|
||||
generateAgentEnv,
|
||||
getDefaultOperatorSourceLabel,
|
||||
getDefaultTenantAndHost,
|
||||
@@ -31,21 +28,16 @@ import {
|
||||
loadFleetRoster,
|
||||
mergeAgentEnv,
|
||||
parseHeartbeat,
|
||||
parseInitProfile,
|
||||
parseSystemdShow,
|
||||
parseTmuxListPanes,
|
||||
parseTmuxListSessions,
|
||||
registerFleetCommand,
|
||||
removeAgentFromRoster,
|
||||
resolveFleetPaths,
|
||||
resolvePresetFilename,
|
||||
RUNTIME_ACCEPTABLE_COMMANDS,
|
||||
serializeRosterToYaml,
|
||||
VERIFY_DEFAULT_TIMEOUT_MS,
|
||||
VERIFY_POLL_INTERVAL_MS,
|
||||
type AgentPsRow,
|
||||
type CommandRunner,
|
||||
type FleetProfile,
|
||||
type FleetRoster,
|
||||
type InteractiveRunner,
|
||||
type SleepFn,
|
||||
@@ -71,12 +63,10 @@ describe('registerFleetCommand', () => {
|
||||
|
||||
expect(fleet).toBeDefined();
|
||||
expect(fleet!.commands.map((command) => command.name()).sort()).toEqual([
|
||||
'add',
|
||||
'init',
|
||||
'install',
|
||||
'install-systemd',
|
||||
'ps',
|
||||
'remove',
|
||||
'restart',
|
||||
'start',
|
||||
'status',
|
||||
@@ -2142,736 +2132,3 @@ describe('agent send --verify', () => {
|
||||
expect(VERIFY_DEFAULT_TIMEOUT_MS).toBe(6_000);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fleet Phase F1: config-type presets + AI-free init wizard
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('fleet preset rosters', () => {
|
||||
const examplesDir = resolve(process.cwd(), 'framework', 'fleet', 'examples');
|
||||
|
||||
it.each(['general', 'coding', 'research', 'hybrid'] as FleetProfile[])(
|
||||
'%s preset: loads via loadFleetRoster and has exactly one orchestrator',
|
||||
async (preset) => {
|
||||
const rosterPath = join(examplesDir, `${preset}.yaml`);
|
||||
const roster = await loadFleetRoster(rosterPath);
|
||||
expect(countOrchestrators(roster)).toBe(1);
|
||||
expect(roster.agents.find((a) => a.name === 'orchestrator')).toBeDefined();
|
||||
},
|
||||
);
|
||||
|
||||
it('general preset: orchestrator + one generalist worker', async () => {
|
||||
const roster = await loadFleetRoster(join(examplesDir, 'general.yaml'));
|
||||
expect(roster.agents.map((a) => a.name)).toEqual(['orchestrator', 'generalist']);
|
||||
expect(roster.agents.find((a) => a.name === 'orchestrator')?.runtime).toBe('claude');
|
||||
expect(roster.agents.find((a) => a.name === 'generalist')?.runtime).toBe('pi');
|
||||
});
|
||||
|
||||
it('coding preset: orchestrator + coder0 + coder1 + reviewer', async () => {
|
||||
const roster = await loadFleetRoster(join(examplesDir, 'coding.yaml'));
|
||||
expect(roster.agents.map((a) => a.name)).toEqual([
|
||||
'orchestrator',
|
||||
'coder0',
|
||||
'coder1',
|
||||
'reviewer',
|
||||
]);
|
||||
});
|
||||
|
||||
it('research preset: orchestrator + researcher0 + researcher1 + analyst', async () => {
|
||||
const roster = await loadFleetRoster(join(examplesDir, 'research.yaml'));
|
||||
expect(roster.agents.map((a) => a.name)).toEqual([
|
||||
'orchestrator',
|
||||
'researcher0',
|
||||
'researcher1',
|
||||
'analyst',
|
||||
]);
|
||||
});
|
||||
|
||||
it('hybrid preset: orchestrator + coder0 + researcher0 + reviewer', async () => {
|
||||
const roster = await loadFleetRoster(join(examplesDir, 'hybrid.yaml'));
|
||||
expect(roster.agents.map((a) => a.name)).toEqual([
|
||||
'orchestrator',
|
||||
'coder0',
|
||||
'researcher0',
|
||||
'reviewer',
|
||||
]);
|
||||
});
|
||||
|
||||
it('worker agents in new presets use pi runtime with model_hint openai-codex/gpt-5.5:high', async () => {
|
||||
for (const preset of ['general', 'coding', 'research', 'hybrid'] as FleetProfile[]) {
|
||||
const roster = await loadFleetRoster(join(examplesDir, `${preset}.yaml`));
|
||||
const workers = roster.agents.filter((a) => a.name !== 'orchestrator');
|
||||
for (const worker of workers) {
|
||||
expect(worker.runtime).toBe('pi');
|
||||
expect(worker.modelHint).toBe('openai-codex/gpt-5.5:high');
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('orchestrator in new presets uses claude runtime with persistent_persona', async () => {
|
||||
for (const preset of ['general', 'coding', 'research', 'hybrid'] as FleetProfile[]) {
|
||||
const roster = await loadFleetRoster(join(examplesDir, `${preset}.yaml`));
|
||||
const orch = roster.agents.find((a) => a.name === 'orchestrator');
|
||||
expect(orch?.runtime).toBe('claude');
|
||||
expect(orch?.persistentPersona).toBe(true);
|
||||
}
|
||||
});
|
||||
|
||||
it('new presets are sanitized: no operator identity tokens', async () => {
|
||||
for (const preset of ['general', 'coding', 'research', 'hybrid'] as FleetProfile[]) {
|
||||
const text = await readFile(join(examplesDir, `${preset}.yaml`), 'utf8');
|
||||
expect(text).not.toMatch(/jarvis|jason|woltje/i);
|
||||
// working_directory must not reference ~/src or /home
|
||||
expect(text).not.toMatch(/~\/src|\/home\//);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('parseInitProfile', () => {
|
||||
it('accepts all six fleet profiles', () => {
|
||||
expect(parseInitProfile('general')).toBe('general');
|
||||
expect(parseInitProfile('coding')).toBe('coding');
|
||||
expect(parseInitProfile('research')).toBe('research');
|
||||
expect(parseInitProfile('hybrid')).toBe('hybrid');
|
||||
expect(parseInitProfile('minimal')).toBe('minimal');
|
||||
expect(parseInitProfile('local-canary')).toBe('local-canary');
|
||||
});
|
||||
|
||||
it('rejects unknown profiles with a message listing all valid names', () => {
|
||||
expect(() => parseInitProfile('typo')).toThrow('Unsupported fleet profile');
|
||||
expect(() => parseInitProfile('typo')).toThrow('general');
|
||||
expect(() => parseInitProfile('typo')).toThrow('coding');
|
||||
});
|
||||
|
||||
it('FLEET_PROFILES contains all six valid profile names', () => {
|
||||
expect(FLEET_PROFILES).toContain('general');
|
||||
expect(FLEET_PROFILES).toContain('coding');
|
||||
expect(FLEET_PROFILES).toContain('research');
|
||||
expect(FLEET_PROFILES).toContain('hybrid');
|
||||
expect(FLEET_PROFILES).toContain('minimal');
|
||||
expect(FLEET_PROFILES).toContain('local-canary');
|
||||
});
|
||||
});
|
||||
|
||||
describe('resolvePresetFilename', () => {
|
||||
it.each(FLEET_PROFILES)('maps %s to %s.yaml', (profile) => {
|
||||
expect(resolvePresetFilename(profile)).toBe(`${profile}.yaml`);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fleet Phase F5: orchestrator-mutable fleet — pure helper tests (R9)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('fleet add/remove — pure helpers', () => {
|
||||
const baseRoster: FleetRoster = {
|
||||
version: 1,
|
||||
transport: 'tmux',
|
||||
tmux: { socketName: 'mosaic-factory', holderSession: '_holder' },
|
||||
defaults: { workingDirectory: '~/src' },
|
||||
runtimes: { codex: { resetCommand: '/clear' } },
|
||||
agents: [
|
||||
{ name: 'orchestrator', runtime: 'claude', className: 'orchestrator' },
|
||||
{ name: 'coder0', runtime: 'codex', className: 'worker' },
|
||||
],
|
||||
};
|
||||
|
||||
it('addAgentToRoster appends a new agent and returns a new roster object', () => {
|
||||
const newAgent = { name: 'reviewer0', runtime: 'pi', className: 'worker' };
|
||||
const updated = addAgentToRoster(baseRoster, newAgent);
|
||||
expect(updated.agents).toHaveLength(3);
|
||||
expect(updated.agents[2]).toEqual(newAgent);
|
||||
// immutable — original unchanged
|
||||
expect(baseRoster.agents).toHaveLength(2);
|
||||
expect(updated).not.toBe(baseRoster);
|
||||
});
|
||||
|
||||
it('addAgentToRoster throws on duplicate name', () => {
|
||||
expect(() =>
|
||||
addAgentToRoster(baseRoster, { name: 'coder0', runtime: 'claude', className: 'worker' }),
|
||||
).toThrow('Agent "coder0" already exists in the fleet roster.');
|
||||
});
|
||||
|
||||
it('addAgentToRoster throws on invalid name (invalid characters)', () => {
|
||||
expect(() =>
|
||||
addAgentToRoster(baseRoster, { name: 'bad name!', runtime: 'claude', className: 'worker' }),
|
||||
).toThrow('Invalid fleet agent name');
|
||||
});
|
||||
|
||||
it('addAgentToRoster throws on empty name', () => {
|
||||
expect(() =>
|
||||
addAgentToRoster(baseRoster, { name: '', runtime: 'claude', className: 'worker' }),
|
||||
).toThrow('Invalid fleet agent name');
|
||||
});
|
||||
|
||||
it('removeAgentFromRoster removes the agent and returns new roster', () => {
|
||||
const updated = removeAgentFromRoster(baseRoster, 'coder0');
|
||||
expect(updated.agents).toHaveLength(1);
|
||||
expect(updated.agents[0]!.name).toBe('orchestrator');
|
||||
// immutable
|
||||
expect(baseRoster.agents).toHaveLength(2);
|
||||
expect(updated).not.toBe(baseRoster);
|
||||
});
|
||||
|
||||
it('removeAgentFromRoster throws when agent not found', () => {
|
||||
expect(() => removeAgentFromRoster(baseRoster, 'nonexistent')).toThrow(
|
||||
'Agent "nonexistent" is not in the fleet roster.',
|
||||
);
|
||||
});
|
||||
|
||||
it('removeAgentFromRoster throws when removing the sole orchestrator (guard)', () => {
|
||||
const rosterWithOnlyOrch: FleetRoster = {
|
||||
...baseRoster,
|
||||
agents: [{ name: 'orchestrator', runtime: 'claude', className: 'orchestrator' }],
|
||||
};
|
||||
expect(() => removeAgentFromRoster(rosterWithOnlyOrch, 'orchestrator')).toThrow(
|
||||
'sole orchestrator',
|
||||
);
|
||||
});
|
||||
|
||||
it('removeAgentFromRoster allows removing an orchestrator when another remains', () => {
|
||||
const rosterWithTwoOrchs: FleetRoster = {
|
||||
...baseRoster,
|
||||
agents: [
|
||||
{ name: 'orchestrator', runtime: 'claude', className: 'orchestrator' },
|
||||
{ name: 'orchestrator2', runtime: 'claude', className: 'orchestrator' },
|
||||
{ name: 'coder0', runtime: 'codex', className: 'worker' },
|
||||
],
|
||||
};
|
||||
const updated = removeAgentFromRoster(rosterWithTwoOrchs, 'orchestrator');
|
||||
expect(updated.agents.map((a) => a.name)).toEqual(['orchestrator2', 'coder0']);
|
||||
});
|
||||
|
||||
it('serializeRosterToYaml produces YAML that round-trips through loadFleetRoster', async () => {
|
||||
const yaml = serializeRosterToYaml(baseRoster);
|
||||
expect(typeof yaml).toBe('string');
|
||||
expect(yaml).toContain('version: 1');
|
||||
expect(yaml).toContain('name: orchestrator');
|
||||
expect(yaml).toContain('name: coder0');
|
||||
|
||||
// Round-trip: write to disk and re-load
|
||||
const dir = await mkdtemp(join(tmpdir(), 'mosaic-fleet-'));
|
||||
const rosterPath = join(dir, 'roster.yaml');
|
||||
try {
|
||||
await writeFile(rosterPath, yaml);
|
||||
const loaded = await loadFleetRoster(rosterPath);
|
||||
expect(loaded.agents.map((a) => a.name)).toEqual(['orchestrator', 'coder0']);
|
||||
expect(loaded.tmux.socketName).toBe('mosaic-factory');
|
||||
expect(loaded.agents[0]!.className).toBe('orchestrator');
|
||||
} finally {
|
||||
await rm(dir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
it('serializeRosterToYaml round-trips optional fields (modelHint, workingDirectory)', async () => {
|
||||
const rosterWithOptionals: FleetRoster = {
|
||||
...baseRoster,
|
||||
agents: [
|
||||
{
|
||||
name: 'orchestrator',
|
||||
runtime: 'claude',
|
||||
className: 'orchestrator',
|
||||
modelHint: 'claude-3-5-sonnet',
|
||||
workingDirectory: '/tmp/work',
|
||||
persistentPersona: true,
|
||||
resetBetweenTasks: false,
|
||||
},
|
||||
],
|
||||
};
|
||||
const yaml = serializeRosterToYaml(rosterWithOptionals);
|
||||
expect(yaml).toContain('model_hint: claude-3-5-sonnet');
|
||||
expect(yaml).toContain('working_directory: /tmp/work');
|
||||
expect(yaml).toContain('persistent_persona: true');
|
||||
|
||||
const dir = await mkdtemp(join(tmpdir(), 'mosaic-fleet-'));
|
||||
const rosterPath = join(dir, 'roster.yaml');
|
||||
try {
|
||||
await writeFile(rosterPath, yaml);
|
||||
const loaded = await loadFleetRoster(rosterPath);
|
||||
expect(loaded.agents[0]!.modelHint).toBe('claude-3-5-sonnet');
|
||||
expect(loaded.agents[0]!.workingDirectory).toBe('/tmp/work');
|
||||
expect(loaded.agents[0]!.persistentPersona).toBe(true);
|
||||
} finally {
|
||||
await rm(dir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fleet Phase F5: fleet add command tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('fleet add command', () => {
|
||||
let home: string;
|
||||
|
||||
afterEach(async () => {
|
||||
if (home) {
|
||||
await rm(home, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
async function makeHome(agents = ['orchestrator']): Promise<string> {
|
||||
const dir = await mkdtemp(join(tmpdir(), 'mosaic-fleet-add-'));
|
||||
await mkdir(join(dir, 'fleet', 'agents'), { recursive: true });
|
||||
const agentLines = agents.map((name) => {
|
||||
const cls = name === 'orchestrator' ? 'orchestrator' : 'worker';
|
||||
return ` - name: ${name}\n runtime: claude\n class: ${cls}`;
|
||||
});
|
||||
await writeFile(
|
||||
join(dir, 'fleet', 'roster.yaml'),
|
||||
['version: 1', 'transport: tmux', 'agents:', ...agentLines].join('\n'),
|
||||
);
|
||||
return dir;
|
||||
}
|
||||
|
||||
it('appends agent to roster file and writes env file', async () => {
|
||||
home = await makeHome();
|
||||
const runner: CommandRunner = async () => ({ stdout: '', stderr: '', exitCode: 0 });
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
await program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'add',
|
||||
'coder0',
|
||||
'--runtime',
|
||||
'codex',
|
||||
'--class',
|
||||
'worker',
|
||||
]);
|
||||
|
||||
const roster = await loadFleetRoster(join(home, 'fleet', 'roster.yaml'));
|
||||
expect(roster.agents.map((a) => a.name)).toContain('coder0');
|
||||
|
||||
const envContent = await readFile(join(home, 'fleet', 'agents', 'coder0.env'), 'utf8');
|
||||
expect(envContent).toContain('MOSAIC_AGENT_NAME=coder0');
|
||||
expect(envContent).toContain('MOSAIC_AGENT_RUNTIME=codex');
|
||||
});
|
||||
|
||||
it('--no-start skips the start command', async () => {
|
||||
home = await makeHome();
|
||||
const calls: string[][] = [];
|
||||
const runner: CommandRunner = async (command, args) => {
|
||||
calls.push([command, ...args]);
|
||||
return { stdout: '', stderr: '', exitCode: 0 };
|
||||
};
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
await program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'add',
|
||||
'coder0',
|
||||
'--runtime',
|
||||
'codex',
|
||||
'--class',
|
||||
'worker',
|
||||
'--no-start',
|
||||
]);
|
||||
|
||||
// No start command should have been issued
|
||||
const startCalls = calls.filter((c) => c.includes('start'));
|
||||
expect(startCalls).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('without --no-start, issues start command for the new agent', async () => {
|
||||
home = await makeHome();
|
||||
const calls: string[][] = [];
|
||||
const runner: CommandRunner = async (command, args) => {
|
||||
calls.push([command, ...args]);
|
||||
return { stdout: '', stderr: '', exitCode: 0 };
|
||||
};
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
await program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'add',
|
||||
'coder0',
|
||||
'--runtime',
|
||||
'codex',
|
||||
'--class',
|
||||
'worker',
|
||||
]);
|
||||
|
||||
expect(calls).toContainEqual(['systemctl', '--user', 'start', 'mosaic-agent@coder0.service']);
|
||||
});
|
||||
|
||||
it('throws when adding a duplicate agent name', async () => {
|
||||
home = await makeHome(['orchestrator', 'coder0']);
|
||||
const runner: CommandRunner = async () => ({ stdout: '', stderr: '', exitCode: 0 });
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
await expect(
|
||||
program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'add',
|
||||
'coder0',
|
||||
'--runtime',
|
||||
'codex',
|
||||
'--class',
|
||||
'worker',
|
||||
]),
|
||||
).rejects.toThrow('already exists');
|
||||
});
|
||||
|
||||
it('throws when runtime is invalid', async () => {
|
||||
home = await makeHome();
|
||||
const runner: CommandRunner = async () => ({ stdout: '', stderr: '', exitCode: 0 });
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
await expect(
|
||||
program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'add',
|
||||
'coder0',
|
||||
'--runtime',
|
||||
'notaruntime',
|
||||
'--class',
|
||||
'worker',
|
||||
]),
|
||||
).rejects.toThrow('Invalid runtime');
|
||||
});
|
||||
|
||||
it('accepts optional --model and --working-dir options', async () => {
|
||||
home = await makeHome();
|
||||
const runner: CommandRunner = async () => ({ stdout: '', stderr: '', exitCode: 0 });
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
await program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'add',
|
||||
'coder0',
|
||||
'--runtime',
|
||||
'claude',
|
||||
'--class',
|
||||
'worker',
|
||||
'--model',
|
||||
'claude-sonnet',
|
||||
'--working-dir',
|
||||
'/tmp/work',
|
||||
]);
|
||||
|
||||
const roster = await loadFleetRoster(join(home, 'fleet', 'roster.yaml'));
|
||||
const agent = roster.agents.find((a) => a.name === 'coder0');
|
||||
expect(agent?.modelHint).toBe('claude-sonnet');
|
||||
expect(agent?.workingDirectory).toBe('/tmp/work');
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fleet Phase F5: fleet remove command tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('fleet remove command', () => {
|
||||
let home: string;
|
||||
|
||||
afterEach(async () => {
|
||||
if (home) {
|
||||
await rm(home, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
async function makeHome(): Promise<string> {
|
||||
const dir = await mkdtemp(join(tmpdir(), 'mosaic-fleet-remove-'));
|
||||
await mkdir(join(dir, 'fleet', 'agents'), { recursive: true });
|
||||
await mkdir(join(dir, 'fleet', 'run'), { recursive: true });
|
||||
await writeFile(
|
||||
join(dir, 'fleet', 'roster.yaml'),
|
||||
[
|
||||
'version: 1',
|
||||
'transport: tmux',
|
||||
'agents:',
|
||||
' - name: orchestrator',
|
||||
' runtime: claude',
|
||||
' class: orchestrator',
|
||||
' - name: coder0',
|
||||
' runtime: codex',
|
||||
' class: worker',
|
||||
].join('\n'),
|
||||
);
|
||||
// Create env and heartbeat files for coder0
|
||||
await writeFile(join(dir, 'fleet', 'agents', 'coder0.env'), 'MOSAIC_AGENT_NAME=coder0\n');
|
||||
await writeFile(join(dir, 'fleet', 'run', 'coder0.hb'), 'ts=2026-01-01T00:00:00.000Z\n');
|
||||
return dir;
|
||||
}
|
||||
|
||||
it('removes agent from roster and writes back', async () => {
|
||||
home = await makeHome();
|
||||
const runner: CommandRunner = async () => ({ stdout: '', stderr: '', exitCode: 0 });
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
await program.parseAsync(['node', 'mosaic', 'fleet', 'remove', 'coder0']);
|
||||
|
||||
const roster = await loadFleetRoster(join(home, 'fleet', 'roster.yaml'));
|
||||
expect(roster.agents.map((a) => a.name)).not.toContain('coder0');
|
||||
expect(roster.agents.map((a) => a.name)).toContain('orchestrator');
|
||||
});
|
||||
|
||||
it('stop is called before roster write (stop is the first runner call)', async () => {
|
||||
home = await makeHome();
|
||||
const calls: string[][] = [];
|
||||
const runner: CommandRunner = async (command, args) => {
|
||||
calls.push([command, ...args]);
|
||||
return { stdout: '', stderr: '', exitCode: 0 };
|
||||
};
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
await program.parseAsync(['node', 'mosaic', 'fleet', 'remove', 'coder0']);
|
||||
|
||||
expect(calls[0]).toEqual(['systemctl', '--user', 'stop', 'mosaic-agent@coder0.service']);
|
||||
});
|
||||
|
||||
it('stop failure is non-fatal — warns but still removes from roster', async () => {
|
||||
home = await makeHome();
|
||||
const stderrMessages: string[] = [];
|
||||
const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation((msg) => {
|
||||
stderrMessages.push(String(msg));
|
||||
return true;
|
||||
});
|
||||
|
||||
const runner: CommandRunner = async (command, args) => {
|
||||
if (args.includes('stop')) {
|
||||
return { stdout: '', stderr: 'unit not found', exitCode: 5 };
|
||||
}
|
||||
return { stdout: '', stderr: '', exitCode: 0 };
|
||||
};
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
try {
|
||||
// Must not reject
|
||||
await expect(
|
||||
program.parseAsync(['node', 'mosaic', 'fleet', 'remove', 'coder0']),
|
||||
).resolves.toBeDefined();
|
||||
|
||||
// Agent should be removed from roster despite stop failure
|
||||
const roster = await loadFleetRoster(join(home, 'fleet', 'roster.yaml'));
|
||||
expect(roster.agents.map((a) => a.name)).not.toContain('coder0');
|
||||
|
||||
// Warning must have been emitted
|
||||
expect(stderrMessages.join('')).toMatch(/Warning/);
|
||||
} finally {
|
||||
stderrSpy.mockRestore();
|
||||
}
|
||||
});
|
||||
|
||||
it('--keep-files skips env file deletion', async () => {
|
||||
home = await makeHome();
|
||||
const runner: CommandRunner = async () => ({ stdout: '', stderr: '', exitCode: 0 });
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
await program.parseAsync(['node', 'mosaic', 'fleet', 'remove', 'coder0', '--keep-files']);
|
||||
|
||||
// Env file should still exist
|
||||
const envContent = await readFile(join(home, 'fleet', 'agents', 'coder0.env'), 'utf8');
|
||||
expect(envContent).toContain('MOSAIC_AGENT_NAME=coder0');
|
||||
});
|
||||
|
||||
it('env file is removed by default (no --keep-files)', async () => {
|
||||
home = await makeHome();
|
||||
const runner: CommandRunner = async () => ({ stdout: '', stderr: '', exitCode: 0 });
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
await program.parseAsync(['node', 'mosaic', 'fleet', 'remove', 'coder0']);
|
||||
|
||||
await expect(readFile(join(home, 'fleet', 'agents', 'coder0.env'), 'utf8')).rejects.toThrow();
|
||||
});
|
||||
|
||||
it('removing the sole orchestrator throws with a clear error about the guard', async () => {
|
||||
home = await makeHome();
|
||||
const runner: CommandRunner = async () => ({ stdout: '', stderr: '', exitCode: 0 });
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { runner, mosaicHome: home });
|
||||
|
||||
// First remove the worker so only the orchestrator remains
|
||||
await program.parseAsync(['node', 'mosaic', 'fleet', 'remove', 'coder0']);
|
||||
|
||||
// Now attempt to remove the sole orchestrator
|
||||
await expect(
|
||||
program.parseAsync(['node', 'mosaic', 'fleet', 'remove', 'orchestrator']),
|
||||
).rejects.toThrow('sole orchestrator');
|
||||
});
|
||||
});
|
||||
|
||||
describe('fleet init wizard', () => {
|
||||
let cleanup: string | undefined;
|
||||
|
||||
afterEach(async () => {
|
||||
if (cleanup) {
|
||||
await rm(cleanup, { recursive: true, force: true });
|
||||
cleanup = undefined;
|
||||
}
|
||||
});
|
||||
|
||||
it('defaults to general when stdin is not a TTY and no --profile is given', async () => {
|
||||
cleanup = await tempDir();
|
||||
const rosterPath = join(cleanup, 'fleet', 'roster.yaml');
|
||||
const frameworkRoot = resolve(process.cwd(), 'framework');
|
||||
const stderrMessages: string[] = [];
|
||||
const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation((msg) => {
|
||||
stderrMessages.push(String(msg));
|
||||
return true;
|
||||
});
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
// isStdinTTY: false simulates non-interactive environment
|
||||
registerFleetCommand(program, { frameworkRoot, mosaicHome: cleanup, isStdinTTY: false });
|
||||
|
||||
try {
|
||||
await program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'--roster',
|
||||
rosterPath,
|
||||
'init',
|
||||
'--write',
|
||||
]);
|
||||
const content = await readFile(rosterPath, 'utf8');
|
||||
// Should have written the general preset
|
||||
expect(content).toContain('name: orchestrator');
|
||||
expect(content).toContain('name: generalist');
|
||||
// Stderr should explain the fallback
|
||||
expect(stderrMessages.join('')).toMatch(/defaulting to fleet profile "general"/);
|
||||
} finally {
|
||||
stderrSpy.mockRestore();
|
||||
}
|
||||
});
|
||||
|
||||
it('uses --profile to select preset without wizard (non-TTY path)', async () => {
|
||||
cleanup = await tempDir();
|
||||
const rosterPath = join(cleanup, 'fleet', 'roster.yaml');
|
||||
const frameworkRoot = resolve(process.cwd(), 'framework');
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { frameworkRoot, mosaicHome: cleanup, isStdinTTY: false });
|
||||
|
||||
try {
|
||||
await program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'--roster',
|
||||
rosterPath,
|
||||
'init',
|
||||
'--profile',
|
||||
'coding',
|
||||
'--write',
|
||||
]);
|
||||
const content = await readFile(rosterPath, 'utf8');
|
||||
expect(content).toContain('name: coder0');
|
||||
expect(content).toContain('name: reviewer');
|
||||
} finally {
|
||||
// cleanup handled by afterEach
|
||||
}
|
||||
});
|
||||
|
||||
it('written roster has exactly one orchestrator agent (countOrchestrators validation)', async () => {
|
||||
cleanup = await tempDir();
|
||||
const frameworkRoot = resolve(process.cwd(), 'framework');
|
||||
for (const preset of ['general', 'coding', 'research', 'hybrid'] as FleetProfile[]) {
|
||||
const rosterPath = join(cleanup, `${preset}-roster.yaml`);
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { frameworkRoot, mosaicHome: cleanup, isStdinTTY: false });
|
||||
await program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'--roster',
|
||||
rosterPath,
|
||||
'init',
|
||||
'--profile',
|
||||
preset,
|
||||
'--write',
|
||||
]);
|
||||
const roster = await loadFleetRoster(rosterPath);
|
||||
expect(countOrchestrators(roster)).toBe(1);
|
||||
}
|
||||
});
|
||||
|
||||
it('re-init with --write and existing roster requires --force (R8 idempotency)', async () => {
|
||||
cleanup = await tempDir();
|
||||
const rosterPath = join(cleanup, 'fleet', 'roster.yaml');
|
||||
const frameworkRoot = resolve(process.cwd(), 'framework');
|
||||
const program = new Command();
|
||||
program.exitOverride();
|
||||
registerFleetCommand(program, { frameworkRoot, mosaicHome: cleanup, isStdinTTY: false });
|
||||
|
||||
// First write
|
||||
await program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'--roster',
|
||||
rosterPath,
|
||||
'init',
|
||||
'--profile',
|
||||
'general',
|
||||
'--write',
|
||||
]);
|
||||
|
||||
// Second write without --force must fail
|
||||
await expect(
|
||||
program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'--roster',
|
||||
rosterPath,
|
||||
'init',
|
||||
'--profile',
|
||||
'general',
|
||||
'--write',
|
||||
]),
|
||||
).rejects.toThrow('Fleet roster already exists');
|
||||
|
||||
// With --force must succeed
|
||||
await program.parseAsync([
|
||||
'node',
|
||||
'mosaic',
|
||||
'fleet',
|
||||
'--roster',
|
||||
rosterPath,
|
||||
'init',
|
||||
'--profile',
|
||||
'coding',
|
||||
'--write',
|
||||
'--force',
|
||||
]);
|
||||
const content = await readFile(rosterPath, 'utf8');
|
||||
expect(content).toContain('name: coder0');
|
||||
});
|
||||
});
|
||||
|
||||
@@ -1,10 +1,9 @@
|
||||
import { constants } from 'node:fs';
|
||||
import { access, chmod, copyFile, mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
|
||||
import { access, chmod, copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
|
||||
import { homedir, hostname, userInfo } from 'node:os';
|
||||
import { dirname, join, resolve } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { spawn } from 'node:child_process';
|
||||
import * as readline from 'node:readline';
|
||||
import type { Command } from 'commander';
|
||||
import YAML from 'yaml';
|
||||
|
||||
@@ -42,11 +41,6 @@ export interface FleetCommandDeps {
|
||||
sleepFn?: SleepFn;
|
||||
mosaicHome?: string;
|
||||
frameworkRoot?: string;
|
||||
/**
|
||||
* Injectable TTY check for `fleet init` wizard. Defaults to process.stdin.isTTY.
|
||||
* Tests stub this to simulate interactive or non-interactive environments.
|
||||
*/
|
||||
isStdinTTY?: boolean;
|
||||
}
|
||||
|
||||
interface RawFleetRoster {
|
||||
@@ -805,42 +799,19 @@ export function registerFleetCommand(program: Command, deps: FleetCommandDeps =
|
||||
cmd
|
||||
.command('init')
|
||||
.description('Initialize a local fleet roster')
|
||||
.option(
|
||||
'--profile <name>',
|
||||
`Roster profile: ${FLEET_PROFILES.join(', ')} (skips interactive wizard)`,
|
||||
)
|
||||
.option('--profile <name>', 'Roster profile: minimal or local-canary', 'minimal')
|
||||
.option('--write', 'Write the roster to Mosaic home')
|
||||
.option('--force', 'Overwrite an existing roster when used with --write')
|
||||
.action(async (opts: { profile?: string; write?: boolean; force?: boolean }) => {
|
||||
.action(async (opts: { profile: string; write?: boolean; force?: boolean }) => {
|
||||
const commandOpts = cmd.opts<{ mosaicHome: string; roster?: string }>();
|
||||
const activePaths = resolveFleetPaths(commandOpts.mosaicHome);
|
||||
|
||||
let profile: FleetProfile;
|
||||
if (opts.profile !== undefined) {
|
||||
// Explicit --profile flag: validate and use it (non-interactive path).
|
||||
profile = parseInitProfile(opts.profile);
|
||||
} else {
|
||||
// No --profile: use wizard when stdin is a TTY, else default to 'general'.
|
||||
const isTTY = deps.isStdinTTY ?? process.stdin.isTTY ?? false;
|
||||
if (isTTY) {
|
||||
profile = await promptFleetProfile();
|
||||
} else {
|
||||
process.stderr.write(
|
||||
'Note: stdin is not a TTY; defaulting to fleet profile "general". ' +
|
||||
'Use --profile <name> to select a different preset.\n',
|
||||
);
|
||||
profile = 'general';
|
||||
}
|
||||
}
|
||||
|
||||
const source = join(frameworkRoot, 'fleet', 'examples', resolvePresetFilename(profile));
|
||||
const profile = parseInitProfile(opts.profile);
|
||||
const source = join(frameworkRoot, 'fleet', 'examples', `${profile}.yaml`);
|
||||
const content = await readFile(source, 'utf8');
|
||||
|
||||
if (!opts.write) {
|
||||
console.log(content.trimEnd());
|
||||
return;
|
||||
}
|
||||
|
||||
const destination = commandOpts.roster ?? activePaths.rosterPath;
|
||||
if (!opts.force && (await canRead(destination))) {
|
||||
throw new Error(
|
||||
@@ -849,23 +820,7 @@ export function registerFleetCommand(program: Command, deps: FleetCommandDeps =
|
||||
}
|
||||
await mkdir(dirname(destination), { recursive: true });
|
||||
await writeFile(destination, content);
|
||||
|
||||
// Validate: exactly one orchestrator required (R5) — friendly summary on success.
|
||||
const written = await loadFleetRoster(destination);
|
||||
const orchCount = countOrchestrators(written);
|
||||
if (orchCount !== 1) {
|
||||
process.stderr.write(
|
||||
`Warning: fleet roster at ${destination} has ${orchCount} orchestrator agent(s) (expected exactly 1).\n`,
|
||||
);
|
||||
console.log(
|
||||
`Initialized ${profile} fleet: ${written.agents.length} agent(s). Next: mosaic fleet install`,
|
||||
);
|
||||
} else {
|
||||
const workerCount = written.agents.length - 1;
|
||||
console.log(
|
||||
`Initialized ${profile} fleet: 1 orchestrator + ${workerCount} agent(s). Next: mosaic fleet install`,
|
||||
);
|
||||
}
|
||||
console.log(`Wrote fleet roster: ${destination}`);
|
||||
});
|
||||
|
||||
cmd
|
||||
@@ -1143,112 +1098,6 @@ export function registerFleetCommand(program: Command, deps: FleetCommandDeps =
|
||||
}
|
||||
});
|
||||
|
||||
cmd
|
||||
.command('add <name>')
|
||||
.description('Add a new agent to the fleet roster and optionally start it')
|
||||
.requiredOption('--runtime <runtime>', `Agent runtime (${VALID_FLEET_RUNTIMES.join(', ')})`)
|
||||
.requiredOption('--class <class>', 'Agent class (e.g. worker, orchestrator, canary)')
|
||||
.option('--model <hint>', 'Model hint for the agent')
|
||||
.option('--working-dir <path>', 'Working directory for the agent')
|
||||
.option('--no-start', 'Skip starting the agent after adding')
|
||||
.action(
|
||||
async (
|
||||
name: string,
|
||||
opts: {
|
||||
runtime: string;
|
||||
class: string;
|
||||
model?: string;
|
||||
workingDir?: string;
|
||||
start: boolean;
|
||||
},
|
||||
) => {
|
||||
if (!VALID_FLEET_RUNTIMES.includes(opts.runtime)) {
|
||||
throw new Error(
|
||||
`Invalid runtime "${opts.runtime}". Valid runtimes: ${VALID_FLEET_RUNTIMES.join(', ')}.`,
|
||||
);
|
||||
}
|
||||
const commandOpts = cmd.opts<{ mosaicHome: string; roster?: string }>();
|
||||
const activePaths = resolveFleetPaths(commandOpts.mosaicHome);
|
||||
const rosterPath = await resolveRosterPath(commandOpts.mosaicHome, commandOpts.roster);
|
||||
const roster = await loadFleetRoster(rosterPath);
|
||||
|
||||
const newAgent: FleetAgent = {
|
||||
name,
|
||||
runtime: opts.runtime,
|
||||
className: opts.class,
|
||||
...(opts.workingDir !== undefined && { workingDirectory: opts.workingDir }),
|
||||
...(opts.model !== undefined && { modelHint: opts.model }),
|
||||
};
|
||||
|
||||
const updatedRoster = addAgentToRoster(roster, newAgent);
|
||||
await writeFile(rosterPath, serializeRosterToYaml(updatedRoster));
|
||||
|
||||
const envPath = join(activePaths.agentEnvDir, `${name}.env`);
|
||||
const existingEnv = (await canRead(envPath)) ? await readFile(envPath, 'utf8') : undefined;
|
||||
await mkdir(activePaths.agentEnvDir, { recursive: true });
|
||||
await writeFile(
|
||||
envPath,
|
||||
mergeAgentEnv(generateAgentEnv(updatedRoster, newAgent), existingEnv),
|
||||
);
|
||||
|
||||
console.log(`Added ${name} (${opts.runtime}/${opts.class}) to the fleet.`);
|
||||
|
||||
if (opts.start !== false) {
|
||||
await runChecked(runner, buildFleetServiceCommand('start', name));
|
||||
console.log(`Started mosaic-agent@${name}.service.`);
|
||||
} else {
|
||||
console.log(`Agent queued (--no-start); run: mosaic fleet start ${name}`);
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
cmd
|
||||
.command('remove <name>')
|
||||
.description('Remove an agent from the fleet roster')
|
||||
.option('--keep-files', 'Skip deleting env and heartbeat files')
|
||||
.action(async (name: string, opts: { keepFiles?: boolean }) => {
|
||||
const commandOpts = cmd.opts<{ mosaicHome: string; roster?: string }>();
|
||||
const activePaths = resolveFleetPaths(commandOpts.mosaicHome);
|
||||
const rosterPath = await resolveRosterPath(commandOpts.mosaicHome, commandOpts.roster);
|
||||
const roster = await loadFleetRoster(rosterPath);
|
||||
|
||||
// Guard: throws if removing leaves 0 orchestrators or agent not in roster
|
||||
const updatedRoster = removeAgentFromRoster(roster, name);
|
||||
|
||||
// Stop agent (non-fatal)
|
||||
try {
|
||||
const stopResult = await runner(...splitCommand(buildFleetServiceCommand('stop', name)));
|
||||
if (stopResult.exitCode !== 0) {
|
||||
process.stderr.write(
|
||||
`Warning: could not stop mosaic-agent@${name}.service: ${stopResult.stderr || stopResult.stdout || 'non-zero exit'}\n`,
|
||||
);
|
||||
}
|
||||
} catch (err) {
|
||||
process.stderr.write(
|
||||
`Warning: stop command failed for ${name}: ${err instanceof Error ? err.message : String(err)}\n`,
|
||||
);
|
||||
}
|
||||
|
||||
// Write updated roster
|
||||
await writeFile(rosterPath, serializeRosterToYaml(updatedRoster));
|
||||
|
||||
// Delete env and heartbeat files (best-effort, non-fatal)
|
||||
if (!opts.keepFiles) {
|
||||
try {
|
||||
await unlink(join(activePaths.agentEnvDir, `${name}.env`));
|
||||
} catch {
|
||||
// best-effort
|
||||
}
|
||||
try {
|
||||
await unlink(heartbeatPath(name, activePaths.mosaicHome));
|
||||
} catch {
|
||||
// best-effort
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`Removed ${name} from the fleet.`);
|
||||
});
|
||||
|
||||
return cmd;
|
||||
}
|
||||
|
||||
@@ -1819,195 +1668,11 @@ function splitCommand(command: string[]): [string, string[]] {
|
||||
return [bin, args];
|
||||
}
|
||||
|
||||
/** All supported fleet profile names. */
|
||||
export type FleetProfile =
|
||||
| 'general'
|
||||
| 'coding'
|
||||
| 'research'
|
||||
| 'hybrid'
|
||||
| 'minimal'
|
||||
| 'local-canary';
|
||||
|
||||
/** The list of all valid fleet profile names, for wizard menus and error messages. */
|
||||
export const FLEET_PROFILES: readonly FleetProfile[] = [
|
||||
'general',
|
||||
'coding',
|
||||
'research',
|
||||
'hybrid',
|
||||
'minimal',
|
||||
'local-canary',
|
||||
];
|
||||
|
||||
/**
|
||||
* Maps a fleet profile name to its example YAML filename (without the path).
|
||||
* Pure function — testable without I/O.
|
||||
*/
|
||||
export function resolvePresetFilename(profile: FleetProfile): string {
|
||||
return `${profile}.yaml`;
|
||||
function parseInitProfile(profile: string): 'minimal' | 'local-canary' {
|
||||
if (profile === 'minimal' || profile === 'local-canary') {
|
||||
return profile;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate and normalise a fleet profile name string.
|
||||
* Throws with a clear message on unknown values.
|
||||
*/
|
||||
export function parseInitProfile(profile: string): FleetProfile {
|
||||
if ((FLEET_PROFILES as readonly string[]).includes(profile)) {
|
||||
return profile as FleetProfile;
|
||||
}
|
||||
throw new Error(`Unsupported fleet profile "${profile}". Use: ${FLEET_PROFILES.join(', ')}.`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Count orchestrator agents in a parsed roster.
|
||||
* Returns the count; callers assert === 1.
|
||||
*/
|
||||
export function countOrchestrators(roster: FleetRoster): number {
|
||||
return roster.agents.filter((a) => a.className === 'orchestrator').length;
|
||||
}
|
||||
|
||||
/** Valid runtime identifiers for fleet agents. */
|
||||
export const VALID_FLEET_RUNTIMES: readonly string[] = [
|
||||
'pi',
|
||||
'claude',
|
||||
'codex',
|
||||
'opencode',
|
||||
'dogfood',
|
||||
];
|
||||
|
||||
/**
|
||||
* Add a new agent to a fleet roster (immutable — returns a new FleetRoster).
|
||||
* Throws on invalid name, duplicate name.
|
||||
*/
|
||||
export function addAgentToRoster(roster: FleetRoster, agent: FleetAgent): FleetRoster {
|
||||
if (!agent.name || !/^[A-Za-z0-9_.-]+$/.test(agent.name)) {
|
||||
throw new Error(`Invalid fleet agent name: ${agent.name || '<empty>'}`);
|
||||
}
|
||||
if (roster.agents.some((a) => a.name === agent.name)) {
|
||||
throw new Error(`Agent "${agent.name}" already exists in the fleet roster.`);
|
||||
}
|
||||
return {
|
||||
...roster,
|
||||
agents: [...roster.agents, agent],
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove an agent from a fleet roster (immutable — returns a new FleetRoster).
|
||||
* Throws if the agent is not found, or if removal would leave zero orchestrators.
|
||||
*/
|
||||
export function removeAgentFromRoster(roster: FleetRoster, name: string): FleetRoster {
|
||||
const agent = roster.agents.find((a) => a.name === name);
|
||||
if (!agent) {
|
||||
throw new Error(`Agent "${name}" is not in the fleet roster.`);
|
||||
}
|
||||
const remaining = roster.agents.filter((a) => a.name !== name);
|
||||
const remainingOrchCount = remaining.filter((a) => a.className === 'orchestrator').length;
|
||||
if (remainingOrchCount === 0 && agent.className === 'orchestrator') {
|
||||
throw new Error(
|
||||
`Cannot remove agent "${name}": it is the sole orchestrator. Add another orchestrator first (R5).`,
|
||||
);
|
||||
}
|
||||
return {
|
||||
...roster,
|
||||
agents: remaining,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Serialize a FleetRoster to YAML text (snake_case keys).
|
||||
* The output is parseable by loadFleetRoster.
|
||||
*/
|
||||
export function serializeRosterToYaml(roster: FleetRoster): string {
|
||||
const agents = roster.agents.map((agent) => {
|
||||
const raw: Record<string, unknown> = {
|
||||
name: agent.name,
|
||||
runtime: agent.runtime,
|
||||
class: agent.className,
|
||||
};
|
||||
if (agent.workingDirectory !== undefined) {
|
||||
raw['working_directory'] = agent.workingDirectory;
|
||||
}
|
||||
if (agent.modelHint !== undefined) {
|
||||
raw['model_hint'] = agent.modelHint;
|
||||
}
|
||||
if (agent.persistentPersona !== undefined) {
|
||||
raw['persistent_persona'] = agent.persistentPersona;
|
||||
}
|
||||
if (agent.resetBetweenTasks !== undefined) {
|
||||
raw['reset_between_tasks'] = agent.resetBetweenTasks;
|
||||
}
|
||||
if (agent.kickstartTemplate !== undefined) {
|
||||
raw['kickstart_template'] = agent.kickstartTemplate;
|
||||
}
|
||||
return raw;
|
||||
});
|
||||
|
||||
const runtimes: Record<string, { reset_command: string }> = {};
|
||||
for (const [runtime, config] of Object.entries(roster.runtimes)) {
|
||||
runtimes[runtime] = { reset_command: config.resetCommand };
|
||||
}
|
||||
|
||||
const raw: Record<string, unknown> = {
|
||||
version: roster.version,
|
||||
transport: roster.transport,
|
||||
tmux: {
|
||||
socket_name: roster.tmux.socketName,
|
||||
holder_session: roster.tmux.holderSession,
|
||||
},
|
||||
defaults: {
|
||||
working_directory: roster.defaults.workingDirectory,
|
||||
},
|
||||
runtimes,
|
||||
agents,
|
||||
};
|
||||
|
||||
return YAML.stringify(raw);
|
||||
}
|
||||
|
||||
/**
|
||||
* Prompt interactively for a fleet profile via stdin readline.
|
||||
* AI-free: no LLM calls — pure readline menu.
|
||||
* Resolves with the chosen profile string, or rejects on I/O error.
|
||||
*/
|
||||
function promptFleetProfile(): Promise<FleetProfile> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
|
||||
const menu = [
|
||||
'',
|
||||
'Choose a fleet configuration type:',
|
||||
' 1) general — orchestrator + generalist worker',
|
||||
' 2) coding — orchestrator + coder0 + coder1 + reviewer',
|
||||
' 3) research — orchestrator + researcher0 + researcher1 + analyst',
|
||||
' 4) hybrid — orchestrator + coder0 + researcher0 + reviewer',
|
||||
' 5) minimal — single canary-pi agent (no orchestrator)',
|
||||
' 6) local-canary — legacy canary preset with lead + coder + reviewer',
|
||||
'',
|
||||
].join('\n');
|
||||
process.stdout.write(menu);
|
||||
rl.question('Enter number or name [1]: ', (answer) => {
|
||||
rl.close();
|
||||
const trimmed = answer.trim();
|
||||
// Map numeric shortcut → name
|
||||
const byNumber: Record<string, FleetProfile> = {
|
||||
'1': 'general',
|
||||
'2': 'coding',
|
||||
'3': 'research',
|
||||
'4': 'hybrid',
|
||||
'5': 'minimal',
|
||||
'6': 'local-canary',
|
||||
'': 'general', // default on empty enter
|
||||
};
|
||||
if (trimmed in byNumber) {
|
||||
resolve(byNumber[trimmed]!);
|
||||
return;
|
||||
}
|
||||
try {
|
||||
resolve(parseInitProfile(trimmed));
|
||||
} catch (err) {
|
||||
reject(err);
|
||||
}
|
||||
});
|
||||
});
|
||||
throw new Error(`Unsupported fleet profile "${profile}". Use: minimal, local-canary.`);
|
||||
}
|
||||
|
||||
function writeCommandOutput(result: CommandResult): void {
|
||||
|
||||
Reference in New Issue
Block a user