Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
// vi.mock() calls are hoisted by Vitest before import evaluation, but are placed
// at the top for clarity and to match the convention in other test files.
// ── Listener-guard suite support (see "CoS event listener rejection guards").
// `initSpawner()` wires the real `task:ready` / `agent:terminate` listeners onto
// the shared `cosEvents` emitter; these mocks keep that wiring off the network,
// the runner socket and the agent store, and let a single test force the one
// rejection it is about.
const listenerGuardState = vi.hoisted(() => ({ loadStateError: null, terminateError: null }));
vi.mock('./providerStatus.js', async (importOriginal) => ({
...(await importOriginal()),
initProviderStatus: vi.fn().mockResolvedValue(undefined),
}));
vi.mock('./cosRunnerClient.js', async (importOriginal) => ({
...(await importOriginal()),
isRunnerAvailable: vi.fn().mockResolvedValue(false),
isRunnerReachable: vi.fn().mockResolvedValue(false),
initCosRunnerConnection: vi.fn(),
onCosRunnerEvent: vi.fn(),
}));
vi.mock('./agentManagement.js', async (importOriginal) => ({
...(await importOriginal()),
cleanupOrphanedAgents: vi.fn().mockResolvedValue(undefined),
}));
vi.mock('./updateChecker.js', async (importOriginal) => ({
...(await importOriginal()),
isUpdateInProgress: vi.fn().mockReturnValue(false),
}));
vi.mock('./cosForgeSpawnGate.js', async (importOriginal) => ({
...(await importOriginal()),
forgeSpawnHoldReason: vi.fn().mockResolvedValue(null),
}));
vi.mock('./cosState.js', async (importOriginal) => {
const actual = await importOriginal();
return {
...actual,
loadState: vi.fn(async () => {
if (listenerGuardState.loadStateError) throw listenerGuardState.loadStateError;
return actual.loadState();
}),
};
});
vi.mock('./agentOrchestrator.js', async (importOriginal) => {
const actual = await importOriginal();
return {
...actual,
spawnAgentForTask: vi.fn().mockResolvedValue(undefined),
terminateAgent: vi.fn(async () => {
if (listenerGuardState.terminateError) throw listenerGuardState.terminateError;
}),
};
});
import { describe, it, expect, vi, beforeAll, beforeEach, afterEach } from 'vitest';
import { isTruthyMeta, isFalsyMeta } from './agentState.js';
import { cosEvents } from './cosEvents.js';
import { initSpawner } from './subAgentSpawner.js';
import { applyAppWorktreeDefault } from './cosTaskGenerator.js';
/**
* Pure decision helpers from the sub-agent spawn path.
*
* Kept under this name because it is where these cases were written; each import
* now names the module that DEFINES the helper. They used to come through
* `subAgentSpawner.js`'s back-compat barrel, retired in #3450 — a test reaching
* for a re-export is exactly the kind of consumer that kept that barrel alive.
*
* Note: We test the pure functions directly by importing them from production.
* For functions with complex dependencies (process spawning, file system, etc.)
* we focus on the decision-making logic that can be unit tested.
*/
// Worktree/PR flag resolution + metadata coercion helpers, exercised through
// the real production helpers (isTruthyMeta/isFalsyMeta/applyAppWorktreeDefault).
describe('Worktree & metadata flag helpers', () => {
// --- isTruthyMeta helper (imported from production) ---
describe('isTruthyMeta', () => {
it('should return true for boolean true', () => {
expect(isTruthyMeta(true)).toBe(true);
});
it('should return true for string "true"', () => {
expect(isTruthyMeta('true')).toBe(true);
});
it('should return false for false', () => {
expect(isTruthyMeta(false)).toBe(false);
});
it('should return false for undefined/null/other values', () => {
expect(isTruthyMeta(undefined)).toBe(false);
expect(isTruthyMeta(null)).toBe(false);
expect(isTruthyMeta('false')).toBe(false);
expect(isTruthyMeta(1)).toBe(false);
expect(isTruthyMeta('')).toBe(false);
});
});
// --- isFalsyMeta helper (imported from production) ---
describe('isFalsyMeta', () => {
it('should return true for boolean false', () => {
expect(isFalsyMeta(false)).toBe(true);
});
it('should return true for string "false"', () => {
expect(isFalsyMeta('false')).toBe(true);
});
it('should return false for true', () => {
expect(isFalsyMeta(true)).toBe(false);
});
it('should return false for undefined/null/other values', () => {
expect(isFalsyMeta(undefined)).toBe(false);
expect(isFalsyMeta(null)).toBe(false);
expect(isFalsyMeta('true')).toBe(false);
expect(isFalsyMeta(0)).toBe(false);
expect(isFalsyMeta('')).toBe(false);
});
});
// --- applyAppWorktreeDefault logic (imported from production cos.js) ---
describe('applyAppWorktreeDefault', () => {
it('should fill defaults when metadata has no worktree/openPR fields', () => {
const metadata = {};
applyAppWorktreeDefault(metadata, { defaultUseWorktree: true, defaultOpenPR: true });
expect(metadata.useWorktree).toBe(true);
expect(metadata.openPR).toBe(true);
});
it('should not override task-type metadata that is already set', () => {
const metadata = { useWorktree: false, openPR: false };
applyAppWorktreeDefault(metadata, { defaultUseWorktree: true, defaultOpenPR: true });
expect(metadata.useWorktree).toBe(false);
expect(metadata.openPR).toBe(false);
});
it('should enforce openPR=false when useWorktree=false', () => {
const metadata = { useWorktree: false };
applyAppWorktreeDefault(metadata, { defaultOpenPR: true });
expect(metadata.openPR).toBe(false);
});
it('should imply useWorktree when defaultOpenPR is true', () => {
const metadata = {};
applyAppWorktreeDefault(metadata, { defaultOpenPR: true });
expect(metadata.useWorktree).toBe(true);
expect(metadata.openPR).toBe(true);
});
it('copies an explicit app PR completion default onto new PR tasks', () => {
const metadata = {};
applyAppWorktreeDefault(metadata, { defaultOpenPR: true, defaultPrCompletion: 'leave-open' });
expect(metadata).toMatchObject({ useWorktree: true, openPR: true, prCompletion: 'leave-open' });
});
it.each(['merge-on-green', 'leave-open', 'draft'])('keeps a task-level %s pin over the app default', policy => {
// The Schedule tab's "After opening PR" select writes this pin into the
// interval's taskMetadata — the more specific choice must win.
const metadata = { prCompletion: policy };
applyAppWorktreeDefault(metadata, { defaultOpenPR: true, defaultPrCompletion: 'review-then-merge' });
expect(metadata.prCompletion).toBe(policy);
});
it('pins reviewed auto-merge on a new PR task when the app has no completion setting', () => {
const metadata = {};
applyAppWorktreeDefault(metadata, { defaultOpenPR: true });
expect(metadata.prCompletion).toBe('review-then-merge');
});
it.each([true, false, 'true', 'false'])('preserves an explicit legacy reviewLoop=%s unless the app pins a policy', reviewLoop => {
const metadata = { openPR: true, reviewLoop };
applyAppWorktreeDefault(metadata, {});
expect(metadata.prCompletion).toBe(reviewLoop === true || reviewLoop === 'true' ? 'review-then-merge' : 'merge-on-green');
const overridden = { openPR: true, reviewLoop };
applyAppWorktreeDefault(overridden, { defaultPrCompletion: 'draft' });
expect(overridden.prCompletion).toBe('draft');
});
it('applies app leave-open to self-managed claim PRs without provisioning another worktree', () => {
const metadata = { claimFlow: true, useWorktree: false, openPR: false };
applyAppWorktreeDefault(metadata, { defaultPrCompletion: 'leave-open' });
expect(metadata).toMatchObject({ prCompletion: 'leave-open', useWorktree: false, openPR: false });
});
it('should not let defaultUseWorktree:false override explicit openPR:true', () => {
const metadata = { openPR: true };
applyAppWorktreeDefault(metadata, { defaultUseWorktree: false });
// openPR implies useWorktree — app default must not override explicit openPR
expect(metadata.useWorktree).toBe(true);
expect(metadata.openPR).toBe(true);
});
it('should handle openPR:"true" string the same as boolean true', () => {
const metadata = { openPR: 'true' };
applyAppWorktreeDefault(metadata, { defaultUseWorktree: false });
expect(metadata.useWorktree).toBe(true);
expect(metadata.openPR).toBe('true');
});
it('should leave metadata unchanged when app has no defaults', () => {
const metadata = { useWorktree: true, openPR: true };
applyAppWorktreeDefault(metadata, {});
expect(metadata.useWorktree).toBe(true);
expect(metadata.openPR).toBe(true);
});
it('should default openPR to true when worktree is enabled and defaultOpenPR is not false', () => {
const metadata = { useWorktree: true };
applyAppWorktreeDefault(metadata, {});
expect(metadata.openPR).toBe(true);
const metadata2 = {};
applyAppWorktreeDefault(metadata2, { defaultUseWorktree: true });
expect(metadata2.useWorktree).toBe(true);
expect(metadata2.openPR).toBe(true);
});
});
});
/**
* `cosEvents` is a plain `EventEmitter` — it neither awaits nor catches what a
* listener returns, so an `async` listener passed straight to `.on` turns any
* rejection into a process-level `unhandledRejection`. For `task:ready`, the one
* chokepoint every spawn emitter funnels through, that also means the queued
* task is silently never dispatched and the failure carries no task id.
*
* These two cases pin the wrapper: they fail if the `.catch` is dropped, or if a
* new `await` is added ahead of the listener's inner `try`.
*/
describe('CoS event listener rejection guards', () => {
const flushMicrotasks = async () => {
for (let i = 0; i < 5; i++) await new Promise(resolve => setImmediate(resolve));
};
let logs;
let unhandled;
const collectLog = entry => logs.push(entry);
const collectUnhandled = reason => unhandled.push(reason);
beforeAll(async () => {
await initSpawner();
});
beforeEach(() => {
logs = [];
unhandled = [];
cosEvents.on('log', collectLog);
process.on('unhandledRejection', collectUnhandled);
});
afterEach(() => {
cosEvents.off('log', collectLog);
process.off('unhandledRejection', collectUnhandled);
listenerGuardState.loadStateError = null;
listenerGuardState.terminateError = null;
});
it('logs a task:ready dispatch failure with the task id instead of leaking a rejection', async () => {
listenerGuardState.loadStateError = new Error('state read failed');
cosEvents.emit('task:ready', { id: 'task-x' });
await flushMicrotasks();
expect(unhandled).toEqual([]);
const errors = logs.filter(entry => entry.level === 'error');
expect(errors).toHaveLength(1);
expect(errors[0].message).toContain('task-x');
expect(errors[0].message).toContain('state read failed');
expect(errors[0].taskId).toBe('task-x');
});
it('logs an agent:terminate failure with the agent id instead of leaking a rejection', async () => {
listenerGuardState.terminateError = new Error('Agent not found');
cosEvents.emit('agent:terminate', 'agent-unknown');
await flushMicrotasks();
expect(unhandled).toEqual([]);
const errors = logs.filter(entry => entry.level === 'error');
expect(errors).toHaveLength(1);
expect(errors[0].message).toContain('agent-unknown');
expect(errors[0].message).toContain('Agent not found');
expect(errors[0].agentId).toBe('agent-unknown');
});
});