К основному содержанию
скилл CX Codex

product-cost-analyze-for-fba — скилл для Claude Code: установка

Скилл product-cost-analyze-for-fba собирает карточки товаров с Amazon, ищет оптовые цены на 1688 через поиск по картинке и рассчитывает маржинальность FBA в локальном HTML-отчёте.

MIT 2 установок ★ 1 обновлён 2026-09-04

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add AronLEEdev/product-cost-analyze-skill --skill product-cost-analyze-for-fba -a claude-code
Открыть на GitHub

Что делает product-cost-analyze-for-fba

Скилл автоматизирует связку поиска товаров и оценки юнит-экономики Amazon FBA. Он управляет запущенным браузером Chrome через Claude-in-Chrome MCP: находит выдачу Amazon по ключевому слову в диапазоне от $10 до $50, считывает метку «bought in past month», а затем ищет фабричные цены FOB на 1688.com через пакетный поиск по изображениям.

Себестоимость и комиссии Amazon рассчитываются через публичный API Profitlee (ключ не требуется) с помощью локального скрипта calc.mjs на Node.js ≥ 18. Итоговые данные пишутся в results.js, а встроенный сервер serve-report.py на Python 3 отображает статический отчёт с экспортом в PDF. Результаты поиска кэшируются на 14 дней в каталоге ~/Documents/product-research/_cache/cost, поэтому повторный запуск по тому же запросу не нагружает браузер.

Без заранее авторизованного профиля в 1688.com и расширения Claude-in-Chrome MCP скилл сразу остановит работу, так как не умеет сам проходить капчи и формы входа.

Какие задачи решает

  • Собрать топ-10 листингов Amazon по ключевому слову с оценкой продаж
  • Найти оптовые цены FOB на 1688.com по фотографиям товаров
  • Рассчитать комиссии Amazon FBA через публичный API Profitlee
  • Сформировать локальный HTML-отчёт с кнопкой сохранения в PDF

Примеры запросов агенту

  • Проанализируй затраты и маржинальность FBA для reusable beeswax bread bag
  • Собери отчёт по товарам Amazon и ценам с 1688 по запросу silicone baking mat

Как установить product-cost-analyze-for-fba

1Через Skills CLI (Vercel)

npx skills add AronLEEdev/product-cost-analyze-skill --skill product-cost-analyze-for-fba -a claude-code

2Вручную: положить файлы

~/.claude/skills/product-cost-analyze-for-fba/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/product-cost-analyze-for-fba/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о product-cost-analyze-for-fba

Как установить product-cost-analyze-for-fba в Claude Code?

Выполните команду npx skills add AronLEEdev/product-cost-analyze-skill --skill product-cost-analyze-for-fba -a claude-code.

Что делает product-cost-analyze-for-fba?

Скилл открывает Chrome, парсит поисковую выдачу Amazon, находит поставщиков на 1688 по картинкам, считает комиссии FBA и собирает интерактивный отчёт.

Какие аккаунты и программы нужны для запуска?

Требуются Node.js ≥ 18, Python 3, расширение Claude-in-Chrome MCP и браузер Chrome с уже выполненным входом на 1688.com.

Исходный текст

SKILL.md · MIT
---
name: product-cost-analyze-for-fba
description: Perform FBA product-cost analysis for ecommerce sellers. Given a product keyword, drive the user's logged-in Chrome via the Claude-in-Chrome MCP to capture top Amazon listings (volume from "bought in past month" badges), batch reverse-image-search 1688.com for wholesale FOB prices, compute FBA fees via the Profitlee calc API, and render a static HTML profitability report.
---

# Product Research Procedure

A reusable browser automation for fetching product data and estimating FBA profitability. The user provides a product keyword; the skill drives the user's logged-in Chrome through the **Claude-in-Chrome MCP** to find matching products on Amazon (monthly volume from the **"bought in past month"** badges), batch reverse-image-searches **1688.com** for a wholesale FOB reference, runs the FBA profitability formula (via the **Profitlee** calc API), and writes a `results.js` data file that the bundled **static HTML template** renders — so the HTML is never regenerated and costs zero tokens per run.

## Output files (per run)

All outputs go into a run directory, e.g. `~/Documents/product-research/<keyword>/`:

