nexscope-ai/nexscope-ecommerce-skills / ecommerce-mercado-market-intelligence
ecommerce.mercado-market-intelligence
VerifiedQuery Mercado Libre public market intelligence through the Nexscope research proxy. Use when the user requests this public marketplace or patent data; do not use for seller-console or store-authorized operations.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 5.5 KB |
| manifest.json | config | 420 B |
| references/api.md | markdown | 15.6 KB |
| references/testing.md | markdown | 2.0 KB |
| scripts/damai_mercado_market_intelligence.py | script | 14.9 KB |
| scripts/upload_image.py | script | 9.6 KB |
scripts/upload_image.py
View on GitHub#!/usr/bin/env python3
"""Upload local image files or base64 image data via the Nexscope Skill Asset API.
Usage:
python upload_image.py /path/to/local/image.png
python upload_image.py "data:image/jpeg;base64,/9j/4AAQ..."
python upload_image.py "/9j/4AAQ..." # pure base64 (auto-detected)
Flow:
1. POST /api/skill-asset/presign -> get presigned PUT URL + assetId
2. PUT file bytes directly to S3 presigned URL
3. POST /api/skill-asset/confirm -> verify upload + get public URL
4. Print JSON array of results to stdout
Requires: NEXSCOPE_PROXY_BASE and NEXSCOPE_API_KEY environment variables.
"""
import base64
import hashlib
import json
import os
import re
import sys
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen
PRESIGN_PATH = "/api/skill-asset/presign"
CONFIRM_PATH = "/api/skill-asset/confirm"
MAX_FILE_SIZE = 20 * 1024 * 1024 # 20 MB
# magic bytes -> (extension, content_type)
_MAGIC_MAP = [
(b"\x89PNG\r\n\x1a\n", ".png", "image/png"),
(b"\xff\xd8\xff", ".jpg", "image/jpeg"),
(b"GIF87a", ".gif", "image/gif"),
(b"GIF89a", ".gif", "image/gif"),
(b"RIFF", ".webp", "image/webp"), # RIFF....WEBP
(b"BM", ".bmp", "image/bmp"),
]
_DATA_URI_RE = re.compile(r"^data:([^;]*)(;base64)?,(.*)", re.IGNORECASE)
def _detect_meta_from_bytes(raw):
"""Sniff file type from magic bytes. Returns (ext, content_type)."""
for magic, ext, ct in _MAGIC_MAP:
if raw.startswith(magic):
if ext == ".webp":
# RIFF header needs further check for WEBP subtype
if len(raw) > 11 and raw[8:12] == b"WEBP":
return ext, ct
continue
return ext, ct
return ".jpg", "image/jpeg"
def _content_type(ext):
"""Map file extension to MIME content type."""
mapping = {
".jpg": "image/jpeg", ".jpeg": "image/jpeg",
".png": "image/png", ".gif": "image/gif",
".webp": "image/webp", ".bmp": "image/bmp",
}
return mapping.get(ext, "application/octet-stream")
def _api_post(base, key, path, body):
"""Send a JSON POST request and return the parsed response."""
url = base.rstrip("/") + path
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
req = Request(url, data=data, method="POST", headers={
"Authorization": "Bearer " + key,
"Content-Type": "application/json",
"Accept": "application/json",
})
try:
with urlopen(req, timeout=30) as resp:
return json.loads(resp.read().decode("utf-8"))
except HTTPError as e:
raw = e.read().decode("utf-8", errors="replace") if e.fp else ""
return {"error": "HTTP {}: {}".format(e.code, e.reason), "details": raw}
def _put_file(put_url, data, content_type):
"""Upload bytes directly to a presigned S3 PUT URL."""
req = Request(put_url, data=data, method="PUT", headers={
"Content-Type": content_type,
})
try:
with urlopen(req, timeout=60) as resp:
if resp.status not in (200, 201, 204):
return False, "PUT returned HTTP {}".format(resp.status)
return True, None
except HTTPError as e:
return False, "PUT failed: HTTP {}: {}".format(e.code, e.reason)
except URLError as e:
return False, "PUT connection failed: {}".format(e.reason)
def upload_bytes(file_bytes, file_name, content_type, base, key):
"""Upload raw bytes through the presign + PUT + confirm flow.
Returns a dict with keys: url, assetId, name, size, ext on success,
or error, input, message on failure.
"""
file_size = len(file_bytes)
ext = os.path.splitext(file_name)[1].lower()
if not ext:
ext = _detect_meta_from_bytes(file_bytes)[0]
if file_size > MAX_FILE_SIZE:
return {"error": True, "input": file_name,
"message": "File too large: {} bytes (max {})".format(file_size, MAX_FILE_SIZE)}
# Step 1: Get presigned URL
presign = _api_post(base, key, PRESIGN_PATH, {
"fileName": file_name,
"contentType": content_type,
"fileSize": file_size,
})
if "code" in presign:
if presign["code"] != 0:
return {"error": True, "input": file_name,
"message": "Presign failed: code={} msg={}".format(
presign.get("code"), presign.get("msg", ""))}
elif presign.get("error"):
return {"error": True, "input": file_name,
"message": "Presign request failed: {}".format(presign.get("error"))}
data = presign.get("data")
if not data:
return {"error": True, "input": file_name,
"message": "Presign response missing data: {}".format(
json.dumps(presign, ensure_ascii=False)[:500])}
put_url = data.get("putUrl")
oss_key = data.get("ossKey")
if not put_url:
return {"error": True, "input": file_name,
"message": "Presign response missing putUrl: {}".format(
json.dumps(data, ensure_ascii=False)[:500])}
# Step 2: Upload directly to S3
ok, err = _put_file(put_url, file_bytes, content_type)
if not ok:
return {"error": True, "input": file_name, "message": err}
# Compute SHA-256 for verification
sha256 = hashlib.sha256(file_bytes).hexdigest()
# Step 3: Confirm upload
confirm = _api_post(base, key, CONFIRM_PATH, {
"ossKey": oss_key,
"expectedSize": file_size,
"expectedSha256": sha256,
})
if "code" in confirm:
if confirm["code"] != 0:
return {"error": True, "input": file_name,
"message": "Confirm failed: code={} msg={}".format(
confirm.get("code"), confirm.get("msg", ""))}
elif confirm.get("error"):
return {"error": True, "input": file_name,
"message": "Confirm request failed: {}".format(confirm.get("error"))}
confirm_data = confirm.get("data")
if not confirm_data:
return {"error": True, "input": file_name,
"message": "Confirm response missing data: {}".format(
json.dumps(confirm, ensure_ascii=False)[:500])}
public_url = confirm_data.get("publicUrl")
asset_id = confirm_data.get("assetId")
return {
"url": public_url,
"assetId": asset_id,
"name": file_name,
"size": file_size,
"ext": ext.lstrip("."),
}
def upload_file(local_path, base, key):
"""Upload a local file through the presign + PUT + confirm flow."""
if not os.path.isfile(local_path):
return {"error": True, "input": local_path, "message": "File not found"}
file_name = os.path.basename(local_path)
ext = os.path.splitext(file_name)[1].lower()
content_type = _content_type(ext)
with open(local_path, "rb") as f:
file_bytes = f.read()
return upload_bytes(file_bytes, file_name, content_type, base, key)
def _parse_base64_input(raw_input):
"""Parse a base64 or data-URI string into (bytes, file_name, content_type).
Returns None if the input does not look like base64.
"""
content_type = "image/jpeg"
file_name = "image.jpg"
b64 = raw_input.strip()
# Check for data URI prefix: data:image/png;base64,xxxx
m = _DATA_URI_RE.match(b64)
if m:
ct = (m.group(1) or "image/jpeg").strip().lower()
if ct:
content_type = ct
b64 = m.group(3)
# Derive file name from content type
ext = {"image/jpeg": ".jpg", "image/png": ".png", "image/gif": ".gif",
"image/webp": ".webp", "image/bmp": ".bmp"}.get(content_type, ".jpg")
file_name = "image" + ext
# Quick heuristic: if it's > 100 chars and looks like base64 (no spaces, mostly alphanumeric+/=)
# and is NOT a file path (no backslashes or forward slashes that look like a path)
if not m and len(b64) < 100:
return None # too short to be base64, probably a file path
if not m and ("\\" in b64 or ("/" in b64 and os.path.exists(b64))):
return None # looks like a file path
try:
decoded = base64.b64decode(b64, validate=True)
except Exception:
if m:
# data URI but base64 decode failed — try without validation
try:
decoded = base64.b64decode(b64, validate=False)
except Exception:
return None
else:
return None
if len(decoded) == 0:
return None
# Sniff actual type from decoded bytes to get correct extension
ext, sniffed_ct = _detect_meta_from_bytes(decoded)
if not m:
content_type = sniffed_ct
file_name = "image" + ext
return decoded, file_name, content_type
def main():
if len(sys.argv) < 2:
print("Usage: {} <local_path|base64_string|data:URI> [...]".format(sys.argv[0]), file=sys.stderr)
sys.exit(1)
base = os.environ.get("NEXSCOPE_PROXY_BASE", "").strip()
key = os.environ.get("NEXSCOPE_API_KEY", "").strip()
if not base or not key:
print("NEXSCOPE_PROXY_BASE and NEXSCOPE_API_KEY are required", file=sys.stderr)
sys.exit(1)
results = []
had_error = False
for arg in sys.argv[1:]:
# Try base64 first, then fall back to file path
parsed = _parse_base64_input(arg)
if parsed:
raw_bytes, name, ct = parsed
result = upload_bytes(raw_bytes, name, ct, base, key)
else:
result = upload_file(arg, base, key)
results.append(result)
if result.get("error"):
had_error = True
print(json.dumps(results, ensure_ascii=False, indent=2))
if had_error:
sys.exit(1)
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| add-product-e2e-evalpaperclipai/paperclipAdd or extend a Paperclip full-stack runner E2E workflow, fixture, matcher, or report evidence path for local or Daytona execution. | Stars: 115k | Updated | Claude CodeCodex | Verified | Install |
| add-runner-evalpaperclipai/paperclipAdd or extend a Paperclip Runner protocol evaluation definition, roster, assertion, or report fixture with provenance and narrow validation. | Stars: 115k | Updated | Claude CodeCodex | Verified | Install |
| diagnose-why-work-stoppedpaperclipai/paperclipCompatibility entry point for failed, stalled, looping, or over-recovered Paperclip work. Use fix-failed-paperclip-run for the full diagnosis, regression, repair, real verification, and green-PR workflow; honor an explicitly requested diagnosis-only scope. | Stars: 115k | Updated | Claude CodeCodex | Verified | Install |
| fix-failed-paperclip-runpaperclipai/paperclipDiagnose and fix failed, stuck, slow, or incorrectly blocked Paperclip tasks and runs. Use with a task/run URL or failure report to trace the root cause, prove a regression red then green, check second-order effects, verify the real workflow, and deliver a PR with passing checks. | Stars: 115k | Updated | Claude CodeCodex | Verified | Install |