@socialized.dev/cli 0.1.0

package/README.md

@@ -0,0 +1,66 @@
+# @socialized.dev/cli
+
+`socialized.dev` publishes videos through the socialized.dev API from a terminal or CI job.
+
+## Install
+
+```sh
+npm install -g @socialized.dev/cli
+```
+
+Inside the monorepo:
+
+```sh
+pnpm -F @socialized.dev/cli cli -- --help
+```
+
+## Auth
+
+Create an API key in the dashboard, then store it locally:
+
+```sh
+socialized.dev login --key sk_...
+socialized.dev whoami
+```
+
+Headless runs can use environment variables instead of stored config:
+
+```sh
+SOCIALIZED_DEV_API_KEY=sk_... socialized.dev brands list
+```
+
+## Publications
+
+```sh
+socialized.dev publications create \
+  --video ./clip.mp4 \
+  --to youtube,instagram \
+  --title "Launch clip" \
+  --description "Posted once, everywhere." \
+  --watch
+```
+
+`publications create` uploads local video and cover files internally, then creates the
+publication. You can also pass an existing `asset_...` id to `--video` or `--cover`.
+
+## Brands
+
+If your account has multiple brands, you can switch between them:
+
+```sh
+# List all brands
+socialized.dev brands list
+
+# Select a brand for future publication commands
+socialized.dev brands use brand_...
+```
+
+## Environment Variables
+
+- `SOCIALIZED_DEV_API_KEY`: API Key to authenticate requests.
+- `SOCIALIZED_DEV_BRAND_ID`: Explicitly select a brand ID for commands.
+- `SOCIALIZED_DEV_API_URL`: Use a custom API host (default is `https://api.socialized.dev/api/v1`).
+
+## CI/CD and npm Trusted Publishing
+
+This package is securely published to npm registry using **npm OIDC Trusted Publishing** via GitHub Actions. Trusted publishing allows publishing directly from a verified GitHub Actions workflow without managing or leaking npm automation tokens.

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/bin.js

