@pedrofariasx/qwenproxy 1.1.0

package/src/linter/structural-parser.ts

@@ -0,0 +1,352 @@
+/*
+ * Layer 2: Structural AST Parser (Tolerant)
+ * Builds partial AST from JSON-like structures without strict parsing
+ */
+
+import type { PartialASTNode, ToolCallSource } from './types'
+
+export interface StructuralParseResult {
+  ast: PartialASTNode | null
+  confidence: number
+  errors: string[]
+  sourceHint: ToolCallSource
+}
+
+export class StructuralParser {
+  private pos = 0
+  private text = ''
+  private errors: string[] = []
+
+  parse(text: string, sourceHint: ToolCallSource = 'unknown'): StructuralParseResult {
+    this.pos = 0
+    this.text = text.trim()
+    this.errors = []
+
+    if (this.text.length === 0) {
+      return { ast: null, confidence: 0, errors: ['Empty input'], sourceHint }
+    }
+
+    const nodes: PartialASTNode[] = []
+
+    while (this.pos < this.text.length) {
+      this.skipWhitespace()
+      if (this.pos >= this.text.length) break
+      const node = this.parseValue()
+      if (node) nodes.push(node)
+    }
+
+    if (nodes.length === 0) {
+      return { ast: null, confidence: 0, errors: ['No parseable content'], sourceHint }
+    }
+
+    const root: PartialASTNode = {
+      type: 'object',
+      raw: this.text,
+      confidence: this.calculateConfidence(nodes),
+    }
+    if (nodes.length === 1 && nodes[0].type === 'object' && nodes[0].value !== undefined) {
+      root.value = nodes[0].value
+      root.children = nodes[0].children
+    } else {
+      root.children = nodes
+    }
+
+    return { ast: root, confidence: root.confidence, errors: this.errors, sourceHint }
+  }
+
+  private parseValue(): PartialASTNode | undefined {
+    const char = this.peek()
+    if (char === '{') return this.parseObject()
+    if (char === '[') return this.parseArray()
+    if (char === '"' || char === "'") return this.parseString()
+    if (this.isNull(char)) return this.parseNull()
+    if (this.isBoolean(char)) return this.parseBoolean()
+    if (this.isNumberStart(char)) return this.parseNumber()
+    if (this.isUnquotedKey(char)) return this.parseUnquotedValue()
+    if (this.isReActAction(char)) return this.parseReActBlock()
+    return undefined
+  }
+
+  private parseObject(): PartialASTNode {
+    const start = this.pos
+    this.expect('{')
+    const children: PartialASTNode[] = []
+
+    while (this.pos < this.text.length) {
+      this.skipWhitespace()
+      if (this.peek() === '}') { this.pos++; break }
+
+      const key = this.parseKey()
+      if (!key) { this.pos++; this.errors.push(`Expected key at position ${this.pos}`); continue }
+
+      this.skipWhitespace()
+      this.expectOptional(':')
+      this.skipWhitespace()
+
+      let value: PartialASTNode | undefined
+      const ch = this.peek()
+      if (ch === '"' || ch === "'") value = this.parseString()
+      else if (ch === '{') value = this.parseObject()
+      else if (ch === '[') value = this.parseArray()
+      else value = this.parseScalar()
+
+      if (value) {
+        children.push({
+          type: 'object',
+          value: value.value,
+          raw: this.text.slice(start, this.pos),
+          confidence: 1,
+          children: [key, value],
+        })
+      }
+
+      this.skipWhitespace()
+      if (this.expectOptional(',')) {
+        this.skipWhitespace()
+        if (this.peek() === '}') break
+      }
+    }
+
+    const value: Record<string, unknown> = {}
+    for (const child of children) {
+      if (child.children && child.children.length >= 2) {
+        const key = child.children[0].value
+        const val = child.children[1].value
+        if (key !== undefined) value[key as string] = val
+      }
+    }
+
+    return {
+      type: 'object',
+      value,
+      raw: this.text.slice(start, this.pos),
+      confidence: this.calculateObjectConfidence(children),
+      children,
+    }
+  }
+
+  private parseArray(): PartialASTNode {
+    const start = this.pos
+    this.expect('[')
+    const children: PartialASTNode[] = []
+
+    while (this.pos < this.text.length) {
+      this.skipWhitespace()
+      if (this.peek() === ']') { this.pos++; break }
+      const value = this.parseValue()
+      if (value) children.push(value)
+      this.skipWhitespace()
+      this.expectOptional(',')
+    }
+
+    return {
+      type: 'array',
+      raw: this.text.slice(start, this.pos),
+      confidence: children.length > 0 ? 0.9 : 0.5,
+      children,
+    }
+  }
+
+  private parseString(): PartialASTNode {
+    const start = this.pos
+    const quote = this.peek()
+    this.expect(quote as '"' | "'")
+    let value = ''
+    try {
+      value = this.readStringContent(quote)
+    } catch {
+      this.errors.push(`Unterminated string at position ${start}`)
+      const content = this.text.slice(start + 1)
+      const idx = content.split('').findIndex((c, i) => c === quote && (i === 0 || content[i - 1] !== '\\'))
+      value = idx === -1 ? content : content.slice(0, idx)
+      this.pos = this.text.length
+    }
+    return { type: 'string', value, raw: this.text.slice(start, this.pos), confidence: 0.95 }
+  }
+
+  private readStringContent(quote: string): string {
+    let value = ''
+    while (this.pos < this.text.length) {
+      const char = this.text[this.pos++]
+      if (char === '\\' && this.pos < this.text.length) {
+        const next = this.text[this.pos++]
+        value += this.resolveEscapeSequence(char, next)
+        continue
+      }
+      if (char === quote) break
+      value += char
+    }
+    return value
+  }
+
+  private resolveEscapeSequence(_backslash: string, char: string): string {
+    const map: Record<string, string> = { n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', '"': '"', "'": "'", '\\': '\\', '0': '\0' }
+    return map[char] ?? _backslash + char
+  }
+
+  private parseKey(): PartialASTNode | undefined {
+    const start = this.pos
+    if (this.peek() === '"' || this.peek() === "'") {
+      const key = this.parseString()
+      return { type: 'string', value: key.value, raw: key.raw, confidence: 1 }
+    }
+
+    let key = ''
+    while (this.pos < this.text.length) {
+      const c = this.text[this.pos]
+      if (/[a-zA-Z0-9_\-]/.test(c)) { key += c; this.pos++ }
+      else break
+    }
+
+    if (key.length === 0) { this.pos = start; return undefined }
+  }
+
+  private parseScalar(): PartialASTNode | undefined {
+    const start = this.pos
+    let value = ''
+    while (this.pos < this.text.length) {
+      const c = this.text[this.pos]
+      if (c === ',' || c === '}' || c === ']' || c === '\n') break
+      value += c
+      this.pos++
+    }
+    value = value.trim()
+
+    if (value === 'true') return { type: 'boolean', value: true, raw: value, confidence: 1 }
+    if (value === 'false') return { type: 'boolean', value: false, raw: value, confidence: 1 }
+    if (value === 'null' || value === 'undefined') return { type: 'null', value: null, raw: value, confidence: 0.9 }
+    const num = Number(value)
+    if (!isNaN(num) && isFinite(num)) return { type: 'number', value: num, raw: value, confidence: 0.9 }
+    if (value.startsWith('"') && value.endsWith('"')) return { type: 'string', value: value.slice(1, -1), raw: value, confidence: 0.85 }
+    if (value.startsWith("'") && value.endsWith("'")) return { type: 'string', value: value.slice(1, -1), raw: value, confidence: 0.8 }
+    return { type: 'unknown', value, raw: value, confidence: 0.3 }
+  }
+
+  private parseUnquotedValue(): PartialASTNode | undefined {
+    const start = this.pos
+    let value = ''
+    while (this.pos < this.text.length) {
+      const c = this.text[this.pos]
+      if (/[a-zA-Z0-9_\- ]/.test(c)) { value += c; this.pos++ }
+      else break
+    }
+    if (value.length === 0) return undefined
+    return { type: 'unknown', value: value.trim(), raw: value, confidence: 0.5 }
+  }
+
+  private parseNull(): PartialASTNode | undefined {
+    if (this.text.slice(this.pos, this.pos + 4) === 'null') {
+      this.pos += 4
+      return { type: 'null', value: null, raw: 'null', confidence: 1 }
+    }
+    return undefined
+  }
+
+  private parseBoolean(): PartialASTNode | undefined {
+    if (this.text.slice(this.pos, this.pos + 4) === 'true') {
+      this.pos += 4
+      return { type: 'boolean', value: true, raw: 'true', confidence: 1 }
+    }
+    if (this.text.slice(this.pos, this.pos + 5) === 'false') {
+      this.pos += 5
+      return { type: 'boolean', value: false, raw: 'false', confidence: 1 }
+    }
+    return undefined
+  }
+
+  private parseNumber(): PartialASTNode | undefined {
+    const start = this.pos
+    let value = ''
+    while (this.pos < this.text.length) {
+      const c = this.text[this.pos]
+      if (/[0-9.\-eE+]/.test(c)) { value += c; this.pos++ }
+      else break
+    }
+    if (value.length === 0) return undefined
+    const num = Number(value)
+    if (!isNaN(num) && isFinite(num)) return { type: 'number', value: num, raw: value, confidence: 0.9 }
+    return { type: 'unknown', value, raw: value, confidence: 0.3 }
+  }
+
+  private parseReActBlock(): PartialASTNode | undefined {
+    const start = this.pos
+    let action = ''
+    let input = ''
+
+    const actionMatch = this.text.slice(this.pos).match(/^Action:\s*(\w+)/i)
+    if (!actionMatch) return undefined
+    action = actionMatch[1]
+    this.pos += actionMatch[0].length
+    this.skipWhitespace()
+
+    const inputMatch = this.text.slice(this.pos).match(/^Action Input:\s*(\{[\s\S]*)/i)
+    if (inputMatch) {
+      input = inputMatch[1].trim()
+      this.pos += inputMatch[0].length
+    }
+
+    return { type: 'object', value: { action, input }, raw: this.text.slice(start, this.pos), confidence: 0.85 }
+  }
+
+  private isReActAction(char: string): boolean {
+    return /^Action:|^thought|^Observation|^Final Answer/i.test(this.text.slice(this.pos))
+  }
+  private isNull(char: string): boolean { return this.text.slice(this.pos, this.pos + 4) === 'null' }
+  private isBoolean(char: string): boolean {
+    return this.text.slice(this.pos, this.pos + 4) === 'true' || this.text.slice(this.pos, this.pos + 5) === 'false'
+  }
+  private isNumberStart(char: string): boolean { return /[0-9.\-]/.test(char) }
+  private isUnquotedKey(char: string): boolean { return /[a-zA-Z_]/.test(char) && !this.isNull(char) && !this.isReActAction(char) }
+
+  private skipWhitespace(): void {
+    while (this.pos < this.text.length && /\s/.test(this.text[this.pos])) this.pos++
+  }
+  private peek(): string { return this.text[this.pos] ?? '' }
+  private expect(char: string): boolean {
+    if (this.peek() === char) { this.pos++; return true }
+    this.errors.push(`Expected '${char}' at position ${this.pos}, got '${this.peek()}'`)
+    return false
+  }
+  private expectOptional(char: string): boolean {
+    if (this.peek() === char) { this.pos++; return true }
+    return false
+  }
+
+  private calculateConfidence(nodes: PartialASTNode[]): number {
+    if (nodes.length === 0) return 0
+    const avg = nodes.reduce((a, n) => a + n.confidence, 0) / nodes.length
+    return Math.max(0, Math.min(1, avg - Math.min(this.errors.length * 0.1, 0.5)))
+  }
+
+  private calculateObjectConfidence(children: PartialASTNode[]): number {
+    if (children.length === 0) return 0.1
+    let confidence = 0.7
+    if (children.some(c => c.children && c.children[0]?.type === 'string')) confidence += 0.2
+    if (this.errors.length === 0) confidence += 0.1
+    if (children.length >= 2) confidence += 0.05
+    return Math.min(0.99, confidence)
+  }
+
+  static extractJsonFromText(text: string): string[] {
+    const results: string[] = []
+    let depth = 0, start = -1, inString = false, escape = false
+
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i]
+      if (escape) { escape = false; continue }
+      if (char === '\\' && inString) { escape = true; continue }
+      if (char === '"' && !escape) { inString = !inString; continue }
+      if (inString) continue
+
+      if (char === '{' || char === '[') {
+        if (depth === 0) start = i
+        depth++
+      } else if (char === '}' || char === ']') {
+        depth--
+        if (depth === 0 && start !== -1) { results.push(text.slice(start, i + 1)); start = -1 }
+      }
+    }
+
+    return results
+  }
+}

