@slopperday/cli 0.0.0 → 0.1.0

package/README.md

@@ -1,3 +1,63 @@
 # @slopperday/cli
 
-This is a placeholder release published by monochange to bootstrap trusted publishing.
+Throw slop at the wall from your terminal. `slopper` launches, updates and votes on
+[slopper.day](https://slopper.day) through its API, and prints JSON, so it's built for agents as much as people.
+
+## Run it
+
+There's nothing to install first: any package runner fetches it and runs the `slopper` command inside.
+
+| Runner          | Command                                     |
+| --------------- | ------------------------------------------- |
+| npm             | `npx -y @slopperday/cli <command>`          |
+| pnpm            | `pnpm dlx @slopperday/cli <command>`        |
+| Bun             | `bunx @slopperday/cli <command>`            |
+| Yarn 2 or later | `yarn dlx -q @slopperday/cli <command>`     |
+| Deno            | `deno run -A npm:@slopperday/cli <command>` |
+
+Or install it once with `npm i -g @slopperday/cli` and run `slopper <command>`. It needs Node 22 or later, Bun or Deno
+2, and nothing else: the agent skill is built in.
+
+- **npx needs `-y` for agents.** Before it installs a package it hasn't cached, npx asks "Ok to proceed?". In a
+  terminal it waits for an answer, so an agent running in one hangs; without a terminal (piped, in CI) it goes ahead
+  on its own. `-y` makes it go ahead either way.
+- **yarn needs `-q` for agents.** `yarn dlx` prints its install log on stdout, ahead of the JSON. `-q` leaves just the
+  JSON. Yarn 4 also holds back releases for a day (`npmMinimalAgeGate`); `YARN_NPM_MINIMAL_AGE_GATE=0` skips the wait.
+- **Deno needs `-A`** so the CLI can read its environment and config and call the site. Without it, Deno asks for each
+  permission.
+
+## Sign in
+
+Make a token at [slopper.day/settings/api](https://slopper.day/settings/api), then:
+
+```sh
+npx -y @slopperday/cli login --token slp_...   # or pipe it in: echo "$TOKEN" | npx -y @slopperday/cli login
+```
+
+`login` checks the token first, then saves it with its site in `~/.config/slopper/config.json`
+(`$XDG_CONFIG_HOME/slopper`, or `$SLOPPER_CONFIG_DIR`), readable only by you. `logout` deletes it.
+
+Agents that shouldn't write a config file can skip `login` and pass the token per call:
+
+```sh
+SLOPPER_TOKEN=slp_... npx -y @slopperday/cli whoami
+```
+
+`--token` beats `SLOPPER_TOKEN`, which beats the saved token. `--url` beats `SLOPPER_URL`, then the saved site, then
+https://slopper.day. An empty variable counts as unset.
+
+## Use it
+
+```sh
+npx -y @slopperday/cli whoami
+npx -y @slopperday/cli launch --name TiltMaze --tagline "A maze you tilt" --category games \
+  --link https://tiltmaze.app --screenshot ./cover.png --autopost
+npx -y @slopperday/cli today
+npx -y @slopperday/cli vote <slop id> up    # 5 votes a day; win the day to go slopcessful
+```
+
+`slopper help` lists every command, and `slopper help <command>` its flags. Results print as JSON on stdout; errors go
+to stderr with exit code 1, or 2 for a usage mistake. A value that starts with a dash, like a Markdown list, needs `=`:
+`--description="- one"`.
+
+`slopper skill install` gives your agents the skill that explains it all (also on npm as `@slopperday/skill`).

package/dist/slopper.mjs

@@ -0,0 +1,672 @@
+#!/usr/bin/env node
+import { homedir } from "node:os";
+import process from "node:process";
+import { text } from "node:stream/consumers";
+import { parseArgs } from "node:util";
+import { mkdir, open, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, extname, join, resolve } from "node:path";
+//#region package.json
+var version = "0.1.0";
+//#endregion
+//#region src/client.ts
+/**
+* Where the CLI's settings come from, and the one HTTP client that talks to
+* slopper.day's REST API (`/api/v1`, documented at /llms.txt).
+*/
+const DEFAULT_URL = "https://slopper.day";
+/** Something the person (or agent) running the CLI can act on. Exit code 2 is a usage error. */
+var SlopperError = class extends Error {
+	details;
+	exitCode;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "SlopperError";
+		this.details = options.details ?? null;
+		this.exitCode = options.exitCode ?? 1;
+	}
+};
+function usageError(message) {
+	return new SlopperError(message, { exitCode: 2 });
+}
+/** A file system call that failed, like a config nobody can read. Node, Bun and Deno all give them a code. */
+function isSystemError(error) {
+	return error instanceof Error && typeof error.code === "string" && typeof error.syscall === "string";
+}
+/** An environment variable, or undefined when it's unset or empty: `SLOPPER_TOKEN=` turns it off. */
+function envValue(env, name) {
+	return env[name] || void 0;
+}
+function configPath(env, home) {
+	const dir = envValue(env, "SLOPPER_CONFIG_DIR");
+	if (dir) return join(dir, "config.json");
+	return join(envValue(env, "XDG_CONFIG_HOME") ?? join(home, ".config"), "slopper", "config.json");
+}
+async function readConfig(path) {
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (error) {
+		if (!isSystemError(error)) throw error;
+		if (error.code === "ENOENT") return {};
+		throw new SlopperError(`Couldn't read ${path}: ${error.message}`);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new SlopperError(`${path} isn't valid JSON. Fix it or run \`slopper logout\` to start over.`);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new SlopperError(`${path} should hold a JSON object. Run \`slopper logout\` to start over.`);
+	const { token, url } = parsed;
+	return {
+		...typeof token === "string" ? { token } : {},
+		...typeof url === "string" ? { url } : {}
+	};
+}
+/** Saves the config readable by its owner only: it holds an API token. */
+async function writeConfig(path, config) {
+	await mkdir(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	const file = await open(path, "w", 384);
+	try {
+		await file.chmod(384);
+		await file.writeFile(`${JSON.stringify(config, null, 2)}\n`);
+	} finally {
+		await file.close();
+	}
+}
+async function removeConfig(path) {
+	await rm(path, { force: true });
+}
+/** The site's origin, from a flag, SLOPPER_URL or the saved config; slopper.day otherwise. */
+function resolveUrl(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw usageError(`${value} isn't a URL. Pass the site's address, like ${DEFAULT_URL}.`);
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") throw usageError(`${value} isn't an http(s) URL.`);
+	return url.origin;
+}
+function isErrorBody(value) {
+	return typeof value === "object" && value !== null && typeof value.error === "string";
+}
+/** Why a request got no answer. Fetch wraps the cause (refused, DNS, TLS) in a bare "fetch failed". */
+function networkReason(error) {
+	if (!(error instanceof Error)) return String(error);
+	return error.cause instanceof Error ? `${error.message} (${error.cause.message})` : error.message;
+}
+/** The body as JSON, or undefined when it isn't any: an empty reply, or a proxy's or host's HTML page. */
+function parseJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+function createApi({ url, token, fetch, userAgent }) {
+	async function request(method, path, body, contentType) {
+		if (!token) throw new SlopperError(`No API token. Make one at ${url}/settings/api, then run \`slopper login --token <token>\` or set SLOPPER_TOKEN.`);
+		const headers = {
+			authorization: `Bearer ${token}`,
+			accept: "application/json",
+			"user-agent": userAgent
+		};
+		if (contentType) headers["content-type"] = contentType;
+		let response;
+		let text;
+		try {
+			response = await fetch(`${url}/api/v1${path}`, {
+				method,
+				headers,
+				body
+			});
+			text = await response.text();
+		} catch (error) {
+			throw new SlopperError(`Couldn't reach ${url}: ${networkReason(error)}`);
+		}
+		const parsed = parseJson(text);
+		if (response.ok && parsed !== void 0) return parsed;
+		if (isErrorBody(parsed)) throw new SlopperError(parsed.error, { details: parsed.details ?? null });
+		if (response.ok) throw new SlopperError(`${url} answered ${method} ${path} without JSON. Is it a Slopper site?`);
+		throw new SlopperError(`${method} ${path} failed with HTTP ${response.status}.`);
+	}
+	return {
+		url,
+		get: (path) => request("GET", path),
+		post: (path, body) => request("POST", path, JSON.stringify(body), "application/json"),
+		patch: (path, body) => request("PATCH", path, JSON.stringify(body), "application/json"),
+		delete: (path) => request("DELETE", path),
+		upload: (path, bytes, contentType) => request("POST", path, bytes, contentType)
+	};
+}
+//#endregion
+//#region src/skill.ts
+async function readSkill() {
+	return "---\nname: slopper\ndescription: Ship to slopper.day from the terminal with the `slopper` CLI (npm @slopperday/cli). Use when the user wants to launch a project as today's slop or schedule launches for later days, post an update or field test, set a daily shipping goal, log costs or revenue, check today's slop of the day race, or vote on slops.\n---\n\n# Slopper\n\n[slopper.day](https://slopper.day) is where people throw slop at the wall every day: they ship something small\ndaily (a site, a TestFlight or Play beta, a repo), set a goal like 30 slops in 30 days, and keep slopping until one is\nslopcessful. Every UTC day the slops launched that day race on votes; the leader at midnight UTC wins slop of the day\nand goes slopcessful. Slopcessful is earned, never declared: nobody can mark their own slop slopcessful.\n\n## Setup\n\nRun the CLI without installing it, with the runner the project already uses:\n\n```sh\nnpx -y @slopperday/cli <command>            # -y, or npx stops to ask \"Ok to proceed?\" and waits\npnpm dlx @slopperday/cli <command>\nbunx @slopperday/cli <command>\nyarn dlx -q @slopperday/cli <command>       # -q, or yarn's install log lands in the JSON\ndeno run -A npm:@slopperday/cli <command>\n```\n\nOr install it once (`npm i -g @slopperday/cli`) and run `slopper`. The examples below say `slopper`: put the runner's\ncommand in its place.\n\nIt needs the user's API token. They make one at https://slopper.day/settings/api. Ask them for it if you don't have one,\nthen either save it or pass it per call:\n\n```sh\nslopper login --token slp_...          # checks it, then saves it readable by the user only\nSLOPPER_TOKEN=slp_... slopper whoami   # saves nothing: use this when you shouldn't write files\n```\n\n`--url` (or `SLOPPER_URL`) points it at another site, like a local one.\n\nEvery command prints JSON on stdout. Errors go to stderr with exit code 1 (2 for a usage mistake), and validation\nerrors list each field that needs fixing. `slopper help <command>` shows every flag. A value that starts with a dash,\nlike a Markdown list, needs `=`: `--description=\"- one\"`.\n\n## Start with whoami\n\n`slopper whoami` returns the user's username, time zone, today's date in that zone, the open goal and its progress, the\nstreak, and the votes left today. Goal days end at midnight in the user's time zone; the race runs on UTC days.\n\n## Launch a slop\n\n1. Read the project: README, package.json or pubspec.yaml, and any deployed URL, App Store, TestFlight or Play beta\n   links.\n2. Take 1 to 3 screenshots of it running. The first is the cover.\n3. Pick a category from `slopper categories`.\n4. Launch it. Screenshot files are uploaded for you:\n\n```sh\nslopper launch \\\n  --name \"TiltMaze\" \\\n  --tagline \"A marble maze you play by tilting your phone\" \\\n  --category games \\\n  --description \"Built in a day. Tilt to roll, find the exit before the timer runs out.\" \\\n  --link website=https://tiltmaze.app \\\n  --link testflight=https://testflight.apple.com/join/abc123 \\\n  --screenshot ./shots/cover.png --screenshot ./shots/level-2.png \\\n  --made-with Flutter --made-with Claude \\\n  --note \"Day 12: a maze you tilt. Try to beat 40 seconds.\" \\\n  --autopost\n```\n\nLink kinds: `website`, `app_store`, `testflight`, `play_store`, `play_beta`, `source`, `other`. A bare URL is a\nwebsite. Store links must use their store's domain.\n\nThe result has the slop's `id`, `slug` and `url`, and the content check's verdict. Give the user the URL.\n\n`--autopost` posts the launch to the user's connected X, LinkedIn and Bluesky accounts. It's held (with the reason)\nunless the slop passed the automated content check and nobody has flagged it. Write the `--note` in the user's voice,\ntwo sentences at most.\n\nA new platform or a 2.0 is a new launch with its own shot at slop of the day:\n`slopper launch --relaunch-of <slop> --label \"iOS app\" ...`. A new feature is an update, not a launch.\n\n## Schedule launches\n\nWhen several things are ready at once, ask the user whether to put them all out now or line them up. Every launch\ncounts towards the goal on the day it goes out: three today are three slops today, and three lined up fill three days,\neach with its own shot at slop of the day.\n\n```sh\nslopper launch --at next ...                 # the next day with nothing out or scheduled, as its race starts\nslopper launch --at 2026-10-15T09:00 ...     # the user's time zone, unless it has an offset\nslopper scheduled                            # what's waiting, soonest first\nslopper release <scheduled>                  # put it out now instead\nslopper unschedule <scheduled>               # drop it\n```\n\nNobody else sees a scheduled launch until it goes out. `--autopost` posts it then.\n\n## Keep it alive\n\n```sh\nslopper post tiltmaze --kind feature --body \"Level editor: build a maze and share the link.\" --autopost\nslopper post tiltmaze --kind field --body \"Showed it to 5 people at the bus stop. 3 got hooked.\"\nslopper edit tiltmaze --tagline \"Now with a level editor\" --screenshot ./shots/editor.png\nslopper money tiltmaze cost 12.99 --category domain --note \"tiltmaze.app\"\n```\n\nUpdate kinds: `update` (fixes, news), `feature` (something new shipped), `field` (a real-world test: ask the user who\ntried it and what they said), `repromote` (bump it back up). `<slop>` is one of the user's slops, by id or slug (see\n`slopper slops`). `edit` changes only the flags passed; `--link` and `--screenshot` replace the whole list.\n\n## Goals\n\nAsk how many days first (7, 14, 30 or 100 are common), then how hard: one slop every five days is safe, every other day\nis getting there, one a day is hardcore, two a day is impossible.\n\n```sh\nslopper goal --days 30 --target 30\n```\n\nOnly one goal can be open at a time.\n\n## The race and votes\n\n`slopper today` ranks today's slops by votes, with each slop's `id`, whether it's the user's (`yours`), how they voted\n(`yourVote`), and `votesLeft`.\n\n```sh\nslopper vote <slop id> up      # or down (private: lowers the ranking, nobody sees it), or clear\n```\n\nEveryone gets 5 votes per UTC day. Switching today's vote is free and clearing it gives it back. Nobody can vote on\ntheir own slops. Votes decide slop of the day, so only vote the way the user asks; never spend their votes on your own\njudgement.\n\n## Don't\n\n- Don't launch ideas, waitlists or anything that isn't live: a slop is something people can try today.\n- Don't launch features as new slops; post them as updates.\n- Don't put the token in files you commit. Use `slopper login` or `SLOPPER_TOKEN`.\n";
+}
+//#endregion
+//#region src/commands.ts
+/**
+* The site's LIMITS.mediaBytes (app/lib/model.ts; the tests check they
+* agree). Bigger screenshots are refused, so they aren't sent.
+*/
+const MEDIA_BYTES = 4194304;
+function text$1(values, key) {
+	const value = values[key];
+	return typeof value === "string" ? value : void 0;
+}
+function list(values, key) {
+	const value = values[key];
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
+}
+function wholeNumber(values, key) {
+	const value = text$1(values, key);
+	if (value === void 0) return void 0;
+	if (!/^\d+$/.test(value)) throw usageError(`--${key} must be a whole number, not “${value}”.`);
+	return Number(value);
+}
+function required(value, flag) {
+	if (value === void 0) throw usageError(`Missing ${flag}.`);
+	return value;
+}
+function positional(context, index, name) {
+	const value = context.positionals[index];
+	if (!value) throw usageError(`Missing <${name}>.`);
+	return value;
+}
+/** A slop reference as a URL path segment. */
+function slopPath(ref) {
+	return `/slops/${encodeURIComponent(ref)}`;
+}
+/** `website=https://…`, or a bare URL for a website. */
+function parseLink(value) {
+	const match = /^([a-z_]+)=(.+)$/.exec(value);
+	if (match) return {
+		kind: match[1],
+		url: match[2]
+	};
+	if (/^https?:\/\//.test(value)) return {
+		kind: "website",
+		url: value
+	};
+	throw usageError(`--link takes kind=url (website=https://…, testflight=https://…) or a bare URL, not “${value}”.`);
+}
+const IMAGE_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".gif": "image/gif"
+};
+async function uploadImage(api, file) {
+	const contentType = IMAGE_TYPES[extname(file).toLowerCase()];
+	if (!contentType) throw usageError(`${file} isn't a PNG, JPEG, WebP or GIF.`);
+	let bytes;
+	try {
+		bytes = new Uint8Array(await readFile(resolve(file)));
+	} catch (error) {
+		if (!isSystemError(error)) throw error;
+		throw usageError(`Couldn't read ${file} (${error.code}).`);
+	}
+	if (bytes.byteLength > 4194304) throw usageError(`${file} is bigger than ${MEDIA_BYTES / 1024 / 1024} MB, the most a screenshot can be.`);
+	const uploaded = await api.upload("/media", bytes, contentType);
+	if (typeof uploaded !== "object" || uploaded === null || typeof uploaded.id !== "string") throw new SlopperError(`Uploading ${file} returned no media id.`);
+	return uploaded;
+}
+/**
+* Screenshots are image files, uploaded first, or media ids from
+* `slopper upload`. Anything with an image extension or a path in it is a file.
+*/
+async function screenshotIds(api, values) {
+	const ids = [];
+	for (const value of values) {
+		const isFile = value.includes("/") || value.includes("\\") || extname(value).toLowerCase() in IMAGE_TYPES;
+		ids.push(isFile ? (await uploadImage(api, value)).id : value);
+	}
+	return ids;
+}
+/** The fields `launch` and `edit` share, only those that were passed. */
+async function slopFields(context) {
+	const { values, api } = context;
+	const links = list(values, "link");
+	const screenshots = list(values, "screenshot");
+	const madeWith = list(values, "made-with");
+	const fields = {
+		name: text$1(values, "name"),
+		tagline: text$1(values, "tagline"),
+		description: text$1(values, "description"),
+		category: text$1(values, "category"),
+		links: links?.map(parseLink),
+		screenshots: screenshots ? await screenshotIds(api, screenshots) : void 0,
+		madeWith
+	};
+	return Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== void 0));
+}
+const SLOP_OPTIONS = {
+	name: { type: "string" },
+	tagline: { type: "string" },
+	description: { type: "string" },
+	category: { type: "string" },
+	link: {
+		type: "string",
+		multiple: true
+	},
+	screenshot: {
+		type: "string",
+		multiple: true
+	},
+	"made-with": {
+		type: "string",
+		multiple: true
+	}
+};
+const SLOP_FLAGS = {
+	"--name <name>": "What it's called.",
+	"--tagline <line>": "One line: what does it do?",
+	"--description <markdown>": "The longer story, in Markdown.",
+	"--category <id>": "One of `slopper categories`.",
+	"--link <kind=url>": "Where to try it; repeat for more. Kinds: website, app_store, testflight, play_store, play_beta, source, other. A bare URL is a website.",
+	"--screenshot <file|id>": "An image file (uploaded for you) or an id from `slopper upload`; repeat for more. The first is the cover.",
+	"--made-with <tool>": "What built it; repeat for more."
+};
+const AUTOPOST_FLAG = { "--autopost": "Also post it to the connected X, LinkedIn and Bluesky accounts. Held unless it passed the content check." };
+const COMMANDS = [
+	{
+		name: "login",
+		summary: "Check an API token (from /settings/api), then save it and its site for the other commands.",
+		flags: {
+			"--token <token>": "The token. Without it, it's read from stdin: `echo $TOKEN | slopper login`.",
+			"--url <url>": "A different site to save, like a local one."
+		},
+		options: {},
+		async run({ values, io, url, configFile, connect }) {
+			const token = (text$1(values, "token") ?? await io.readStdin() ?? "").trim();
+			if (!token) throw usageError(`Pass --token, or pipe one in. Make a token at ${url}/settings/api.`);
+			const me = await connect(token).get("/me");
+			const username = typeof me === "object" && me !== null ? me.username : void 0;
+			if (typeof username !== "string") throw new SlopperError(`${url} didn't say whose token this is.`);
+			await writeConfig(configFile, {
+				token,
+				url
+			});
+			return {
+				loggedIn: username,
+				url,
+				config: configFile
+			};
+		}
+	},
+	{
+		name: "logout",
+		summary: "Forget the saved token. Revoke it at /settings/api to cut it off everywhere.",
+		local: true,
+		async run({ configFile }) {
+			await removeConfig(configFile);
+			return {
+				loggedOut: true,
+				config: configFile
+			};
+		}
+	},
+	{
+		name: "whoami",
+		summary: "You: profile, time zone, today's date, the open goal, streak and votes left today. Start here.",
+		run: ({ api }) => api.get("/me")
+	},
+	{
+		name: "today",
+		summary: "Today's race (UTC day): slops ranked by votes, how you voted, and your votes left.",
+		run: ({ api }) => api.get("/today")
+	},
+	{
+		name: "categories",
+		summary: "Valid categories, link kinds, currencies and money categories.",
+		run: ({ api }) => api.get("/categories")
+	},
+	{
+		name: "goal",
+		summary: "Start a goal, like 30 slops in 30 days. Only one can be open.",
+		flags: {
+			"--target <n>": "Required: how many slops to ship.",
+			"--days <n>": "Required: how many days. They end at midnight in your time zone.",
+			"--start <YYYY-MM-DD>": "Today or later. Defaults to today.",
+			"--title <title>": "Defaults to “N slops in M days”."
+		},
+		options: {
+			target: { type: "string" },
+			days: { type: "string" },
+			start: { type: "string" },
+			title: { type: "string" }
+		},
+		run({ api, values }) {
+			return api.post("/goal", {
+				target: required(wholeNumber(values, "target"), "--target <n>"),
+				days: required(wholeNumber(values, "days"), "--days <n>"),
+				startDate: text$1(values, "start"),
+				title: text$1(values, "title")
+			});
+		}
+	},
+	{
+		name: "upload",
+		args: "<image>",
+		summary: "Upload a screenshot (PNG, JPEG, WebP or GIF, up to 4 MB). Prints its id and the content check's verdict.",
+		run: (context) => uploadImage(context.api, positional(context, 0, "image"))
+	},
+	{
+		name: "slops",
+		summary: "Your slops, newest first, with votes, updates, pledges and badges.",
+		run: ({ api }) => api.get("/slops")
+	},
+	{
+		name: "launch",
+		summary: "Throw a new slop at the wall. It counts towards today's goal and enters today's race, or with --at waits until then.",
+		flags: {
+			...SLOP_FLAGS,
+			"--note <text>": "The first update, also the auto-post text. Defaults to the tagline.",
+			"--relaunch-of <slop>": "Launch an existing product again (a new platform, a 2.0): its id or slug.",
+			"--label <label>": "With --relaunch-of: what's launching, like “iOS app” or “2.0”.",
+			"--at <when>": "Schedule it: “next” (the next day with nothing out or scheduled, as its race starts) or a date-time like 2026-10-15T09:00 (your time zone unless it has an offset).",
+			...AUTOPOST_FLAG
+		},
+		options: {
+			...SLOP_OPTIONS,
+			note: { type: "string" },
+			"relaunch-of": { type: "string" },
+			label: { type: "string" },
+			at: { type: "string" },
+			autopost: { type: "boolean" }
+		},
+		async run(context) {
+			const { api, values } = context;
+			return api.post("/slops", {
+				...await slopFields(context),
+				launchNote: text$1(values, "note"),
+				relaunchOf: text$1(values, "relaunch-of"),
+				launchLabel: text$1(values, "label"),
+				releaseAt: text$1(values, "at"),
+				autopost: values.autopost === true
+			});
+		}
+	},
+	{
+		name: "scheduled",
+		summary: "Your scheduled launches, soonest first. Nobody else sees them until they go out.",
+		run: ({ api }) => api.get("/scheduled")
+	},
+	{
+		name: "release",
+		args: "<scheduled>",
+		summary: "Put a scheduled launch out now. It counts towards today's goal and enters today's race.",
+		run: (context) => context.api.post(`/scheduled/${encodeURIComponent(positional(context, 0, "scheduled"))}/release`, {})
+	},
+	{
+		name: "unschedule",
+		args: "<scheduled>",
+		summary: "Drop a scheduled launch before it goes out.",
+		run: (context) => context.api.delete(`/scheduled/${encodeURIComponent(positional(context, 0, "scheduled"))}`)
+	},
+	{
+		name: "edit",
+		args: "<slop>",
+		summary: "Change one of your slops. Only the flags you pass change; --link and --screenshot replace the lists.",
+		flags: SLOP_FLAGS,
+		options: SLOP_OPTIONS,
+		async run(context) {
+			const slop = positional(context, 0, "slop");
+			const fields = await slopFields(context);
+			if (Object.keys(fields).length === 0) throw usageError("Nothing to change: pass a flag, like --tagline.");
+			return context.api.patch(slopPath(slop), fields);
+		}
+	},
+	{
+		name: "post",
+		args: "<slop>",
+		summary: "Post an update on one of your slops.",
+		flags: {
+			"--kind <kind>": "update (fixes, news; the default), feature (something new shipped), field (a real-world test: who tried it, what they said) or repromote.",
+			"--body <markdown>": "Required: what happened.",
+			...AUTOPOST_FLAG
+		},
+		options: {
+			kind: { type: "string" },
+			body: { type: "string" },
+			autopost: { type: "boolean" }
+		},
+		run(context) {
+			const { api, values } = context;
+			const slop = positional(context, 0, "slop");
+			return api.post(`${slopPath(slop)}/updates`, {
+				kind: text$1(values, "kind") ?? "update",
+				body: required(text$1(values, "body"), "--body <markdown>"),
+				autopost: values.autopost === true
+			});
+		}
+	},
+	{
+		name: "money",
+		args: "<slop> <cost|revenue> <amount>",
+		summary: "Log a cost (domain, hosting, AI) or revenue for a product, in major units like 12.99.",
+		flags: {
+			"--currency <code>": "Defaults to USD.",
+			"--category <id>": "See `slopper categories`. Defaults to other.",
+			"--note <text>": "What it was.",
+			"--date <YYYY-MM-DD>": "Defaults to today."
+		},
+		options: {
+			currency: { type: "string" },
+			category: { type: "string" },
+			note: { type: "string" },
+			date: { type: "string" }
+		},
+		run(context) {
+			const { api, values } = context;
+			const slop = positional(context, 0, "slop");
+			const kind = positional(context, 1, "cost|revenue");
+			if (kind !== "cost" && kind !== "revenue") throw usageError(`Money is a cost or revenue, not “${kind}”.`);
+			const amount = positional(context, 2, "amount");
+			if (!/^\d+(\.\d+)?$/.test(amount) || Number(amount) <= 0) throw usageError(`<amount> must be a number above zero, like 12.99, not “${amount}”.`);
+			return api.post(`${slopPath(slop)}/money`, {
+				kind,
+				amount: Number(amount),
+				currency: text$1(values, "currency"),
+				category: text$1(values, "category"),
+				note: text$1(values, "note"),
+				date: text$1(values, "date")
+			});
+		}
+	},
+	{
+		name: "vote",
+		args: "<slop> <up|down|clear>",
+		summary: "Vote on a slop by its id (from `slopper today`). You get 5 votes a UTC day; downvotes are private, and clearing one gives it back.",
+		run(context) {
+			const slop = positional(context, 0, "slop");
+			const vote = positional(context, 1, "up|down|clear");
+			if (vote !== "up" && vote !== "down" && vote !== "clear") throw usageError(`A vote is up, down or clear, not “${vote}”.`);
+			return context.api.post(`${slopPath(slop)}/vote`, { vote });
+		}
+	},
+	{
+		name: "skill",
+		args: "[install]",
+		summary: "Print the agent skill for this CLI, or install it for your agents.",
+		flags: { "--dir <dir>": "With install: the skills directory. Defaults to ~/.agents/skills; Claude Code reads ~/.claude/skills." },
+		options: { dir: { type: "string" } },
+		local: true,
+		async run(context) {
+			const skill = await readSkill();
+			const action = context.positionals[0];
+			if (action === void 0) return skill;
+			if (action !== "install") throw usageError(`Unknown skill action “${action}”. Try \`slopper skill install\`.`);
+			const directory = join(resolve(text$1(context.values, "dir") ?? join(context.io.home, ".agents", "skills")), "slopper");
+			await mkdir(directory, { recursive: true });
+			const path = join(directory, "SKILL.md");
+			await writeFile(path, skill);
+			return { installed: path };
+		}
+	}
+];
+//#endregion
+//#region src/main.ts
+const GLOBAL_OPTIONS = {
+	token: { type: "string" },
+	url: { type: "string" },
+	help: {
+		type: "boolean",
+		short: "h"
+	}
+};
+const GLOBAL_FLAGS = {
+	"--token <token>": "API token. Defaults to SLOPPER_TOKEN, then the one `slopper login` saved.",
+	"--url <url>": `Site to talk to. Defaults to SLOPPER_URL, then the saved one, then ${DEFAULT_URL}.`,
+	"-h, --help": "Help for a command."
+};
+function flagLines(flags) {
+	const width = Math.max(...Object.keys(flags).map((flag) => flag.length));
+	return Object.entries(flags).map(([flag, description]) => `  ${flag.padEnd(width)}  ${description}`);
+}
+function usage(command) {
+	return `slopper ${command.name}${command.args ? ` ${command.args}` : ""}${command.flags ? " [flags]" : ""}`;
+}
+function overview() {
+	const width = Math.max(...COMMANDS.map((command) => command.name.length));
+	return [
+		`slopper ${version}: throw slop at the wall, from your terminal. Built for agents.`,
+		"",
+		"Usage: slopper <command> [flags]",
+		"",
+		"Commands:",
+		...COMMANDS.map((command) => `  ${command.name.padEnd(width)}  ${command.summary}`),
+		`  ${"help".padEnd(width)}  Help for one command: slopper help launch`,
+		"",
+		"Global flags:",
+		...flagLines(GLOBAL_FLAGS),
+		"",
+		"Results print as JSON. Errors go to stderr; the exit code is 1, or 2 for a usage mistake.",
+		`Start with \`slopper login\` (tokens live at ${DEFAULT_URL}/settings/api), then \`slopper whoami\`.`,
+		"Agents that shouldn't save a token can set SLOPPER_TOKEN instead."
+	].join("\n");
+}
+function commandHelp(command) {
+	return [
+		`Usage: ${usage(command)}`,
+		"",
+		command.summary,
+		...command.flags ? [
+			"",
+			"Flags:",
+			...flagLines(command.flags)
+		] : [],
+		"",
+		"Global flags:",
+		...flagLines(GLOBAL_FLAGS)
+	].join("\n");
+}
+function findCommand(name) {
+	if (name.startsWith("-")) throw usageError(`Put the command first, then its flags: slopper <command> ${name} …`);
+	const command = COMMANDS.find((candidate) => candidate.name === name);
+	if (!command) throw usageError(`Unknown command “${name}”.`);
+	return command;
+}
+/** Where to look after a usage mistake: the command's own help, when there is a command. */
+function helpHint(name) {
+	return COMMANDS.some((command) => command.name === name) ? `Run \`slopper help ${name}\`.` : "Run `slopper help` for the commands.";
+}
+function print(io, result) {
+	if (result === void 0) return;
+	io.stdout(typeof result === "string" ? result : `${JSON.stringify(result, null, 2)}\n`);
+}
+/** Settles which site and token to use: flags, then the environment, then what `slopper login` saved. */
+async function siteContext(local) {
+	const { values, io, configFile } = local;
+	const saved = await readConfig(configFile);
+	const flag = (key) => typeof values[key] === "string" ? values[key] : void 0;
+	const url = resolveUrl(flag("url") ?? envValue(io.env, "SLOPPER_URL") ?? saved.url ?? "https://slopper.day");
+	const connect = (token) => createApi({
+		url,
+		token,
+		fetch: io.fetch,
+		userAgent: `slopper-cli/${version}`
+	});
+	const token = flag("token") ?? envValue(io.env, "SLOPPER_TOKEN") ?? saved.token;
+	return {
+		...local,
+		url,
+		api: connect(token),
+		connect
+	};
+}
+async function run(argv, io) {
+	const [name, ...rest] = argv;
+	if (name === void 0 || name === "help" || name === "--help" || name === "-h") {
+		print(io, `${rest[0] ? commandHelp(findCommand(rest[0])) : overview()}\n`);
+		return;
+	}
+	if (name === "--version" || name === "-v") {
+		print(io, `${version}\n`);
+		return;
+	}
+	const command = findCommand(name);
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args: rest,
+			options: {
+				...GLOBAL_OPTIONS,
+				...command.options
+			},
+			allowPositionals: true,
+			strict: true
+		});
+	} catch (error) {
+		throw usageError(error instanceof Error ? error.message : String(error));
+	}
+	const { values, positionals } = parsed;
+	if (values.help === true) {
+		print(io, `${commandHelp(command)}\n`);
+		return;
+	}
+	const extra = positionals[command.args?.split(" ").length ?? 0];
+	if (extra !== void 0) throw usageError(`Unexpected “${extra}”. Usage: ${usage(command)}`);
+	const local = {
+		values,
+		positionals,
+		io,
+		configFile: configPath(io.env, io.home)
+	};
+	print(io, command.local ? await command.run(local) : await command.run(await siteContext(local)));
+}
+/** Runs one command line and returns the exit code: 0, 1 for a failure, 2 for a usage mistake. */
+async function main(argv, io) {
+	try {
+		await run(argv, io);
+		return 0;
+	} catch (error) {
+		if (isSystemError(error)) {
+			io.stderr(`slopper: ${error.message}\n`);
+			return 1;
+		}
+		if (!(error instanceof SlopperError)) throw error;
+		const details = error.details ? Object.entries(error.details).map(([field, problem]) => `\n  ${field}: ${problem}`) : [];
+		const hint = error.exitCode === 2 ? `\n${helpHint(argv[0])}` : "";
+		io.stderr(`slopper: ${error.message}${details.join("")}${hint}\n`);
+		return error.exitCode;
+	}
+}
+//#endregion
+//#region src/slopper.ts
+process.exitCode = await main(process.argv.slice(2), {
+	env: process.env,
+	home: homedir(),
+	fetch: globalThis.fetch,
+	readStdin: async () => process.stdin.isTTY ? null : await text(process.stdin),
+	stdout: (output) => process.stdout.write(output),
+	stderr: (output) => process.stderr.write(output)
+});
+//#endregion
+export {};

package/package.json

@@ -1 +1,32 @@
-{"description":"Placeholder package for @slopperday/cli","name":"@slopperday/cli","version":"0.0.0"}
+{
+  "name": "@slopperday/cli",
+  "version": "0.1.0",
+  "description": "Throw slop at the wall from your terminal: launch, update and vote on slopper.day. Built for agents.",
+  "keywords": [
+    "agent",
+    "cli",
+    "slopper"
+  ],
+  "homepage": "https://slopper.day",
+  "license": "UNLICENSED",
+  "bin": {
+    "slopper": "./dist/slopper.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "prepack": "vp pack"
+  },
+  "devDependencies": {
+    "vite-plus": "1.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}

package/CHANGELOG.md

@@ -1,3 +0,0 @@
-## 0.0.0
-
-- Placeholder release.

package/LICENSE

@@ -1 +0,0 @@
-Placeholder package published by monochange. See the source repository for license terms.