tovuk 0.1.47

package/src/internal/deploy.ts

@@ -0,0 +1,154 @@
+import { agentError } from './errors.ts'
+import { apiRequest } from './api.ts'
+import { buildStatusResponseFromJson, deployResponseFromJson } from './api-models.ts'
+import { createArchiveBase64, gitCommitSha } from './archive.ts'
+import { readOrLoginToken } from './auth.ts'
+import { createDeployPlan } from './deploy-plan.ts'
+import { runDoctor } from './doctor.ts'
+import { discoverDeployProjects } from './workspace.ts'
+import { printJson, progress, sleep } from './project.ts'
+import type {
+  BuildRecord,
+  CliOptions,
+  DeployPlanProject,
+  DeployResponse,
+  JsonObject,
+  WorkspaceDeployResult
+} from './types.ts'
+
+async function deploy(projectDir: string, cli: CliOptions): Promise<void> {
+  const projects = discoverDeployProjects(projectDir)
+  if (projects.length === 0) {
+    throw agentError('missing_project_contract', 'No tovuk.toml was found.', 'Run `npx tovuk init` in each app directory, or pass a project path.', cli.json)
+  }
+
+  const token = await readOrLoginToken(cli)
+  const plan = await createDeployPlan(projects, cli, token)
+  const results = await deployProjects(plan, cli, token)
+
+  if (cli.wait) {
+    await waitForWorkspaceBuilds(cli, token, results)
+  }
+
+  const singleResult = results.length === 1 ? results[0] : undefined
+  if (singleResult) {
+    printDeployResult(singleResult.response, cli)
+    return
+  }
+
+  printWorkspaceDeployResults(projectDir, results, cli)
+}
+
+async function deployProjects(plan: DeployPlanProject[], cli: CliOptions, token: string): Promise<WorkspaceDeployResult[]> {
+  const results: WorkspaceDeployResult[] = []
+  const workspaceDeploy = plan.length > 1
+  if (workspaceDeploy && !cli.json) {
+    console.log(`deploying ${plan.length} projects`)
+  }
+
+  for (const { project, wantsDatabase } of plan) {
+    if (workspaceDeploy && !cli.json) {
+      console.log(`checking ${project.relative}`)
+    }
+    const response = await deployProject(project.dir, cli, token, wantsDatabase)
+    results.push({ project, wantsDatabase, response })
+    if (workspaceDeploy && !cli.json) {
+      console.log(`${project.relative} queued ${response.build_job.id}`)
+      console.log(`${project.relative} url ${response.app.url}`)
+    }
+  }
+
+  return results
+}
+
+async function deployProject(projectDir: string, cli: CliOptions, token: string, wantsDatabase: boolean): Promise<DeployResponse> {
+  const report = runDoctor(projectDir)
+  if (!report.ok) {
+    const firstFailure = report.checks.find((check) => !check.ok)
+    throw agentError('doctor_failed', 'Tovuk doctor failed.', firstFailure?.agent_instruction ?? 'Fix the failed checks and retry.', cli.json)
+  }
+
+  const body: JsonObject = {
+    config: report.config,
+    commit_sha: gitCommitSha(projectDir),
+    wants_database: wantsDatabase,
+    source_archive_base64: createArchiveBase64(projectDir)
+  }
+
+  return deployResponseFromJson(await apiRequest(cli, 'POST', '/v1/deploy', token, body))
+}
+
+function printDeployResult(response: DeployResponse, cli: CliOptions): void {
+  if (cli.json) {
+    printJson(response)
+    return
+  }
+
+  console.log(`queued ${response.build_job.id}`)
+  console.log(`app ${response.app.id}`)
+  console.log(`url ${response.app.url}`)
+  console.log(`next npx tovuk logs --app ${response.app.id}`)
+}
+
+function printWorkspaceDeployResults(projectDir: string, results: WorkspaceDeployResult[], cli: CliOptions): void {
+  if (cli.json) {
+    printJson({
+      workspace: projectDir,
+      deploys: results.map((result) => ({
+        path: result.project.relative,
+        kind: result.project.kind,
+        wants_database: result.wantsDatabase,
+        app: result.response.app,
+        build_job: result.response.build_job,
+        final_build: result.finalBuild ?? null
+      }))
+    })
+    return
+  }
+
+  const firstApp = results[0]?.response.app.id
+  if (firstApp) {
+    console.log(`next npx tovuk logs --app ${firstApp}`)
+  }
+}
+
+async function waitForWorkspaceBuilds(cli: CliOptions, token: string, results: WorkspaceDeployResult[]): Promise<void> {
+  await Promise.all(results.map(async (result): Promise<void> => {
+    const finalBuild = await waitForBuild(cli, token, result.response.build_job.id)
+    result.finalBuild = finalBuild
+    result.response.final_build = finalBuild
+  }))
+}
+
+async function waitForBuild(cli: CliOptions, token: string, buildId: string): Promise<BuildRecord> {
+  const deadline = Date.now() + cli.waitTimeoutSeconds * 1000
+  let lastStatus = ''
+
+  while (Date.now() <= deadline) {
+    const response = buildStatusResponseFromJson(await apiRequest(cli, 'GET', `/v1/builds/${encodeURIComponent(buildId)}`, token, null))
+    const build = response.build
+    if (!build?.status) {
+      throw agentError('build_status_unavailable', 'Build status is unavailable.', `Retry with \`npx tovuk logs --build ${buildId}\`.`, cli.json)
+    }
+
+    if (build.status !== lastStatus) {
+      progress(cli, `build ${build.id} ${build.status}`)
+      lastStatus = build.status
+    }
+    if (['succeeded', 'failed', 'canceled'].includes(build.status)) {
+      return build
+    }
+    await sleep(3000)
+  }
+
+  throw agentError(
+    'build_wait_timeout',
+    `Timed out waiting for build ${buildId}.`,
+    `Run \`npx tovuk logs --build ${buildId}\` to continue watching.`,
+    cli.json
+  )
+}
+
+export {
+  deploy
+}

