@miaws/miaw 1.18.5 → 1.18.7

package/src/util/process.ts

@@ -1,177 +0,0 @@
-import { type ChildProcess } from "child_process"
-import type { Stream } from "node:stream"
-import launch from "cross-spawn"
-import { buffer } from "node:stream/consumers"
-import { errorMessage } from "./error"
-
-export type Stdio = "inherit" | "pipe" | "ignore" | number | Stream
-export type Shell = boolean | string
-
-export interface Options {
-  cwd?: string
-  env?: NodeJS.ProcessEnv | null
-  stdin?: Stdio
-  stdout?: Stdio
-  stderr?: Stdio
-  shell?: Shell
-  abort?: AbortSignal
-  kill?: NodeJS.Signals | number
-  timeout?: number
-}
-
-export interface RunOptions extends Omit<Options, "stdout" | "stderr"> {
-  nothrow?: boolean
-}
-
-export interface Result {
-  code: number
-  stdout: Buffer
-  stderr: Buffer
-}
-
-export interface TextResult extends Result {
-  text: string
-}
-
-export class RunFailedError extends Error {
-  readonly cmd: string[]
-  readonly code: number
-  readonly stdout: Buffer
-  readonly stderr: Buffer
-
-  constructor(cmd: string[], code: number, stdout: Buffer, stderr: Buffer) {
-    const text = stderr.toString().trim()
-    super(
-      text
-        ? `Command failed with code ${code}: ${cmd.join(" ")}\n${text}`
-        : `Command failed with code ${code}: ${cmd.join(" ")}`,
-    )
-    this.name = "ProcessRunFailedError"
-    this.cmd = [...cmd]
-    this.code = code
-    this.stdout = stdout
-    this.stderr = stderr
-  }
-}
-
-export type Child = ChildProcess & { exited: Promise<number> }
-
-export function spawn(cmd: string[], opts: Options = {}): Child {
-  if (cmd.length === 0) throw new Error("Command is required")
-  opts.abort?.throwIfAborted()
-
-  const proc = launch(cmd[0], cmd.slice(1), {
-    cwd: opts.cwd,
-    shell: opts.shell,
-    env: opts.env === null ? {} : opts.env ? { ...process.env, ...opts.env } : undefined,
-    stdio: [opts.stdin ?? "ignore", opts.stdout ?? "ignore", opts.stderr ?? "ignore"],
-    windowsHide: process.platform === "win32",
-  })
-
-  let closed = false
-  let timer: ReturnType<typeof setTimeout> | undefined
-
-  const abort = () => {
-    if (closed) return
-    if (proc.exitCode !== null || proc.signalCode !== null) return
-    closed = true
-
-    proc.kill(opts.kill ?? "SIGTERM")
-
-    const ms = opts.timeout ?? 5_000
-    if (ms <= 0) return
-    timer = setTimeout(() => proc.kill("SIGKILL"), ms)
-  }
-
-  const exited = new Promise<number>((resolve, reject) => {
-    const done = () => {
-      opts.abort?.removeEventListener("abort", abort)
-      if (timer) clearTimeout(timer)
-    }
-
-    proc.once("exit", (code, signal) => {
-      done()
-      resolve(code ?? (signal ? 1 : 0))
-    })
-
-    proc.once("error", (error) => {
-      done()
-      reject(error)
-    })
-  })
-  void exited.catch(() => undefined)
-
-  if (opts.abort) {
-    opts.abort.addEventListener("abort", abort, { once: true })
-    if (opts.abort.aborted) abort()
-  }
-
-  const child = proc as Child
-  child.exited = exited
-  return child
-}
-
-export async function run(cmd: string[], opts: RunOptions = {}): Promise<Result> {
-  const proc = spawn(cmd, {
-    cwd: opts.cwd,
-    env: opts.env,
-    stdin: opts.stdin,
-    shell: opts.shell,
-    abort: opts.abort,
-    kill: opts.kill,
-    timeout: opts.timeout,
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-
-  if (!proc.stdout || !proc.stderr) throw new Error("Process output not available")
-
-  const out = await Promise.all([proc.exited, buffer(proc.stdout), buffer(proc.stderr)])
-    .then(([code, stdout, stderr]) => ({
-      code,
-      stdout,
-      stderr,
-    }))
-    .catch((err: unknown) => {
-      if (!opts.nothrow) throw err
-      return {
-        code: 1,
-        stdout: Buffer.alloc(0),
-        stderr: Buffer.from(errorMessage(err)),
-      }
-    })
-  if (out.code === 0 || opts.nothrow) return out
-  throw new RunFailedError(cmd, out.code, out.stdout, out.stderr)
-}
-
-// Duplicated in `packages/sdk/js/src/process.ts` because the SDK cannot import
-// `miaw` without creating a cycle. Keep both copies in sync.
-export async function stop(proc: ChildProcess) {
-  if (proc.exitCode !== null || proc.signalCode !== null) return
-
-  if (process.platform !== "win32" || !proc.pid) {
-    proc.kill()
-    return
-  }
-
-  const out = await run(["taskkill", "/pid", String(proc.pid), "/T", "/F"], {
-    nothrow: true,
-  })
-
-  if (out.code === 0) return
-  proc.kill()
-}
-
-export async function text(cmd: string[], opts: RunOptions = {}): Promise<TextResult> {
-  const out = await run(cmd, opts)
-  return {
-    ...out,
-    text: out.stdout.toString(),
-  }
-}
-
-export async function lines(cmd: string[], opts: RunOptions = {}): Promise<string[]> {
-  return (await text(cmd, opts)).text.split(/\r?\n/).filter(Boolean)
-}
-
-export * as Process from "./process"

package/src/util/proxy-env.ts

@@ -1,72 +0,0 @@
-/*
- * Adapted from proxy-from-env: https://github.com/Rob--W/proxy-from-env
- *
- * The MIT License
- *
- * Copyright (C) 2016-2018 Rob Wu <rob@robwu.nl>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of
- * this software and associated documentation files (the "Software"), to deal in
- * the Software without restriction, including without limitation the rights to
- * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is furnished to do
- * so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-const DEFAULT_PORTS: Record<string, number> = {
-  ftp: 21,
-  gopher: 70,
-  http: 80,
-  https: 443,
-  ws: 80,
-  wss: 443,
-}
-
-export function getProxyForUrl(input: string | URL) {
-  const url = typeof input === "string" ? (URL.canParse(input) ? new URL(input) : undefined) : input
-  if (!url) return
-
-  const protocol = url.protocol.split(":", 1)[0]
-  const hostname = url.host.replace(/:\d*$/, "")
-  const port = Number.parseInt(url.port) || DEFAULT_PORTS[protocol] || 0
-  if (!shouldProxy(hostname, port)) return
-
-  const proxy = env(`${protocol}_proxy`) || env("all_proxy")
-  if (!proxy) return
-  return proxy.includes("://") ? proxy : `${protocol}://${proxy}`
-}
-
-function shouldProxy(hostname: string, port: number) {
-  const noProxy = env("no_proxy").toLowerCase()
-  if (!noProxy) return true
-  if (noProxy === "*") return false
-
-  return noProxy.split(/[,\s]/).every((proxy) => {
-    if (!proxy) return true
-
-    const parsed = proxy.match(/^(.+):(\d+)$/)
-    const proxyHostname = parsed ? parsed[1] : proxy
-    const proxyPort = parsed ? Number.parseInt(parsed[2]) : 0
-    if (proxyPort && proxyPort !== port) return true
-
-    if (!/^[.*]/.test(proxyHostname)) return hostname !== proxyHostname
-    return !hostname.endsWith(proxyHostname.startsWith("*") ? proxyHostname.slice(1) : proxyHostname)
-  })
-}
-
-function env(key: string) {
-  return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || ""
-}
-
-export * as ProxyEnv from "./proxy-env"

package/src/util/queue.ts

@@ -1,32 +0,0 @@
-export class AsyncQueue<T> implements AsyncIterable<T> {
-  private queue: T[] = []
-  private resolvers: ((value: T) => void)[] = []
-
-  push(item: T) {
-    const resolve = this.resolvers.shift()
-    if (resolve) resolve(item)
-    else this.queue.push(item)
-  }
-
-  async next(): Promise<T> {
-    if (this.queue.length > 0) return this.queue.shift()!
-    return new Promise((resolve) => this.resolvers.push(resolve))
-  }
-
-  async *[Symbol.asyncIterator]() {
-    while (true) yield await this.next()
-  }
-}
-
-export async function work<T>(concurrency: number, items: T[], fn: (item: T) => Promise<void>) {
-  const pending = [...items]
-  await Promise.all(
-    Array.from({ length: concurrency }, async () => {
-      while (true) {
-        const item = pending.pop()
-        if (item === undefined) return
-        await fn(item)
-      }
-    }),
-  )
-}

package/src/util/record.ts

@@ -1 +0,0 @@
-export * from "@miaw/tui/util/record"

package/src/util/repository.ts

@@ -1,232 +0,0 @@
-import path from "path"
-import { fileURLToPath } from "url"
-import { Schema } from "effect"
-import { Global } from "@miaw/core/global"
-
-type BaseReference = {
-  host: string
-  path: string
-  segments: string[]
-  owner?: string
-  repo: string
-  remote: string
-  label: string
-}
-
-export type RemoteReference = BaseReference & {
-  protocol?: string
-}
-
-export type FileReference = BaseReference & {
-  host: "file"
-  protocol: "file:"
-}
-
-export type Reference = RemoteReference | FileReference
-
-export class InvalidRepositoryReferenceError extends Schema.TaggedErrorClass<InvalidRepositoryReferenceError>()(
-  "RepositoryInvalidReferenceError",
-  {
-    repository: Schema.String,
-    message: Schema.String,
-  },
-) {}
-
-export class UnsupportedLocalRepositoryError extends Schema.TaggedErrorClass<UnsupportedLocalRepositoryError>()(
-  "RepositoryUnsupportedLocalRepositoryError",
-  {
-    repository: Schema.String,
-    message: Schema.String,
-  },
-) {}
-
-export class InvalidRepositoryBranchError extends Schema.TaggedErrorClass<InvalidRepositoryBranchError>()(
-  "RepositoryInvalidBranchError",
-  {
-    branch: Schema.String,
-    message: Schema.String,
-  },
-) {}
-
-export type RepositoryError =
-  | InvalidRepositoryReferenceError
-  | UnsupportedLocalRepositoryError
-  | InvalidRepositoryBranchError
-
-export function isRepositoryError(error: unknown): error is RepositoryError {
-  return (
-    error instanceof InvalidRepositoryReferenceError ||
-    error instanceof UnsupportedLocalRepositoryError ||
-    error instanceof InvalidRepositoryBranchError
-  )
-}
-
-function normalizeRepositoryInput(input: string) {
-  return input
-    .trim()
-    .replace(/^git\+/, "")
-    .replace(/#.*$/, "")
-    .replace(/\/+$/, "")
-}
-
-function trimGitSuffix(input: string) {
-  return input.replace(/\.git$/, "")
-}
-
-function parts(input: string) {
-  return input
-    .split("/")
-    .map((item) => trimGitSuffix(item.trim()))
-    .filter(Boolean)
-}
-
-function safeHost(input: string) {
-  return Boolean(input) && !input.startsWith("-") && !/[\s/\\]/.test(input)
-}
-
-function safeSegment(input: string) {
-  return input !== "." && input !== ".." && !input.includes(":") && !/[\s/\\]/.test(input)
-}
-
-function hostLike(input: string) {
-  return input.includes(".") || input.includes(":") || input === "localhost"
-}
-
-function withSlash(input: string) {
-  return input.endsWith("/") ? input : `${input}/`
-}
-
-function githubRemote(pathname: string) {
-  const base = process.env.MIAW_REPO_CLONE_GITHUB_BASE_URL
-  if (!base) return `https://github.com/${pathname}.git`
-  return new URL(`${pathname}.git`, withSlash(base)).href
-}
-
-function buildRemoteReference(input: { host: string; segments: string[]; remote?: string; protocol?: string }) {
-  const segments = input.segments.map(trimGitSuffix).filter(Boolean)
-  if (!safeHost(input.host) || !segments.length || segments.some((segment) => !safeSegment(segment))) return null
-  const pathname = segments.join("/")
-  const repo = segments[segments.length - 1]
-  const host = input.host.toLowerCase()
-  return {
-    host,
-    path: pathname,
-    segments,
-    owner: segments.length === 2 ? segments[0] : undefined,
-    repo,
-    remote: input.remote ?? (host === "github.com" ? githubRemote(pathname) : `https://${host}/${pathname}.git`),
-    label: host === "github.com" && segments.length === 2 ? pathname : `${host}/${pathname}`,
-    protocol: input.protocol,
-  } satisfies RemoteReference
-}
-
-function buildFileReference(input: { url: URL; remote: string }) {
-  const filePath = path.normalize(fileURLToPath(input.url))
-  const segments = filePath.split(/[\\/]+/).filter(Boolean)
-  if (!segments.length) return null
-  return {
-    host: "file",
-    path: filePath,
-    segments: segments.map((segment) => segment.replace(/:$/, "")),
-    owner: undefined,
-    repo: trimGitSuffix(segments[segments.length - 1]),
-    remote: input.remote,
-    label: filePath,
-    protocol: "file:",
-  } satisfies FileReference
-}
-
-export function parseRepositoryReference(input: string) {
-  const cleaned = normalizeRepositoryInput(input)
-  if (!cleaned) return null
-
-  const githubPrefixed = cleaned.match(/^github:([^/\s]+)\/([^/\s]+)$/)
-  if (githubPrefixed) {
-    return buildRemoteReference({ host: "github.com", segments: [githubPrefixed[1], githubPrefixed[2]] })
-  }
-
-  if (!cleaned.includes("://")) {
-    const scp = cleaned.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/)
-    if (scp) return buildRemoteReference({ host: scp[1], segments: parts(scp[2]), remote: cleaned })
-
-    const direct = parts(cleaned)
-    if (direct.length >= 2 && hostLike(direct[0])) {
-      return buildRemoteReference({ host: direct[0], segments: direct.slice(1) })
-    }
-
-    if (direct.length === 2) {
-      return buildRemoteReference({ host: "github.com", segments: direct })
-    }
-  }
-
-  try {
-    const url = new URL(cleaned)
-    if (url.protocol === "file:") return buildFileReference({ url, remote: cleaned })
-    const pathname = parts(url.pathname)
-    const host = url.host
-    return buildRemoteReference({
-      host,
-      segments: pathname,
-      remote: host === "github.com" ? githubRemote(pathname.join("/")) : cleaned,
-      protocol: url.protocol,
-    })
-  } catch {
-    return null
-  }
-}
-
-export function isFileRepositoryReference(reference: Reference): reference is FileReference {
-  return reference.protocol === "file:"
-}
-
-export function isRemoteRepositoryReference(reference: Reference): reference is RemoteReference {
-  return !isFileRepositoryReference(reference)
-}
-
-export function parseRemoteRepositoryReference(input: string) {
-  const reference = parseRepositoryReference(input)
-  if (!reference) {
-    throw new InvalidRepositoryReferenceError({
-      repository: input,
-      message: "Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand",
-    })
-  }
-  if (!isRemoteRepositoryReference(reference)) {
-    throw new UnsupportedLocalRepositoryError({
-      repository: input,
-      message: "Local file repositories are not supported",
-    })
-  }
-  return reference
-}
-
-export function validateRepositoryBranch(branch: string) {
-  if (!/^[A-Za-z0-9/_.-]+$/.test(branch) || branch.startsWith("-") || branch.includes("..")) {
-    throw new InvalidRepositoryBranchError({
-      branch,
-      message:
-        "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain ..",
-    })
-  }
-}
-
-export function parseGitHubRemote(input: string) {
-  const cleaned = normalizeRepositoryInput(input)
-  if (!cleaned.includes("://") && !cleaned.match(/^(?:[^@/\s]+@)?github\.com:/)) return null
-
-  const parsed = parseRepositoryReference(cleaned)
-  if (!parsed || parsed.host !== "github.com" || !parsed.owner || parsed.segments.length !== 2) return null
-  return { owner: parsed.owner, repo: parsed.repo }
-}
-
-export function repositoryCachePath(input: Reference) {
-  return path.join(Global.Path.repos, ...input.host.split(":"), ...input.segments)
-}
-
-export function repositoryCacheIdentity(input: Reference) {
-  return `${input.host}/${input.path}`
-}
-
-export function sameRepositoryReference(left: Reference, right: Reference) {
-  return repositoryCacheIdentity(left) === repositoryCacheIdentity(right)
-}

package/src/util/rpc.ts

@@ -1,66 +0,0 @@
-type Definition = {
-  [method: string]: (input: any) => any
-}
-
-export function listen(rpc: Definition) {
-  onmessage = async (evt) => {
-    const parsed = JSON.parse(evt.data)
-    if (parsed.type === "rpc.request") {
-      const result = await rpc[parsed.method](parsed.input)
-      postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
-    }
-  }
-}
-
-export function emit(event: string, data: unknown) {
-  postMessage(JSON.stringify({ type: "rpc.event", event, data }))
-}
-
-export function client<T extends Definition>(target: {
-  postMessage: (data: string) => void | null
-  onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
-}) {
-  const pending = new Map<number, (result: any) => void>()
-  const listeners = new Map<string, Set<(data: any) => void>>()
-  let id = 0
-  target.onmessage = async (evt) => {
-    const parsed = JSON.parse(evt.data)
-    if (parsed.type === "rpc.result") {
-      const resolve = pending.get(parsed.id)
-      if (resolve) {
-        resolve(parsed.result)
-        pending.delete(parsed.id)
-      }
-    }
-    if (parsed.type === "rpc.event") {
-      const handlers = listeners.get(parsed.event)
-      if (handlers) {
-        for (const handler of handlers) {
-          handler(parsed.data)
-        }
-      }
-    }
-  }
-  return {
-    call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
-      const requestId = id++
-      return new Promise((resolve) => {
-        pending.set(requestId, resolve)
-        target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
-      })
-    },
-    on<Data>(event: string, handler: (data: Data) => void) {
-      let handlers = listeners.get(event)
-      if (!handlers) {
-        handlers = new Set()
-        listeners.set(event, handlers)
-      }
-      handlers.add(handler)
-      return () => {
-        handlers!.delete(handler)
-      }
-    },
-  }
-}
-
-export * as Rpc from "./rpc"

package/src/util/signal.ts

@@ -1,12 +0,0 @@
-export function signal() {
-  let resolve: any
-  const promise = new Promise((r) => (resolve = r))
-  return {
-    trigger() {
-      return resolve()
-    },
-    wait() {
-      return promise
-    },
-  }
-}

package/src/util/timeout.ts

@@ -1,13 +0,0 @@
-export function withTimeout<T>(promise: Promise<T>, ms: number, label?: string): Promise<T> {
-  let timeout: NodeJS.Timeout
-  return Promise.race([
-    promise.finally(() => {
-      clearTimeout(timeout)
-    }),
-    new Promise<never>((_, reject) => {
-      timeout = setTimeout(() => {
-        reject(new Error(label ?? `Operation timed out after ${ms}ms`))
-      }, ms)
-    }),
-  ])
-}

package/src/util/token.ts

@@ -1 +0,0 @@
-export { Token, estimate } from "@miaw/core/util/token"

package/src/util/wildcard.ts

@@ -1,59 +0,0 @@
-import { sortBy, pipe } from "remeda"
-
-export function match(str: string, pattern: string) {
-  if (str) str = str.replaceAll("\\", "/")
-  if (pattern) pattern = pattern.replaceAll("\\", "/")
-  let escaped = pattern
-    .replace(/[.+^${}()|[\]\\]/g, "\\$&") // escape special regex chars
-    .replace(/\*/g, ".*") // * becomes .*
-    .replace(/\?/g, ".") // ? becomes .
-
-  // If pattern ends with " *" (space + wildcard), make the trailing part optional
-  // This allows "ls *" to match both "ls" and "ls -la"
-  if (escaped.endsWith(" .*")) {
-    escaped = escaped.slice(0, -3) + "( .*)?"
-  }
-
-  const flags = process.platform === "win32" ? "si" : "s"
-  return new RegExp("^" + escaped + "$", flags).test(str)
-}
-
-export function all(input: string, patterns: Record<string, any>) {
-  const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
-  let result = undefined
-  for (const [pattern, value] of sorted) {
-    if (match(input, pattern)) {
-      result = value
-      continue
-    }
-  }
-  return result
-}
-
-export function allStructured(input: { head: string; tail: string[] }, patterns: Record<string, any>) {
-  const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
-  let result = undefined
-  for (const [pattern, value] of sorted) {
-    const parts = pattern.split(/\s+/)
-    if (!match(input.head, parts[0])) continue
-    if (parts.length === 1 || matchSequence(input.tail, parts.slice(1))) {
-      result = value
-      continue
-    }
-  }
-  return result
-}
-
-function matchSequence(items: string[], patterns: string[]): boolean {
-  if (patterns.length === 0) return true
-  const [pattern, ...rest] = patterns
-  if (pattern === "*") return matchSequence(items, rest)
-  for (let i = 0; i < items.length; i++) {
-    if (match(items[i], pattern) && matchSequence(items.slice(i + 1), rest)) {
-      return true
-    }
-  }
-  return false
-}
-
-export * as Wildcard from "./wildcard"