traw 0.2.2

package/src/utils/log.ts

@@ -0,0 +1,222 @@
+import { markdown } from "markdownly.js"
+
+let silent = false
+
+export function setSilent(value: boolean) {
+  silent = value
+}
+
+function renderMd(text: string): string {
+  try {
+    return markdown(text).trim()
+  } catch {
+    return text
+  }
+}
+
+const c = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  bold: "\x1b[1m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  magenta: "\x1b[35m",
+  blue: "\x1b[34m",
+  gray: "\x1b[90m",
+}
+
+const icons = {
+  arrow: "→",
+  check: "✓",
+  cross: "✗",
+  dot: "(0)",
+  circle: "○",
+  brain: "!",
+  play: ">",
+}
+
+class Spinner {
+  private frames = [".", "..", "..."]
+  private idx = 0
+  private interval: ReturnType<typeof setInterval> | null = null
+  private label: string
+
+  constructor(label: string) {
+    this.label = label
+  }
+
+  start() {
+    process.stdout.write("\x1b[?25l")
+    process.stdout.write(`  ${c.dim}${this.label}...${c.reset}`)
+    this.interval = setInterval(() => {
+      this.idx = (this.idx + 1) % this.frames.length
+      process.stdout.write(`\r\x1b[K  ${c.dim}${this.label}${this.frames[this.idx]}${c.reset}`)
+    }, 250)
+  }
+
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval)
+      this.interval = null
+    }
+    process.stdout.write(`\r\x1b[K`)
+    process.stdout.write("\x1b[?25h")
+  }
+}
+
+let loadSpinner: Spinner | null = null
+let receiveSpinner: Spinner | null = null
+let openSpinner: Spinner | null = null
+
+export const log = {
+  header: (goal: string) => {
+    if (silent) return
+    console.log()
+    console.log(`${c.yellow}${icons.play}${c.reset} ${goal}`)
+    console.log()
+  },
+
+  config: (opts: { mo: string; model: string; headless: boolean; video: boolean; vision: boolean; steps: number }) => {
+    if (silent) return
+    const parts = [
+      `${c.dim}${opts.model}${c.reset}`,
+      opts.headless ? `${c.dim}headless${c.reset}` : null,
+      opts.video ? `${c.dim}video${c.reset}` : null,
+      opts.vision ? `${c.dim}vision${c.reset}` : null,
+      `${c.dim}steps:${c.reset} ${opts.steps}`,
+    ].filter(Boolean)
+    console.log(`  ${parts.join("  ")}`)
+    console.log()
+  },
+
+  plan: (text: string) => {
+    if (silent) return
+    console.log(renderMd(text))
+    console.log()
+  },
+
+  step: (n: number, total: number, url: string) => {
+    if (silent) return
+    const shortUrl = url.length > 50 ? url.slice(0, 47) + "..." : url
+    console.log(`${c.magenta}${icons.dot}${c.reset} ${c.bold}${n}/${total}${c.reset} ${c.dim}${shortUrl}${c.reset}`)
+  },
+
+  thought: (msg: string) => {
+    if (silent) return
+    const short = msg.length > 80 ? msg.slice(0, 77) + "..." : msg
+    console.log(`  ${c.bold}${c.yellow}${icons.brain}${c.reset} ${c.gray}${short}${c.reset}`)
+  },
+
+  action: (type: string, target?: string) => {
+    if (silent) return
+    const t = target ? ` ${c.dim}${target}${c.reset}` : ""
+    console.log(`  ${c.blue}${icons.arrow}${c.reset} ${type}${t}`)
+  },
+
+  ok: (msg?: string) => {
+    if (silent) return
+    if (msg) {
+      const short = msg.length > 60 ? msg.slice(0, 57) + "..." : msg
+      console.log(`  ${c.green}${icons.check}${c.reset} ${c.dim}${short}${c.reset}`)
+    }
+  },
+
+  fail: (msg: string) => {
+    if (silent) return
+    const short = msg.length > 60 ? msg.slice(0, 57) + "..." : msg
+    console.log(`  ${c.red}${icons.cross}${c.reset} ${short}`)
+  },
+
+  done: (steps: number, reason?: string) => {
+    if (silent) return
+    console.log()
+    console.log(`${c.green}${icons.check} done${c.reset} ${c.dim}in ${steps} steps${c.reset}`)
+    if (reason) {
+      console.log()
+      console.log(renderMd(reason))
+    }
+  },
+
+  stats: (totalMs: number, aiMs: number, browserMs: number) => {
+    if (silent) return
+    const fmt = (ms: number) => (ms / 1000).toFixed(1) + "s"
+    console.log()
+    console.log(`${c.dim}total:${c.reset}   ${fmt(totalMs)}`)
+    console.log(`${c.dim}neuro:${c.reset}      ${fmt(aiMs)} ${c.dim}(${Math.round(aiMs / totalMs * 100)}%)${c.reset}`)
+    console.log(`${c.dim}browser:${c.reset} ${fmt(browserMs)} ${c.dim}(${Math.round(browserMs / totalMs * 100)}%)${c.reset}`)
+  },
+
+  video: (path: string) => {
+    if (silent) return
+    console.log(`${c.dim}${icons.circle} video: ${path}${c.reset}`)
+  },
+
+  error: (msg: string) => {
+    // errors always print, even in silent mode
+    console.error(`${c.red}${icons.cross} ${msg}${c.reset}`)
+  },
+
+  info: (msg: string) => {
+    if (silent) return
+    console.log(`${c.cyan}${icons.arrow}${c.reset} ${msg}`)
+  },
+
+  success: (msg: string) => {
+    if (silent) return
+    console.log(`${c.green}${icons.check}${c.reset} ${msg}`)
+  },
+
+  planning: () => {
+    if (silent) return
+    process.stdout.write(`${c.dim}planning...${c.reset}`)
+  },
+
+  planDone: () => {
+    if (silent) return
+    process.stdout.write(`\r${c.dim}planning... done${c.reset}\n\n`)
+  },
+
+  loadStart: () => {
+    if (silent) return
+    loadSpinner = new Spinner("load")
+    loadSpinner.start()
+  },
+
+  loadStop: () => {
+    if (silent) return
+    if (loadSpinner) {
+      loadSpinner.stop()
+      loadSpinner = null
+    }
+  },
+
+  receiveStart: () => {
+    if (silent) return
+    receiveSpinner = new Spinner("receive")
+    receiveSpinner.start()
+  },
+
+  receiveStop: () => {
+    if (silent) return
+    if (receiveSpinner) {
+      receiveSpinner.stop()
+      receiveSpinner = null
+    }
+  },
+
+  openStart: () => {
+    if (silent) return
+    openSpinner = new Spinner("opening")
+    openSpinner.start()
+  },
+
+  openStop: () => {
+    if (silent) return
+    if (openSpinner) {
+      openSpinner.stop()
+      openSpinner = null
+    }
+  },
+}

