@ronaldphilipsen/local-action 0.0.0-stage → 7.1.0

package/src/stubs/core/path-utils.ts

@@ -0,0 +1,39 @@
+/**
+ * Last Reviewed Commit: 00282d61458d99f725588a9463b9d25dfda51c22
+ * Last Reviewed Date: 2026-01-16
+ */
+
+import * as path from 'path'
+
+/**
+ * Converts the given path to the posix form. On Windows, `\\` will be replaced
+ * with `/`.
+ *
+ * @param pth Path to transform
+ * @return Posix path
+ */
+export function toPosixPath(pth: string): string {
+  return pth.replace(/[\\]/g, '/')
+}
+
+/**
+ * Converts the given path to the win32 form. On Linux, `/` will be replaced
+ * with `\\`.
+ *
+ * @param pth Path to transform
+ * @return Win32 path
+ */
+export function toWin32Path(pth: string): string {
+  return pth.replace(/[/]/g, '\\')
+}
+
+/**
+ * Converts the given path to a platform-specific path. It does this by
+ * replacing instances of `/` and `\` with the platform-specific path separator.
+ *
+ * @param pth The path to platformize
+ * @return The platform-specific path
+ */
+export function toPlatformPath(pth: string): string {
+  return pth.replace(/[/\\]/g, path.sep)
+}

package/src/stubs/core/platform.ts

@@ -0,0 +1,132 @@
+/**
+ * Last Reviewed Commit: d402248c459082c3727b5d592f9c44b81d7d9709
+ * Last Reviewed Date: 2026-01-16
+ */
+
+import * as exec from '@actions/exec'
+import os from 'os'
+
+/**
+ * Gets the Windows version and name.
+ *
+ * @remarks
+ *
+ * - Exported for testing purposes.
+ *
+ * @returns Promise with the Windows version and name
+ */
+export const getWindowsInfo = async (): Promise<{
+  name: string
+  version: string
+}> => {
+  const { stdout: version } = await exec.getExecOutput(
+    'powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"',
+    undefined,
+    {
+      silent: true
+    }
+  )
+
+  const { stdout: name } = await exec.getExecOutput(
+    'powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"',
+    undefined,
+    {
+      silent: true
+    }
+  )
+
+  return {
+    name: name.trim(),
+    version: version.trim()
+  }
+}
+
+/**
+ * Gets the macOS version and name.
+ *
+ * @remarks
+ *
+ * - Exported for testing purposes.
+ *
+ * @returns Promise with the macOS version and name
+ */
+export const getMacOsInfo = async (): Promise<{
+  name: string
+  version: string
+}> => {
+  const { stdout } = await exec.getExecOutput('sw_vers', undefined, {
+    silent: true
+  })
+
+  const version = stdout.match(/ProductVersion:\s*(.+)/)?.[1] ?? ''
+  const name = stdout.match(/ProductName:\s*(.+)/)?.[1] ?? ''
+
+  return {
+    name,
+    version
+  }
+}
+
+/**
+ * Gets the Linux version and name.
+ *
+ * @remarks
+ *
+ * - Exported for testing purposes.
+ *
+ * @returns Promise with the Linux version and name
+ */
+export const getLinuxInfo = async (): Promise<{
+  name: string
+  version: string
+}> => {
+  const { stdout } = await exec.getExecOutput(
+    'lsb_release',
+    ['-i', '-r', '-s'],
+    {
+      silent: true
+    }
+  )
+
+  const [name, version] = stdout.trim().split('\n')
+
+  return {
+    name,
+    version
+  }
+}
+
+export const platform = os.platform()
+export const arch = os.arch()
+export const isWindows = platform === 'win32'
+export const isMacOS = platform === 'darwin'
+export const isLinux = platform === 'linux'
+
+/**
+ * Gets the platform details.
+ *
+ * @returns Promise with the platform details
+ */
+/* istanbul ignore next */
+export async function getDetails(): Promise<{
+  name: string
+  platform: string
+  arch: string
+  version: string
+  isWindows: boolean
+  isMacOS: boolean
+  isLinux: boolean
+}> {
+  return {
+    ...(await (isWindows
+      ? getWindowsInfo()
+      : isMacOS
+        ? getMacOsInfo()
+        : getLinuxInfo())),
+    platform,
+    arch,
+    isWindows,
+    isMacOS,
+    isLinux
+  }
+}