package/src/internal/doctor.ts

@@ -0,0 +1,146 @@
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { doctorCheck } from './checks.ts'
+import { agentError } from './errors.ts'
+import { parseTovukToml, validateConfig } from './config.ts'
+import { discoverDeployProjects } from './workspace.ts'
+import { printJson } from './project.ts'
+import { rustDoctorChecks, unsafeCheck } from './rust-doctor.ts'
+import { frontendLockfileExists, frontendScriptChecks, frontendSourceChecks } from './frontend-policy.ts'
+import type { DoctorCheck, DoctorReport, WorkspaceDoctorReport, TovukConfig } from './types.ts'
+
+function doctorProject(projectDir: string, json: boolean): void {
+  const report = runDoctorWorkspace(projectDir)
+  if (json) {
+    printJson(report)
+    if (!report.ok) {
+      process.exitCode = 1
+    }
+    return
+  }
+
+  printDoctorReport(report)
+
+  if (!report.ok) {
+    const firstFailure = doctorChecks(report).find((check) => !check.ok)
+    throw agentError('doctor_failed', 'Tovuk doctor failed.', firstFailure?.agent_instruction || 'Fix the failed checks and retry `npx tovuk doctor`.', json)
+  }
+}
+
+function runDoctorWorkspace(projectDir: string): DoctorReport | WorkspaceDoctorReport {
+  if (existsSync(path.join(projectDir, 'tovuk.toml'))) {
+    return runDoctor(projectDir)
+  }
+
+  const projects = discoverDeployProjects(projectDir)
+  if (projects.length === 0) {
+    return runDoctor(projectDir)
+  }
+
+  const reports = projects.map((project) => {
+    const report = runDoctor(project.dir)
+    return {
+      relative: project.relative,
+      ok: report.ok,
+      project: report.project,
+      config: report.config,
+      checks: report.checks
+    }
+  })
+  return {
+    ok: reports.every((report) => report.ok),
+    workspace: projectDir,
+    projects: reports
+  }
+}
+
+function runDoctor(projectDir: string): DoctorReport {
+  const configResult = readConfig(projectDir)
+  const checks: DoctorCheck[] = [configResult.check]
+  const kind = configResult.config?.kind || 'rust_backend'
+  checks.push(...requiredFileChecks(projectDir, kind))
+  if (kind === 'static_frontend') {
+    checks.push(frontendLockfileCheck(projectDir))
+    checks.push(...frontendSourceChecks(projectDir))
+    checks.push(...frontendScriptChecks(projectDir, configResult.valid))
+  } else {
+    checks.push(...rustDoctorChecks(projectDir, configResult.valid))
+  }
+
+  if (kind === 'static_frontend') {
+    checks.push(unsafeCheck(projectDir))
+  }
+
+  return {
+    ok: checks.every((check) => check.ok),
+    project: projectDir,
+    config: configResult.config,
+    checks
+  }
+}
+
+function printDoctorReport(report: DoctorReport | WorkspaceDoctorReport): void {
+  if (isWorkspaceDoctorReport(report)) {
+    report.projects.forEach(printProjectReport)
+    return
+  }
+  printChecks(report.checks)
+}
+
+function printProjectReport(report: DoctorReport & { relative: string }): void {
+  console.log(`project ${report.relative}`)
+  printChecks(report.checks)
+}
+
+function printChecks(checks: readonly DoctorCheck[]): void {
+  for (const check of checks) {
+    console.log(`${check.ok ? 'ok' : 'fail'} ${check.name}${check.message ? ` - ${check.message}` : ''}`)
+  }
+}
+
+function doctorChecks(report: DoctorReport | WorkspaceDoctorReport): DoctorCheck[] {
+  return isWorkspaceDoctorReport(report)
+    ? report.projects.flatMap((project) => project.checks)
+    : report.checks
+}
+
+function readConfig(projectDir: string): { check: DoctorCheck; config: TovukConfig | null; valid: boolean } {
+  const configPath = path.join(projectDir, 'tovuk.toml')
+  if (!existsSync(configPath)) {
+    return {
+      check: { name: 'tovuk.toml', ok: false, message: 'missing', agent_instruction: 'Create and commit tovuk.toml, then retry.' },
+      config: null,
+      valid: false
+    }
+  }
+  try {
+    const config = parseTovukToml(readFileSync(configPath, 'utf8'), projectDir)
+    validateConfig(config)
+    return { check: { name: 'tovuk.toml', ok: true, message: 'valid', agent_instruction: null }, config, valid: true }
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error)
+    return { check: { name: 'tovuk.toml', ok: false, message, agent_instruction: `Fix tovuk.toml: ${message}.` }, config: null, valid: false }
+  }
+}
+
+function requiredFileChecks(projectDir: string, kind: TovukConfig['kind']): DoctorCheck[] {
+  return requiredFiles(kind).map((file) => {
+    const ok = existsSync(path.join(projectDir, file))
+    return doctorCheck(file, ok, 'found', 'missing', `Create and commit ${file}, then retry.`)
+  })
+}
+
+function requiredFiles(kind: TovukConfig['kind']): string[] {
+  return kind === 'static_frontend' ? ['package.json'] : ['Cargo.toml', 'Cargo.lock']
+}
+
+function frontendLockfileCheck(projectDir: string): DoctorCheck {
+  const ok = frontendLockfileExists(projectDir)
+  return doctorCheck('frontend lockfile', ok, 'found', 'missing', 'Commit package-lock.json, pnpm-lock.yaml, yarn.lock, bun.lock, or bun.lockb, then retry.')
+}
+
+function isWorkspaceDoctorReport(report: DoctorReport | WorkspaceDoctorReport): report is WorkspaceDoctorReport {
+  return 'projects' in report
+}
+
+export { doctorProject, runDoctor, runDoctorWorkspace }

