@fluid-app/fluid-cli-theme-dev 0.1.21 → 0.1.23

package/src/theme/syncer.ts

@@ -1,338 +0,0 @@
-import { sep } from "node:path";
-import type { ApiClient } from "../api.js";
-import type { ThemeFile } from "./file.js";
-import type { ThemeRoot } from "./root.js";
-import { themes, type components } from "@fluid-app/themes-api-client";
-
-type RemoteResource = components["schemas"]["ApplicationThemeResource"];
-
-export interface SyncResult {
-  uploaded: number;
-  downloaded: number;
-  deleted: number;
-  errors: string[];
-  validationFailed: boolean;
-}
-
-export class Syncer {
-  private checksums = new Map<string, string>();
-
-  constructor(
-    private api: ApiClient,
-    private themeId: number,
-    private themeRoot: ThemeRoot,
-  ) {}
-
-  // ─── Checksum Management ──────────────────────────────────────────────────
-
-  async fetchChecksums(): Promise<void> {
-    const body = await themes.listThemeResources(this.api, this.themeId);
-    this.updateChecksums(body.application_theme_resources ?? []);
-  }
-
-  private updateChecksums(resources: RemoteResource[]): void {
-    for (const r of resources) {
-      if (r.key && r.checksum) this.checksums.set(r.key, r.checksum);
-    }
-    for (const key of this.checksums.keys()) {
-      if (this.checksums.has(`${key}.liquid`)) this.checksums.delete(key);
-    }
-  }
-
-  hasChanged(file: ThemeFile): boolean {
-    return file.checksum() !== this.checksums.get(file.relativePath);
-  }
-
-  remoteKeys(): string[] {
-    return [...this.checksums.keys()];
-  }
-
-  /** Snapshot of remote checksums (key → sha256). Available after fetchChecksums() or downloadAll(). */
-  remoteChecksums(): Record<string, string> {
-    return Object.fromEntries(this.checksums);
-  }
-
-  // ─── Upload ───────────────────────────────────────────────────────────────
-
-  async uploadFile(file: ThemeFile): Promise<void> {
-    if (file.isText) {
-      await themes.updateThemeResource(this.api, this.themeId, {
-        application_theme_resource: {
-          key: file.relativePath,
-          content: file.read(),
-        },
-      });
-    } else {
-      await this.uploadBinaryFile(file);
-    }
-  }
-
-  private async uploadBinaryFile(file: ThemeFile): Promise<void> {
-    // Step 1: Create DAM placeholder
-    const placeholderBody = await this.api.post<{
-      asset: { id: number; canonical_path: string };
-    }>("/api/dam/assets", {
-      placeholder_asset: {
-        description: `Uploaded via Fluid CLI: ${file.name}`,
-        mime_type: file.mime.name,
-        name: file.name,
-      },
-    });
-    const asset = placeholderBody.asset;
-
-    // Step 2: Get ImageKit auth token
-    const authBody = await this.api.post<{
-      token: string;
-      signature: string;
-      expire: number;
-    }>("/api/dam/assets/imagekit_auth", {});
-
-    // Step 3: Upload to ImageKit via multipart
-    const folder = this.canonicalPathToImageKitFolder(asset.canonical_path);
-    const formData = new FormData();
-    const blob = new Blob([file.readBinary() as unknown as ArrayBuffer], {
-      type: file.mime.name,
-    });
-    formData.append("file", blob, file.name);
-    formData.append("token", authBody.token);
-    formData.append("signature", authBody.signature);
-    formData.append("expire", String(authBody.expire));
-    formData.append("folder", folder);
-    formData.append("fileName", file.name);
-    formData.append("publicKey", "public_j7s4Ih9ETh/OCp41mVQH7tlXBdU=");
-
-    const ikResp = await fetch(
-      "https://upload.imagekit.io/api/v1/files/upload",
-      {
-        method: "POST",
-        body: formData,
-      },
-    );
-    if (!ikResp.ok) throw new Error(`ImageKit upload failed: ${ikResp.status}`);
-    const ikBody = (await ikResp.json()) as {
-      fileId: string;
-      url: string;
-      thumbnailUrl: string;
-      size: number;
-      height?: number;
-      width?: number;
-    };
-
-    // Step 4: Backfill DAM asset
-    const backfillPayload: Record<string, unknown> = {
-      asset: {
-        id: asset.id,
-        imagekit_file_id: ikBody.fileId,
-        imagekit_url: ikBody.url,
-        mime_type: file.mime.name,
-        name: file.name,
-        file_size: ikBody.size,
-        expected_path: asset.canonical_path,
-      },
-    };
-    if (ikBody.height)
-      (backfillPayload["asset"] as Record<string, unknown>)["height"] =
-        ikBody.height;
-    if (ikBody.width)
-      (backfillPayload["asset"] as Record<string, unknown>)["width"] =
-        ikBody.width;
-
-    const backfillBody = await this.api.post<{
-      asset: { code: string; default_variant_url: string };
-    }>("/api/dam/assets/backfill_imagekit", backfillPayload);
-
-    // Step 5: Associate with theme resource
-    await themes.updateThemeResource(this.api, this.themeId, {
-      application_theme_resource: {
-        key: file.relativePath,
-        dam_asset: {
-          dam_asset_code: backfillBody.asset.code,
-          content_type: file.mime.name,
-          content_size: ikBody.size,
-          filename: file.name,
-          handle: backfillBody.asset.code,
-          url: backfillBody.asset.default_variant_url,
-          preview_image_url: ikBody.thumbnailUrl,
-        },
-      },
-    });
-  }
-
-  private canonicalPathToImageKitFolder(canonicalPath: string): string {
-    const parts = canonicalPath.split(".");
-    const companyId = parts[0] ?? "unknown";
-    const category = parts[1] ?? "files";
-    const assetCode = parts[2] ?? "unknown";
-    const folderMap: Record<string, string> = {
-      images: "images",
-      videos: "videos",
-      audio: "audio",
-      documents: "documents",
-      files: "files",
-    };
-    return `${companyId}/${folderMap[category] ?? "files"}/${assetCode}`;
-  }
-
-  // ─── Delete ───────────────────────────────────────────────────────────────
-
-  async deleteRemoteFile(relativePath: string): Promise<void> {
-    await themes.deleteThemeResource(this.api, this.themeId, {
-      application_theme_resource: { key: relativePath },
-    });
-    this.checksums.delete(relativePath);
-  }
-
-  // ─── Download ─────────────────────────────────────────────────────────────
-
-  async downloadAll(): Promise<RemoteResource[]> {
-    const body = await themes.listThemeResources(this.api, this.themeId);
-    const resources = body.application_theme_resources ?? [];
-    this.updateChecksums(resources);
-    return resources;
-  }
-
-  async downloadBinaryAsset(url: string): Promise<Buffer> {
-    const resp = await fetch(url);
-    if (!resp.ok) throw new Error(`Failed to download asset: ${resp.status}`);
-    return Buffer.from(await resp.arrayBuffer());
-  }
-
-  // ─── Full Upload ──────────────────────────────────────────────────────────
-
-  async uploadTheme(
-    opts: {
-      delete?: boolean;
-      validate?: boolean;
-      onProgress?: (done: number, total: number) => void;
-    } = {},
-  ): Promise<SyncResult> {
-    await this.fetchChecksums();
-
-    const localFiles = this.themeRoot.files();
-    const result: SyncResult = {
-      uploaded: 0,
-      deleted: 0,
-      downloaded: 0,
-      errors: [],
-      validationFailed: false,
-    };
-
-    // Schema validation pass
-    if (opts.validate) {
-      for (const file of localFiles) {
-        if (!file.isLiquid) continue;
-        const diagnostics = file.validateSchema();
-        const errors = diagnostics.filter((d) => d.severity === "error");
-        for (const d of errors) {
-          result.errors.push(`${file.relativePath}: ${d.message}`);
-        }
-      }
-      if (result.errors.length > 0) {
-        result.validationFailed = true;
-        return result;
-      }
-    }
-
-    const toUpload = localFiles.filter((f) => f.exists && this.hasChanged(f));
-    let done = 0;
-    for (const file of toUpload) {
-      try {
-        await this.uploadFile(file);
-        result.uploaded++;
-      } catch (e) {
-        result.errors.push(`Upload ${file.relativePath}: ${e}`);
-      }
-      opts.onProgress?.(++done, toUpload.length);
-    }
-
-    if (opts.delete) {
-      const localPaths = new Set(localFiles.map((f) => f.relativePath));
-      const toDelete = this.remoteKeys().filter((k) => !localPaths.has(k));
-      for (const key of toDelete) {
-        try {
-          await this.deleteRemoteFile(key);
-          result.deleted++;
-        } catch (e) {
-          result.errors.push(`Delete ${key}: ${e}`);
-        }
-      }
-    }
-
-    return result;
-  }
-
-  // ─── Full Download ────────────────────────────────────────────────────────
-
-  async downloadTheme(
-    opts: {
-      delete?: boolean;
-      skip?: Set<string>;
-      onProgress?: (done: number, total: number) => void;
-    } = {},
-  ): Promise<SyncResult & { skipped: number }> {
-    const resources = await this.downloadAll();
-    const result: SyncResult & { skipped: number } = {
-      uploaded: 0,
-      deleted: 0,
-      downloaded: 0,
-      skipped: 0,
-      errors: [],
-      validationFailed: false,
-    };
-
-    let done = 0;
-    for (const resource of resources) {
-      if (opts.skip?.has(resource.key)) {
-        result.skipped++;
-        opts.onProgress?.(++done, resources.length);
-        continue;
-      }
-
-      const file = this.themeRoot.file(resource.key);
-
-      // Guard against path traversal from malicious API responses
-      if (!file.absolutePath.startsWith(this.themeRoot.root + sep)) {
-        result.errors.push(`Download ${resource.key}: path traversal detected`);
-        opts.onProgress?.(++done, resources.length);
-        continue;
-      }
-
-      try {
-        if (resource.resource_type === "FileResource" && resource.url) {
-          const buf = await this.downloadBinaryAsset(resource.url);
-          file.write(buf);
-        } else if (
-          resource.content !== undefined &&
-          resource.content !== null
-        ) {
-          const content =
-            typeof resource.content === "string"
-              ? resource.content
-              : JSON.stringify(resource.content);
-          file.write(content);
-        }
-        result.downloaded++;
-      } catch (e) {
-        result.errors.push(`Download ${resource.key}: ${e}`);
-      }
-      opts.onProgress?.(++done, resources.length);
-    }
-
-    if (opts.delete) {
-      const remoteKeys = new Set(resources.map((r) => r.key));
-      for (const file of this.themeRoot.files()) {
-        if (!remoteKeys.has(file.relativePath)) {
-          try {
-            const { unlinkSync } = await import("node:fs");
-            unlinkSync(file.absolutePath);
-            result.deleted++;
-          } catch {
-            // ignore
-          }
-        }
-      }
-    }
-
-    return result;
-  }
-}

