clay-server 5.2.0-beta.1 → 5.2.0-beta.11

package/lib/project-session-runtime-actions.js

@@ -0,0 +1,64 @@
+// Legacy terminal recovery only. New terminal presentation has been retired.
+function attachSessionRuntimeActions(ctx) {
+  function inspect(session) {
+    return JSON.stringify([session.terminalId, session.runtimeTerminalId, session.tuiSuspended, [session.terminalId, session.runtimeTerminalId].map(function (id) { return typeof id === "number" && ctx.tm ? ctx.tm.identity(id) : null; })]);
+  }
+  async function change(session, mode, revalidate) {
+    revalidate();
+    if (mode !== "gui") throw new Error("New terminal presentation has been removed. Only return to GUI chat is supported; provider threads cannot migrate across vendors.");
+    if (session.isProcessing || session._queryStarting || session.queryInstance || Object.keys(session.pendingPermissions || {}).length || Object.keys(session.pendingAskUser || {}).length) throw new Error("Runtime changes require an idle session without an active provider handle or pending approvals.");
+    if (session.taskStopRequested || session._pendingMessageDrainPaused || ctx.isPendingQueuePaused && ctx.isPendingQueuePaused(session)) throw new Error("A stopped session cannot be resumed by a runtime change.");
+    var vendor = session.vendor || ctx.sm.defaultVendor || "claude";
+    var ids = Array.from(new Set([session.terminalId, session.runtimeTerminalId].filter(function (id) { return typeof id === "number"; })));
+    if (!ids.length && (session.runtimeMode || session.mode || "gui") === "gui") return { status: "completed", runtimeMode: "gui", runtimeEffect: "none", threadPreserved: true };
+    var lifecycle = require("./yoke/provider-contract").resolve(vendor);
+    if (typeof lifecycle.supportsLegacyGuiResume !== "function" || !lifecycle.supportsLegacyGuiResume(session)) throw new Error("This provider cannot return a legacy terminal thread to GUI chat.");
+    var closed = 0, persisted = false;
+    var fields = ['terminalId', 'runtimeTerminalId'];
+    var originalFields = fields.map(function (field) { return session[field]; });
+    var targets = ids.map(function (id) { return { id: id, identity: ctx.tm && ctx.tm.identity(id), closed: false }; });
+    var suspended = session.tuiSuspended;
+    function exactTerminals() {
+      if (session.tuiSuspended !== suspended) throw new Error("Terminal presentation changed during shutdown.");
+      targets.forEach(function (target) {
+        var current = ctx.tm && ctx.tm.identity(target.id);
+        if (!target.identity || (target.closed ? current !== null : current !== target.identity)) throw new Error("A terminal runtime was replaced during shutdown.");
+      });
+      fields.forEach(function (field, index) {
+        var original = originalFields[index], current = session[field];
+        if (current === original || current == null && original == null) return;
+        var target = targets.find(function (item) { return item.id === original; });
+        if (current == null && target && target.closed) return;
+        throw new Error("A new or replacement terminal was attached during shutdown.");
+      });
+    }
+    try {
+      for (var target of targets) {
+        revalidate();
+        exactTerminals();
+        if (!ctx.tm || typeof ctx.tm.closeAndWait !== "function") throw new Error("Completion-aware terminal shutdown is unavailable.");
+        ctx.tm.markReclaimed(target.id);
+        await ctx.tm.closeAndWait(target.id); target.closed = true; closed++;
+        revalidate();
+        exactTerminals();
+      }
+      revalidate();
+      exactTerminals();
+      session.terminalId = null; session.runtimeTerminalId = null;
+      ctx.prepareGui(session, { deferSave: true });
+      exactTerminals();
+      session.runtimeMode = "gui"; session.tuiSuspended = false;
+      if (ctx.sm.saveSessionFile(session) !== true) throw new Error("GUI presentation could not be saved after terminal shutdown.");
+      persisted = true;
+      ctx.sm.broadcastSessionList();
+      ctx.publishGui(session);
+      return { status: "completed", runtimeMode: "gui", runtimeEffect: closed ? "terminal_closed" : "none", persisted: true, threadPreserved: true, executionStarted: false };
+    } catch (error) {
+      error.productControlResult = { status: "failed", outcome: "partial", persisted: persisted, runtimeEffect: closed ? "terminal_closed" : "closure_unconfirmed", retrySafe: false, executionStarted: false };
+      throw error;
+    }
+  }
+  function inspectLifecycle() { return ctx.tm.list().map(function (terminal) { return Object.assign({}, terminal, { identity: ctx.tm.identity(terminal.id) }); }); }
+  return { change: change, inspect: inspect, inspectLifecycle: inspectLifecycle };
+}
+module.exports = { attachSessionRuntimeActions: attachSessionRuntimeActions };

package/lib/project-session-spawn.js

@@ -1,6 +1,5 @@
 var yoke = require("./yoke");
 var sessionSpawnMcp = require("./session-spawn-mcp-server");
-var cliSessions = require("./cli-sessions");
 var os = require("os");
 var osUsers = require("./os-users");
 