package/src/internal/errors.ts

@@ -0,0 +1,46 @@
+
+
+import type { AgentErrorPayload } from './types.ts'
+
+function agentError(code: string, message: string, agentInstruction: string, json: boolean): TovukError {
+  return new TovukError({
+    code,
+    message,
+    agent_instruction: agentInstruction,
+    docs_url: null,
+    checkout_url: null
+  }, json, 1)
+}
+
+function printAgentError(payload: AgentErrorPayload, json: boolean): void {
+  if (json) {
+    console.error(JSON.stringify(payload, null, 2))
+    return
+  }
+
+  console.error(payload.message || 'Tovuk command failed.')
+  if (payload.agent_instruction) {
+    console.error(`agent_instruction: ${payload.agent_instruction}`)
+  }
+  if (payload.docs_url) {
+    console.error(`docs: ${payload.docs_url}`)
+  }
+  if (payload.checkout_url) {
+    console.error(`checkout: ${payload.checkout_url}`)
+  }
+}
+
+class TovukError extends Error {
+  payload: AgentErrorPayload
+  json: boolean
+  exitCode: number
+
+  constructor(payload: AgentErrorPayload, json: boolean, exitCode: number) {
+    super(payload.message || 'Tovuk command failed.')
+    this.payload = payload
+    this.json = json
+    this.exitCode = exitCode
+  }
+}
+
+export { agentError, printAgentError, TovukError }

