lib/daemon-project-lifecycle.js
Rama main · réplica de lectura del repositorio original.
// Shared ordinary-project mutations. Persistence precedes runtime publication.
var fs = require('fs');
var path = require('path');
var cp = require('child_process');
var access = require('./daemon-project-access');
var ownership = require('./project-ownership');
var configModule = require('./config');
function attachProjectLifecycle(ctx) {
var pending = new Map();
var operations = require('./project-lifecycle-operations').attachLifecycleOperations({ config: config, find: find, snapshot: snapshot, save: save, record: record,
storageDir: configModule.CONFIG_DIR, directory: identity, relay: relay, publish: publish, publishRuntime: publishRuntime });
function config() { return ctx.getConfig(); }
function relay() { return ctx.getRelay(); }
function find(slug) { return (config().projects || []).find(function (p) { return p.slug === slug; }); }
function ordinary(project) {
if (!project || ownership.isPersonal(project) || access.parentSlugFor(project.slug)) throw new Error('Choose a registered ordinary parent project. Clay, Mates and worktrees are excluded.');
if (project.lifecycleState) throw new Error('Project removal is still pending; inspect its receipt before another action.');
return project;
}
function save(next) { ctx.saveConfig(next); ctx.setConfig(next); }
function publish() {
try { configModule.syncClayrc(config().projects); } catch (error) {}
relay().broadcastAll({ type: 'projects_updated', projects: relay().getProjects(), projectCount: config().projects.length });
}
function identity(candidate) {
var canonical = fs.realpathSync(candidate), stat = fs.statSync(canonical);
if (!stat.isDirectory()) throw new Error('Choose an existing directory.');
return { path: canonical, dev: stat.dev, ino: stat.ino, uid: stat.uid };
}
function existing(candidate, user) {
var target = identity(candidate), found = (config().projects || []).find(function (project) { return require('./project-directory-claim').canonical(project.path) === target.path; });
if (!found) return null;
var users = require('./users');
if (users.isMultiUser() ? !user || !users.canAccessProject(user.id, access.getProjectAccess(config(), found.slug, config().osUsers)) : !!found.ownerId && found.ownerId !== (user && user.id || null)) throw new Error('Directory access is not permitted.');
ordinary(found);
return found;
}
function registration(candidate, user) {
var target = identity(candidate);
var dataRoot = require('./project-directory-claim').canonical(configModule.CONFIG_DIR);
var relative = path.relative(dataRoot, target.path), inverse = path.relative(target.path, dataRoot);
if (relative !== '..' && relative.indexOf('..' + path.sep) !== 0 && !path.isAbsolute(relative) || inverse !== '..' && inverse.indexOf('..' + path.sep) !== 0 && !path.isAbsolute(inverse)) throw new Error('Clay private storage cannot be registered as an ordinary project.');
(config().projects || []).forEach(function (p) {
var root = identity(p.path).path;
function inside(a, b) { var rel = path.relative(a, b); return rel !== '..' && rel.indexOf('..' + path.sep) !== 0 && !path.isAbsolute(rel); }
if (inside(target.path, root) || inside(root, target.path) && p.ownerId !== (user && user.id)) throw new Error('Directory intersects a registered project.');
});
return target;
}
function assertSupported(action) {
if (config().osUsers && ['visibility', 'allowed_users', 'owner'].indexOf(action) >= 0) throw new Error('OS filesystem sharing and ownership changes are unavailable through canonical Clay; the OS sharing/ownership transaction has no completion acknowledgement.');
}
function creationPlan(name) {
var current = config(), base = current.osUsers ? '/var/clay/projects' : current.projectsDir || path.join(configModule.REAL_HOME, 'clay-projects');
var canonical = require('./project-directory-claim').canonical;
var slug = configModule.generateSlug(path.join(base, name), current.projects.map(function (p) { return p.slug; }));
return { base: base, path: path.join(canonical(base), slug), slug: slug };
}
function creationRevision(anchor) {
var plan = creationPlan('inspection');
var canonical = require('./project-directory-claim').canonical;
if (!anchor) {
anchor = plan.base;
while (!fs.existsSync(anchor)) { var parent = path.dirname(anchor); if (parent === anchor) break; anchor = parent; }
}
return JSON.stringify({ base: plan.base, canonicalBase: canonical(plan.base), anchor: anchor, directory: identity(anchor), osUsers: config().osUsers, projects: config().projects });
}
function inspect(slug) {
var project = ordinary(find(slug));
return { project: JSON.parse(JSON.stringify(project)), directory: identity(project.path) };
}
function stamp(slug) { return JSON.stringify(inspect(slug)); }
function receipt(key, fingerprint, userId) {
var item = key && (config().projectControlReceipts || {})[key];
if (!item) return null;
if (item.fingerprint !== fingerprint || item.ownerId !== (userId || null)) throw new Error('requestId already names another exact project action.');
var live = item.slug && find(item.slug);
if (!live && item.result.filesDeleted !== false && item.result.outcome !== 'removal_reserved_runtime_pending') throw new Error('The receipt target registration was deleted. No action was repeated.');
if (live && (live.projectKnowledgeId !== item.projectKnowledgeId || live.ownerId !== item.ownerId && !(item.action === 'owner' && item.result.status === 'completed'))) throw new Error('The receipt target was replaced or transferred.');
return item.result;
}
function record(next, correlation, result, project, action) {
if (!correlation) return;
var receipts = Object.assign({}, next.projectControlReceipts || {});
if (!receipts[correlation.key] && Object.keys(receipts).length >= 5000) throw new Error('Project control receipt capacity reached.');
receipts[correlation.key] = { action: action || correlation.action, sourceKey: correlation.sourceKey || null, fingerprint: correlation.fingerprint, ownerId: correlation.ownerId || null, slug: project && project.slug, projectKnowledgeId: project && project.projectKnowledgeId, result: result };
next.projectControlReceipts = receipts;
}
function runtime(slug) { var found; relay().forEachProject(function (project, candidate) { if (candidate === slug) found = project; }); return found; }
function publishRuntime(project, action) {
if (config().osUsers && (action === 'register' || action === 'create')) require('./project-linux-access').verify(project.path, ctx.findUser(project.ownerId), ctx.resolveIdentity);
var current = runtime(project.slug), status = current && current.getStatus();
if (status && (status.path !== project.path || status.projectKnowledgeId !== project.projectKnowledgeId)) throw new Error('A replacement runtime occupies the saved registration.');
if (!current && relay().addProject(project.path, project.slug, project.title || null, project.icon || null, project.ownerId || null, null, { projectKnowledgeId: project.projectKnowledgeId }) === false) throw new Error('Saved project runtime publication was not acknowledged.');
relay().setProjectTitle(project.slug, project.title || null);
relay().forEachProject(function (target, slug) {
if (slug === project.slug || access.parentSlugFor(slug) === project.slug) {
target.setProjectOwner(project.ownerId || null);
if ((action === 'environment' || action === 'recovered') && target.refreshEnvironmentRuntime) target.refreshEnvironmentRuntime();
}
});
if (action === 'owner' || action === 'visibility' || action === 'allowed_users' || action === 'recovered') relay().refreshProjectAccess();
if ((action === 'create' || action === 'register') && ctx.registerWorktrees) ctx.registerWorktrees(project, project.ownerId && ctx.findUser(project.ownerId));
}
function publication(next, project, action, result, correlation) {
var op = operations.begin(next, project, action, result, correlation);
save(next);
try {
publishRuntime(project, action);
if (correlation && correlation.authorize) correlation.authorize();
operations.exact(op);
var completed = snapshot(); operations.complete(completed, op, project); save(completed);
try { publish(); } catch (error) { result.notificationPending = true; }
return Object.assign({}, result, { operationId: op.id });
} catch (error) { error.lifecycleResult = Object.assign({}, error.lifecycleResult || {}, operations.partial(op, error.message)); throw error; }
}
function receiptPreview(fingerprint, sourceKey, ownerId) {
return Object.values(config().projectControlReceipts || {}).find(function (item) {
return item.action === 'owner' && item.result.status === 'completed' && item.fingerprint === fingerprint && item.sourceKey === sourceKey && item.ownerId === ownerId;
});
}
function snapshot() { var lastConfig = config(); return Object.assign({}, lastConfig, JSON.parse(JSON.stringify(lastConfig))); }
function creatingAccount(user, existingOnly) {
var users = require('./users');
if (!users.isMultiUser()) return null;
var live = user && ctx.findUser(user.id);
if (!live || !existingOnly && !users.getEffectivePermissions(live, config().osUsers).createProject) throw new Error('Live project creation permission is required.');
return live;
}
function create(name, user, correlation, validate) {
user = creatingAccount(user);
if (!/^[a-zA-Z0-9_-]{1,100}$/.test(name) || (/^mate-/i.test(name) || name.indexOf('--') >= 0)) throw new Error('Invalid ordinary project name.');
if (validate) validate();
var current = config(), base = current.osUsers ? '/var/clay/projects' : current.projectsDir || path.join(configModule.REAL_HOME, 'clay-projects');
var creatingIdentity = JSON.stringify([user && user.id, user && user.linuxUser]);
var osIdentity = null;
if (current.osUsers) {
if (!user || !user.linuxUser) throw new Error('A provisioned Linux account is required.');
osIdentity = ctx.resolveIdentity(user.linuxUser);
if (!Number.isInteger(osIdentity.uid) || !Number.isInteger(osIdentity.gid)) throw new Error('Linux identity unavailable.');
}
var slug = configModule.generateSlug(path.join(base, name), current.projects.map(function (p) { return p.slug; }));
var claim = require('./project-directory-claim').claim({ baseDir: base, slug: slug, projects: current.projects, userId: user && user.id });
var persisted = false;
try {
claim.assertOwned();
var options = { cwd: claim.path, stdio: 'pipe' };
if (osIdentity) {
fs.chownSync(claim.path, osIdentity.uid, osIdentity.gid);
options = Object.assign({}, options, { uid: osIdentity.uid, gid: osIdentity.gid, env: { HOME: osIdentity.home, USER: user.linuxUser, PATH: '/usr/local/bin:/usr/bin:/bin' } });
var wrapped = require('./os-users').wrapSpawnAsUser('git', ['init'], options);
cp.execFileSync(wrapped.command, wrapped.args, wrapped.options);
} else cp.execFileSync('git', ['init'], options);
claim.assertOwned();
user = creatingAccount(user);
if (JSON.stringify([user && user.id, user && user.linuxUser]) !== creatingIdentity) throw new Error('Creating OS account identity changed.');
if (osIdentity && JSON.stringify(ctx.resolveIdentity(user.linuxUser)) !== JSON.stringify(osIdentity)) throw new Error('Resolved OS identity changed during creation.');
if (osIdentity) { fs.chmodSync(claim.path, 0o700); require('./project-linux-access').verify(claim.path, user, ctx.resolveIdentity); }
if (validate) validate();
var next = snapshot(), project = { slug: slug, path: claim.path, ownerId: user && user.id || null, visibility: 'private', addedAt: Date.now(), projectKnowledgeId: require('./project-log-context').createProjectKnowledgeId() };
next.projects.push(project);
var result = { ok: true, slug: slug, status: 'completed' };
return publication(next, project, 'create', result, correlation);
} catch (error) {
persisted = !!(error.lifecycleResult && error.lifecycleResult.persisted);
if (!persisted) { try { if (!claim.cleanup()) error.message += '; claimed directory was replaced; cleanup skipped'; } catch (cleanupError) { error.message += '; directory cleanup failed: ' + cleanupError.message; } }
else error.message += '; registration persisted; inspect operationId and explicitly reconcile rather than creating again';
throw error;
}
}
function register(candidate, user, correlation, validate) {
user = creatingAccount(user, true);
if (validate) validate();
var registered = existing(candidate, user);
if (registered) {
if (config().osUsers) require('./project-linux-access').verify(registered.path, user, ctx.resolveIdentity);
if (!runtime(registered.slug)) {
var pendingOperation = Object.values(config().projectLifecycleOperations || {}).reverse().find(function (item) { return item.slug === registered.slug && item.phase === 'pending'; });
if (pendingOperation) return operations.partial(pendingOperation);
throw new Error('The registration exists but its runtime is unavailable.');
}
return { ok: true, status: 'completed', slug: registered.slug, existing: true };
}
user = creatingAccount(user);
var target = registration(candidate, user), next = snapshot();
if (config().osUsers) require('./project-linux-access').verify(candidate, user, ctx.resolveIdentity);
var slug = configModule.generateSlug(target.path, next.projects.map(function (p) { return p.slug; }));
if (/^mate-/.test(slug) || access.parentSlugFor(slug)) throw new Error('Reserved private project identity.');
var removed = (next.removedProjects || []).find(function (p) { return p.path === target.path && (p.userId || null) === (user && user.id || null); });
var project = { slug: slug, path: target.path, ownerId: user && user.id || null, visibility: 'private', addedAt: Date.now(), projectKnowledgeId: removed && removed.projectKnowledgeId || require('./project-log-context').createProjectKnowledgeId() };
next.projects.push(project); next.removedProjects = (next.removedProjects || []).filter(function (p) { return p.path !== target.path; });
if (validate) validate();
var result = { ok: true, status: 'completed', slug: slug };
return publication(next, project, 'register', result, correlation);
}
function update(slug, action, value, correlation, validate) {
if (validate) validate();
ordinary(find(slug));
var next = snapshot(), project = next.projects.find(function (p) { return p.slug === slug; });
if (action === 'rename') {
if (value !== null && (typeof value !== 'string' || value.length > 100 || /[\u0000-\u001f\u007f]/.test(value))) throw new Error('Invalid project title.');
project.title = value;
} else if (action === 'environment') {
if (typeof value !== 'string' || value.length > 100000 || /\u0000/.test(value)) throw new Error('Invalid project environment.');
var envError = require('./runtime-env').validateEnvString(value);
if (envError) throw new Error(envError);
project.envrc = value;
} else if (action === 'visibility') {
if (next.osUsers) throw new Error('OS filesystem sharing changes are unavailable through this service.');
if (value !== 'public' && value !== 'private') throw new Error('Invalid visibility.'); project.visibility = value;
} else if (action === 'allowed_users') {
if (next.osUsers) throw new Error('OS filesystem sharing changes are unavailable through this service.');
if (!Array.isArray(value) || value.length > 100 || value.some(function (id, i) { return !ctx.findUser(id) || value.indexOf(id) !== i; })) throw new Error('Choose existing unique accounts.');
project.allowedUsers = value;
} else if (action === 'owner') {
if (next.osUsers) throw new Error('OS ownership transfers are unavailable through this service.');
if (typeof value !== 'string' || !ctx.findUser(value)) throw new Error('Choose an existing owner account.');
project.ownerId = value;
} else if (action === 'session_visibility') {
var changed = access.setSessionVisibilityDefault(next, slug, value); if (!changed.ok) throw new Error(changed.error);
} else throw new Error('Unsupported project mutation.');
var result = { ok: true, status: 'completed', slug: slug };
if (action === 'environment') result.runtimeRefreshed = true;
if (action === 'environment') result.timing = 'Applies to newly created coding-agent processes. Active processes keep their current environment.';
return publication(next, project, action, result, correlation);
}
async function remove(slug, userId, correlation, validate) {
if (validate) validate();
var project = ordinary(find(slug)), next = snapshot();
var savedProject = next.projects.find(function (item) { return item.slug === slug; });
var result = { ok: true, status: 'completed', slug: slug, filesDeleted: false, semantics: 'Removed the Clay registration and stopped project runtimes. Project files and stored history remain on disk.' };
var targets = relay().getProjectLifecycleTargets(slug);
var op = operations.begin(next, savedProject, 'remove', result, correlation, targets); save(next);
return operations.reconcile(slug, op.id, { userId: userId || null }, correlation && correlation.authorize || function () {}, null);
}
function execute(args, user, correlation, validate) {
var old = correlation && receipt(correlation.key, correlation.fingerprint, correlation.ownerId);
if (old) return pending.get(correlation.key) || old;
if (args.action === 'reconcile' || args.action === 'recover_registration') return operations.reconcile(args.projectSlug, args.value, { userId: user && user.id || null }, correlation.authorize, validate, args.action === 'recover_registration');
if (args.action === 'create') return create(args.name, user, correlation, validate);
if (args.action === 'register') return register(args.path, user, correlation, validate);
if (args.action !== 'remove') return update(args.projectSlug, args.action, args.value, correlation, validate);
var promise = remove(args.projectSlug, user && user.id, correlation, validate).catch(function (error) {
var current = find(args.projectSlug);
if (current && current.lifecycleState === 'removing' && !error.lifecycleResult) error.lifecycleResult = { outcome: 'removal_reserved_runtime_pending', persisted: true, retrySafe: false, slug: args.projectSlug, operationId: current.lifecycleOperationId, recoveryAction: 'reconcile' };
throw error;
});
if (correlation) { pending.set(correlation.key, promise); promise.finally(function () { pending.delete(correlation.key); }).catch(function () {}); }
return promise;
}
function resumeRecovered(slug, userId) {
var project = ordinary(find(slug));
var pendingOperation = access.pendingLifecycleOperation(config(), project);
if (pendingOperation) throw new Error('Review and reconcile pending project operation ' + pendingOperation.id + ' before resuming execution.');
if (!project.lifecycleExecutionPaused) return true;
if (project.ownerId !== userId || !ctx.findUser(userId)) throw new Error('Only the current owner can explicitly resume recovered project execution.');
var next = snapshot(); delete next.projects.find(function (item) { return item.slug === slug; }).lifecycleExecutionPaused; save(next); return true;
}
function canRestore(project) { return !project.lifecycleState; }
return { resumeRecovered: resumeRecovered, inspectRecovery: operations.inspect, receiptPreview: receiptPreview, canRestore: canRestore, assertSupported: assertSupported, creationPlan: creationPlan, creationRevision: creationRevision, inspect: inspect, stamp: stamp, registration: registration, receipt: receipt, execute: execute, create: create, register: register, update: update, remove: remove };
}
module.exports = { attachProjectLifecycle: attachProjectLifecycle };