package/src/utils/mo-manager.ts

@@ -0,0 +1,153 @@
+import { spawn, type Subprocess } from "bun"
+import { homedir } from "os"
+import { join } from "path"
+import { log } from "./log"
+
+const MO_REPO = "zarazaex69/mo"
+const CONFIG_DIR = join(homedir(), ".config", "traw")
+const MO_BIN = join(CONFIG_DIR, "mo")
+const MO_CONFIG_DIR = join(CONFIG_DIR, "configs")
+const MO_CONFIG = join(MO_CONFIG_DIR, "config.yaml")
+const CONFIG_URL = "https://raw.githubusercontent.com/zarazaex69/mo/main/configs/config.yaml"
+
+let moProcess: Subprocess | null = null
+
+function getPlatformAsset(): string {
+  const platform = process.platform
+  const arch = process.arch
+
+  if (platform === "linux" && arch === "x64") return "mo-linux-amd64"
+  if (platform === "linux" && arch === "arm64") return "mo-linux-arm64"
+  if (platform === "darwin" && arch === "x64") return "mo-darwin-amd64"
+  if (platform === "darwin" && arch === "arm64") return "mo-darwin-arm64"
+
+  throw new Error(`unsupported platform: ${platform}-${arch}`)
+}
+
+async function getLatestRelease(): Promise<{ tag: string; url: string }> {
+  const resp = await fetch(`https://api.github.com/repos/${MO_REPO}/releases/latest`)
+  if (!resp.ok) throw new Error("failed to fetch latest release")
+
+  const data = await resp.json() as { tag_name: string; assets: { name: string; browser_download_url: string }[] }
+  const asset = getPlatformAsset()
+  const tarball = data.assets.find(a => a.name === `${asset}.tar.gz`)
+
+  if (!tarball) throw new Error(`no binary for ${asset}`)
+
+  return { tag: data.tag_name, url: tarball.browser_download_url }
+}
+
+export async function pingMo(url: string): Promise<boolean> {
+  try {
+    const resp = await fetch(`${url}/health`, { signal: AbortSignal.timeout(2000) })
+    return resp.ok
+  } catch {
+    return false
+  }
+}
+
+export async function isMoInstalled(): Promise<boolean> {
+  return await Bun.file(MO_BIN).exists()
+}
+
+export async function downloadMo(): Promise<void> {
+  log.info("fetching latest mo release...")
+
+  const { tag, url } = await getLatestRelease()
+  log.info(`downloading mo ${tag}...`)
+
+  // ensure config dir exists
+  await Bun.write(join(CONFIG_DIR, ".keep"), "")
+  await Bun.write(join(MO_CONFIG_DIR, ".keep"), "")
+
+  const resp = await fetch(url)
+  if (!resp.ok) throw new Error("download failed")
+
+  const tarPath = join(CONFIG_DIR, "mo.tar.gz")
+  await Bun.write(tarPath, resp)
+
+  // extract tarball
+  const proc = spawn(["tar", "-xzf", tarPath, "-C", CONFIG_DIR], { stdout: "ignore", stderr: "pipe" })
+  await proc.exited
+
+  if (proc.exitCode !== 0) {
+    throw new Error("failed to extract mo")
+  }
+
+  // rename extracted binary to just "mo"
+  const asset = getPlatformAsset()
+  const extractedPath = join(CONFIG_DIR, asset)
+
+  if (await Bun.file(extractedPath).exists()) {
+    const content = await Bun.file(extractedPath).arrayBuffer()
+    await Bun.write(MO_BIN, content)
+    await Bun.spawn(["rm", extractedPath]).exited
+  }
+
+  // make executable
+  await Bun.spawn(["chmod", "+x", MO_BIN]).exited
+
+  // cleanup
+  await Bun.spawn(["rm", tarPath]).exited
+
+  // download config if not exists
+  if (!await Bun.file(MO_CONFIG).exists()) {
+    log.info("downloading config...")
+    const cfgResp = await fetch(CONFIG_URL)
+    if (cfgResp.ok) {
+      await Bun.write(MO_CONFIG, cfgResp)
+    }
+  }
+
+  log.success(`mo ${tag} installed`)
+}
+
+export async function startMo(port: number): Promise<void> {
+  if (!await isMoInstalled()) {
+    throw new Error("mo not installed")
+  }
+
+  log.info("starting mo server...")
+
+  const configExists = await Bun.file(MO_CONFIG).exists()
+  if (!configExists) {
+    throw new Error(`config not found: ${MO_CONFIG}`)
+  }
+
+  moProcess = spawn([MO_BIN, "--config", MO_CONFIG, "--port", String(port)], {
+    stdout: "ignore",
+    stderr: "ignore",
+    env: { ...process.env, MO_DATA_PATH: CONFIG_DIR },
+  })
+
+  // wait for server to be ready
+  const maxWait = 10000
+  const start = Date.now()
+
+  while (Date.now() - start < maxWait) {
+    // check if process died
+    if (moProcess.exitCode !== null) {
+      throw new Error(`mo exited with code ${moProcess.exitCode}`)
+    }
+
+    if (await pingMo(`http://localhost:${port}`)) {
+      log.success("mo server ready")
+      return
+    }
+    await Bun.sleep(300)
+  }
+
+  throw new Error("mo server failed to start (timeout)")
+}
+
+export function stopMo(): void {
+  if (moProcess) {
+    moProcess.kill()
+    moProcess = null
+  }
+}
+
+// cleanup on exit
+process.on("exit", stopMo)
+process.on("SIGINT", () => { stopMo(); process.exit(0) })
+process.on("SIGTERM", () => { stopMo(); process.exit(0) })

