clay-server 2.33.1 → 2.34.0-beta.10

package/lib/mate-datastore.js

@@ -0,0 +1,359 @@
+var fs = require("fs");
+var path = require("path");
+var config = require("./config");
+
+var sqlite;
+var _availabilityError = null;
+try {
+  sqlite = require("node:sqlite");
+} catch (e) {
+  sqlite = null;
+  _availabilityError = "Mate datastores require Node 22.13.0 or newer with node:sqlite available.";
+}
+
+function parseNodeVersion(version) {
+  var parts = String(version || "").split(".");
+  return {
+    major: parseInt(parts[0] || "0", 10) || 0,
+    minor: parseInt(parts[1] || "0", 10) || 0,
+    patch: parseInt(parts[2] || "0", 10) || 0,
+  };
+}
+
+function assertNodeVersion() {
+  var v = parseNodeVersion(process.versions.node);
+  if (v.major < 22 || (v.major === 22 && v.minor < 13)) {
+    throw new Error("Mate datastores require Node 22.13.0 or newer.");
+  }
+}
+try {
+  assertNodeVersion();
+} catch (e) {
+  if (!_availabilityError) _availabilityError = e.message;
+}
+
+var DatabaseSync = sqlite ? sqlite.DatabaseSync : null;
+
+var MAX_ROWS = 200;
+var MAX_RESULT_BYTES = 1024 * 1024;
+var DB_SIZE_WARNING_BYTES = 100 * 1024 * 1024;
+var PRAGMA_BUSY_TIMEOUT = 5000;
+var CLAY_META_VERSION = "1";
+
+var _dbCache = {};
+
+function isMateDatastoreAvailable() {
+  return !!DatabaseSync && !_availabilityError;
+}
+
+function getMateDatastoreAvailabilityError() {
+  return _availabilityError || null;
+}
+
+function assertAvailable() {
+  if (!isMateDatastoreAvailable()) {
+    throw new Error(getMateDatastoreAvailabilityError() || "Mate datastore is unavailable.");
+  }
+}
+
+function getMateDbPath(opts) {
+  if (opts && opts.dbPath) return String(opts.dbPath);
+  if (opts && opts.mateDir) return path.join(String(opts.mateDir), "store.db");
+  var userId = opts && opts.userId ? String(opts.userId) : "default";
+  var mateId = opts && opts.mateId ? String(opts.mateId) : null;
+  if (!mateId) throw new Error("Mate datastore requires a mateId.");
+  return path.join(config.CONFIG_DIR, "mates", userId, mateId, "store.db");
+}
+
+function ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function getDbSizeBytes(dbPath) {
+  try {
+    return fs.statSync(dbPath).size;
+  } catch (e) {
+    return 0;
+  }
+}
+
+function openDatabase(dbPath) {
+  var db = new DatabaseSync(dbPath);
+  try { db.exec("PRAGMA journal_mode = WAL"); } catch (e) {}
+  try { db.exec("PRAGMA foreign_keys = ON"); } catch (e2) {}
+  try { db.exec("PRAGMA busy_timeout = " + PRAGMA_BUSY_TIMEOUT); } catch (e3) {}
+  return db;
+}
+
+function initClayMeta(db) {
+  var now = new Date().toISOString();
+  db.exec("CREATE TABLE IF NOT EXISTS clay_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+  var stmt = db.prepare("INSERT OR IGNORE INTO clay_meta (key, value) VALUES (?, ?)");
+  stmt.run("clay_meta_version", CLAY_META_VERSION);
+  stmt.run("created_at", now);
+  stmt.run("last_opened_at", now);
+  db.prepare("UPDATE clay_meta SET value = ? WHERE key = ?").run(now, "last_opened_at");
+}
+
+function ensureMateDatastore(opts) {
+  assertAvailable();
+  var dbPath = getMateDbPath(opts);
+  if (_dbCache[dbPath] && _dbCache[dbPath].db) return _dbCache[dbPath];
+  ensureParentDir(dbPath);
+  var db = openDatabase(dbPath);
+  initClayMeta(db);
+  var wrapper = {
+    db: db,
+    dbPath: dbPath,
+    sizeBytes: getDbSizeBytes(dbPath),
+    warning: getDbSizeBytes(dbPath) > DB_SIZE_WARNING_BYTES ? "Mate datastore exceeds 100 MB soft warning threshold." : null,
+  };
+  _dbCache[dbPath] = wrapper;
+  return wrapper;
+}
+
+function openMateDatastore(opts) {
+  return ensureMateDatastore(opts);
+}
+
+function closeMateDatastore(handle) {
+  var wrapper = unwrapHandle(handle);
+  if (!wrapper || !wrapper.db) return;
+  try {
+    wrapper.db.close();
+  } catch (e) {}
+  if (wrapper.dbPath && _dbCache[wrapper.dbPath]) delete _dbCache[wrapper.dbPath];
+}
+
+function closeAllMateDatastores() {
+  var keys = Object.keys(_dbCache);
+  for (var i = 0; i < keys.length; i++) {
+    closeMateDatastore(_dbCache[keys[i]]);
+  }
+}
+
+function unwrapHandle(handle) {
+  if (!handle) return null;
+  if (handle.db && handle.dbPath) return handle;
+  return { db: handle, dbPath: null, sizeBytes: 0, warning: null };
+}
+
+function normalizeSql(sql) {
+  var text = String(sql || "");
+  text = text.replace(/^\s*(?:--[^\n]*\n|\/\*[\s\S]*?\*\/\s*)*/g, "");
+  return text.trim();
+}
+
+function getFirstKeyword(sql) {
+  var text = normalizeSql(sql);
+  var match = text.match(/^([A-Za-z]+)/);
+  return match ? match[1].toUpperCase() : "";
+}
+
+function hasMultipleStatements(sql) {
+  var text = normalizeSql(sql);
+  if (text.indexOf(";") === -1) return false;
+  return !/;\s*$/.test(text) || text.slice(0, -1).indexOf(";") !== -1;
+}
+
+function isForbiddenSql(sql) {
+  var text = normalizeSql(sql).toUpperCase();
+  var banned = [
+    "ATTACH DATABASE",
+    "DETACH DATABASE",
+    "LOAD_EXTENSION",
+    "LOAD EXTENSION",
+  ];
+  for (var i = 0; i < banned.length; i++) {
+    if (text.indexOf(banned[i]) !== -1) return banned[i];
+  }
+  if (/PRAGMA\s+(?!table_info|table_xinfo|index_list|index_info|foreign_key_list)/i.test(text)) {
+    return "PRAGMA";
+  }
+  return "";
+}
+
+function isReadOnlyQuery(sql) {
+  var kw = getFirstKeyword(sql);
+  if (kw === "SELECT" || kw === "WITH") return true;
+  return false;
+}
+
+function isAllowedExec(sql) {
+  var kw = getFirstKeyword(sql);
+  return kw === "CREATE" || kw === "ALTER" || kw === "DROP" || kw === "INSERT" || kw === "UPDATE" || kw === "DELETE";
+}
+
+function bindParams(stmt, params) {
+  if (!params) return stmt;
+  if (!Array.isArray(params)) return stmt;
+  return stmt.run.apply(stmt, params);
+}
+
+function runQuery(handle, sql, params, limits) {
+  var wrapper = unwrapHandle(handle);
+  if (!wrapper || !wrapper.db) {
+    return makeError("MATE_DATASTORE_UNAVAILABLE", "Mate datastore is not available.");
+  }
+  var text = normalizeSql(sql);
+  if (!text) return makeError("SQLITE_QUERY_REJECTED", "Query SQL is required.");
+  if (hasMultipleStatements(text)) return makeError("SQLITE_QUERY_REJECTED", "Multiple statements are not allowed in query mode.");
+  var forbidden = isForbiddenSql(text);
+  if (forbidden) return makeError("SQLITE_FORBIDDEN", forbidden + " is not allowed in Mate datastores.");
+  if (!isReadOnlyQuery(text)) return makeError("SQLITE_QUERY_REJECTED", "Only SELECT and WITH queries are allowed.");
+
+  try {
+    var stmt = wrapper.db.prepare(text);
+    var rows = Array.isArray(params) ? stmt.all.apply(stmt, params) : stmt.all();
+    rows = sanitizeValue(rows);
+    var rowCount = rows.length;
+    var maxRows = limits && typeof limits.maxRows === "number" ? limits.maxRows : MAX_ROWS;
+    var truncated = false;
+    if (rows.length > maxRows) {
+      rows = rows.slice(0, maxRows);
+      truncated = true;
+    }
+    var result = {
+      ok: true,
+      rows: rows,
+      rowCount: rowCount,
+      truncated: truncated,
+    };
+    if (wrapper.warning) result.warning = wrapper.warning;
+    if (limits && limits.includeSizeInfo) {
+      result.sizeBytes = wrapper.sizeBytes;
+    }
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") > (limits && limits.maxBytes ? limits.maxBytes : MAX_RESULT_BYTES)) {
+      return makeError("SQLITE_RESULT_TOO_LARGE", "Query result exceeds the 1 MB response limit.");
+    }
+    return result;
+  } catch (e) {
+    return normalizeSqliteError(e, "SQLITE_EXEC_FAILED", "Query failed.");
+  }
+}
+
+function runExec(handle, sql, params, limits) {
+  var wrapper = unwrapHandle(handle);
+  if (!wrapper || !wrapper.db) {
+    return makeError("MATE_DATASTORE_UNAVAILABLE", "Mate datastore is not available.");
+  }
+  var text = normalizeSql(sql);
+  if (!text) return makeError("MATE_DATASTORE_BAD_INPUT", "SQL is required.");
+  if (hasMultipleStatements(text)) return makeError("SQLITE_EXEC_FAILED", "Multiple statements are not allowed in exec mode.");
+  var forbidden = isForbiddenSql(text);
+  if (forbidden) return makeError("SQLITE_FORBIDDEN", forbidden + " is not allowed in Mate datastores.");
+  if (!isAllowedExec(text)) return makeError("SQLITE_EXEC_FAILED", "Only CREATE, ALTER, DROP, INSERT, UPDATE, and DELETE are allowed in exec mode.");
+
+  try {
+    var stmt = wrapper.db.prepare(text);
+    var runResult = Array.isArray(params) ? stmt.run.apply(stmt, params) : stmt.run();
+    var result = {
+      ok: true,
+      changes: typeof runResult.changes === "number" ? runResult.changes : 0,
+      lastInsertRowid: typeof runResult.lastInsertRowid !== "undefined" ? sanitizeValue(runResult.lastInsertRowid) : null,
+    };
+    if (wrapper.warning) result.warning = wrapper.warning;
+    if (limits && limits.includeSizeInfo) {
+      result.sizeBytes = getDbSizeBytes(wrapper.dbPath);
+    }
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") > (limits && limits.maxBytes ? limits.maxBytes : MAX_RESULT_BYTES)) {
+      return makeError("SQLITE_RESULT_TOO_LARGE", "Execution result exceeds the 1 MB response limit.");
+    }
+    wrapper.sizeBytes = getDbSizeBytes(wrapper.dbPath);
+    if (wrapper.sizeBytes > DB_SIZE_WARNING_BYTES) {
+      wrapper.warning = "Mate datastore exceeds 100 MB soft warning threshold.";
+      result.warning = wrapper.warning;
+    }
+    return result;
+  } catch (e) {
+    return normalizeSqliteError(e, "SQLITE_EXEC_FAILED", "Execution failed.");
+  }
+}
+
+function listSchemaObjects(handle) {
+  var wrapper = unwrapHandle(handle);
+  if (!wrapper || !wrapper.db) {
+    return makeError("MATE_DATASTORE_UNAVAILABLE", "Mate datastore is not available.");
+  }
+  try {
+    var rows = wrapper.db.prepare(
+      "SELECT name, type, sql FROM sqlite_master WHERE type IN ('table', 'view', 'index') AND name NOT LIKE 'sqlite_%' AND name NOT LIKE 'clay_%' ORDER BY type, name"
+    ).all();
+    return { ok: true, objects: rows };
+  } catch (e) {
+    return normalizeSqliteError(e, "SQLITE_EXEC_FAILED", "Failed to list schema objects.");
+  }
+}
+
+function describeTable(handle, tableName) {
+  var wrapper = unwrapHandle(handle);
+  if (!wrapper || !wrapper.db) {
+    return makeError("MATE_DATASTORE_UNAVAILABLE", "Mate datastore is not available.");
+  }
+  if (!isSafeIdentifier(tableName)) {
+    return makeError("MATE_DATASTORE_BAD_INPUT", "Table name is invalid.");
+  }
+  try {
+    var info = wrapper.db.prepare("SELECT name, type, sql FROM sqlite_master WHERE name = ? AND type IN ('table', 'view')").get(tableName);
+    if (!info) return makeError("SQLITE_TABLE_NOT_FOUND", "Table not found.");
+    var columns = wrapper.db.prepare("PRAGMA table_info(" + quoteIdentifier(tableName) + ")").all();
+    var indexes = wrapper.db.prepare("PRAGMA index_list(" + quoteIdentifier(tableName) + ")").all();
+    return {
+      ok: true,
+      table: tableName,
+      columns: columns,
+      indexes: indexes,
+      createSql: info.sql || null,
+    };
+  } catch (e) {
+    return normalizeSqliteError(e, "SQLITE_EXEC_FAILED", "Failed to describe table.");
+  }
+}
+
+function isSafeIdentifier(name) {
+  return typeof name === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+
+function quoteIdentifier(name) {
+  return '"' + String(name).replace(/"/g, '""') + '"';
+}
+
+function makeError(code, message) {
+  return { ok: false, code: code, message: message };
+}
+
+function sanitizeValue(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(sanitizeValue);
+  if (value && typeof value === "object") {
+    var out = {};
+    var keys = Object.keys(value);
+    for (var i = 0; i < keys.length; i++) {
+      out[keys[i]] = sanitizeValue(value[keys[i]]);
+    }
+    return out;
+  }
+  return value;
+}
+
+function normalizeSqliteError(err, fallbackCode, fallbackMessage) {
+  var message = err && err.message ? String(err.message) : fallbackMessage;
+  var code = fallbackCode;
+  if (message.indexOf("no such table") !== -1) code = "SQLITE_TABLE_NOT_FOUND";
+  if (message.indexOf("no such column") !== -1) code = "SQLITE_QUERY_REJECTED";
+  return { ok: false, code: code, message: message };
+}
+
+module.exports = {
+  isMateDatastoreAvailable: isMateDatastoreAvailable,
+  getMateDatastoreAvailabilityError: getMateDatastoreAvailabilityError,
+  openMateDatastore: openMateDatastore,
+  ensureMateDatastore: ensureMateDatastore,
+  listSchemaObjects: listSchemaObjects,
+  describeTable: describeTable,
+  runQuery: runQuery,
+  runExec: runExec,
+  closeMateDatastore: closeMateDatastore,
+  closeAllMateDatastores: closeAllMateDatastores,
+  getMateDbPath: getMateDbPath,
+};

package/lib/mates.js

@@ -131,6 +131,7 @@ function createMate(ctx, seedData) {
     createdBy: userId,
     createdAt: Date.now(),
     seedData: seedData || {},
+    vendor: (seedData && seedData.vendor) || "claude",
     profile: {
       displayName: null,
       avatarColor: colors[colorIdx],
@@ -158,7 +159,7 @@ function createMate(ctx, seedData) {
   yaml += "createdAt: " + mate.createdAt + "\n";
   yaml += "relationship: " + (seedData.relationship || "assistant") + "\n";
   yaml += "activities: " + JSON.stringify(seedData.activity || []) + "\n";
-  yaml += "autonomy: " + (seedData.autonomy || "always_ask") + "\n";
+  yaml += "vendor: " + (seedData.vendor || "claude") + "\n";
   fs.writeFileSync(path.join(mateDir, "mate.yaml"), yaml);
 
   // Write initial CLAUDE.md (will be replaced by interview)
@@ -172,7 +173,6 @@ function createMate(ctx, seedData) {
   if (seedData.communicationStyle && seedData.communicationStyle.length > 0) {
     claudeMd += "- Communication: " + seedData.communicationStyle.join(", ") + "\n";
   }
-  claudeMd += "- Autonomy: " + (seedData.autonomy || "always_ask") + "\n";
   var initialIdentity = claudeMd.trimEnd();
   claudeMd += TEAM_SECTION;
   claudeMd += SESSION_MEMORY_SECTION;

package/lib/os-users.js

@@ -3,14 +3,24 @@
 
 var fs = require("fs");
 var path = require("path");
-var { execSync } = require("child_process");
+var execFileSync = require("child_process").execFileSync;
+var _aclGrantCache = Object.create(null);
+
+function aclCacheKey(projectPath, linuxUser) {
+  return path.resolve(projectPath) + "::" + linuxUser;
+}
+
+function isSafeLinuxUsername(username) {
+  return typeof username === "string" && /^[a-z_][a-z0-9_-]*[$]?$/.test(username);
+}
 
 /**
  * Resolve Linux user info from username via getent passwd.
  * Returns { uid, gid, home, user, shell } or throws on failure.
  */
 function resolveOsUserInfo(username) {
-  var output = execSync("getent passwd " + username, { encoding: "utf8", timeout: 5000 }).trim();
+  if (!isSafeLinuxUsername(username)) throw new Error("Invalid Linux username");
+  var output = execFileSync("getent", ["passwd", username], { encoding: "utf8", timeout: 5000, stdio: "pipe" }).trim();
   // getent passwd format: username:x:uid:gid:gecos:home:shell
   var parts = output.split(":");
   if (parts.length < 7) throw new Error("Unexpected getent output for user " + username);
@@ -74,7 +84,7 @@ function fsAsUser(op, args, osUserInfo) {
       "var buf = fs.readFileSync(f);",
       "process.stdout.write(buf.toString('base64'));",
     ].join(" ");
-    var binOutput = execSync(process.execPath + " -e " + JSON.stringify(script), {
+    var binOutput = execFileSync(process.execPath, ["-e", script], {
       encoding: "utf8",
       timeout: 10000,
       uid: osUserInfo.uid,
@@ -94,7 +104,7 @@ function fsAsUser(op, args, osUserInfo) {
     throw new Error("Unknown fsAsUser operation: " + op);
   }
 
-  var output = execSync(process.execPath + " -e " + JSON.stringify(script), {
+  var output = execFileSync(process.execPath, ["-e", script], {
     encoding: "utf8",
     timeout: 10000,
     uid: osUserInfo.uid,
@@ -151,7 +161,7 @@ function getAclInstallCommand() {
  */
 function checkAclSupport() {
   try {
-    execSync("which setfacl", { encoding: "utf8", timeout: 5000, stdio: "pipe" });
+    execFileSync("which", ["setfacl"], { encoding: "utf8", timeout: 5000, stdio: "pipe" });
     return { available: true };
   } catch (e) {
     return { available: false, installCmd: getAclInstallCommand() };
@@ -182,19 +192,31 @@ function grantProjectAccess(projectPath, linuxUser) {
     console.log("[os-users] Skipping ACL for home directory: " + projectPath);
     return;
   }
+  if (!isSafeLinuxUsername(linuxUser)) {
+    console.error("[os-users] Invalid Linux username for ACL grant: " + linuxUser);
+    return;
+  }
+  var cacheKey = aclCacheKey(projectPath, linuxUser);
+  if (_aclGrantCache[cacheKey]) {
+    return;
+  }
   try {
     // Recursive ACL for existing files
-    execSync("setfacl -R -m u:" + linuxUser + ":rwX " + JSON.stringify(projectPath), {
+    execFileSync("setfacl", ["-R", "-m", "u:" + linuxUser + ":rwX", projectPath], {
       encoding: "utf8",
       timeout: 30000,
+      stdio: "pipe",
     });
     // Default ACL so new files also inherit access
-    execSync("setfacl -R -d -m u:" + linuxUser + ":rwX " + JSON.stringify(projectPath), {
+    execFileSync("setfacl", ["-R", "-d", "-m", "u:" + linuxUser + ":rwX", projectPath], {
       encoding: "utf8",
       timeout: 30000,
+      stdio: "pipe",
     });
+    _aclGrantCache[cacheKey] = true;
     console.log("[os-users] Granted ACL access for " + linuxUser + " on " + projectPath);
   } catch (e) {
+    delete _aclGrantCache[cacheKey];
     var errMsg = (e.stderr || e.message || "").toString();
     if (errMsg.indexOf("not found") !== -1 || errMsg.indexOf("ENOENT") !== -1) {
       var cmd = getAclInstallCommand();
@@ -214,15 +236,23 @@ function revokeProjectAccess(projectPath, linuxUser) {
     console.log("[os-users] Skipping ACL revoke for home directory: " + projectPath);
     return;
   }
+  if (!isSafeLinuxUsername(linuxUser)) {
+    console.error("[os-users] Invalid Linux username for ACL revoke: " + linuxUser);
+    return;
+  }
+  var cacheKey = aclCacheKey(projectPath, linuxUser);
   try {
-    execSync("setfacl -R -x u:" + linuxUser + " " + JSON.stringify(projectPath), {
+    execFileSync("setfacl", ["-R", "-x", "u:" + linuxUser, projectPath], {
       encoding: "utf8",
       timeout: 30000,
+      stdio: "pipe",
     });
-    execSync("setfacl -R -d -x u:" + linuxUser + " " + JSON.stringify(projectPath), {
+    execFileSync("setfacl", ["-R", "-d", "-x", "u:" + linuxUser, projectPath], {
       encoding: "utf8",
       timeout: 30000,
+      stdio: "pipe",
     });
+    delete _aclGrantCache[cacheKey];
     console.log("[os-users] Revoked ACL access for " + linuxUser + " on " + projectPath);
   } catch (e) {
     var errMsg = (e.stderr || e.message || "").toString();
@@ -260,10 +290,11 @@ function toLinuxUsername(clayUsername) {
  */
 function ensureLinger(username) {
   try {
-    var uid = execSync("id -u " + username, { encoding: "utf8", timeout: 5000, stdio: "pipe" }).trim();
+    if (!isSafeLinuxUsername(username)) throw new Error("Invalid Linux username");
+    var uid = execFileSync("id", ["-u", username], { encoding: "utf8", timeout: 5000, stdio: "pipe" }).trim();
     var lingerFile = "/var/lib/systemd/linger/" + username;
     if (fs.existsSync(lingerFile)) return;
-    execSync("loginctl enable-linger " + username, {
+    execFileSync("loginctl", ["enable-linger", username], {
       encoding: "utf8",
       timeout: 10000,
       stdio: "pipe",
@@ -279,7 +310,8 @@ function ensureLinger(username) {
  */
 function linuxUserExists(username) {
   try {
-    execSync("id " + username, { encoding: "utf8", timeout: 5000, stdio: "pipe" });
+    if (!isSafeLinuxUsername(username)) return false;
+    execFileSync("id", [username], { encoding: "utf8", timeout: 5000, stdio: "pipe" });
     return true;
   } catch (e) {
     return false;
@@ -288,7 +320,8 @@ function linuxUserExists(username) {
 
 function getLinuxUserHome(username) {
   try {
-    var line = execSync("getent passwd " + username, { encoding: "utf8", timeout: 5000, stdio: "pipe" }).trim();
+    if (!isSafeLinuxUsername(username)) return "/home/" + (username || "");
+    var line = execFileSync("getent", ["passwd", username], { encoding: "utf8", timeout: 5000, stdio: "pipe" }).trim();
     var parts = line.split(":");
     return parts[5] || "/home/" + username;
   } catch (e) {
@@ -298,7 +331,8 @@ function getLinuxUserHome(username) {
 
 function getLinuxUserUid(username) {
   try {
-    var uid = execSync("id -u " + username, { encoding: "utf8", timeout: 5000, stdio: "pipe" }).trim();
+    if (!isSafeLinuxUsername(username)) return null;
+    var uid = execFileSync("id", ["-u", username], { encoding: "utf8", timeout: 5000, stdio: "pipe" }).trim();
     return parseInt(uid, 10);
   } catch (e) {
     return null;
@@ -312,11 +346,13 @@ function getLinuxUserUid(username) {
  */
 function installClaudeCli(linuxName) {
   try {
+    if (!isSafeLinuxUsername(linuxName)) throw new Error("Invalid Linux username");
     // Download and run the Claude CLI install script as the target user
-    execSync(
-      "su - " + linuxName + " -c \"curl -fsSL https://claude.ai/install.sh | bash\"",
-      { encoding: "utf8", timeout: 60000, stdio: "pipe" }
-    );
+    execFileSync("su", ["-", linuxName, "-c", "curl -fsSL https://claude.ai/install.sh | bash"], {
+      encoding: "utf8",
+      timeout: 60000,
+      stdio: "pipe",
+    });
     console.log("[os-users] Claude CLI installed for " + linuxName);
   } catch (e) {
     var msg = (e.stderr || e.message || "").trim();
@@ -326,24 +362,19 @@ function installClaudeCli(linuxName) {
 
   // Append PATH export to the user's shell config if not already present
   try {
-    var home = "/home/" + linuxName;
-    var rcFile;
-    if (fs.existsSync(home + "/.zshrc")) {
-      rcFile = "~/.zshrc";
+    var userInfo = resolveOsUserInfo(linuxName);
+    var home = userInfo.home || ("/home/" + linuxName);
+    var rcPath = fs.existsSync(path.join(home, ".zshrc")) ? path.join(home, ".zshrc") : path.join(home, ".bashrc");
+    var exportLine = 'export PATH="$HOME/.local/bin:$PATH"';
+    var existing = "";
+    try { existing = fs.readFileSync(rcPath, "utf8"); } catch (e2) {}
+    if (existing.indexOf(exportLine) === -1) {
+      var prefix = existing && !/\n$/.test(existing) ? "\n" : "";
+      fs.appendFileSync(rcPath, prefix + exportLine + "\n", "utf8");
+      try { fs.chownSync(rcPath, userInfo.uid, userInfo.gid); } catch (e3) {}
+      console.log("[os-users] PATH export appended to " + rcPath + " for " + linuxName);
     } else {
-      rcFile = "~/.bashrc";
-    }
-
-    // Check if PATH export is already present before appending
-    var checkCmd = "su - " + linuxName + " -c \"grep -qF '/.local/bin' " + rcFile + "\"";
-    try {
-      execSync(checkCmd, { encoding: "utf8", timeout: 5000, stdio: "pipe" });
-      console.log("[os-users] PATH already configured in " + rcFile + " for " + linuxName);
-    } catch (grepErr) {
-      // grep returned non-zero, meaning the line is not present; append it
-      var appendCmd = "su - " + linuxName + " -c 'echo \"export PATH=\\\"\\$HOME/.local/bin:\\$PATH\\\"\" >> " + rcFile + "'";
-      execSync(appendCmd, { encoding: "utf8", timeout: 5000, stdio: "pipe" });
-      console.log("[os-users] PATH export appended to " + rcFile + " for " + linuxName);
+      console.log("[os-users] PATH already configured in " + rcPath + " for " + linuxName);
     }
   } catch (e) {
     var rcMsg = (e.stderr || e.message || "").trim();
@@ -368,7 +399,7 @@ function provisionLinuxUser(clayUsername) {
   }
 
   try {
-    execSync("useradd -m -s /bin/bash " + linuxName, {
+    execFileSync("useradd", ["-m", "-s", "/bin/bash", linuxName], {
       encoding: "utf8",
       timeout: 15000,
       stdio: "pipe",
@@ -453,7 +484,8 @@ function grantAllUsersAccess(projectPath, usersModule) {
  */
 function deactivateLinuxUser(linuxUsername) {
   try {
-    execSync("usermod -L " + linuxUsername, { encoding: "utf8", timeout: 5000, stdio: "pipe" });
+    if (!isSafeLinuxUsername(linuxUsername)) throw new Error("Invalid Linux username");
+    execFileSync("usermod", ["-L", linuxUsername], { encoding: "utf8", timeout: 5000, stdio: "pipe" });
     console.log("[os-users] Deactivated Linux user: " + linuxUsername);
     return { ok: true };
   } catch (e) {
@@ -493,4 +525,5 @@ module.exports = {
   isHomeDirectory: isHomeDirectory,
   getLinuxUserHome: getLinuxUserHome,
   getLinuxUserUid: getLinuxUserUid,
+  isSafeLinuxUsername: isSafeLinuxUsername,
 };

package/lib/project-connection.js

@@ -52,12 +52,27 @@ function attachConnection(ctx) {
   var getLatestVersion = ctx.getLatestVersion;
   var getTitle = ctx.getTitle;
   var getProject = ctx.getProject;
+  var warmup = ctx.warmup;
+
+  // Adapters are initialized lazily: the first websocket connection into
+  // this project triggers warmup. Without this guard we would either keep
+  // the old eager behavior (30+ Codex processes at daemon start) or run
+  // warmup once per reconnect.
+  var _warmedUp = false;
 
   function handleConnection(ws, wsUser, handleMessage, handleDisconnection) {
     ws._clayUser = wsUser || null;
     clients.add(ws);
     broadcastClientCount();
 
+    if (!_warmedUp) {
+      _warmedUp = true;
+      if (typeof warmup === "function") {
+        try { warmup(); }
+        catch (e) { console.error("[project-connection] warmup failed for " + slug + ":", e && e.message ? e.message : e); }
+      }
+    }
+
     var loopState = _loop.loopState;
     var loopRegistry = _loop.loopRegistry;
 
@@ -67,16 +82,7 @@ function attachConnection(ctx) {
       setTimeout(function() { _loop.resumeLoop(); }, 500);
     }
 
-    // Auto-assign owner if project has none and a user connects (e.g. IPC-added projects)
     var projectOwnerId = getProjectOwnerId();
-    if (!projectOwnerId && ws._clayUser && ws._clayUser.id && !isMate) {
-      setProjectOwnerId(ws._clayUser.id);
-      projectOwnerId = ws._clayUser.id;
-      if (opts.onProjectOwnerChanged) {
-        opts.onProjectOwnerChanged(slug, projectOwnerId);
-      }
-      console.log("[project] Auto-assigned owner for " + slug + ": " + projectOwnerId);
-    }
 
     // Send cached state
     var _userId = ws._clayUser ? ws._clayUser.id : null;
@@ -140,6 +146,7 @@ function attachConnection(ctx) {
           ownerId: s.ownerId || null,
           sessionVisibility: s.sessionVisibility || "shared",
           bookmarked: !!s.bookmarked,
+          favoriteOrder: typeof s.favoriteOrder === "number" ? s.favoriteOrder : null,
         };
       }),
     });