@netlify/agent-runner-cli 1.119.11-alpha.0 → 1.119.12-alpha.0

package/dist/scripts/scaffold.js

@@ -1,3 +1,3 @@
-import{spawnSync as S}from"child_process";import{readdirSync as w,statSync as I,writeFileSync as m,mkdirSync as N}from"fs";import{createRequire as v}from"module";import s from"path";import t from"process";var u=v(import.meta.url);function x(){let e=u("@netlify/ts-cli/package.json"),n=s.dirname(u.resolve("@netlify/ts-cli/package.json"));return s.join(n,e.bin)}function M(e){let n=e.slice(2),r=n[0];(!r||r.startsWith("--"))&&(console.error("Usage: scaffold.js <template-id> [--package-manager npm|pnpm|yarn]"),t.exit(1));let i=n.indexOf("--package-manager"),o=i!==-1?n[i+1]??"":"";return{templateId:r,packageManager:o}}var b=new Set(["node_modules",".git",".netlify",".claude",".next","dist","build",".cache"]);function D(e,n=4){let r=[];function i(o,l){if(l>n)return;let g;try{g=w(o).sort()}catch{return}for(let f of g){if(b.has(f))continue;let a=s.join(o,f),p=s.relative(e,a),d=!1;try{d=I(a).isDirectory()}catch{continue}d?(r.push(p+"/"),i(a,l+1)):r.push(p)}}return i(e,0),r.join(`
-`)}var{templateId:h,packageManager:c}=M(t.argv),O=x(),R=t.env.NVM_BIN?`${t.env.NVM_BIN}/node`:"node",k=[O,"--target-dir","./","--no-git","--json","--add-ons",h];c&&k.push("--package-manager",c);var y=S(R,k,{stdio:"inherit"});y.status!==0&&t.exit(y.status??1);var j={template:h,packageManager:c};try{N(s.join(t.cwd(),".netlify"),{recursive:!0}),m(s.join(t.cwd(),".netlify","scaffold-result.json"),JSON.stringify(j));let e=D(t.cwd());m(s.join(t.cwd(),".netlify","scaffold-tree.md"),e)}catch{}console.log(JSON.stringify(j));
+import{spawnSync as w}from"child_process";import{existsSync as N,readdirSync as j,statSync as x,writeFileSync as k,mkdirSync as _}from"fs";import{createRequire as v}from"module";import n from"path";import t from"process";var A=".axis-scaffold-skip-install",h=v(import.meta.url);function L(){let e=h("@netlify/ts-cli/package.json"),s=n.dirname(h.resolve("@netlify/ts-cli/package.json"));return n.join(s,e.bin)}function O(e){let s=e.slice(2),r=s[0];(!r||r.startsWith("--"))&&(console.error("Usage: scaffold.js <template-id> [--package-manager npm|pnpm|yarn]"),t.exit(1));let o=s.indexOf("--package-manager"),a=o!==-1?s[o+1]??"":"";return{templateId:r,packageManager:a}}var T=new Set(["node_modules",".git",".netlify",".claude",".next","dist","build",".cache"]);function F(e,s=4){let r=[];function o(a,g){if(g>s)return;let m;try{m=j(a).sort()}catch{return}for(let p of m){if(T.has(p))continue;let c=n.join(a,p),y=n.relative(e,c),S=!1;try{S=x(c).isDirectory()}catch{continue}S?(r.push(y+"/"),o(c,g+1)):r.push(y)}}return o(e,0),r.join(`
+`)}var{templateId:d,packageManager:l}=O(t.argv),C=L(),D=t.env.NVM_BIN?`${t.env.NVM_BIN}/node`:"node",u=[C,"--target-dir","./","--no-git","--json","--add-ons",d];l&&u.push("--package-manager",l);var I=t.env.AXIS_WORKSPACE,E=I!==void 0&&N(n.join(I,A));(t.env.NETLIFY_SCAFFOLD_NO_INSTALL==="1"||E)&&u.push("--no-install");var i=w(D,u,{stdio:["inherit","pipe","inherit"],encoding:"utf8"});i.status!==0&&(i.stdout&&t.stdout.write(i.stdout),t.exit(i.status??1));var f;try{f=JSON.parse(i.stdout)?.starter?.framework}catch{i.stdout&&t.stdout.write(i.stdout)}var M={template:d,packageManager:l};try{_(n.join(t.cwd(),".netlify"),{recursive:!0}),k(n.join(t.cwd(),".netlify","scaffold-result.json"),JSON.stringify(M));let e=F(t.cwd());k(n.join(t.cwd(),".netlify","scaffold-tree.md"),e)}catch{}var R=f?` (${f})`:"";console.log(`\u2713 Scaffolded "${d}" template${R}. File tree: .netlify/scaffold-tree.md`);
 //# sourceMappingURL=scaffold.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@netlify/agent-runner-cli",
   "type": "module",