package/src/utils/notify.ts

@@ -0,0 +1,31 @@
+// desktop notifications via notify-send (linux)
+import { $ } from "bun"
+
+let hasNotifySend: boolean | null = null
+
+export async function checkNotify(): Promise<boolean> {
+  if (hasNotifySend !== null) return hasNotifySend
+
+  try {
+    await $`which notify-send`.quiet()
+    hasNotifySend = true
+  } catch {
+    hasNotifySend = false
+  }
+
+  return hasNotifySend
+}
+
+export async function notify(title: string, body?: string): Promise<void> {
+  if (!hasNotifySend) return
+
+  try {
+    if (body) {
+      await $`notify-send ${title} ${body}`.quiet()
+    } else {
+      await $`notify-send ${title}`.quiet()
+    }
+  } catch {
+    // ignore notification errors
+  }
+}

package/src/utils/version.ts

@@ -0,0 +1,39 @@
+import pkg from "../../package.json"
+
+export const VERSION = pkg.version
+
+const GITHUB_REPO = "zarazaex69/traw"
+const RELEASES_API = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`
+
+interface GithubRelease {
+  tag_name: string
+  html_url: string
+}
+
+export async function checkForUpdates(): Promise<{
+  hasUpdate: boolean
+  current: string
+  latest: string
+  url: string
+} | null> {
+  try {
+    const resp = await fetch(RELEASES_API, {
+      headers: { "User-Agent": "traw-cli" },
+    })
+
+    if (!resp.ok) return null
+
+    const release = await resp.json() as GithubRelease
+    const latest = release.tag_name.replace(/^v/, "")
+    const current = VERSION.replace(/^v/, "")
+
+    return {
+      hasUpdate: latest !== current,
+      current: VERSION,
+      latest: release.tag_name,
+      url: release.html_url,
+    }
+  } catch {
+    return null
+  }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": false,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}