pinokiod 7.2.17 → 7.3.0

package/kernel/api/shell_run_template.js

@@ -1,273 +0,0 @@
-function isCmdShellName(shellName) {
-  const name = (shellName || '').toLowerCase()
-  return name.includes('cmd.exe') || name === 'cmd'
-}
-
-function isPowerShellName(shellName) {
-  const name = (shellName || '').toLowerCase()
-  return name.includes('powershell') || name.includes('pwsh')
-}
-
-const ENV_ARG_MARKER_RE = /__PINOKIO_ENVARG_(\d+)__/g
-
-function envArgMarker(index) {
-  return `__PINOKIO_ENVARG_${index}__`
-}
-
-function isPinokioEnvArgKey(key) {
-  return /^PINOKIO_ARG_\d+$/.test(key || "")
-}
-
-function hasEnvArgMarker(value) {
-  ENV_ARG_MARKER_RE.lastIndex = 0
-  return ENV_ARG_MARKER_RE.test(String(value))
-}
-
-function quotePosixLiteral(value) {
-  const input = value == null ? "" : String(value)
-  return `'${input.split("'").join("'\"'\"'")}'`
-}
-
-function quotePowerShellComposite(value) {
-  const input = value == null ? "" : String(value)
-  ENV_ARG_MARKER_RE.lastIndex = 0
-  let output = '"'
-  let lastIndex = 0
-  for (const match of input.matchAll(ENV_ARG_MARKER_RE)) {
-    const literal = input.slice(lastIndex, match.index)
-    output += literal.replace(/[`"$]/g, (char) => "`" + char)
-    output += "${env:PINOKIO_ARG_" + match[1] + "}"
-    lastIndex = match.index + match[0].length
-  }
-  output += input.slice(lastIndex).replace(/[`"$]/g, (char) => "`" + char)
-  output += '"'
-  return output
-}
-
-function quoteCmdComposite(value) {
-  const input = value == null ? "" : String(value)
-  ENV_ARG_MARKER_RE.lastIndex = 0
-  let output = '"'
-  let lastIndex = 0
-  for (const match of input.matchAll(ENV_ARG_MARKER_RE)) {
-    const literal = input.slice(lastIndex, match.index)
-    output += literal.replace(/([()%!^"<>&|])/g, '^$1')
-    output += "!PINOKIO_ARG_" + match[1] + "!"
-    lastIndex = match.index + match[0].length
-  }
-  output += input.slice(lastIndex).replace(/([()%!^"<>&|])/g, '^$1')
-  output += '"'
-  return output
-}
-
-function quoteEnvArgComposite(value, shellName) {
-  const input = value == null ? "" : String(value)
-  if (isCmdShellName(shellName)) {
-    return quoteCmdComposite(input)
-  }
-  if (isPowerShellName(shellName)) {
-    return quotePowerShellComposite(input)
-  }
-
-  ENV_ARG_MARKER_RE.lastIndex = 0
-  const parts = []
-  let lastIndex = 0
-  for (const match of input.matchAll(ENV_ARG_MARKER_RE)) {
-    const literal = input.slice(lastIndex, match.index)
-    if (literal) {
-      parts.push(quotePosixLiteral(literal))
-    }
-    parts.push('"$PINOKIO_ARG_' + match[1] + '"')
-    lastIndex = match.index + match[0].length
-  }
-  const tail = input.slice(lastIndex)
-  if (tail) {
-    parts.push(quotePosixLiteral(tail))
-  }
-  return parts.length > 0 ? parts.join("") : "''"
-}
-
-function shellNameFor(kernel, params) {
-  let shellName = kernel && kernel.platform === "win32" ? "cmd.exe" : "bash"
-  if (params && typeof params.shell === "string" && params.shell.trim()) {
-    shellName = params.shell
-  }
-  return shellName
-}
-
-function isPlainObject(value) {
-  return value && value.constructor === Object
-}
-
-function hasMultiline(value) {
-  return typeof value === "string" && /[\r\n]/.test(value)
-}
-
-function isStructuredArgvMessage(value) {
-  return isPlainObject(value) && Array.isArray(value._)
-}
-
-function hasStructuredArgvMessage(value) {
-  if (isStructuredArgvMessage(value)) {
-    return true
-  }
-  if (Array.isArray(value)) {
-    return value.some((item) => isStructuredArgvMessage(item))
-  }
-  return false
-}
-
-function protectStructuredString(value, state) {
-  if (!hasMultiline(value)) {
-    return value
-  }
-  const name = `PINOKIO_ARG_${state.args.length}`
-  state.args.push({
-    name,
-    value: value == null ? "" : String(value)
-  })
-  return envArgMarker(state.args.length - 1)
-}
-
-function protectStructuredValue(value, state) {
-  if (typeof value === "string") {
-    return protectStructuredString(value, state)
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => protectStructuredValue(item, state))
-  }
-  if (isPlainObject(value)) {
-    const rendered = {}
-    for (const [key, item] of Object.entries(value)) {
-      rendered[key] = protectStructuredValue(item, state)
-    }
-    return rendered
-  }
-  return value
-}
-
-function protectStructuredMessage(value, state) {
-  if (isStructuredArgvMessage(value)) {
-    return protectStructuredValue(value, state)
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => isStructuredArgvMessage(item) ? protectStructuredValue(item, state) : item)
-  }
-  return value
-}
-
-function renderEnvArgs(kernel, rpc, memory) {
-  if (!rpc || rpc.method !== "shell.run" || !rpc.params || !hasStructuredArgvMessage(rpc.params.message)) {
-    return rpc
-  }
-
-  const shellName = shellNameFor(kernel, rpc.params)
-  const state = { args: [] }
-  const message = protectStructuredMessage(rpc.params.message, state)
-
-  if (state.args.length === 0) {
-    return rpc
-  }
-
-  const env = Object.assign({}, rpc.params.env || {})
-  for (const arg of state.args) {
-    env[arg.name] = arg.value
-  }
-
-  return {
-    ...rpc,
-    params: {
-      ...rpc.params,
-      message,
-      env,
-      _pinokio_env_args: state.args,
-      _pinokio_cmd_delayed_expansion: isCmdShellName(shellName)
-    }
-  }
-}
-
-function envArgDetails(value) {
-  const normalized = String(value == null ? "" : value)
-    .replace(/\r\n/g, "\n")
-    .replace(/\r/g, "\n")
-    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "?")
-  const lines = normalized.split("\n")
-  const previewLines = []
-  const maxLines = 8
-  const maxChars = 800
-  let used = 0
-
-  for (const line of lines.slice(0, maxLines)) {
-    const remaining = maxChars - used
-    if (remaining <= 0) {
-      break
-    }
-    if (line.length > remaining) {
-      previewLines.push(line.slice(0, remaining) + "...")
-      used = maxChars
-      break
-    }
-    previewLines.push(line)
-    used += line.length + 1
-  }
-
-  const preview = previewLines.join("\n")
-  const truncated = lines.length > previewLines.length || normalized.length > preview.length
-  if (truncated && previewLines[previewLines.length - 1] !== "...") {
-    previewLines.push("...")
-  }
-
-  return {
-    lineCount: normalized.length === 0 ? 0 : lines.length,
-    previewLines,
-    truncated
-  }
-}
-
-function formatEnvArgsPreview(args) {
-  if (!Array.isArray(args) || args.length === 0) {
-    return ""
-  }
-  const lines = ["\r\nPinokio shell args", ""]
-  for (const arg of args) {
-    const details = envArgDetails(arg.value)
-    lines.push(`${arg.name}  ${details.lineCount} lines`)
-    for (const previewLine of details.previewLines) {
-      lines.push(`  ${previewLine}`)
-    }
-    lines.push("")
-  }
-  return lines.join("\r\n") + "\r\n"
-}
-
-function envArgSummary(value) {
-  const details = envArgDetails(value)
-  return {
-    type: "pinokio env arg",
-    lines: details.lineCount,
-    preview: details.previewLines.join("\n"),
-    truncated: details.truncated
-  }
-}
-
-function redactEnvArgs(env) {
-  if (!env || typeof env !== "object") {
-    return env
-  }
-  const redacted = { ...env }
-  for (const key of Object.keys(redacted)) {
-    if (isPinokioEnvArgKey(key)) {
-      redacted[key] = envArgSummary(redacted[key])
-    }
-  }
-  return redacted
-}
-
-module.exports = {
-  renderEnvArgs,
-  quoteEnvArgComposite,
-  hasEnvArgMarker,
-  isPinokioEnvArgKey,
-  formatEnvArgsPreview,
-  redactEnvArgs
-}

package/kernel/api/uri/index.js

@@ -1,51 +0,0 @@
-const Util = require('../../util')
-
-const appendQueryParams = (uri, params) => {
-  if (!params || typeof params !== 'object' || Array.isArray(params)) {
-    return uri
-  }
-
-  const entries = []
-  for (const [key, value] of Object.entries(params)) {
-    const values = Array.isArray(value) ? value : [value]
-    for (const item of values) {
-      if (item === undefined || item === null) {
-        continue
-      }
-      const serialized = typeof item === 'object' ? JSON.stringify(item) : String(item)
-      entries.push(`${encodeURIComponent(key)}=${encodeURIComponent(serialized)}`)
-    }
-  }
-
-  if (entries.length === 0) {
-    return uri
-  }
-
-  const hashIndex = uri.indexOf('#')
-  const base = hashIndex === -1 ? uri : uri.slice(0, hashIndex)
-  const hash = hashIndex === -1 ? '' : uri.slice(hashIndex)
-  const separator = base.includes('?')
-    ? (base.endsWith('?') || base.endsWith('&') ? '' : '&')
-    : '?'
-
-  return `${base}${separator}${entries.join('&')}${hash}`
-}
-
-class URI {
-  build(params = {}) {
-    const uri = typeof params.uri === 'string' ? params.uri.trim() : ''
-    if (!uri) {
-      throw new Error('uri.open requires params.uri')
-    }
-    return appendQueryParams(uri, params.params)
-  }
-
-  async open(req, ondata, kernel) {
-    const uri = this.build(req.params)
-    ondata({ raw: `\r\nopening uri: ${uri}\r\n` })
-    const result = await Util.openURI(uri)
-    return { uri, result }
-  }
-}
-
-module.exports = URI

package/kernel/plugin_sources.js

@@ -1,236 +0,0 @@
-const fs = require("fs")
-const path = require("path")
-const { glob } = require("glob")
-
-const LOCAL_RUN_PREFIX = "/run"
-const LOCAL_ASSET_PREFIX = "/asset"
-const SYSTEM_RUN_PREFIX = "/pinokio/run"
-const SYSTEM_ASSET_PREFIX = "/pinokio/asset"
-const LOCAL_PLUGIN_RUN_PREFIX = `${LOCAL_RUN_PREFIX}/plugin`
-const LOCAL_PLUGIN_ASSET_PREFIX = `${LOCAL_ASSET_PREFIX}/plugin`
-const SYSTEM_PLUGIN_RUN_PREFIX = `${SYSTEM_RUN_PREFIX}/plugin`
-const SYSTEM_PLUGIN_ASSET_PREFIX = `${SYSTEM_ASSET_PREFIX}/plugin`
-
-const toPathname = (value) => {
-  const raw = typeof value === "string" ? value.trim() : ""
-  if (!raw) return ""
-  try {
-    if (/^https?:\/\//i.test(raw)) return new URL(raw).pathname
-    if (raw.startsWith("/")) return new URL(`http://localhost${raw}`).pathname
-  } catch (_) {
-  }
-  return raw.split("?")[0].split("#")[0]
-}
-
-const normalizeSlashes = (value) => String(value || "").replace(/\\/g, "/").replace(/\/{2,}/g, "/")
-
-const systemRoot = (kernel) => {
-  if (kernel && typeof kernel.systemPath === "function") {
-    return kernel.systemPath()
-  }
-  return path.resolve(__dirname, "..", "system")
-}
-
-const systemPluginRoot = (kernel) => {
-  if (kernel && typeof kernel.systemPath === "function") {
-    return kernel.systemPath("plugin")
-  }
-  return path.resolve(__dirname, "..", "system", "plugin")
-}
-
-const isSystemRunPath = (value) => toPathname(value).startsWith(`${SYSTEM_RUN_PREFIX}/`)
-const isLocalRunPath = (value) => toPathname(value).startsWith(`${LOCAL_RUN_PREFIX}/`)
-const isRunPath = (value) => isLocalRunPath(value) || isSystemRunPath(value)
-const isSystemPluginPath = (value) => normalizeSlashes(value).startsWith(`${SYSTEM_PLUGIN_RUN_PREFIX}/`)
-const isLegacyPluginCodePath = (value) => {
-  const normalized = normalizeSlashes(value).replace(/^\/+/, "")
-  return normalized.startsWith("plugin/code/") || normalized.startsWith("code/")
-}
-
-const normalizePluginPath = (value) => {
-  let normalized = toPathname(value)
-  if (!normalized) return ""
-  normalized = normalizeSlashes(normalized)
-  if (!normalized.startsWith(`${SYSTEM_RUN_PREFIX}/`)) {
-    normalized = normalized.replace(/^\/run(?=\/)/, "")
-  }
-  if (!normalized.startsWith("/")) {
-    normalized = `/${normalized}`
-  }
-  normalized = normalized.replace(/\/+$/, "")
-  if (!normalized.endsWith("/pinokio.js")) {
-    normalized = `${normalized}/pinokio.js`
-  }
-  return normalized
-}
-
-const pluginSelectionMatches = (src, selectedValue) => {
-  const selectedPlugin = normalizeSlashes(typeof selectedValue === "string" ? selectedValue.trim() : "")
-  if (!selectedPlugin || !src) return false
-  const selectedRunPath = selectedPlugin.startsWith(`${SYSTEM_RUN_PREFIX}/`)
-    ? selectedPlugin
-    : `${LOCAL_RUN_PREFIX}${selectedPlugin}`
-  return src === selectedPlugin || src.startsWith(selectedRunPath)
-}
-
-const resolveRunPath = (kernel, value) => {
-  const pathname = toPathname(value)
-  if (isSystemRunPath(pathname)) {
-    const parts = pathname.split("/").filter(Boolean).slice(2)
-    return kernel.systemPath(...parts)
-  }
-  if (isLocalRunPath(pathname)) {
-    const parts = pathname.split("/").filter(Boolean).slice(1)
-    return kernel.path(...parts)
-  }
-  return ""
-}
-
-const resolvePinokioPath = (kernel, value) => {
-  const runPath = resolveRunPath(kernel, value)
-  if (runPath) return runPath
-  const pathname = toPathname(value)
-  return pathname ? kernel.path(pathname.replace(/^\/+/, "")) : ""
-}
-
-const systemRelativeFromPluginPath = (normalizedPath) => {
-  return normalizeSlashes(normalizedPath).replace(/^\/pinokio\/run\/+/, "")
-}
-
-const pluginPathToAbsolute = (kernel, normalizedPath) => {
-  if (isSystemPluginPath(normalizedPath)) {
-    return kernel.systemPath(systemRelativeFromPluginPath(normalizedPath))
-  }
-  return kernel.path(normalizeSlashes(normalizedPath).replace(/^\/+/, ""))
-}
-
-const pluginRunHrefForPath = (normalizedPath) => {
-  if (typeof normalizedPath !== "string" || !normalizedPath) return ""
-  if (isSystemPluginPath(normalizedPath)) return normalizedPath
-  return `${LOCAL_RUN_PREFIX}${normalizedPath}`
-}
-
-const pluginAssetHrefForIcon = (normalizedPath, icon) => {
-  const trimmedIcon = typeof icon === "string" ? icon.trim() : ""
-  if (!trimmedIcon) return ""
-  if (isSystemPluginPath(normalizedPath)) {
-    const relativeDir = path.posix.dirname(systemRelativeFromPluginPath(normalizedPath))
-    return `${SYSTEM_ASSET_PREFIX}/${relativeDir}/${trimmedIcon}`
-  }
-  if (normalizeSlashes(normalizedPath).startsWith("/plugin/")) {
-    const relativeDir = path.posix.dirname(normalizeSlashes(normalizedPath).slice(1))
-    return `${LOCAL_ASSET_PREFIX}/${relativeDir}/${trimmedIcon}`
-  }
-  return ""
-}
-
-const normalizeLauncherTool = (toolValue) => {
-  let normalizedTool = typeof toolValue === "string" ? toolValue.trim() : ""
-  normalizedTool = normalizedTool.replace(/^https?:\/\/[^/]+/i, "")
-  normalizedTool = normalizedTool.replace(/^\/+|\/+$/g, "")
-  if (!normalizedTool || normalizedTool.includes("..") || !/^[A-Za-z0-9._/-]+$/.test(normalizedTool)) {
-    const error = new Error("Invalid plugin.")
-    error.status = 400
-    throw error
-  }
-  if (!normalizedTool.startsWith("pinokio/run/")) {
-    normalizedTool = normalizedTool.replace(/^run\//, "")
-  }
-  if (isLegacyPluginCodePath(normalizedTool)) {
-    const error = new Error("The managed plugin/code path is no longer used.")
-    error.status = 400
-    throw error
-  }
-  return normalizedTool
-}
-
-const resolveLauncherPluginHref = (toolValue) => {
-  const normalizedTool = normalizeLauncherTool(toolValue)
-  if (normalizedTool.startsWith("pinokio/run/")) {
-    const scriptPath = normalizedTool.endsWith(".js")
-      ? normalizedTool
-      : `${normalizedTool}/pinokio.js`
-    return `/${scriptPath}`
-  }
-  if (normalizedTool.startsWith("plugin/") || normalizedTool.startsWith("api/")) {
-    const scriptPath = normalizedTool.endsWith(".js")
-      ? normalizedTool
-      : `${normalizedTool}/pinokio.js`
-    return `${LOCAL_RUN_PREFIX}/${scriptPath}`
-  }
-  return `${LOCAL_PLUGIN_RUN_PREFIX}/${normalizedTool}/pinokio.js`
-}
-
-const loadPluginsFromRoot = async ({ kernel, root, runPrefix, assetPrefix, source, ignore = [] }) => {
-  const exists = await fs.promises.stat(root).then((stat) => stat.isDirectory()).catch(() => false)
-  if (!exists) return []
-
-  const pluginPaths = await glob("**/pinokio.js", { cwd: root, ignore })
-  const plugins = []
-  for (const pluginPath of pluginPaths) {
-    const normalizedPluginPath = normalizeSlashes(pluginPath)
-    const config = await kernel.require(path.resolve(root, pluginPath))
-    if (!config || !Array.isArray(config.run)) continue
-    const invalid = Object.keys(config).some((key) => typeof config[key] === "function")
-    if (invalid) continue
-
-    const cwd = normalizedPluginPath.split("/").slice(0, -1).join("/")
-    const href = `${runPrefix}/${normalizedPluginPath}`
-    const image = config.icon ? `${assetPrefix}/${cwd}/${config.icon}` : config.image
-    plugins.push({
-      ...config,
-      href,
-      src: href,
-      image,
-      source,
-      system: source === "system",
-    })
-  }
-  return plugins
-}
-
-const loadPluginMenu = async (kernel) => {
-  const systemPlugins = await loadPluginsFromRoot({
-    kernel,
-    root: systemPluginRoot(kernel),
-    runPrefix: SYSTEM_PLUGIN_RUN_PREFIX,
-    assetPrefix: SYSTEM_PLUGIN_ASSET_PREFIX,
-    source: "system",
-  })
-  const localPlugins = await loadPluginsFromRoot({
-    kernel,
-    root: path.resolve(kernel.homedir, "plugin"),
-    runPrefix: LOCAL_PLUGIN_RUN_PREFIX,
-    assetPrefix: LOCAL_PLUGIN_ASSET_PREFIX,
-    source: "local",
-    ignore: ["code/**"],
-  })
-  return systemPlugins.concat(localPlugins)
-}
-
-module.exports = {
-  LOCAL_RUN_PREFIX,
-  LOCAL_ASSET_PREFIX,
-  SYSTEM_RUN_PREFIX,
-  SYSTEM_ASSET_PREFIX,
-  LOCAL_PLUGIN_RUN_PREFIX,
-  SYSTEM_PLUGIN_RUN_PREFIX,
-  SYSTEM_PLUGIN_ASSET_PREFIX,
-  systemRoot,
-  systemPluginRoot,
-  toPathname,
-  isSystemRunPath,
-  isLocalRunPath,
-  isRunPath,
-  isSystemPluginPath,
-  isLegacyPluginCodePath,
-  normalizePluginPath,
-  pluginSelectionMatches,
-  resolveRunPath,
-  resolvePinokioPath,
-  pluginPathToAbsolute,
-  pluginRunHrefForPath,
-  pluginAssetHrefForIcon,
-  resolveLauncherPluginHref,
-  loadPluginMenu,
-}

package/kernel/watch/context.js

@@ -1,42 +0,0 @@
-const path = require("path")
-const { watchFs } = require("./drivers/fs")
-const { poll } = require("./drivers/poll")
-
-class WatchContext {
-  constructor(options = {}) {
-    this.kernel = options.kernel
-    this.manager = options.manager
-    this.id = options.id
-    this.cwd = path.resolve(options.cwd)
-    this.dirname = path.resolve(options.dirname || options.cwd)
-    this.request = options.request
-    this.script = options.script
-    this.declaration = options.declaration
-    this.input = options.input || {}
-    this.args = options.args || this.input
-    this.watch = {
-      fs: (targetPath, callback, watchOptions = {}) => {
-        return watchFs(this.resolve(targetPath), callback, {
-          ...watchOptions,
-          onError: watchOptions.onError || ((error) => {
-            console.warn("[watch.fs]", error && error.message ? error.message : error)
-          })
-        })
-      }
-    }
-  }
-
-  resolve(targetPath) {
-    return this.kernel.api.resolvePath(this.cwd, String(targetPath || "."))
-  }
-
-  resolveModule(targetPath) {
-    return this.kernel.api.resolvePath(this.dirname, String(targetPath || "."))
-  }
-
-  poll(interval, callback, options = {}) {
-    return poll(interval, callback, options)
-  }
-}
-
-module.exports = WatchContext

package/kernel/watch/drivers/fs.js

@@ -1,71 +0,0 @@
-const fs = require("fs")
-const path = require("path")
-const ParcelWatcher = require("@parcel/watcher")
-
-const DEFAULT_IGNORE = [
-  "**/.git/**",
-  "**/node_modules/**",
-  "**/__pycache__/**",
-  "**/.venv/**",
-  "**/venv/**",
-  "**/env/**"
-]
-
-function isInside(candidate, parent) {
-  const relative = path.relative(parent, candidate)
-  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative))
-}
-
-async function nearestExistingDirectory(targetPath) {
-  let current = path.resolve(targetPath)
-  while (current && current !== path.dirname(current)) {
-    const stats = await fs.promises.stat(current).catch(() => null)
-    if (stats && stats.isDirectory()) {
-      return current
-    }
-    current = path.dirname(current)
-  }
-  return current || path.parse(path.resolve(targetPath)).root
-}
-
-async function watchFs(targetPath, callback, options = {}) {
-  const resolvedTarget = path.resolve(targetPath)
-  const targetStats = await fs.promises.stat(resolvedTarget).catch(() => null)
-  const watchRoot = targetStats && targetStats.isDirectory()
-    ? resolvedTarget
-    : await nearestExistingDirectory(resolvedTarget)
-  const filterToTarget = watchRoot !== resolvedTarget
-
-  const subscription = await ParcelWatcher.subscribe(
-    watchRoot,
-    (error, events) => {
-      if (error) {
-        if (typeof options.onError === "function") {
-          options.onError(error)
-        }
-        return
-      }
-      const normalizedEvents = Array.isArray(events) ? events : []
-      const filteredEvents = filterToTarget
-        ? normalizedEvents.filter((event) => event && event.path && isInside(path.resolve(event.path), resolvedTarget))
-        : normalizedEvents
-      if (filteredEvents.length === 0) {
-        return
-      }
-      callback(filteredEvents)
-    },
-    {
-      ignore: Array.isArray(options.ignore) ? options.ignore : DEFAULT_IGNORE
-    }
-  )
-
-  return async () => {
-    if (subscription && typeof subscription.unsubscribe === "function") {
-      await subscription.unsubscribe().catch(() => {})
-    }
-  }
-}
-
-module.exports = {
-  watchFs
-}

package/kernel/watch/drivers/poll.js

@@ -1,33 +0,0 @@
-function poll(interval, callback, options = {}) {
-  const delay = Math.max(100, Number(interval || options.interval || 1000))
-  let stopped = false
-  let running = false
-
-  const tick = async () => {
-    if (stopped || running) return
-    running = true
-    try {
-      await callback()
-    } catch (error) {
-      if (typeof options.onError === "function") {
-        options.onError(error)
-      }
-    } finally {
-      running = false
-    }
-  }
-
-  if (options.immediate !== false) {
-    setTimeout(tick, 0)
-  }
-  const timer = setInterval(tick, delay)
-
-  return async () => {
-    stopped = true
-    clearInterval(timer)
-  }
-}
-
-module.exports = {
-  poll
-}