-  "version": "1.119.11-alpha.0",
+  "version": "1.119.12-alpha.0",
   "description": "CLI tool for running Netlify agents",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -65,6 +65,7 @@
     "@commitlint/config-conventional": "^20.0.0",
     "@eslint/compat": "^2.0.0",
     "@eslint/js": "^9.35.0",
+    "@netlify/axis": "^1.11.0",
     "@netlify/eslint-config-node": "^7.0.1",
     "@types/node": "^24.5.0",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -74,6 +75,7 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-n": "^17.0.0",
     "husky": "^9.0.0",
+    "jiti": "^2.7.0",
     "patch-package": "^8.0.0",
     "tsup": "^8.5.0",
     "typescript": "^5.0.0",

package/scripts/scenarios/install-skills.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * Installs the orchestrator's bundled skills into the agent's skill directory
+ * by calling `setupAgentSkills` from `src/context.js` — the same function the
+ * orchestrator itself uses at runtime. Intended to run as an axis scenario
+ * setup action when the scenario wants to A/B with-skills vs without.
+ *
+ * Uses `jiti` to import the orchestrator source directly so we don't need a
+ * pre-built `dist/` (context.js transitively imports several `.ts` modules
+ * that plain Node ESM can't resolve).
+ *
+ * Usage:
+ *   node install-skills.mjs [--agent claude-code|codex|gemini] [--target-dir <abs>]
+ *
+ * Omit `--agent` to install for all known agents in one pass.
+ */
+import process from 'node:process'
+import { parseArgs } from 'node:util'
+
+import { createJiti } from 'jiti'
+
+const jiti = createJiti(import.meta.url, { interopDefault: true })
+const { setupAgentSkills, resetSkillsCache } = await jiti.import('../../src/context.js')
+
+// Axis adapter name → orchestrator runner key (matches `AGENT_SKILLS_DIRS` in src/context.js).
+const RUNNER_BY_AGENT = {
+  'claude-code': 'claude',
+  codex: 'codex',
+  gemini: 'gemini',
+}
+
+const ALL_AGENTS = Object.keys(RUNNER_BY_AGENT)
+
+const main = async () => {
+  const { values } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      agent: { type: 'string' },
+      'target-dir': { type: 'string' },
+    },
+    strict: false,
+  })
+
+  const agents = values.agent ? [values.agent] : ALL_AGENTS
+
+  for (const agent of agents) {
+    const runner = RUNNER_BY_AGENT[agent] ?? agent
+    resetSkillsCache()
+    const installed = await setupAgentSkills(runner, values['target-dir'] ? { targetDir: values['target-dir'] } : {})
+    process.stderr.write(`[install-skills] ${runner}: ${installed.length} skill(s)\n`)
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`[install-skills] error: ${err.message ?? err}\n`)
+  process.exit(1)
+})