@@ -0,0 +1,531 @@
+#!/usr/bin/env node
+import { buildApplication, buildCommand, buildRouteMap, run, text_en } from "@stricli/core";
+import { createReadStream, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, extname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { Readable } from "node:stream";
+//#region package.json
+var version = "0.1.0";
+//#endregion
+//#region src/api.ts
+var ApiError = class extends Error {
+	status;
+	body;
+	constructor(status, body, method, path) {
+		super(`socialized.dev API ${method} ${path} failed (${status}): ${formatErrorBody(body)}`);
+		this.status = status;
+		this.body = body;
+	}
+};
+const formatErrorBody = (body) => {
+	try {
+		const parsed = JSON.parse(body);
+		if (parsed !== null && typeof parsed === "object") {
+			const record = parsed;
+			const code = typeof record.error === "string" ? record.error : void 0;
+			const message = typeof record.message === "string" ? record.message : void 0;
+			if (code && message) return `${code}: ${message}`;
+			if (message) return message;
+			if (code) return code;
+		}
+	} catch {}
+	return body || "(empty response)";
+};
+const createApiClient = (config) => {
+	const request = async (path, init = {}) => {
+		const res = await fetch(`${config.apiUrl}${path}`, {
+			...init,
+			headers: {
+				...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
+				...init.body ? { "content-type": "application/json" } : {},
+				...init.headers
+			}
+		});
+		if (!res.ok) throw new ApiError(res.status, await res.text(), init.method ?? "GET", path);
+		return res;
+	};
+	const json = (path, init) => request(path, init).then((res) => res.json());
+	return {
+		listBrands: () => json("/brands"),
+		startAssetUpload: (body) => json("/assets", {
+			method: "POST",
+			body: JSON.stringify(body)
+		}),
+		completeAssetUpload: (uploadId, parts) => json(`/assets/${encodeURIComponent(uploadId)}/complete`, {
+			method: "POST",
+			body: JSON.stringify({ parts })
+		}),
+		createPublication: (brandId, body, idempotencyKey) => json(`/brands/${encodeURIComponent(brandId)}/publications`, {
+			method: "POST",
+			headers: { "Idempotency-Key": idempotencyKey },
+			body: JSON.stringify(body)
+		}),
+		getPublication: (brandId, publicationId) => json(`/brands/${encodeURIComponent(brandId)}/publications/${encodeURIComponent(publicationId)}`)
+	};
+};
+//#endregion
+//#region src/config.ts
+const getConfigDir = () => join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "socialized.dev");
+const getConfigFile = () => join(getConfigDir(), "config.json");
+const DEFAULT_API_URL = "https://api.socialized.dev/api/v1";
+const readStored = () => {
+	try {
+		return JSON.parse(readFileSync(getConfigFile(), "utf8"));
+	} catch {
+		return {};
+	}
+};
+const writeStored = (config) => {
+	mkdirSync(getConfigDir(), { recursive: true });
+	writeFileSync(getConfigFile(), `${JSON.stringify(config, null, 2)}\n`, { mode: 384 });
+};
+const saveConfig = (patch) => writeStored({
+	...readStored(),
+	...patch
+});
+const clearConfig = () => writeStored({});
+const resolveConfig = (overrides = {}) => {
+	const stored = readStored();
+	return {
+		apiKey: overrides.apiKey ?? process.env.SOCIALIZED_DEV_API_KEY ?? stored.apiKey ?? null,
+		apiUrl: overrides.apiUrl ?? process.env.SOCIALIZED_DEV_API_URL ?? stored.apiUrl ?? DEFAULT_API_URL,
+		brandId: overrides.brandId ?? process.env.SOCIALIZED_DEV_BRAND_ID ?? stored.brandId ?? null
+	};
+};
+//#endregion
+//#region src/util.ts
+var UsageError = class extends Error {};
+const readStdin = async () => {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8");
+};
+//#endregion
+//#region src/context.ts
+const buildContext = () => {
+	const config = resolveConfig();
+	return {
+		process,
+		config,
+		api: createApiClient(config)
+	};
+};
+const requireAuth = (ctx) => {
+	if (!ctx.config.apiKey) throw new UsageError("Not authenticated. Run `socialized.dev login --key sk_...` first.");
+};
+//#endregion
+//#region src/output.ts
+const out = (ctx, message) => {
+	ctx.process.stdout.write(`${message}\n`);
+};
+const err = (ctx, message) => {
+	ctx.process.stderr.write(`${message}\n`);
+};
+const jsonOut = (ctx, value) => {
+	out(ctx, JSON.stringify(value, null, 2));
+};
+//#endregion
+//#region src/commands/auth.ts
+const loginCommand = buildCommand({
+	docs: { brief: "Store an API key for socialized.dev" },
+	parameters: { flags: { key: {
+		kind: "parsed",
+		parse: String,
+		optional: true,
+		brief: "API key; or pipe it: `echo sk_... | socialized.dev login`"
+	} } },
+	async func(flags) {
+		const piped = flags.key === void 0 && !process.stdin.isTTY ? (await readStdin()).trim() : void 0;
+		const key = (flags.key ?? piped)?.trim();
+		if (!key) throw new UsageError("Pass an API key with `--key sk_...` or pipe one to stdin.");
+		const { brands } = await createApiClient(resolveConfig({ apiKey: key })).listBrands();
+		saveConfig({
+			apiKey: key,
+			brandId: brands.length === 1 ? brands[0]?.id : void 0
+		});
+		out(this, `Authenticated. ${brands.length} brand${brands.length === 1 ? "" : "s"} available.`);
+	}
+});
+const logoutCommand = buildCommand({
+	docs: { brief: "Clear stored socialized.dev config" },
+	parameters: {},
+	func() {
+		clearConfig();
+		out(this, "Logged out.");
+	}
+});
+const whoamiCommand = buildCommand({
+	docs: { brief: "Show API URL, selected brand, and connected platforms" },
+	parameters: { flags: { json: {
+		kind: "boolean",
+		brief: "Print JSON output"
+	} } },
+	async func(flags) {
+		requireAuth(this);
+		const { brands } = await this.api.listBrands();
+		const selected = brands.find((brand) => brand.id === this.config.brandId) ?? brands[0] ?? null;
+		if (flags.json) return jsonOut(this, {
+			apiUrl: this.config.apiUrl,
+			selectedBrand: selected,
+			brands
+		});
+		out(this, `API: ${this.config.apiUrl}`);
+		out(this, `Brand: ${selected ? `${selected.name} (${selected.id})` : "(none)"}`);
+		if (selected) out(this, `Connected: ${selected.connectedPlatforms.join(", ") || "(none)"}`);
+	}
+});
+//#endregion
+//#region src/commands/brands.ts
+const resolveBrand = (brands, selector) => {
+	const matches = brands.filter((brand) => brand.id === selector || brand.name === selector);
+	if (matches.length === 1) {
+		const brand = matches[0];
+		if (brand === void 0) throw new UsageError(`Brand not found: ${selector}`);
+		return brand;
+	}
+	if (matches.length > 1) throw new UsageError(`Brand name is ambiguous: ${selector}`);
+	throw new UsageError(`Brand not found: ${selector}`);
+};
+const brandsRoutes = buildRouteMap({
+	routes: {
+		list: buildCommand({
+			docs: { brief: "List brands available to the API key" },
+			parameters: { flags: { json: {
+				kind: "boolean",
+				brief: "Print JSON output"
+			} } },
+			async func(flags) {
+				requireAuth(this);
+				const { brands } = await this.api.listBrands();
+				if (flags.json) return jsonOut(this, { brands });
+				if (brands.length === 0) {
+					out(this, "No brands found. Go to the web dashboard to create one.");
+					return;
+				}
+				for (const brand of brands) out(this, `${brand.id}\t${brand.name}\t${brand.connectedPlatforms.join(",") || "-"}`);
+			}
+		}),
+		use: buildCommand({
+			docs: { brief: "Persist the default brand for publication commands" },
+			parameters: { positional: {
+				kind: "tuple",
+				parameters: [{
+					brief: "Brand id or exact brand name",
+					parse: String
+				}]
+			} },
+			async func(_flags, selector) {
+				requireAuth(this);
+				const { brands } = await this.api.listBrands();
+				if (brands.length === 0) throw new UsageError("No brands found. Go to the web dashboard to create one.");
+				const brand = resolveBrand(brands, selector);
+				saveConfig({ brandId: brand.id });
+				out(this, `Using ${brand.name} (${brand.id}).`);
+			}
+		})
+	},
+	docs: { brief: "Manage default brand selection" }
+});
+//#endregion
+//#region src/commands/publications.ts
+const parseTargets = (value) => {
+	const targets = value.split(",").map((target) => target.trim()).filter(Boolean);
+	if (targets.length === 0) throw new UsageError("Pass at least one platform with `--to`.");
+	const seen = /* @__PURE__ */ new Set();
+	for (const target of targets) {
+		if (target !== "youtube" && target !== "instagram" && target !== "facebook" && target !== "tiktok") throw new UsageError(`Unsupported platform: ${target}`);
+		if (seen.has(target)) throw new UsageError(`Duplicate platform not allowed: ${target}`);
+		seen.add(target);
+	}
+	return targets;
+};
+const resolveBrandId = async (ctx, flagBrand) => {
+	let brandId = flagBrand ?? ctx.config.brandId;
+	if (!brandId) {
+		const { brands } = await ctx.api.listBrands();
+		if (brands.length === 1) {
+			const firstBrand = brands[0];
+			if (firstBrand) brandId = firstBrand.id;
+			else throw new UsageError("No brands found. Go to the web dashboard to create one.");
+		} else if (brands.length === 0) throw new UsageError("No brands found. Go to the web dashboard to create one.");
+		else throw new UsageError("Multiple brands available. Select a default brand with `brands use <brandId>`, or pass `--brand <brandId>`.");
+	}
+	return brandId;
+};
+const uploadAsset = async (ctx, filePath, kind, jsonMode) => {
+	const ext = extname(filePath).toLowerCase();
+	let contentType = "application/octet-stream";
+	if (kind === "video") if (ext === ".mp4") contentType = "video/mp4";
+	else if (ext === ".mov") contentType = "video/quicktime";
+	else if (ext === ".m4v") contentType = "video/mp4";
+	else if (ext === ".webm") contentType = "video/webm";
+	else contentType = "video/mp4";
+	else if (ext === ".jpg" || ext === ".jpeg") contentType = "image/jpeg";
+	else if (ext === ".png") contentType = "image/png";
+	else if (ext === ".webp") contentType = "image/webp";
+	else contentType = "application/octet-stream";
+	const stat = statSync(filePath);
+	if (!stat.isFile()) throw new UsageError(`Not a file: ${filePath}`);
+	if (stat.size <= 0) throw new UsageError(`File is empty: ${filePath}`);
+	const filename = basename(filePath);
+	const sizeBytes = stat.size;
+	const log = (msg) => {
+		if (jsonMode) err(ctx, msg);
+		else out(ctx, msg);
+	};
+	log(`Uploading ${kind} file: ${filename} (${sizeBytes} bytes, MIME: ${contentType})...`);
+	const plan = await ctx.api.startAssetUpload({
+		filename,
+		contentType,
+		sizeBytes
+	});
+	const completedParts = [];
+	for (const part of plan.parts) {
+		const partNumber = part.partNumber;
+		const start = (partNumber - 1) * plan.partSize;
+		const end = Math.min(sizeBytes, partNumber * plan.partSize) - 1;
+		log(`  Uploading part ${partNumber}/${plan.parts.length} (bytes ${start}-${end})...`);
+		const stream = createReadStream(filePath, {
+			start,
+			end
+		});
+		const uploadInit = {
+			method: "PUT",
+			body: Readable.toWeb(stream),
+			duplex: "half",
+			headers: { "Content-Length": String(end - start + 1) }
+		};
+		const response = await fetch(part.url, uploadInit);
+		if (!response.ok) throw new Error(`Failed to upload part ${partNumber}: HTTP ${response.status}`);
+		const etag = response.headers.get("etag");
+		if (!etag) throw new Error(`Upload of part ${partNumber} failed: missing ETag header`);
+		completedParts.push({
+			partNumber,
+			etag
+		});
+	}
+	log(`Completing multipart upload...`);
+	const completeResult = await ctx.api.completeAssetUpload(plan.uploadId, completedParts);
+	log(`Asset uploaded successfully: ${completeResult.assetId}`);
+	return completeResult.assetId;
+};
+const pollPublication = async (ctx, brandId, pubId, jsonMode) => {
+	const intervalMs = 2e3;
+	while (true) {
+		const result = await ctx.api.getPublication(brandId, pubId);
+		const pub = result.publication;
+		if (jsonMode) {
+			err(ctx, `Status: ${pub.status}`);
+			for (const target of pub.targets) err(ctx, `  - ${target.platform}: ${target.status}${target.error ? ` (${target.error})` : ""}`);
+		} else {
+			out(ctx, `Status: ${pub.status}`);
+			for (const target of pub.targets) out(ctx, `  - ${target.platform}: ${target.status}${target.error ? ` (${target.error})` : ""}`);
+		}
+		if (pub.status === "done" || pub.status === "failed" || pub.status === "partial") return result;
+		await new Promise((resolve) => setTimeout(resolve, intervalMs));
+	}
+};
+const printDispatchResult = (ctx, res) => {
+	out(ctx, `Publication queued. ID: ${res.publicationId}`);
+	out(ctx, `Status: ${res.status}`);
+	out(ctx, "Targets:");
+	for (const target of res.targets) out(ctx, `  - ${target.platform}: ${target.status}`);
+};
+const printPublicationSummary = (ctx, pub) => {
+	out(ctx, `Publication ID: ${pub.id}`);
+	out(ctx, `Status: ${pub.status}`);
+	out(ctx, "Targets:");
+	for (const target of pub.targets) out(ctx, `  - ${target.platform}: ${target.status}${target.externalUrl ? ` (${target.externalUrl})` : ""}${target.error ? ` - Error: ${target.error}` : ""}`);
+};
+const publicationsRoutes = buildRouteMap({
+	routes: {
+		create: buildCommand({
+			docs: { brief: "Create a publication, uploading local video/cover files as needed" },
+			parameters: { flags: {
+				video: {
+					kind: "parsed",
+					parse: String,
+					brief: "Video file path or asset id"
+				},
+				cover: {
+					kind: "parsed",
+					parse: String,
+					optional: true,
+					brief: "Cover image path or asset id"
+				},
+				to: {
+					kind: "parsed",
+					parse: parseTargets,
+					brief: "Comma-separated platforms"
+				},
+				title: {
+					kind: "parsed",
+					parse: String,
+					brief: "Publication title"
+				},
+				description: {
+					kind: "parsed",
+					parse: String,
+					optional: true,
+					brief: "Publication description"
+				},
+				brand: {
+					kind: "parsed",
+					parse: String,
+					optional: true,
+					brief: "Brand id"
+				},
+				idempotencyKey: {
+					kind: "parsed",
+					parse: String,
+					optional: true,
+					brief: "Idempotency-Key value"
+				},
+				watch: {
+					kind: "boolean",
+					brief: "Poll until final status"
+				},
+				json: {
+					kind: "boolean",
+					brief: "Print JSON output"
+				}
+			} },
+			async func(flags) {
+				requireAuth(this);
+				const brandId = await resolveBrandId(this, flags.brand);
+				let videoAssetId;
+				if (flags.video.startsWith("asset_")) videoAssetId = flags.video;
+				else videoAssetId = await uploadAsset(this, flags.video, "video", flags.json);
+				let coverAssetId = null;
+				if (flags.cover) if (flags.cover.startsWith("asset_")) coverAssetId = flags.cover;
+				else coverAssetId = await uploadAsset(this, flags.cover, "cover", flags.json);
+				const idempotencyKey = flags.idempotencyKey ?? randomUUID();
+				const result = await this.api.createPublication(brandId, {
+					videoAssetId,
+					coverAssetId,
+					title: flags.title,
+					description: flags.description ?? "",
+					targets: flags.to.map((platform) => ({
+						platform,
+						options: {}
+					}))
+				}, idempotencyKey);
+				if (flags.watch) {
+					const finalResult = await pollPublication(this, brandId, result.publicationId, flags.json);
+					if (flags.json) return jsonOut(this, finalResult);
+					printPublicationSummary(this, finalResult.publication);
+				} else {
+					if (flags.json) return jsonOut(this, result);
+					printDispatchResult(this, result);
+				}
+			}
+		}),
+		get: buildCommand({
+			docs: { brief: "Read a publication" },
+			parameters: {
+				flags: {
+					brand: {
+						kind: "parsed",
+						parse: String,
+						optional: true,
+						brief: "Brand id"
+					},
+					json: {
+						kind: "boolean",
+						brief: "Print JSON output"
+					}
+				},
+				positional: {
+					kind: "tuple",
+					parameters: [{
+						brief: "Publication id",
+						parse: String
+					}]
+				}
+			},
+			async func(flags, id) {
+				requireAuth(this);
+				const brandId = await resolveBrandId(this, flags.brand);
+				const result = await this.api.getPublication(brandId, id);
+				if (flags.json) return jsonOut(this, result);
+				printPublicationSummary(this, result.publication);
+			}
+		}),
+		status: buildCommand({
+			docs: { brief: "Show publication status" },
+			parameters: {
+				flags: {
+					brand: {
+						kind: "parsed",
+						parse: String,
+						optional: true,
+						brief: "Brand id"
+					},
+					watch: {
+						kind: "boolean",
+						brief: "Poll until final status"
+					},
+					json: {
+						kind: "boolean",
+						brief: "Print JSON output"
+					}
+				},
+				positional: {
+					kind: "tuple",
+					parameters: [{
+						brief: "Publication id",
+						parse: String
+					}]
+				}
+			},
+			async func(flags, id) {
+				requireAuth(this);
+				const brandId = await resolveBrandId(this, flags.brand);
+				if (flags.watch) {
+					const result = await pollPublication(this, brandId, id, flags.json);
+					if (flags.json) return jsonOut(this, result);
+					printPublicationSummary(this, result.publication);
+				} else {
+					const result = await this.api.getPublication(brandId, id);
+					if (flags.json) return jsonOut(this, result);
+					printPublicationSummary(this, result.publication);
+				}
+			}
+		})
+	},
+	docs: { brief: "Create and inspect publications" }
+});
+//#endregion
+//#region src/app.ts
+const cleanError = (error) => error instanceof Error ? error.message : String(error);
+const text = {
+	...text_en,
+	exceptionWhileRunningCommand: cleanError,
+	commandErrorResult: cleanError
+};
+const app = buildApplication(buildRouteMap({
+	routes: {
+		login: loginCommand,
+		logout: logoutCommand,
+		whoami: whoamiCommand,
+		brands: brandsRoutes,
+		publications: publicationsRoutes
+	},
+	docs: { brief: "socialized.dev — publish videos from the terminal" }
+}), {
+	name: "socialized.dev",
+	versionInfo: { currentVersion: version },
+	scanner: { caseStyle: "allow-kebab-for-camel" },
+	localization: { loadText: () => text }
+});
+//#endregion
+//#region src/bin.ts
+try {
+	await run(app, process.argv.slice(2), buildContext());
+} catch (error) {
+	process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+	process.exitCode = 1;
+}
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@socialized.dev/cli",
+  "version": "0.1.0",
+  "private": false,
+  "license": "MIT",
+  "type": "module",
+  "description": "socialized.dev CLI — publish a video once, everywhere, from the terminal.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fishballapp/fishballapps.git",
+    "directory": "projects/socialized.dev/apps/cli"
+  },
+  "homepage": "https://socialized.dev",
+  "bugs": {
+    "url": "https://github.com/fishballapp/fishballapps/issues"
+  },
+  "bin": {
+    "socialized.dev": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@stricli/core": "^1.2.7"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsdown": "^0.22.3",
+    "vitest": "^4.1.5"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "cli": "pnpm build && node dist/bin.js",
+    "test": "vitest run --passWithNoTests"
+  }
+}