package/src/theme-config.ts

@@ -1,34 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-export interface ThemeConfig {
-  themeId: number;
-  themeName: string;
-  company: string;
-  lastPulledAt: string | null;
-  checksums: Record<string, string>;
-}
-
-const CONFIG_FILE = ".fluid-theme.json";
-
-function configPath(themeRoot: string): string {
-  return join(themeRoot, CONFIG_FILE);
-}
-
-/** Read `.fluid-theme.json` from a theme directory, or null if it doesn't exist. */
-export function readThemeConfig(themeRoot: string): ThemeConfig | null {
-  const path = configPath(themeRoot);
-  if (!existsSync(path)) return null;
-  try {
-    const raw = readFileSync(path, "utf-8");
-    return JSON.parse(raw) as ThemeConfig;
-  } catch {
-    return null;
-  }
-}
-
-/** Write `.fluid-theme.json` to a theme directory. */
-export function writeThemeConfig(themeRoot: string, config: ThemeConfig): void {
-  const path = configPath(themeRoot);
-  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", "utf-8");
-}

package/src/theme-picker.ts

@@ -1,164 +0,0 @@
-import chalk from "chalk";
-import prompts from "prompts";
-import type { createApiClient } from "./api.js";
-import { themes, type components } from "@fluid-app/themes-api-client";
-
-export type ApplicationTheme = components["schemas"]["ApplicationTheme"];
-
-const PAGE_SIZE = 50;
-const LOAD_MORE_VALUE = -1;
-
-function themeLabel(t: ApplicationTheme): string {
-  const active = t.status === "active" ? ` ${chalk.green("[active]")}` : "";
-  return `${t.name} (#${t.id})${active}`;
-}
-
-function themeChoices(
-  themeList: ApplicationTheme[],
-  hasMore: boolean,
-): prompts.Choice[] {
-  const choices: prompts.Choice[] = themeList.map((t) => ({
-    title: themeLabel(t),
-    value: t.id,
-  }));
-  if (hasMore) {
-    choices.push({
-      title: chalk.dim(`── Load more themes ──`),
-      value: LOAD_MORE_VALUE,
-    });
-  }
-  return choices;
-}
-
-async function fetchThemesPage(
-  api: ReturnType<typeof createApiClient>,
-  page: number,
-  searchQuery?: string,
-): Promise<{
-  themes: ApplicationTheme[];
-  hasMore: boolean;
-}> {
-  const body = await themes.listApplicationThemes(api, {
-    per_page: PAGE_SIZE,
-    page,
-    ...(searchQuery ? { search_query: searchQuery } : {}),
-  });
-  const list = body.application_themes ?? [];
-  const totalPages = body.meta?.total_pages ?? 1;
-  return { themes: list, hasMore: page < totalPages };
-}
-
-export async function selectTheme(
-  api: ReturnType<typeof createApiClient>,
-  message: string,
-): Promise<ApplicationTheme> {
-  const allThemes: ApplicationTheme[] = [];
-  let page = 1;
-  let hasMore = true;
-  let initialIndex = 0;
-
-  // Search cache — persists across suggest calls
-  let searchQuery = "";
-  let searchResults: ApplicationTheme[] = [];
-
-  while (true) {
-    if (hasMore && allThemes.length < page * PAGE_SIZE) {
-      const result = await fetchThemesPage(api, page);
-      allThemes.push(...result.themes);
-      hasMore = result.hasMore;
-    }
-
-    if (!allThemes.length) {
-      console.error("No themes found.");
-      process.exit(1);
-    }
-
-    const choices = themeChoices(allThemes, hasMore);
-
-    const { id } = await prompts(
-      {
-        type: "autocomplete",
-        name: "id",
-        message,
-        initial: initialIndex,
-        choices,
-        suggest: async (input: string, choices: prompts.Choice[]) => {
-          if (!input) {
-            searchQuery = "";
-            searchResults = [];
-            return choices;
-          }
-
-          if (input !== searchQuery) {
-            searchQuery = input;
-            try {
-              const result = await fetchThemesPage(api, 1, input);
-              searchResults = result.themes;
-            } catch {
-              searchResults = [];
-            }
-          }
-
-          return searchResults.map((t) => ({
-            title: themeLabel(t),
-            value: t.id,
-          }));
-        },
-      },
-      { onCancel: () => process.exit(130) },
-    );
-
-    if (id === LOAD_MORE_VALUE) {
-      initialIndex = allThemes.length;
-      page++;
-      continue;
-    }
-
-    if (!id) {
-      console.error("No theme selected.");
-      process.exit(1);
-    }
-
-    // Check loaded themes first, then search results
-    const found =
-      allThemes.find((t) => t.id === id) ??
-      searchResults.find((t) => t.id === id);
-    if (found) return found;
-
-    // Fetch directly by ID as fallback
-    const body = await themes.getApplicationTheme(api, id);
-    return body.application_theme;
-  }
-}
-
-export async function findTheme(
-  api: ReturnType<typeof createApiClient>,
-  identifier: string,
-): Promise<ApplicationTheme> {
-  // Try ID lookup first
-  const idNum = Number(identifier);
-  if (Number.isInteger(idNum) && idNum > 0) {
-    try {
-      const body = await themes.getApplicationTheme(api, idNum);
-      if (body.application_theme) return body.application_theme;
-    } catch {
-      // Not found by ID, fall through to search
-    }
-  }
-
-  // Search by name via API with pagination
-  let page = 1;
-  let hasMore = true;
-  while (hasMore) {
-    const result = await fetchThemesPage(api, page, identifier);
-    const found = result.themes.find(
-      (t) => t.name.toLowerCase() === identifier.toLowerCase(),
-    );
-    if (found) return found;
-    hasMore = result.hasMore;
-    page++;
-  }
-
-  console.error(`No theme found with identifier: ${identifier}`);
-  process.exit(1);
-}