package/scripts/scenarios/netlify-deploy.mjs

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+/**
+ * Shared teardown script for axis scenarios.
+ *
+ * Looks up (or creates) a Netlify site by name, zips the workspace source, and
+ * POSTs the zip to `/sites/{site_id}/builds` so Netlify builds and deploys it
+ * server-side. Writes a small markdown block to `$AXIS_OUTPUT` so the deploy
+ * URL is rendered in the axis report.
+ *
+ * Quiet by design: prints nothing on success aside from the JSON summary on
+ * stdout. Errors include the raw argv to make argument-passing problems
+ * obvious without leaving routine runs noisy.
+ *
+ * Usage:
+ *   node netlify-deploy.mjs --name axis-<slug> [--dir .] [--account <id-or-slug>] [--message "…"] [--branch axis-preview]
+ *
+ * Requires: NETLIFY_AUTH_TOKEN env var, and the `zip` binary on PATH.
+ */
+import { execFile } from 'node:child_process'
+import { appendFile, mkdtemp, readFile, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import process from 'node:process'
+import { parseArgs, promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+
+const NETLIFY_API = 'https://api.netlify.com/api/v1'
+
+const IGNORE_PATTERNS = [
+  'node_modules*',
+  '.git*',
+  '.netlify*',
+  '.next*',
+  'dist*',
+  'build*',
+  '.nuxt*',
+  '.output*',
+  '.vercel*',
+  '__pycache__*',
+  '.venv*',
+  '.env',
+  '.DS_Store',
+  'Thumbs.db',
+  '*.log',
+  '.nyc_output*',
+  'coverage*',
+  '.cache*',
+  '.tmp*',
+  '.temp*',
+]
+
+const SITE_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/
+
+const rawArgv = process.argv.slice(2)
+
+/**
+ * DNS subdomain labels max out at 63 characters. Netlify deploy preview URLs
+ * are `https://<branch>--<site>.netlify.app`, so `branch + '--' + site` has
+ * to fit within that limit. We leave one byte of margin (62) so we don't
+ * trip any stricter Netlify-side checks.
+ */
+const SUBDOMAIN_MAX = 62
+/** Random suffix chars to keep each axis run unique without overwriting previous deploys. */
+const HEX_LEN = 4
+
+const slugifyBranch = (value) =>
+  String(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+
+/**
+ * Default branch from `AXIS_AGENT`/`AXIS_VARIANT` so each axis combination
+ * gets its own preview URL. Branch length is computed against the site name
+ * so the full `<branch>--<site>` subdomain stays within
+ * {@link SUBDOMAIN_MAX} characters. When the agent+variant identifier is
+ * too long to fit, it is truncated from the right (variant first, then
+ * agent), keeping enough room for the hex prefix on every run.
+ */
+const envDefaultBranch = (siteName = '') => {
+  const { AXIS_AGENT, AXIS_VARIANT } = process.env
+  const parts = [AXIS_AGENT, AXIS_VARIANT].filter(Boolean).map(slugifyBranch).filter(Boolean)
+  const joinedRaw = parts.length ? parts.join('-') : 'axis-preview'
+
+  // budget = SUBDOMAIN_MAX − "--" − siteName − hex − "-" between hex and joined
+  const hexOverhead = HEX_LEN + 1
+  const maxJoinedLen = Math.max(1, SUBDOMAIN_MAX - 2 - siteName.length - hexOverhead)
+  const joined = joinedRaw.slice(0, maxJoinedLen).replace(/-+$/, '')
+
+  const hex = Math.random().toString(16).slice(2, 2 + HEX_LEN)
+  return `${hex}-${joined}`
+}
+
+/** Default message describes the axis combination so Netlify deploy lists are scannable. */
+const envDefaultMessage = () => {
+  const { AXIS_AGENT, AXIS_MODEL, AXIS_VARIANT } = process.env
+  const parts = []
+  if (AXIS_AGENT) parts.push(`agent=${AXIS_AGENT}`)
+  if (AXIS_MODEL) parts.push(`model=${AXIS_MODEL}`)
+  if (AXIS_VARIANT) parts.push(`variant=${AXIS_VARIANT}`)
+  return parts.length ? `axis · ${parts.join(' · ')}` : 'axis scenario teardown'
+}
+
+const readCliOptions = () => {
+  const { values } = parseArgs({
+    args: rawArgv,
+    options: {
+      name: { type: 'string' },
+      dir: { type: 'string', default: '.' },
+      account: { type: 'string' },
+      message: { type: 'string' },
+      branch: { type: 'string' },
+    },
+    strict: false,
+  })
+  return {
+    ...values,
+    message: values.message ?? envDefaultMessage(),
+    branch: values.branch ?? envDefaultBranch(typeof values.name === 'string' ? values.name : ''),
+  }
+}
+
+const validateName = (name) => {
+  if (typeof name !== 'string' || name.length === 0) {
+    throw new Error(`--name must be a non-empty string. Got: ${typeof name} ${JSON.stringify(name)}`)
+  }
+  if (!SITE_NAME_PATTERN.test(name)) {
+    throw new Error(
+      `--name "${name}" is not a valid Netlify subdomain. ` +
+        `Must be lowercase letters/digits/hyphens, 1-63 chars, no leading or trailing hyphen.`,
+    )
+  }
+}
+
+const apiFetch = async (path, init = {}) => {
+  const url = path.startsWith('http') ? path : `${NETLIFY_API}${path}`
+  const res = await fetch(url, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${process.env.NETLIFY_AUTH_TOKEN}`,
+      'Content-Type': 'application/json',
+      ...(init.headers ?? {}),
+    },
+  })
+  if (!res.ok) {
+    const body = await res.text().catch(() => '')
+    throw new Error(`${init.method ?? 'GET'} ${path} → ${res.status}: ${body}`)
+  }
+  if (res.status === 204) return null
+  return res.json()
+}
+
+const NETLIFY_ID_PATTERN = /^[a-f0-9]{24}$/i
+
+let cachedAccountSlug
+const resolveAccountSlug = async (idOrSlug) => {
+  if (!idOrSlug) return undefined
+  if (!NETLIFY_ID_PATTERN.test(idOrSlug)) return idOrSlug
+  if (cachedAccountSlug) return cachedAccountSlug
+  const accounts = await apiFetch('/accounts')
+  if (!Array.isArray(accounts)) throw new Error('GET /accounts returned non-array')
+  const match = accounts.find((a) => a.id === idOrSlug)
+  if (!match) {
+    throw new Error(`Netlify account id ${idOrSlug} is not accessible by this token (NETLIFY_AUTH_TOKEN).`)
+  }
+  cachedAccountSlug = match.slug
+  return cachedAccountSlug
+}
+
+const findSiteByName = async (name, accountSlug) => {
+  const params = new URLSearchParams({ filter: 'all', name })
+  if (accountSlug) params.set('account_slug', accountSlug)
+  const sites = await apiFetch(`/sites?${params.toString()}`)
+  if (!Array.isArray(sites)) return null
+  return sites.find((s) => s.name === name) ?? null
+}
+
+const isSubdomainTakenError = (err) =>
+  /\b422\b/.test(String(err?.message ?? '')) && /subdomain.*must be unique/i.test(String(err?.message ?? ''))
+
+const createSite = async (name, accountSlug) => {
+  const path = accountSlug ? `/${encodeURIComponent(accountSlug)}/sites` : '/sites'
+  return apiFetch(path, { method: 'POST', body: JSON.stringify({ name }) })
+}
+
+const lookupOrCreateSite = async (name, accountSlug) => {
+  const existing = await findSiteByName(name, accountSlug)
+  if (existing) return existing
+  try {
+    return await createSite(name, accountSlug)
+  } catch (err) {
+    if (!isSubdomainTakenError(err)) throw err
+    const retry = await findSiteByName(name, accountSlug)
+    if (retry) return retry
+    throw new Error(
+      `Netlify site name '${name}' is taken by another account this token cannot access. ` +
+        `Pick a different siteName or grant this token access to the existing site.`,
+    )
+  }
+}
+
+const ensureSourceDir = async (dir) => {
+  let info
+  try {
+    info = await stat(dir)
+  } catch (err) {
+    throw new Error(`source dir does not exist: ${dir} (${err.code})`)
+  }
+  if (!info.isDirectory()) throw new Error(`source dir is not a directory: ${dir}`)
+}
+
+const zipSource = async (sourceDir) => {
+  const tmp = await mkdtemp(join(tmpdir(), 'axis-deploy-'))
+  const zipPath = join(tmp, 'source.zip')
+  const excludeArgs = IGNORE_PATTERNS.flatMap((p) => ['-x', p])
+  await execFileAsync('zip', ['-r', '-q', zipPath, '.', ...excludeArgs], {
+    cwd: sourceDir,
+    maxBuffer: 100 * 1024 * 1024,
+  })
+  return zipPath
+}
+
+const triggerBuildFromZip = async ({ siteId, zipPath, title, branch }) => {
+  const body = await readFile(zipPath)
+  const params = new URLSearchParams({ title })
+  if (branch) params.set('branch', branch)
+  const url = `${NETLIFY_API}/sites/${siteId}/builds?${params.toString()}`
+  const res = await fetch(url, {
+    method: 'POST',
+    body,
+    headers: {
+      Authorization: `Bearer ${process.env.NETLIFY_AUTH_TOKEN}`,
+      'Content-Type': 'application/zip',
+      'Content-Length': String(body.length),
+    },
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => '')
+    throw new Error(`POST /sites/${siteId}/builds → ${res.status}: ${text}`)
+  }
+  return res.json()
+}
+
+const fetchDeploy = async (deployId) => {
+  try {
+    return await apiFetch(`/deploys/${deployId}`)
+  } catch {
+    return null
+  }
+}
+
+const writeAxisOutput = async (markdown) => {
+  const path = process.env.AXIS_OUTPUT
+  if (!path) return
+  await appendFile(path, markdown.endsWith('\n') ? markdown : `${markdown}\n`)
+}
+
+/**
+ * Markdown body appended to `$AXIS_OUTPUT`. Renders as clickable links in the
+ * axis report. Falls back gracefully when fields are still provisioning.
+ */
+const buildReportMarkdown = ({ siteName, site, build, deploy, branch }) => {
+  const previewUrl = deploy?.deploy_ssl_url || deploy?.deploy_url
+  const branchUrl = branch && site?.ssl_url ? site.ssl_url.replace(/^https:\/\//, `https://${branch}--`) : null
+  const liveUrl = previewUrl || branchUrl
+  const adminLogsUrl = `${site.admin_url}/deploys/${build.deploy_id}`
+  const sitePageUrl = site.admin_url
+
+  const links = []
+  if (liveUrl) links.push(`[Live preview](${liveUrl})`)
+  links.push(`[Build logs](${adminLogsUrl})`)
+  links.push(`[Site dashboard](${sitePageUrl})`)
+
+  return `## Netlify deploy — \`${siteName}\`\n\n${links.join(' · ')}\n`
+}
+
+const main = async () => {
+  const { name, dir, account, message, branch } = readCliOptions()
+  validateName(name)
+  if (!process.env.NETLIFY_AUTH_TOKEN) throw new Error('NETLIFY_AUTH_TOKEN is not set')
+
+  await ensureSourceDir(dir)
+  const accountSlug = await resolveAccountSlug(account)
+  const site = await lookupOrCreateSite(name, accountSlug)
+  const zipPath = await zipSource(dir)
+  const build = await triggerBuildFromZip({ siteId: site.id, zipPath, title: message, branch })
+  const deploy = await fetchDeploy(build.deploy_id)
+
+  await writeAxisOutput(buildReportMarkdown({ siteName: name, site, build, deploy, branch }))
+
+  process.stdout.write(
+    JSON.stringify({
+      siteId: site.id,
+      siteName: site.name,
+      siteUrl: site.ssl_url || site.url,
+      buildId: build.id,
+      deployId: build.deploy_id,
+      deployUrl: deploy?.deploy_ssl_url || deploy?.deploy_url,
+      adminLogsUrl: `${site.admin_url}/deploys/${build.deploy_id}`,
+    }) + '\n',
+  )
+}
+
+main().catch((err) => {
+  // Include argv on error so argument-passing bugs (e.g. shells dropping a
+  // quoted value) are visible without dumping argv on every successful run.
+  process.stderr.write(`[deploy] error: ${err.message ?? err}\n`)
+  process.stderr.write(`[deploy] argv: ${JSON.stringify(rawArgv)}\n`)
+  process.exit(1)
+})

package/scripts/scenarios/prewarm-template-mirror.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Populates a per-scenario local mirror of `netlify/swar-templates` inside the
+ * current AXIS workspace, at the path `@netlify/ts-cli` falls back to when its
+ * GitHub fetch is blocked by the agent sandbox.
+ *
+ * The path comes from the same constant the create-mode prompt uses
+ * (`TS_CLI_TEMPLATE_MIRROR_FALLBACK_BASE` in `src/stages/create.ts`), passed
+ * in via env so production and axis stay in sync without this script having
+ * to import TypeScript.
+ *
+ * Env vars:
+ *   - `AXIS_WORKSPACE` — set by axis on every lifecycle script; the
+ *     scenario's workspace dir.
+ *   - `TS_CLI_TEMPLATE_MIRROR_BASE` — passed by the helper that schedules
+ *     this script (`scenarioPrewarmTemplateMirror` in
+ *     `scenarios/helpers/scenario-prompts.ts`); should match the default
+ *     value emitted in the create-mode scaffold command.
+ *
+ * ts-cli wipes the mirror via `cleanupLocalMirror()` after each scaffold, but
+ * that's fine — axis tears the workspace down at the end of the scenario, so
+ * the mirror has no lifetime beyond a single ts-cli run.
+ */
+import { execSync } from 'node:child_process'
+import { existsSync, mkdirSync } from 'node:fs'
+import { dirname, isAbsolute, join, resolve } from 'node:path'
+import process from 'node:process'
+
+const REPO = 'https://github.com/netlify/swar-templates.git'
+
+const workspace = process.env.AXIS_WORKSPACE
+const mirrorBase = process.env.TS_CLI_TEMPLATE_MIRROR_BASE
+
+if (!workspace) {
+  process.stderr.write('[prewarm-template-mirror] AXIS_WORKSPACE is not set (run this from an axis setup phase)\n')
+  process.exit(1)
+}
+if (!mirrorBase) {
+  process.stderr.write(
+    '[prewarm-template-mirror] TS_CLI_TEMPLATE_MIRROR_BASE is not set (pass it via the scenario helper)\n',
+  )
+  process.exit(1)
+}
+
+const absBase = isAbsolute(mirrorBase) ? mirrorBase : resolve(workspace, mirrorBase)
+const mirrorDir = join(absBase, 'cache', 'cwd', 'swar-templates')
+const manifestPath = join(mirrorDir, 'manifest.json')
+
+if (existsSync(manifestPath)) {
+  process.stderr.write(`[prewarm-template-mirror] mirror already populated at ${mirrorDir}\n`)
+  process.exit(0)
+}
+
+mkdirSync(dirname(mirrorDir), { recursive: true })
+process.stderr.write(`[prewarm-template-mirror] cloning ${REPO} → ${mirrorDir}\n`)
+
+try {
+  execSync(`git clone --depth 1 "${REPO}" "${mirrorDir}"`, { stdio: 'inherit' })
+} catch (err) {
+  process.stderr.write(`[prewarm-template-mirror] git clone failed: ${err.message ?? err}\n`)
+  process.exit(1)
+}
+
+if (!existsSync(manifestPath)) {
+  process.stderr.write(`[prewarm-template-mirror] clone succeeded but ${manifestPath} is missing\n`)
+  process.exit(1)
+}
+
+process.stderr.write(`[prewarm-template-mirror] ready at ${mirrorDir}\n`)