clay-server 5.1.0-beta.2 → 6.0.0-beta.1

package/lib/sdk-message-processor.js

@@ -6,11 +6,13 @@ var yoke = require("./yoke");
 var backgroundTaskTiming = require("./background-task-timing");
 var sessionTitlePolicy = require("./session-title-policy");
 var askUserIdentity = require("./ask-user-request-identity");
+var quotaSnapshots = require("./sdk-quota-snapshot");
 
 var OVERLOAD_RETRY_LIMIT = 3;
 
 function attachMessageProcessor(ctx) {
   var sm = ctx.sm;
+  quotaSnapshots.attachQuotaSnapshots(sm);
   var send = ctx.send;
   var slug = ctx.slug;
   var isMate = ctx.isMate;
@@ -653,11 +655,13 @@ function attachMessageProcessor(ctx) {
         session._queuedTurnCount = 0;
         onProcessingChanged();
       }
-      // Detect "Not logged in" scenario early for the check below
+      // Recognize only short, zero-cost CLI login responses, not ordinary prose.
       var previewTrimmed = (session.responsePreview || "").trim();
       var isZeroCost = !parsed.cost || parsed.cost === 0;
       var isLoginPrompt = isZeroCost && previewTrimmed.length < 100
-        && /not logged in/i.test(previewTrimmed) && /\/login/i.test(previewTrimmed);
+        && ((/not logged in/i.test(previewTrimmed) && /\/login/i.test(previewTrimmed))
+          || ((session.vendor || "claude") === "claude"
+            && /^Failed to authenticate: OAuth session expired and could not be refreshed\.?$/i.test(previewTrimmed)));
       // Fetch rich context usage breakdown (fire-and-forget, non-blocking)
       if (session.queryInstance && typeof session.queryInstance.getContextUsage === "function") {
         var contextQuery = session.queryInstance;
@@ -692,7 +696,7 @@ function attachMessageProcessor(ctx) {
       if (parsed.fastModeState) {
         sendAndRecord(session, { type: "fast_mode_state", state: parsed.fastModeState });
       }
-      // Detect "Not logged in / Please run /login" from SDK.
+      // Recover both missing login and expired OAuth sessions from the SDK.
       // This is a short canned response with zero cost, not actual AI output.
       if (isLoginPrompt) {
         emitAuthRequired(session);
@@ -853,6 +857,10 @@ function attachMessageProcessor(ctx) {
 
     } else if (parsed.yokeType === "rate_limit") {
       var info = parsed.rateLimitInfo;
+      if (info.source === "account_snapshot") {
+        quotaSnapshots.recordQuotaSnapshot(session, info, sendAndRecord);
+        return;
+      }
       console.log("[sdk-bridge] rate_limit_event for session " + session.localId + ": status=" + info.status + " resetsAt=" + info.resetsAt + " isUsingOverage=" + info.isUsingOverage + " isProcessing=" + session.isProcessing);
 
       // Persist the scoped reset snapshot so reconnect/history restore can reproject it.
@@ -877,7 +885,11 @@ function attachMessageProcessor(ctx) {
           resetsAt: info.resetsAt ? info.resetsAt * 1000 : null,
           rateLimitType: info.rateLimitType || null,
           utilization: info.utilization || null,
-          isUsingOverage: info.isUsingOverage || false,
+          isUsingOverage: info.isUsingOverage === true || info.overageInUse === true,
+          overageEnabled: typeof info.overageEnabled === "boolean" ? info.overageEnabled : null,
+          overageStatus: info.overageStatus || null,
+          overageResetsAt: info.overageResetsAt ? info.overageResetsAt * 1000 : null,
+          overageDisabledReason: info.overageDisabledReason || null,
         });
         // Track rejection for auto-continue / scheduled message support
         if (info.status === "rejected" && info.resetsAt) {

package/lib/sdk-quota-snapshot.js

@@ -0,0 +1,37 @@
+function recordQuotaSnapshot(session, info, sendAndRecord) {
+  var message = {
+    type: "rate_limit_usage",
+    sessionId: session.localId,
+    vendor: session.vendor,
+    source: "account_snapshot",
+    limitId: info.limitId,
+    quotaWindows: info.windows.map(function (window) {
+      return Object.assign({}, window, { resetsAt: window.resetsAt ? window.resetsAt * 1000 : null });
+    }),
+  };
+  var snapshots = session._quotaSnapshots || (session._quotaSnapshots = Object.create(null));
+  var key = JSON.stringify([session.ownerId, session.vendor, info.limitId]);
+  var serialized = JSON.stringify(message);
+  if (snapshots[key] === serialized) return;
+  snapshots[key] = serialized;
+  sendAndRecord(session, message);
+}
+
+function attachQuotaSnapshots(sm) {
+  if (typeof sm.addOnSessionViewed !== "function") return;
+  sm.addOnSessionViewed(function (session, ws, send) {
+    if (session.vendor !== "codex") return;
+    var seen = Object.create(null);
+    var history = session.history || [];
+    // A deduplicated snapshot may precede the initial page of chat history.
+    for (var i = history.length - 1; i >= 0; i--) {
+      var entry = history[i];
+      if (entry.type !== "rate_limit_usage" || entry.source !== "account_snapshot" || entry.vendor !== session.vendor) continue;
+      if (seen[entry.limitId]) continue;
+      seen[entry.limitId] = true;
+      send(Object.assign({}, entry, { sessionId: session.localId }));
+    }
+  });
+}
+
+module.exports = { recordQuotaSnapshot: recordQuotaSnapshot, attachQuotaSnapshots: attachQuotaSnapshots };

package/lib/server-appearance-settings.js

@@ -0,0 +1,71 @@
+var fs = require('fs');
+var path = require('path');
+
+function attachAppearanceSettings(ctx) {
+  var defaultPath = path.join(ctx.CONFIG_DIR, 'appearance-preferences.json');
+  function reply(res, code, data) {
+    res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(data));
+  }
+  function identity(req) {
+    if (!ctx.isRequestAuthed(req)) return null;
+    if (!ctx.users.isMultiUser()) return { id: 'default' };
+    return ctx.getMultiUserFromReq(req);
+  }
+  function read(user) {
+    var saved;
+    if (ctx.users.isMultiUser()) saved = user.appearancePreferences;
+    else {
+      try { saved = JSON.parse(fs.readFileSync(defaultPath, 'utf8')); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+    }
+    return Object.assign({ theme: saved && saved.theme || null, mode: saved && saved.mode || null, configured: !!saved }, saved && saved.lightTheme ? { lightTheme: saved.lightTheme } : {}, saved && saved.darkTheme ? { darkTheme: saved.darkTheme } : {});
+  }
+  function save(user, values) {
+    if (ctx.users.isMultiUser()) {
+      var data = ctx.users.loadUsers();
+      var current = data.users.find(function (entry) { return entry.id === user.id; });
+      if (!current) throw new Error('Account no longer available.');
+      current.appearancePreferences = values;
+      ctx.users.saveUsers(data);
+    } else {
+      fs.mkdirSync(ctx.CONFIG_DIR, { recursive: true });
+      fs.writeFileSync(defaultPath + '.tmp', JSON.stringify(values), { mode: 0o600 });
+      fs.renameSync(defaultPath + '.tmp', defaultPath);
+    }
+  }
+  function handleRequest(req, res, url) {
+    if (url !== '/api/user/appearance') return false;
+    var user = identity(req);
+    if (!user) { reply(res, 401, { error: 'Sign in to manage appearance.' }); return true; }
+    if (req.method === 'GET') {
+      try { reply(res, 200, read(user)); } catch (error) { reply(res, 500, { error: 'Could not read appearance preferences.' }); }
+      return true;
+    }
+    if (req.method !== 'PUT') { reply(res, 405, { error: 'Method not allowed.' }); return true; }
+    if (req.headers['x-clay-settings'] !== '1' || (req.headers['sec-fetch-site'] && ['same-origin', 'none'].indexOf(req.headers['sec-fetch-site']) < 0)) {
+      reply(res, 403, { error: 'Save preferences from Clay.' }); return true;
+    }
+    var body = ''; var tooLarge = false;
+    req.setEncoding('utf8');
+    req.on('data', function (chunk) { body += chunk; if (body.length > 4096 && !tooLarge) { tooLarge = true; reply(res, 413, { error: 'Request too large.' }); } });
+    req.on('end', function () {
+      if (tooLarge) return;
+      user = identity(req);
+      if (!user) { reply(res, 401, { error: 'Sign in again.' }); return; }
+      var values;
+      try { values = JSON.parse(body); } catch (error) { reply(res, 400, { error: 'Invalid JSON.' }); return; }
+      if (!values || (values.theme !== null && (typeof values.theme !== 'string' || !/^[a-zA-Z0-9_-]{1,120}$/.test(values.theme))) || [null, 'light', 'dark'].indexOf(values.mode) < 0) { reply(res, 400, { error: 'Invalid appearance preference.' }); return; }
+      if (['lightTheme', 'darkTheme'].some(function (field) { return values[field] !== undefined && (typeof values[field] !== 'string' || !/^[a-zA-Z0-9_-]{1,120}$/.test(values[field])); })) { reply(res, 400, { error: 'Invalid theme pair.' }); return; }
+      var previous;
+      try { previous = read(user); } catch (error) { reply(res, 500, { error: 'Could not read appearance preferences.' }); return; }
+      values = Object.assign({}, previous.lightTheme ? { lightTheme: previous.lightTheme } : {}, previous.darkTheme ? { darkTheme: previous.darkTheme } : {}, values);
+      values = Object.assign({ theme: values.theme, mode: values.mode }, values.lightTheme ? { lightTheme: values.lightTheme } : {}, values.darkTheme ? { darkTheme: values.darkTheme } : {});
+      try { save(user, values); reply(res, 200, values); }
+      catch (error) { reply(res, 500, { error: 'Could not save appearance preferences. Your draft is retained.' }); }
+    });
+    return true;
+  }
+  return { handleRequest: handleRequest };
+}
+module.exports = { attachAppearanceSettings: attachAppearanceSettings };

package/lib/server-linear.js

@@ -10,39 +10,45 @@ function attachLinear(ctx) {
   }
   function json(res, status, body) { res.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' }); res.end(JSON.stringify(body)); }
   function handleRequest(req, res, url) {
-    if (url !== '/api/linear/connection') return false;
+    var match = /^\/api\/linear\/connections(?:\/([a-zA-Z0-9_-]{1,64}))?$/.exec(url);
+    if (url !== '/api/linear/connection' && !match) return false;
+    var connectionId = match && match[1];
+    if (match && !connectionId && req.method !== 'GET') { json(res, 405, { error: 'Method not allowed.' }); return true; }
     var id = owner(req);
     if (!id) { json(res, 401, { error: 'Sign in to connect Linear.' }); return true; }
     var origin = req.headers.origin;
     try { if (req.headers['sec-fetch-site'] === 'cross-site' || (origin && new URL(origin).host !== req.headers.host)) throw new Error(); }
     catch (error) { json(res, 403, { error: 'Invalid request origin.' }); return true; }
     if (req.method === 'GET') {
-      try { json(res, 200, storage.view(id)); } catch (error) { json(res, 500, { error: 'Could not read Linear connection.' }); }
+      try { json(res, 200, match && !connectionId ? { connections: storage.list(id) } : storage.view(id, connectionId)); } catch (error) { json(res, 500, { error: 'Could not read Linear connection.' }); }
       return true;
     }
     if (req.method !== 'PUT' && req.method !== 'DELETE') { json(res, 405, { error: 'Method not allowed.' }); return true; }
     // A disconnect or newer save invalidates an older validation in flight.
-    var operation = {}; pending.set(id, operation);
+    var operation = {}, pendingId = id + ':' + (connectionId || 'default'); pending.set(pendingId, operation);
     var chunks = [], size = 0;
     req.on('data', function (chunk) { size += chunk.length; if (size <= 8192) chunks.push(chunk); });
     req.on('end', async function () {
       try {
         if (size > 8192) throw new Error('Request is too large.');
-        var token = null, workspace = null;
+        var token = null, workspace = null, name;
         if (req.method === 'PUT') {
           var body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+          name = body.name;
+          if (match && (typeof name !== 'string' || !name.trim() || name.trim().length > 80)) throw new Error('Invalid connection name.');
+          if (match && !body.key) body.key = storage.key(id, connectionId);
           if (typeof body.key !== 'string' || !body.key.trim() || body.key.length > 4096 || /[\r\n]/.test(body.key)) throw new Error('Enter a valid Linear API key.');
           token = body.key.trim();
           var data = await (ctx.query || api.query)(token, 'query ClayConnection { organization { id name urlKey } }');
           if (!data.organization || !data.organization.id) throw new Error('Linear workspace is unavailable.');
           workspace = { id: data.organization.id, name: data.organization.name, slug: data.organization.urlKey };
         }
-        if (pending.get(id) !== operation || owner(req) !== id || res.destroyed) throw new Error('Connection changed. Please try again.');
-        json(res, 200, storage.save(id, token, workspace));
+        if (pending.get(pendingId) !== operation || owner(req) !== id || res.destroyed) throw new Error('Connection changed. Please try again.');
+        json(res, 200, storage.save(id, token, workspace, connectionId, name));
       } catch (error) { if (!res.destroyed) json(res, 400, { error: 'Could not update Linear connection. Check your API key and try again.' }); }
-      finally { if (pending.get(id) === operation) pending.delete(id); }
+      finally { if (pending.get(pendingId) === operation) pending.delete(pendingId); }
     });
-    req.on('error', function () { if (pending.get(id) === operation) pending.delete(id); });
+    req.on('error', function () { if (pending.get(pendingId) === operation) pending.delete(pendingId); });
     return true;
   }
   return { handleRequest: handleRequest, storage: storage };

package/lib/server-notification-settings.js

@@ -0,0 +1,67 @@
+var fs = require('fs');
+var path = require('path');
+
+function attachNotificationSettings(ctx) {
+  var defaultPath = path.join(ctx.CONFIG_DIR, 'notification-preferences.json');
+  function reply(res, code, data) {
+    res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(data));
+  }
+  function identity(req) {
+    if (!ctx.isRequestAuthed(req)) return null;
+    if (!ctx.users.isMultiUser()) return { id: 'default' };
+    return ctx.getMultiUserFromReq(req);
+  }
+  function read(user) {
+    var saved;
+    if (ctx.users.isMultiUser()) saved = user.notificationPreferences;
+    else {
+      try { saved = JSON.parse(fs.readFileSync(defaultPath, 'utf8')); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+    }
+    return { alert: !saved || saved.alert !== false, sound: !saved || saved.sound !== false, configured: !!saved };
+  }
+  function save(user, values) {
+    if (ctx.users.isMultiUser()) {
+      var data = ctx.users.loadUsers();
+      var current = data.users.find(function (entry) { return entry.id === user.id; });
+      if (!current) throw new Error('Account no longer available.');
+      current.notificationPreferences = values;
+      ctx.users.saveUsers(data);
+    } else {
+      fs.mkdirSync(ctx.CONFIG_DIR, { recursive: true });
+      fs.writeFileSync(defaultPath + '.tmp', JSON.stringify(values), { mode: 0o600 });
+      fs.renameSync(defaultPath + '.tmp', defaultPath);
+    }
+  }
+  function handleRequest(req, res, url) {
+    if (url !== '/api/user/notifications') return false;
+    var user = identity(req);
+    if (!user) { reply(res, 401, { error: 'Sign in to manage notifications.' }); return true; }
+    if (req.method === 'GET') {
+      try { reply(res, 200, read(user)); } catch (error) { reply(res, 500, { error: 'Could not read notification preferences.' }); }
+      return true;
+    }
+    if (req.method !== 'PUT') { reply(res, 405, { error: 'Method not allowed.' }); return true; }
+    if (req.headers['x-clay-settings'] !== '1' || (req.headers['sec-fetch-site'] && ['same-origin', 'none'].indexOf(req.headers['sec-fetch-site']) < 0)) {
+      reply(res, 403, { error: 'Save preferences from Clay.' }); return true;
+    }
+    var body = ''; var tooLarge = false;
+    req.setEncoding('utf8');
+    req.on('data', function (chunk) { body += chunk; if (body.length > 4096 && !tooLarge) { tooLarge = true; reply(res, 413, { error: 'Request too large.' }); } });
+    req.on('end', function () {
+      if (tooLarge) return;
+      user = identity(req);
+      if (!user) { reply(res, 401, { error: 'Sign in again.' }); return; }
+      var values;
+      try { values = JSON.parse(body); } catch (error) { reply(res, 400, { error: 'Invalid JSON.' }); return; }
+      if (!values || typeof values.alert !== 'boolean' || typeof values.sound !== 'boolean') { reply(res, 400, { error: 'Alert and sound must be booleans.' }); return; }
+      values = { alert: values.alert, sound: values.sound };
+      try { save(user, values); reply(res, 200, values); }
+      catch (error) { reply(res, 500, { error: 'Could not save notification preferences. Your draft is retained.' }); }
+    });
+    return true;
+  }
+  return { handleRequest: handleRequest };
+}
+module.exports = { attachNotificationSettings: attachNotificationSettings };

package/lib/server-settings.js

@@ -12,9 +12,13 @@ function attachSettings(ctx) {
   var CONFIG_DIR = ctx.CONFIG_DIR;
 
   var profilePath = path.join(CONFIG_DIR, "profile.json");
+  var appearanceSettings = require('./server-appearance-settings').attachAppearanceSettings(ctx);
+  var notificationSettings = require('./server-notification-settings').attachNotificationSettings(ctx);
   var experimentalSettings = attachExperimentalSettings(ctx);
 
   function handleRequest(req, res, fullUrl) {
+    if (appearanceSettings.handleRequest(req, res, fullUrl)) return true;
+    if (notificationSettings.handleRequest(req, res, fullUrl)) return true;
     if (experimentalSettings.handleRequest(req, res, fullUrl)) return true;
     // Render historical avatar styles locally so profile seeds never leave Clay.
     if (req.method === "GET" && fullUrl === "/api/generated-avatar") {

package/lib/server-storage.js

@@ -0,0 +1,56 @@
+var scanStorage = require('./storage-usage').scanStorage;
+
+function attachStorage(ctx) {
+  var pending = null;
+  var cached = null;
+  var progress = null;
+  var expires = 0;
+  var failed = false;
+  function reply(res, status, data) {
+    res.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(data));
+  }
+  function authorized(req, res) {
+    if (!ctx.isRequestAuthed(req)) { reply(res, 401, { error: 'Authentication required.' }); return false; }
+    var user = ctx.getMultiUserFromReq(req);
+    if (ctx.users.isMultiUser() && (!user || user.role !== 'admin')) {
+      reply(res, 403, { error: 'Only server administrators can view disk usage.' }); return false;
+    }
+    return true;
+  }
+  function handleRequest(req, res, url) {
+    if (url !== '/api/server/storage') return false;
+    if (!authorized(req, res)) return true;
+    if (req.method !== 'GET') { reply(res, 405, { error: 'Method not allowed.' }); return true; }
+    if (failed && Date.now() < expires) { reply(res, 500, { error: 'Disk usage could not be measured. Try again in a few seconds.' }); return true; }
+    if (cached && Date.now() < expires) { reply(res, 200, cached); return true; }
+    if (!pending) {
+      progress = null; failed = false;
+      var users = ctx.users.getAllUsers();
+      var projects = ctx.getProjects ? ctx.getProjects() : [];
+      if (!ctx.users.isMultiUser() && users.length <= 1) {
+        if (!users.length) users = [{ id: 'local', username: 'Local user' }];
+        projects = projects.map(function (project) { return Object.assign({}, project, { projectOwnerId: project.projectOwnerId || users[0].id }); });
+      }
+      pending = (ctx.scanStorage || scanStorage)({ configDir: ctx.configDir, platform: process.platform,
+        attribution: ctx.osUsers && ctx.users.isMultiUser() && process.platform === 'linux' ? 'filesystem' : 'project',
+        users: users, projects: projects, onProgress: function (data) { progress = data; },
+        projectPaths: ctx.getProjectPaths ? ctx.getProjectPaths() : [] }).then(function (result) {
+        cached = result; expires = Date.now() + 30000; return result;
+      }).catch(function (error) { failed = true; expires = Date.now() + 5000; throw error; }).finally(function () { pending = null; });
+    }
+    var timer;
+    Promise.race([pending, new Promise(function (resolve) {
+      timer = setTimeout(function () { resolve(progress || { scanning: true }); }, 750);
+    })]).then(function (result) {
+      clearTimeout(timer);
+      if (!res.destroyed && authorized(req, res)) reply(res, result.scanning ? 202 : 200, result);
+    }).catch(function () {
+      clearTimeout(timer);
+      if (!res.destroyed) reply(res, 500, { error: 'Disk usage could not be measured. Try refreshing.' });
+    });
+    return true;
+  }
+  return { handleRequest: handleRequest };
+}
+module.exports = { attachStorage: attachStorage };

package/lib/server.js

@@ -188,7 +188,6 @@ function createServer(opts) {
   var onGetDaemonConfig = opts.onGetDaemonConfig || null;
   var onSetPin = opts.onSetPin || null;
   var onSetKeepAwake = opts.onSetKeepAwake || null;
-  var onSetInheritGroups = opts.onSetInheritGroups || null;
   var onSetImageRetention = opts.onSetImageRetention || null;
   var onShutdown = opts.onShutdown || null;
   var onRestart = opts.onRestart || null;
@@ -473,9 +472,14 @@ function createServer(opts) {
     users: users, getMultiUserFromReq: getMultiUserFromReq,
     isRequestAuthed: isRequestAuthed, opts: opts, getConfiguredOrigins: getConfiguredOrigins,
   });
+  var storageSettings = require('./server-storage').attachStorage({
+    users: users, getMultiUserFromReq: getMultiUserFromReq, isRequestAuthed: isRequestAuthed,
+    configDir: CONFIG_DIR, osUsers: osUsers, getProjects: getProjects,
+  });
   var logRejectedOrigin = createOriginRejectionLogger({ log: opts.onOriginRejectedLog });
 
   var settings = serverSettings.attachSettings({
+    isRequestAuthed: isRequestAuthed,
     users: users,
     mates: mates,
     getMultiUserFromReq: getMultiUserFromReq,
@@ -815,6 +819,7 @@ function createServer(opts) {
     if (linear.handleRequest(req, res, fullUrl)) return;
     if (speech.handleRequest(req, res, fullUrl)) return;
     if (networkSettings.handleRequest(req, res, fullUrl)) return;
+    if (storageSettings.handleRequest(req, res, fullUrl)) return;
     if (settings.handleRequest(req, res, fullUrl)) return;
 
     // --- Admin API endpoints (multi-user mode only) ---
@@ -1516,10 +1521,13 @@ function createServer(opts) {
       },
       onGetProjectMcpServers: onGetProjectMcpServers,
       onSetProjectMcpServers: onSetProjectMcpServers,
+      onGetSharedEnv: opts.onGetSharedEnv,
+      onSetSharedEnv: opts.onSetSharedEnv,
+      onGetProjectEnv: opts.onGetProjectEnv,
+      onSetProjectEnv: opts.onSetProjectEnv,
       onGetDaemonConfig: onGetDaemonConfig,
       onSetPin: onSetPin,
       onSetKeepAwake: onSetKeepAwake,
-      onSetInheritGroups: onSetInheritGroups,
       onSetImageRetention: onSetImageRetention,
       onSetUpdateChannel: onSetUpdateChannel,
       updateChannel: onGetDaemonConfig ? (onGetDaemonConfig().updateChannel || "stable") : "stable",

package/lib/sessions.js

@@ -444,9 +444,8 @@ function createSessionManager(opts) {
   // Adopt orphaned CLI sessions from ~/.claude/projects/<encoded-cwd>/ as
   // Clay session records. After this runs the sidebar shows a single
   // unified list of sessions regardless of whether they were born inside
-  // Clay or via the `claude` CLI directly. The user's claudeOpenMode pref
-  // decides how each click renders (TUI respawn vs GUI hydration) - both
-  // paths already exist for born-TUI sessions.
+  // Clay or via the `claude` CLI directly. Idle CLI sessions hydrate into
+  // Clay chat; already-running terminal runtimes keep their presentation.
   //
   // Adopted records are saved with mode='tui' because they originated in
   // the CLI, not via the SDK. The cross-mode click logic in

package/lib/startup-projects.js

@@ -0,0 +1,40 @@
+// Saved project records are authoritative; filesystem availability only controls
+// runtime registration. Recent-project entries must never restore access grants.
+function buildStartupProjects(config, recent, options) {
+  var projects = [];
+  var paths = new Set();
+  var slugs = [];
+  var removed = new Set((config && config.removedProjects || []).map(function (p) { return p.path; }));
+  (config && config.projects || []).forEach(function (p) {
+    if (paths.has(p.path)) return;
+    projects.push(Object.assign({}, p));
+    paths.add(p.path);
+    slugs.push(p.slug);
+  });
+
+  function add(project) {
+    if (paths.has(project.path) || removed.has(project.path)) return;
+    if (!options.existsSync(project.path)) return;
+    var slug = options.generateSlug(project.path, slugs);
+    projects.push({
+      path: project.path,
+      slug: slug,
+      title: project.title || undefined,
+      icon: project.icon || undefined,
+      addedAt: project.addedAt || Date.now(),
+    });
+    paths.add(project.path);
+    slugs.push(slug);
+  }
+
+  if (options.addCwd) {
+    var cwdRecent = (recent || []).find(function (p) { return p.path === options.cwd; });
+    add(cwdRecent || { path: options.cwd });
+  }
+  (recent || []).forEach(function (p) {
+    if (p.path !== options.cwd) add(p);
+  });
+  return projects;
+}
+
+module.exports = { buildStartupProjects: buildStartupProjects };

package/lib/storage-usage.js

@@ -0,0 +1,127 @@
+var fs = require('node:fs/promises');
+var path = require('node:path');
+var execFile = require('node:child_process').execFile;
+
+function resolveIdentity(username) {
+  return new Promise(function (resolve) {
+    if (!/^[a-z_][a-z0-9_-]*[$]?$/.test(username || '')) return resolve(null);
+    execFile('getent', ['passwd', username], { timeout: 3000, maxBuffer: 8192 }, function (error, output) {
+      if (error) return resolve(null);
+      var parts = output.trim().split(':');
+      var uid = Number(parts[2]);
+      resolve(parts.length >= 7 && /^\d+$/.test(parts[2]) && Number.isInteger(uid) && uid >= 0 && path.isAbsolute(parts[5]) ? { uid: uid, home: parts[5] } : null);
+    });
+  });
+}
+
+// Read metadata only. Shared paths and hard links count once across all roots.
+async function scanStorage(options) {
+  var started = Date.now();
+  var deadline = options.maxMs ? started + options.maxMs : Infinity;
+  var maxEntries = options.maxEntries || Infinity;
+  var users = options.users || [];
+  var projectMode = options.attribution === "project";
+  var projects = options.projects || [];
+  var identities = await Promise.all(users.map(function (user) {
+    return !projectMode && options.platform === 'linux' && user.linuxUser ? (options.resolveIdentity || resolveIdentity)(user.linuxUser) : null;
+  }));
+  var rows = users.map(function (user, index) {
+    return { id: user.id, name: user.displayName || user.username, linuxUser: user.linuxUser || null, mapped: projectMode || !!identities[index], projects: 0, bytes: 0, files: 0 };
+  });
+  var owners = new Map();
+  identities.forEach(function (identity, index) {
+    if (!identity) return;
+    // A reused OS identity cannot be split accurately between Clay accounts.
+    owners.set(identity.uid, owners.has(identity.uid) ? null : rows[index]);
+  });
+  identities.forEach(function (identity, index) {
+    if (identity && !owners.get(identity.uid)) rows[index].mapped = false;
+  });
+  var projectRoots = new Map();
+  var projectErrors = 0;
+  for (var project of projects) {
+    try {
+      var projectPath = await fs.realpath(project.path);
+      var row = rows.find(function (item) { return item.id === project.projectOwnerId; }) || null;
+      if (row) row.projects++;
+      if (projectRoots.has(projectPath) && projectRoots.get(projectPath) !== row) row = null;
+      projectRoots.set(projectPath, row);
+    } catch (error) { projectErrors++; }
+  }
+  var orderedProjects = Array.from(projectRoots.keys()).sort(function (a, b) { return b.length - a.length; });
+  function projectOwner(filePath) {
+    var root = orderedProjects.find(function (candidate) { return filePath === candidate || filePath.indexOf(candidate + path.sep) === 0; });
+    return root ? projectRoots.get(root) : null;
+  }
+  var roots = orderedProjects.concat(options.projectPaths || []);
+  identities.forEach(function (identity) { if (identity) roots.push(identity.home); });
+  roots.push(options.configDir);
+  var report = { attribution: projectMode ? "project" : "filesystem", users: rows, totalBytes: 0, totalFiles: 0, unattributedBytes: 0, unattributedFiles: 0,
+    partial: false, errors: projectErrors + users.filter(function (user, index) { return !projectMode && options.platform === 'linux' && user.linuxUser && !identities[index]; }).length, skippedLinks: 0, skippedMounts: 0, scannedEntries: 0, roots: 0, platform: options.platform };
+  var lastProgress = 0;
+  function progress() {
+    if (!options.onProgress || Date.now() - lastProgress < 500) return;
+    lastProgress = Date.now();
+    options.onProgress(Object.assign({}, report, { scanning: true, checkedAt: new Date().toISOString(),
+      users: rows.map(function (row) { return Object.assign({}, row); }) }));
+  }
+  progress();
+  var seen = new Map();
+  var rootPaths = new Set();
+  for (var root of roots) {
+    if (typeof root !== 'string' || !path.isAbsolute(root)) { report.errors++; continue; }
+    try {
+      root = await fs.realpath(root);
+      // Never turn a misconfigured home/project into a whole-host scan.
+      if (root === path.parse(root).root) { report.errors++; continue; }
+      if (rootPaths.has(root)) continue;
+      rootPaths.add(root);
+      var rootStat = await fs.lstat(root);
+      report.roots++;
+      await walk(root, rootStat.dev);
+    } catch (error) { report.errors++; }
+    if (report.partial) break;
+  }
+  report.partial = report.partial || report.errors > 0 || report.skippedMounts > 0;
+  report.scanning = false;
+  report.checkedAt = new Date().toISOString();
+  return report;
+
+  async function walk(filePath, device) {
+    if (Date.now() >= deadline || report.scannedEntries >= maxEntries) { report.partial = true; return; }
+    var stat;
+    try { stat = await fs.lstat(filePath); } catch (error) { report.errors++; return; }
+    if (stat.isSymbolicLink()) { report.skippedLinks++; return; }
+    if (stat.dev !== device) { report.skippedMounts++; return; }
+    var key = stat.dev + ':' + stat.ino;
+    var owner = projectMode ? projectOwner(filePath) : owners.get(stat.uid);
+    if (seen.has(key)) {
+      var previous = seen.get(key);
+      if (projectMode && stat.isFile() && previous.owner && previous.owner !== owner) {
+        previous.owner.bytes -= previous.bytes; previous.owner.files--;
+        report.unattributedBytes += previous.bytes; report.unattributedFiles++;
+        previous.owner = null;
+      }
+      return;
+    }
+    report.scannedEntries++;
+    if (!stat.isDirectory() && !stat.isFile()) return;
+    var bytes = typeof stat.blocks === 'number' ? stat.blocks * 512 : stat.size;
+    // Only directories and multiply-linked files need identity deduplication.
+    if (stat.isDirectory() || stat.nlink > 1) seen.set(key, { owner: owner, bytes: bytes });
+    report.totalBytes += bytes;
+    if (stat.isFile()) report.totalFiles++;
+    if (owner) { owner.bytes += bytes; if (stat.isFile()) owner.files++; }
+    else { report.unattributedBytes += bytes; if (stat.isFile()) report.unattributedFiles++; }
+    progress();
+    if (!stat.isDirectory()) return;
+    try {
+      var directory = await fs.opendir(filePath);
+      for await (var entry of directory) {
+        await walk(path.join(filePath, entry.name), device);
+        if (report.partial) break;
+      }
+    } catch (error) { report.errors++; }
+  }
+}
+module.exports = { scanStorage: scanStorage };