package/src/stubs/core/summary.ts

@@ -0,0 +1,399 @@
+/**
+ * Last Reviewed Commit: 07242b37a49ef3c3704f429570b3c9e377b72ecb
+ * Last Reviewed Date: 2026-01-16
+ */
+
+import fs from 'fs'
+import { EOL } from 'os'
+import path from 'path'
+import { CoreMeta } from './core.js'
+
+/**
+ * A row for a summary table.
+ */
+export type SummaryTableRow = (SummaryTableCell | string)[]
+
+/**
+ * A cell for a summary table row.
+ */
+export interface SummaryTableCell {
+  /**
+   * Cell content
+   */
+  data: string
+  /**
+   * Render cell as header
+   * (optional) default: false
+   */
+  header?: boolean
+  /**
+   * Number of columns the cell extends
+   * (optional) default: '1'
+   */
+  colspan?: string
+  /**
+   * Number of rows the cell extends
+   * (optional) default: '1'
+   */
+  rowspan?: string
+}
+
+/**
+ * Summary image options.
+ */
+export interface SummaryImageOptions {
+  /**
+   * The width of the image in pixels. Must be an integer without a unit.
+   * (optional)
+   */
+  width?: string
+  /**
+   * The height of the image in pixels. Must be an integer without a unit.
+   * (optional)
+   */
+  height?: string
+}
+
+/**
+ * Summary write options.
+ */
+export interface SummaryWriteOptions {
+  /**
+   * Replace all existing content in summary file with buffer contents
+   * (optional) default: false
+   */
+  overwrite?: boolean
+}
+
+/**
+ * A class for creating and writing job step summaries.
+ */
+export class Summary {
+  /** Output buffer to write to the summary file. */
+  private _buffer: string
+
+  /** The path to the summary file. */
+  private _filePath?: string
+
+  /**
+   * Initialize with an empty buffer.
+   */
+  constructor() {
+    this._buffer = ''
+  }
+
+  /**
+   * Finds the summary file path from the environment. Rejects if the
+   * environment variable is not set/empty or the file does not exist.
+   *
+   * @remarks
+   *
+   * - Uses core metadata to track step summary path.
+   *
+   * @returns Step summary file path.
+   */
+  async filePath(): Promise<string> {
+    // Return the current value, if available.
+    if (this._filePath) return this._filePath
+
+    // Throw if the path is not set/empty.
+    if (!CoreMeta.stepSummaryPath)
+      throw new Error(
+        'Unable to find environment variable for $GITHUB_STEP_SUMMARY. Check if your runtime environment supports job summaries.'
+      )
+
+    try {
+      // Resolve the full path to the file.
+      CoreMeta.stepSummaryPath = path.resolve(
+        process.cwd(),
+        CoreMeta.stepSummaryPath
+      )
+
+      // If the file does not exist, create it. GitHub Actions runners normally
+      // create this file automatically. When testing with local-action, we do
+      // not know if the file already exists.
+      if (!fs.existsSync(CoreMeta.stepSummaryPath))
+        fs.writeFileSync(CoreMeta.stepSummaryPath, '', { encoding: 'utf8' })
+
+      // Test access to the file (read or write).
+      fs.accessSync(
+        CoreMeta.stepSummaryPath,
+        fs.constants.R_OK | fs.constants.W_OK
+      )
+    } catch {
+      throw new Error(
+        `Unable to access summary file: '${CoreMeta.stepSummaryPath}'. Check if the file has correct read/write permissions.`
+      )
+    }
+
+    this._filePath = CoreMeta.stepSummaryPath
+    return Promise.resolve(this._filePath)
+  }
+
+  /**
+   * Wraps content in the provided HTML tag and adds any specified attributes.
+   *
+   * @param tag HTML tag to wrap. Example: 'html', 'body', 'div', etc.
+   * @param content The content to wrap within the tag.
+   * @param attrs A key-value list of HTML attributes to add.
+   * @returns Content wrapped in an HTML element.
+   */
+  wrap(
+    tag: string,
+    content: string | null,
+    attrs: { [attribute: string]: string } = {}
+  ): string {
+    const htmlAttrs: string = Object.entries(attrs)
+      .map(([key, value]) => ` ${key}="${value}"`)
+      .join('')
+
+    return !content
+      ? `<${tag}${htmlAttrs}>`
+      : `<${tag}${htmlAttrs}>${content}</${tag}>`
+  }
+
+  /**
+   * Writes the buffer to the summary file and empties the buffer. This can
+   * append (default) or overwrite the file.
+   *
+   * @param options Options for the write operation.
+   * @returns A promise that resolves to the Summary instance for chaining.
+   */
+  async write(
+    options: SummaryWriteOptions = { overwrite: false }
+  ): Promise<Summary> {
+    // Set the function to call based on the overwrite setting.
+    const writeFunc = options.overwrite ? fs.writeFileSync : fs.appendFileSync
+
+    // If the file does not exist, create it. GitHub Actions runners normally
+    // create this file automatically. When testing with local-action, we do not
+    // know if the file already exists.
+    const filePath: string = await this.filePath()
+
+    // Call the write function.
+    writeFunc(filePath, this._buffer, { encoding: 'utf8' })
+
+    // Empty the buffer.
+    return this.emptyBuffer()
+  }
+
+  /**
+   * Clears the buffer and summary file.
+   *
+   * @returns A promise that resolve to the Summary instance for chaining.
+   */
+  async clear(): Promise<Summary> {
+    return this.emptyBuffer().write({ overwrite: true })
+  }
+
+  /**
+   * Returns the current buffer as a string.
+   *
+   * @returns Current buffer contents.
+   */
+  stringify(): string {
+    return this._buffer
+  }
+
+  /**
+   * Returns `true` the buffer is empty, `false` otherwise.
+   *
+   * @returns Whether the buffer is empty.
+   */
+  isEmptyBuffer(): boolean {
+    return this._buffer.length === 0
+  }
+
+  /**
+   * Resets the buffer without writing to the summary file.
+   *
+   * @returns The Summary instance for chaining.
+   */
+  emptyBuffer(): Summary {
+    this._buffer = ''
+    return this
+  }
+
+  /**
+   * Adds raw text to the buffer.
+   *
+   * @param text The content to add.
+   * @param addEOL Whether to append `EOL` to the raw text (default: `false`).
+   *
+   * @returns The Summary instance for chaining.
+   */
+  addRaw(text: string, addEOL: boolean = false): Summary {
+    this._buffer += text
+    return addEOL ? this.addEOL() : this
+  }
+
+  /**
+   * Adds the operating system-specific `EOL` marker to the buffer.
+   *
+   * @returns The Summary instance for chaining.
+   */
+  addEOL(): Summary {
+    return this.addRaw(EOL)
+  }
+
+  /**
+   * Adds a code block (\<code\>) to the buffer.
+   *
+   * @param code Content to render within the code block.
+   * @param lang Language to use for syntax highlighting.
+   * @returns Summary instance for chaining.
+   */
+  addCodeBlock(code: string, lang?: string): Summary {
+    return this.addRaw(
+      this.wrap('pre', this.wrap('code', code), lang ? { lang } : {})
+    ).addEOL()
+  }
+
+  /**
+   * Adds a list (\<li\>) element to the buffer.
+   *
+   * @param items List of items to render.
+   * @param ordered Whether the list should be ordered.
+   * @returns Summary instance for chaining.
+   */
+  addList(items: string[], ordered: boolean = false): Summary {
+    return this.addRaw(
+      this.wrap(
+        ordered ? 'ol' : 'ul',
+        items.map(item => this.wrap('li', item)).join('')
+      )
+    ).addEOL()
+  }
+
+  /**
+   * Adds a table (\<table\>) element to the buffer.
+   *
+   * @param rows Table rows to render.
+   * @returns Summary instance for chaining.
+   */
+  addTable(rows: SummaryTableRow[]): Summary {
+    return this.addRaw(
+      this.wrap(
+        'table',
+        // The table body consists of a list of rows, each with a list of cells.
+        rows
+          .map(row => {
+            const cells: string = row
+              .map(cell => {
+                // Cell is a string, return as-is.
+                if (typeof cell === 'string') return this.wrap('td', cell)
+
+                // Cell is a SummaryTableCell, extract the data and attributes.
+                return this.wrap(cell.header ? 'th' : 'td', cell.data, {
+                  ...(cell.colspan ? { colspan: cell.colspan } : {}),
+                  ...(cell.rowspan ? { rowspan: cell.rowspan } : {})
+                })
+              })
+              .join('')
+
+            return this.wrap('tr', cells)
+          })
+          .join('')
+      )
+    ).addEOL()
+  }
+
+  /**
+   * Adds a details (\<details\>) element to the buffer.
+   *
+   * @param label Text for the \<summary\> element.
+   * @param content Text for the \<details\> container.
+   * @returns Summary instance for chaining.
+   */
+  addDetails(label: string, content: string): Summary {
+    return this.addRaw(
+      this.wrap('details', this.wrap('summary', label) + content)
+    ).addEOL()
+  }
+
+  /**
+   * Adds an image (\<img\>) element to the buffer.
+   *
+   * @param src Path to the image to embed.
+   * @param alt Text description of the image.
+   * @param options Additional image attributes.
+   * @returns Summary instance for chaining.
+   */
+  addImage(
+    src: string,
+    alt: string,
+    options: SummaryImageOptions = {}
+  ): Summary {
+    return this.addRaw(
+      this.wrap('img', null, {
+        src,
+        alt,
+        ...(options.width ? { width: options.width } : {}),
+        ...(options.height ? { height: options.height } : {})
+      })
+    ).addEOL()
+  }
+
+  /**
+   * Adds a heading (\<hX\>) element to the buffer.
+   *
+   * @param text Heading text to render.
+   * @param level Heading level. Defaults to `1`.
+   * @returns Summary instance for chaining.
+   */
+  addHeading(text: string, level: number | string = 1): Summary {
+    // If level is a string, attempt to parse it as a number.
+    const levelAsNum = typeof level === 'string' ? parseInt(level) : level
+
+    // If level is less than 1 or greater than 6, default to `h1`.
+    const tag =
+      Number.isNaN(levelAsNum) || levelAsNum < 1 || levelAsNum > 6
+        ? 'h1'
+        : `h${level}`
+
+    const element = this.wrap(tag, text)
+    return this.addRaw(element).addEOL()
+  }
+
+  /**
+   * Adds a horizontal rule (\<hr\>) element to the buffer.
+   *
+   * @returns Summary instance for chaining.
+   */
+  addSeparator(): Summary {
+    return this.addRaw(this.wrap('hr', null)).addEOL()
+  }
+
+  /**
+   * Adds a line break (\<br\>) to the buffer.
+   *
+   * @returns Summary instance for chaining.
+   */
+  addBreak(): Summary {
+    return this.addRaw(this.wrap('br', null)).addEOL()
+  }
+
+  /**
+   * Adds a block quote \<blockquote\> element to the buffer.
+   *
+   * @param text Quote text to render.
+   * @param cite (Optional) Citation URL.
+   * @returns Summary instance for chaining.
+   */
+  addQuote(text: string, cite?: string): Summary {
+    return this.addRaw(
+      this.wrap('blockquote', text, cite ? { cite } : {})
+    ).addEOL()
+  }
+
+  /**
+   * Adds an anchor (\<a\>) element to the buffer.
+   *
+   * @param text Text content to render.
+   * @param href Hyperlink to the target.
+   * @returns Summary instance for chaining.
+   */
+  addLink(text: string, href: string): Summary {
+    return this.addRaw(this.wrap('a', text, { href })).addEOL()
+  }
+}

