Warp每次调用一次工具都算是一个次数，实测下来效果真的不太好。不太想继续写了。但是模型比较保真
这个Cookie也比较离谱很快会过期一次
也可以在客户端抓这个包自动刷新Cookie
欢迎各位佬参观我的石山
import struct
import httpx
import asyncio
import sys
import time
import subprocess
import base64
import re
import json
# ============================================================
# Protobuf 构建器
# ============================================================
class PreciseProtobufBuilder:
"""精确的 Protobuf 消息构建器"""
def __init__(self):
self.buffer = bytearray()
def encode_varint(self, value: int) -> bytes:
"""编码变长整数"""
result = bytearray()
while value >= 0x80:
result.append((value & 0x7F) | 0x80)
value >>= 7
result.append(value & 0x7F)
return bytes(result)
def encode_tag(self, field_number: int, wire_type: int) -> bytes:
"""编码 protobuf 标签"""
tag = (field_number << 3) | wire_type
return self.encode_varint(tag)
def add_length_delimited(self, field_number: int, data: bytes):
"""添加长度限定字段"""
self.buffer.extend(self.encode_tag(field_number, 2))
self.buffer.extend(self.encode_varint(len(data)))
self.buffer.extend(data)
def add_string(self, field_number: int, value: str):
"""添加字符串字段"""
data = value.encode('utf-8')
self.add_length_delimited(field_number, data)
def add_varint(self, field_number: int, value: int):
"""添加变长整数字段"""
self.buffer.extend(self.encode_tag(field_number, 0))
self.buffer.extend(self.encode_varint(value))
def add_raw_bytes(self, data: bytes):
"""直接添加原始字节"""
self.buffer.extend(data)
def get_bytes(self) -> bytes:
"""获取构建的字节数据"""
return bytes(self.buffer)
# ============================================================
# Protobuf 解析工具
# ============================================================
def decode_varint(data, offset=0):
"""解码变长整数"""
result = 0
shift = 0
while offset < len(data):
if shift >= 64: # 防止无限循环
break
byte = data[offset]
offset += 1
result |= (byte & 0x7f) << shift
if (byte & 0x80) == 0:
break
shift += 7
return result, offset
def extract_field(buffer, target_field_number):
"""提取指定字段号的字段"""
offset = 0
while offset < len(buffer):
try:
if offset >= len(buffer):
break
tag_result, new_offset = decode_varint(buffer, offset)
tag = tag_result
wire_type = tag & 0x7
field_number = tag >> 3
offset = new_offset
if field_number == target_field_number:
if wire_type == 2: # LENGTH_DELIMITED
length_result, new_offset = decode_varint(buffer, offset)
length = length_result
offset = new_offset
if offset + length <= len(buffer):
value = buffer[offset:offset + length]
return {'wireType': wire_type, 'value': value, 'size': new_offset - offset + length}
elif wire_type == 0: # VARINT
value_result, new_offset = decode_varint(buffer, offset)
return {'wireType': wire_type, 'value': value_result, 'size': new_offset - offset}
elif wire_type == 1: # FIXED64
if offset + 8 <= len(buffer):
value = buffer[offset:offset + 8]
return {'wireType': wire_type, 'value': value, 'size': 8}
elif wire_type == 5: # FIXED32
if offset + 4 <= len(buffer):
value = buffer[offset:offset + 4]
return {'wireType': wire_type, 'value': value, 'size': 4}
# 跳过这个字段
if wire_type == 0: # VARINT
_, offset = decode_varint(buffer, offset)
elif wire_type == 1: # FIXED64
offset += 8
elif wire_type == 2: # LENGTH_DELIMITED
length_result, new_offset = decode_varint(buffer, offset)
length = length_result
offset = new_offset + length
elif wire_type == 5: # FIXED32
offset += 4
else:
break
except Exception:
break
return None
def extract_field_by_path(buffer, field_path):
"""按路径提取字段"""
current_buffer = buffer
for field_number in field_path:
field = extract_field(current_buffer, field_number)
if not field or field.get('wireType') != 2:
return None
current_buffer = field['value']
return current_buffer
# ============================================================
# 数据解析工具
# ============================================================
def parse_input(input_str):
"""解析输入 - 支持hex和base64"""
clean = re.sub(r'\s', '', input_str)
if re.match(r'^[0-9a-fA-F]+$', clean):
return bytes.fromhex(clean)
# 处理base64 padding
missing = len(clean) % 4
if missing:
clean += '=' * (4 - missing)
try:
return base64.b64decode(clean)
except:
return None
def _urlsafe_b64decode_padded(s: str) -> bytes:
"""URL安全的base64解码，自动补齐填充"""
clean = re.sub(r'\s', '', s)
missing = len(clean) % 4
if missing:
clean += '=' * (4 - missing)
return base64.urlsafe_b64decode(clean)
# ============================================================
# AI 文本提取与验证
# ============================================================
def extract_ai_text_from_message(buffer):
"""从单个消息提取AI文本"""
# 主要路径：初始消息和流式更新
primary_paths = [
[2, 1, 3, 2, 3, 1], # initial message
[2, 1, 5, 1, 3, 1] # stream update
]
for path in primary_paths:
try:
text_buffer = extract_field_by_path(buffer, path)
if text_buffer:
try:
text = text_buffer.decode('utf-8')
if is_valid_ai_text(text):
return clean_ai_text(text)
except:
continue
except:
continue
return None
def is_valid_ai_text(text):
"""验证是否为有效AI文本"""
if not text or len(text.strip()) == 0:
return False
# 过滤系统字符串
system_strings = ['agent_output.text', 'server_message_data', 'USER_INITIATED']
if text.strip() in system_strings:
return False
# 过滤纯UUID
if re.match(r'^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$', text.strip(), re.I):
return False
# 过滤纯base64/hex
if re.match(r'^[A-Za-z0-9+/=]{10,}$', text.strip()):
return False
# 检查是否包含有意义的字符
if re.search(r"[\u4e00-\u9fff\w，。！？、；：（）《》【】#\s-]", text):
return True
return False
def clean_ai_text(text):
"""清理AI文本"""
# 移除控制字符但保留换行
text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]', ' ', text)
# 移除UUID噪声
text = re.sub(r'\$[a-f0-9-]+Z\$[a-f0-9-]+', '', text, flags=re.I)
text = re.sub(r'[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}', '', text, flags=re.I)
# 规范化空格
text = re.sub(r'[ \t]+', ' ', text)
return text.strip()
# ============================================================
# Python 代码提取（从文件）
# ============================================================
def _try_extract_python_segment(text: str):
"""尝试从文本中提取Python代码段"""
start_markers = [
'#!/usr/bin/env python3',
'#!/usr/bin/env python',
]
start = -1
for marker in start_markers:
pos = text.find(marker)
if pos != -1:
start = pos
break
if start == -1:
triple = text.find('"""')
imp = text.find('import ')
if triple != -1 and (imp == -1 or triple < imp):
start = triple
else:
for keyword in ('class ', 'def ', 'import ', 'from '):
pos = text.find(keyword)
if pos != -1:
start = pos
break
if start == -1:
return None
end_markers = [
'tool_call.apply_file_diffs',
'\n"tool_call',
'\n$tool_call',
]
end = len(text)
for marker in end_markers:
pos = text.find(marker, start)
if pos != -1:
end = min(end, pos)
break
segment = text[start:end]
# 清理末尾异常字符
segment = re.sub(r'[\x00-\x1F\x7F-\x9F]+$', '', segment).rstrip()
return segment if segment.strip() else None
def extract_python_code_from_file(path: str = '1.txt'):
"""从文件中提取Python代码"""
candidates = []
try:
with open(path, 'r', encoding='utf-8') as f:
for line in f:
if not line.startswith('data:'):
continue
payload = line[5:].strip()
if not payload or payload == '[DONE]':
continue
raw = None
try:
raw = _urlsafe_b64decode_padded(payload)
except Exception:
try:
clean = re.sub(r'\s', '', payload)
pad = '=' * ((4 - len(clean) % 4) % 4)
raw = base64.b64decode(clean + pad)
except Exception:
continue
if not raw:
continue
text = raw.decode('utf-8', errors='ignore')
code = _try_extract_python_segment(text)
if code:
score = 0
if '#!/usr/bin' in code:
score += 10
if 'TaskManager' in code:
score += 5
if 'class ' in code:
score += 3
if 'def ' in code:
score += 2
if ('import ' in code) or ('from ' in code):
score += 2
score += code.count('\n')
candidates.append((score, code))
except Exception:
return None
if not candidates:
return None
candidates.sort(key=lambda x: x[0], reverse=True)
return candidates[0][1]
# ============================================================
# 输入格式解析
# ============================================================
def parse_openai_format(content):
"""解析OpenAI兼容格式的输入"""
try:
# 尝试解析JSON格式
data = json.loads(content)
# 支持OpenAI API格式
if 'messages' in data:
messages = data['messages']
query_parts = []
for msg in messages:
role = msg.get('role', 'user')
text = msg.get('content', '')
if role == 'system':
query_parts.append(f"[系统指令] {text}")
elif role == 'user':
query_parts.append(text)
elif role == 'assistant':
query_parts.append(f"[助手回复] {text}")
return '\n'.join(query_parts)
# 支持简单的prompt格式
elif 'prompt' in data:
return data['prompt']
# 如果有model字段，忽略它（因为我们总是使用Warp AI）
elif 'model' in data and 'content' in data:
return data['content']
except json.JSONDecodeError:
# 不是JSON格式，返回原文
return content
return content
# ============================================================
# Protobuf 请求构建
# ============================================================
def build_protobuf_request(query: str = "你好"):
"""基于标准模板构建protobuf请求"""
try:
# 读取标准模板
with open('standard_template.hex', 'r') as f:
template_hex = ''.join(f.read().split())
# 如果查询是"燃尽了"，直接返回模板
if query == "燃尽了":
return bytes.fromhex(template_hex)
# 动态替换查询
# 分析模板结构
original_query_field = "320F0A0D0A0B0A09E78783E5B0BDE4BA86"
query_pos = template_hex.find(original_query_field)
if query_pos == -1:
raise ValueError("无法在模板中找到查询字段")
# 构建新的查询字段
query_bytes = query.encode('utf-8')
query_length = len(query_bytes)
if query_length > 4000:
raise ValueError("查询文本过长，请控制在4000字节以内")
# 编码函数
def encode_varint_for_length(value):
if value < 128:
return f"{value:02X}"
else:
result = ""
while value >= 128:
result += f"{(value & 0x7f) | 0x80:02X}"
value >>= 7
result += f"{value:02X}"
return result
def get_varint_byte_count(value):
if value < 128:
return 1
count = 1
while value >= 128:
count += 1
value >>= 7
return count
# 计算嵌套长度
text_length = query_length
text_length_varint_bytes = get_varint_byte_count(text_length)
level3_total = 1 + text_length_varint_bytes + text_length
level3_length_varint_bytes = get_varint_byte_count(level3_total)
level2_total = 1 + level3_length_varint_bytes + level3_total
level2_length_varint_bytes = get_varint_byte_count(level2_total)
level1_total = 1 + level2_length_varint_bytes + level2_total
new_query_field = (
f"32{encode_varint_for_length(level1_total)}" +
f"0A{encode_varint_for_length(level2_total)}" +
f"0A{encode_varint_for_length(level3_total)}" +
f"0A{encode_varint_for_length(text_length)}" +
query_bytes.hex().upper()
)
# 计算长度差异并更新系统字段
original_query_len = len(original_query_field) // 2
new_query_len = len(new_query_field) // 2
length_diff = new_query_len - original_query_len
original_system_length = 0x60
new_system_length = original_system_length + length_diff
# 替换查询字段
modified_hex = template_hex.replace(original_query_field, new_query_field)
# 更新系统字段长度
def encode_varint(value):
if value < 128:
return f"{value:02X}"
else:
result = ""
while value >= 128:
result += f"{(value & 0x7f) | 0x80:02X}"
value >>= 7
result += f"{value:02X}"
return result
old_system_header = "1260"
new_system_varint = encode_varint(new_system_length)
new_system_header = f"12{new_system_varint}"
modified_hex = modified_hex.replace(old_system_header, new_system_header)
# 生成完成
return bytes.fromhex(modified_hex)
except FileNotFoundError:
raise ValueError("未找到模板文件")
# ============================================================
# 输出工具
# ============================================================
def print_char_by_char(text, delay=0.01):
"""逐字打印文本"""
for char in text:
print(char, end='', flush=True)
time.sleep(delay)
def show_result(content):
"""显示结果，使用统一格式"""
print("Get:")
print("=" * 60)
print(content)
print("=" * 60)
# ============================================================
# 主要功能
# ============================================================
async def send_warp_request(query: str):
"""发送请求到Warp AI并返回结果"""
# JWT token
auth_token = "eyJhbGciOiJSUzI1NiIsImtpZCI6IjJiN2JhZmIyZjEwY2FlMmIxZjA3ZjM4MTZjNTQyMmJlY2NhNWMyMjMiLCJ0eXAiOiJKV1QifQ.eyJuYW1lIjoi5a2Z5a2ZIiwicGljdHVyZSI6Imh0dHBzOi8vbGgzLmdvb2dsZXVzZXJjb250ZW50LmNvbS9hL0FDZzhvY0luSHkybFJoM0ZtaE1lTkd1VWt1a0dHckRiOTVQLU5FcFRhaFV6Mk1MeGhkUU10dz1zOTYtYyIsImlzcyI6Imh0dHBzOi8vc2VjdXJldG9rZW4uZ29vZ2xlLmNvbS9hc3RyYWwtZmllbGQtMjk0NjIxIiwiYXVkIjoiYXN0cmFsLWZpZWxkLTI5NDYyMSIsImF1dGhfdGltZSI6MTc1NTExODk5NywidXNlcl9pZCI6IjJhNUNROWNMTUhPMGJ3V2ZOdGh2MG1jaEp0czEiLCJzdWIiOiIyYTVDUTljTE1ITzBid1dmTnRodjBtY2hKdHMxIiwiaWF0IjoxNzU1MTI0Mzc2LCJleHAiOjE3NTUxMjc5NzYsImVtYWlsIjoic3Vuc3VuYWFiYmNjMUBnbWFpbC5jb20iLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwiZmlyZWJhc2UiOnsiaWRlbnRpdGllcyI6eyJnb29nbGUuY29tIjpbIjExNzQ1ODIzNzU2NTI1ODkwMTc1NyJdLCJlbWFpbCI6WyJzdW5zdW5hYWJiY2MxQGdtYWlsLmNvbSJdfSwic2lnbl9pbl9wcm92aWRlciI6Imdvb2dsZS5jb20ifX0.aM5ZjgINCyeUY0DNklDcwZ_0Yf5BNaPxtNWHL1J8Z5C2HSf4dM9a-KiZ5qOeeBBR8CEAEBOQkYAzht51wP0JXTjxIofRREklxZcmBiaptOfgQM2mO8kXr7FblZlQqPPR3xEnPUjsRc4dFEJJryqt5IyvTegwcMDNf6pBATM54kUHZegNRPJaLrxrKzaUwiq2gvhC-W5TQt6cLJNrih5Uf8hYqI3SJAzptQKTpGtPC4-H_1b7pAWdvap5ru_nJ4T_FWMTkBnQYJ_nBGiCvbLf2FYkfTrAfysCaKiNP19AywKvPEspVJ_dKclPma6uvFCYXzIkEGeLtxYf031HaJkVLw"
# 构建protobuf请求
try:
protobuf_data = build_protobuf_request(query)
except Exception as e:
show_result(f"构建请求失败: {str(e)}")
return
# 构建请求头
headers = {
'Accept': 'text/event-stream',
'Accept-Encoding': 'gzip, br',
'Content-Type': 'application/octet-stream',
'x-warp-client-version': 'v0.2025.08.06.08.12.stable_02',
'x-warp-os-category': 'Windows',
'x-warp-os-name': 'Windows',
'x-warp-os-version': '11 (26100)',
'content-type': 'application/x-protobuf',
'authorization': f'Bearer {auth_token}',
'Content-Length': str(len(protobuf_data))
}
# 发送请求并将结果写入1.txt
with open('1.txt', 'w', encoding='utf-8') as output_file:
async with httpx.AsyncClient(
verify=False,
timeout=httpx.Timeout(600.0),
follow_redirects=True,
http2=True
) as client:
try:
async with client.stream(
'POST',
'https://app.warp.dev/ai/multi-agent',
headers=headers,
content=protobuf_data
) as response:
if response.status_code != 200:
error_content = await response.aread()
show_result(f"请求失败: {response.status_code}")
return
data_count = 0
# 静默接收数据
async for line in response.aiter_lines():
if line.strip():
# 保存原始数据到文件
output_file.write(line + '\n')
output_file.flush()
# 计数数据块
if line.startswith('data:') and not line.startswith('event:'):
data_content = line[5:].strip()
if data_content and data_content != '[DONE]':
data_count += 1
if line.startswith('data: ') and line[6:] == '[DONE]':
break
# 静默处理
# 使用JavaScript解析器获取完整准确的回复
try:
result = subprocess.run(['node', 'precise_ai_text_extractor.js'],
capture_output=True, text=True, encoding='utf-8', cwd='.')
if result.returncode == 0:
# 从输出中提取完整AI回复
output_lines = result.stdout.split('\n')
in_ai_reply = False
ai_reply_lines = []
for line in output_lines:
if '🎯 完整AI回复' in line:
in_ai_reply = True
continue
elif '─' in line and in_ai_reply:
if ai_reply_lines: # 结束线
break
else: # 开始线
continue
elif in_ai_reply and line.strip():
ai_reply_lines.append(line)
if ai_reply_lines:
full_ai_reply = '\n'.join(ai_reply_lines)
show_result(full_ai_reply)
else:
show_result("无法提取完整回复")
else:
# 静默处理解析失败
pass
except Exception as e:
# 静默处理异常
pass
except httpx.ConnectError as e:
show_result("网络连接失败")
except httpx.TimeoutException:
show_result("请求超时")
except Exception as e:
show_result("请求失败")
# 静默保存文件
# 自动提取并打印 Python 代码
try:
code = extract_python_code_from_file('1.txt')
if code:
print("\n" + code)
except Exception:
pass
async def main():
"""主函数"""
# 获取查询内容
if len(sys.argv) > 1:
candidate = sys.argv[1]
try:
import os
if os.path.exists(candidate) and os.path.isfile(candidate):
with open(candidate, 'r', encoding='utf-8') as f:
raw_content = f.read().strip()
else:
raw_content = candidate
except Exception:
raw_content = candidate
# 解析OpenAI兼容格式
query = parse_openai_format(raw_content)
else:
query = input("请输入你的问题: ")
query = parse_openai_format(query)
# 发送请求并自动解析
await send_warp_request(query)
if __name__ == "__main__":
asyncio.run(main())
const fs = require('fs');
const { Buffer } = require('buffer');
function decodeVarint(buffer, offset) {
let result = 0n;
let shift = 0;
let byte = 0;
let bytesRead = 0;
do {
if (offset >= buffer.length) throw new RangeError("Buffer overflow");
if (bytesRead >= 10) throw new Error("Varint too long");
byte = buffer[offset++];
bytesRead++;
const dataBits = BigInt(byte & 0x7f);
result = result + (dataBits << BigInt(shift));
shift += 7;
} while (byte >= 0x80);
return { value: result, bytesConsumed: bytesRead };
}
function parseInput(input) {
const clean = input.replace(/\s/g, "");
if (/^[0-9a-fA-F]+$/.test(clean)) {
return Buffer.from(clean, "hex");
}
const missing = clean.length % 4;
return Buffer.from(missing ? clean + '='.repeat(4 - missing) : clean, "base64");
}
function extractField(buffer, targetFieldNumber) {
let offset = 0;
while (offset < buffer.length) {
try {
const tagResult = decodeVarint(buffer, offset);
const tag = Number(tagResult.value);
const wireType = tag & 0x7;
const fieldNumber = tag >> 3;
offset += tagResult.bytesConsumed;
if (fieldNumber === targetFieldNumber) {
let value = null;
let valueSize = 0;
switch (wireType) {
case 0:
const varintResult = decodeVarint(buffer, offset);
value = varintResult.value;
valueSize = varintResult.bytesConsumed;
break;
case 1:
if (offset + 8 <= buffer.length) {
value = buffer.readBigUInt64LE(offset);
valueSize = 8;
}
break;
case 2:
const lengthResult = decodeVarint(buffer, offset);
const length = Number(lengthResult.value);
const lengthSize = lengthResult.bytesConsumed;
if (offset + lengthSize + length <= buffer.length) {
value = buffer.slice(offset + lengthSize, offset + lengthSize + length);
valueSize = lengthSize + length;
}
break;
case 5:
if (offset + 4 <= buffer.length) {
value = buffer.readUInt32LE(offset);
valueSize = 4;
}
break;
}
if (value !== null) {
return { wireType, value, size: valueSize };
}
}
switch (wireType) {
case 0:
const skipVarint = decodeVarint(buffer, offset);
offset += skipVarint.bytesConsumed;
break;
case 1:
offset += 8;
break;
case 2:
const skipLength = decodeVarint(buffer, offset);
offset += skipLength.bytesConsumed + Number(skipLength.value);
break;
case 5:
offset += 4;
break;
default:
return null;
}
} catch (e) {
break;
}
}
return null;
}
function extractFieldByPath(buffer, fieldPath) {
let currentBuffer = buffer;
for (const fieldNumber of fieldPath) {
const field = extractField(currentBuffer, fieldNumber);
if (!field || field.wireType !== 2) {
return null;
}
currentBuffer = field.value;
}
return currentBuffer;
}
function extractAITextFromMessage(buffer) {
const primaryPaths = [
[2, 1, 3, 2, 3, 1],
[2, 1, 5, 1, 3, 1]
];
for (const path of primaryPaths) {
try {
const textBuffer = extractFieldByPath(buffer, path);
if (textBuffer) {
const text = textBuffer.toString('utf-8');
if (isValidAIText(text)) {
return cleanAIText(text);
}
}
} catch (e) {
continue;
}
}
return null;
}
function isValidAIText(text) {
if (!text || text.length === 0) return false;
const systemStrings = [
'agent_output.text',
'server_message_data',
'USER_INITIATED'
];
if (systemStrings.includes(text.trim())) {
return false;
}
if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(text.trim())) {
return false;
}
if (/^[A-Za-z0-9+/=]{20,}$/.test(text.trim())) {
return false;
}
const hasValidContent = /[\u4e00-\u9fff\w，。！？、；：""''（）《》【】\-#\s]/.test(text);
return hasValidContent && text.length >= 1;
}
function cleanAIText(text) {
return text
.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, ' ')
.replace(/\$[a-f0-9-]+Z\$[a-f0-9-]+/gi, '')
.replace(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/gi, '')
.replace(/[ \t]+/g, ' ')
.replace(/[ \t]*\n[ \t]*/g, '\n')
.replace(/\n{3,}/g, '\n\n')
.trim();
}
function extractAllAITexts() {
try {
const content = fs.readFileSync('./1.txt', 'utf-8');
const dataLines = content.split('\n')
.filter(line => line.trim().startsWith('data:'))
.map(line => line.trim().substring(5));
const extractedTexts = [];
const seenTexts = new Set(); // 避免重复文本
for (let i = 0; i < dataLines.length; i++) {
try {
const buffer = parseInput(dataLines[i]);
const aiText = extractAITextFromMessage(buffer);
if (aiText && !seenTexts.has(aiText)) {
seenTexts.add(aiText);
extractedTexts.push(aiText);
}
} catch (error) {
continue;
}
}
if (extractedTexts.length > 0) {
// 打印调试信息
console.log('🔍 找到的文本片段数量:', extractedTexts.length);
console.log('─'.repeat(60));
// 打印每个片段用于调试
extractedTexts.forEach((text, index) => {
console.log(`片段 ${index + 1}: "${text}"`);
});
console.log('─'.repeat(60));
console.log('🎯 完整AI回复');
console.log('─'.repeat(60));
// 直接拼接所有文本片段
const fullReply = extractedTexts.join('');
console.log(fullReply);
console.log('─'.repeat(60));
} else {
console.log('未找到有效的AI文本内容');
}
} catch (error) {
console.log('处理过程中发生错误:', error.message);
}
}
if (require.main === module) {
extractAllAITexts();
}
0A 26 12 24 65 34 35 35 33 66 64 33 2D 64 32 61 31 2D 34 36 33 33 2D 61 34 33 39 2D 31 32 33 36
38 61 39 37 65 35 31 34 12 60 0A 4D 0A 20 0A 0E 43 3A 5C 55 73 65 72 73 5C 68 75 69 79 65 12 0E
43 3A 5C 55 73 65 72 73 5C 68 75 69 79 65 12 09 0A 07 57 69 6E 64 6F 77 73 1A 16 0A 04 70 77 73
68 12 0E 35 2E 31 2E 32 36 31 30 30 2E 34 36 35 32 22 06 08 B5 97 F1 C4 06 32 0F 0A 0D 0A 0B 0A
09 E7 87 83 E5 B0 BD E4 BA 86 1A 39 0A 1B 0A 0F 63 6C 61 75 64 65 2D 34 2E 31 2D 6F 70 75 73 12
02 6F 33 1A 04 61 75 74 6F 10 01 18 01 20 01 38 01 40 01 4A 0C 04 05 06 07 0C 08 09 00 02 03 01
0B 58 01 60 01 22 42 12 1E 0A 0A 65 6E 74 72 79 70 6F 69 6E 74 12 10 1A 0E 55 53 45 52 5F 49 4E
49 54 49 41 54 45 44 12 20 0A 1A 69 73 5F 61 75 74 6F 64 65 74 65 63 74 65 64 5F 75 73 65 72 5F
71 75 65 72 79 12 02 20 00
依靠字段替换和解析，菜菜佬带带0.0
，已经很棒了