package/src/workspace.ts

@@ -1,71 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, relative, resolve, sep } from "node:path";
-
-export interface FluidWorkspace {
-  /** Absolute path to the workspace root (where .fluid-workspace.json lives) */
-  root: string;
-  /** Parsed workspace config */
-  config: WorkspaceConfig;
-}
-
-interface WorkspaceConfig {
-  type: string;
-  version: number;
-}
-
-const WORKSPACE_FILE = ".fluid-workspace.json";
-
-/**
- * Walk up from `startDir` looking for `.fluid-workspace.json`.
- * Returns the workspace info if found, or `null` if not in a workspace.
- */
-export function findWorkspace(startDir?: string): FluidWorkspace | null {
-  let dir = resolve(startDir ?? process.cwd());
-
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    const candidate = join(dir, WORKSPACE_FILE);
-    if (existsSync(candidate)) {
-      try {
-        const raw = readFileSync(candidate, "utf-8");
-        const config = JSON.parse(raw) as WorkspaceConfig;
-        return { root: dir, config };
-      } catch {
-        return null;
-      }
-    }
-    const parent = dirname(dir);
-    if (parent === dir) break; // reached filesystem root
-    dir = parent;
-  }
-
-  return null;
-}
-
-/**
- * If cwd is already inside `{workspace}/local/{company}/...`, return that
- * theme root directory. Otherwise return null.
- *
- * Examples (workspace root = /code/fluid-theme-dev):
- *   cwd = /code/fluid-theme-dev/local/acme-co           → /code/fluid-theme-dev/local/acme-co
- *   cwd = /code/fluid-theme-dev/local/acme-co/templates  → /code/fluid-theme-dev/local/acme-co
- *   cwd = /code/fluid-theme-dev                          → null
- *   cwd = /code/fluid-theme-dev/local                    → null
- */
-export function resolveThemeRootFromCwd(
-  workspace: FluidWorkspace,
-): string | null {
-  const cwd = resolve(process.cwd());
-  const localDir = join(workspace.root, "local");
-  const rel = relative(localDir, cwd);
-
-  // Not under local/ at all, or exactly at local/
-  if (rel.startsWith("..") || rel === ".") return null;
-
-  // rel is like "acme-co" or "acme-co/templates/subfolder"
-  // The theme root is the first segment: local/{company}
-  const firstSegment = rel.split(sep)[0];
-  if (!firstSegment) return null;
-
-  return join(localDir, firstSegment);
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "@fluid-app/typescript-config/base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "incremental": false
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsdown.config.ts

@@ -1,19 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export default defineConfig({
-  entry: { index: "src/index.ts" },
-  format: ["esm"],
-  dts: { eager: true },
-  clean: true,
-  target: "node24",
-  deps: {
-    neverBundle: [
-      "@fluid-app/fluid-cli",
-      "commander",
-      "chokidar",
-      "open",
-      "ora",
-      "prompts",
-    ],
-  },
-});