Skip to content
Back to search

pinme

SkillWorks with Claude CodeGitHub

Deploy Your Frontend in a Single Command. Claude Code Skills supported.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/glitternetwork-pinme/badge.svg)](/listings/glitternetwork-pinme)

HTML

<a href="/listings/glitternetwork-pinme"><img src="/api/listings/glitternetwork-pinme/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Prerequisites

- Node.js `>= 16.13.0`

Create a new Worker project

npm install -g pinme
pinme login
pinme create my-app
cd my-app
pinme save

What this workflow gives you:

- a generated PinMe project from the official template - platform-side Worker and database provisioning - local project config in `pinme.toml` - frontend and Worker deployment from one CLI

Update only the part you changed

pinme update-worker
pinme update-db
pinme update-web

Upload a static build when you do not need the project workflow

pinme login
pinme upload dist

Common build directories are `dist`, `build`, `out`, and `public`.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 391 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <a href="https://pinme.eth.limo/">
  3. <img src="https://2egc5b44.pinit.eth.limo/" height="92" alt="PinMe logo">
  4. <h3 align="center">PinMe</h3>
  5. </a>
  6. </p>
  7. <p align="center">
  8. Create and deploy your web in one command.
  9. </p>
  10. # PinMe
  11. [PinMe](https://pinme.eth.limo/) is a zero-config deployment CLI focused on one-command creation and deployment for full-stack projects.
  12. It lets you quickly set up and launch a complete project with an integrated frontend, Worker backend, and database, without tedious configuration. PinMe is built to make full-stack delivery much simpler and significantly improve development efficiency.
  13. Website: [https://pinme.eth.limo/](https://pinme.eth.limo/)
  14. > **PinMe Skill**
  15. >
  16. > Install the PinMe skill before using PinMe in agent workflows:
  17. >
  18. > ```bash
  19. > npx skills add glitternetwork/pinme
  20. > ```
  21. ## Table of Contents
  22. - [Quick Start](#quick-start)
  23. - [For AI Agents](#for-ai-agents)
  24. - [Installation](#installation)
  25. - [PinMe Project Workflow](#pinme-project-workflow)
  26. - [Authentication and Account Commands](#authentication-and-account-commands)
  27. - [Static Uploads and IPFS Utilities](#static-uploads-and-ipfs-utilities)
  28. - [Command Reference](#command-reference)
  29. - [Development and Testing](#development-and-testing)
  30. - [Limits and Operational Notes](#limits-and-operational-notes)
  31. - [Examples](#examples)
  32. - [Support](#support)
  33. ## Quick Start
  34. ### Prerequisites
  35. - Node.js `>= 16.13.0`
  36. ### Create a new Worker project
  37. ```bash
  38. npm install -g pinme
  39. pinme login
  40. pinme create my-app
  41. cd my-app
  42. pinme save
  43. ```
  44. What this workflow gives you:
  45. - a generated PinMe project from the official template
  46. - platform-side Worker and database provisioning
  47. - local project config in `pinme.toml`
  48. - frontend and Worker deployment from one CLI
  49. ### Update only the part you changed
  50. ```bash
  51. pinme update-worker
  52. pinme update-db
  53. pinme update-web
  54. ```
  55. ### Upload a static build when you do not need the project workflow
  56. ```bash
  57. pinme login
  58. pinme upload dist
  59. ```
  60. Common build directories are `dist`, `build`, `out`, and `public`.
  61. ## For AI Agents
  62. Prefer the PinMe project workflow when the user wants a frontend plus backend plus database, or when the repo already contains `pinme.toml`.
  63. ### Project-mode protocol
  64. Use this flow when the user wants a Worker app, database migrations, or ongoing project updates.
  65. 1. Check Node.js:
  66. ```bash
  67. node --version
  68. ```
  69. 2. Ensure the CLI is available:
  70. ```bash
  71. npm install -g pinme
  72. ```
  73. 3. Authenticate:
  74. ```bash
  75. pinme login
  76. ```
  77. 4. Choose the right project command:
  78. - create a new project: `pinme create <name>`
  79. - deploy everything from a PinMe project root: `pinme save`
  80. - update Worker only: `pinme update-worker`
  81. - update SQL migrations only: `pinme update-db`
  82. - update frontend only: `pinme update-web`
  83. 5. If the repo contains `pinme.toml`, run project commands from that directory.
  84. 6. Return the final project URL printed by the CLI for frontend deploys. For Worker-only or DB-only updates, return the relevant success result instead of fabricating a URL.
  85. ### Static-upload fallback
  86. Use this only when the task is just "publish the built frontend" and there is no PinMe project workflow involved.
  87. 1. Authenticate:
  88. ```bash
  89. pinme login
  90. ```
  91. Or for automation:
  92. ```bash
  93. pinme set-appkey <AppKey>
  94. ```
  95. 2. Find the built output directory in this order:
  96. - `dist/`
  97. - `build/`
  98. - `out/`
  99. - `public/`
  100. 3. Verify the directory exists and contains built assets such as `index.html`.
  101. 4. Upload it:
  102. ```bash
  103. pinme upload <folder>
  104. ```
  105. ### Guardrails
  106. - Do not upload source folders such as `src/`.
  107. - Do not upload `node_modules`, `.git`, or `.env`.
  108. - Do not claim unsupported backend hosting outside the PinMe project template flow.
  109. - For project commands, do not run `update-*` commands outside a PinMe project root with `pinme.toml`.
  110. ## Installation
  111. Install from npm:
  112. ```bash
  113. npm install -g pinme
  114. ```
  115. Verify installation:
  116. ```bash
  117. pinme --version
  118. ```
  119. ## PinMe Project Workflow
  120. ### What `create` sets up
  121. `pinme create <name>` does more than scaffold files. The command:
  122. - requires an authenticated session
  123. - creates the platform project resources first
  124. - downloads the official Worker project template
  125. - writes project metadata into `pinme.toml`
  126. - writes backend metadata and frontend config files
  127. - installs workspace dependencies
  128. - builds the Worker
  129. - uploads Worker code and SQL files
  130. - builds the frontend and attempts an initial frontend upload
  131. After creation, the CLI prints the project management URL and suggests `pinme save` for the next deploy.
  132. ### Create a project
  133. ```bash
  134. pinme login
  135. pinme create my-app
  136. ```
  137. If the target directory already exists, the CLI asks before overwriting it unless `--force` is used.
  138. ### Deploy the whole project
  139. Run this from the project root that contains `pinme.toml`:
  140. ```bash
  141. pinme save
  142. pinme save --domain my-site
  143. pinme save --domain example.com
  144. ```
  145. `save` performs the full deploy path:
  146. - installs project dependencies
  147. - builds the Worker with `npm run build:worker`
  148. - uploads Worker code and SQL files from `db/`
  149. - builds the frontend with `npm run build:frontend`
  150. - uploads `frontend/dist`
  151. - optionally binds a domain after the frontend deploy
  152. ### Update only one layer
  153. Use targeted commands when only one part changed:
  154. ```bash
  155. pinme update-worker
  156. pinme update-db
  157. pinme update-web
  158. ```
  159. What each command expects:
  160. - `update-worker`: builds and uploads Worker code from the current PinMe project
  161. - `update-db`: uploads `.sql` files from `db/`
  162. - `update-web`: builds and uploads `frontend/dist`
  163. ### Delete a project
  164. ```bash
  165. pinme delete
  166. pinme delete my-app
  167. pinme delete my-app --force
  168. ```
  169. This deletes the platform-side Worker, domain binding, and D1 database. Local files remain unchanged.
  170. ## Authentication and Account Commands
  171. ### Login and AppKey
  172. ```bash
  173. pinme login
  174. pinme login --env test
  175. pinme set-appkey
  176. pinme set-appkey <AppKey>
  177. pinme show-appkey
  178. pinme appkey
  179. pinme logout
  180. ```
  181. Notes:
  182. - `pinme login` is the recommended path for project commands.
  183. - `set-appkey` is the alternative authentication method for CLI and automation usage.
  184. ### Domains, wallet, and history
  185. ```bash
  186. pinme my-domains
  187. pinme domain
  188. pinme wallet
  189. pinme wallet-balance
  190. pinme balance
  191. pinme list
  192. pinme ls
  193. pinme list -l 5
  194. pinme list -c
  195. ```
  196. ## Static Uploads and IPFS Utilities
  197. These commands are useful when you already have artifacts and do not need the full Worker project flow.
  198. ### Upload a directory or file
  199. ```bash
  200. pinme upload
  201. pinme upload ./dist
  202. pinme upload ./dist --domain my-site
  203. pinme upload ./dist --domain example.com
  204. pinme upload ./dist --domain my-site --dns
  205. ```
  206. Domain handling:
  207. - domains containing a dot are treated as DNS domains
  208. - domains without a dot are treated as PinMe subdomains
  209. - `--dns` forces DNS mode
  210. ### Bind while uploading
  211. ```bash
  212. pinme bind ./dist --domain my-site
  213. pinme bind ./dist --domain example.com
  214. ```
  215. `bind` requires wallet balance.
  216. ### Import or export CAR files
  217. ```bash
  218. pinme import
  219. pinme import ./site.car
  220. pinme import ./site.car --domain my-site
  221. pinme export <cid>
  222. pinme export <cid> --output ./exports
  223. ```
  224. ### Remove uploaded content
  225. ```bash
  226. pinme rm
  227. pinme rm <value>
  228. ```
  229. ## Command Reference
  230. | Command | What it does |
  231. | --------------------------------------------------------- | ------------------------------------------------------------ |
  232. | `pinme create [name]` | Create a new PinMe Worker project from the official template |
  233. | `pinme save [--domain <name>]` | Deploy the current PinMe project: Worker, SQL, and frontend |
  234. | `pinme update-worker` | Build and upload Worker code only |
  235. | `pinme update-db` | Upload SQL migrations from `db/` only |
  236. | `pinme update-web` | Build and upload the frontend only |
  237. | `pinme delete [name] [--force]` | Delete a platform project |
  238. | `pinme upload [path]` | Upload a file or directory to IPFS |
  239. | `pinme bind [path] --domain <name>` | Upload and bind a domain |
  240. | `pinme import [path]` | Import a CAR file |
  241. | `pinme export <cid> [--output <dir>]` | Export IPFS content as a CAR file |
  242. | `pinme rm [value]` | Remove uploaded content |
  243. | `pinme login [--env test\|prod]` | Login via browser |
  244. | `pinme set-appkey [AppKey]` | Set authentication with an AppKey |
  245. | `pinme show-appkey` / `pinme appkey` | Show masked AppKey info |
  246. | `pinme my-domains` / `pinme domain` | List domains owned by the current account |
  247. | `pinme wallet` / `pinme wallet-balance` / `pinme balance` | Show current wallet balance |
  248. | `pinme list` / `pinme ls` | Show upload history |
  249. | `pinme help` | Show CLI help |
  250. ## Development and Testing
  251. PinMe uses Vitest for unit/integration tests, real `dist/index.js` CLI smoke tests, npm package checks, and Stryker for slower mutation testing.
  252. ```bash
  253. npm run test # Unit and integration tests
  254. npm run test:coverage # Coverage gate for core modules
  255. npm run test:cli # Real CLI black-box tests
  256. npm run test:pack # npm pack/package-shape checks
  257. npm run verify # Full pull-request gate
  258. npm run test:mutation # Slow mutation tests for manual/nightly runs
  259. ```
  260. Tests must not call live PinMe/IPFS/CAR services. Use `nock`, local loopback servers, fixtures, and temporary HOME directories for API and CLI scenarios.
  261. For the full testing policy, layout, and mutation-testing guidance, see
  262. [TESTING.md](TESTING.md).
  263. ## Limits and Operational Notes
  264. - Default single-file upload limit: `100MB`
  265. - Default directory upload limit: `500MB`
  266. - These upload defaults come from the CLI and can be overridden with environment variables
  267. - `update-db` enforces a total SQL payload limit of `10MB` per run
  268. - `upload`, `import`, and project commands require authentication
  269. - domain binding requires wallet balance
  270. - `save`, `update-worker`, `update-db`, and `update-web` expect to run from a PinMe project root with `pinme.toml`
  271. ## Examples
  272. This repo includes example projects and docs:
  273. - [example/docs](./example/docs)
  274. - [example/pinme-blog](./example/pinme-blog)
  275. - [example/supabase](./example/supabase)
  276. ## Support
  277. - Website: [https://pinme.eth.limo/](https://pinme.eth.limo/)
  278. - GitHub: [https://github.com/glitternetwork/pinme](https://github.com/glitternetwork/pinme)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.