@sanity/cli 3.59.2-canary.19 → 3.59.2-corel-fix-presentation-perspective-switching.536

package/src/util/remoteTemplate.ts

@@ -0,0 +1,319 @@
+import {access, readFile, writeFile} from 'node:fs/promises'
+import {join, posix, sep} from 'node:path'
+import {Readable} from 'node:stream'
+import {pipeline} from 'node:stream/promises'
+import {type ReadableStream} from 'node:stream/web'
+
+import {ENV_TEMPLATE_FILES, REQUIRED_ENV_VAR} from '@sanity/template-validator'
+import {x} from 'tar'
+
+import {debug} from '../debug'
+import {type CliApiClient, type PackageJson} from '../types'
+
+const DISALLOWED_PATHS = [
+  // Prevent security risks from unknown GitHub Actions
+  '/.github/',
+]
+
+const ENV_VAR = {
+  ...REQUIRED_ENV_VAR,
+  READ_TOKEN: 'SANITY_API_READ_TOKEN',
+  WRITE_TOKEN: 'SANITY_API_WRITE_TOKEN',
+} as const
+
+const API_READ_TOKEN_ROLE = 'viewer'
+const API_WRITE_TOKEN_ROLE = 'editor'
+
+type EnvData = {
+  projectId: string
+  dataset: string
+  readToken?: string
+  writeToken?: string
+}
+
+type GithubUrlString =
+  | `https://github.com/${string}/${string}`
+  | `https://www.github.com/${string}/${string}`
+
+export type RepoInfo = {
+  username: string
+  name: string
+  branch: string
+  filePath: string
+}
+
+export function getGitHubRawContentUrl(repoInfo: RepoInfo): string {
+  const {username, name, branch, filePath} = repoInfo
+  return `https://raw.githubusercontent.com/${username}/${name}/${branch}/${filePath}`
+}
+
+function isGithubRepoShorthand(value: string): boolean {
+  if (URL.canParse(value)) {
+    return false
+  }
+  // This supports :owner/:repo and :owner/:repo/nested/path, e.g.
+  // sanity-io/sanity
+  // sanity-io/sanity/templates/next-js
+  // sanity-io/templates/live-content-api
+  // sanity-io/sanity/packages/@sanity/cli/test/test-template
+  return /^[\w-]+\/[\w-.]+(\/[@\w-.]+)*$/.test(value)
+}
+
+function isGithubRepoUrl(value: string | URL): value is URL | GithubUrlString {
+  if (URL.canParse(value) === false) {
+    return false
+  }
+  const url = new URL(value)
+  const pathSegments = url.pathname.slice(1).split('/')
+
+  return (
+    url.protocol === 'https:' &&
+    url.hostname === 'github.com' &&
+    // The pathname must have at least 2 segments. If it has more than 2, the
+    // third must be "tree" and it must have at least 4 segments.
+    // https://github.com/:owner/:repo
+    // https://github.com/:owner/:repo/tree/:ref
+    pathSegments.length >= 2 &&
+    (pathSegments.length > 2 ? pathSegments[2] === 'tree' && pathSegments.length >= 4 : true)
+  )
+}
+
+async function downloadTarStream(url: string, bearerToken?: string): Promise<Readable> {
+  const headers: Record<string, string> = {}
+  if (bearerToken) {
+    headers.Authorization = `Bearer ${bearerToken}`
+  }
+
+  const res = await fetch(url, {headers})
+
+  if (!res.body) {
+    throw new Error(`Failed to download: ${url}`)
+  }
+
+  return Readable.fromWeb(res.body as ReadableStream)
+}
+
+export function checkIsRemoteTemplate(templateName?: string): boolean {
+  return templateName?.includes('/') ?? false
+}
+
+export async function getGitHubRepoInfo(value: string, bearerToken?: string): Promise<RepoInfo> {
+  let username = ''
+  let name = ''
+  let branch = ''
+  let filePath = ''
+
+  if (isGithubRepoShorthand(value)) {
+    const parts = value.split('/')
+    username = parts[0]
+    name = parts[1]
+    // If there are more segments after owner/repo, they form the file path
+    if (parts.length > 2) {
+      filePath = parts.slice(2).join('/')
+    }
+  }
+
+  if (isGithubRepoUrl(value)) {
+    const url = new URL(value)
+    const pathSegments = url.pathname.slice(1).split('/')
+    username = pathSegments[0]
+    name = pathSegments[1]
+
+    // If we have a "tree" segment, everything after branch is the file path
+    if (pathSegments[2] === 'tree') {
+      branch = pathSegments[3]
+      if (pathSegments.length > 4) {
+        filePath = pathSegments.slice(4).join('/')
+      }
+    }
+  }
+
+  if (!username || !name) {
+    throw new Error('Invalid GitHub repository format')
+  }
+
+  const tokenMessage =
+    'GitHub repository not found. For private repositories, use --template-token to provide an access token.\n\n' +
+    'You can generate a new token at https://github.com/settings/personal-access-tokens/new\n' +
+    'Set the token to "read-only" with repository access and a short expiry (e.g. 7 days) for security.'
+
+  try {
+    const headers: Record<string, string> = {}
+    if (bearerToken) {
+      headers.Authorization = `Bearer ${bearerToken}`
+    }
+
+    const infoResponse = await fetch(`https://api.github.com/repos/${username}/${name}`, {
+      headers,
+    })
+
+    if (infoResponse.status !== 200) {
+      if (infoResponse.status === 404) {
+        throw new Error(tokenMessage)
+      }
+      throw new Error('GitHub repository not found')
+    }
+
+    const info = await infoResponse.json()
+
+    return {
+      username,
+      name,
+      branch: branch || info.default_branch,
+      filePath,
+    }
+  } catch {
+    throw new Error(tokenMessage)
+  }
+}
+
+export async function downloadAndExtractRepo(
+  root: string,
+  {username, name, branch, filePath}: RepoInfo,
+  bearerToken?: string,
+): Promise<void> {
+  let rootPath: string | null = null
+  await pipeline(
+    await downloadTarStream(
+      `https://codeload.github.com/${username}/${name}/tar.gz/${branch}`,
+      bearerToken,
+    ),
+    x({
+      cwd: root,
+      strip: filePath ? filePath.split('/').length + 1 : 1,
+      filter: (p: string) => {
+        const posixPath = p.split(sep).join(posix.sep)
+        if (rootPath === null) {
+          const pathSegments = posixPath.split(posix.sep)
+          rootPath = pathSegments.length ? pathSegments[0] : null
+        }
+        for (const disallowedPath of DISALLOWED_PATHS) {
+          if (posixPath.includes(disallowedPath)) return false
+        }
+        return posixPath.startsWith(`${rootPath}${filePath ? `/${filePath}/` : '/'}`)
+      },
+    }),
+  )
+}
+
+export async function checkIfNeedsApiToken(root: string, type: 'read' | 'write'): Promise<boolean> {
+  try {
+    const templatePath = await Promise.any(
+      ENV_TEMPLATE_FILES.map(async (file) => {
+        await access(join(root, file))
+        return file
+      }),
+    )
+    const templateContent = await readFile(join(root, templatePath), 'utf8')
+    return templateContent.includes(type === 'read' ? ENV_VAR.READ_TOKEN : ENV_VAR.WRITE_TOKEN)
+  } catch {
+    return false
+  }
+}
+
+export async function applyEnvVariables(
+  root: string,
+  envData: EnvData,
+  targetName = '.env',
+): Promise<void> {
+  const templatePath = await Promise.any(
+    ENV_TEMPLATE_FILES.map(async (file) => {
+      await access(join(root, file))
+      return file
+    }),
+  ).catch(() => undefined)
+
+  if (!templatePath) {
+    return // No template .env file found, skip
+  }
+
+  try {
+    const templateContent = await readFile(join(root, templatePath), 'utf8')
+    const {projectId, dataset, readToken = ''} = envData
+
+    const findAndReplaceVariable = (
+      content: string,
+      varRegex: RegExp | string,
+      value: string,
+      useQuotes: boolean,
+    ) => {
+      const varPattern = typeof varRegex === 'string' ? varRegex : varRegex.source
+      const pattern = new RegExp(`.*${varPattern}=.*$`, 'gm')
+      const matches = content.matchAll(pattern)
+      return Array.from(matches).reduce((updatedContent, match) => {
+        if (!match[0]) return updatedContent
+        const varName = match[0].split('=')[0].trim()
+        return updatedContent.replace(
+          new RegExp(`${varName}=.*$`, 'gm'),
+          `${varName}=${useQuotes ? `"${value}"` : value}`,
+        )
+      }, content)
+    }
+
+    let envContent = templateContent
+    const vars = [
+      {pattern: ENV_VAR.PROJECT_ID, value: projectId},
+      {pattern: ENV_VAR.DATASET, value: dataset},
+      {pattern: ENV_VAR.READ_TOKEN, value: readToken},
+    ]
+    const useQuotes = templateContent.includes('="')
+
+    for (const {pattern, value} of vars) {
+      envContent = findAndReplaceVariable(envContent, pattern, value, useQuotes)
+    }
+
+    await writeFile(join(root, targetName), envContent)
+  } catch (err) {
+    throw new Error(
+      'Failed to set environment variables. This could be due to file permissions or the .env file format. See https://www.sanity.io/docs/environment-variables for details on environment variable setup.',
+    )
+  }
+}
+
+export async function tryApplyPackageName(root: string, name: string): Promise<void> {
+  try {
+    const packageJson = await readFile(join(root, 'package.json'), 'utf8')
+    const pkg: PackageJson = JSON.parse(packageJson)
+    pkg.name = name
+
+    await writeFile(join(root, 'package.json'), JSON.stringify(pkg, null, 2))
+  } catch (err) {
+    // noop
+  }
+}
+
+export async function generateSanityApiToken(
+  label: string,
+  type: 'read' | 'write',
+  projectId: string,
+  apiClient: CliApiClient,
+): Promise<string> {
+  const response = await apiClient({requireProject: false, requireUser: true})
+    .config({apiVersion: 'v2021-06-07'})
+    .request<{key: string}>({
+      uri: `/projects/${projectId}/tokens`,
+      method: 'POST',
+      body: {
+        label: `${label} (${Date.now()})`,
+        roleName: type === 'read' ? API_READ_TOKEN_ROLE : API_WRITE_TOKEN_ROLE,
+      },
+    })
+  return response.key
+}
+
+export async function setCorsOrigin(
+  origin: string,
+  projectId: string,
+  apiClient: CliApiClient,
+): Promise<void> {
+  try {
+    await apiClient({api: {projectId}}).request({
+      method: 'POST',
+      url: '/cors',
+      body: {origin: origin, allowCredentials: true}, // allowCredentials is true to allow for embedded studios if needed
+    })
+  } catch (error) {
+    // Silent fail, it most likely means that the origin is already set
+    debug('Failed to set CORS origin', error)
+  }
+}

package/templates/get-started/plugins/sanity-plugin-tutorial/GetStartedTutorial.tsx

@@ -1,4 +1,4 @@
-import React, {useRef, useState} from 'react'
+import React, {useState} from 'react'
 import {
   Card,
   Container,
@@ -32,8 +32,8 @@ export const GetStartedTutorial = () => {
   )
 
   const {sanity} = useTheme()
-  const rootElement = useRef(null)
-  const rect = useElementSize(rootElement.current)
+  const [rootElement, setRootElement] = useState<HTMLDivElement | null>(null)
+  const rect = useElementSize(rootElement)
   const width = rect?.content?.width
   const isSmallScreen = width ? width < sanity.media[1] : false
   const isProdEnv = process.env.NODE_ENV !== 'development'
@@ -48,7 +48,7 @@ export const GetStartedTutorial = () => {
   }
 
   return (
-    <div ref={rootElement}>
+    <div ref={setRootElement}>
       <Card tone="primary" padding={isSmallScreen ? 3 : 5} paddingBottom={isSmallScreen ? 4 : 6}>
         <Flex justify={isSmallScreen ? 'space-between' : 'flex-end'} align="center">
           {isSmallScreen && (

package/src/actions/init-plugin/initPlugin.ts

@@ -1,119 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import {type InitFlags} from '../../commands/init/initCommand'
-import {debug} from '../../debug'
-import {type CliCommandArguments, type CliCommandContext, type SanityJson} from '../../types'
-import {bootstrapFromTemplate} from './bootstrapFromTemplate'
-import {pluginTemplates} from './pluginTemplates'
-
-export default async function initPlugin(
-  args: CliCommandArguments<InitFlags>,
-  context: CliCommandContext,
-): Promise<void> {
-  const {output, prompt} = context
-  const [, specifiedTemplateUrl] = args.argsWithoutOptions
-
-  output.print('This utility will walk you through creating a new Sanity plugin.')
-  output.print('Press ^C at any time to quit.\n')
-
-  const hasTemplateUrl = /^https?:\/\//.test(specifiedTemplateUrl || '')
-
-  if (hasTemplateUrl) {
-    debug('User provided template URL: %s', specifiedTemplateUrl)
-    return bootstrapFromUrl(context, specifiedTemplateUrl)
-  }
-
-  let specifiedTemplate = null
-  if (specifiedTemplateUrl) {
-    specifiedTemplate = pluginTemplates.find((tpl) => tpl.value === specifiedTemplateUrl)
-  }
-
-  if (specifiedTemplate) {
-    debug(
-      'User wanted template "%s", match found at %s',
-      specifiedTemplateUrl,
-      specifiedTemplate.url,
-    )
-
-    return bootstrapFromUrl(context, specifiedTemplate.url)
-  } else if (specifiedTemplateUrl) {
-    throw new Error(`Cannot find template with name "${specifiedTemplateUrl}"`)
-  }
-
-  const templateChoices = pluginTemplates.map(({value, name}) => ({value, name}))
-  const selected = await prompt.single({
-    message: 'Select template to use',
-    type: 'list',
-    choices: templateChoices,
-  })
-
-  specifiedTemplate = pluginTemplates.find((tpl) => tpl.value === selected)
-  if (!specifiedTemplate) {
-    throw new Error('No template selected')
-  }
-
-  debug('User selected template URL: %s', specifiedTemplate.url)
-  return bootstrapFromUrl(context, specifiedTemplate.url)
-}
-
-async function bootstrapFromUrl(context: CliCommandContext, url: string): Promise<void> {
-  const {output, prompt, yarn, workDir} = context
-
-  debug('Bootstrapping from URL: %s', url)
-  const {name, outputPath, inPluginsPath, dependencies} = await bootstrapFromTemplate(context, url)
-
-  if (inPluginsPath) {
-    const addIt = await prompt.single({
-      type: 'confirm',
-      message: 'Enable plugin in current Sanity installation?',
-      default: true,
-    })
-
-    if (addIt) {
-      await addPluginToManifest(workDir, name.replace(/^sanity-plugin-/, ''))
-    }
-  }
-
-  if (dependencies) {
-    const dependencyString = JSON.stringify(dependencies, null, 2)
-      .split('\n')
-      .slice(1, -1)
-      .join('\n')
-      .replace(/"/g, '')
-
-    output.print('\nThe following dependencies are required for this template:')
-    output.print(`${dependencyString}\n`)
-  }
-
-  if (dependencies && inPluginsPath) {
-    const addDeps = await prompt.single({
-      type: 'confirm',
-      message: 'Install dependencies in current project?',
-      default: true,
-    })
-
-    if (addDeps) {
-      const deps = Object.keys(dependencies).map((dep) => `${dep}@${dependencies[dep]}`)
-      await yarn(['add'].concat(deps), {...output, rootDir: workDir})
-
-      output.print('Dependencies installed.')
-      output.print('Remember to remove them from `package.json` if you no longer need them!')
-    }
-  }
-
-  output.print(`\nSuccess! Plugin initialized at ${outputPath}`)
-}
-
-async function addPluginToManifest(sanityDir: string, pluginName: string): Promise<SanityJson> {
-  const manifestPath = path.join(sanityDir, 'sanity.json')
-  const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'))
-
-  manifest.plugins = manifest.plugins || []
-  if (manifest.plugins.indexOf(pluginName) === -1) {
-    manifest.plugins.push(pluginName)
-  }
-
-  await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2))
-  return manifest
-}

package/src/actions/init-plugin/pluginTemplates.ts

@@ -1,38 +0,0 @@
-export interface PluginTemplate {
-  value: string
-  name: string
-  url: string
-}
-
-export const pluginTemplates: PluginTemplate[] = [
-  {
-    value: 'logo',
-    name: 'Studio logo',
-    url: 'https://github.com/sanity-io/plugin-template-logo/archive/master.zip',
-  },
-  {
-    value: 'tool',
-    name: 'Basic, empty tool',
-    url: 'https://github.com/sanity-io/plugin-template-tool/archive/master.zip',
-  },
-  {
-    value: 'toolWithRouting',
-    name: 'Tool with basic routing',
-    url: 'https://github.com/sanity-io/plugin-template-tool-with-routing/archive/master.zip',
-  },
-  {
-    value: 'chessInput',
-    name: 'Chess board input component w/ block preview',
-    url: 'https://github.com/sanity-io/plugin-template-chess-input/archive/master.zip',
-  },
-  {
-    value: 'dashboardWidget',
-    name: 'A Dashboard widget with cats',
-    url: 'https://github.com/sanity-io/plugin-template-dashboard-widget-cats/archive/master.zip',
-  },
-  {
-    value: 'assetSource',
-    name: 'Custom asset source plugin',
-    url: 'https://github.com/sanity-io/plugin-template-asset-source/archive/master.zip',
-  },
-]