@mexty/cli 1.2.0 → 1.4.0

package/src/commands/create.ts

@@ -108,21 +108,25 @@ export async function createCommand(
     const block = await apiClient.createBlock(blockData);
 
     console.log(chalk.green(`✅ Block created successfully!`));
-    console.log(chalk.gray(`   Block ID: ${block._id}`));
-    console.log(chalk.gray(`   Block Type: ${block.blockType}`));
+    console.log(chalk.gray(`   Block ID: ${block.id || block._id}`));
+    console.log(
+      chalk.gray(`   Block Type: ${block.blockType || block._doc?.blockType}`)
+    );
 
-    if (block.gitUrl) {
-      console.log(chalk.gray(`   GitHub URL: ${block.gitUrl}`));
+    // Handle both plain objects and Mongoose documents
+    const gitUrl = block.gitUrl || block._doc?.gitUrl;
+    if (gitUrl) {
+      console.log(chalk.gray(`   GitHub URL: ${gitUrl}`));
 
       // Clone the repository
-      const repoName = GitManager.extractRepoName(block.gitUrl);
+      const repoName = GitManager.extractRepoName(gitUrl);
       const targetDir = path.join(process.cwd(), repoName);
 
       console.log(chalk.yellow(`📦 Cloning repository to ./${repoName}...`));
 
       try {
         const gitManager = new GitManager();
-        await gitManager.cloneRepository(block.gitUrl, targetDir);
+        await gitManager.cloneRepository(gitUrl, targetDir);
 
         console.log(
           chalk.green(`🎉 Block created and repository cloned successfully!`)
@@ -149,7 +153,7 @@ export async function createCommand(
           chalk.red(`❌ Failed to clone repository: ${cloneError.message}`)
         );
         console.log(chalk.yellow(`You can manually clone it later:`));
-        console.log(chalk.gray(`  git clone ${block.gitUrl}`));
+        console.log(chalk.gray(`  git clone ${gitUrl}`));
       }
     } else {
       console.log(

package/src/commands/publish.ts

@@ -1,49 +1,54 @@
-import chalk from 'chalk';
-import fs from 'fs';
-import path from 'path';
-import { apiClient } from '../utils/api';
-import { GitManager } from '../utils/git';
-import { createInterface } from 'readline';
-import { syncCommand } from './sync';
-import { requireAuthentication, getAuthenticatedUser } from '../utils/auth';
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { apiClient } from "../utils/api";
+import { GitManager } from "../utils/git";
+import { createInterface } from "readline";
+// Removed sync command import as it's been deleted
+import { requireAuthentication, getAuthenticatedUser } from "../utils/auth";
 
 // Simple confirmation function
 async function confirm(question: string): Promise<boolean> {
   return new Promise((resolve) => {
     const rl = createInterface({
       input: process.stdin,
-      output: process.stdout
+      output: process.stdout,
     });
 
     rl.question(`${question} (y/N): `, (answer) => {
       rl.close();
-      resolve(answer.toLowerCase().trim() === 'y' || answer.toLowerCase().trim() === 'yes');
+      resolve(
+        answer.toLowerCase().trim() === "y" ||
+          answer.toLowerCase().trim() === "yes"
+      );
     });
   });
 }
 
 // Extract block ID from package.json or git URL
 async function findBlockId(): Promise<string | null> {
-  const packageJsonPath = path.join(process.cwd(), 'package.json');
-  
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+
   if (fs.existsSync(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-      
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
       // Look for block ID in package.json name or description
-      if (packageJson.name && packageJson.name.startsWith('block-')) {
-        return packageJson.name.replace('block-', '');
+      if (packageJson.name && packageJson.name.startsWith("block-")) {
+        return packageJson.name.replace("block-", "");
       }
-      
+
       // Look in description for block ID pattern
       if (packageJson.description) {
-        const match = packageJson.description.match(/block[:\s]+([a-f0-9]{24})/i);
+        const match = packageJson.description.match(
+          /block[:\s]+([a-f0-9]{24})/i
+        );
         if (match) {
           return match[1];
         }
       }
     } catch (error) {
-      console.warn(chalk.yellow('⚠️  Could not parse package.json'));
+      console.warn(chalk.yellow("⚠️  Could not parse package.json"));
     }
   }
 
@@ -51,7 +56,7 @@ async function findBlockId(): Promise<string | null> {
   try {
     const gitManager = new GitManager();
     const remoteUrl = await gitManager.getRemoteUrl();
-    
+
     if (remoteUrl) {
       const match = remoteUrl.match(/block-([a-f0-9]{24})/);
       if (match) {
@@ -65,21 +70,36 @@ async function findBlockId(): Promise<string | null> {
   return null;
 }
 
-export async function publishCommand(): Promise<void> {
+interface PublishOptions {
+  agent?: boolean;
+}
+
+export async function publishCommand(
+  options: PublishOptions = {}
+): Promise<void> {
   try {
     // Check authentication first
     requireAuthentication();
-    
+
     const user = getAuthenticatedUser();
-    console.log(chalk.blue('🚀 Publishing block...'));
-    console.log(chalk.gray(`   User: ${user?.fullName || user?.email || 'Unknown'}`));
+    console.log(chalk.blue("🚀 Publishing block to marketplace..."));
+    console.log(
+      chalk.gray(`   User: ${user?.fullName || user?.email || "Unknown"}`)
+    );
+    console.log(
+      chalk.gray(`   Agent insertable: ${options.agent ? "Yes" : "No"}`)
+    );
 
     // Check if we're in a git repository
     const gitManager = new GitManager();
     const isGitRepo = await gitManager.isGitRepository();
-    
+
     if (!isGitRepo) {
-      console.error(chalk.red('❌ Not a git repository. Please run this command from a block repository.'));
+      console.error(
+        chalk.red(
+          "❌ Not a git repository. Please run this command from a block repository."
+        )
+      );
       process.exit(1);
     }
 
@@ -91,8 +111,14 @@ export async function publishCommand(): Promise<void> {
     // Find block ID
     const blockId = await findBlockId();
     if (!blockId) {
-      console.error(chalk.red('❌ Could not determine block ID from repository.'));
-      console.error(chalk.yellow('   Make sure you are in a block repository created with mexty'));
+      console.error(
+        chalk.red("❌ Could not determine block ID from repository.")
+      );
+      console.error(
+        chalk.yellow(
+          "   Make sure you are in a block repository created with mexty"
+        )
+      );
       process.exit(1);
     }
 
@@ -100,60 +126,125 @@ export async function publishCommand(): Promise<void> {
 
     // Check for uncommitted changes
     if (repoInfo.hasChanges) {
-      console.log(chalk.yellow('⚠️  You have uncommitted changes.'));
-      console.log(chalk.gray('   Please commit your changes before publishing:'));
-      console.log(chalk.gray('   git add . && git commit -m "Your commit message"'));
-      
-      const proceed = await confirm('Do you want to continue anyway?');
+      console.log(chalk.yellow("⚠️  You have uncommitted changes."));
+      console.log(
+        chalk.gray("   Please commit your changes before publishing:")
+      );
+      console.log(
+        chalk.gray('   git add . && git commit -m "Your commit message"')
+      );
+
+      const proceed = await confirm("Do you want to continue anyway?");
       if (!proceed) {
-        console.log(chalk.yellow('🚫 Publishing cancelled.'));
+        console.log(chalk.yellow("🚫 Publishing cancelled."));
         return;
       }
     }
 
     // Ask user to push changes
-    console.log(chalk.blue('\n📤 Push your changes to GitHub:'));
+    console.log(chalk.blue("\n📤 Push your changes to GitHub:"));
     console.log(chalk.gray(`   git push origin ${repoInfo.branch}`));
-    
-    const pushed = await confirm('Have you pushed your changes to GitHub?');
+
+    const pushed = await confirm("Have you pushed your changes to GitHub?");
     if (!pushed) {
-      console.log(chalk.yellow('🚫 Please push your changes first and then run publish again.'));
+      console.log(
+        chalk.yellow(
+          "🚫 Please push your changes first and then run publish again."
+        )
+      );
       return;
     }
 
     // Trigger save and bundle
-    console.log(chalk.yellow('📡 Triggering build and bundle process...'));
-    
+    console.log(chalk.yellow("📡 Triggering build and bundle process..."));
+
     try {
       const result = await apiClient.saveAndBundle({ blockId });
-      
-      console.log(chalk.green('✅ Block published successfully!'));
+
+      console.log(chalk.green("✅ Block bundled successfully!"));
       console.log(chalk.gray(`   Bundle Path: ${result.bundlePath}`));
       console.log(chalk.gray(`   Federation URL: ${result.federationUrl}`));
-      
+
       if (result.message) {
         console.log(chalk.blue(`   ${result.message}`));
       }
 
-      // Automatically sync registry after successful publish
-      console.log(chalk.blue('\n🔄 Auto-syncing registry...'));
+      // Update sharing scope to publish to marketplace (free only)
+      console.log(chalk.blue("\n🌐 Publishing to marketplace..."));
+
       try {
-        await syncCommand();
-        console.log(chalk.green('✅ Registry synced! Your block is now available as a named component.'));
-      } catch (syncError: any) {
-        console.warn(chalk.yellow(`⚠️ Registry sync failed: ${syncError.message}`));
-        console.log(chalk.gray('   You can manually sync later with: mexty sync'));
-        // Don't fail the publish if sync fails - it's not critical
+        // Get current block to check existing scope
+        const block = await apiClient.getBlock(blockId);
+        const currentScope = block?.scope || ["user-store"];
+
+        // Add published-store to scope if not already present
+        const newScope = [
+          ...new Set([...currentScope, "user-store", "published-store"]),
+        ];
+
+        await apiClient.updateBlockSharing(blockId, newScope);
+        console.log(chalk.green("✅ Block published to marketplace (free)"));
+
+        // Update agent insertability if requested
+        if (options.agent) {
+          console.log(chalk.blue("🤖 Making block insertable by AI agents..."));
+          try {
+            await apiClient.updateBlockAgentInsertable(blockId, true);
+            console.log(chalk.green("✅ Block is now insertable by AI agents"));
+          } catch (agentError: any) {
+            // This might fail if user is not Mext staff, but that's okay
+            console.log(
+              chalk.yellow(
+                "⚠️  Could not set agent insertability (requires Mext staff permissions)"
+              )
+            );
+            console.log(
+              chalk.gray(
+                `   Error: ${agentError.message || "Permission denied"}`
+              )
+            );
+          }
+        }
+      } catch (sharingError: any) {
+        console.error(
+          chalk.red("❌ Failed to publish to marketplace:"),
+          sharingError.message
+        );
+        console.log(
+          chalk.yellow(
+            "   Block was built successfully but not published to marketplace."
+          )
+        );
+        console.log(
+          chalk.gray("   You can try publishing again or contact support.")
+        );
+        return;
+      }
+
+      // Success message
+      console.log(
+        chalk.green("\n🎉 Block published to marketplace successfully!")
+      );
+      console.log(chalk.blue("Your block is now:"));
+      console.log(chalk.gray("  ✓ Available for free download by anyone"));
+      console.log(chalk.gray("  ✓ Discoverable in the marketplace"));
+      if (options.agent) {
+        console.log(
+          chalk.gray("  ✓ Insertable by AI agents (if you have permissions)")
+        );
       }
-      
+      console.log(
+        chalk.gray(
+          `  ✓ Viewable at: https://mexty.ai/preview.html?blockId=${blockId}`
+        )
+      );
     } catch (buildError: any) {
       console.error(chalk.red(`❌ Build failed: ${buildError.message}`));
-      console.log(chalk.yellow('   Check the server logs for more details.'));
+      console.log(chalk.yellow("   Check the server logs for more details."));
       process.exit(1);
     }
-
   } catch (error: any) {
     console.error(chalk.red(`❌ Failed to publish block: ${error.message}`));
     process.exit(1);
   }
-} 
+}

package/src/index.ts

@@ -4,10 +4,8 @@ import { Command } from "commander";
 import chalk from "chalk";
 import { loginCommand } from "./commands/login";
 import { createCommand } from "./commands/create";
-import { forkCommand } from "./commands/fork";
 import { deleteCommand } from "./commands/delete";
 import { publishCommand } from "./commands/publish";
-import { syncCommand } from "./commands/sync";
 import { saveCommand } from "./commands/save";
 import { apiClient } from "./utils/api";
 
@@ -57,11 +55,6 @@ program
   )
   .action(createCommand);
 
-program
-  .command("fork <blockId>")
-  .description("Fork an existing block and clone its repository")
-  .action(forkCommand);
-
 program
   .command("delete <blockId>")
   .description("Delete a block (requires ownership)")
@@ -69,14 +62,10 @@ program
 
 program
   .command("publish")
-  .description("Publish current block with automatic bundling")
+  .description("Publish current block to marketplace (free only)")
+  .option("--agent", "Make block insertable by AI agents", false)
   .action(publishCommand);
 
-program
-  .command("sync")
-  .description("Sync block registry and update typed exports")
-  .action(syncCommand);
-
 program
   .command("save")
   .description("Save current block (git add, commit, push, and trigger build)")

package/src/utils/api.ts

@@ -6,7 +6,16 @@ import os from "os";
 
 export interface Block {
   _id: string;
+  id?: string;
   blockType: string;
+  _doc?: {
+    _id: string;
+    blockType: string;
+    title: string;
+    description: string;
+    gitUrl?: string;
+    [key: string]: any;
+  };
   title: string;
   description: string;
   gitUrl?: string;
@@ -225,6 +234,24 @@ class ApiClient {
     return response.data;
   }
 
+  async updateBlockSharing(blockId: string, scope: string[]): Promise<any> {
+    const response = await this.client.patch(`/api/blocks/${blockId}/sharing`, {
+      scope,
+    });
+    return response.data;
+  }
+
+  async updateBlockAgentInsertable(
+    blockId: string,
+    isInsertableByAgent: boolean
+  ): Promise<any> {
+    const response = await this.client.patch(
+      `/api/blocks/${blockId}/agent-insertable`,
+      { isInsertableByAgent }
+    );
+    return response.data;
+  }
+
   async healthCheck(): Promise<boolean> {
     try {
       await this.client.get("/api/health");

package/src/commands/fork.ts

@@ -1,58 +0,0 @@
-import chalk from 'chalk';
-import path from 'path';
-import { apiClient } from '../utils/api';
-import { GitManager } from '../utils/git';
-import { requireAuthentication, getAuthenticatedUser } from '../utils/auth';
-
-export async function forkCommand(blockId: string): Promise<void> {
-  try {
-    // Check authentication first
-    requireAuthentication();
-    
-    const user = getAuthenticatedUser();
-    console.log(chalk.blue(`🍴 Forking block: ${blockId}`));
-    console.log(chalk.gray(`   User: ${user?.fullName || user?.email || 'Unknown'}`));
-
-    // Fork the block
-    console.log(chalk.yellow('📡 Forking block on server...'));
-    const forkedBlock = await apiClient.forkBlock({ blockId });
-    
-    console.log(chalk.green(`✅ Block forked successfully!`));
-    console.log(chalk.gray(`   New Block ID: ${forkedBlock._id}`));
-    console.log(chalk.gray(`   Title: ${forkedBlock.title}`));
-    console.log(chalk.gray(`   Description: ${forkedBlock.description}`));
-    
-    if (forkedBlock.gitUrl) {
-      console.log(chalk.gray(`   GitHub URL: ${forkedBlock.gitUrl}`));
-      
-      // Clone the forked repository
-      const repoName = GitManager.extractRepoName(forkedBlock.gitUrl);
-      const targetDir = path.join(process.cwd(), repoName);
-      
-      console.log(chalk.yellow(`📦 Cloning forked repository to ./${repoName}...`));
-      
-      try {
-        const gitManager = new GitManager();
-        await gitManager.cloneRepository(forkedBlock.gitUrl, targetDir);
-        
-        console.log(chalk.green(`🎉 Block forked and repository cloned successfully!`));
-        console.log(chalk.blue(`\nNext steps:`));
-        console.log(chalk.gray(`  1. cd ${repoName}`));
-        console.log(chalk.gray(`  2. Make your changes`));
-        console.log(chalk.gray(`  3. git add . && git commit -m "Your changes"`));
-        console.log(chalk.gray(`  4. mexty publish`));
-        
-      } catch (cloneError: any) {
-        console.error(chalk.red(`❌ Failed to clone repository: ${cloneError.message}`));
-        console.log(chalk.yellow(`You can manually clone it later:`));
-        console.log(chalk.gray(`  git clone ${forkedBlock.gitUrl}`));
-      }
-    } else {
-      console.log(chalk.yellow('⚠️  No GitHub repository available for this block'));
-    }
-
-  } catch (error: any) {
-    console.error(chalk.red(`❌ Failed to fork block: ${error.message}`));
-    process.exit(1);
-  }
-}