#!/usr/bin/env node
import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as Console from "effect/Console";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import { Command, Flag } from "effect/cli";
import { ChildProcess, ChildProcessSpawner } from "effect/process";
import { BRAND_ASSET_PATHS, DEVELOPMENT_PUBLIC_ICON_OVERRIDES } from "./lib/brand-assets.ts";
import { encodePngIco, readPngDimensions, WINDOWS_ICON_SIZES } from "./lib/icon-export.ts";
const DESIGN_GENERATION = 26;
const ICON_COMPOSER_EXECUTABLE_PARTS = [
"Contents",
"Applications",
"Icon Composer.app",
"Contents",
"Executables",
"ictool",
] as const;
const STANDALONE_ICON_COMPOSER_EXECUTABLE_PARTS = [
"Icon Composer.app",
"Contents",
"Executables",
"ictool",
] as const;
const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
const IconComposerVersion = Schema.Struct({
"bundle-version": Schema.NonEmptyString,
"short-bundle-version": Schema.NonEmptyString,
});
const decodeIconComposerVersion = Schema.decodeUnknownEffect(
Schema.fromJsonString(IconComposerVersion),
);
type IconPlatform = "iOS";
interface VariantOutputs {
readonly ios: string;
readonly macos: string;
readonly universal: string;
readonly appleTouch: string;
readonly webIcon192: string;
readonly webIcon512: string;
readonly favicon16: string;
readonly favicon32: string;
readonly faviconIco: string;
readonly windowsIco: string;
}
interface IconVariant {
readonly label: string;
readonly source: string;
readonly outputs: VariantOutputs;
}
interface IconComposerTool {
readonly path: string;
readonly version: string;
readonly bundleVersion: string;
readonly supportsDesignGeneration: boolean;
}
interface CommandResult {
readonly stdout: string;
readonly stderr: string;
readonly exitCode: number;
}
export class IconExportFileSystemError extends Schema.TaggedError<IconExportFileSystemError>()(
"IconExportFileSystemError",
{
operation: Schema.Literals([
"resolve-repository-root",
"check-path",
"read-directory",
"read-file",
"make-directory",
"make-temp-directory",
"make-temp-file",
"write-file",
"rename-file",
]),
path: Schema.String,
cause: Schema.Defect(),
},
) {
override get message(): string {
return `Icon export file-system operation '${this.operation}' failed for ${this.path}.`;
}
}
export class IconExportProcessError extends Schema.TaggedError<IconExportProcessError>()(
"IconExportProcessError",
{
operation: Schema.Literals(["spawn", "collect-stdout", "collect-stderr", "wait-for-exit"]),
command: Schema.String,
argumentCount: NonNegativeInt,
cause: Schema.Defect(),
},
) {
override get message(): string {
return `Icon export process operation '${this.operation}' failed for ${this.command}.`;
}
}
export class IconExportCommandFailedError extends Schema.TaggedError<IconExportCommandFailedError>()(
"IconExportCommandFailedError",
{
command: Schema.String,
argumentCount: NonNegativeInt,
exitCode: Schema.Int,
sourcePath: Schema.String,
size: Schema.Int,
stdout: Schema.optional(Schema.String),
stderr: Schema.optional(Schema.String),
},
) {
override get message(): string {
return `Icon Composer failed to export ${this.sourcePath} at ${this.size}x${this.size}.`;
}
}
export class IconExportToolResolutionError extends Schema.TaggedError<IconExportToolResolutionError>()(
"IconExportToolResolutionError",
{
reason: Schema.Literals(["configured-invalid", "configured-outdated", "not-found"]),
designGeneration: Schema.Int,
toolPath: Schema.optional(Schema.String),
version: Schema.optional(Schema.String),
},
) {
override get message(): string {
switch (this.reason) {
case "configured-invalid":
return `ICON_COMPOSER_TOOL does not point to Icon Composer's export-capable ictool: ${this.toolPath}`;
case "configured-outdated":
return `ICON_COMPOSER_TOOL points to Icon Composer ${this.version}, but version 2 or newer is required for design generation ${this.designGeneration}.`;
case "not-found":
return `Could not find an Icon Composer 2.x exporter compatible with design generation ${this.designGeneration}. Install a compatible Icon Composer/Xcode or set ICON_COMPOSER_TOOL to Icon Composer.app/Contents/Executables/ictool.`;
}
}
}
export class IconExportSourceMissingError extends Schema.TaggedError<IconExportSourceMissingError>()(
"IconExportSourceMissingError",
{
sourcePath: Schema.String,
},
) {
override get message(): string {
return `Missing Icon Composer source project: ${this.sourcePath}`;
}
}
export class IconExportRenditionError extends Schema.TaggedError<IconExportRenditionError>()(
"IconExportRenditionError",
{
sourcePath: Schema.String,
outputPath: Schema.String,
expectedSize: Schema.Int,
actualWidth: Schema.optional(Schema.Int),
actualHeight: Schema.optional(Schema.Int),
cause: Schema.optional(Schema.Defect()),
},
) {
override get message(): string {
const actual =
this.actualWidth === undefined || this.actualHeight === undefined
? "an invalid PNG"
: `${this.actualWidth}x${this.actualHeight}`;
return `Icon Composer produced ${actual}; expected ${this.expectedSize}x${this.expectedSize} for ${this.sourcePath}.`;
}
}
export class IconExportEncodingError extends Schema.TaggedError<IconExportEncodingError>()(
"IconExportEncodingError",
{
variant: Schema.String,
cause: Schema.Defect(),
},
) {
override get message(): string {
return `Failed to encode ICO renditions for the ${this.variant} icon.`;
}
}
export class IconExportAssetsStaleError extends Schema.TaggedError<IconExportAssetsStaleError>()(
"IconExportAssetsStaleError",
{
paths: Schema.Array(Schema.String),
},
) {
override get message(): string {
return `Generated icon assets are stale:\n${this.paths.map((path) => `- ${path}`).join("\n")}`;
}
}
const ICON_VARIANTS = [
{
label: "development",
source: BRAND_ASSET_PATHS.developmentIconComposerProject,
outputs: {
ios: BRAND_ASSET_PATHS.developmentIosIconPng,
macos: BRAND_ASSET_PATHS.developmentDesktopIconPng,
universal: BRAND_ASSET_PATHS.developmentUniversalIconPng,
appleTouch: BRAND_ASSET_PATHS.developmentWebAppleTouchIconPng,
webIcon192: BRAND_ASSET_PATHS.developmentWebIcon192Png,
webIcon512: BRAND_ASSET_PATHS.developmentWebIcon512Png,
favicon16: BRAND_ASSET_PATHS.developmentWebFavicon16Png,
favicon32: BRAND_ASSET_PATHS.developmentWebFavicon32Png,
faviconIco: BRAND_ASSET_PATHS.developmentWebFaviconIco,
windowsIco: BRAND_ASSET_PATHS.developmentWindowsIconIco,
},
},
{
label: "preview",
source: BRAND_ASSET_PATHS.nightlyIconComposerProject,
outputs: {
ios: BRAND_ASSET_PATHS.nightlyIosIconPng,
macos: BRAND_ASSET_PATHS.nightlyMacIconPng,
universal: BRAND_ASSET_PATHS.nightlyLinuxIconPng,
appleTouch: BRAND_ASSET_PATHS.nightlyWebAppleTouchIconPng,
webIcon192: BRAND_ASSET_PATHS.nightlyWebIcon192Png,
webIcon512: BRAND_ASSET_PATHS.nightlyWebIcon512Png,
favicon16: BRAND_ASSET_PATHS.nightlyWebFavicon16Png,
favicon32: BRAND_ASSET_PATHS.nightlyWebFavicon32Png,
faviconIco: BRAND_ASSET_PATHS.nightlyWebFaviconIco,
windowsIco: BRAND_ASSET_PATHS.nightlyWindowsIconIco,
},
},
{
label: "production",
source: BRAND_ASSET_PATHS.productionIconComposerProject,
outputs: {
ios: BRAND_ASSET_PATHS.productionIosIconPng,
macos: BRAND_ASSET_PATHS.productionMacIconPng,
universal: BRAND_ASSET_PATHS.productionLinuxIconPng,
appleTouch: BRAND_ASSET_PATHS.productionWebAppleTouchIconPng,
webIcon192: BRAND_ASSET_PATHS.productionWebIcon192Png,
webIcon512: BRAND_ASSET_PATHS.productionWebIcon512Png,
favicon16: BRAND_ASSET_PATHS.productionWebFavicon16Png,
favicon32: BRAND_ASSET_PATHS.productionWebFavicon32Png,
faviconIco: BRAND_ASSET_PATHS.productionWebFaviconIco,
windowsIco: BRAND_ASSET_PATHS.productionWindowsIconIco,
},
},
] as const satisfies ReadonlyArray<IconVariant>;
const RepositoryRoot = Effect.service(Path.Path).pipe(
Effect.flatMap((path) => path.fromFileUrl(new URL("..", import.meta.url))),
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "resolve-repository-root",
path: new URL("..", import.meta.url).pathname,
cause,
}),
),
);
const collectStreamAsString = <E>(stream: Stream.Stream<Uint8Array, E>) =>
stream.pipe(
Stream.decodeText(),
Stream.runFold(
() => "",
(acc, chunk) => acc + chunk,
),
);
const runCommand = Effect.fn("iconExport.runCommand")(function* (
command: string,
args: ReadonlyArray<string>,
) {
const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
const child = yield* spawner.spawn(ChildProcess.make(command, args)).pipe(
Effect.mapError(
(cause) =>
new IconExportProcessError({
operation: "spawn",
command,
argumentCount: args.length,
cause,
}),
),
);
const [stdout, stderr, exitCode] = yield* Effect.all(
[
collectStreamAsString(child.stdout).pipe(
Effect.mapError(
(cause) =>
new IconExportProcessError({
operation: "collect-stdout",
command,
argumentCount: args.length,
cause,
}),
),
),
collectStreamAsString(child.stderr).pipe(
Effect.mapError(
(cause) =>
new IconExportProcessError({
operation: "collect-stderr",
command,
argumentCount: args.length,
cause,
}),
),
),
child.exitCode.pipe(
Effect.map(Number),
Effect.mapError(
(cause) =>
new IconExportProcessError({
operation: "wait-for-exit",
command,
argumentCount: args.length,
cause,
}),
),
),
],
{ concurrency: "unbounded" },
);
return { stdout, stderr, exitCode } satisfies CommandResult;
});
const iconComposerToolFromDeveloperDirectory = (developerDirectory: string, path: Path.Path) =>
path.resolve(developerDirectory, "..", ...ICON_COMPOSER_EXECUTABLE_PARTS.slice(1));
const readSelectedDeveloperDirectory = Effect.fn("iconExport.readSelectedDeveloperDirectory")(
function* () {
const result = yield* runCommand("xcode-select", ["-p"]).pipe(Effect.option);
return Option.flatMap(result, (output) => {
const developerDirectory = output.stdout.trim();
return output.exitCode === 0 && developerDirectory.length > 0
? Option.some(developerDirectory)
: Option.none();
});
},
);
const findXcodeAppCandidates = Effect.fn("iconExport.findXcodeAppCandidates")(function* (
directory: string,
) {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const entries = yield* fs.readDirectory(directory).pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "read-directory",
path: directory,
cause,
}),
),
Effect.orElseSucceed(() => []),
);
return entries
.filter((entry) => /^Xcode.*\.app$/.test(entry))
.map((entry) => path.join(directory, entry, ...ICON_COMPOSER_EXECUTABLE_PARTS));
});
const probeIconComposerTool = Effect.fn("iconExport.probeIconComposerTool")(function* (
candidate: string,
) {
const fs = yield* FileSystem.FileSystem;
const exists = yield* fs.exists(candidate).pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "check-path",
path: candidate,
cause,
}),
),
Effect.orElseSucceed(() => false),
);
if (!exists) return Option.none<IconComposerTool>();
const result = yield* runCommand(candidate, ["--version"]).pipe(Effect.option);
if (Option.isNone(result) || result.value.exitCode !== 0) {
return Option.none<IconComposerTool>();
}
const version = yield* decodeIconComposerVersion(result.value.stdout).pipe(Effect.option);
if (Option.isNone(version)) return Option.none<IconComposerTool>();
const bundleVersion = version.value["bundle-version"];
const shortVersion = version.value["short-bundle-version"];
return Option.some({
path: candidate,
version: `${shortVersion} (${bundleVersion})`,
bundleVersion,
supportsDesignGeneration: Number.parseInt(shortVersion, 10) >= 2,
});
});
const resolveIconComposerTool = Effect.fn("iconExport.resolveIconComposerTool")(function* () {
const path = yield* Path.Path;
const environment = yield* HostProcess.Environment;
const configuredTool = environment.ICON_COMPOSER_TOOL?.trim();
if (configuredTool) {
const tool = yield* probeIconComposerTool(configuredTool);
if (Option.isNone(tool)) {
return yield* new IconExportToolResolutionError({
reason: "configured-invalid",
designGeneration: DESIGN_GENERATION,
toolPath: configuredTool,
});
}
if (!tool.value.supportsDesignGeneration) {
return yield* new IconExportToolResolutionError({
reason: "configured-outdated",
designGeneration: DESIGN_GENERATION,
toolPath: configuredTool,
version: tool.value.version,
});
}
return tool.value;
}
const selectedDeveloperDirectory = yield* readSelectedDeveloperDirectory();
const configuredDeveloperDirectory = environment.DEVELOPER_DIR?.trim();
const homeDirectory = environment.HOME?.trim();
const searchDirectories = [
"/Applications",
...(homeDirectory ? [path.join(homeDirectory, "Downloads")] : []),
];
const xcodeCandidates = yield* Effect.forEach(searchDirectories, findXcodeAppCandidates, {
concurrency: "unbounded",
});
const candidates = new Set<string>([
...(configuredDeveloperDirectory
? [iconComposerToolFromDeveloperDirectory(configuredDeveloperDirectory, path)]
: []),
...Option.match(selectedDeveloperDirectory, {
onNone: () => [],
onSome: (developerDirectory) => [
iconComposerToolFromDeveloperDirectory(developerDirectory, path),
],
}),
path.join("/Applications", ...STANDALONE_ICON_COMPOSER_EXECUTABLE_PARTS),
...(homeDirectory
? [path.join(homeDirectory, "Applications", ...STANDALONE_ICON_COMPOSER_EXECUTABLE_PARTS)]
: []),
...xcodeCandidates.flat(),
]);
const probed = yield* Effect.forEach([...candidates], probeIconComposerTool, {
concurrency: "unbounded",
});
const compatibleTools = probed
.filter(Option.isSome)
.map((tool) => tool.value)
.filter((tool) => tool.supportsDesignGeneration)
.sort((left, right) =>
right.bundleVersion.localeCompare(left.bundleVersion, undefined, { numeric: true }),
);
const newestTool = compatibleTools[0];
if (newestTool) return newestTool;
return yield* new IconExportToolResolutionError({
reason: "not-found",
designGeneration: DESIGN_GENERATION,
});
});
const renderIcon = Effect.fn("iconExport.renderIcon")(function* (
toolPath: string,
sourcePath: string,
outputPath: string,
platform: IconPlatform,
size: number,
) {
const fs = yield* FileSystem.FileSystem;
const args = [
sourcePath,
"--export-image",
"--output-file",
outputPath,
"--platform",
platform,
"--rendition",
"Default",
"--width",
String(size),
"--height",
String(size),
"--scale",
"1",
"--design-generation",
String(DESIGN_GENERATION),
];
const result = yield* runCommand(toolPath, args);
if (result.exitCode !== 0) {
return yield* new IconExportCommandFailedError({
command: toolPath,
argumentCount: args.length,
exitCode: result.exitCode,
sourcePath,
size,
...(result.stdout.trim() ? { stdout: result.stdout.trim() } : {}),
...(result.stderr.trim() ? { stderr: result.stderr.trim() } : {}),
});
}
const contents = yield* fs.readFile(outputPath).pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "read-file",
path: outputPath,
cause,
}),
),
);
const buffer = Buffer.from(contents);
const dimensions = yield* Effect.try({
try: () => readPngDimensions(buffer),
catch: (cause) =>
new IconExportRenditionError({
sourcePath,
outputPath,
expectedSize: size,
cause,
}),
});
if (dimensions.width !== size || dimensions.height !== size) {
return yield* new IconExportRenditionError({
sourcePath,
outputPath,
expectedSize: size,
actualWidth: dimensions.width,
actualHeight: dimensions.height,
});
}
return buffer;
});
const renderVariant = Effect.fn("iconExport.renderVariant")(function* (
toolPath: string,
repositoryRoot: string,
temporaryDirectory: string,
variant: IconVariant,
) {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const sourcePath = path.join(repositoryRoot, variant.source);
const sourceExists = yield* fs.exists(sourcePath).pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "check-path",
path: sourcePath,
cause,
}),
),
);
if (!sourceExists) {
return yield* new IconExportSourceMissingError({ sourcePath: variant.source });
}
const renditionCache = new Map<string, Buffer>();
const render = Effect.fn("iconExport.renderVariant.rendition")(function* (
platform: IconPlatform,
size: number,
) {
const cacheKey = `${platform}-${size}`;
const cached = renditionCache.get(cacheKey);
if (cached) return cached;
const outputPath = path.join(temporaryDirectory, `${variant.label}-${platform}-${size}.png`);
const contents = yield* renderIcon(toolPath, sourcePath, outputPath, platform, size);
renditionCache.set(cacheKey, contents);
return contents;
});
const ios = yield* render("iOS", 1024);
const icoRenditions = yield* Effect.forEach(
WINDOWS_ICON_SIZES,
(size) => render("iOS", size).pipe(Effect.map((contents) => ({ size, contents }))),
{ concurrency: 1 },
);
const ico = yield* Effect.try({
try: () => encodePngIco(icoRenditions),
catch: (cause) => new IconExportEncodingError({ variant: variant.label, cause }),
});
return new Map<string, Buffer>([
[variant.outputs.ios, ios],
[variant.outputs.universal, ios],
[variant.outputs.appleTouch, yield* render("iOS", 180)],
[variant.outputs.webIcon192, yield* render("iOS", 192)],
[variant.outputs.webIcon512, yield* render("iOS", 512)],
[variant.outputs.favicon16, yield* render("iOS", 16)],
[variant.outputs.favicon32, yield* render("iOS", 32)],
[variant.outputs.faviconIco, ico],
[variant.outputs.windowsIco, ico],
]);
});
const writeAtomically = Effect.fn("iconExport.writeAtomically")(function* (
repositoryRoot: string,
relativePath: string,
contents: Buffer,
) {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const targetPath = path.join(repositoryRoot, relativePath);
const targetDirectory = path.dirname(targetPath);
yield* fs.makeDirectory(targetDirectory, { recursive: true }).pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "make-directory",
path: targetDirectory,
cause,
}),
),
);
const temporaryPath = yield* fs
.makeTempFileScoped({
directory: targetDirectory,
prefix: ".t3-icon-export-",
suffix: ".tmp",
})
.pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "make-temp-file",
path: targetDirectory,
cause,
}),
),
);
yield* fs.writeFile(temporaryPath, contents).pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "write-file",
path: temporaryPath,
cause,
}),
),
);
yield* fs.rename(temporaryPath, targetPath).pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "rename-file",
path: targetPath,
cause,
}),
),
);
});
const isCurrent = Effect.fn("iconExport.isCurrent")(function* (
repositoryRoot: string,
relativePath: string,
expected: Buffer,
) {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const targetPath = path.join(repositoryRoot, relativePath);
const exists = yield* fs.exists(targetPath).pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "check-path",
path: targetPath,
cause,
}),
),
);
if (!exists) return false;
const actual = yield* fs.readFile(targetPath).pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "read-file",
path: targetPath,
cause,
}),
),
);
return Buffer.from(actual).equals(expected);
});
export const exportBrandIcons = Effect.fn("exportBrandIcons")(function* (checkOnly: boolean) {
const fs = yield* FileSystem.FileSystem;
const repositoryRoot = yield* RepositoryRoot;
const tool = yield* resolveIconComposerTool();
const temporaryDirectory = yield* fs
.makeTempDirectoryScoped({
prefix: "t3-icon-export-",
})
.pipe(
Effect.mapError(
(cause) =>
new IconExportFileSystemError({
operation: "make-temp-directory",
path: "system temporary directory",
cause,
}),
),
);
yield* Console.log(
`Exporting icons with Icon Composer ${tool.version}, design generation ${DESIGN_GENERATION}.`,
);
const generated = new Map<string, Buffer>();
for (const variant of ICON_VARIANTS) {
yield* Console.log(`Rendering ${variant.label} from ${variant.source}...`);
const variantAssets = yield* renderVariant(
tool.path,
repositoryRoot,
temporaryDirectory,
variant,
);
for (const [relativePath, contents] of variantAssets) {
generated.set(relativePath, contents);
}
}
for (const override of DEVELOPMENT_PUBLIC_ICON_OVERRIDES) {
const sourceContents = generated.get(override.sourceRelativePath);
if (sourceContents === undefined) {
return yield* Effect.die(
new Error(`Generated development web icon is missing: ${override.sourceRelativePath}`),
);
}
generated.set(override.targetRelativePath, sourceContents);
}
if (checkOnly) {
const stale = yield* Effect.filter(
[...generated.entries()],
([relativePath, contents]) =>
isCurrent(repositoryRoot, relativePath, contents).pipe(Effect.map((current) => !current)),
{ concurrency: "unbounded" },
);
if (stale.length > 0) {
return yield* new IconExportAssetsStaleError({
paths: stale.map(([relativePath]) => relativePath),
});
}
yield* Console.log(`All ${generated.size} generated icon assets are current.`);
return;
}
yield* Effect.forEach(
generated,
([relativePath, contents]) => writeAtomically(repositoryRoot, relativePath, contents),
{ concurrency: 1, discard: true },
);
yield* Console.log(`Updated ${generated.size} generated icon assets.`);
});
export const exportBrandIconsCommand = Command.make(
"export-brand-icons",
{
check: Flag.Boolean("check").pipe(
Flag.withDescription("Verify generated icon assets without modifying files."),
Flag.withDefault(false),
),
},
({ check }) => exportBrandIcons(check).pipe(Effect.scoped),
).pipe(
Command.withDescription(
"Export development, preview, and production assets from Icon Composer projects.",
),
);
if (import.meta.main) {
Command.run(exportBrandIconsCommand, { version: "0.0.0" }).pipe(
Effect.provide(NodeServices.layer),
NodeRuntime.runMain,
);
}