package/src/stubs/env.ts

@@ -0,0 +1,40 @@
+import type { EnvMetadata } from '../types.js'
+
+/**
+ * Environment Metdata
+ */
+export const EnvMeta: EnvMetadata = {
+  actionFile: '',
+  actionPath: '',
+  artifacts: [],
+  caches: {},
+  dotenvFile: '',
+  entrypoint: '',
+  env: {},
+  inputs: {},
+  outputs: {},
+  path: '',
+  postEntrypoint: undefined,
+  preEntrypoint: undefined
+}
+
+/**
+ * Reset the Environment Metadata
+ *
+ * Simple convenience function to reset the environment metadata back to initial
+ * state.
+ */
+export function ResetEnvMetadata(): void {
+  EnvMeta.actionFile = ''
+  EnvMeta.actionPath = ''
+  EnvMeta.artifacts = []
+  EnvMeta.caches = {}
+  EnvMeta.dotenvFile = ''
+  EnvMeta.entrypoint = ''
+  EnvMeta.env = {}
+  EnvMeta.inputs = {}
+  EnvMeta.outputs = {}
+  EnvMeta.path = ''
+  EnvMeta.postEntrypoint = undefined
+  EnvMeta.preEntrypoint = undefined
+}

package/src/stubs/github/context.ts

