@sleekcms/sync 1.0.0

package/dist/cli.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * CLI setup, prompts, and UI for the CMS CLI
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.prompt = prompt;
+exports.showWatchHelp = showWatchHelp;
+exports.setupKeyboardInput = setupKeyboardInput;
+exports.showEditorMenu = showEditorMenu;
+const readline_1 = __importDefault(require("readline"));
+const child_process_1 = require("child_process");
+const commander_1 = require("commander");
+let rawModeEnabled = false;
+function parseArgs() {
+    commander_1.program
+        .name("cms-sync")
+        .description("SleekCMS CLI tool to sync and edit CMS templates locally. Downloads templates, watches for changes, and syncs updates back to the API.")
+        .addOption(new commander_1.Option("-v, --version", "output the version number").hideHelp())
+        .option("-t, --token <token>", "API authentication token (required)")
+        .addOption(new commander_1.Option("-e, --env <env>", "Environment (localhost, development, production)").default("production").hideHelp())
+        .option("-p, --path <path>", "Directory path for files (default: <token-prefix>-views)")
+        .addHelpText("after", `
+Examples:
+  $ cms-sync --token abc123-xxxx
+  $ cms-sync -t abc123-xxxx -e development
+  $ cms-sync -t abc123-xxxx -p ./my-templates
+`)
+        .parse(process.argv);
+    return commander_1.program.opts();
+}
+function suspendRawMode() {
+    if (process.stdin.isTTY && rawModeEnabled) {
+        process.stdin.setRawMode(false);
+    }
+}
+function resumeRawMode() {
+    if (process.stdin.isTTY && rawModeEnabled) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+    }
+}
+function prompt(question) {
+    suspendRawMode();
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resumeRawMode();
+            resolve(answer.trim());
+        });
+    });
+}
+function commandExists(cmd) {
+    try {
+        (0, child_process_1.execSync)(`which ${cmd}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function showWatchHelp() {
+    console.log("📋 Commands: [r] Re-fetch all files  [x] Exit\n");
+}
+function setupKeyboardInput(handlers) {
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        rawModeEnabled = true;
+    }
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", async (key) => {
+        // Handle Ctrl+C
+        if (key === "\u0003") {
+            if (handlers.onExit)
+                await handlers.onExit();
+            return;
+        }
+        const cmd = key.toLowerCase();
+        if (cmd === "r" && handlers.onRefetch) {
+            console.log("\n🔄 Re-fetching all files...");
+            await handlers.onRefetch();
+            console.log("👀 Watching for changes...");
+            showWatchHelp();
+        }
+        else if (cmd === "x" && handlers.onExit) {
+            await handlers.onExit();
+        }
+    });
+}
+function showEditorMenu(viewsDir, handlers) {
+    const editors = [];
+    if (commandExists("code")) {
+        editors.push({ key: "1", name: "VS Code", cmd: "code" });
+    }
+    if (commandExists("cursor")) {
+        editors.push({ key: "2", name: "Cursor", cmd: "cursor" });
+    }
+    if (editors.length === 0) {
+        console.log("\n👀 Watching for changes...");
+        showWatchHelp();
+        setupKeyboardInput(handlers);
+        return;
+    }
+    console.log("\n📂 Open in editor:");
+    editors.forEach(e => console.log(`   [${e.key}] ${e.name}`));
+    console.log("   [Enter] Skip");
+    console.log("   [x] Quit\n");
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    // Count lines to clear (menu header + editors + skip + quit + empty + prompt)
+    const linesToClear = editors.length + 5;
+    rl.question("Select editor: ", async (answer) => {
+        rl.close();
+        // Clear the menu lines
+        process.stdout.write(`\x1b[${linesToClear}A`); // Move cursor up
+        for (let i = 0; i < linesToClear; i++) {
+            process.stdout.write("\x1b[2K\n"); // Clear each line
+        }
+        process.stdout.write(`\x1b[${linesToClear}A`); // Move back up
+        if (answer.trim().toLowerCase() === "x") {
+            if (handlers.onExit)
+                await handlers.onExit();
+            return;
+        }
+        const selected = editors.find(e => e.key === answer.trim());
+        if (selected) {
+            console.log(`👀 Watching for changes... (opened ${selected.name})`);
+            (0, child_process_1.spawn)(selected.cmd, ["-n", viewsDir], {
+                detached: true,
+                stdio: "ignore",
+            }).unref();
+        }
+        else {
+            console.log("👀 Watching for changes...");
+        }
+        showWatchHelp();
+        setupKeyboardInput(handlers);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * SleekCMS CLI — interactive entry point.
+ *
+ * Handles CLI prompts, editor launch, and file watching. All sync work
+ * (fetch, push, pull, cache) is delegated to setup-site.ts so the same
+ * logic can be invoked standalone (e.g. as a skill for managed agents).
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * SleekCMS CLI — interactive entry point.
+ *
+ * Handles CLI prompts, editor launch, and file watching. All sync work
+ * (fetch, push, pull, cache) is delegated to setup-site.ts so the same
+ * logic can be invoked standalone (e.g. as a skill for managed agents).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cli = __importStar(require("./cli"));
+const watcher = __importStar(require("./watcher"));
+const setup_site_1 = require("./setup-site");
+const agentMdContent = fs_extra_1.default.readFileSync(path_1.default.join(__dirname, "AGENT.md"), "utf-8");
+const options = cli.parseArgs();
+if (options.version) {
+    // package.json sits one directory above the compiled output
+    const pkg = require("../package.json");
+    console.log(pkg.version);
+    process.exit(0);
+}
+let VIEWS_DIR = null;
+let ENV = null;
+let TOKEN = null;
+let site = null;
+let isShuttingDown = false;
+async function cleanupFiles(dir) {
+    if (!dir)
+        return;
+    console.log("🧹 Cleaning up files...");
+    try {
+        await fs_extra_1.default.remove(dir);
+        console.log(`✅ Cleanup complete. Deleted workspace at ${dir}.`);
+    }
+    catch (err) {
+        const e = err;
+        console.error("❌ Error during cleanup:", e.message);
+    }
+}
+async function runSync({ flush = false } = {}) {
+    const result = await (0, setup_site_1.syncSite)({
+        token: TOKEN,
+        viewsDir: VIEWS_DIR ?? undefined,
+        path: VIEWS_DIR ? undefined : options.path,
+        env: ENV ?? undefined,
+        agentMd: agentMdContent,
+        flush,
+    });
+    VIEWS_DIR = result.viewsDir;
+    site = result.site;
+    return result;
+}
+async function initConfig() {
+    TOKEN = options.token ?? null;
+    if (!TOKEN) {
+        TOKEN = await cli.prompt("Enter SleekCMS CLI auth token: ");
+        if (!TOKEN) {
+            console.error("❌ Token is required.");
+            process.exit(1);
+        }
+    }
+    const tokenParts = TOKEN.trim().split("-");
+    ENV = (tokenParts[2] || options.env || "production").toLowerCase();
+    let customPath = options.path;
+    if (customPath && customPath.startsWith("~")) {
+        customPath = path_1.default.join(os_1.default.homedir(), customPath.slice(1));
+    }
+    options.path = customPath;
+}
+async function handleExit() {
+    if (isShuttingDown)
+        return;
+    isShuttingDown = true;
+    watcher.setShuttingDown(true);
+    console.log("\n⚠️ Shutting down...");
+    await watcher.stopWatching();
+    await cleanupFiles(VIEWS_DIR);
+    process.exit(0);
+}
+async function main() {
+    await initConfig();
+    try {
+        await runSync();
+    }
+    catch (err) {
+        const e = err;
+        console.error("❌ Sync failed:", e.body || e.message);
+        process.exit(1);
+    }
+    watcher.init({ viewsDir: VIEWS_DIR, onSync: runSync });
+    watcher.monitorFiles();
+    console.log(`\n✅ Ready! Editing session started for site - ${site.name}.`);
+    console.log(`\n📁 Workspace created at: ${VIEWS_DIR}`);
+    if (ENV !== "production")
+        console.log(`🌐 Environment: ${ENV}`);
+    console.log(`\n⚠️  Files will be cleaned up on exit (Ctrl+C).`);
+    cli.showEditorMenu(VIEWS_DIR, {
+        onExit: handleExit,
+        onRefetch: () => runSync({ flush: true }),
+    });
+    process.on("SIGINT", async () => {
+        console.log("\n🛑 Caught interrupt signal (Ctrl+C)");
+        await handleExit();
+    });
+    process.on("SIGTERM", async () => {
+        console.log("\n🛑 Caught termination signal");
+        await handleExit();
+    });
+}
+main();

package/dist/setup-site.d.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+/**
+ * SleekCMS site sync — standalone, self-contained.
+ *
+ * Bi-directional sync between a local workspace and the SleekCMS server.
+ * Safe to invoke repeatedly: a `.cache/state.json` inside the workspace
+ * tracks server-known state so only real diffs are pushed.
+ */
+export interface Site {
+    id: number;
+    name: string;
+    [key: string]: unknown;
+}
+export interface SyncSiteOptions {
+    token: string;
+    viewsDir?: string;
+    path?: string;
+    env?: string;
+    agentMd?: string;
+    flush?: boolean;
+}
+export interface SyncSiteResult {
+    viewsDir: string;
+    site: Site;
+    isFirstRun: boolean;
+    pushed: number;
+    pulled: number;
+}
+export declare function resolveViewsDir(basePath: string | undefined, site: Site): string;
+export declare function syncSite(opts: SyncSiteOptions): Promise<SyncSiteResult>;

package/dist/setup-site.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * SleekCMS site sync — standalone, self-contained.
+ *
+ * Bi-directional sync between a local workspace and the SleekCMS server.
+ * Safe to invoke repeatedly: a `.cache/state.json` inside the workspace
+ * tracks server-known state so only real diffs are pushed.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveViewsDir = resolveViewsDir;
+exports.syncSite = syncSite;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const API_BASE_URLS = {
+    localhost: "http://app.sleekcms.test/api/mcp",
+    development: "https://app.sleekcms.dev/api/mcp",
+    production: "https://app.sleekcms.com/api/mcp",
+};
+const SRC_DIRS = [
+    "src/views/blocks",
+    "src/views/entries",
+    "src/views/pages",
+    "src/views/layouts",
+    "src/models/blocks",
+    "src/models/entries",
+    "src/models/pages",
+    "src/content/pages",
+    "src/content/entries",
+    "src/public/js",
+    "src/public/css",
+];
+class RequestError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+    }
+}
+async function request(baseUrl, token, method, p, body) {
+    const res = await fetch(baseUrl + p, {
+        method,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            ...(body !== undefined ? { "Content-Type": "application/json" } : {}),
+        },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new RequestError(`${method} ${p} → ${res.status}: ${text}`, res.status, text);
+    }
+    return res.json();
+}
+async function writeAuxFiles(viewsDir, agentMdContent) {
+    if (agentMdContent) {
+        await fs_extra_1.default.outputFile(path_1.default.join(viewsDir, "AGENT.md"), agentMdContent);
+        await fs_extra_1.default.outputFile(path_1.default.join(viewsDir, "CLAUDE.md"), agentMdContent);
+        await fs_extra_1.default.outputFile(path_1.default.join(viewsDir, ".vscode", "copilot-instructions.md"), agentMdContent);
+    }
+    await fs_extra_1.default.outputFile(path_1.default.join(viewsDir, ".vscode", "settings.json"), JSON.stringify({
+        "files.associations": { "*.model": "javascript" },
+        "[javascript]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
+        "js/ts.validate.enabled": false,
+    }, null, 2));
+}
+async function checkAndWriteToken(viewsDir, token) {
+    const tokenPath = path_1.default.join(viewsDir, ".cache", "token");
+    if (await fs_extra_1.default.pathExists(tokenPath)) {
+        const existing = (await fs_extra_1.default.readFile(tokenPath, "utf-8")).trim();
+        if (existing !== token) {
+            throw new Error(`Workspace at ${viewsDir} is tied to a different token. ` +
+                `Remove ${tokenPath} or use a different workspace.`);
+        }
+        return;
+    }
+    await fs_extra_1.default.outputFile(tokenPath, token);
+}
+function resolveViewsDir(basePath, site) {
+    const slug = `${site.name.substr(0, 20)} ${site.id}`
+        .replace(/[\s_]+/g, "-")
+        .toLowerCase();
+    const base = basePath || path_1.default.join(os_1.default.homedir(), ".sleekcms");
+    return path_1.default.resolve(base, slug);
+}
+async function syncSite(opts) {
+    const token = (opts.token || "").trim();
+    if (!token)
+        throw new Error("syncSite: token is required");
+    const env = (opts.env || token.split("-")[2] || "production").toLowerCase();
+    const apiBase = API_BASE_URLS[env] || API_BASE_URLS.production;
+    const site = await request(apiBase, token, "GET", "/get_site");
+    const viewsDir = opts.viewsDir
+        ? path_1.default.resolve(opts.viewsDir)
+        : resolveViewsDir(opts.path, site);
+    await fs_extra_1.default.ensureDir(viewsDir);
+    await Promise.all(SRC_DIRS.map((dir) => fs_extra_1.default.ensureDir(path_1.default.join(viewsDir, dir))));
+    await checkAndWriteToken(viewsDir, token);
+    const statePath = path_1.default.join(viewsDir, ".cache", "state.json");
+    if (opts.flush)
+        await fs_extra_1.default.remove(statePath);
+    const isFirstRun = !(await fs_extra_1.default.pathExists(statePath));
+    let fileMap = isFirstRun ? {} : (await fs_extra_1.default.readJson(statePath)).fileMap || {};
+    let pushed = 0;
+    let pulled = 0;
+    if (isFirstRun) {
+        ({ fileMap, pulled } = await pullServerState(viewsDir, apiBase, token));
+        await writeAuxFiles(viewsDir, opts.agentMd);
+    }
+    else {
+        pushed = await pushLocalChanges(viewsDir, fileMap, apiBase, token);
+    }
+    await fs_extra_1.default.outputJson(statePath, { fileMap }, { spaces: 2 });
+    return { viewsDir, site, isFirstRun, pushed, pulled };
+}
+async function walkFiles(viewsDir) {
+    const sourceRoot = path_1.default.join(viewsDir, "src");
+    if (!(await fs_extra_1.default.pathExists(sourceRoot)))
+        return [];
+    const out = [];
+    async function walk(dir) {
+        const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory())
+                await walk(full);
+            else if (entry.isFile())
+                out.push(path_1.default.relative(viewsDir, full).replace(/\\/g, "/"));
+        }
+    }
+    await walk(sourceRoot);
+    return out;
+}
+/**
+ * Push local edits via /save_files. Server enforces save order.
+ *
+ * Skip: file mtime matches cache → don't read, don't push.
+ * After save, only overwrite the local file if its mtime is unchanged from
+ * when we read it — otherwise a newer local edit is pending and we'd clobber it.
+ */
+async function pushLocalChanges(viewsDir, fileMap, apiBase, token) {
+    const changes = [];
+    for (const rel of await walkFiles(viewsDir)) {
+        const full = path_1.default.join(viewsDir, rel);
+        const prior = fileMap[rel];
+        const stat = await fs_extra_1.default.stat(full);
+        if (prior && prior.mtimeMs === stat.mtimeMs)
+            continue;
+        const content = await fs_extra_1.default.readFile(full, "utf-8");
+        if (!content.trim())
+            continue;
+        changes.push({ rel, full, stat, content, prior });
+    }
+    if (changes.length === 0)
+        return 0;
+    let results;
+    try {
+        results = await request(apiBase, token, "POST", "/save_files", changes.map((c) => ({ path: c.rel, content: c.content })));
+    }
+    catch (err) {
+        const e = err;
+        console.error("❌ Error saving files:", e.body || e.message);
+        return 0;
+    }
+    const errors = await loadErrors(viewsDir);
+    let pushed = 0;
+    for (let i = 0; i < changes.length; i++) {
+        const c = changes[i];
+        const r = results[i] || {};
+        if (r.error) {
+            errors[c.rel] = r.error;
+            console.error(`❌ Error saving ${c.rel}: ${r.error}`);
+            continue;
+        }
+        delete errors[c.rel];
+        const finalContent = r.content ?? c.content;
+        let finalMtime = c.stat.mtimeMs;
+        const currentStat = await fs_extra_1.default.stat(c.full);
+        if (currentStat.mtimeMs === c.stat.mtimeMs && finalContent !== c.content) {
+            await fs_extra_1.default.outputFile(c.full, finalContent);
+            finalMtime = (await fs_extra_1.default.stat(c.full)).mtimeMs;
+        }
+        fileMap[c.rel] = { mtimeMs: finalMtime };
+        console.log(`✅ ${c.prior ? "Updated" : "Created"} ${c.rel}`);
+        pushed++;
+    }
+    await saveErrors(viewsDir, errors);
+    return pushed;
+}
+const ERROR_LOG = "sync-errors.log";
+async function loadErrors(viewsDir) {
+    const file = path_1.default.join(viewsDir, ERROR_LOG);
+    if (!(await fs_extra_1.default.pathExists(file)))
+        return {};
+    const text = await fs_extra_1.default.readFile(file, "utf-8");
+    const errors = {};
+    for (const line of text.split("\n")) {
+        const idx = line.indexOf(": ");
+        if (idx > 0)
+            errors[line.slice(0, idx)] = line.slice(idx + 2);
+    }
+    return errors;
+}
+async function saveErrors(viewsDir, errors) {
+    const file = path_1.default.join(viewsDir, ERROR_LOG);
+    const entries = Object.entries(errors);
+    if (entries.length === 0) {
+        await fs_extra_1.default.remove(file);
+        return;
+    }
+    await fs_extra_1.default.outputFile(file, entries.map(([p, msg]) => `${p}: ${msg}`).join("\n") + "\n");
+}
+async function pullServerState(viewsDir, apiBase, token) {
+    console.log("📥 Fetching files...");
+    const files = await request(apiBase, token, "GET", "/get_files");
+    const fileMap = {};
+    let pulled = 0;
+    for (const file of files) {
+        const full = path_1.default.join(viewsDir, file.path);
+        await fs_extra_1.default.outputFile(full, file.content);
+        const mtimeMs = (await fs_extra_1.default.stat(full)).mtimeMs;
+        pulled++;
+        fileMap[file.path] = { mtimeMs };
+    }
+    console.log(`✔️ Synced ${files.length} file(s).`);
+    return { fileMap, pulled };
+}
+if (require.main === module) {
+    commander_1.program
+        .name("setup-site")
+        .description("Initialize a SleekCMS workspace: pull all files and persist the auth token for future syncs.")
+        .requiredOption("-t, --token <token>", "SleekCMS CLI auth token")
+        .option("-d, --dir <dir>", "Parent directory; workspace is created as a slug-named subfolder (default: current directory)")
+        .option("-e, --env <env>", "Environment override (localhost, development, production)")
+        .parse(process.argv);
+    const opts = commander_1.program.opts();
+    syncSite({
+        token: opts.token,
+        path: opts.dir || path_1.default.join(os_1.default.homedir(), ".sleekcms"),
+        env: opts.env,
+    })
+        .then(({ viewsDir, site, isFirstRun, pulled }) => {
+        if (isFirstRun) {
+            console.log(`\n✅ Workspace initialized for "${site.name}" at ${viewsDir} (pulled ${pulled} file(s)).`);
+        }
+        else {
+            console.log(`\n✅ Workspace already initialized for "${site.name}" at ${viewsDir}.`);
+        }
+        console.log(`\nNext: cd ${viewsDir}  →  edit files  →  run sync-site`);
+    })
+        .catch((err) => {
+        console.error("❌", err.body || err.message);
+        process.exit(1);
+    });
+}

package/dist/sync-site.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * SleekCMS site sync — thin wrapper.
+ *
+ * Reads the auth token from <workspace>/.cache/token (written by setup-site)
+ * and pushes local changes to the server.
+ *
+ * Usage: sync-site [-d <workspace-dir>]
+ *   -d defaults to the current directory.
+ *
+ * To initialize a new workspace for the first time, run setup-site instead:
+ *   setup-site -t <token> [-d <parent-dir>]
+ */
+export {};

package/dist/sync-site.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * SleekCMS site sync — thin wrapper.
+ *
+ * Reads the auth token from <workspace>/.cache/token (written by setup-site)
+ * and pushes local changes to the server.
+ *
+ * Usage: sync-site [-d <workspace-dir>]
+ *   -d defaults to the current directory.
+ *
+ * To initialize a new workspace for the first time, run setup-site instead:
+ *   setup-site -t <token> [-d <parent-dir>]
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const setup_site_1 = require("./setup-site");
+commander_1.program
+    .name("sync-site")
+    .description("Push local changes to SleekCMS. Reads auth token from <workspace>/.cache/token.")
+    .option("-d, --dir <dir>", "Workspace directory (default: current directory)")
+    .parse(process.argv);
+const opts = commander_1.program.opts();
+const workspaceDir = path_1.default.resolve(opts.dir || ".");
+const tokenPath = path_1.default.join(workspaceDir, ".cache", "token");
+fs_extra_1.default.readFile(tokenPath, "utf-8")
+    .then(raw => {
+    const token = raw.trim();
+    if (!token)
+        throw new Error(`Token file is empty: ${tokenPath}`);
+    return (0, setup_site_1.syncSite)({ token, viewsDir: workspaceDir });
+})
+    .then(({ viewsDir, site, pushed }) => {
+    console.log(`\n✅ Sync complete for "${site.name}" at ${viewsDir} (pushed ${pushed} file(s)).`);
+})
+    .catch((err) => {
+    if (err.code === "ENOENT") {
+        console.error(`❌ Workspace not initialized — run: setup-site -t <token>`);
+    }
+    else {
+        console.error("❌", err.body || err.message);
+    }
+    process.exit(1);
+});

package/dist/watcher.d.ts

@@ -0,0 +1,17 @@
+/**
+ * File watching + debounced sync trigger.
+ *
+ * All push/pull logic lives in setup-site.ts. This module only:
+ *   - watches the workspace with chokidar
+ *   - debounces change events
+ *   - calls back into a provided `onSync` handler that invokes syncSite()
+ */
+interface WatcherOptions {
+    viewsDir: string;
+    onSync: () => Promise<unknown>;
+}
+export declare function init(options: WatcherOptions): void;
+export declare function setShuttingDown(value: boolean): void;
+export declare function monitorFiles(): void;
+export declare function stopWatching(): Promise<void>;
+export {};