jonsoc 1.1.48 → 1.1.50

package/src/index.ts

@@ -1,208 +0,0 @@
-import path from "path"
-import { existsSync } from "fs"
-
-const workdir = process.env.JONSOC_WORKDIR ?? process.env.JOC_WORKDIR ?? process.env.OPENCODE_WORKDIR
-if (workdir && existsSync(workdir)) {
-  process.chdir(workdir)
-}
-
-const localDevFlag = process.env.JONSOC_LOCAL_DEV ?? process.env.OPENCODE_LOCAL_DEV
-
-async function shouldRunLocalDev(cwd: string) {
-  if (localDevFlag) return false
-  const pkgFile = Bun.file(path.join(cwd, "package.json"))
-  const pkg = await pkgFile.json().catch(() => undefined)
-  const name = typeof pkg?.name === "string" ? pkg.name : ""
-  const isRoot = name === "jonsoc" || name === "jonsoc"
-  if (!isRoot) return false
-  const entry = Bun.file(path.join(cwd, "packages", "jonsoc", "src", "index.ts"))
-  return entry.exists()
-}
-
-if (await shouldRunLocalDev(process.cwd())) {
-  const args = process.argv.slice(2)
-  const bunPath = process.execPath
-  process.stdout.write(`$ ${bunPath} run dev ${args.join(" ")}`.trimEnd() + "\n")
-  const child = Bun.spawn({
-    cmd: [bunPath, "run", "dev", ...args],
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-    cwd: process.cwd(),
-    env: {
-      ...process.env,
-      JONSOC_WORKDIR: process.env.JONSOC_WORKDIR ?? process.env.JOC_WORKDIR ?? process.cwd(),
-      JONSOC_LOCAL_DEV: "1",
-      OPENCODE_LOCAL_DEV: "1",
-    },
-  })
-  process.exit(await child.exited)
-}
-
-await runCli()
-
-async function runCli() {
-  const yargsModule = await import("yargs")
-  const yargs = yargsModule.default
-  const { hideBin } = await import("yargs/helpers")
-  const { RunCommand } = await import("./cli/cmd/run")
-  const { GenerateCommand } = await import("./cli/cmd/generate")
-  const { Log } = await import("./util/log")
-  const { AuthCommand } = await import("./cli/cmd/auth")
-  const { AgentCommand } = await import("./cli/cmd/agent")
-  const { UpgradeCommand } = await import("./cli/cmd/upgrade")
-  const { UninstallCommand } = await import("./cli/cmd/uninstall")
-  const { ModelsCommand } = await import("./cli/cmd/models")
-  const { UI } = await import("./cli/ui")
-  const { Installation } = await import("./installation")
-  const { NamedError } = await import("@jonsoc/util/error")
-  const { FormatError } = await import("./cli/error")
-  const { ServeCommand } = await import("./cli/cmd/serve")
-  const { DebugCommand } = await import("./cli/cmd/debug")
-  const { StatsCommand } = await import("./cli/cmd/stats")
-  const { McpCommand } = await import("./cli/cmd/mcp")
-  const { GithubCommand } = await import("./cli/cmd/github")
-  const { ExportCommand } = await import("./cli/cmd/export")
-  const { ImportCommand } = await import("./cli/cmd/import")
-  const { AttachCommand } = await import("./cli/cmd/tui/attach")
-  const { TuiThreadCommand } = await import("./cli/cmd/tui/thread")
-  const { AcpCommand } = await import("./cli/cmd/acp")
-  const { EOL } = await import("os")
-  const { WebCommand } = await import("./cli/cmd/web")
-  const { PrCommand } = await import("./cli/cmd/pr")
-  const { SessionCommand } = await import("./cli/cmd/session")
-  const { Brand } = await import("./brand")
-
-  process.on("unhandledRejection", (e) => {
-    Log.Default.error("rejection", {
-      e: e instanceof Error ? e.message : e,
-    })
-  })
-
-  process.on("uncaughtException", (e) => {
-    Log.Default.error("exception", {
-      e: e instanceof Error ? e.message : e,
-    })
-  })
-
-  const cli = yargs(hideBin(process.argv))
-    .parserConfiguration({ "populate--": true })
-    .scriptName(Brand.CLI_NAME)
-    .wrap(100)
-    .help("help", "show help")
-    .alias("help", "h")
-    .version("version", "show version number", Installation.VERSION)
-    .alias("version", "v")
-    .option("print-logs", {
-      describe: "print logs to stderr",
-      type: "boolean",
-    })
-    .option("log-level", {
-      describe: "log level",
-      type: "string",
-      choices: ["DEBUG", "INFO", "WARN", "ERROR"],
-    })
-    .middleware(async (opts) => {
-      await Log.init({
-        print: process.argv.includes("--print-logs"),
-        dev: Installation.isLocal(),
-        level: (() => {
-          const level = opts.logLevel
-          if (level === "DEBUG" || level === "INFO" || level === "WARN" || level === "ERROR") return level
-          if (Installation.isLocal()) return "DEBUG"
-          return "INFO"
-        })(),
-      })
-
-      process.env.AGENT = "1"
-      process.env.JONSOC = "1"
-      process.env.OPENCODE = "1"
-
-      Log.Default.info(Brand.BRAND_LOWER, {
-        version: Installation.VERSION,
-        args: process.argv.slice(2),
-      })
-    })
-    .usage("\n" + UI.logo())
-    .completion("completion", "generate shell completion script")
-    .command(AcpCommand)
-    .command(McpCommand)
-    .command(TuiThreadCommand)
-    .command(AttachCommand)
-    .command(RunCommand)
-    .command(GenerateCommand)
-    .command(DebugCommand)
-    .command(AuthCommand)
-    .command(AgentCommand)
-    .command(UpgradeCommand)
-    .command(UninstallCommand)
-    .command(ServeCommand)
-    .command(WebCommand)
-    .command(ModelsCommand)
-    .command(StatsCommand)
-    .command(ExportCommand)
-    .command(ImportCommand)
-    .command(GithubCommand)
-    .command(PrCommand)
-    .command(SessionCommand)
-    .fail((msg, err) => {
-      if (
-        msg?.startsWith("Unknown argument") ||
-        msg?.startsWith("Not enough non-option arguments") ||
-        msg?.startsWith("Invalid values:")
-      ) {
-        if (err) throw err
-        cli.showHelp("log")
-      }
-      if (err) throw err
-      process.exit(1)
-    })
-    .strict()
-
-  try {
-    await cli.parse()
-  } catch (e) {
-    let data: Record<string, any> = {}
-    if (e instanceof NamedError) {
-      const obj = e.toObject()
-      Object.assign(data, {
-        ...obj.data,
-      })
-    }
-
-    if (e instanceof Error) {
-      Object.assign(data, {
-        name: e.name,
-        message: e.message,
-        cause: e.cause?.toString(),
-        stack: e.stack,
-      })
-    }
-
-    if (e instanceof ResolveMessage) {
-      Object.assign(data, {
-        name: e.name,
-        message: e.message,
-        code: e.code,
-        specifier: e.specifier,
-        referrer: e.referrer,
-        position: e.position,
-        importKind: e.importKind,
-      })
-    }
-    Log.Default.error("fatal", data)
-    const formatted = FormatError(e)
-    if (formatted) UI.error(formatted)
-    if (formatted === undefined) {
-      UI.error("Unexpected error, check log file at " + Log.file() + " for more details" + EOL)
-      console.error(e instanceof Error ? e.message : String(e))
-    }
-    process.exitCode = 1
-  } finally {
-    // Some subprocesses don't react properly to SIGTERM and similar signals.
-    // Most notably, some docker-container-based MCP servers don't handle such signals unless
-    // run using `docker run --init`.
-    // Explicitly exit to avoid any hanging subprocesses.
-    process.exit()
-  }
-}