@@ -0,0 +1,94 @@
+/**
+ * Last Reviewed Commit: faa425440f86f9c16587a19dfb59491253a2c92a
+ * Last Reviewed Date: 2026-01-16
+ */
+
+import { existsSync, readFileSync } from 'fs'
+import { EOL } from 'os'
+import type { WebhookPayload } from './interfaces.js'
+
+export class Context {
+  /**
+   * Webhook payload object that triggered the workflow
+   */
+  payload: WebhookPayload
+
+  eventName: string
+  sha: string
+  ref: string
+  workflow: string
+  action: string
+  actor: string
+  job: string
+  runAttempt: number
+  runNumber: number
+  runId: number
+  apiUrl: string
+  serverUrl: string
+  graphqlUrl: string
+
+  /**
+   * Hydrate the context from the environment
+   */
+  constructor() {
+    this.payload = {}
+
+    /* istanbul ignore next */
+    if (process.env.GITHUB_EVENT_PATH) {
+      if (existsSync(process.env.GITHUB_EVENT_PATH)) {
+        this.payload = JSON.parse(
+          readFileSync(process.env.GITHUB_EVENT_PATH, { encoding: 'utf8' })
+        )
+      } else {
+        const path = process.env.GITHUB_EVENT_PATH
+        process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${EOL}`)
+      }
+    }
+
+    this.eventName = process.env.GITHUB_EVENT_NAME as string
+    this.sha = process.env.GITHUB_SHA as string
+    this.ref = process.env.GITHUB_REF as string
+    this.workflow = process.env.GITHUB_WORKFLOW as string
+    this.action = process.env.GITHUB_ACTION as string
+    this.actor = process.env.GITHUB_ACTOR as string
+    this.job = process.env.GITHUB_JOB as string
+    this.runAttempt = parseInt(process.env.GITHUB_RUN_ATTEMPT as string, 10)
+    this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER as string, 10)
+    this.runId = parseInt(process.env.GITHUB_RUN_ID as string, 10)
+    /* istanbul ignore next */
+    this.apiUrl = process.env.GITHUB_API_URL ?? 'https://api.github.com'
+    /* istanbul ignore next */
+    this.serverUrl = process.env.GITHUB_SERVER_URL ?? 'https://github.com'
+    /* istanbul ignore next */
+    this.graphqlUrl =
+      process.env.GITHUB_GRAPHQL_URL ?? 'https://api.github.com/graphql'
+  }
+
+  /* istanbul ignore next */
+  get issue(): { owner: string; repo: string; number: number } {
+    const payload = this.payload
+
+    return {
+      ...this.repo,
+      number: (payload.issue || payload.pull_request || payload).number
+    }
+  }
+
+  /* istanbul ignore next */
+  get repo(): { owner: string; repo: string } {
+    if (process.env.GITHUB_REPOSITORY) {
+      const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/')
+      return { owner, repo }
+    }
+
+    if (this.payload.repository)
+      return {
+        owner: this.payload.repository.owner.login,
+        repo: this.payload.repository.name
+      }
+
+    throw new Error(
+      "context.repo requires a GITHUB_REPOSITORY environment variable like 'owner/repo'"
+    )
+  }
+}