@web42/cli 0.1.6 → 0.1.8

package/dist/commands/init.js

@@ -1,4 +1,4 @@
-import { writeFileSync, existsSync, readdirSync, readFileSync, } from "fs";
+import { writeFileSync, mkdirSync, existsSync, readdirSync, readFileSync, } from "fs";
 import { join } from "path";
 import { Command } from "commander";
 import chalk from "chalk";
@@ -7,6 +7,8 @@ import { requireAuth } from "../utils/config.js";
 import { parseSkillMd } from "../utils/skill.js";
 import { listBundledSkills, copySkillToWorkspace } from "../utils/bundled-skills.js";
 import { resolvePlatform, listPlatforms } from "../platforms/registry.js";
+import { writeMarketplace, writeResourcesMeta } from "../utils/sync.js";
+import { DEFAULT_MARKETPLACE } from "../types/sync.js";
 import { AGENTS_MD, IDENTITY_MD, SOUL_MD, TOOLS_MD, USER_MD, HEARTBEAT_MD, INIT_BOOTSTRAP_MD, } from "../platforms/openclaw/templates.js";
 function detectWorkspaceSkills(cwd) {
     const skillsDir = join(cwd, "skills");
@@ -147,6 +149,67 @@ export const initCommand = new Command("init")
     if (skipped.length > 0) {
         console.log(chalk.dim(`  Skipped (already exist): ${skipped.join(", ")}`));
     }
+    // Scaffold .web42/ metadata folder
+    const web42Dir = join(cwd, ".web42");
+    mkdirSync(web42Dir, { recursive: true });
+    const marketplacePath = join(web42Dir, "marketplace.json");
+    if (!existsSync(marketplacePath)) {
+        writeMarketplace(cwd, { ...DEFAULT_MARKETPLACE });
+        console.log(chalk.green(`  Created ${chalk.bold(".web42/marketplace.json")}`));
+    }
+    else {
+        console.log(chalk.dim("  Skipped .web42/marketplace.json (already exists)"));
+    }
+    const resourcesJsonPath = join(web42Dir, "resources.json");
+    if (!existsSync(resourcesJsonPath)) {
+        writeResourcesMeta(cwd, []);
+        console.log(chalk.green(`  Created ${chalk.bold(".web42/resources.json")}`));
+    }
+    else {
+        console.log(chalk.dim("  Skipped .web42/resources.json (already exists)"));
+    }
+    mkdirSync(join(web42Dir, "resources"), { recursive: true });
+    const ignorePath = join(cwd, ".web42ignore");
+    if (!existsSync(ignorePath)) {
+        writeFileSync(ignorePath, [
+            "# .web42ignore — files excluded from web42 pack / push",
+            "# Syntax: glob patterns, one per line. Lines starting with # are comments.",
+            "# NOTE: .git, node_modules, .web42/, manifest.json, and other internals",
+            "#       are always excluded automatically.",
+            "",
+            "# Working notes & drafts",
+            "TODO.md",
+            "NOTES.md",
+            "drafts/**",
+            "",
+            "# Environment & secrets",
+            ".env",
+            ".env.*",
+            "",
+            "# IDE / editor",
+            ".vscode/**",
+            ".idea/**",
+            ".cursor/**",
+            "",
+            "# Test & CI",
+            "tests/**",
+            "__tests__/**",
+            ".github/**",
+            "",
+            "# Build artifacts",
+            "dist/**",
+            "build/**",
+            "",
+            "# Large media not needed at runtime",
+            "# *.mp4",
+            "# *.mov",
+            "",
+        ].join("\n"), "utf-8");
+        console.log(chalk.green(`  Created ${chalk.bold(".web42ignore")}`));
+    }
+    else {
+        console.log(chalk.dim("  Skipped .web42ignore (already exists)"));
+    }
     // Offer bundled starter skills
     const bundled = listBundledSkills();
     if (bundled.length > 0) {
@@ -190,5 +253,6 @@ export const initCommand = new Command("init")
         }
     }
     console.log();
+    console.log(chalk.dim("Edit .web42/marketplace.json to set price, tags, license, and visibility."));
     console.log(chalk.dim("Run `web42 pack` to bundle your agent, or `web42 push` to pack and publish."));
 });

package/dist/commands/pack.js

