@aiwg/cli 2026.9.20 → 2026.9.21

package/dist/src/extensions/manifest.js

@@ -123,6 +123,7 @@ export const ProviderConfigSchema = z.object({
         'factory',
         'grokbot',
         'hermes',
+        'muse',
         'opencode',
         'openclaw',
         'openhuman',

package/dist/src/marketplace/provenance.js

@@ -12,6 +12,7 @@ import { createHash, createPrivateKey, createPublicKey, sign as cryptoSign, veri
 import { lstat, readFile, readdir } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
+import { createCanonicalSigner } from '../security/signing.js';
 import { MARKETPLACE_ENVELOPE_SCHEMA, MARKETPLACE_LOCK_SCHEMA, MARKETPLACE_RECEIPT_SCHEMA, } from './provenance-types.js';
 const execFileAsync = promisify(execFile);
 const SHA256 = /^[a-f0-9]{64}$/;
@@ -55,7 +56,20 @@ function stable(value) {
     }
     return value;
 }
-/** RFC-8785-style deterministic JSON for the JSON-native protocol values. */
+/**
+ * RFC-8785-style deterministic JSON for the JSON-native protocol values.
+ *
+ * For JSON-native values (no `undefined`, no non-finite numbers, no `toJSON`,
+ * no array-index keys such as "9" or "10") this is byte-identical to the
+ * RFC 8785 `artifact-trust.canonicalJson`: both sort keys by UTF-16 code unit
+ * and serialize scalars with `JSON.stringify`. It is kept because existing
+ * marketplace signatures depend on its handling of the other values:
+ * `undefined` object members are dropped, `undefined` array entries and
+ * non-finite numbers become `null` (RFC 8785 throws), and array-index keys are
+ * emitted first in numeric order because the sorted object is rebuilt.
+ * test/unit/security/canonical-json-parity.test.ts pins the parity and the
+ * differences.
+ */
 export function canonicalJson(value) {
     return JSON.stringify(stable(value));
 }
@@ -411,40 +425,24 @@ export function envelopeSigningPayload(envelope) {
     const { signatures: _signatures, ...payload } = envelope;
     return payload;
 }
-function publicKeyDer(key) {
-    const object = typeof key === 'string'
-        ? createPublicKey(key)
-        : key.type === 'public' ? key : createPublicKey(key);
-    if (object.asymmetricKeyType !== 'ed25519')
-        throw new Error('Marketplace signing keys must use Ed25519');
-    return object.export({ format: 'der', type: 'spki' });
-}
+// Marketplace signatures are made over this module's `canonicalJson`, which is
+// kept (see its comment) so existing envelopes and receipts verify unchanged.
+// The helpers themselves live in src/security/signing.ts.
+const marketplaceSigner = createCanonicalSigner({
+    canonicalize: canonicalJson,
+    keyTypeErrorMessage: 'Marketplace signing keys must use Ed25519',
+});
 function publicKeyFromBase64(value) {
     return createPublicKey({ key: Buffer.from(value, 'base64'), format: 'der', type: 'spki' });
 }
 export function signCanonicalDocument(document, privateKeyPem, options = {}) {
-    const privateKey = createPrivateKey(privateKeyPem);
-    if (privateKey.asymmetricKeyType !== 'ed25519')
-        throw new Error('Marketplace signing keys must use Ed25519');
-    const publicKey = options.publicKeyPem ? createPublicKey(options.publicKeyPem) : createPublicKey(privateKey);
-    const payload = canonicalJson(document);
-    return {
-        keyId: options.keyId ?? signingKeyId(publicKey),
-        algorithm: 'ed25519',
-        publicKey: publicKeyDer(publicKey).toString('base64'),
-        signedAt: options.signedAt ?? new Date().toISOString(),
-        payloadSha256: sha256(payload),
-        signature: cryptoSign(null, Buffer.from(payload), privateKey).toString('base64'),
-    };
+    return marketplaceSigner.signCanonicalDocument(document, privateKeyPem, options);
 }
 export function verifyCanonicalSignature(document, signature) {
-    const payload = canonicalJson(document);
-    return signature.algorithm === 'ed25519'
-        && signature.payloadSha256 === sha256(payload)
-        && cryptoVerify(null, Buffer.from(payload), publicKeyFromBase64(signature.publicKey), Buffer.from(signature.signature, 'base64'));
+    return marketplaceSigner.verifyCanonicalSignature(document, signature);
 }
 export function signingKeyId(publicKey) {
-    return `ed25519:${sha256(publicKeyDer(publicKey)).slice(0, 32)}`;
+    return marketplaceSigner.signingKeyId(publicKey);
 }
 export function signProvenanceEnvelope(envelope, privateKeyPem, options = {}) {
     validateProvenanceEnvelope(envelope);

package/dist/src/mcp/cli.mjs

@@ -19,6 +19,7 @@ import {
 import { McpProfileRegistry } from './profiles.mjs';
 import { getMcpInjectionDefinition } from '../providers/provider-definitions.mjs';
 import { manageOmpMcp } from './omp-config.mjs';
+import { unmanageGrokBuildMcp } from './grok-build-config.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -1202,12 +1203,21 @@ export async function main(args = process.argv.slice(2)) {
 
     case 'uninject': {
       const provider = parseFlag(subArgs, '--provider');
-      if (!['omp', 'oh-my-pi'].includes(provider)) throw new Error('uninject currently supports --provider omp');
+      if (!['omp', 'oh-my-pi', 'grok-build'].includes(provider)) throw new Error('uninject supports --provider omp or grok-build');
       const scope = parseFlag(subArgs, '--scope') || 'project';
       if (!['project', 'user'].includes(scope)) throw new Error('Scope must be project or user');
       const remove = (parseFlag(subArgs, '--servers') || '').split(',').map(s => s.trim()).filter(Boolean);
       if (!remove.length) throw new Error('uninject requires --servers name[,name]');
       const configPath = getProviderConfigPath(provider, parseFlag(subArgs, '--project') || '.', { scope });
+      if (provider === 'grok-build') {
+        const projectDir = parseFlag(subArgs, '--project') || '.';
+        const result = await unmanageGrokBuildMcp(configPath, remove, {
+          dryRun: subArgs.includes('--dry-run'),
+          root: scope === 'user' ? path.dirname(path.dirname(configPath)) : path.resolve(projectDir),
+        });
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
       const result = await manageOmpMcp(configPath, [], { remove, dryRun: subArgs.includes('--dry-run') });
       console.log(JSON.stringify(result, null, 2));
       break;

package/dist/src/mcp/grok-build-config.mjs

@@ -0,0 +1,189 @@
+import { constants } from 'node:fs';
+import { access, lstat, mkdir, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, relative, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { replaceServer } from './toml-editor.mjs';
+
+const START = name => `# >>> AIWG-managed Grok MCP: ${name}`;
+const END = name => `# <<< AIWG-managed Grok MCP: ${name}`;
+const ENV_REF = /^(?:[^$]|\$\{[A-Za-z_][A-Za-z0-9_]*(?::-[^}]*)?\})*$/;
+
+function string(value) {
+  if (typeof value !== 'string') throw new Error('Grok MCP string fields must be strings');
+  return JSON.stringify(value).replace(/\u007f/g, '\\u007f');
+}
+
+function key(value) {
+  return /^[A-Za-z0-9_-]+$/.test(value) ? value : string(value);
+}
+
+function inline(values = {}) {
+  return `{ ${Object.entries(values).map(([name, value]) => `${key(name)} = ${string(value)}`).join(', ')} }`;
+}
+
+export function renderGrokMcpServer(server) {
+  if (!server?.name) throw new Error('Grok MCP server name is required');
+  const lines = [`[mcp_servers.${key(server.name)}]`];
+  if (server.type === 'stdio') {
+    if (!server.command) throw new Error(`Grok MCP stdio server "${server.name}" requires command`);
+    lines.push(`command = ${string(server.command)}`);
+    if (server.args?.length) lines.push(`args = [${server.args.map(string).join(', ')}]`);
+    if (server.env && Object.keys(server.env).length) lines.push(`env = ${inline(server.env)}`);
+  } else {
+    if (!server.url) throw new Error(`Grok MCP HTTP server "${server.name}" requires url`);
+    lines.push(`url = ${string(server.url)}`);
+    const headers = { ...(server.headers || {}) };
+    for (const [header, envName] of Object.entries(server.headerEnv || {})) {
+      headers[header] = `\${${envName}}`;
+    }
+    if (Object.keys(headers).length) lines.push(`headers = ${inline(headers)}`);
+  }
+  if (server.enabled === false) lines.push('enabled = false');
+  for (const value of [server.command, server.url, ...(server.args || []), ...Object.values(server.env || {}), ...Object.values(server.headers || {})]) {
+    if (typeof value === 'string' && value.includes('$') && !ENV_REF.test(value)) {
+      throw new Error(`Grok MCP server "${server.name}" contains an invalid environment reference`);
+    }
+  }
+  lines.push('startup_timeout_sec = 30', 'tool_timeout_sec = 6000');
+  return lines.join('\n');
+}
+
+function managedRange(text, name) {
+  let start = text.indexOf(START(name));
+  const endMarker = END(name);
+  const end = text.indexOf(endMarker);
+  if (start < 0 && end < 0) return null;
+  if (start < 0 || end < start) throw new Error(`Malformed AIWG ownership markers for Grok MCP server "${name}"`);
+  // Deployment owns the single blank separator it adds before its marker.
+  if (start > 0 && text.slice(start - 2, start) === '\n\n') start -= 1;
+  return [start, end + endMarker.length + (text[end + endMarker.length] === '\n' ? 1 : 0)];
+}
+
+export function mergeGrokMcpServers(text, servers) {
+  let output = text;
+  const seen = new Set();
+  for (const server of servers) {
+    if (seen.has(server.name)) throw new Error(`Duplicate Grok MCP server name "${server.name}"`);
+    seen.add(server.name);
+    const section = renderGrokMcpServer(server);
+    const range = managedRange(output, server.name);
+    const probeText = range ? output.slice(0, range[0]) + output.slice(range[1]) : output;
+    const probe = replaceServer(probeText, server.name, section);
+    if (!range && probe.alreadyPresent) {
+      throw new Error(`Grok MCP server "${server.name}" is operator-managed; refusing to replace it`);
+    }
+    const prefix = range ? output.slice(0, range[0]) : `${output}${output && !output.endsWith('\n') ? '\n' : ''}`;
+    const block = `${prefix ? '\n' : ''}${START(server.name)}\n${section}\n${END(server.name)}\n`;
+    output = range ? prefix + block + output.slice(range[1]) : prefix + block;
+    // Parse and validate the completed document without exposing its content.
+    replaceServer(output, '__aiwg_validation_probe__', '[mcp_servers.__aiwg_validation_probe__]\ncommand = "true"');
+  }
+  return output;
+}
+
+export function removeGrokMcpServers(text, names) {
+  let output = text;
+  const removed = [];
+  for (const name of names) {
+    const range = managedRange(output, name);
+    if (!range) continue;
+    output = output.slice(0, range[0]) + output.slice(range[1]);
+    removed.push(name);
+  }
+  if (output) replaceServer(output, '__aiwg_validation_probe__', '[mcp_servers.__aiwg_validation_probe__]\ncommand = "true"');
+  return { text: output, removed };
+}
+
+async function assertSafeTarget(configPath, root) {
+  const absolute = resolve(configPath);
+  const base = resolve(root);
+  const rel = relative(base, absolute);
+  if (!rel || rel.startsWith('..') || rel.startsWith('/') || rel.includes('\0')) {
+    throw new Error('Grok MCP config path must be a file beneath the selected configuration root');
+  }
+  for (let current = dirname(absolute); current !== base; current = dirname(current)) {
+    try {
+      if ((await lstat(current)).isSymbolicLink()) throw new Error('Refusing Grok MCP path through a symbolic link');
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
+  }
+  try {
+    const info = await lstat(absolute);
+    if (info.isSymbolicLink() || !info.isFile()) throw new Error('Refusing unsafe Grok MCP config target');
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+  }
+}
+
+async function atomicWrite(file, content) {
+  await mkdir(dirname(file), { recursive: true });
+  const temp = `${file}.aiwg-${process.pid}-${Date.now()}.tmp`;
+  try {
+    const handle = await open(temp, 'wx', 0o600);
+    await handle.writeFile(content, 'utf8');
+    await handle.sync();
+    await handle.close();
+    await rename(temp, file);
+  } catch (error) {
+    await rm(temp, { force: true });
+    throw error;
+  }
+}
+
+export async function manageGrokBuildMcp(configPath, servers, options = {}) {
+  const root = options.root || dirname(dirname(configPath));
+  if (options.blockedByPolicy) return { configPath, state: 'blocked-by-policy', serversInjected: [], alreadyPresent: [], error: options.blockedByPolicy };
+  await assertSafeTarget(configPath, root);
+  let before = '';
+  try { before = await readFile(configPath, 'utf8'); } catch (error) { if (error?.code !== 'ENOENT') throw error; }
+  const alreadyPresent = servers.filter(server => managedRange(before, server.name)).map(server => server.name);
+  const after = mergeGrokMcpServers(before, servers);
+  if (!options.dryRun && after !== before) await atomicWrite(configPath, after);
+  return { configPath, state: options.disabled ? 'disabled' : 'configured', serversInjected: servers.map(server => server.name), alreadyPresent };
+}
+
+export async function unmanageGrokBuildMcp(configPath, names, options = {}) {
+  const root = options.root || dirname(dirname(configPath));
+  await assertSafeTarget(configPath, root);
+  let before;
+  try { before = await readFile(configPath, 'utf8'); } catch (error) { if (error?.code === 'ENOENT') return { configPath, state: 'absent', removed: [] }; throw error; }
+  const result = removeGrokMcpServers(before, names);
+  if (!options.dryRun && result.text !== before) await atomicWrite(configPath, result.text);
+  return { configPath, state: result.removed.length ? 'configured' : 'absent', removed: result.removed };
+}
+
+function runJson(binary, args, cwd, env) {
+  const run = spawnSync(binary, args, { cwd, env, encoding: 'utf8', timeout: 30_000 });
+  if (run.error || run.status !== 0) return { ok: false, detail: run.error?.message || run.stderr || `exit ${run.status}` };
+  try { return { ok: true, value: JSON.parse(run.stdout || '{}') }; }
+  catch { return { ok: false, detail: 'Grok returned malformed JSON' }; }
+}
+
+export async function inspectGrokBuildNative(options = {}) {
+  const configPath = options.configPath || resolve(options.projectDir || '.', '.grok/config.toml');
+  let config = '';
+  try { config = await readFile(configPath, 'utf8'); } catch (error) { if (error?.code === 'ENOENT') return { mcp: 'absent', hooks: 'absent', diagnostics: [] }; throw error; }
+  const disabled = /\benabled\s*=\s*false\b/.test(config);
+  const names = [...config.matchAll(/# >>> AIWG-managed Grok MCP: ([^\n]+)/g)].map(match => match[1]);
+  let mcp = names.length ? (disabled ? 'disabled' : 'configured') : 'absent';
+  const diagnostics = [];
+  if (options.blockedByPolicy) mcp = 'blocked-by-policy';
+  if (options.binary && names.length) {
+    const inspected = runJson(options.binary, ['inspect', '--json'], options.projectDir || '.', options.env || process.env);
+    if (!inspected.ok || !names.every(name => JSON.stringify(inspected.value || {}).includes(name))) {
+      mcp = 'unhealthy';
+      diagnostics.push(inspected.ok ? 'grok inspect did not expose every AIWG-managed MCP server' : inspected.detail);
+    }
+    const listed = runJson(options.binary, ['mcp', 'list', '--json'], options.projectDir || '.', options.env || process.env);
+    if (!listed.ok) { mcp = 'unhealthy'; diagnostics.push(listed.detail); }
+    for (const name of names) {
+      const doctor = runJson(options.binary, ['mcp', 'doctor', name, '--json'], options.projectDir || '.', options.env || process.env);
+      if (!doctor.ok) { mcp = 'unhealthy'; diagnostics.push(`${name}: ${doctor.detail}`); }
+    }
+  }
+  const hooksDir = resolve(options.projectDir || '.', '.grok/hooks');
+  let hooks = 'absent';
+  try { await access(hooksDir, constants.R_OK); hooks = options.trusted === true ? 'configured' : 'untrusted'; } catch { /* absent */ }
+  return { mcp, hooks, servers: names, diagnostics };
+}

package/dist/src/mcp/registry.js

@@ -1,4 +1,5 @@
 import { manageOmpMcp } from './omp-config.mjs';
+import { manageGrokBuildMcp } from './grok-build-config.mjs';
 import { replaceServer } from './toml-editor.mjs';
 import { resolveOmpPaths } from '../providers/omp-paths.mjs';
 /**
@@ -11,7 +12,7 @@ import { resolveOmpPaths } from '../providers/omp-paths.mjs';
  * @implements #554
  */
 import { readFile, writeFile, mkdir } from 'fs/promises';
-import { resolve } from 'path';
+import { dirname, resolve } from 'path';
 import { resolveConfigDir } from '../config/user-config.js';
 import { getProviderDefinition } from '../providers/provider-definitions.js';
 // ============================================
@@ -300,6 +301,9 @@ export function getProviderConfigPath(provider, projectDir = '.', options = {})
         factory: resolve(homeDir, '.factory/mcp.json'),
         codex: resolve(homeDir, '.codex/config.toml'),
         openai: resolve(homeDir, '.codex/config.toml'),
+        'grok-build': options.scope === 'user'
+            ? resolve(process.env.GROK_HOME || resolve(homeDir, '.grok'), 'config.toml')
+            : resolve(projectDir, '.grok/config.toml'),
         opencode: resolve(projectDir, 'opencode.json'),
         windsurf: resolve(homeDir, '.codeium/windsurf/mcp_config.json'),
         warp: resolve(homeDir, '.warp/mcp.json'),
@@ -342,6 +346,21 @@ export async function injectServers(registry, provider, options = {}) {
             return { ...result, error: error instanceof Error ? error.message : String(error) };
         }
     }
+    if (provider === 'grok-build') {
+        try {
+            const managed = await manageGrokBuildMcp(configPath, allServers, {
+                dryRun,
+                root: options.scope === 'user' ? dirname(dirname(configPath)) : resolve(projectDir),
+            });
+            if (!dryRun && !managed.error)
+                for (const server of allServers)
+                    await registry.recordInjection(server.name, 'grok-build');
+            return { ...result, ...managed };
+        }
+        catch (error) {
+            return { ...result, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
     // Handle TOML-based providers (Codex/OpenAI) separately
     if (provider === 'codex' || provider === 'openai') {
         return injectToml(registry, allServers, configPath, provider, dryRun, result);
@@ -432,6 +451,7 @@ export const SUPPORTED_PROVIDERS = [
     'cursor',
     'factory',
     'codex',
+    'grok-build',
     'opencode',
     'windsurf',
     'warp',

package/dist/src/mcp/registry.mjs

@@ -1,4 +1,5 @@
 import { manageOmpMcp } from './omp-config.mjs';
+import { manageGrokBuildMcp } from './grok-build-config.mjs';
 import { replaceServer } from './toml-editor.mjs';
 import { resolveOmpPaths } from '../providers/omp-paths.mjs';
 /**
@@ -15,7 +16,7 @@ import { resolveOmpPaths } from '../providers/omp-paths.mjs';
  */
 
 import { readFile, writeFile, mkdir } from 'fs/promises';
-import { resolve } from 'path';
+import { dirname, resolve } from 'path';
 import { homedir } from 'os';
 import { existsSync } from 'fs';
 import {
@@ -345,6 +346,24 @@ export async function injectServers(registry, provider, options = {}) {
     }
   }
 
+  if (normalizedProvider === 'grok-build') {
+    try {
+      const managed = await manageGrokBuildMcp(configPath, allServers, {
+        dryRun,
+        root: options.scope === 'user'
+          ? dirname(dirname(configPath))
+          : resolve(projectDir),
+        blockedByPolicy: options.blockedByPolicy,
+      });
+      if (!dryRun && !managed.error) {
+        for (const server of allServers) await registry.recordInjection(server.name, 'grok-build');
+      }
+      return { ...result, ...managed };
+    } catch (error) {
+      return { ...result, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+
   if (mcpDefinition?.configFormat === 'toml') {
     return injectToml(registry, allServers, configPath, provider, dryRun, result);
   }