@@ -161,7 +160,7 @@ function attachSessionSpawn(ctx) {
   var sm = ctx.sm;
   var queue = createSpawnQueue(SPAWN_CONCURRENCY);
   var adapters = ctx.adapters || {};
-  var readCliSessionHistory = ctx.readCliSessionHistory || cliSessions.readCliSessionHistory;
+  var readCliSessionHistory = ctx.readCliSessionHistory || function(home, project, sessionId, provider) { return require("./yoke/session-history").read(provider || "claude", home, project, sessionId); };
 
   function resolveSessionHome(session) {
     var linuxUser = ctx.getLinuxUserForSession(session);
@@ -283,7 +282,7 @@ function attachSessionSpawn(ctx) {
               forkHistory = parent.history.slice();
             } else {
               forkHistory = await readCliSessionHistory(
-                resolveSessionHome(parent), ctx.cwd, forkResult.sessionId
+                resolveSessionHome(parent), ctx.cwd, forkResult.sessionId, parent.vendor
               );
             }
           } catch (e) {

package/lib/project-session-vendor.js

@@ -0,0 +1,55 @@
+var yoke = require('./yoke');
+function attachSessionVendor(ctx) {
+  function verifyIdentity(session, vendor) {
+    if (!ctx.osUsers) return;
+    var info = yoke.getVendorInfo(vendor), linuxUser = ctx.getLinuxUserForSession(session);
+    if (!info || !info.osUserIsolation || !linuxUser) throw new Error('The provider requires an authorized mapped OS identity.');
+    var identity = require('./os-users').resolveOsUserInfo(linuxUser);
+    if (!Number.isInteger(identity.uid) || identity.uid < 0 || !Number.isInteger(identity.gid) || identity.gid < 0) throw new Error('The mapped OS identity is unavailable.');
+  }
+  function setVendor(session, vendor, revalidate) {
+    if (!session || ctx.sm.sessions.get(session.localId) !== session) throw new Error('The Driver was deleted or replaced.');
+    if (revalidate) revalidate();
+    if (!(ctx.adapters || {})[vendor] || (ctx.sm.availableVendors || []).indexOf(vendor) < 0) throw new Error('This provider is unavailable in the project runtime.');
+    verifyIdentity(session, vendor);
+    if (session.cliSessionId || session.queryInstance || session.isProcessing || session._queryStarting || (session.history || []).length || (session.runtimeMode || session.mode || 'gui') !== 'gui') throw new Error('Provider selection requires a fresh idle GUI Driver without a provider thread or transcript.');
+    if (session.taskStopRequested || session._pendingMessageDrainPaused || ctx.isPendingQueuePaused && ctx.isPendingQueuePaused(session)) throw new Error('A stopped Driver requires an explicit separate resume action.');
+    var previous = { vendor: session.vendor, model: session.model, effort: session.effort, permissionMode: session.permissionMode, effectivePermissionMode: session.effectivePermissionMode };
+    session.vendor = vendor;
+    session.model = null;
+    session.effort = yoke.clampEffort(vendor, session.effort) || null;
+    var modes = yoke.sessionTools.contract(ctx.adapters[vendor]).permissionModes;
+    if (session.permissionMode === 'auto' && (!Array.isArray(modes) || modes.indexOf('auto') < 0)) session.permissionMode = 'default';
+    session.effectivePermissionMode = null;
+    try { if (ctx.sm.saveSessionFile(session) !== true) throw new Error('Could not persist the provider selection.'); }
+    catch (error) { Object.assign(session, previous); throw error; }
+    try {
+      ctx.sm.broadcastSessionList();
+      ctx.sm.sendToSession(session, { type: 'model_info', vendor: vendor, sessionId: session.localId, model: '', models: (ctx.sm.modelsByVendor || {})[vendor] || [], availableVendors: ctx.sm.availableVendors || [], installedVendors: ctx.sm.installedVendors || [] });
+      ctx.sm.sendToSession(session, { type: 'config_state', vendor: vendor, sessionId: session.localId, model: '', effort: session.effort, mode: session.permissionMode || ctx.sm.currentPermissionMode || 'default' });
+    } catch (error) { return { status: 'failed', outcome: 'partial', persisted: true, runtimeEffect: 'none', vendor: vendor, error: 'Provider selection saved, but publication failed: ' + error.message }; }
+    return { status: 'completed', persisted: true, runtimeEffect: 'none', vendor: vendor };
+  }
+  function newSession(source, vendor, revalidate) {
+    revalidate();
+    if (!(ctx.adapters || {})[vendor] || (ctx.sm.availableVendors || []).indexOf(vendor) < 0) throw new Error('This provider is unavailable in the project runtime.');
+    if (source.isProcessing || source._queryStarting || source.taskStopRequested || source._pendingMessageDrainPaused || ctx.isPendingQueuePaused && ctx.isPendingQueuePaused(source)) throw new Error('Create a replacement provider session only from an idle, unstopped Driver.');
+    verifyIdentity(source, vendor);
+    revalidate();
+    var created = ctx.sm.createSessionRaw({ ownerId: source.ownerId || null, vendor: vendor, mode: 'gui', sessionVisibility: 'private' });
+    var ref = require('./workspace-query-service').sessionRef(ctx.slug, created), persisted = false;
+    try {
+      revalidate();
+      if (ctx.sm.saveSessionFile(created) !== true) throw new Error('Could not save the new provider session.');
+      persisted = true;
+      revalidate();
+      ctx.sm.broadcastSessionList();
+      return { status: 'completed', persisted: true, newSessionRef: ref, vendor: vendor, threadMigrated: false, originalRetained: true, executionStarted: false };
+    } catch (error) {
+      error.productControlResult = { status: 'failed', outcome: 'partial', persisted: persisted, retainedInMemory: true, newSessionRef: ref, threadMigrated: false, originalRetained: true, executionStarted: false, retrySafe: false };
+      throw error;
+    }
+  }
+  return { setVendor: setVendor, newSession: newSession };
+}
+module.exports = { attachSessionVendor: attachSessionVendor };