@@ -3,11 +3,12 @@ import { join } from "path";
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
-import { openclawAdapter } from "../platforms/openclaw/adapter.js";
+import { openclawAdapter, HARDCODED_EXCLUDES } from "../platforms/openclaw/adapter.js";
 import { parseSkillMd } from "../utils/skill.js";
+const HARDCODED_EXCLUDES_SET = new Set(HARDCODED_EXCLUDES);
 export const packCommand = new Command("pack")
     .description("Pack your agent workspace into a distributable artifact")
-    .option("-o, --output <dir>", "Output directory", ".web42")
+    .option("-o, --output <dir>", "Output directory", ".web42/dist")
     .option("--dry-run", "Preview what would be packed without writing files")
     .action(async (opts) => {
     const cwd = process.cwd();
@@ -57,6 +58,14 @@ export const packCommand = new Command("pack")
         }
         if (opts.dryRun) {
             spinner.stop();
+            const userPatterns = (result.ignorePatterns ?? []).filter((p) => !HARDCODED_EXCLUDES_SET.has(p));
+            if (userPatterns.length > 0) {
+                console.log(chalk.bold("Ignore patterns from .web42ignore:"));
+                for (const p of userPatterns) {
+                    console.log(chalk.yellow(`  ✕ ${p}`));
+                }
+                console.log();
+            }
             console.log(chalk.bold("Dry run — would pack:"));
             console.log();
             for (const f of result.files) {

package/dist/commands/pull.js

@@ -1,13 +1,15 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
 import { apiGet } from "../utils/api.js";
 import { requireAuth } from "../utils/config.js";
+import { buildLocalSnapshot, computeHashFromSnapshot, readSyncState, writeSyncState, writeMarketplace, writeResourcesMeta, } from "../utils/sync.js";
 export const pullCommand = new Command("pull")
-    .description("Pull latest agent files from the Web42 marketplace into the current directory")
-    .action(async () => {
+    .description("Pull latest agent state from the Web42 marketplace into the current directory")
+    .option("--force", "Skip hash comparison and always pull")
+    .action(async (opts) => {
     const config = requireAuth();
     const cwd = process.cwd();
     const manifestPath = join(cwd, "manifest.json");
@@ -22,25 +24,71 @@ export const pullCommand = new Command("pull")
     }
     const spinner = ora(`Pulling @${config.username}/${manifest.name}...`).start();
     try {
-        const agents = await apiGet(`/api/agents?username=${config.username}`);
-        const agent = agents.find((a) => a.slug === manifest.name);
-        if (!agent) {
-            spinner.fail(`Agent @${config.username}/${manifest.name} not found on the marketplace. Run \`web42 push\` first.`);
-            process.exit(1);
+        // -------------------------------------------------------------------
+        // Step 1: Resolve agent ID
+        // -------------------------------------------------------------------
+        let syncState = readSyncState(cwd);
+        let agentId = syncState?.agent_id ?? null;
+        if (!agentId) {
+            spinner.text = "Looking up agent...";
+            const agents = await apiGet(`/api/agents?username=${config.username}`);
+            const agent = agents.find((a) => a.slug === manifest.name);
+            if (!agent) {
+                spinner.fail(`Agent @${config.username}/${manifest.name} not found on the marketplace. Run \`web42 push\` first.`);
+                process.exit(1);
+            }
+            agentId = agent.id;
         }
-        const files = await apiGet(`/api/agents/${agent.id}/files?include_content=true`);
-        if (files.length === 0) {
-            spinner.succeed("Agent is up to date (no files on remote).");
-            return;
+        // -------------------------------------------------------------------
+        // Step 2: Compare remote hash with last known remote hash (unless --force)
+        // -------------------------------------------------------------------
+        if (!opts.force && syncState?.last_remote_hash) {
+            spinner.text = "Checking remote state...";
+            const remote = await apiGet(`/api/agents/${agentId}/sync`);
+            if (remote.hash === syncState.last_remote_hash) {
+                spinner.succeed(`${chalk.bold(`@${config.username}/${manifest.name}`)} is already in sync (no remote changes).`);
+                return;
+            }
         }
+        // -------------------------------------------------------------------
+        // Step 3: Pull full snapshot
+        // -------------------------------------------------------------------
+        spinner.text = "Downloading snapshot...";
+        const pullResult = await apiGet(`/api/agents/${agentId}/sync/pull`);
+        const { snapshot } = pullResult;
         let written = 0;
+        // -------------------------------------------------------------------
+        // Step 4a: Write manifest.json (merge identity into existing manifest)
+        // -------------------------------------------------------------------
+        const updatedManifest = {
+            ...manifest,
+            ...snapshot.manifest,
+            name: snapshot.identity.slug,
+            description: snapshot.identity.description,
+        };
+        writeFileSync(manifestPath, JSON.stringify(updatedManifest, null, 2) + "\n");
+        written++;
+        // -------------------------------------------------------------------
+        // Step 4b: Write README.md
+        // -------------------------------------------------------------------
+        if (snapshot.readme) {
+            writeFileSync(join(cwd, "README.md"), snapshot.readme, "utf-8");
+            written++;
+        }
+        // -------------------------------------------------------------------
+        // Step 4c: Write .web42/marketplace.json
+        // -------------------------------------------------------------------
+        writeMarketplace(cwd, snapshot.marketplace);
+        written++;
+        // -------------------------------------------------------------------
+        // Step 4d: Write agent files
+        // -------------------------------------------------------------------
         let skipped = 0;
-        for (const file of files) {
+        for (const file of snapshot.files) {
             if (file.content === null || file.content === undefined) {
                 skipped++;
                 continue;
             }
-            // Skip packaging artifacts that are regenerated on push
             if (file.path === ".openclaw/config.json") {
                 skipped++;
                 continue;
@@ -50,10 +98,33 @@ export const pullCommand = new Command("pull")
             writeFileSync(filePath, file.content, "utf-8");
             written++;
         }
-        if (agent.manifest) {
-            writeFileSync(manifestPath, JSON.stringify(agent.manifest, null, 2) + "\n");
+        // -------------------------------------------------------------------
+        // Step 4e: Write resources metadata
+        // -------------------------------------------------------------------
+        if (snapshot.resources.length > 0) {
+            const resourcesMeta = snapshot.resources.map((r, i) => ({
+                file: `resource-${i}-${r.title.replace(/[^a-zA-Z0-9.-]/g, "_")}`,
+                title: r.title,
+                description: r.description ?? undefined,
+                type: r.type,
+                sort_order: r.sort_order,
+            }));
+            writeResourcesMeta(cwd, resourcesMeta);
+            written++;
         }
+        // -------------------------------------------------------------------
+        // Step 5: Save sync state (compute local hash from what we just wrote)
+        // -------------------------------------------------------------------
+        const localSnapshot = buildLocalSnapshot(cwd);
+        const localHash = computeHashFromSnapshot(localSnapshot);
+        writeSyncState(cwd, {
+            agent_id: agentId,
+            last_remote_hash: pullResult.hash,
+            last_local_hash: localHash,
+            synced_at: new Date().toISOString(),
+        });
         spinner.succeed(`Pulled ${chalk.bold(`@${config.username}/${manifest.name}`)} (${written} files written${skipped > 0 ? `, ${skipped} skipped` : ""})`);
+        console.log(chalk.dim(`  Sync hash: ${pullResult.hash.slice(0, 12)}...`));
     }
     catch (error) {
         spinner.fail("Pull failed");

package/dist/commands/push.js

@@ -1,48 +1,30 @@
-import { createHash } from "crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync, } from "fs";
-import { join, relative } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
-import { apiPost } from "../utils/api.js";
+import { apiPost, apiFormData } from "../utils/api.js";
 import { requireAuth } from "../utils/config.js";
 import { openclawAdapter } from "../platforms/openclaw/adapter.js";
 import { parseSkillMd } from "../utils/skill.js";
-function hashContent(content) {
-    return createHash("sha256").update(content).digest("hex");
-}
-function readPackedFiles(dir) {
-    const files = [];
-    function walk(currentDir) {
-        const entries = readdirSync(currentDir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = join(currentDir, entry.name);
-            if (entry.isDirectory()) {
-                walk(fullPath);
-            }
-            else {
-                if (entry.name === "manifest.json" && currentDir === dir)
-                    continue;
-                const stat = statSync(fullPath);
-                if (stat.size > 1024 * 1024)
-                    continue;
-                try {
-                    const content = readFileSync(fullPath, "utf-8");
-                    const relPath = relative(dir, fullPath);
-                    files.push({ path: relPath, content, hash: hashContent(content) });
-                }
-                catch {
-                    // Skip binary files
-                }
-            }
-        }
-    }
-    walk(dir);
-    return files;
+import { buildLocalSnapshot, computeHashFromSnapshot, findLocalAvatar, readResourcesMeta, readSyncState, writeSyncState, } from "../utils/sync.js";
+function mimeFromExtension(ext) {
+    const map = {
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        webp: "image/webp",
+        svg: "image/svg+xml",
+        mp4: "video/mp4",
+        webm: "video/webm",
+        pdf: "application/pdf",
+    };
+    return map[ext.toLowerCase()] ?? "application/octet-stream";
 }
 export const pushCommand = new Command("push")
     .description("Push your agent package to the Web42 marketplace")
-    .action(async () => {
+    .option("--force", "Skip hash comparison and always push")
+    .action(async (opts) => {
     const config = requireAuth();
     const cwd = process.cwd();
     const manifestPath = join(cwd, "manifest.json");
@@ -56,19 +38,23 @@ export const pushCommand = new Command("push")
         process.exit(1);
     }
     const spinner = ora("Preparing agent package...").start();
-    const web42Dir = join(cwd, ".web42");
-    let processedFiles;
-    if (existsSync(web42Dir)) {
-        spinner.text = "Reading packed artifact...";
-        processedFiles = readPackedFiles(web42Dir);
-        const packedManifestPath = join(web42Dir, "manifest.json");
+    // -----------------------------------------------------------------------
+    // Step 1: Pack into .web42/dist/
+    // -----------------------------------------------------------------------
+    const distDir = join(cwd, ".web42", "dist");
+    if (existsSync(distDir)) {
+        spinner.text = "Reading packed artifact from .web42/dist/...";
+        const packedManifestPath = join(distDir, "manifest.json");
         if (existsSync(packedManifestPath)) {
             manifest = JSON.parse(readFileSync(packedManifestPath, "utf-8"));
         }
     }
     else {
-        spinner.text = "No .web42/ found, packing automatically...";
-        const result = await openclawAdapter.pack({ cwd, outputDir: ".web42" });
+        spinner.text = "Packing agent into .web42/dist/...";
+        const result = await openclawAdapter.pack({
+            cwd,
+            outputDir: ".web42/dist",
+        });
         const internalPrefixes = [];
         for (const f of result.files) {
             const skillMatch = f.path.match(/^skills\/([^/]+)\/SKILL\.md$/);
@@ -81,7 +67,6 @@ export const pushCommand = new Command("push")
         if (internalPrefixes.length > 0) {
             result.files = result.files.filter((f) => !internalPrefixes.some((p) => f.path.startsWith(p)));
         }
-        processedFiles = result.files;
         const existingKeys = new Set((manifest.configVariables ?? []).map((v) => v.key));
         for (const cv of result.configVariables) {
             if (!existingKeys.has(cv.key)) {
@@ -91,45 +76,124 @@ export const pushCommand = new Command("push")
                 existingKeys.add(cv.key);
             }
         }
-        mkdirSync(web42Dir, { recursive: true });
+        mkdirSync(distDir, { recursive: true });
         for (const file of result.files) {
-            const filePath = join(web42Dir, file.path);
+            const filePath = join(distDir, file.path);
             mkdirSync(join(filePath, ".."), { recursive: true });
             writeFileSync(filePath, file.content, "utf-8");
         }
-        writeFileSync(join(web42Dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+        writeFileSync(join(distDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
     }
-    spinner.text = `Pushing ${processedFiles.length} files...`;
-    let readme = "";
-    const readmePath = join(cwd, "README.md");
-    if (existsSync(readmePath)) {
-        readme = readFileSync(readmePath, "utf-8");
-    }
-    try {
+    // -----------------------------------------------------------------------
+    // Step 2: Resolve agent ID (create if first push)
+    // -----------------------------------------------------------------------
+    spinner.text = "Resolving agent...";
+    let syncState = readSyncState(cwd);
+    let agentId = syncState?.agent_id ?? null;
+    let isCreated = false;
+    if (!agentId) {
+        let readme = "";
+        const readmePath = join(cwd, "README.md");
+        if (existsSync(readmePath)) {
+            readme = readFileSync(readmePath, "utf-8");
+        }
         const agentResult = await apiPost("/api/agents", {
             slug: manifest.name,
             name: manifest.name,
-            description: manifest.description,
+            description: manifest.description ?? "",
             readme,
             manifest,
             demo_video_url: manifest.demoVideoUrl,
         });
-        const agentId = agentResult.agent.id;
-        const fileEntries = processedFiles.map((f) => ({
-            path: f.path,
-            content: f.content,
-            content_hash: f.hash,
-            storage_url: `agent-files/${config.username}/${manifest.name}/${f.path}`,
-        }));
-        await apiPost(`/api/agents/${agentId}/files`, { files: fileEntries });
-        spinner.succeed(`Pushed ${chalk.bold(`@${config.username}/${manifest.name}`)} (${processedFiles.length} files)`);
-        if (agentResult.created) {
+        agentId = agentResult.agent.id;
+        isCreated = !!agentResult.created;
+    }
+    // -----------------------------------------------------------------------
+    // Step 3: Build local snapshot and compute hash
+    // -----------------------------------------------------------------------
+    spinner.text = "Building snapshot...";
+    const snapshot = buildLocalSnapshot(cwd);
+    const localHash = computeHashFromSnapshot(snapshot);
+    // -----------------------------------------------------------------------
+    // Step 4: Compare local hash with last known local hash (unless --force)
+    // -----------------------------------------------------------------------
+    if (!opts.force && !isCreated && syncState?.last_local_hash) {
+        if (localHash === syncState.last_local_hash) {
+            spinner.succeed(`${chalk.bold(`@${config.username}/${manifest.name}`)} has no local changes since last sync.`);
+            return;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Step 5: Push snapshot
+    // -----------------------------------------------------------------------
+    spinner.text = `Pushing ${snapshot.files.length} files...`;
+    try {
+        const pushResult = await apiPost(`/api/agents/${agentId}/sync/push`, snapshot);
+        let finalHash = pushResult.hash;
+        // -------------------------------------------------------------------
+        // Step 6: Upload avatar if present
+        // -------------------------------------------------------------------
+        const avatarPath = findLocalAvatar(cwd);
+        if (avatarPath) {
+            spinner.text = "Uploading avatar...";
+            const ext = avatarPath.split(".").pop() ?? "png";
+            const avatarBuffer = readFileSync(avatarPath);
+            const avatarBlob = new Blob([avatarBuffer], {
+                type: mimeFromExtension(ext),
+            });
+            const avatarForm = new FormData();
+            avatarForm.append("avatar", avatarBlob, `avatar.${ext}`);
+            const avatarResult = await apiFormData(`/api/agents/${agentId}/sync/avatar`, avatarForm);
+            finalHash = avatarResult.hash;
+        }
+        // -------------------------------------------------------------------
+        // Step 7: Upload resources if present
+        // -------------------------------------------------------------------
+        const resourcesMeta = readResourcesMeta(cwd);
+        if (resourcesMeta.length > 0) {
+            spinner.text = "Uploading resources...";
+            const resForm = new FormData();
+            const metadataForApi = resourcesMeta.map((meta, i) => ({
+                file_key: `resource_${i}`,
+                title: meta.title,
+                description: meta.description,
+                type: meta.type,
+                sort_order: meta.sort_order,
+            }));
+            resForm.append("metadata", JSON.stringify(metadataForApi));
+            for (let i = 0; i < resourcesMeta.length; i++) {
+                const meta = resourcesMeta[i];
+                const resFilePath = join(cwd, ".web42", "resources", meta.file);
+                if (existsSync(resFilePath)) {
+                    const resBuffer = readFileSync(resFilePath);
+                    const ext = meta.file.split(".").pop() ?? "";
+                    const blob = new Blob([resBuffer], {
+                        type: mimeFromExtension(ext),
+                    });
+                    resForm.append(`resource_${i}`, blob, meta.file);
+                }
+            }
+            const resResult = await apiFormData(`/api/agents/${agentId}/sync/resources`, resForm);
+            finalHash = resResult.hash;
+        }
+        // -------------------------------------------------------------------
+        // Step 8: Save sync state
+        // -------------------------------------------------------------------
+        writeSyncState(cwd, {
+            agent_id: agentId,
+            last_remote_hash: finalHash,
+            last_local_hash: localHash,
+            synced_at: new Date().toISOString(),
+        });
+        spinner.succeed(`Pushed ${chalk.bold(`@${config.username}/${manifest.name}`)} (${snapshot.files.length} files)`);
+        if (isCreated) {
             console.log(chalk.green("  New agent created!"));
         }
         else {
             console.log(chalk.green("  Agent updated."));
         }
         console.log(chalk.dim(`  View at: ${config.apiUrl ? config.apiUrl.replace("https://", "") : "web42.ai"}/${config.username}/${manifest.name}`));
+        console.log(chalk.dim(`  Sync hash: ${finalHash.slice(0, 12)}...`));
     }
     catch (error) {
         spinner.fail("Push failed");

package/dist/commands/sync.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const syncCommand: Command;

package/dist/commands/sync.js

@@ -0,0 +1,98 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { apiGet } from "../utils/api.js";
+import { requireAuth } from "../utils/config.js";
+import { buildLocalSnapshot, computeHashFromSnapshot, readSyncState, } from "../utils/sync.js";
+export const syncCommand = new Command("sync")
+    .description("Check sync status between local workspace and the marketplace")
+    .action(async () => {
+    const config = requireAuth();
+    const cwd = process.cwd();
+    const manifestPath = join(cwd, "manifest.json");
+    if (!existsSync(manifestPath)) {
+        console.log(chalk.red("No manifest.json found. Are you in an agent directory?"));
+        process.exit(1);
+    }
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    if (!manifest.name) {
+        console.log(chalk.red("manifest.json is missing a name field."));
+        process.exit(1);
+    }
+    const spinner = ora("Checking sync status...").start();
+    try {
+        // Resolve agent ID
+        const syncState = readSyncState(cwd);
+        let agentId = syncState?.agent_id ?? null;
+        if (!agentId) {
+            const agents = await apiGet(`/api/agents?username=${config.username}`);
+            const agent = agents.find((a) => a.slug === manifest.name);
+            if (!agent) {
+                spinner.fail(`Agent @${config.username}/${manifest.name} not found on the marketplace. Run \`web42 push\` first.`);
+                process.exit(1);
+            }
+            agentId = agent.id;
+        }
+        // Compute local hash
+        const distDir = join(cwd, ".web42", "dist");
+        let localHash = null;
+        if (existsSync(distDir)) {
+            const snapshot = buildLocalSnapshot(cwd);
+            localHash = computeHashFromSnapshot(snapshot);
+        }
+        // Fetch remote hash
+        const remote = await apiGet(`/api/agents/${agentId}/sync`);
+        const remoteHash = remote.hash;
+        const lastRemoteHash = syncState?.last_remote_hash ?? null;
+        const lastLocalHash = syncState?.last_local_hash ?? null;
+        spinner.stop();
+        console.log();
+        console.log(chalk.bold(`  Sync status for @${config.username}/${manifest.name}`));
+        console.log();
+        console.log(`  Remote hash:  ${chalk.cyan(remoteHash.slice(0, 12))}...`);
+        if (localHash) {
+            console.log(`  Local hash:   ${chalk.cyan(localHash.slice(0, 12))}...`);
+        }
+        else {
+            console.log(`  Local hash:   ${chalk.dim("(not packed yet — run web42 pack first)")}`);
+        }
+        if (lastRemoteHash) {
+            console.log(`  Last synced:  ${chalk.dim(syncState.synced_at)}`);
+        }
+        else {
+            console.log(`  Last synced:  ${chalk.dim("never")}`);
+        }
+        console.log();
+        // Determine sync status by comparing each side against its last-known hash
+        if (!lastRemoteHash || !lastLocalHash) {
+            console.log(chalk.yellow("  Status: Never synced — run `web42 push` or `web42 pull`"));
+        }
+        else {
+            const localChanged = localHash !== null && localHash !== lastLocalHash;
+            const remoteChanged = remoteHash !== lastRemoteHash;
+            if (localChanged && remoteChanged) {
+                console.log(chalk.red("  Status: Both local and remote have changed since last sync"));
+                console.log(chalk.dim("  Use `web42 push --force` or `web42 pull --force` to resolve"));
+            }
+            else if (localChanged) {
+                console.log(chalk.yellow("  Status: Local changes (push to sync)"));
+                console.log(chalk.dim("  Run `web42 push` to update the marketplace"));
+            }
+            else if (remoteChanged) {
+                console.log(chalk.yellow("  Status: Remote changes (pull to sync)"));
+                console.log(chalk.dim("  Run `web42 pull` to update local files"));
+            }
+            else {
+                console.log(chalk.green("  Status: In sync"));
+            }
+        }
+        console.log();
+    }
+    catch (error) {
+        spinner.fail("Sync status check failed");
+        console.error(chalk.red(error.message));
+        process.exit(1);
+    }
+});