package/src/linter/types.ts

@@ -0,0 +1,74 @@
+/*
+ * File: types.ts
+ * Project: qwenproxy
+ * UltraToolCallLinter - Core type definitions
+ */
+
+export type ToolCallSource = 'openai' | 'claude' | 'gemini' | 'react' | 'unknown'
+
+export interface CanonicalToolCall {
+  tool: string
+  input: Record<string, unknown>
+  meta?: {
+    source: ToolCallSource
+    confidence: number
+    repaired: boolean
+  }
+}
+
+export interface ParserState {
+  buffer: string
+  insideCodeBlock: boolean
+  braceDepth: number
+  bracketDepth: number
+  inString: boolean
+  escapeNext: boolean
+  potentialToolStart: boolean
+}
+
+export interface PartialASTNode {
+  type: 'object' | 'array' | 'string' | 'number' | 'boolean' | 'null' | 'unknown'
+  value?: unknown
+  raw: string
+  confidence: number
+  children?: PartialASTNode[]
+}
+
+export interface RawToolCandidate {
+  source: ToolCallSource
+  raw: Record<string, unknown>
+  rawString: string
+  confidence: number
+}
+
+export interface ParseResult {
+  text: string
+  toolCalls: CanonicalToolCall[]
+  errors: string[]
+  confidence: number
+}
+
+export interface SecurityViolation {
+  type: 'shell_injection' | 'filesystem_access' | 'ssrf' | 'prompt_injection' | 'encoded_payload'
+  field: string
+  value: string
+  detail: string
+}
+
+export interface ToolRegistry {
+  [name: string]: {
+    name: string
+    description: string
+    parameters: Record<string, unknown>
+    required?: string[]
+    strict?: boolean
+  }
+}
+
+export interface ToolDefinition {
+  name: string
+  description: string
+  parameters: Record<string, unknown>
+  required?: string[]
+  strict?: boolean
+}

