@usesocial/cli 0.11.6 → 0.11.8

package/dist/index.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 import * as fs from "node:fs";
-import { createReadStream, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { createReadStream, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
-import { basename, dirname, extname, join, resolve } from "node:path";
 import { parseArgs, styleText } from "node:util";
-import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { chmod, lstat, mkdir, readFile, readdir, readlink, rm, writeFile } from "node:fs/promises";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { createHash } from "node:crypto";
 import { dirname as dirname$1, isAbsolute, posix, relative, sep } from "path";
@@ -15,6 +15,7 @@ import l__default, { createInterface } from "node:readline";
 import { AsyncLocalStorage } from "node:async_hooks";
 import process$1, { stdin, stdout } from "node:process";
 import { ReadStream } from "node:tty";
+import { spawn, spawnSync } from "node:child_process";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -11039,6 +11040,7 @@ pgTable("cli_session_grants", {
 }, (table) => [index("cli_session_grants_user_idx").on(table.userId, table.createdAt.desc()), check("cli_session_grants_scope_alias_check", sqlCheckIn(table.scopeAlias, CLI_SCOPE_ALIASES$1))]);
 pgTable("wrapped", {
 	id: text$1("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+	userId: text$1("user_id").references(() => user.id, { onDelete: "cascade" }),
 	platform: text$1("platform", { enum: PLATFORMS }).notNull().default("x"),
 	username: text$1("username").notNull(),
 	platformProfileId: text$1("platform_profile_id").notNull(),
@@ -11052,6 +11054,7 @@ pgTable("wrapped", {
 	updatedAt: timestamptz("updated_at").notNull().defaultNow()
 }, (table) => [
 	uniqueIndex("wrapped_platform_profile_key").on(table.platform, table.platformProfileId),
+	index("wrapped_user_platform_idx").on(table.userId, table.platform, table.updatedAt.desc()).where(sql`${table.userId} is not null`),
 	index("wrapped_platform_username_idx").on(table.platform, table.username),
 	check("wrapped_platform_check", sqlCheckIn(table.platform, PLATFORMS)),
 	check("wrapped_status_check", sqlCheckIn(table.status, WRAPPED_STATUSES))
@@ -23172,7 +23175,7 @@ function createEnv(opts) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.11.6";
+var version$1 = "0.11.8";
 //#endregion
 //#region src/lib/env.ts
 const URLWithTrailingSlash = url().transform(ensureTrailingSlash);
@@ -23682,6 +23685,9 @@ const readStdin = async () => {
 const printLine = (value) => {
 	outputWriters.stdout(value);
 };
+const printStderrLine = (value) => {
+	outputWriters.stderr(value);
+};
 const printData = (value) => {
 	outputWriters.stdout(JSON.stringify(value));
 };
@@ -27121,24 +27127,24 @@ function matchProperty(property, propertyValues, warnFunction) {
 			if (["is_date_before"].includes(operator)) return overrideDate < parsedDate;
 			return overrideDate > parsedDate;
 		}
-		case "semver_eq": return 0 === compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value)));
-		case "semver_neq": return 0 !== compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value)));
-		case "semver_gt": return compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value))) > 0;
-		case "semver_gte": return compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value))) >= 0;
-		case "semver_lt": return compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value))) < 0;
-		case "semver_lte": return compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value))) <= 0;
+		case "semver_eq": return 0 === compareSemverTuples(parseSemver$1(String(overrideValue)), parseSemver$1(String(value)));
+		case "semver_neq": return 0 !== compareSemverTuples(parseSemver$1(String(overrideValue)), parseSemver$1(String(value)));
+		case "semver_gt": return compareSemverTuples(parseSemver$1(String(overrideValue)), parseSemver$1(String(value))) > 0;
+		case "semver_gte": return compareSemverTuples(parseSemver$1(String(overrideValue)), parseSemver$1(String(value))) >= 0;
+		case "semver_lt": return compareSemverTuples(parseSemver$1(String(overrideValue)), parseSemver$1(String(value))) < 0;
+		case "semver_lte": return compareSemverTuples(parseSemver$1(String(overrideValue)), parseSemver$1(String(value))) <= 0;
 		case "semver_tilde": {
-			const overrideParsed = parseSemver(String(overrideValue));
+			const overrideParsed = parseSemver$1(String(overrideValue));
 			const { lower, upper } = computeTildeBounds(String(value));
 			return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
 		}
 		case "semver_caret": {
-			const overrideParsed = parseSemver(String(overrideValue));
+			const overrideParsed = parseSemver$1(String(overrideValue));
 			const { lower, upper } = computeCaretBounds(String(value));
 			return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
 		}
 		case "semver_wildcard": {
-			const overrideParsed = parseSemver(String(overrideValue));
+			const overrideParsed = parseSemver$1(String(overrideValue));
 			const { lower, upper } = computeWildcardBounds(String(value));
 			return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
 		}
