traw 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "traw",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "module": "src/index.ts",
   "type": "module",
   "bin": {

package/readme.md

@@ -30,12 +30,12 @@ Traw is a simple and fast neuro agent that browses the internet instead of you
 
 ```bash
 # install the traw
-git clone https://github.com/zarazaex69/traw
-cd traw
-bun install
+bun add -g traw
+# or 
+npm i -g traw
 
 # auth the traw 
-bun run traw auth
+bun run traw auth glm
  # mo server not found. install mo? [Y/n] Y 
 ```
 <div align="center">

package/src/cli/help.ts

@@ -6,32 +6,41 @@ traw v${VERSION} - AI browser agent
 
 Usage:
   traw run "your goal here"
-  traw auth
+  traw auth <provider>
   traw upd
 
 Commands:
-  run           execute browser agent with a goal
-  auth          register new account and set as default
-  upd           check for updates
+  run                    execute browser agent with a goal
+  auth qwen              register qwen account (chat.qwen.ai)
+  auth glm               register glm account (z.ai)
+  auth list [provider]   list tokens (all or by provider)
+  auth activate <id>     activate token by id
+  upd                    check for updates
+
+Models:
+  qwen: coder-model (default), vision-model (--fast)
+  glm:  GLM-4-Plus, GLM-4-Flash, GLM-4-Air, GLM-4-6-API-V1
 
 Options:
-  --fast        use fast model (glm-4-flash, no thinking)
+  --fast        use fast model (vision-model for qwen, GLM-4-Flash for glm)
   --headless    run without visible browser (default)
   --headed      show browser window
   --video       enable video recording
-  --vision      send screenshots to AI (visual mode)
   --steps=N     max steps (default: 20)
   --mo=URL      mo server url (default: http://localhost:8804)
   --api=URL     custom OpenAI-compatible API url (bypasses mo)
   --api-key=KEY API key for custom endpoint (or use OPENAI_API_KEY env)
-  --model=NAME  model name (default: glm-4.7)
+  --model=NAME  model name (default: coder-model)
   -v, --version show version
 
 Examples:
-  traw auth
+  traw auth qwen
+  traw auth glm
+  traw auth list
+  traw auth activate abc123
   traw run "find the weather in Moscow"
+  traw run --model=GLM-4-Plus "search for news"
   traw run --fast "quick search for bun.js"
   traw run --video "search for documentation"
-  traw run --api=https://api.openai.com --model=gpt-4o "search for news"
 `)
 }

package/src/cli/index.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import { parseArgs } from "util"
 import { Agent } from "../agent/agent"
 import type { AgentConfig } from "../types"
 import { log, setSilent } from "../utils/log"
@@ -9,11 +10,34 @@ import { checkFirstRun, markFirstRunDone, showStarBanner } from "../utils/first-
 
 const DEFAULT_MO_PORT = 8804
 
+const cliOptions = {
+  help: { type: "boolean" as const, short: "h" as const },
+  version: { type: "boolean" as const, short: "v" as const },
+  headless: { type: "boolean" as const },
+  headed: { type: "boolean" as const },
+  video: { type: "boolean" as const },
+  fast: { type: "boolean" as const },
+  debug: { type: "boolean" as const },
+  json: { type: "boolean" as const },
+  steps: { type: "string" as const },
+  mo: { type: "string" as const },
+  api: { type: "string" as const },
+  "api-key": { type: "string" as const },
+  model: { type: "string" as const },
+}
+
+type Provider = "qwen" | "glm"
+
+const providerModels: Record<Provider, { default: string; fast: string }> = {
+  qwen: { default: "coder-model", fast: "vision-model" },
+  glm: { default: "GLM-4-Plus", fast: "GLM-4-Flash" },
+}
+
 const defaultConfig: AgentConfig = {
   moUrl: `http://localhost:${DEFAULT_MO_PORT}`,
   apiUrl: undefined,
   apiKey: process.env.OPENAI_API_KEY || process.env.API_KEY,
-  model: "glm-4.7",
+  model: "coder-model",
   thinking: true,
   headless: true,
   recordVideo: false,
@@ -31,12 +55,10 @@ async function prompt(question: string): Promise<string> {
 }
 
 async function ensureMo(moUrl: string): Promise<boolean> {
-  // check if mo is already running
   if (await pingMo(moUrl)) {
     return true
   }
 
-  // mo not running, check if installed
   const installed = await isMoInstalled()
 
   if (!installed) {
@@ -54,7 +76,6 @@ async function ensureMo(moUrl: string): Promise<boolean> {
     }
   }
 
-  // start mo
   try {
     const port = parseInt(new URL(moUrl).port) || DEFAULT_MO_PORT
     await startMo(port)
@@ -65,11 +86,13 @@ async function ensureMo(moUrl: string): Promise<boolean> {
   }
 }
 
-async function registerAccount(moUrl: string): Promise<void> {
-  log.info("registering new account...")
+async function registerAccount(moUrl: string, provider: Provider): Promise<void> {
+  log.info(`registering new ${provider} account...`)
   log.info("browser will open for captcha solving")
 
-  const resp = await fetch(`${moUrl}/auth/register`, {
+  const endpoint = provider === "qwen" ? "/auth/qwen/register" : "/auth/glm/register"
+
+  const resp = await fetch(`${moUrl}${endpoint}`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
   })
@@ -81,7 +104,7 @@ async function registerAccount(moUrl: string): Promise<void> {
 
   const data = await resp.json() as {
     success: boolean
-    token: { id: string; email: string; active: boolean }
+    token: { id: string; email: string; is_active: boolean }
   }
 
   if (!data.success) {
@@ -90,32 +113,91 @@ async function registerAccount(moUrl: string): Promise<void> {
 
   log.success(`registered: ${data.token.email}`)
   log.info(`token id: ${data.token.id}`)
+  log.info(`provider: ${provider}`)
   log.info("token is now active and ready to use")
 }
 
+async function listTokens(moUrl: string, provider: Provider): Promise<void> {
+  const endpoint = `/auth/${provider}/tokens`
+
+  const resp = await fetch(`${moUrl}${endpoint}`)
+  if (!resp.ok) {
+    throw new Error(`failed to list tokens: ${resp.status}`)
+  }
+
+  const data = await resp.json() as {
+    tokens: Array<{
+      id: string
+      email: string
+      provider: string
+      is_active: boolean
+      created_at: string
+    }>
+  }
+
+  if (!data.tokens || data.tokens.length === 0) {
+    log.info(`no ${provider} tokens found`)
+    return
+  }
+
+  console.log()
+  log.info(`${provider} tokens:`)
+  for (const t of data.tokens) {
+    const active = t.is_active ? " [active]" : ""
+    console.log(`  ${t.id} - ${t.email}${active}`)
+  }
+  console.log()
+}
+
+async function activateToken(moUrl: string, tokenId: string): Promise<void> {
+  const providers: Provider[] = ["qwen", "glm"]
+
+  for (const provider of providers) {
+    const resp = await fetch(`${moUrl}/auth/${provider}/tokens/${tokenId}/activate`, {
+      method: "POST",
+    })
+
+    if (resp.ok) {
+      log.success(`token ${tokenId} activated`)
+      return
+    }
+  }
+
+  throw new Error(`token ${tokenId} not found`)
+}
+
+function detectProviderFromModel(model: string): Provider {
+  if (model.startsWith("coder-") || model.startsWith("vision-")) {
+    return "qwen"
+  }
+  return "glm"
+}
+
 async function main() {
-  const args = process.argv.slice(2)
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: cliOptions,
+    allowPositionals: true,
+    strict: false,
+  })
 
-  // show star banner on first run (non-blocking)
   if (await checkFirstRun()) {
     showStarBanner()
     await markFirstRunDone()
   }
 
-  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+  if (positionals.length === 0 || values.help) {
     printHelp()
     return
   }
 
-  const cmd = args[0]
-
-  // handle version command
-  if (cmd === "--version" || cmd === "-v") {
+  if (values.version) {
     console.log(`traw ${VERSION}`)
     return
   }
 
-  // handle update check command
+  const cmd = positionals[0]
+
   if (cmd === "upd" || cmd === "update") {
     log.info(`current version: ${VERSION}`)
     log.info("checking for updates...")
@@ -136,21 +218,42 @@ async function main() {
     return
   }
 
-  // handle auth command
   if (cmd === "auth") {
-    let moUrl = defaultConfig.moUrl
-    for (let i = 1; i < args.length; i++) {
-      if (args[i].startsWith("--mo=")) {
-        moUrl = args[i].split("=")[1]
-      }
-    }
+    const moUrl = typeof values.mo === "string" ? values.mo : defaultConfig.moUrl
+    const subCmd = positionals[1]
 
     if (!await ensureMo(moUrl)) {
       process.exit(1)
     }
 
     try {
-      await registerAccount(moUrl)
+      if (subCmd === "qwen") {
+        await registerAccount(moUrl, "qwen")
+      } else if (subCmd === "glm") {
+        await registerAccount(moUrl, "glm")
+      } else if (subCmd === "list") {
+        const provider = positionals[2] as Provider | undefined
+        if (provider && (provider === "qwen" || provider === "glm")) {
+          await listTokens(moUrl, provider)
+        } else {
+          await listTokens(moUrl, "qwen")
+          await listTokens(moUrl, "glm")
+        }
+      } else if (subCmd === "activate") {
+        const tokenId = positionals[2]
+        if (!tokenId) {
+          log.error("provide token id: traw auth activate <id>")
+          process.exit(1)
+        }
+        await activateToken(moUrl, tokenId)
+      } else {
+        log.error("usage: traw auth <qwen|glm|list|activate>")
+        log.info("  traw auth qwen     - register qwen account")
+        log.info("  traw auth glm      - register glm/z.ai account")
+        log.info("  traw auth list     - list all tokens")
+        log.info("  traw auth activate <id> - activate token")
+        process.exit(1)
+      }
     } catch (err: any) {
       log.error(err.message)
       process.exit(1)
@@ -165,82 +268,53 @@ async function main() {
     process.exit(1)
   }
 
-  const config = { ...defaultConfig }
-  const goalParts: string[] = []
+  const moUrl = typeof values.mo === "string" ? values.mo : defaultConfig.moUrl
+  const apiUrl = typeof values.api === "string" ? values.api : undefined
+  const apiKey = typeof values["api-key"] === "string" ? values["api-key"] : defaultConfig.apiKey
 
-  for (let i = 1; i < args.length; i++) {
-    const arg = args[i]
+  let model: string
+  if (typeof values.model === "string") {
+    model = values.model
+  } else {
+    const provider: Provider = "qwen"
+    model = values.fast ? providerModels[provider].fast : providerModels[provider].default
+  }
 
-    if (arg === "--headless") {
-      config.headless = true
-      continue
-    }
-    if (arg === "--no-headless" || arg === "--headed") {
-      config.headless = false
-      continue
-    }
-    if (arg === "--video") {
-      config.recordVideo = true
-      continue
-    }
-    if (arg === "--fast") {
-      config.model = "0727-106B-API"
-      config.thinking = false
-      continue
-    }
-    if (arg === "--debug") {
-      config.debug = true
-      continue
-    }
-    if (arg === "--json") {
-      config.jsonOutput = true
-      continue
-    }
-    if (arg.startsWith("--steps=")) {
-      config.maxSteps = parseInt(arg.split("=")[1])
-      continue
-    }
-    if (arg.startsWith("--mo=")) {
-      config.moUrl = arg.split("=")[1]
-      continue
-    }
-    if (arg.startsWith("--api=")) {
-      config.apiUrl = arg.split("=")[1]
-      continue
-    }
-    if (arg.startsWith("--api-key=")) {
-      config.apiKey = arg.split("=")[1]
-      continue
-    }
-    if (arg.startsWith("--model=")) {
-      config.model = arg.split("=")[1]
-      continue
-    }
-    if (!arg.startsWith("--")) {
-      goalParts.push(arg)
-    }
+  const steps = typeof values.steps === "string" ? parseInt(values.steps) : defaultConfig.maxSteps
+
+  const config: AgentConfig = {
+    moUrl,
+    apiUrl,
+    apiKey,
+    model,
+    thinking: values.fast !== true,
+    headless: values.headed === true ? false : (values.headless === true || defaultConfig.headless),
+    recordVideo: values.video === true,
+    maxSteps: steps,
+    debug: values.debug === true,
+    jsonOutput: values.json === true,
   }
 
-  const goal = goalParts.join(" ")
+  const goal = positionals.slice(1).join(" ")
   if (!goal) {
-    log.error("provide a goal: bun run traw run \"your goal\"")
+    log.error("provide a goal: traw run \"your goal\"")
     process.exit(1)
   }
 
   if (!config.jsonOutput) {
     log.header(goal)
     log.config({
-      api: config.apiUrl || config.moUrl,
+      mo: config.apiUrl || config.moUrl,
       model: config.model,
       headless: config.headless,
       video: config.recordVideo,
+      vision: false,
       steps: config.maxSteps,
     })
   } else {
     setSilent(true)
   }
 
-  // skip mo setup if using custom api
   if (!config.apiUrl && !await ensureMo(config.moUrl)) {
     process.exit(1)
   }