package/src/internal/frontend-policy.ts

@@ -0,0 +1,272 @@
+import { existsSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import path from 'node:path'
+import { doctorCheck } from './checks.ts'
+import { DEFAULT_BUN_FRONTEND_CHECK_COMMAND, DEFAULT_NPM_FRONTEND_CHECK_COMMAND, FRONTEND_INSTALL_COMMANDS, FRONTEND_JAVASCRIPT_EXTENSIONS, FRONTEND_PACKAGE_MANAGERS, FRONTEND_SOURCE_ROOTS, JAVASCRIPT_LINTERS } from './constants.ts'
+import { readPackageJson, walkProjectFiles } from './project.ts'
+import type { DoctorCheck, FrontendSourceReport, PackageManifest } from './types.ts'
+
+const REQUIRED_FRONTEND_SCRIPTS = ['typecheck', 'lint'] as const
+type FrontendScriptName = typeof REQUIRED_FRONTEND_SCRIPTS[number]
+type CommandPredicate = (command: string) => boolean
+
+function frontendLockfileExists(projectDir: string): boolean {
+  return ['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb']
+    .some((file) => existsSync(path.join(projectDir, file)))
+}
+
+function frontendPackageManager(projectDir: string): 'bun' | 'npm' {
+  return existsSync(path.join(projectDir, 'bun.lock')) || existsSync(path.join(projectDir, 'bun.lockb'))
+    ? 'bun'
+    : 'npm'
+}
+
+function frontendCheckCommand(projectDir: string): string {
+  return frontendPackageManager(projectDir) === 'bun'
+    ? DEFAULT_BUN_FRONTEND_CHECK_COMMAND
+    : DEFAULT_NPM_FRONTEND_CHECK_COMMAND
+}
+
+function frontendBuildCommand(projectDir: string): string {
+  return frontendPackageManager(projectDir) === 'bun'
+    ? 'bun run build'
+    : 'npm run build'
+}
+
+function frontendScriptChecks(projectDir: string, runScripts: boolean): DoctorCheck[] {
+  const manifest = readPackageJson(projectDir)
+  const scripts: Record<FrontendScriptName, string> = {
+    typecheck: packageScriptValue(manifest, 'typecheck'),
+    lint: packageScriptValue(manifest, 'lint')
+  }
+  const checks: DoctorCheck[] = [
+    ...REQUIRED_FRONTEND_SCRIPTS.map((script) => packageScriptExistsCheck(script, scripts[script])),
+    strictTypecheckCheck(scripts.typecheck),
+    nativeLintCheck(manifest),
+    nativeQualityGateCheck(manifest)
+  ]
+
+  if (runScripts && checks.every((check) => check.ok)) {
+    checks.push(...REQUIRED_FRONTEND_SCRIPTS.map((script) => packageScriptCheck(projectDir, script)))
+  }
+
+  return checks
+}
+
+function packageScriptExistsCheck(script: FrontendScriptName, command: string): DoctorCheck {
+  const ok = command !== ''
+  return doctorCheck(`package script ${script}`, ok, 'found', 'missing', `Add a non-empty "${script}" script to package.json, then retry.`)
+}
+
+function strictTypecheckCheck(command: string): DoctorCheck {
+  const ok = usesStrictFrontendTypechecker(command)
+  return doctorCheck('strict frontend typecheck', ok, 'accepted', 'native typecheck missing', 'Set package.json `typecheck` to `oxlint src vite.config.ts --deny-warnings --type-aware --type-check --tsconfig tsconfig.json`, then retry.')
+}
+
+function nativeLintCheck(manifest: PackageManifest | null): DoctorCheck {
+  const ok = !packageScriptTreeUses(manifest, 'lint', usesJavascriptLinter)
+    && packageScriptTreeUses(manifest, 'lint', usesNativeFrontendLinter)
+  return doctorCheck('native frontend lint', ok, 'accepted', 'native linter missing', 'Replace the lint script with native tooling such as `oxlint src vite.config.ts --deny-warnings`, `biome check .`, or `deno lint`, then retry.')
+}
+
+function nativeQualityGateCheck(manifest: PackageManifest | null): DoctorCheck {
+  const ok = packageScriptTreeUses(manifest, 'lint', usesNativeDeadCodeChecker)
+    && packageScriptTreeUses(manifest, 'lint', usesNativeDuplicateChecker)
+    && packageScriptTreeUses(manifest, 'lint', usesNativeHealthChecker)
+  return doctorCheck('native frontend quality gates', ok, 'accepted', 'dead-code, duplicate-code, or health gate missing', 'Add Fallow checks for `dead-code`, semantic `dupes`, and `health` to package.json `lint`, then retry.')
+}
+
+function frontendSourceChecks(projectDir: string): DoctorCheck[] {
+  const report = frontendSourceReport(projectDir)
+  return [
+    {
+      name: 'typescript source',
+      ok: report.typescript.length > 0,
+      message: report.typescript.length > 0 ? report.typescript.slice(0, 3).join(', ') : 'missing',
+      agent_instruction: report.typescript.length > 0 ? null : 'Add browser source as .ts or .tsx under src, app, pages, routes, or components, then retry.'
+    },
+    {
+      name: 'javascript source',
+      ok: report.javascript.length === 0,
+      message: report.javascript.length === 0 ? 'none found' : report.javascript.slice(0, 5).join(', '),
+      agent_instruction: report.javascript.length === 0 ? null : 'Rename browser .js, .jsx, .mjs, or .cjs source files to .ts or .tsx and fix type errors before deploying.'
+    }
+  ]
+}
+
+function frontendSourceReport(projectDir: string): FrontendSourceReport {
+  const report: FrontendSourceReport = { typescript: [], javascript: [] }
+  walkProjectFiles(projectDir, (_file, relative) => {
+    const sourceKind = frontendSourceKind(relative)
+    if (sourceKind) {
+      report[sourceKind].push(relative)
+    }
+  })
+  return report
+}
+
+function frontendSourceKind(relative: string): keyof FrontendSourceReport | null {
+  if (!isFrontendSourcePath(relative)) {
+    return null
+  }
+  if (isFrontendTypescriptSource(relative)) {
+    return 'typescript'
+  }
+  return isFrontendJavascriptSource(relative) ? 'javascript' : null
+}
+
+function isFrontendSourcePath(relative: string): boolean {
+  const [root = ''] = relative.split('/')
+  return FRONTEND_SOURCE_ROOTS.has(root)
+}
+
+function isFrontendTypescriptSource(relative: string): boolean {
+  return !relative.endsWith('.d.ts') && (relative.endsWith('.ts') || relative.endsWith('.tsx'))
+}
+
+function isFrontendJavascriptSource(relative: string): boolean {
+  return FRONTEND_JAVASCRIPT_EXTENSIONS.some((extension) => relative.endsWith(extension))
+}
+
+function packageScriptValue(manifest: PackageManifest | null, script: string): string {
+  const value = manifest?.scripts?.[script]
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function usesJavascriptLinter(command: string): boolean {
+  const tokens = commandTokens(command)
+  return tokens.some((token, index) => {
+    const commandName = commandNameFromToken(token)
+    return JAVASCRIPT_LINTERS.has(commandName)
+      || (commandName === 'next' && tokens[index + 1] === 'lint')
+  })
+}
+
+function usesStrictFrontendTypechecker(command: string): boolean {
+  const tokens = commandTokens(command)
+  return tokens.some((token, index) => {
+    const commandName = commandNameFromToken(token)
+    return (commandName === 'oxlint' && tokens.includes('--type-aware') && tokens.includes('--type-check'))
+      || (commandName === 'deno' && tokens[index + 1] === 'check')
+  })
+}
+
+function usesNativeFrontendLinter(command: string): boolean {
+  const tokens = commandTokens(command)
+  return tokens.some((token, index) => {
+    const commandName = commandNameFromToken(token)
+    return commandName === 'oxlint'
+      || (commandName === 'biome' && ['check', 'lint'].includes(tokens[index + 1] ?? ''))
+      || (commandName === 'deno' && tokens[index + 1] === 'lint')
+  })
+}
+
+function usesNativeDeadCodeChecker(command: string): boolean {
+  return usesFallowSubcommand(command, 'dead-code')
+}
+
+function usesNativeDuplicateChecker(command: string): boolean {
+  return usesFallowSubcommand(command, 'dupes')
+}
+
+function usesNativeHealthChecker(command: string): boolean {
+  return usesFallowSubcommand(command, 'health')
+}
+
+function usesFallowSubcommand(command: string, subcommand: string): boolean {
+  return commandTokens(command).some((token, index, tokens) => (
+    commandNameFromToken(token) === 'fallow' && tokens[index + 1] === subcommand
+  ))
+}
+
+function packageScriptTreeUses(manifest: PackageManifest | null, script: string, predicate: CommandPredicate, seen = new Set<string>()): boolean {
+  if (seen.has(script)) {
+    return false
+  }
+  seen.add(script)
+
+  const command = packageScriptValue(manifest, script)
+  if (command === '') {
+    return false
+  }
+  if (predicate(command)) {
+    return true
+  }
+
+  return referencedPackageScripts(command).some((referencedScript) => packageScriptTreeUses(manifest, referencedScript, predicate, seen))
+}
+
+function referencedPackageScripts(command: string): string[] {
+  const tokens = commandTokens(command)
+  const scripts: string[] = []
+  for (const [index, token] of tokens.entries()) {
+    if (!FRONTEND_PACKAGE_MANAGERS.has(commandNameFromToken(token)) || tokens[index + 1] !== 'run') {
+      continue
+    }
+    const script = scriptNameAfterRun(tokens, index + 2)
+    if (script !== null) {
+      scripts.push(script)
+    }
+  }
+  return scripts
+}
+
+function scriptNameAfterRun(tokens: readonly string[], start: number): string | null {
+  let index = start
+  while (tokens[index]?.startsWith('-')) {
+    index += 1
+  }
+  return tokens[index] ?? null
+}
+
+function commandTokens(command: string): string[] {
+  return command
+    .replace(/[&|;()]/gu, ' ')
+    .split(/\s+/u)
+    .map((token) => token.trim().replace(/^["']|["']$/gu, ''))
+    .filter(Boolean)
+}
+
+function commandNameFromToken(token: string): string {
+  return token.split('/').pop() ?? ''
+}
+
+function hasFrontendInstallCommand(tokens: string[]): boolean {
+  return tokens.some((token, index) => FRONTEND_INSTALL_COMMANDS.has(`${commandNameFromToken(token)} ${tokens[index + 1] || ''}`))
+}
+
+function hasFrontendScriptRun(tokens: string[], script: string): boolean {
+  return tokens.some((token, index) => {
+    if (!FRONTEND_PACKAGE_MANAGERS.has(commandNameFromToken(token)) || tokens[index + 1] !== 'run') {
+      return false
+    }
+    return tokens[index + 2] === script || ((tokens[index + 2] ?? '').startsWith('-') && tokens[index + 3] === script)
+  })
+}
+
+function packageScriptCheck(projectDir: string, script: string): DoctorCheck {
+  const manager = frontendPackageManager(projectDir)
+  const args = manager === 'bun' ? ['run', script] : ['run', '--silent', script]
+  const result = spawnSync(manager, args, {
+    cwd: projectDir,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  })
+  if (result.error) {
+    return {
+      name: `${manager} run ${script}`,
+      ok: false,
+      message: result.error.message,
+      agent_instruction: `Install ${manager === 'bun' ? 'Bun' : 'Node.js and npm'}, then run \`${manager} run ${script}\` before deploying.`
+    }
+  }
+
+  return {
+    name: `${manager} run ${script}`,
+    ok: result.status === 0,
+    message: result.status === 0 ? 'passed' : (result.stderr || result.stdout || `${manager} run ${script} failed`).trim().slice(0, 240),
+    agent_instruction: result.status === 0 ? null : `Run \`${manager} run ${script}\`, fix every error, then redeploy.`
+  }
+}
+
+export { frontendLockfileExists, frontendCheckCommand, frontendBuildCommand, frontendScriptChecks, frontendSourceChecks, usesJavascriptLinter, commandTokens, hasFrontendInstallCommand, hasFrontendScriptRun }