@@ -27214,7 +27220,7 @@ function parseSemverNumericIdentifier(part, raw) {
 	if (part.length > 1 && "0" === part[0]) throw new InconclusiveMatchError(`Invalid semver: ${raw}`);
 	return parseInt(part, 10);
 }
-function parseSemver(value) {
+function parseSemver$1(value) {
 	const baseVersion = String(value).trim().replace(/^[vV]/, "").split("-")[0].split("+")[0];
 	if (!baseVersion || baseVersion.startsWith(".")) throw new InconclusiveMatchError(`Invalid semver: ${value}`);
 	const parts = baseVersion.split(".");
@@ -27236,7 +27242,7 @@ function compareSemverTuples(a, b) {
 	return 0;
 }
 function computeTildeBounds(value) {
-	const parsed = parseSemver(value);
+	const parsed = parseSemver$1(value);
 	return {
 		lower: [
 			parsed[0],
@@ -27251,7 +27257,7 @@ function computeTildeBounds(value) {
 	};
 }
 function computeCaretBounds(value) {
-	const [major, minor, patch] = parseSemver(value);
+	const [major, minor, patch] = parseSemver$1(value);
 	const lower = [
 		major,
 		minor,
@@ -28471,7 +28477,7 @@ const outcomeForExitCode = (code) => {
 	}
 };
 /** Any non-empty value other than "0"/"false" counts as truthy. */
-const truthy = (value) => {
+const truthy$1 = (value) => {
 	if (!value) return false;
 	const normalized = value.trim().toLowerCase();
 	return normalized !== "" && normalized !== "0" && normalized !== "false";
@@ -28480,7 +28486,7 @@ const truthy = (value) => {
 * `enabled` is pure env — computed once, no I/O. When false, no client is
 * constructed, the state file is never touched, and no notice is printed.
 */
-const computeEnabled = () => !!env.NEXT_PUBLIC_POSTHOG_PROJECT_TOKEN && !truthy(env.DO_NOT_TRACK) && !truthy(env.SOCIAL_DO_NOT_TRACK) && !truthy(env.CI);
+const computeEnabled = () => !!env.NEXT_PUBLIC_POSTHOG_PROJECT_TOKEN && !truthy$1(env.DO_NOT_TRACK) && !truthy$1(env.SOCIAL_DO_NOT_TRACK) && !truthy$1(env.CI);
 const statePath = () => join(homedir(), ".social", "analytics.json");
 /**
 * Read existing state, or create a fresh anonymousId on first run. Returns
@@ -37161,6 +37167,516 @@ const schemaCommand = defineCommand({
 	}
 });
 //#endregion
+//#region src/update/check.ts
+const NPM_REGISTRY_URL = "https://registry.npmjs.org/@usesocial%2fcli";
+const SKILL_TREE_URL = "https://api.github.com/repos/usesocial/skill/git/trees/main:skills/social";
+const UPDATE_CACHE_TTL_MS = 1200 * 60 * 1e3;
+const UPDATE_NOTICE_TTL_MS = 1440 * 60 * 1e3;
+const INTERNAL_UPDATE_PROBE_ENV = "SOCIAL_INTERNAL_UPDATE_PROBE";
+_enum([
+	"brew",
+	"bun",
+	"npm"
+]);
+const CLIUpdateStatus = _enum([
+	"current",
+	"update_available",
+	"unknown"
+]);
+const SkillUpdateStatus = _enum([
+	"current",
+	"not_installed",
+	"update_available",
+	"unknown"
+]);
+const SkillScope = _enum(["project", "global"]);
+const NPMRegistryResponse = object({
+	"dist-tags": object({ latest: string().optional() }).passthrough().optional(),
+	versions: record(string(), object({ dist: object({
+		integrity: string().optional(),
+		tarball: string().optional()
+	}).passthrough().optional() }).passthrough())
+}).passthrough();
+const GitHubTreeResponse = object({ sha: string() });
+const CacheFile = object({
+	checkedAt: number().int().nonnegative(),
+	cli: object({
+		currentVersion: string(),
+		latestVersion: string().nullable(),
+		status: CLIUpdateStatus,
+		updateCommand: string().nullable()
+	}),
+	notices: record(string(), number().int().nonnegative()).optional(),
+	skill: object({
+		localTreeSHA: string().optional(),
+		remoteTreeSHA: string().optional(),
+		scope: SkillScope.nullable(),
+		status: SkillUpdateStatus,
+		updateCommand: string().nullable()
+	})
+}).strict();
+const internalPackageRoot = () => {
+	const dir = dirname(fileURLToPath(import.meta.url));
+	const leaf = basename(dir);
+	return leaf === "dist" || leaf === "src" ? dirname(dir) : dirname(dirname(dir));
+};
+const updateCachePath = (home = process.env.HOME ?? homedir()) => join(home, ".social", "update-check.json");
+const defaultCommandRunner = (cmd, args, options) => {
+	const result = spawnSync(cmd, args, {
+		cwd: options?.cwd,
+		encoding: "utf8",
+		maxBuffer: 1024 * 1024,
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		],
+		timeout: 1e4
+	});
+	return {
+		ok: result.status === 0,
+		stdout: typeof result.stdout === "string" ? result.stdout : ""
+	};
+};
+const truthy = (value) => {
+	if (!value) return false;
+	const normalized = value.trim().toLowerCase();
+	return normalized !== "" && normalized !== "0" && normalized !== "false";
+};
+const updateAwarenessEnabled = () => process.stderr.isTTY && !truthy(process.env.CI) && !truthy(process.env.DO_NOT_TRACK) && !truthy(process.env.SOCIAL_DO_NOT_TRACK);
+const parseSemver = (version) => {
+	const match = /^v?(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<pre>[0-9A-Za-z.-]+))?/.exec(version);
+	if (!match?.groups) return;
+	return {
+		major: Number(match.groups.major),
+		minor: Number(match.groups.minor),
+		patch: Number(match.groups.patch),
+		prerelease: match.groups.pre?.split(".") ?? []
+	};
+};
+const compareIdentifier = (left, right) => {
+	const leftNumber = /^\d+$/.test(left) ? Number(left) : void 0;
+	const rightNumber = /^\d+$/.test(right) ? Number(right) : void 0;
+	if (leftNumber !== void 0 && rightNumber !== void 0) return Math.sign(leftNumber - rightNumber);
+	if (leftNumber !== void 0) return -1;
+	if (rightNumber !== void 0) return 1;
+	return left.localeCompare(right);
+};
+const compareSemver = (left, right) => {
+	const parsedLeft = parseSemver(left);
+	const parsedRight = parseSemver(right);
+	if (!(parsedLeft && parsedRight)) return left.localeCompare(right);
+	for (const key of [
+		"major",
+		"minor",
+		"patch"
+	]) {
+		const delta = parsedLeft[key] - parsedRight[key];
+		if (delta !== 0) return Math.sign(delta);
+	}
+	if (parsedLeft.prerelease.length === 0 && parsedRight.prerelease.length > 0) return 1;
+	if (parsedLeft.prerelease.length > 0 && parsedRight.prerelease.length === 0) return -1;
+	const length = Math.max(parsedLeft.prerelease.length, parsedRight.prerelease.length);
+	for (let index = 0; index < length; index += 1) {
+		const leftPart = parsedLeft.prerelease[index];
+		const rightPart = parsedRight.prerelease[index];
+		if (leftPart === void 0) return -1;
+		if (rightPart === void 0) return 1;
+		const delta = compareIdentifier(leftPart, rightPart);
+		if (delta !== 0) return delta;
+	}
+	return 0;
+};
+const detectPackageManager = (packageRoot) => {
+	const normalized = packageRoot.replaceAll("\\", "/");
+	if (normalized.includes("/Cellar/usesocial/") || normalized.includes("/Cellar/cli/") || normalized.includes("/Homebrew/")) return "brew";
+	if (normalized.includes("/.bun/install/global/")) return "bun";
+	return "npm";
+};
+const cliUpdateCommand = (manager) => {
+	if (manager === "brew") return "brew upgrade usesocial/tap/cli";
+	if (manager === "bun") return "bun install -g @usesocial/cli@latest";
+	return "npm install -g @usesocial/cli@latest";
+};
+const skillUpdateRunner = (manager) => manager === "bun" ? "bunx --bun" : "npx --yes";
+const skillUpdateCommand = (scope, manager) => `${skillUpdateRunner(manager)} skills update social --${scope} --yes`;
+const parseNPMUpdateResult = (value, currentVersion, manager) => {
+	const parsed = NPMRegistryResponse.safeParse(value);
+	if (!parsed.success) return {
+		currentVersion,
+		latestVersion: null,
+		status: "unknown",
+		updateCommand: null
+	};
+	const latestVersion = parsed.data["dist-tags"]?.latest ?? null;
+	if (!latestVersion || compareSemver(latestVersion, currentVersion) <= 0) return {
+		currentVersion,
+		latestVersion,
+		status: "current",
+		updateCommand: null
+	};
+	const latestPackage = parsed.data.versions[latestVersion];
+	if (!(latestPackage?.dist?.tarball && latestPackage.dist.integrity)) return {
+		currentVersion,
+		latestVersion,
+		status: "unknown",
+		updateCommand: null
+	};
+	return {
+		currentVersion,
+		latestVersion,
+		status: "update_available",
+		updateCommand: cliUpdateCommand(manager)
+	};
+};
+const unknownCLIStatus = () => ({
+	currentVersion: VERSION,
+	latestVersion: null,
+	status: "unknown",
+	updateCommand: null
+});
+const checkCLIUpdate = async (deps = {}) => {
+	const packageRoot = deps.packageRoot ?? internalPackageRoot();
+	const fetchImpl = deps.fetch ?? fetch;
+	try {
+		const response = await fetchImpl(NPM_REGISTRY_URL, { headers: { accept: "application/json" } });
+		if (!response.ok) return unknownCLIStatus();
+		return parseNPMUpdateResult(await response.json(), VERSION, detectPackageManager(packageRoot));
+	} catch {
+		return unknownCLIStatus();
+	}
+};
+const readJSON = async (path) => {
+	try {
+		return JSON.parse(await readFile(path, "utf8"));
+	} catch {
+		return;
+	}
+};
+const lockSkillFrom = (value) => {
+	if (!value || typeof value !== "object") return;
+	const skills = value.skills;
+	if (!skills || typeof skills !== "object") return;
+	const social = skills.social;
+	if (!social || typeof social !== "object") return;
+	const record = social;
+	return {
+		source: typeof record.source === "string" ? record.source : void 0,
+		skillPath: typeof record.skillPath === "string" ? record.skillPath : void 0
+	};
+};
+const skillFolderFromLock = (lockPath, skill) => {
+	if (!skill?.skillPath) return;
+	return join(dirname(lockPath), dirname(skill.skillPath));
+};
+const candidateFromLock = async (lockPath, scope) => {
+	const skill = lockSkillFrom(await readJSON(lockPath));
+	const folder = skillFolderFromLock(lockPath, skill);
+	if (!folder) return;
+	return {
+		folder,
+		scope,
+		source: skill?.source
+	};
+};
+const folderFromListEntry = (entry) => {
+	if (!entry || typeof entry !== "object") return;
+	const record = entry;
+	for (const key of [
+		"folder",
+		"path",
+		"directory",
+		"dir"
+	]) if (typeof record[key] === "string") return record[key];
+	if (typeof record.skillPath === "string") return dirname(record.skillPath);
+};
+const listEntriesFrom = (value) => {
+	if (Array.isArray(value)) return value;
+	if (!value || typeof value !== "object") return [];
+	const record = value;
+	if (Array.isArray(record.skills)) return record.skills;
+	if (record.skills && typeof record.skills === "object") return Object.entries(record.skills).map(([name, skill]) => skill && typeof skill === "object" ? {
+		name,
+		...skill
+	} : { name });
+	return [];
+};
+const candidateFromSkillsList = (rawJSON, lockPath, scope) => {
+	try {
+		const folder = folderFromListEntry(listEntriesFrom(JSON.parse(rawJSON)).find((entry) => {
+			if (!entry || typeof entry !== "object") return false;
+			const record = entry;
+			return record.name === "social" || record.id === "social";
+		}));
+		if (!folder) return;
+		return {
+			folder: folder.startsWith("/") ? folder : join(dirname(lockPath), folder),
+			scope
+		};
+	} catch {
+		return;
+	}
+};
+const installedSkillCandidate = async (deps) => {
+	const cwd = deps.cwd ?? process.cwd();
+	const home = deps.home ?? process.env.HOME ?? homedir();
+	const runCommand = deps.runCommand ?? defaultCommandRunner;
+	const candidates = [{
+		args: ["list", "--json"],
+		lockPath: join(cwd, "skills-lock.json"),
+		scope: "project"
+	}, {
+		args: [
+			"list",
+			"--json",
+			"--global"
+		],
+		lockPath: join(home, ".agents", ".skill-lock.json"),
+		scope: "global"
+	}];
+	for (const candidate of candidates) {
+		const fromLock = await candidateFromLock(candidate.lockPath, candidate.scope);
+		if (fromLock?.source === "usesocial/skill" && existsSync(fromLock.folder)) return fromLock;
+		const listed = runCommand("skills", candidate.args, { cwd });
+		if (!listed.ok) continue;
+		const fromList = candidateFromSkillsList(listed.stdout, candidate.lockPath, candidate.scope);
+		if (!fromList) continue;
+		const lock = lockSkillFrom(await readJSON(candidate.lockPath));
+		if (lock?.source !== "usesocial/skill") continue;
+		return {
+			...fromList,
+			source: lock.source
+		};
+	}
+};
+const hashGitObject = (type, body) => createHash("sha1").update(Buffer.from(`${type} ${body.length}\0`)).update(body).digest("hex");
+const gitBlobHash = (content) => hashGitObject("blob", content);
+const compareTreeEntry = (left, right) => Buffer.compare(Buffer.from(left.sortName), Buffer.from(right.sortName));
+const gitTreeHashForFolder = async (folder) => {
+	const dirents = await readdir(folder, { withFileTypes: true });
+	const entries = [];
+	for (const dirent of dirents) {
+		if (dirent.name === ".git") continue;
+		const path = join(folder, dirent.name);
+		const stat = await lstat(path);
+		if (stat.isDirectory()) {
+			entries.push({
+				mode: "40000",
+				name: dirent.name,
+				sha: await gitTreeHashForFolder(path),
+				sortName: `${dirent.name}/`
+			});
+			continue;
+		}
+		if (stat.isSymbolicLink()) {
+			entries.push({
+				mode: "120000",
+				name: dirent.name,
+				sha: gitBlobHash(Buffer.from(await readlink(path))),
+				sortName: dirent.name
+			});
+			continue;
+		}
+		if (stat.isFile()) {
+			const executable = [
+				1,
+				8,
+				64
+			].some((bit) => Math.floor(stat.mode / bit) % 2 === 1);
+			entries.push({
+				mode: executable ? "100755" : "100644",
+				name: dirent.name,
+				sha: gitBlobHash(await readFile(path)),
+				sortName: dirent.name
+			});
+		}
+	}
+	return hashGitObject("tree", Buffer.concat(entries.sort(compareTreeEntry).map((entry) => Buffer.concat([Buffer.from(`${entry.mode} ${entry.name}\0`), Buffer.from(entry.sha, "hex")]))));
+};
+const remoteSkillTreeSHA = async (fetchImpl) => {
+	const response = await fetchImpl(SKILL_TREE_URL, { headers: { accept: "application/vnd.github+json" } });
+	if (!response.ok) return;
+	const parsed = GitHubTreeResponse.safeParse(await response.json());
+	return parsed.success ? parsed.data.sha : void 0;
+};
+const unknownSkillStatus = () => ({
+	scope: null,
+	status: "unknown",
+	updateCommand: null
+});
+const checkSkillUpdate = async (deps = {}) => {
+	const manager = detectPackageManager(deps.packageRoot ?? internalPackageRoot());
+	const install = await installedSkillCandidate(deps);
+	if (!install) return {
+		scope: null,
+		status: "not_installed",
+		updateCommand: null
+	};
+	if (install.source !== "usesocial/skill") return unknownSkillStatus();
+	try {
+		const fetchImpl = deps.fetch ?? fetch;
+		const [localSHA, remoteSHA] = await Promise.all([gitTreeHashForFolder(install.folder), remoteSkillTreeSHA(fetchImpl)]);
+		if (!remoteSHA) return {
+			scope: install.scope,
+			status: "unknown",
+			updateCommand: null
+		};
+		return {
+			localTreeSHA: localSHA,
+			remoteTreeSHA: remoteSHA,
+			scope: install.scope,
+			status: localSHA === remoteSHA ? "current" : "update_available",
+			updateCommand: localSHA === remoteSHA ? null : skillUpdateCommand(install.scope, manager)
+		};
+	} catch {
+		return {
+			scope: install.scope,
+			status: "unknown",
+			updateCommand: null
+		};
+	}
+};
+const refreshUpdateStatus = async (deps = {}) => {
+	const [cli, skill] = await Promise.all([checkCLIUpdate(deps), checkSkillUpdate(deps)]);
+	return {
+		checkedAt: deps.now?.() ?? Date.now(),
+		cli,
+		skill
+	};
+};
+const readCachedUpdateStatus = async (home) => {
+	try {
+		const parsed = CacheFile.safeParse(JSON.parse(await readFile(updateCachePath(home), "utf8")));
+		return parsed.success ? parsed.data : void 0;
+	} catch {
+		return;
+	}
+};
+const writeCachedUpdateStatus = async (home, status) => {
+	const path = updateCachePath(home);
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify(status, null, 2)}\n`, { mode: 384 });
+	await chmod(path, 384);
+};
+const refreshUpdateStatusCache = async (deps = {}) => {
+	const status = await refreshUpdateStatus(deps);
+	const cached = await readCachedUpdateStatus(deps.home);
+	await writeCachedUpdateStatus(deps.home, {
+		...status,
+		notices: cached?.notices
+	});
+	return status;
+};
+const isUpdateCacheStale = (cache, now) => !cache || now - cache.checkedAt >= UPDATE_CACHE_TTL_MS;
+const noticeDue = (cache, key, now) => now - (cache.notices?.[key] ?? 0) >= UPDATE_NOTICE_TTL_MS;
+const withNotice = (cache, key, now) => ({
+	...cache,
+	notices: {
+		...cache.notices ?? {},
+		[key]: now
+	}
+});
+const noticeLinesFor = (cache, now) => {
+	const notices = [];
+	if (cache.cli.status === "update_available" && cache.cli.latestVersion && cache.cli.updateCommand) {
+		const key = `cli:${cache.cli.latestVersion}`;
+		if (noticeDue(cache, key, now)) notices.push({
+			key,
+			line: `Update available: social CLI ${cache.cli.latestVersion} (current ${cache.cli.currentVersion}). Run: ${cache.cli.updateCommand}`
+		});
+	}
+	if (cache.skill.status === "update_available" && cache.skill.scope && cache.skill.updateCommand && cache.skill.remoteTreeSHA) {
+		const key = `skill:${cache.skill.scope}:${cache.skill.remoteTreeSHA}`;
+		if (noticeDue(cache, key, now)) notices.push({
+			key,
+			line: `Update available: social skill (${cache.skill.scope}). Run: ${cache.skill.updateCommand}`
+		});
+	}
+	return notices;
+};
+const spawnInternalProbe = (packageRoot) => {
+	const sourceEntry = join(packageRoot, "src", "index.ts");
+	const distEntry = join(packageRoot, "bin", "social.mjs");
+	const entry = process.versions.bun && existsSync(sourceEntry) ? sourceEntry : distEntry;
+	spawn(process.execPath, [entry], {
+		detached: true,
+		env: {
+			...process.env,
+			[INTERNAL_UPDATE_PROBE_ENV]: "1"
+		},
+		stdio: "ignore"
+	}).unref();
+};
+const maybeRunUpdateAwareness = async (deps = {}) => {
+	if (!updateAwarenessEnabled()) return;
+	const now = deps.now?.() ?? Date.now();
+	const home = deps.home;
+	const cache = await readCachedUpdateStatus(home);
+	if (cache) {
+		let next = cache;
+		for (const notice of noticeLinesFor(cache, now)) {
+			printStderrLine(notice.line);
+			next = withNotice(next, notice.key, now);
+		}
+		if (next !== cache) await writeCachedUpdateStatus(home, next);
+	}
+	if (isUpdateCacheStale(cache, now)) spawnInternalProbe(deps.packageRoot ?? internalPackageRoot());
+};
+const runInternalUpdateProbeIfRequested = async (deps = {}) => {
+	if (process.env[INTERNAL_UPDATE_PROBE_ENV] !== "1") return false;
+	try {
+		await refreshUpdateStatusCache(deps);
+	} catch {}
+	return true;
+};
+const updateCommand = defineCommand({
+	meta: commandMeta({
+		name: "update",
+		description: "Check for social CLI and skill updates.",
+		contract: localCLIContract({
+			outputSchema: object({
+				cli: object({
+					currentVersion: string(),
+					latestVersion: string().nullable(),
+					status: _enum([
+						"current",
+						"update_available",
+						"unknown"
+					]),
+					updateCommand: string().nullable()
+				}),
+				skill: object({
+					scope: _enum(["project", "global"]).nullable(),
+					status: _enum([
+						"current",
+						"not_installed",
+						"update_available",
+						"unknown"
+					]),
+					updateCommand: string().nullable()
+				})
+			}),
+			responseShaping: { formats: ["json"] }
+		})
+	}),
+	run: async () => {
+		const status = await refreshUpdateStatus();
+		printData({
+			cli: {
+				currentVersion: status.cli.currentVersion,
+				latestVersion: status.cli.latestVersion,
+				status: status.cli.status,
+				updateCommand: status.cli.updateCommand
+			},
+			skill: {
+				scope: status.skill.scope,
+				status: status.skill.status,
+				updateCommand: status.skill.updateCommand
+			}
+		});
+	}
+});
+//#endregion
 //#region src/index.ts
 const originalEmitWarning = process.emitWarning.bind(process);
 process.emitWarning = ((warning, ...rest) => {
@@ -37351,6 +37867,7 @@ const createSocialCommand = (deps = createCLIDeps()) => {
 		subCommands: {
 			account: accountCommand,
 			schema: schemaCommand,
+			update: updateCommand,
 			x: xCommand,
 			linkedin: linkedinCommand,
 			feedback: feedbackCommand
@@ -37397,6 +37914,10 @@ const runSocial = async ({ command = createSocialCommand(), now = Date.now, rawA
 		captureCommandException(error, exitCode, telemetry, now);
 		return await finish(exitCode, telemetry, now);
 	}
+	if (path[0] !== "update") await maybeRunUpdateAwareness({
+		now,
+		packageRoot: dirname(dirname(fileURLToPath(import.meta.url)))
+	});
 	return await finish(0, telemetry, now);
 };
 const isEPIPEError = (error) => error instanceof Error && "code" in error && error.code === "EPIPE";
@@ -37447,6 +37968,7 @@ const installProcessHandlers = (telemetry) => {
 	process.stderr.on("error", handlePipeError);
 };
 const main = async () => {
+	if (await runInternalUpdateProbeIfRequested()) process.exit(0);
 	installProcessHandlers(analytics);
 	process.exit(await runSocial());
 };