package/src/installation/index.ts

@@ -1,258 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import path from "path"
-import { $ } from "bun"
-import z from "zod"
-import { NamedError } from "@jonsoc/util/error"
-import { Log } from "../util/log"
-import { iife } from "@/util/iife"
-import { Flag } from "../flag/flag"
-
-declare global {
-  const OPENCODE_VERSION: string
-  const OPENCODE_CHANNEL: string
-}
-
-import { Brand } from "../brand"
-
-export namespace Installation {
-  const log = Log.create({ service: "installation" })
-  const cliName = Brand.CLI_NAME
-  const legacyCliName = Brand.LEGACY_CLI_NAME
-  const npmPackage = Brand.NPM_PACKAGE
-  const legacyNpmPackage = Brand.LEGACY_NPM_PACKAGE
-  const repo = Brand.REPO.replace(/^https?:\/\/github\.com\//, "")
-  const installUrl = Brand.INSTALL_URL
-
-  export type Method = Awaited<ReturnType<typeof method>>
-
-  export const Event = {
-    Updated: BusEvent.define(
-      "installation.updated",
-      z.object({
-        version: z.string(),
-      }),
-    ),
-    UpdateAvailable: BusEvent.define(
-      "installation.update-available",
-      z.object({
-        version: z.string(),
-      }),
-    ),
-  }
-
-  export const Info = z
-    .object({
-      version: z.string(),
-      latest: z.string(),
-    })
-    .meta({
-      ref: "InstallationInfo",
-    })
-  export type Info = z.infer<typeof Info>
-
-  export async function info() {
-    return {
-      version: VERSION,
-      latest: await latest(),
-    }
-  }
-
-  export function isPreview() {
-    return CHANNEL !== "latest"
-  }
-
-  export function isLocal() {
-    return CHANNEL === "local"
-  }
-
-  export async function method() {
-    if (process.execPath.includes(path.join(".jonsoc", "bin"))) return "curl"
-    if (process.execPath.includes(path.join(".jonsoc", "bin"))) return "curl"
-    if (process.execPath.includes(path.join(".local", "bin"))) return "curl"
-    const exec = process.execPath.toLowerCase()
-
-    const checks = [
-      {
-        name: "npm" as const,
-        command: () => $`npm list -g --depth=0`.throws(false).quiet().text(),
-      },
-      {
-        name: "yarn" as const,
-        command: () => $`yarn global list`.throws(false).quiet().text(),
-      },
-      {
-        name: "pnpm" as const,
-        command: () => $`pnpm list -g --depth=0`.throws(false).quiet().text(),
-      },
-      {
-        name: "bun" as const,
-        command: () => $`bun pm ls -g`.throws(false).quiet().text(),
-      },
-      {
-        name: "brew" as const,
-        command: () => $`brew list --formula ${cliName}`.throws(false).quiet().text(),
-      },
-      {
-        name: "scoop" as const,
-        command: () => $`scoop list ${cliName}`.throws(false).quiet().text(),
-      },
-      {
-        name: "choco" as const,
-        command: () => $`choco list --limit-output ${cliName}`.throws(false).quiet().text(),
-      },
-    ]
-
-    checks.sort((a, b) => {
-      const aMatches = exec.includes(a.name)
-      const bMatches = exec.includes(b.name)
-      if (aMatches && !bMatches) return -1
-      if (!aMatches && bMatches) return 1
-      return 0
-    })
-
-    for (const check of checks) {
-      const output = await check.command()
-      const installedNames =
-        check.name === "brew" || check.name === "choco" || check.name === "scoop"
-          ? [cliName, legacyCliName]
-          : [npmPackage, legacyNpmPackage]
-      if (installedNames.some((name) => output.includes(name))) {
-        return check.name
-      }
-    }
-
-    return "unknown"
-  }
-
-  export const UpgradeFailedError = NamedError.create(
-    "UpgradeFailedError",
-    z.object({
-      stderr: z.string(),
-    }),
-  )
-
-  async function getBrewFormula() {
-    const tap = Brand.HOMEBREW_TAP
-    const tapFormula = await $`brew list --formula ${tap}/${cliName}`.throws(false).quiet().text()
-    if (tapFormula.includes(cliName)) return `${tap}/${cliName}`
-    const coreFormula = await $`brew list --formula ${cliName}`.throws(false).quiet().text()
-    if (coreFormula.includes(cliName)) return cliName
-    return cliName
-  }
-
-  export async function upgrade(method: Method, target: string) {
-    let cmd
-    switch (method) {
-      case "curl":
-        cmd = $`curl -fsSL ${installUrl} | bash`.env({
-          ...process.env,
-          VERSION: target,
-        })
-        break
-      case "npm":
-        cmd = $`npm install -g ${npmPackage}@${target}`
-        break
-      case "pnpm":
-        cmd = $`pnpm install -g ${npmPackage}@${target}`
-        break
-      case "bun":
-        cmd = $`bun install -g ${npmPackage}@${target}`
-        break
-      case "brew": {
-        const formula = await getBrewFormula()
-        cmd = $`brew upgrade ${formula}`.env({
-          HOMEBREW_NO_AUTO_UPDATE: "1",
-          ...process.env,
-        })
-        break
-      }
-      case "choco":
-        cmd = $`echo Y | choco upgrade ${cliName} --version=${target}`
-        break
-      case "scoop":
-        cmd = $`scoop install ${cliName}@${target}`
-        break
-      default:
-        throw new Error(`Unknown method: ${method}`)
-    }
-    const result = await cmd.quiet().throws(false)
-    if (result.exitCode !== 0) {
-      const stderr = method === "choco" ? "not running from an elevated command shell" : result.stderr.toString("utf8")
-      throw new UpgradeFailedError({
-        stderr: stderr,
-      })
-    }
-    log.info("upgraded", {
-      method,
-      target,
-      stdout: result.stdout.toString(),
-      stderr: result.stderr.toString(),
-    })
-    await $`${process.execPath} --version`.nothrow().quiet().text()
-  }
-
-  export const VERSION = typeof OPENCODE_VERSION === "string" ? OPENCODE_VERSION : "local"
-  export const CHANNEL = typeof OPENCODE_CHANNEL === "string" ? OPENCODE_CHANNEL : "local"
-  export const USER_AGENT = Brand.USER_AGENT
-
-  export async function latest(installMethod?: Method) {
-    const detectedMethod = installMethod || (await method())
-
-    if (detectedMethod === "brew") {
-      const formula = await getBrewFormula()
-      if (formula === cliName) {
-        return fetch(`https://formulae.brew.sh/api/formula/${cliName}.json`)
-          .then((res) => {
-            if (!res.ok) throw new Error(res.statusText)
-            return res.json()
-          })
-          .then((data: any) => data.versions.stable)
-      }
-    }
-
-    if (detectedMethod === "npm" || detectedMethod === "bun" || detectedMethod === "pnpm") {
-      const registry = await iife(async () => {
-        const r = (await $`npm config get registry`.quiet().nothrow().text()).trim()
-        const reg = r || "https://registry.npmjs.org"
-        return reg.endsWith("/") ? reg.slice(0, -1) : reg
-      })
-      const channel = CHANNEL
-      return fetch(`${registry}/${npmPackage}/${channel}`)
-        .then((res) => {
-          if (!res.ok) throw new Error(res.statusText)
-          return res.json()
-        })
-        .then((data: any) => data.version)
-    }
-
-    if (detectedMethod === "choco") {
-      return fetch(
-        `https://community.chocolatey.org/api/v2/Packages?$filter=Id%20eq%20%27${cliName}%27%20and%20IsLatestVersion&$select=Version`,
-        { headers: { Accept: "application/json;odata=verbose" } },
-      )
-        .then((res) => {
-          if (!res.ok) throw new Error(res.statusText)
-          return res.json()
-        })
-        .then((data: any) => data.d.results[0].Version)
-    }
-
-    if (detectedMethod === "scoop") {
-      return fetch(`https://raw.githubusercontent.com/ScoopInstaller/Main/master/bucket/${cliName}.json`, {
-        headers: { Accept: "application/json" },
-      })
-        .then((res) => {
-          if (!res.ok) throw new Error(res.statusText)
-          return res.json()
-        })
-        .then((data: any) => data.version)
-    }
-
-    return fetch(`https://api.github.com/repos/${repo}/releases/latest`)
-      .then((res) => {
-        if (!res.ok) throw new Error(res.statusText)
-        return res.json()
-      })
-      .then((data: any) => data.tag_name.replace(/^v/, ""))
-  }
-}