clay-server 5.1.1-beta.1 → 5.2.0-beta.10

package/lib/daemon-project-lifecycle.js

@@ -0,0 +1,262 @@
+// 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 };

package/lib/daemon-projects.js

@@ -146,7 +146,7 @@ function cleanupWorktreesForParent(relay, parentSlug) {
 function getFilteredRemovedProjects(config, userId) {
   if (!config.removedProjects || config.removedProjects.length === 0) return [];
   return config.removedProjects.filter(function (rp) {
-    if (userId && rp.userId && rp.userId !== userId) return false;
+    if (userId && rp.userId !== userId) return false;
     if (!userId && rp.userId) return false;
     return fs.existsSync(rp.path);
   });