@commonlyai/cli 0.1.39 → 0.1.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonlyai/cli",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "license": "Apache-2.0",
   "description": "The Commonly CLI — connect agents, manage pods, iterate fast",
   "type": "module",

package/src/commands/agent.js

@@ -395,27 +395,46 @@ export const setWakeOnMessage = async ({ client, record, enabled }) => {
 export const updateAgentConfiguration = async ({
   client,
   record,
+  adapter = null,
   model = null,
   effort = null,
   envPath = null,
   parseEnv = parseEnvironmentFile,
+  adapterRegistry = { getAdapter, listAdapterNames },
 }) => {
   if (!record?.podId || !record?.agentName) {
     throw new Error('token record is missing podId/agentName — re-attach the agent');
   }
   const instanceId = record.instanceId || 'default';
   const runtime = {};
+  const environmentRuntime = {};
+  if (adapter !== null && adapter !== undefined) {
+    const normalizedAdapter = String(adapter).trim().toLowerCase();
+    const knownAdapters = adapterRegistry.listAdapterNames();
+    const selectedAdapter = adapterRegistry.getAdapter(normalizedAdapter);
+    if (!selectedAdapter || !knownAdapters.includes(normalizedAdapter)) {
+      throw new Error(
+        `Unknown adapter '${normalizedAdapter}'. Known: ${knownAdapters.join(', ')}`,
+      );
+    }
+    if (!await selectedAdapter.detect()) {
+      throw new Error(`Adapter '${normalizedAdapter}' not found on PATH. Install it and retry.`);
+    }
+    runtime.adapter = normalizedAdapter;
+  }
   if (model !== null && model !== undefined) {
     const normalizedModel = String(model);
     const validation = validateEnvironmentSpec({ model: normalizedModel });
     if (!validation.ok) throw new Error(validation.errors.join('; '));
     runtime.model = normalizedModel;
+    environmentRuntime.model = normalizedModel;
   }
   if (effort !== null && effort !== undefined) {
     const normalizedEffort = String(effort);
     const validation = validateEnvironmentSpec({ effort: normalizedEffort });
     if (!validation.ok) throw new Error(validation.errors.join('; '));
     runtime.effort = normalizedEffort;
+    environmentRuntime.effort = normalizedEffort;
   }
   const config = {};
   if (Object.keys(runtime).length) config.runtime = runtime;
@@ -429,15 +448,15 @@ export const updateAgentConfiguration = async ({
   // an ADR-008 environment, a model/effort flag must update that declaration
   // too; otherwise the daemon would correctly prefer the old explicit value
   // over the new legacy runtime overlay.
-  if (environment && Object.keys(runtime).length) {
-    environment = { ...environment, ...runtime };
+  if (environment && Object.keys(environmentRuntime).length) {
+    environment = { ...environment, ...environmentRuntime };
   }
-  if (!environment && Object.keys(runtime).length) {
-    environment = { ...runtime };
+  if (!environment && Object.keys(environmentRuntime).length) {
+    environment = { ...environmentRuntime };
   }
   if (environment) config.environment = environment;
   if (!Object.keys(config).length) {
-    throw new Error('provide at least one of --model, --effort, or --env');
+    throw new Error('provide at least one of --adapter, --model, --effort, or --env');
   }
 
   await client.patch(
@@ -449,6 +468,7 @@ export const updateAgentConfiguration = async ({
     podId: record.podId,
     instanceId,
     changed: Object.keys(config),
+    ...(runtime.adapter ? { adapter: runtime.adapter } : {}),
     ...(environment ? { environment } : {}),
   };
 };
@@ -2077,6 +2097,7 @@ Examples:
 
   # List installed agents
   $ commonly agent list
+  $ commonly agent config my-claude --adapter claude --model gpt-5.4 --effort high
   $ commonly agent config my-claude --model gpt-5.4 --effort high
 
 Docs:
@@ -2704,6 +2725,7 @@ Use --local to find the name you'd pass to 'agent run' or 'agent detach'.
   agent
     .command('config <name>')
     .description('Update an attached agent\'s server-side runtime configuration')
+    .option('--adapter <name>', 'Local runtime adapter (must be installed on this machine)')
     .option('--model <id>', 'Model identifier to use on the next daemon restart')
     .option('--effort <level>', 'Reasoning effort (low|medium|high|xhigh|max)')
     .option('--env <path>', 'Replace the ADR-008 environment spec with this JSON file')
@@ -2722,12 +2744,17 @@ Use --local to find the name you'd pass to 'agent run' or 'agent detach'.
         const result = await updateAgentConfiguration({
           client,
           record,
+          adapter: opts.adapter,
           model: opts.model,
           effort: opts.effort,
           envPath: opts.env ? pathResolve(opts.env) : null,
         });
-        if (result.environment) {
-          saveAgentToken(name, { ...record, environment: result.environment });
+        if (result.environment || result.adapter) {
+          saveAgentToken(name, {
+            ...record,
+            ...(result.environment ? { environment: result.environment } : {}),
+            ...(result.adapter ? { adapter: result.adapter } : {}),
+          });
         }
         console.log(`✓ Updated ${result.agentName} in pod ${result.podId} (${result.changed.join(', ')})`);
         console.log('  The daemon will apply the change on its next poll; a standalone agent run needs a restart.');

package/src/lib/adapters/claude.js

@@ -59,7 +59,7 @@ import {
   writeFile,
 } from 'fs/promises';
 import { homedir, tmpdir } from 'os';
-import { isAbsolute, join } from 'path';
+import { delimiter, isAbsolute, join } from 'path';
 
 import { mountSkills } from '../environment.js';
 import { wrapArgvWithBwrap } from '../sandbox/bwrap.js';
@@ -337,17 +337,39 @@ const createMcpConfig = async (mcpServers, ctx = {}) => {
 
 // ── argv preparation — environment-aware ────────────────────────────────────
 
+// Claude's npm installer commonly puts the binary in ~/.local/bin, while
+// launchd/supervisor environments intentionally use a small PATH. Keep the
+// command name for the legacy spawn contract, but add this directory to the
+// child environment and to every detection lookup so a daemon does not report
+// a false "adapter unavailable" (or hit spawn ENOENT) merely because it was
+// started outside an interactive shell.
+const withClaudePath = (input) => {
+  const output = { ...(input || process.env) };
+  const localBin = join(homedir(), '.local', 'bin');
+  const entries = String(output.PATH || '')
+    .split(delimiter)
+    .filter(Boolean);
+  if (!entries.includes(localBin)) entries.push(localBin);
+  output.PATH = entries.join(delimiter);
+  return output;
+};
+
 // Resolve the absolute path of `claude` so bwrap's execvp doesn't depend on
 // PATH being correctly populated inside the sandbox namespace. Surfaced live
 // during the 2026-04-17 demo validation: bwrap silently inherits parent
 // PATH but cannot reach the user's `~/.local/bin` without an absolute path
 // argv[0], even when that directory is bound read-only into the sandbox.
-const resolveClaudePath = () => {
+const resolveClaudePath = (env = process.env) => {
   // Defensive: spawnSync can return undefined under aggressive mocks (the
   // adapters.claude.environment.test.mjs suite stubs child_process so no real
   // process runs). Treat any failure mode as "use the bare command name."
   let which;
-  try { which = spawnSync('which', ['claude'], { encoding: 'utf8' }); } catch { /* ignore */ }
+  try {
+    which = spawnSync('which', ['claude'], {
+      encoding: 'utf8',
+      env: withClaudePath(env),
+    });
+  } catch { /* ignore */ }
   if (which && which.status === 0) {
     const p = (which.stdout || '').trim();
     if (p) {
@@ -363,7 +385,8 @@ const resolveClaudePath = () => {
 
 const prepareArgv = async (innerArgv, ctx) => {
   const env = ctx.environment;
-  if (!env) return { cmd: 'claude', args: innerArgv, env: ctx.claudeEnv };
+  const claudeEnv = withClaudePath(ctx.claudeEnv);
+  if (!env) return { cmd: 'claude', args: innerArgv, env: claudeEnv };
 
   let allowedPatterns = [];
   if (Array.isArray(env.mcp) && env.mcp.length > 0) {
@@ -407,7 +430,7 @@ const prepareArgv = async (innerArgv, ctx) => {
       ...innerArgv,
       ...buildPublicClaudePolicyArgs(allowedPatterns),
     ];
-    const claudeBin = resolveClaudePath();
+    const claudeBin = resolveClaudePath(claudeEnv);
     const mcpExecutables = (env.mcp || [])
       .map((server) => server?.command?.[0])
       .filter((command) => isAbsolute(command));
@@ -422,7 +445,7 @@ const prepareArgv = async (innerArgv, ctx) => {
     return {
       cmd: wrapped[0],
       args: wrapped.slice(1),
-      env: ctx.claudeEnv,
+      env: claudeEnv,
     };
   }
 
@@ -430,15 +453,15 @@ const prepareArgv = async (innerArgv, ctx) => {
     innerArgv = [...innerArgv, '--allowedTools', ...allowedPatterns];
   }
   if (sandboxMode === 'bwrap') {
-    const claudeBin = resolveClaudePath();
+    const claudeBin = resolveClaudePath(claudeEnv);
     const wrapped = wrapArgvWithBwrap([claudeBin, ...innerArgv], env, {
       workspacePath: ctx.cwd,
       readOnlyPaths: ctx.mcpConfigDir ? [ctx.mcpConfigDir] : [],
     });
-    return { cmd: wrapped[0], args: wrapped.slice(1), env: ctx.claudeEnv };
+    return { cmd: wrapped[0], args: wrapped.slice(1), env: claudeEnv };
   }
 
-  return { cmd: 'claude', args: innerArgv, env: ctx.claudeEnv };
+  return { cmd: 'claude', args: innerArgv, env: claudeEnv };
 };
 
 export default {
@@ -453,14 +476,21 @@ export default {
 
   async detect() {
     try {
-      const res = spawnSync('claude', ['--version'], { encoding: 'utf8' });
+      const claudeEnv = withClaudePath(process.env);
+      const res = spawnSync('claude', ['--version'], {
+        encoding: 'utf8',
+        env: claudeEnv,
+      });
       if (res.error || res.status !== 0) return null;
       // `claude --version` prints e.g. "2.5.1 (Claude Code)" — first token is enough
       const version = (res.stdout || '').trim().split(/\s+/)[0] || 'unknown';
       // Best-effort resolve of the binary path for clearer UX ("claude detected
       // at /usr/local/bin/claude"). Falls back to the bare command name on
       // platforms without `which` (e.g. Windows).
-      const where = spawnSync('which', ['claude'], { encoding: 'utf8' });
+      const where = spawnSync('which', ['claude'], {
+        encoding: 'utf8',
+        env: claudeEnv,
+      });
       const path = where.status === 0 ? (where.stdout || '').trim() || 'claude' : 'claude';
       return { path, version };
     } catch {

package/src/lib/daemon-supervisor.js

@@ -133,6 +133,26 @@ export const createDaemonSupervisor = ({
       // once at boot). A row with NO declared model leaves the record alone —
       // never strip an operator's hand-set environment.
       const wanted = environmentFor(row);
+      const declaredAdapter = row.runtime && typeof row.runtime === 'object'
+        && typeof row.runtime.adapter === 'string'
+        ? row.runtime.adapter.trim().toLowerCase()
+        : null;
+      let adapterChanged = false;
+      let nextAdapter = existing.adapter;
+      if (declaredAdapter) {
+        const detectedAdapter = await resolveAdapter(row.runtime || null);
+        // resolveAdapterForRuntime historically probes fallbacks when a
+        // declared adapter is absent. A configuration edit must never accept
+        // that fallback: it would report claude while running codex (or vice
+        // versa). Keep the existing child/token untouched until the exact
+        // requested adapter is detected locally.
+        if (detectedAdapter !== declaredAdapter) {
+          log(`[${row.agentName}] requested adapter '${declaredAdapter}' is not available on this machine — keeping the current seat`);
+          return false;
+        }
+        nextAdapter = declaredAdapter;
+        adapterChanged = existing.adapter !== nextAdapter;
+      }
       if (wanted) {
         const nextEnvironment = wanted.declared
           ? wanted.value
@@ -140,18 +160,37 @@ export const createDaemonSupervisor = ({
         const workspacePath = workspacePathFor(nextEnvironment);
         const nextRecord = {
           ...existing,
+          ...(adapterChanged ? { adapter: nextAdapter } : {}),
           environment: nextEnvironment,
           ...(workspacePath ? { workspacePath } : {}),
         };
-        if (!isDeepStrictEqual(existing.environment || null, nextEnvironment)
+        if (adapterChanged
+          || !isDeepStrictEqual(existing.environment || null, nextEnvironment)
           || (workspacePath && existing.workspacePath !== workspacePath)) {
           saveToken(row.agentName, nextRecord);
           log('runtime config changed — restarting the seat to load it');
           return 'changed';
         }
       }
+      if (adapterChanged) {
+        saveToken(row.agentName, { ...existing, adapter: nextAdapter });
+        log('runtime adapter changed — restarting the seat to load it');
+        return 'changed';
+      }
       return 'ready';
     }
+    const requestedAdapter = row.runtime && typeof row.runtime === 'object'
+      && typeof row.runtime.adapter === 'string'
+      ? row.runtime.adapter.trim().toLowerCase()
+      : null;
+    let adapter = null;
+    if (requestedAdapter) {
+      adapter = await resolveAdapter(row.runtime || null);
+      if (adapter !== requestedAdapter) {
+        log(`[${row.agentName}] requested adapter '${requestedAdapter}' is not available on this machine — skipping token mint`);
+        return false;
+      }
+    }
     const body = { agentName: row.agentName, instanceId: row.instanceId };
     let minted;
     try {
@@ -174,7 +213,7 @@ export const createDaemonSupervisor = ({
       log(`[${row.agentName}] mint returned no token — skipping`);
       return false;
     }
-    const adapter = await resolveAdapter(row.runtime || null);
+    if (!adapter) adapter = await resolveAdapter(row.runtime || null);
     if (!adapter) {
       log(`[${row.agentName}] no usable CLI adapter on this machine — install claude or codex, or attach manually`);
       return false;