clay-server 3.3.2-beta.3 → 3.4.0-beta.10

package/lib/sdk-bridge.js

@@ -110,6 +110,7 @@ function createSDKBridge(opts) {
   var adapters = opts.adapters || {};
   var mateDisplayName = opts.mateDisplayName || "";
   var isMate = opts.isMate || (slug.indexOf("mate-") === 0);
+  var osUsers = !!opts.osUsers;
   var dangerouslySkipPermissions = opts.dangerouslySkipPermissions || false;
   // mcpServers may be either a static object or a getter function. The
   // getter form lets callers gate individual servers at call time (e.g.
@@ -129,7 +130,7 @@ function createSDKBridge(opts) {
   var _cachedFreshAuthState = null;
   var _cachedFreshAuthAt = 0;
 
-  function getKiroMcpServers(session) {
+  function getAcpMcpServers(session) {
     if (!session) return [];
     var bridgeArgs = [
       path.join(__dirname, "yoke", "mcp-bridge-server.js"),
@@ -323,6 +324,14 @@ function createSDKBridge(opts) {
   var mergeSkills = skills.mergeSkills;
 
   // --- Message processing (extracted to sdk-message-processor.js) ---
+  function getSessionLinuxUser(session) {
+    if (!osUsers || !session) return null;
+    if (session.lastLinuxUser) return session.lastLinuxUser;
+    if (!session.ownerId) return null;
+    var owner = usersModule.findUserById(session.ownerId);
+    return owner && owner.linuxUser ? owner.linuxUser : null;
+  }
+
   // Auto-generate a session title via YOKE adapter.generateTitle().
   // Triggered by sdk-message-processor after AUTO_TITLE_TURN_THRESHOLD turns.
   function autoGenerateTitle(session) {
@@ -345,7 +354,10 @@ function createSDKBridge(opts) {
     }
     console.log("[auto-title] Calling adapter.generateTitle with " + userMessages.length + " messages for session " + session.localId);
 
-    sessionAdapter.generateTitle(userMessages, { cwd: cwd }).then(function(title) {
+    sessionAdapter.generateTitle(userMessages, {
+      cwd: cwd,
+      linuxUser: getSessionLinuxUser(session) || undefined,
+    }).then(function(title) {
       if (!title || title.length < 2) return;
       title = title.substring(0, 100);
       if (!session.titleManuallySet) {
@@ -1131,7 +1143,9 @@ function createSDKBridge(opts) {
   async function rollbackConversation(session, numTurns) {
     var sessionAdapter = getAdapterForSession(session);
     if (sessionAdapter && typeof sessionAdapter.rollbackThread === "function") {
-      await sessionAdapter.rollbackThread(session.cliSessionId, numTurns);
+      await sessionAdapter.rollbackThread(session.cliSessionId, numTurns, {
+        linuxUser: getSessionLinuxUser(session) || undefined,
+      });
     }
     // Claude: conversation rollback is handled by rewindFiles + local history trim
   }
@@ -1143,7 +1157,11 @@ function createSDKBridge(opts) {
 
   async function forkSessionUnified(session, uuid) {
     var sessionAdapter = getAdapterForSession(session);
-    var result = await sessionAdapter.forkSession(session.cliSessionId, { upToMessageId: uuid, dir: cwd });
+    var result = await sessionAdapter.forkSession(session.cliSessionId, {
+      upToMessageId: uuid,
+      dir: cwd,
+      linuxUser: getSessionLinuxUser(session) || undefined,
+    });
     if (!result || !result.sessionId) throw new Error("Fork returned no session id");
 
     // Adapters with rollbackThread (e.g. Codex) use local history copy
@@ -1471,6 +1489,7 @@ function createSDKBridge(opts) {
 
     var queryOpts = {
       cwd: cwd,
+      linuxUser: linuxUser || undefined,
       // appendSystemPrompt, NOT systemPrompt: a plain-string systemPrompt
       // REPLACES the entire Claude Code system prompt (sdk.d.ts:2096), which
       // would strip the driver session down to the two-sentence pair preset.
@@ -1525,13 +1544,20 @@ function createSDKBridge(opts) {
           sandboxMode: codexConfig.sandbox,
           webSearchMode: codexConfig.webSearch,
         },
+        ACP: {
+          mcpServers: getAcpMcpServers(session),
+        },
+        ANTIGRAVITY: {
+          dangerouslySkipPermissions: dangerouslySkipPermissions
+            || session.permissionMode === "bypassPermissions",
+        },
         KIRO: {
           engine: kiroConfig.engine,
           mode: kiroConfig.mode,
           // ACP accepts additional stdio MCP servers per session. The bridge is
           // bound to this Clay session so partner calls cannot leak across
           // concurrent Kiro sessions or users.
-          mcpServers: getKiroMcpServers(session),
+          mcpServers: getAcpMcpServers(session),
         },
       },
     };
@@ -1787,6 +1813,23 @@ function createSDKBridge(opts) {
     } catch (e) {}
     if ((codexBin && fs.existsSync(codexBin)) || tryLookup(yoke.getVendorInfo("codex").binaryName)) result.push("codex");
 
+    var subprocessVendorKeys = ["antigravity", "opencode", "kimi", "grok", "copilot", "qwen", "junie"];
+    var acpProfiles = require("./yoke/acp-agent-profiles");
+    for (var subprocessVendorIndex = 0; subprocessVendorIndex < subprocessVendorKeys.length; subprocessVendorIndex++) {
+      var subprocessVendor = subprocessVendorKeys[subprocessVendorIndex];
+      var subprocessInfo = yoke.getVendorInfo(subprocessVendor);
+      if (!linuxUser || subprocessInfo.osUserIsolation) {
+        if (subprocessVendor === "antigravity") {
+          if (tryLookup(subprocessInfo.binaryName)) result.push(subprocessVendor);
+        } else {
+          var acpProfile = acpProfiles.getAcpAgentProfile(subprocessVendor);
+          if (acpProfiles.findAcpAgentPath(acpProfile)) result.push(subprocessVendor);
+        }
+      } else {
+        console.log("[sdk-bridge] " + subprocessInfo.displayName + " hidden for OS-isolated user " + linuxUser + ": per-user spawning is not implemented");
+      }
+    }
+
     // Kiro has no per-user ACP spawn path yet. Do not advertise the daemon's
     // binary to an OS-isolated user, even if that user also has Kiro installed.
     var kiroInfo = yoke.getVendorInfo("kiro");
@@ -1816,6 +1859,13 @@ function createSDKBridge(opts) {
     var defaultVendor = adapter ? adapter.vendor : "claude";
     sm.defaultVendor = defaultVendor;
 
+    // Installation detection is independent of adapter initialization. Publish
+    // it before warmup so a new project does not render the initial empty state
+    // as if every CLI were missing while the default adapter starts up.
+    sm.installedVendors = detectInstalledVendors(linuxUser);
+    sm.availableVendors = getAvailableVendors(linuxUser);
+    sendModelInfoForVendor(defaultVendor, sm.currentModel || "");
+
     // Initialize default adapter first (provides skills, slash commands, etc.)
     if (adapter) {
       try {
@@ -1867,19 +1917,8 @@ function createSDKBridge(opts) {
     //     actually issues a query with it.
     sm.modelsByVendor = sm.modelsByVendor || {};
 
-    // Detect installed vendors per-user (binary existence check)
-    sm.installedVendors = detectInstalledVendors(linuxUser);
-    sm.availableVendors = getAvailableVendors(linuxUser);
-
-    // Send initial state to client
-    send({
-      type: "model_info",
-      model: sm.currentModel || "",
-      models: getModelsForVendor(defaultVendor),
-      vendor: defaultVendor,
-      availableVendors: sm.availableVendors,
-      installedVendors: sm.installedVendors,
-    });
+    // Send the fully initialized state to the client.
+    sendModelInfoForVendor(defaultVendor, sm.currentModel || "");
   }
 
   async function setModel(session, model) {
@@ -1993,7 +2032,7 @@ function createSDKBridge(opts) {
   // Creates a mention session that can be reused across multiple mentions
   // within a conversation flow (session continuity).
   async function createMentionSession(opts) {
-    // opts: { vendor, claudeMd, initialContext, initialMessage, onDelta, onDone, onError, onActivity }
+    // opts: { vendor, linuxUser, claudeMd, initialContext, initialMessage, onDelta, onDone, onError, onActivity }
     var abortController = new AbortController();
 
     // Current response callbacks (swapped on each pushMessage)
@@ -2013,6 +2052,7 @@ function createSDKBridge(opts) {
     try {
       handle = await mentionAdapter.createQuery({
         cwd: cwd,
+        linuxUser: opts.linuxUser || undefined,
         systemPrompt: opts.claudeMd,
         model: opts.model || undefined,
         toolServers: opts.includeMcpServers ? (mergeMcpServers(getMcpServers(), getRemoteMcpServers) || undefined) : undefined,

package/lib/sdk-message-processor.js

@@ -792,7 +792,16 @@ function attachMessageProcessor(ctx) {
       // processQueryStream can finish the turn when the iterator closes.
       var adapterErrorText = parsed.text || parsed.message || parsed.error || "Agent runtime error";
       session._lastAdapterError = adapterErrorText;
-      sendAndRecord(session, { type: "error", text: adapterErrorText });
+      var isSessionWriterConflict = /thread-store conflict|already has an active writer/i.test(adapterErrorText);
+      if (isSessionWriterConflict) {
+        sendAndRecord(session, {
+          type: "session_writer_conflict",
+          vendor: session.vendor || "codex",
+          text: "This Codex session is already open in another Clay or Codex process. Stop the other server or close the other session, then try again.",
+        });
+      } else {
+        sendAndRecord(session, { type: "error", text: adapterErrorText });
+      }
 
     } else if (parsed.yokeType === "model_refusal") {
       // Model declined the request. "fallback" => the CLI retried on another

package/lib/session-notes-mcp-server.js

@@ -2,7 +2,13 @@
 
 var buildShape = require("./session-spawn-mcp-server").buildShape;
 
-var MEMORY_CONTRACT = "The sticky-note board persists across sessions and is a user-facing artifact shared with people and Clay agents, not private agent scratch space. Default to not writing. Create a note proactively only when the user explicitly asks to remember or track something, or when all of these are true: it will remain useful after the current task and session, it is not already adequately recorded in the repository or another note, and the user would likely be glad to find it on the board a week later. Good notes capture an unresolved commitment, durable product decision, user preference, constraint, or handoff that will materially change future work. Never create a note merely because work is important, lengthy, spans agents or restarts, or might help another agent. Do not record completed work, implementation details, test results, investigation logs, transient blockers, conversation summaries, or announcements of your own activity. When uncertain, do not write. Updates are visible too: update only when durable state materially changes, and remove a note created by your session when it stops being useful instead of turning it into a completion log. Put a concise plain-text title on the first line, stay focused on one topic, and include only the context needed for future action.";
+var MEMORY_CONTRACT =
+  "The sticky-note board persists across sessions and is a user-facing artifact shared with people and Clay agents, not private agent scratch space. " +
+  "Default to not writing. Create a note proactively only when the user explicitly asks to remember or track something, or when all of these are true: it will remain useful after the current task and session, it is not already adequately recorded in the repository or another note, and the user would likely be glad to find it on the board a week later. " +
+  "Good notes capture an unresolved commitment, durable product decision, user preference, constraint, or handoff that will materially change future work. " +
+  "Important exception for deferred defects: while doing code or technical work, actively create a sticky note when you discover a concrete defect, regression risk, security issue, or data-loss risk that is outside the current session goal and will remain unfixed when the turn ends. Do not wait for the user to ask. Include the observable evidence, affected component, likely impact, and a clear next action. Check active notes first when a duplicate is plausible. Do not create defect notes for speculation, general cleanup ideas, or problems you fixed in the current session. " +
+  "Never create a note merely because work is important, lengthy, spans agents or restarts, or might help another agent. Do not record completed work, implementation details, test results, investigation logs, transient blockers, conversation summaries, or announcements of your own activity. When uncertain, do not write. " +
+  "Updates are visible too: update only when durable state materially changes, and remove a note created by your session when it stops being useful instead of turning it into a completion log. Put a concise plain-text title on the first line, stay focused on one topic, and include only the context needed for future action.";
 
 function getToolDefs(handlers) {
   return [

package/lib/worktree.js

@@ -43,9 +43,14 @@ function isWorktree(projectPath) {
   }
 }
 
+function isPathInside(parentPath, candidatePath) {
+  var relative = path.relative(path.resolve(parentPath), path.resolve(candidatePath));
+  return relative !== "" && relative !== ".." && relative.indexOf(".." + path.sep) !== 0 && !path.isAbsolute(relative);
+}
+
 // Scan worktrees for a given project path
-// Returns array of { path, branch, bare, detached, accessible }
-// accessible = true if worktree path is inside parentPath
+// Returns array of { path, branch, bare, detached, external }
+// external = true when Git registered the worktree outside the main project folder
 function scanWorktrees(projectPath) {
   var resolvedParent = path.resolve(projectPath);
   try {
@@ -63,7 +68,7 @@ function scanWorktrees(projectPath) {
       if (wt.bare) continue;
       var resolvedWt = path.resolve(wt.path);
       if (resolvedWt === resolvedParent) continue;
-      wt.accessible = resolvedWt.indexOf(resolvedParent + path.sep) === 0;
+      wt.external = !isPathInside(resolvedParent, resolvedWt);
       wt.dirName = path.basename(wt.path);
       results.push(wt);
     }
@@ -131,4 +136,4 @@ function removeWorktree(projectPath, worktreeDirName) {
   }
 }
 
-module.exports = { scanWorktrees: scanWorktrees, createWorktree: createWorktree, removeWorktree: removeWorktree, isWorktree: isWorktree };
+module.exports = { scanWorktrees: scanWorktrees, createWorktree: createWorktree, removeWorktree: removeWorktree, isWorktree: isWorktree, isPathInside: isPathInside };

package/lib/ws-schema.js

@@ -145,6 +145,7 @@ var schema = {
   "kill_process":             { direction: "c2s", handler: "lib/project-sessions.js", description: "Kill a system process by PID" },
   "process_killed":           { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Process was successfully killed" },
   "process_conflict":         { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Conflict: another process is using the session" },
+  "session_writer_conflict":  { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Codex session is already open in another process" },
 
   // -----------------------------------------------------------------------
   // Context / usage
@@ -353,6 +354,8 @@ var schema = {
   "term_closed":              { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Terminal session was closed" },
   "term_list":                { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Full list of open terminals" },
   "term_error":               { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Terminal error (e.g. access denied)" },
+  "shell_command":            { direction: "c2s", handler: "lib/project-shell-command.js", description: "Run a one-shot shell command for agent context" },
+  "shell_command_result":     { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "One-shot shell command output and exit status" },
 
   // -----------------------------------------------------------------------
   // Sticky notes

package/lib/yoke/acp-agent-profiles.js

@@ -0,0 +1,238 @@
+// ACP Agent Drivers
+// -----------------
+// Vendor-specific facts and optional hooks for agents that implement ACP.
+// Static profiles are sufficient for standard agents; richer runtimes can add
+// hooks without forcing YOKE down to ACP's least-common-denominator feature set.
+
+var fs = require("fs");
+var execFile = require("child_process").execFile;
+var execFileSync = require("child_process").execFileSync;
+
+function findOnPath(binaryName, overrideName) {
+  var overridePath = overrideName && process.env[overrideName];
+  if (overridePath && fs.existsSync(overridePath)) return overridePath;
+  try {
+    var command = process.platform === "win32" ? "where" : "which";
+    var out = execFileSync(command, [binaryName], {
+      timeout: 3000,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return out.trim().split(/\r?\n/)[0] || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function fetchOpenCodeModels(binaryPath, cwd) {
+  return new Promise(function(resolve) {
+    execFile(binaryPath, ["models"], {
+      cwd: cwd || process.cwd(),
+      timeout: 20000,
+      maxBuffer: 4 * 1024 * 1024,
+    }, function(err, stdout) {
+      if (err || !stdout) { resolve([]); return; }
+      var seen = {};
+      var models = [];
+      var lines = String(stdout).split(/\r?\n/);
+      for (var i = 0; i < lines.length; i++) {
+        var value = lines[i].trim();
+        if (!value || seen[value]) continue;
+        seen[value] = true;
+        models.push(value);
+      }
+      resolve(models);
+    });
+  });
+}
+
+function fetchOpenCodeResolvedConfig(binaryPath, cwd, env) {
+  return new Promise(function(resolve, reject) {
+    execFile(binaryPath, ["debug", "config"], {
+      cwd: cwd || process.cwd(),
+      env: Object.assign({}, process.env, env || {}),
+      timeout: 30000,
+      maxBuffer: 4 * 1024 * 1024,
+    }, function(err, stdout) {
+      if (err) { reject(err); return; }
+      try {
+        resolve(JSON.parse(String(stdout || "{}")));
+      } catch (e) {
+        reject(new Error("OpenCode returned invalid resolved configuration"));
+      }
+    });
+  });
+}
+
+function fetchOpenCodeAgentNames(binaryPath, cwd, env) {
+  return fetchOpenCodeResolvedConfig(binaryPath, cwd, env).then(function(config) {
+    return Object.keys(config.agent || {});
+  });
+}
+
+function isSafeOpenCodePermission(value) {
+  if (value === "ask" || value === "deny") return true;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  var keys = Object.keys(value);
+  if (!keys.length) return false;
+  for (var i = 0; i < keys.length; i++) {
+    if (!isSafeOpenCodePermission(value[keys[i]])) return false;
+  }
+  return true;
+}
+
+function validateOpenCodeConfig(config) {
+  if (!config || config.permission !== "ask") {
+    throw new Error("OpenCode resolved configuration does not preserve global ask permissions");
+  }
+  var agents = config.agent || {};
+  var names = Object.keys(agents);
+  for (var i = 0; i < names.length; i++) {
+    var agent = agents[names[i]] || {};
+    if (agent.permission === undefined) continue;
+    if (!isSafeOpenCodePermission(agent.permission)) {
+      throw new Error("OpenCode agent has unsafe resolved permissions: " + names[i]);
+    }
+  }
+}
+
+function trustDefaultWhenModeIsNotExposed(ctx, next) {
+  var options = ctx.state && ctx.state.configOptions;
+  for (var i = 0; i < (options || []).length; i++) {
+    if (options[i].category === "mode" || options[i].id === "mode") return next();
+  }
+  if (ctx.state && ctx.state.modes) return next();
+  return Promise.resolve();
+}
+
+var ACP_AGENT_PROFILES = {
+  opencode: {
+    vendor: "opencode",
+    displayName: "OpenCode",
+    binaryName: "opencode",
+    overrideName: "OPENCODE_CLI_PATH",
+    args: ["acp"],
+    defaultModels: ["auto"],
+    defaultModel: "auto",
+    sessionResume: null,
+    fetchModels: fetchOpenCodeModels,
+    permissionModeGuaranteed: true,
+    prepare: function(ctx) {
+      var injected = ctx.initOpts && ctx.initOpts._openCodeAgentNames;
+      if (Array.isArray(injected)) {
+        ctx.driverState.agentNames = injected.slice();
+        return;
+      }
+      return fetchOpenCodeAgentNames(ctx.binaryPath, ctx.cwd, ctx.initOpts && ctx.initOpts.env).then(function(names) {
+        ctx.driverState.agentNames = names;
+      });
+    },
+    buildProcessOptions: function(ctx, base) {
+      var existing = (base.env && base.env.OPENCODE_CONFIG_CONTENT) || process.env.OPENCODE_CONFIG_CONTENT;
+      var config = {};
+      if (existing) config = JSON.parse(existing);
+      var agent = Object.assign({}, config.agent || {});
+      var names = ["build", "plan"].concat(ctx.driverState.agentNames || []);
+      for (var i = 0; i < names.length; i++) {
+        agent[names[i]] = Object.assign({}, agent[names[i]] || {}, { permission: "ask" });
+      }
+      base.env = Object.assign({}, base.env || {}, {
+        OPENCODE_CONFIG_CONTENT: JSON.stringify(Object.assign({}, config, { permission: "ask", agent: agent })),
+      });
+      return base;
+    },
+    validateProcessOptions: function(ctx) {
+      var injected = ctx.initOpts && ctx.initOpts._openCodeResolvedConfig;
+      var resolved = injected
+        ? Promise.resolve(injected)
+        : fetchOpenCodeResolvedConfig(ctx.binaryPath, ctx.cwd, ctx.processOptions.env);
+      return resolved.then(function(config) {
+        validateOpenCodeConfig(config);
+      });
+    },
+    ensureSafePermissionMode: function() {
+      // OpenCode ACP modes select agents, not approval policy. The process
+      // configuration above enforces ask at both global and effective-agent levels.
+      return Promise.resolve();
+    },
+  },
+  kimi: {
+    vendor: "kimi",
+    displayName: "Kimi Code",
+    binaryName: "kimi",
+    overrideName: "KIMI_CLI_PATH",
+    args: ["acp"],
+    defaultModels: ["auto"],
+    defaultModel: "auto",
+    sessionResume: null,
+    ensureSafePermissionMode: trustDefaultWhenModeIsNotExposed,
+  },
+  grok: {
+    vendor: "grok",
+    displayName: "Grok Build",
+    binaryName: "grok",
+    overrideName: "GROK_CLI_PATH",
+    args: ["--no-auto-update", "--permission-mode", "ask", "agent", "stdio"],
+    defaultModels: ["auto"],
+    defaultModel: "auto",
+    sessionResume: null,
+    permissionModeGuaranteed: true,
+  },
+  copilot: {
+    vendor: "copilot",
+    displayName: "GitHub Copilot CLI",
+    binaryName: "copilot",
+    overrideName: "COPILOT_CLI_PATH",
+    args: ["--acp"],
+    defaultModels: ["auto"],
+    defaultModel: "auto",
+    sessionResume: null,
+    ensureSafePermissionMode: trustDefaultWhenModeIsNotExposed,
+  },
+  qwen: {
+    vendor: "qwen",
+    displayName: "Qwen Code",
+    binaryName: "qwen",
+    overrideName: "QWEN_CLI_PATH",
+    args: ["--acp", "--approval-mode", "default"],
+    defaultModels: ["auto"],
+    defaultModel: "auto",
+    sessionResume: null,
+    permissionModeGuaranteed: true,
+  },
+  junie: {
+    vendor: "junie",
+    displayName: "Junie CLI",
+    binaryName: "junie",
+    overrideName: "JUNIE_CLI_PATH",
+    args: ["--acp", "true"],
+    defaultModels: ["auto"],
+    defaultModel: "auto",
+    sessionResume: null,
+    ensureSafePermissionMode: trustDefaultWhenModeIsNotExposed,
+  },
+};
+
+function getAcpAgentProfile(vendor) {
+  return ACP_AGENT_PROFILES[vendor] || null;
+}
+
+function getAcpAgentDriver(vendor) {
+  return getAcpAgentProfile(vendor);
+}
+
+function findAcpAgentPath(profile) {
+  if (!profile) return null;
+  return findOnPath(profile.binaryName, profile.overrideName);
+}
+
+module.exports = {
+  ACP_AGENT_PROFILES: ACP_AGENT_PROFILES,
+  getAcpAgentProfile: getAcpAgentProfile,
+  getAcpAgentDriver: getAcpAgentDriver,
+  findAcpAgentPath: findAcpAgentPath,
+  fetchOpenCodeModels: fetchOpenCodeModels,
+  fetchOpenCodeAgentNames: fetchOpenCodeAgentNames,
+  fetchOpenCodeResolvedConfig: fetchOpenCodeResolvedConfig,
+  validateOpenCodeConfig: validateOpenCodeConfig,
+};

package/lib/yoke/acp-driver-runtime.js

@@ -0,0 +1,50 @@
+// ACP Vendor Driver Runtime
+// -------------------------
+// ACP supplies defaults. Trusted vendor drivers may extend or replace them so
+// the shared protocol never becomes the ceiling of the richer YOKE contract.
+
+function hasHook(driver, name) {
+  return !!(driver && typeof driver[name] === "function");
+}
+
+function call(driver, name, context, fallback) {
+  if (hasHook(driver, name)) return driver[name](context, fallback);
+  return fallback ? fallback() : undefined;
+}
+
+function callAsync(driver, name, context, fallback) {
+  try {
+    return Promise.resolve(call(driver, name, context, fallback));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+
+function mergeCapabilities(driver, context, base) {
+  var defaults = Object.assign({}, base);
+  if (!hasHook(driver, "extendCapabilities")) return defaults;
+  var extended = driver.extendCapabilities(context, Object.assign({}, defaults));
+  return Object.assign({}, defaults, extended || {});
+}
+
+function buildParams(driver, hookName, context, base) {
+  var defaults = Object.assign({}, base);
+  if (!hasHook(driver, hookName)) return defaults;
+  var result = driver[hookName](context, Object.assign({}, defaults));
+  return result === undefined || result === null ? defaults : result;
+}
+
+function normalizeEvents(driver, context, fallback) {
+  var result = call(driver, "normalizeUpdate", context, fallback);
+  if (result === undefined || result === null) return [];
+  return Array.isArray(result) ? result : [result];
+}
+
+module.exports = {
+  hasHook: hasHook,
+  call: call,
+  callAsync: callAsync,
+  mergeCapabilities: mergeCapabilities,
+  buildParams: buildParams,
+  normalizeEvents: normalizeEvents,
+};