| File | Written by | Description |
|---|---|---|
| `products.json` | Phase 1 | Amazon listings |
| `fob.json` | Phase 2 | 1688 FOB prices |
| `results.js` | Phase 3 | `window.__FBA_DATA__ = {...}` — loaded by the template |
| `report.html` | **one-time copy** | Copy of the bundled template (copy, don't regenerate) |

**This skill is a single file.** A user only needs `SKILL.md` — the runtime
assets are produced on demand into the run dir:
- `calc.mjs` (Phase 3 helper) is **written from the copy embedded in this file** (§3.2). No dependencies beyond Node ≥18 built-ins.
- `report-template.html` (Phase 4 renderer) is **fetched from the skill's repo** on first run (§Phase 4) and saved as `report.html`.
- `serve-report.py` (Phase 4 server) is **fetched from the skill's repo** on first run. It serves the run dir and adds an `/export.pdf` endpoint that backs the report's **Save as PDF** button.

See Phase 4 for serving + opening the report.

## Preconditions & setup (read once)

### Preconditions — accounts & tools the user must have

The skill drives the user's **live Chrome**, so every login below lives in that
one browser profile. Log into Amazon and 1688 there **before** starting.

| Requirement | Needed for | Required? |
|---|---|---|
| Chrome + the **Claude-in-Chrome MCP** extension, connected | browser driver for the whole workflow | **Required** |
| **1688.com account, logged in** (same Chrome profile) | Phase 2 batch image sourcing — submitting `帮我寻源` creates a real sourcing task on the account | **Required** |
| Internet access to **Profitlee's public calc API** (no token — see [docs](https://profitlee.com/docs/api)) | Phase 3 FBA-fee calculation | **Required** |
| **Node.js ≥ 18** | runs the Phase 3 `calc.mjs` helper (written to the run dir) — needs built-in `fetch` | **Required** |
| **Python 3** (or any static file server) | serves the report over http (Phase 4) | **Required** |
| **Amazon** — a logged-in Chrome profile | Phase 1 scraping (anonymous browsing works but trips bot-detection/CAPTCHA more often) | Recommended |
| **Helium 10** extension + account | richer per-product sales volume; otherwise volume is estimated from the "bought in past month" badge | Optional |

If a required item is missing the run cannot complete — e.g. no Profitlee token
hard-stops Phase 3, and a logged-out 1688 hard-stops Phase 2 (the skill asks the
user to resolve it rather than working around it).

### Driver — Claude-in-Chrome MCP

This skill drives the user's own logged-in Chrome through the **Claude-in-Chrome
MCP** (`mcp__Claude_in_Chrome__*`) for **both phases** — no API key, no credits,
and the live session already holds the user's Amazon and 1688 login cookies.
(An earlier `browser-act` CLI path was dropped — it failed to connect reliably.)

Tools used throughout:
- `list_connected_browsers` / `select_browser` — pick the local Chrome.
- `tabs_context_mcp` (with `createIfEmpty: true`) / `tabs_create_mcp` / `tabs_close_mcp` — manage the working tab(s).
- `navigate` — drive the tab to a URL.
- `javascript_tool` — run in-page `eval` for extraction (preferred over `get markdown`; far fewer tokens).
- `computer` — `screenshot` and **real pointer clicks** (needed where a JS click won't trigger a gesture-gated action; see Phase 2).

> **No automated login or CAPTCHA solving.** If a site shows a login wall or a
> verification slider, stop and ask the user to resolve it, then continue.

### Profitlee calc API (public — no token)

Phase 3 calls **Profitlee's public calc engine** at
`https://profitlee.com/api/v1/calculate` — no API key, no auth, nothing to set
up. Full API reference: <https://profitlee.com/docs/api>.

## Caching (14-day TTL — re-runs cost ~0 browser work)

The Amazon scrape (Phase 1) and especially the **1688 batch** (Phase 2 — slow ~1–2 min,
and it creates a real sourcing task on the user's account each run) are the expensive
parts. Cache each by keyword, 14-day TTL, so re-running the same keyword reuses them.

- **slug** = keyword lowercased, every run of non-alphanumerics → `-`
  (`reusable beeswax bread bag` → `reusable-beeswax-bread-bag`).
- **Check** before the phase; on a hit, copy it in and **skip that phase's browser work**:
  ```bash
  CACHE=~/Documents/product-research/_cache/cost
  HIT=$(find "$CACHE" -name "<artifact>__<slug>.json" -mtime -14 2>/dev/null | head -1)
  [ -n "$HIT" ] && cp "$HIT" "<run-dir>/<artifact>.json" && echo "CACHE HIT <artifact>"
  ```
- **Save** after the phase completes cleanly (only when it was NOT a cache hit):
  ```bash
  mkdir -p "$CACHE" && cp "<run-dir>/<artifact>.json" "$CACHE/<artifact>__<slug>.json"
  ```

Cached artifacts: **`products`** (Phase 1) and **`fob`** (Phase 2). Never cache
partial/hard-stopped data. Phase 3 (Profitlee) is fast and free — always recompute
`results.js` from the cached inputs so price/fee assumptions stay current. To force a
fresh pull, delete the cache file. Reusing a cached `fob` also avoids creating a new
1688 sourcing task.

## Phase 1 — Keyword search on Amazon (Claude-in-Chrome MCP)

Goal: capture the top 10 products (ASIN, title, price, volume, image, pack count) filtered to a $10–$50 price band.

> **Cache first:** run the §Caching check for `products`. On a hit, load the cached
> `products.json` and skip §1.1–1.5. Save it to cache after §1.5 writes it clean.

### 1.1 Browser setup

Connect to the user's Chrome via the MCP:
1. `mcp__Claude_in_Chrome__list_connected_browsers` → `select_browser` with the
   local browser's `deviceId`.
2. `mcp__Claude_in_Chrome__tabs_context_mcp` with `createIfEmpty: true` to get a
   working tab; note its `tabId` and reuse it through Phase 1.

### 1.2 Navigate to filtered search

Encode the $10–$50 price band directly in the URL — faster and more reliable than clicking the left-rail filter. `mcp__Claude_in_Chrome__navigate` the tab to:

```
https://www.amazon.com/s?k=<keyword>&rh=p_36%3A1000-5000&language=en_US
```

(`p_36%3A1000-5000` = cents, so $10–$50.)

### 1.3 Extract product data with eval (not get markdown)

`get markdown` on an Amazon search page returns ~40,000 tokens of navigation chrome, chat widgets, and keyboard shortcuts — almost none of it useful. Run a targeted `javascript_tool` eval instead. It also parses **monthly volume** from the "bought in past month" badge and the **pack count** from the title (Phase 3 multiplies FOB by it):

```js
(function(){
  function vol(t){ if(!t) return 100; const m=t.match(/([\d.]+)K\+/i); if(m) return Math.round(parseFloat(m[1])*1000); const n=t.match(/(\d+)\+/); return n?parseInt(n[1]):100; }
  function pk(t){ const m=(t.match(/(\d+)\s*-?\s*pack/i)||t.match(/pack of\s*(\d+)/i)||t.match(/set of\s*(\d+)/i)||t.match(/(\d+)\s*-?\s*pk\b/i)||t.match(/(\d+)\s*(?:pcs|pc|pieces|count)\b/i)||t.match(/(\d+)\s*each\b/i)); return m?parseInt(m[1],10):1; }
  const seen=new Set();
  return JSON.stringify(
    Array.from(document.querySelectorAll('.s-result-item[data-asin]:not([data-asin=""])')).slice(0,25).map(el=>{
      const asin=el.getAttribute('data-asin'); if(seen.has(asin)) return null; seen.add(asin);
      const title=(el.querySelector('h2 span')||{}).textContent||'';
      const pe=el.querySelector('.a-price .a-offscreen');
      const price=pe?parseFloat(pe.textContent.replace(/[^0-9.]/g,'')):null;
      const be=el.querySelector('.a-size-base.a-color-secondary:not(.a-text-normal)');
      const bought=be?be.textContent.trim():'';
      const ie=el.querySelector('img.s-image');
      const imageUrl=(ie?ie.src:'').replace('_AC_UL320_','_AC_UL640_');
      const packCount=pk(title);
      return { asin, title, price, monthlyVolume:vol(bought), volumeSource:'badge', imageUrl, amazonUrl:'https://www.amazon.com/dp/'+asin, packCount, packSource: packCount>1?'title':'default' };
    }).filter(p=>p&&p.asin&&p.title&&p.price).slice(0,10)
  );
})()
```

Volume comes from the Amazon "bought in past month" badge (`"10K+" → 10000`, `"1K+" → 1000`, `"500+" → 500`, etc.; `volumeSource: "badge"`). Helium 10 is **optional** — if the extension is installed and shows per-product units, use those and set `volumeSource: "helium10"` — but it is not required.

> **`window.*` page variables are cleared by navigation.** If you stash results on `window`, capture the image URLs (and anything else you need) before visiting detail pages in §1.4 — or just re-extract `asin → imageUrl` from the search page afterward. Page-scoped state does not survive a `navigate`.

### 1.4 Get product dimensions

Phase 3 needs L/W/H/weight. For each ASIN, `mcp__Claude_in_Chrome__navigate` to the detail page, then `javascript_tool` eval the product-info table:

```js
(function(){
  const rows=[...document.querySelectorAll('#productDetails_techSpec_section_1 tr, #prodDetails tr, #detailBullets_feature_div li')];
  let dim='', wt='';
  for(const r of rows){
    const t=r.textContent.replace(/\s+/g,' ');
    if(/dimension/i.test(t)&&!dim) dim=t.trim();
    if(/item weight/i.test(t)&&!/shipping/i.test(t)&&!wt) wt=t.trim();
  }
  return JSON.stringify({ dim: dim.slice(0,120), wt: wt.slice(0,60) });
})()
```

Parse `"... 13.7 x 5.31 x 1.57 inches"` → `{L:13.7, W:5.31, H:1.57}` and `"8.8 ounces"` → `weight: 0.55 lb` (ounces ÷ 16).  
If a listing has no dimensions, use category-typical estimates and flag as `dimsSource: "estimated"` in `products.json`.

> ⚠️ **HARD RULE — multipack dimensions must cover the SHIPPED unit.**
> FBA charges on the package Amazon ships, which for an N-pack is the whole carton.
> Amazon's detail page is inconsistent about this, and getting it wrong understates
> the fulfilment fee on exactly the dim-weight-sensitive products where it hurts most.
>
> **Whenever `packCount > 1`, you MUST classify the scraped dims before using them:**
>
> | What the page shows | Meaning | Action |
> |---|---|---|
> | `Package Dimensions` (3 numbers) | the shipped carton | ✅ use as-is, `dimsSource: "scraped"` |
> | `Product/Item Dimensions L×W×H` (3 numbers) | usually the carton on multipacks | ✅ use, but sanity-check against unit size |
> | **`Item Dimensions W × H` (only 2 numbers)** | **ONE unit** — never the carton | ❌ **do not use** — derive the carton |
> | `Item Weight` ≈ one unit's plausible weight | **ONE unit** | ❌ **do not use** — multiply |
>
> **Two-number dimensions are the tell.** A carton always has three. `3.94"W × 11.02"H`
> is a single cylinder's diameter and height.
>
> **Deriving the carton** (label `dimsSource: "derived-Npack"` and record a `dimsNote`
> naming the published figures you derived from):
> - Pack the N units in the tightest realistic arrangement (2 → side by side;
>   4 → 2×2), then add ~0.2 in per axis for wall thickness.
> - `weight = N × unit weight + ~0.15 lb carton tare`.
> - Never silently reuse single-unit dims for an N-pack.
>
> **Cross-check:** `Item Weight ÷ packCount` should be a plausible weight for ONE unit.
> If the published weight is only plausible as a single unit, it IS a single unit.
>
> Because this is a derivation and not a measurement, the report and any write-up must
> say so, and sourcing must confirm the real carton spec with the factory before ordering.

### 1.5 Write products.json

**Pack count.** Amazon listings are often multipacks; the listing price covers
all units, but the 1688 FOB is per single unit, so Phase 3 multiplies FOB by the
pack count. Parse the title and record `packCount` (int) and `packSource`.
Patterns (case-insensitive): `N Pack`, `N-Pack`, `Npack`, `Pack of N`,
`Set of N`, `N pcs|pc|pieces|count`. No match → `packCount: 1,
packSource: "default"` (a true single, or a missed pack).

```json
[
  {
    "asin": "B0EXAMPLE",
    "title": "Product title",
    "amazonUrl": "https://www.amazon.com/dp/B0EXAMPLE",
    "price": 24.99,
    "monthlyVolume": 3000,
    "volumeSource": "badge",
    "imageUrl": "https://m.media-amazon.com/images/I/example._AC_UL640_.jpg",
    "dim": { "L": 13.7, "W": 5.3, "H": 1.6 },
    "weight": 0.55,
    "dimsSource": "scraped",
    "packCount": 4,
    "packSource": "title"
  }
]
```

> **Pagination cursor:** track the current page and seen ASINs so a retry can fetch the next page without overlap.

## Phase 2 — Batch image sourcing for FOB on 1688.com (no fallback)

Goal: upload all product images at once to 1688's batch image-sourcing tool
("图片批量找") and extract a wholesale FOB reference + a seller link per product
from the single results page. **Real 1688 data only — no estimation, no Taobao
fallback. If access is blocked, stop and wait for the user to resolve it.**

> **Cache first:** run the §Caching check for `fob`. On a hit, load the cached
> `fob.json` and skip all of Phase 2 (no re-upload, no new sourcing task). Save it to
> cache after §2.4 writes it clean (all products mapped, no hard-stop).

### 2.1 Setup — require a logged-in batch tab

The batch tool lives at
`https://air.1688.com/kapp/1688-pc-front/ai-avatar/procurement?tab=imageBatch`
and requires login. Login must be done by the user — never automate sign-in.

1. `mcp__Claude_in_Chrome__list_connected_browsers` → `select_browser`, then
   `mcp__Claude_in_Chrome__tabs_context_mcp`.
2. Look for an existing tab whose URL contains
   `air.1688.com/kapp/1688-pc-front/ai-avatar/procurement`.
3. **If none is found, stop and ask the user** to open
   `https://air.1688.com/kapp/1688-pc-front/ai-avatar/procurement?tab=imageBatch`
   and log in, then confirm. Do NOT auto-navigate there or attempt login.
4. Once the tab exists and is logged in, use it as the working tab. If it is not
   on `?tab=imageBatch`, `navigate` it there. Then run the §2.3 step-1
   block-probe before proceeding.

### 2.2 (removed)

Images are injected from their URLs in §2.3 — there is no disk download step.

### 2.3 Batch search

1. **Block-probe** (a CAPTCHA can appear even when logged in). Run via
   `javascript_tool` on the batch tab:

```js
(function(){
  const t = document.title || '';
  const x = (document.body ? document.body.innerText : '').slice(0, 800);
  const blocked = /captcha|interception|验证|滑动|滑块|unusual traffic/i.test(t + ' ' + x);
  return JSON.stringify({ blocked, title: t.slice(0, 60) });
})()
```

If `blocked:true`, hard-stop (step 7).

2. **Inject all images** from products.json `imageUrl`s (in array order) into the
single `multiple` file input, in one pass. Substitute the real URL array for
`URLS`:

```js
(async function(urls){
  const inp = [...document.querySelectorAll('input[type=file]')]
    .find(el => el.multiple && /image/.test(el.accept));
  if (!inp) return 'NO_MULTI_INPUT';
  const dt = new DataTransfer(); let ok = 0;
  for (let i = 0; i < urls.length; i++) {
    try {
      const r = await fetch(urls[i]); if (!r.ok) continue;
      const b = await r.blob();
      dt.items.add(new File([b], 'img' + i + '.jpg', { type: b.type || 'image/jpeg' }));
      ok++;
    } catch (e) {}
  }
  inp.files = dt.files;
  inp.dispatchEvent(new Event('change', { bubbles: true }));
  return 'STAGED ' + ok + '/' + urls.length;
})(URLS)
```

Require `STAGED N/N`. Fewer than N → an image URL failed; hard-stop and fix
products.json.

3. **Wait for upload** to read `上传成功`, then **submit with a REAL pointer
click** on the `帮我寻源` button: `mcp__Claude_in_Chrome__computer` `screenshot`
to locate it, then `computer left_click` by coordinate. A JS `.click()` will not
submit (1688 opens the result via a gesture-gated action). The tab navigates to
`…/procurement/batchDetail?taskId=<id>&tab=imageBatch`.

4. **Poll until done.** The detail page streams results and shows progress
`搜索匹配商品中 X/N`; processing takes ~1–2 min. Poll every ~20–30 s with:

```js
(function(){
  const m = document.body.innerText.match(/搜索匹配商品中\s*(\d+)\/(\d+)/);
  const groups = [...document.querySelectorAll('*')]
    .filter(e => e.childElementCount === 0 && e.textContent.trim() === '已为您找到相似货源').length;
  return JSON.stringify({ progress: m ? m[0] : '(none)', groups });
})()
```

Done when `progress` is `(none)` and `groups` equals N.

5. **Extract per group, normalized per unit** via `javascript_tool`. Each group's
matched cards carry a title, a price, and a direct `detail.1688.com/offer/<id>.html`
link. Read the **full price from the card's `¥X.XX` text** — the `priceMain`
element holds only the integer part for cheap items (¥1.75 → "1"). A 1688 price
may cover a set (e.g. `4个装`), so divide each card's price by its set size
(`cnPack`, parsed from the title) **before** taking the median — the result is a
per-single-unit FOB. Band is ¥0.5–80 (real single-unit wholesale runs as low as
~¥1; this still drops ¥0.03-type junk):

```js
(function(){
  function cnPackOf(t){
    t = t || '';
    const m = t.match(/(\d+)\s*(?:个|只|支|件|台|条|包|盒|套|组)\s*装/)
           || t.match(/(\d+)\s*件套/)
           || t.match(/(\d+)\s*(?:个|只|支|件)\s*[\//]\s*(?:套|包|盒|组)/)
           || t.match(/(\d+)\s*(?:pcs?|pack)/i);
    const n = m ? parseInt(m[1],10) : 1;
    return (n >= 1 && n <= 50) ? n : 1;
  }
  const headers = [...document.querySelectorAll('*')]
    .filter(e => e.childElementCount === 0 && e.textContent.trim() === '已为您找到相似货源');
  function groupRoot(h){ let n=h; for(let i=0;i<8&&n;i++){ if(n.querySelectorAll('a[href*="detail.1688.com/offer"]').length>=1 && /¥|¥/.test(n.textContent)) return n; n=n.parentElement;} return h.parentElement; }
  const groups = headers.map((h, idx) => {
    const root = groupRoot(h);
    const cards = [...root.querySelectorAll('a[href*="detail.1688.com/offer"]')].map(a => {
      let card = a;
      for (let i = 0; i < 6 && card.parentElement; i++) { if (card.querySelector && card.querySelector('[class*=priceMain]')) break; card = card.parentElement; }
      const ym = (card.textContent || '').match(/[¥¥]\s*(\d+\.?\d*)/);
      const price = ym ? parseFloat(ym[1]) : NaN;
      const title = (card.textContent || '').replace(/\s+/g,' ').trim().slice(0,60);
      return { title, price, offerUrl: a.href.split('?')[0], cnPack: cnPackOf(title) };
    });
    const perUnit = cards.map(c => c.price / c.cnPack).filter(v => v >= 0.5 && v <= 80);
    const u = [...new Set(perUnit)].sort((a,b) => a-b);
    const mid = Math.floor(u.length/2);
    const median = u.length ? (u.length % 2 ? u[mid] : (u[mid-1]+u[mid])/2) : 0;
    const first = cards[0] || {};
    return { i: idx+1, count: u.length, median, sellerUrl: first.offerUrl || '', cnPack: first.cnPack || 1, matchedTitle: first.title || '' };
  });
  return JSON.stringify(groups);
})()
```

`fobRmb = median` (per single unit), `candidates = count`; `cnPack` and
`matchedTitle` describe the chosen offer (surfaced so a missed set is catchable).

6. **Map by upload order:** group `i` ↔ products[`i`-1]. Sanity-check
`groups.length === products.length`; mismatch → hard-stop.

7. **Hard-stop rules (no estimation).** Stop and wait for the user (then retry)
when any of these holds — never estimate or fall back:
- block-probe `blocked:true` → ask the user to solve the CAPTCHA / re-login;
- `STAGED` count < N → an image URL failed;
- `groups.length !== products.length` after completion → order mapping unsafe;
- any product group has 0 prices in ¥2–80 → that product is unmatched.
Otherwise accept the group median even when `count` is 1–2.

> ⛔ **1688 batch blocked / incomplete.** Resolve access (log in / solve the
> slider) or fix the failing input, confirm here, then re-run Phase 2. There is
> no fallback — FOB must come from a live 1688 batch result.

### 2.4 Write fob.json

```json
[
  {
    "asin": "B0EXAMPLE",
    "matched": true,
    "source": "1688-batch",
    "fobRmb": 7.3,
    "fobUsd": 1.01,
    "candidates": 2,
    "cnPack": 1,
    "matchedTitle": "驱蝇器黑色 电池款",
    "sellerUrl": "https://detail.1688.com/offer/123456789.html"
  }
]
```

`fobRmb` and `fobUsd` are **per single unit** (`fobUsd = fobRmb / 7.2`).
`candidates` is the per-image price count (typically 1–2 from the batch tool).
`cnPack` is the matched offer's set size (units its price covers; usually 1) and
`matchedTitle` is its name — both surfaced so a missed set is catchable.
`sellerUrl` is the first matched product's direct
`detail.1688.com/offer/<id>.html` link.

> **Only write `fob.json` after all products map cleanly** (group count ==
> product count, no 0-match product). A partial fob.json means Phase 3 cannot
> run.

### 2.5 Hygiene

Submitting `帮我寻源` creates a real sourcing task on the user's 1688 account each
run (async; visible under 历史任务 / 询盘结果). Close the batchDetail tab when done.
No images are written to disk. `fob.json` may contain session-derived data; do
not share or commit it.

## Phase 3 — Calculate & write results.js

The FBA math lives in Profitlee's tested calc engine, not in this skill. Phase 3
sends each product to that engine and writes `results.js` from the responses. Do
**not** hand-roll fee tables here.

There are two transports for the same engine (auto-detected in §3.3): the
**`profitlee-mcp`** tool (`mcp__profitlee__calculate_profit`) if it is installed,
otherwise the **public HTTP API** (`POST https://profitlee.com/api/v1/calculate`,
no token). Both share the same defaults and the same helper, so the resulting
`results.js` is identical either way.

### 3.1 Preconditions

- `<run-dir>/products.json` and `<run-dir>/fob.json` both exist and cover the
  same ASINs (Phase 2 completed with no hard-stop).
- Either the `profitlee-mcp` tool is available, **or** internet access to
  Profitlee's public calc API (no token). See §3.3 — the transport auto-detects.

### 3.2 Write the calc helper

The helper has **no dependencies** (Node ≥18 built-ins only). It maps calc outputs
into the report template's shape (margins as whole percents;
`ppcCost`/`returnLoss`/`tier` field names; `fob = fobUsd × packCount`), filters
survivors (`netProfitAfterPPC > 0`), sorts by net margin then monthly net, badges
the top 3 with margin ≥ 15%, and writes `<run-dir>/results.js`. Both transports in
§3.3 share it. It also exposes two helper modes used by the MCP path:
`--emit-payloads` (writes `payloads.json`, no network) and `--outputs <file>`
(maps from pre-computed outputs, no network).

Write this verbatim to `<run-dir>/calc.mjs`:

```js
// calc.mjs
import { readFile, writeFile } from "node:fs/promises";
import { join, isAbsolute } from "node:path";
import { pathToFileURL } from "node:url";

const API_URL = "https://profitlee.com/api/v1/calculate";

const CONSTANTS = {
  region: "us",
  ppcAcos: 0.20,
  returnRate: 0.05,
  referralPct: 0.15,
  isApparel: false,
  inboundOption: "single",
  storageMonths: 1,
  storageSeason: "janSep",
  exchangeRate: 7.2,
  dutyRate: 0,
  headShipPerUnit: 0.30,
};

export function deriveShipWeight(dim, weight) {
  const { L, W, H } = dim;
  const dimWeight = (Math.max(L, 2) * Math.max(W, 2) * Math.max(H, 2)) / 139;
  return Math.max(weight, dimWeight);
}

export function buildPayload(product, fobEntry) {
  const packCount = product.packCount || 1;
  const fob = fobEntry.fobUsd * packCount;
  return {
    mode: "fba",
    region: CONSTANTS.region,
    L: product.dim.L,
    W: product.dim.W,
    H: product.dim.H,
    weight: product.weight,
    fob,
    headShip: CONSTANTS.headShipPerUnit * packCount,
    duty: fob * CONSTANTS.dutyRate,
    price: product.price,
    monthlyVolume: product.monthlyVolume,
    ppcAcos: CONSTANTS.ppcAcos,
    returnRate: CONSTANTS.returnRate,
    referralPct: CONSTANTS.referralPct,
    isApparel: CONSTANTS.isApparel,
    inboundOption: CONSTANTS.inboundOption,
    storageMonths: CONSTANTS.storageMonths,
    storageSeason: CONSTANTS.storageSeason,
  };
}

export function mapOutputs(product, fobEntry, outputs) {
  return {
    asin: product.asin,
    title: product.title,
    amazonUrl: product.amazonUrl,
    imageUrl: product.imageUrl,
    price: product.price,
    monthlyVolume: product.monthlyVolume,
    volumeSource: product.volumeSource,
    fobRmb: fobEntry.fobRmb,
    fobUsd: fobEntry.fobUsd,
    fobSource: fobEntry.source || "1688",
    sellerUrl: fobEntry.sellerUrl || "",
    dim: product.dim,
    packCount: product.packCount || 1,
    cnPack: fobEntry.cnPack || 1,
    fobUsdPerListing: +((fobEntry.fobUsd) * (product.packCount || 1)).toFixed(2),
    headShip: +(CONSTANTS.headShipPerUnit * (product.packCount || 1)).toFixed(2),
    duty: +((fobEntry.fobUsd) * (product.packCount || 1) * CONSTANTS.dutyRate).toFixed(2),
    shipWeight: outputs.shipWeight,
    tier: outputs.sizeTier,
    landedCogs: outputs.landedCogs,
    inboundFee: outputs.inboundFee,
    fulfillmentFee: outputs.fulfillmentFee,
    referralFee: outputs.referralFee,
    storageFee: outputs.storageFee,
    totalCost: outputs.totalCost,
    grossProfit: outputs.grossProfit,
    grossMargin: +(outputs.grossMargin * 100).toFixed(2),
    ppcCost: outputs.ppcCostPerUnit,
    returnLoss: outputs.returnLossPerUnit,
    netProfitAfterPPC: outputs.netProfitAfterPPC,
    netMarginAfterPPC: +(outputs.netMarginAfterPPC * 100).toFixed(2),
    monthlyNetAfterPPC: Math.round(outputs.monthlyNetAfterPPC),
    recommended: false,
    badge: null,
  };
}

export function selectAndRank(mapped) {
  const survivors = mapped.filter((p) => p.netProfitAfterPPC > 0);
  const eliminated = mapped.filter((p) => p.netProfitAfterPPC <= 0);
  survivors.sort((a, b) =>
    b.netMarginAfterPPC !== a.netMarginAfterPPC
      ? b.netMarginAfterPPC - a.netMarginAfterPPC
      : b.monthlyNetAfterPPC - a.monthlyNetAfterPPC
  );
  let badge = 0;
  for (const s of survivors) {
    if (badge < 3 && s.netMarginAfterPPC >= 15) {
      s.recommended = true;
      s.badge = ++badge;
    }
  }
  return { survivors, eliminated };
}

export async function callApi(payload, fetchImpl = fetch) {
  const res = await fetchImpl(API_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload),
  });
  if (!res.ok) {
    const body = await res.text().catch(() => "");
    throw new Error(`HTTP ${res.status}: ${body.slice(0, 200)}`);
  }
  const json = await res.json();
  const out = json.result || json.outputs; // v1 wraps in `result`; `outputs` kept for back-compat
  if (!out) throw new Error("missing result in response");
  return out;
}

export async function emitPayloads(runDir) {
  const products = JSON.parse(await readFile(join(runDir, "products.json"), "utf8"));
  const fob = JSON.parse(await readFile(join(runDir, "fob.json"), "utf8"));
  const fobMap = new Map(fob.map((f) => [f.asin, f]));
  const payloads = products.map((p) => {
    const f = fobMap.get(p.asin);
    if (!f) throw new Error(`no fob.json entry for ${p.asin}`);
    return { asin: p.asin, payload: buildPayload(p, f) };
  });
  await writeFile(join(runDir, "payloads.json"), JSON.stringify(payloads, null, 2));
  return payloads;
}

export async function main(runDir, keyword, opts = {}) {
  const fetchImpl = opts.fetchImpl || fetch;

  const products = JSON.parse(await readFile(join(runDir, "products.json"), "utf8"));
  const fob = JSON.parse(await readFile(join(runDir, "fob.json"), "utf8"));
  const fobMap = new Map(fob.map((f) => [f.asin, f]));

  const settled = await Promise.allSettled(
    products.map(async (p) => {
      const f = fobMap.get(p.asin);
      if (!f) throw new Error(`no fob.json entry`);
      let outputs;
      if (opts.outputsByAsin) {
        const raw = opts.outputsByAsin[p.asin];
        if (!raw) throw new Error(`no outputs for ${p.asin}`);
        outputs = raw.result || raw; // tolerate {result: CalcOutputs} (MCP) or a raw CalcOutputs
      } else {
        outputs = await callApi(buildPayload(p, f), fetchImpl);
      }
      return mapOutputs(p, f, outputs);
    })
  );

  const failures = settled
    .map((s, i) => (s.status === "rejected" ? `${products[i].asin}: ${s.reason.message}` : null))
    .filter(Boolean);
  if (failures.length) {
    throw new Error("Calc failed — no results.js written:\n" + failures.join("\n"));
  }

  const mapped = settled.map((s) => s.value);

  for (const m of mapped) {
    const sum = m.fobUsdPerListing + m.headShip + m.duty;
    if (Math.abs(sum - m.landedCogs) > 0.05) {
      console.warn(`warn ${m.asin}: FOB+headShip+duty ($${sum.toFixed(2)}) != API landedCogs ($${m.landedCogs})`);
    }
  }

  const { survivors, eliminated } = selectAndRank(mapped);

  const bestMonthly = survivors.length ? Math.max(...survivors.map((s) => s.monthlyNetAfterPPC)) : 0;
  const marketInsight = survivors.length
    ? `${survivors.length} of ${mapped.length} products profitable. Top margin: ${survivors[0].netMarginAfterPPC.toFixed(1)}% (${survivors[0].asin}). Best monthly: $${bestMonthly}/mo.`
    : `0 of ${mapped.length} products profitable.`;

  const data = {
    keyword,
    date: new Date().toISOString().slice(0, 10),
    assumptions: {
      exchangeRate: CONSTANTS.exchangeRate,
      dutyRate: CONSTANTS.dutyRa...

© AronLEEdev · MIT · AronLEEdev/product-cost-analyze-skill

Похожие скиллы

Все скиллы по теме «Браузер и парсинг» →
smoke-test mastra-ai Скилл smoke-test разворачивает проект Mastra через create-mastra и запускает смоук-тест Mastra Studio в Chrome. CX Codex +1 2 500установок job-search proficientlyjobs Скилл job-search прогоняет ежедневный поиск вакансий в браузере, сверяет их с вашим резюме и предпочтениями и оставляет только подходящие. CX Codex +1 555установок amazon-sp-fba-inbound KuudoAI Скилл amazon-sp-fba-inbound помогает оформлять поставки на склады Amazon через API Fulfillment Inbound. Запрашивает подтверждение перед каждым платным шагом. CX Codex +1 ★ 1 596звёзд репо Easyparser — Amazon Product & Seller Data easyparser-com Easyparser — Amazon Product & Seller Data — MCP-сервер для Claude Code: агент получает карточки товаров, офферы продавцов и историю продаж Amazon в 21 маркетплейсе. CX Codex +1 amazon-fba-calculator nexscope-ai Скилл amazon-fba-calculator определяет размерную категорию товара и считает комиссии Amazon FBA по сетке 2024 года. Помогает оценить маржу и ROI до отправки партии на склад. CX Codex +1 1 300установок amazon-fba-prep nexscope-ai Скилл amazon-fba-prep для Claude Code собирает по каждому SKU инструкцию по подготовке, маркировке и упаковке товара перед отправкой на склад Amazon. Закрывает первую партию и проверку плана отгрузки. CX Codex +1 1 200установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой