311 lines
9.9 KiB
TypeScript
311 lines
9.9 KiB
TypeScript
import { randomUUID } from 'node:crypto';
|
|
import fsp from 'node:fs/promises';
|
|
import type { FileHandle } from 'node:fs/promises';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
import {
|
|
AGENT_KEY,
|
|
type JsonObject,
|
|
type RuntimeContract,
|
|
isObject,
|
|
} from './droid-contract.js';
|
|
import {
|
|
type DroidSources,
|
|
type RenderedDocument,
|
|
createSettingsDocument,
|
|
parseDocument,
|
|
} from './droid-config.js';
|
|
|
|
interface FileChange {
|
|
readonly filePath: string;
|
|
readonly label: string;
|
|
readonly original?: string;
|
|
readonly next?: string;
|
|
}
|
|
|
|
interface StagedChange {
|
|
readonly change: FileChange;
|
|
readonly tempPath?: string;
|
|
readonly rollbackPath?: string;
|
|
committed: boolean;
|
|
}
|
|
|
|
function errorMessage(error: unknown): string {
|
|
return error instanceof Error ? error.message : String(error);
|
|
}
|
|
|
|
function asError(error: unknown): Error {
|
|
return error instanceof Error ? error : new Error(String(error));
|
|
}
|
|
|
|
function hasErrorCode(error: unknown, code: string): boolean {
|
|
return isObject(error) && error.code === code;
|
|
}
|
|
|
|
function factoryPaths(): {
|
|
readonly root: string;
|
|
readonly legacy: string;
|
|
readonly settings: string;
|
|
} {
|
|
const directory = path.join(os.homedir(), '.factory');
|
|
return {
|
|
root: path.join(directory, 'hooks.json'),
|
|
legacy: path.join(directory, 'hooks', 'hooks.json'),
|
|
settings: path.join(directory, 'settings.json'),
|
|
};
|
|
}
|
|
|
|
async function readOptional(filePath: string, label: string): Promise<string | undefined> {
|
|
try {
|
|
return await fsp.readFile(filePath, 'utf-8');
|
|
} catch (error) {
|
|
if (hasErrorCode(error, 'ENOENT')) return undefined;
|
|
throw new Error(`Read ${label} at ${filePath}: ${errorMessage(error)}`, {
|
|
cause: asError(error),
|
|
});
|
|
}
|
|
}
|
|
|
|
export async function readSources(): Promise<DroidSources> {
|
|
const paths = factoryPaths();
|
|
const [rootRaw, settingsRaw] = await Promise.all([
|
|
readOptional(paths.root, 'Factory Droid hooks'),
|
|
readOptional(paths.settings, 'Factory Droid settings'),
|
|
]);
|
|
let primary;
|
|
if (rootRaw !== undefined) {
|
|
primary = parseDocument({
|
|
exists: true,
|
|
filePath: paths.root,
|
|
kind: 'hooks',
|
|
raw: rootRaw,
|
|
});
|
|
} else {
|
|
const legacyRaw = await readOptional(paths.legacy, 'Factory Droid legacy hooks');
|
|
if (legacyRaw !== undefined) {
|
|
primary = parseDocument({
|
|
exists: true,
|
|
filePath: paths.legacy,
|
|
kind: 'legacy',
|
|
raw: legacyRaw,
|
|
});
|
|
}
|
|
}
|
|
const settings = settingsRaw === undefined
|
|
? createSettingsDocument(paths.settings)
|
|
: parseDocument({
|
|
exists: true,
|
|
filePath: paths.settings,
|
|
kind: 'settings',
|
|
raw: settingsRaw,
|
|
});
|
|
return { rootPath: paths.root, primary, settings };
|
|
}
|
|
|
|
function labelFor(rendered: RenderedDocument): string {
|
|
if (rendered.document.kind === 'settings') return 'Factory Droid settings';
|
|
if (rendered.document.kind === 'legacy') return 'Factory Droid legacy hooks';
|
|
return 'Factory Droid hooks';
|
|
}
|
|
|
|
function fileChange(rendered: RenderedDocument): FileChange | undefined {
|
|
if (!rendered.changed) return undefined;
|
|
return {
|
|
filePath: rendered.document.filePath,
|
|
label: labelFor(rendered),
|
|
original: rendered.document.exists ? rendered.document.raw : undefined,
|
|
next: rendered.next,
|
|
};
|
|
}
|
|
|
|
async function unlinkOptional(filePath: string): Promise<void> {
|
|
try {
|
|
await fsp.unlink(filePath);
|
|
} catch (error) {
|
|
if (!hasErrorCode(error, 'ENOENT')) throw error;
|
|
}
|
|
}
|
|
|
|
async function writeExclusive(filePath: string, contents: string, label: string): Promise<void> {
|
|
let handle: FileHandle | undefined;
|
|
try {
|
|
handle = await fsp.open(filePath, 'wx', 0o600);
|
|
await handle.writeFile(contents, 'utf-8');
|
|
await handle.sync();
|
|
await handle.close();
|
|
} catch (error) {
|
|
const failures = [asError(error)];
|
|
if (handle) {
|
|
try {
|
|
await handle.close();
|
|
} catch (closeError) {
|
|
failures.push(asError(closeError));
|
|
}
|
|
}
|
|
try {
|
|
await unlinkOptional(filePath);
|
|
} catch (cleanupError) {
|
|
failures.push(asError(cleanupError));
|
|
}
|
|
if (failures.length > 1) {
|
|
throw new AggregateError(failures, `Stage ${label} at ${filePath}`);
|
|
}
|
|
throw new Error(`Stage ${label} at ${filePath}: ${errorMessage(error)}`, {
|
|
cause: failures[0],
|
|
});
|
|
}
|
|
}
|
|
|
|
async function assertUnchanged(change: FileChange): Promise<void> {
|
|
const current = await readOptional(change.filePath, change.label);
|
|
if (current !== change.original) {
|
|
throw new Error(`${change.label} changed during installation: ${change.filePath}`);
|
|
}
|
|
}
|
|
|
|
async function stage(change: FileChange): Promise<StagedChange> {
|
|
await assertUnchanged(change);
|
|
const directory = path.dirname(change.filePath);
|
|
await fsp.mkdir(directory, { recursive: true, mode: 0o700 });
|
|
const token = randomUUID();
|
|
const tempPath = change.next === undefined
|
|
? undefined
|
|
: path.join(directory, `.${path.basename(change.filePath)}.${token}.tmp`);
|
|
const rollbackPath = change.original === undefined
|
|
? undefined
|
|
: path.join(directory, `.${path.basename(change.filePath)}.${token}.rollback`);
|
|
try {
|
|
if (tempPath) await writeExclusive(tempPath, change.next!, change.label);
|
|
if (rollbackPath && change.next !== undefined) {
|
|
await writeExclusive(rollbackPath, change.original!, `${change.label} rollback`);
|
|
}
|
|
} catch (error) {
|
|
const failures = [asError(error)];
|
|
for (const stagedPath of [tempPath, rollbackPath]) {
|
|
if (!stagedPath) continue;
|
|
try {
|
|
await unlinkOptional(stagedPath);
|
|
} catch (cleanupError) {
|
|
failures.push(asError(cleanupError));
|
|
}
|
|
}
|
|
if (failures.length > 1) throw new AggregateError(failures, `Stage ${change.label}`);
|
|
throw error;
|
|
}
|
|
return { change, tempPath, rollbackPath, committed: false };
|
|
}
|
|
|
|
async function commit(staged: StagedChange): Promise<void> {
|
|
await assertUnchanged(staged.change);
|
|
if (staged.change.next === undefined) {
|
|
if (!staged.rollbackPath) throw new Error(`Missing rollback path for ${staged.change.label}`);
|
|
await fsp.rename(staged.change.filePath, staged.rollbackPath);
|
|
} else {
|
|
if (!staged.tempPath) throw new Error(`Missing staged file for ${staged.change.label}`);
|
|
await fsp.rename(staged.tempPath, staged.change.filePath);
|
|
}
|
|
staged.committed = true;
|
|
}
|
|
|
|
async function rollback(staged: StagedChange): Promise<void> {
|
|
if (!staged.committed) return;
|
|
if (staged.change.original === undefined) {
|
|
await unlinkOptional(staged.change.filePath);
|
|
return;
|
|
}
|
|
if (!staged.rollbackPath) throw new Error(`Missing rollback data for ${staged.change.label}`);
|
|
await fsp.rename(staged.rollbackPath, staged.change.filePath);
|
|
}
|
|
|
|
async function cleanup(staged: StagedChange): Promise<void> {
|
|
const paths = [staged.tempPath, staged.rollbackPath].filter(
|
|
(filePath): filePath is string => filePath !== undefined,
|
|
);
|
|
await Promise.all(paths.map(unlinkOptional));
|
|
}
|
|
|
|
export async function writeDocuments(rendered: RenderedDocument[]): Promise<void> {
|
|
const changes = rendered.flatMap((item) => {
|
|
const next = fileChange(item);
|
|
return next ? [next] : [];
|
|
});
|
|
if (changes.length === 0) return;
|
|
const staged: StagedChange[] = [];
|
|
try {
|
|
for (const change of changes) staged.push(await stage(change));
|
|
for (const item of staged) await commit(item);
|
|
} catch (error) {
|
|
const failures = [asError(error)];
|
|
for (const item of [...staged].reverse()) {
|
|
try {
|
|
await rollback(item);
|
|
} catch (rollbackError) {
|
|
failures.push(asError(rollbackError));
|
|
}
|
|
}
|
|
for (const item of staged) {
|
|
try {
|
|
await cleanup(item);
|
|
} catch (cleanupError) {
|
|
failures.push(asError(cleanupError));
|
|
}
|
|
}
|
|
if (failures.length > 1) throw new AggregateError(failures, 'Write Factory Droid hook sources');
|
|
throw new Error(`Write Factory Droid hook sources: ${errorMessage(error)}`, {
|
|
cause: failures[0],
|
|
});
|
|
}
|
|
await Promise.all(staged.map(cleanup));
|
|
}
|
|
|
|
export async function regularFileExists(filePath: string, label: string): Promise<boolean> {
|
|
try {
|
|
return (await fsp.stat(filePath)).isFile();
|
|
} catch (error) {
|
|
if (hasErrorCode(error, 'ENOENT') || hasErrorCode(error, 'ENOTDIR')) return false;
|
|
throw new Error(`Read ${label} at ${filePath}: ${errorMessage(error)}`, {
|
|
cause: asError(error),
|
|
});
|
|
}
|
|
}
|
|
|
|
export async function requireRuntime(filePath: string, label: string): Promise<void> {
|
|
if (!filePath) throw new Error(`${label} path is required`);
|
|
if (!await regularFileExists(filePath, label)) throw new Error(`${label} is missing: ${filePath}`);
|
|
}
|
|
|
|
async function readRuntimeConfig(filePath: string): Promise<JsonObject | undefined> {
|
|
const raw = await readOptional(filePath, 'Elydora runtime config');
|
|
if (raw === undefined) return undefined;
|
|
let value: unknown;
|
|
try {
|
|
value = JSON.parse(raw);
|
|
} catch (error) {
|
|
throw new Error(`Failed to parse Elydora runtime config at ${filePath}: ${errorMessage(error)}`, {
|
|
cause: asError(error),
|
|
});
|
|
}
|
|
if (!isObject(value)) throw new Error(`Elydora runtime config at ${filePath} must contain a JSON object`);
|
|
return value;
|
|
}
|
|
|
|
export async function runtimeFilesExist(contracts: RuntimeContract[]): Promise<boolean> {
|
|
for (const contract of contracts) {
|
|
const agentDirectory = path.dirname(contract.guardPath);
|
|
const runtimeConfig = await readRuntimeConfig(path.join(agentDirectory, 'config.json'));
|
|
if (!runtimeConfig || runtimeConfig.agent_name !== AGENT_KEY) continue;
|
|
const files = await Promise.all([
|
|
regularFileExists(contract.guardPath, 'Elydora guard runtime'),
|
|
regularFileExists(contract.auditPath, 'Elydora audit runtime'),
|
|
]);
|
|
if (files.every(Boolean)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
export function displayConfigPath(sources: DroidSources): string {
|
|
if (sources.primary) return sources.primary.filePath;
|
|
if (sources.settings.exists && sources.settings.hasHooksContainer) return sources.settings.filePath;
|
|
return sources.rootPath;
|
|
}
|