package/src/login.ts

@@ -0,0 +1,228 @@
+import { addAccount, removeAccount, listAccounts, getAccountCredentials, QwenAccount } from './core/accounts.ts'
+import { initPlaywrightForAccount, closePlaywrightForAccount, BrowserType, launchManualLoginAccount, extractAccountInfoFromContext } from './services/playwright.ts'
+import * as readline from 'readline'
+import * as dotenv from 'dotenv'
+
+dotenv.config()
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+})
+
+function askQuestion(query: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(query, (answer) => {
+      resolve(answer.trim())
+    })
+  })
+}
+
+function clear() {
+  process.stdout.write('\x1Bc')
+}
+
+async function showMenu() {
+  let browserType: BrowserType = 'chromium'
+  const browserArg = process.argv.find(arg => arg.startsWith('--browser='))
+  if (browserArg) {
+    browserType = browserArg.split('=')[1] as BrowserType
+  } else if (process.env.BROWSER) {
+    browserType = process.env.BROWSER as BrowserType
+  }
+
+  while (true) {
+    const accounts = listAccounts()
+    clear()
+    console.log('=== QwenProxy Account Manager ===\n')
+
+    if (accounts.length > 0) {
+      console.log(`Configured accounts (${accounts.length}):\n`)
+      for (let i = 0; i < accounts.length; i++) {
+        console.log(`  [${i + 1}] ${accounts[i].email} (ID: ${accounts[i].id})`)
+      }
+    } else {
+      console.log('No accounts configured yet.\n')
+    }
+
+    console.log('\nOptions:')
+    console.log('  [A] Add account (with credentials)')
+    console.log('  [M] Add account (manual browser login)')
+    if (accounts.length > 0) {
+      console.log('  [R] Remove an account')
+      console.log('  [L] Login all accounts')
+    }
+    console.log('  [Q] Quit\n')
+
+    const choice = (await askQuestion('Select an option: ')).toUpperCase()
+
+    if (choice === 'Q') {
+      rl.close()
+      process.exit(0)
+    }
+
+    if (choice === 'A') {
+      await addAccountFlow()
+      continue
+    }
+
+    if (choice === 'M') {
+      await addAccountManualFlow(browserType)
+      continue
+    }
+
+    if (choice === 'R' && accounts.length > 0) {
+      await removeAccountFlow()
+      continue
+    }
+
+    if (choice === 'L' && accounts.length > 0) {
+      await loginAllAccounts(browserType)
+      rl.close()
+      return
+    }
+  }
+}
+
+async function addAccountFlow() {
+  clear()
+  console.log('=== Add New Account ===\n')
+  const email = await askQuestion('Email: ')
+  if (!email) {
+    console.log('Email is required.')
+    await askQuestion('Press Enter to continue...')
+    return
+  }
+  const password = await askQuestion('Password: ')
+  if (!password) {
+    console.log('Password is required.')
+    await askQuestion('Press Enter to continue...')
+    return
+  }
+
+  try {
+    const account = addAccount(email, password)
+    console.log(`\nAccount added: ${account.email} (${account.id})`)
+  } catch (err: any) {
+    console.log(`\nError: ${err.message}`)
+  }
+
+  await askQuestion('Press Enter to continue...')
+}
+
+async function removeAccountFlow() {
+  const accounts = listAccounts()
+  if (accounts.length === 0) return
+
+  clear()
+  console.log('=== Remove Account ===\n')
+
+  for (let i = 0; i < accounts.length; i++) {
+    console.log(`  [${i + 1}] ${accounts[i].email} (ID: ${accounts[i].id})`)
+  }
+
+  const input = await askQuestion('\nSelect account number to remove (or 0 to cancel): ')
+  const idx = parseInt(input) - 1
+
+  if (isNaN(idx) || idx < 0 || idx >= accounts.length) {
+    console.log(input !== '0' ? 'Invalid selection.' : 'Cancelled.')
+    await askQuestion('Press Enter to continue...')
+    return
+  }
+
+  const account = accounts[idx]
+  const confirm = await askQuestion(`\nRemove ${account.email}? (y/N): `)
+  if (confirm.toLowerCase() === 'y') {
+    if (removeAccount(account.id)) {
+      console.log(`Account ${account.email} removed.`)
+    } else {
+      console.log('Failed to remove account.')
+    }
+  } else {
+    console.log('Cancelled.')
+  }
+
+  await askQuestion('Press Enter to continue...')
+}
+
+async function loginAllAccounts(browserType: BrowserType) {
+  const accounts = listAccounts()
+  if (accounts.length === 0) return
+
+  clear()
+  console.log(`Logging in ${accounts.length} account(s) using ${browserType}...\n`)
+
+  for (let i = 0; i < accounts.length; i++) {
+    const account = accounts[i]
+    const creds = getAccountCredentials(account.id)
+    if (!creds || creds.password === '***') {
+      console.log(`[Login] Skipping ${account.email} - no credentials available`)
+      continue
+    }
+    console.log(`[Login] Processing account: ${account.email}`)
+    try {
+      const fullAccount: QwenAccount = {
+        id: creds.id,
+        email: creds.email,
+        password: creds.password,
+      }
+      await initPlaywrightForAccount(fullAccount, true, browserType)
+      console.log(`[Login] Account ${account.email} session saved.`)
+      await closePlaywrightForAccount(account.id)
+    } catch (err: any) {
+      console.error(`[Login] Failed to login ${account.email}: ${err.message}`)
+    }
+  }
+
+  console.log('\n[Login] All accounts processed.')
+  await askQuestion('Press Enter to continue...')
+}
+
+async function addAccountManualFlow(browserType: BrowserType) {
+  clear()
+  console.log('=== Add Account (Manual Login) ===\n')
+  console.log('A browser window will open. Please login to Qwen manually.')
+  console.log('Once logged in, close the browser window or press Ctrl+C here.\n')
+  await askQuestion('Press Enter to open the browser...')
+
+  const crypto = await import('crypto')
+  const accountId = crypto.randomUUID()
+
+  const { context, page } = await launchManualLoginAccount(accountId, browserType)
+
+  console.log('\nBrowser opened. Waiting for you to login...')
+  
+  let loggedIn = false
+  while (!loggedIn) {
+    await new Promise(resolve => setTimeout(resolve, 2000))
+    const { hasSession } = await extractAccountInfoFromContext(page)
+    if (hasSession) {
+      loggedIn = true
+    }
+  }
+
+  console.log('\nLogin detected! Extracting account info...')
+  
+  const extractedEmail = await askQuestion('Enter the email for this account: ')
+  if (!extractedEmail) {
+    console.log('Email is required.')
+    await context.close()
+    await askQuestion('Press Enter to continue...')
+    return
+  }
+
+  try {
+    const account = addAccount(extractedEmail, '', accountId)
+    console.log(`\nAccount added: ${account.email} (${account.id})`)
+  } catch (err: any) {
+    console.log(`\nError: ${err.message}`)
+  }
+
+  await context.close()
+  await askQuestion('Press Enter to continue...')
+}
+
+showMenu().catch(err => {
+  console.error(err)
+  process.exit(1)
+})