kustom-mc 0.1.2 → 0.1.4

package/dist/commands/init.js

@@ -26,11 +26,9 @@ export const initCommand = new Command('init')
             process.exit(1);
         }
     }
-    // Create directory structure
+    // Create directory structure (all scripts go in scripts/, type determined by __type)
     const dirs = [
         'scripts/lib',
-        'blocks',
-        'items',
         'textures',
         'gui',
         'models',
@@ -68,8 +66,6 @@ export const initCommand = new Command('init')
         },
         include: [
             "scripts/**/*.ts",
-            "blocks/**/*.ts",
-            "items/**/*.ts",
             "dist/types/**/*.d.ts",
             ".kustom/types/**/*.d.ts",
             "node_modules/kustom-mc/dist/types/globals.d.ts"
@@ -80,9 +76,7 @@ export const initCommand = new Command('init')
     // Write kustom.config.json with manifest
     const kustomConfig = {
         include: [
-            "scripts/**/*.ts",
-            "blocks/**/*.ts",
-            "items/**/*.ts"
+            "scripts/**/*.ts"
         ],
         exclude: [
             "**/*.test.ts",
@@ -103,10 +97,6 @@ export const initCommand = new Command('init')
         server: {
             url: "http://localhost:8765"
         },
-        deploy: {
-            target: "../run/plugins/kustom-plugin/packs",
-            reloadCommand: "/kustom pack reload"
-        },
         bundle: {
             output: `dist/${packId}.zip`,
             include: [
@@ -127,12 +117,11 @@ export const initCommand = new Command('init')
         version: "1.0.0",
         type: "module",
         scripts: {
+            push: "kustom push",
+            dev: "kustom push --watch",
             build: "kustom build",
-            watch: "kustom build --watch",
-            deploy: "kustom build --deploy",
             bundle: "kustom bundle",
-            validate: "kustom validate",
-            push: "kustom push"
+            validate: "kustom validate"
         },
         devDependencies: {
             "kustom-mc": "^0.1.0",
@@ -194,11 +183,9 @@ dist/
   ├── kustom.config.json   # Pack configuration & manifest
   ├── tsconfig.json        # TypeScript configuration
   ├── package.json         # npm configuration
-  ├── scripts/             # General scripts
+   ├── scripts/             # All scripts (type determined by defineScript/defineBlock/defineItem)
   │   ├── example.ts       # Example script
   │   └── lib/             # Shared utilities
-  ├── blocks/              # Block definitions
-  ├── items/               # Item definitions
   ├── textures/            # Texture files
   ├── models/              # Model files
   ├── sounds/              # Sound files
@@ -208,10 +195,10 @@ dist/
         console.log(chalk.cyan(`  cd ${projectName}`));
     }
     console.log(chalk.cyan('  npm install'));
-    console.log(chalk.cyan('  npm run build'));
+    console.log(chalk.cyan('  npm run push'));
     console.log('\n' + chalk.bold('Available commands:'));
-    console.log('  npm run build    - Compile TypeScript');
-    console.log('  npm run watch    - Watch mode');
-    console.log('  npm run deploy   - Build and deploy to server');
+    console.log('  npm run push     - Build and push to server');
+    console.log('  npm run dev      - Watch mode + auto-push');
+    console.log('  npm run build    - Compile TypeScript only');
     console.log('  npm run bundle   - Create distributable zip');
 });

package/dist/commands/login.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
+import * as readline from 'readline';
 import chalk from 'chalk';
-import { loadConfig } from '../config.js';
+import { loadConfig, saveConfigServerUrl } from '../config.js';
 import { saveServerToken, getServerCredential, normalizeServerUrl, listStoredServers, removeServerCredential } from '../credentials.js';
 /**
  * Validate a token with the server.
@@ -60,6 +61,7 @@ export const loginCommand = new Command('login')
     // Determine server URL
     let serverUrl;
     let token;
+    let serverUrlExplicit = false; // true when user provided the URL as a CLI argument
     // If only one argument provided, it might be the token (use config for server)
     if (serverUrlArg && !tokenArg && !serverUrlArg.includes('://') && !serverUrlArg.includes(':')) {
         // Looks like a token, not a URL
@@ -76,6 +78,7 @@ export const loginCommand = new Command('login')
     else if (serverUrlArg) {
         serverUrl = serverUrlArg;
         token = tokenArg;
+        serverUrlExplicit = true;
     }
     else {
         // No arguments - use config
@@ -159,6 +162,29 @@ export const loginCommand = new Command('login')
             console.log(`  Token expires: ${result.expiresAt}`);
         }
         console.log(`\nCredentials saved to ~/.kustom/credentials.json`);
+        // Offer to update kustom.config.json if the user explicitly provided a server URL
+        if (serverUrlExplicit) {
+            const config = loadConfig(process.cwd());
+            const configServerUrl = config.server?.url ? normalizeServerUrl(config.server.url) : undefined;
+            if (configServerUrl !== serverUrl) {
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout
+                });
+                const answer = await new Promise((resolve) => {
+                    rl.question(chalk.yellow(`Update server.url in kustom.config.json to ${serverUrl}? [y/N] `), resolve);
+                });
+                rl.close();
+                if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+                    if (saveConfigServerUrl(process.cwd(), serverUrl)) {
+                        console.log(chalk.green('Updated server.url in kustom.config.json'));
+                    }
+                    else {
+                        console.log(chalk.yellow('Could not update kustom.config.json (file not found or not writable)'));
+                    }
+                }
+            }
+        }
     }
     catch (error) {
         console.error(chalk.red(`Login failed: ${error instanceof Error ? error.message : error}`));

package/dist/commands/new.js

@@ -22,32 +22,37 @@ export default defineScript({
   }
 });
 `,
-    block: `import { defineScript } from 'kustom-mc';
+    block: `import { defineBlock } from 'kustom-mc';
 
-export default defineScript({
-  run({ shaper }) {
-    shaper.create("{{name}}")
-      .withModel("kustom:block/{{name}}")
-      .fullBlockCollision()
-      .onClick((event) => {
-        const player = event.player;
-        player.sendMessage("You clicked {{name}}!");
-      })
-      .register();
+export default defineBlock({
+  id: "{{name}}",
+  model: "kustom:block/{{name}}",
+  collision: "full",
+  autoPlace: true,
+
+  onClick(event) {
+    event.player.sendMessage("You clicked {{name}}!");
+  },
+
+  onBreak(event) {
+    event.player.sendMessage("{{name}} broken!");
+  },
+
+  onPlace(event) {
+    event.player.sendMessage("{{name}} placed!");
   }
 });
 `,
-    item: `import { defineScript } from 'kustom-mc';
+    item: `import { defineItem } from 'kustom-mc';
 
-export default defineScript({
-  run({ items, definition }) {
-    items.create("{{name}}")
-      .withModel(definition.model("kustom:item/{{name}}"))
-      .on("rightClick", (event) => {
-        const player = event.player;
-        player.sendMessage("You used {{name}}!");
-      })
-      .register();
+export default defineItem({
+  id: "{{name}}",
+  material: "PAPER",
+  model: "kustom:item/{{name}}",
+  displayName: "{{name}}",
+
+  onRightClick(event) {
+    event.player.sendMessage("You used {{name}}!");
   }
 });
 `,
@@ -94,10 +99,11 @@ export const newCommand = new Command('new')
         process.exit(1);
     }
     // Determine output directory and file
+    // All script types go in scripts/ — type is determined by defineScript/defineBlock/defineItem
     const dirMap = {
         script: 'scripts',
-        block: 'blocks',
-        item: 'items',
+        block: 'scripts',
+        item: 'scripts',
         gui: 'scripts'
     };
     const dir = dirMap[type];

package/dist/commands/push.d.ts

@@ -1,9 +1,16 @@
 import { Command } from 'commander';
 /**
- * Push command - bundle and upload pack to server.
+ * Push command — build, bundle, and upload pack to server.
+ *
+ * This is the primary deployment command. It:
+ * 1. Builds all TypeScript files
+ * 2. Bundles compiled JS + assets into a zip
+ * 3. Uploads the zip to the server via HTTP
  *
  * Usage:
- *   npx kustom-mc push              # Push to configured server
- *   npx kustom-mc push --server <url>  # Push to specific server
+ *   kustom push                    # One-shot build + push
+ *   kustom push --watch            # Watch + auto-push on changes
+ *   kustom push --server <url>     # Push to specific server
+ *   kustom push --dry-run          # Build + bundle, don't upload
  */
 export declare const pushCommand: Command;

package/dist/commands/push.js

@@ -2,113 +2,181 @@ import { Command } from 'commander';
 import * as fs from 'fs';
 import * as path from 'path';
 import chalk from 'chalk';
-import { glob } from 'glob';
-import archiver from 'archiver';
-import { loadConfig, generateManifest, validateManifest } from '../config.js';
+import chokidar from 'chokidar';
+import { loadConfig } from '../config.js';
 import { getServerToken, normalizeServerUrl, getServerCredential } from '../credentials.js';
+import { bundleToBuffer } from '../bundler.js';
+import { uploadPack } from '../upload.js';
+import { buildAll, buildFile } from './build.js';
+import { prepare } from './prepare.js';
+/** Debounce delay in milliseconds before auto-pushing after a change */
+const PUSH_DEBOUNCE_MS = 500;
 /**
- * Create a zip bundle in memory and return as Buffer.
+ * Build, bundle, and upload the pack to the server.
+ * Returns true on success, false on failure.
  */
-async function createBundle(projectDir) {
-    const config = loadConfig(projectDir);
-    // Validate manifest
-    const errors = validateManifest(config);
-    if (errors.length > 0) {
-        throw new Error(`Manifest validation failed:\n  ${errors.join('\n  ')}`);
+async function doPush(projectDir, serverUrl, token, options) {
+    try {
+        const { buffer, packId, version, fileCount } = await bundleToBuffer(projectDir);
+        const sizeKB = (buffer.length / 1024).toFixed(2);
+        if (options.verbose) {
+            console.log(`  Bundle: ${fileCount} files, ${sizeKB} KB`);
+        }
+        const result = await uploadPack(serverUrl, token, buffer, packId);
+        if (result.success) {
+            console.log(chalk.green(`  Pushed ${packId} v${version} (${sizeKB} KB)`));
+            return true;
+        }
+        else {
+            console.error(chalk.red(`  Push failed: ${result.error || 'Unknown error'}`));
+            return false;
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`  Push failed: ${error instanceof Error ? error.message : error}`));
+        return false;
     }
-    const packId = config.manifest?.id || 'kustompack';
-    const version = config.manifest?.version || '1.0.0';
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        const archive = archiver('zip', { zlib: { level: 9 } });
-        archive.on('data', (chunk) => chunks.push(chunk));
-        archive.on('end', () => resolve({
-            buffer: Buffer.concat(chunks),
-            packId,
-            version
-        }));
-        archive.on('error', reject);
-        // Generate and add manifest
-        const manifestContent = generateManifest(config);
-        archive.append(manifestContent, { name: 'kustompack.json' });
-        // Add files based on bundle config
-        const includePatterns = config.bundle?.include || [
-            '**/*.js',
-            'textures/**/*',
-            'gui/**/*',
-            'models/**/*',
-            'sounds/**/*'
-        ];
-        const addFiles = async () => {
-            const addedFiles = new Set();
-            for (const pattern of includePatterns) {
-                const files = await glob(pattern, {
-                    cwd: projectDir,
-                    nodir: true,
-                    ignore: ['node_modules/**', 'dist/**', '*.ts', 'kustompack.json']
-                });
-                for (const file of files) {
-                    if (addedFiles.has(file))
-                        continue;
-                    const filePath = path.resolve(projectDir, file);
-                    if (fs.existsSync(filePath)) {
-                        archive.file(filePath, { name: file });
-                        addedFiles.add(file);
-                    }
-                }
-            }
-            archive.finalize();
-        };
-        addFiles().catch(reject);
-    });
 }
 /**
- * Upload a pack to the server.
- *
- * Currently sends raw zip bytes for simplicity and performance.
- *
- * TODO: If a web UI is added later, consider supporting multipart/form-data
- * uploads on the server side (Option 2). This would require:
- * - Adding multipart parsing to PackRegistryServer.java (Apache Commons FileUpload or manual)
- * - Keeping raw zip support for CLI (faster)
- * - Adding multipart support for browser uploads
+ * Watch mode: rebuild and auto-push on file changes with debounce.
  */
-async function uploadPack(serverUrl, token, buffer, packId) {
-    const url = `${normalizeServerUrl(serverUrl)}/packs/upload`;
-    // Send raw zip bytes (faster than multipart, server already supports this)
-    const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${token}`,
-            'Content-Type': 'application/zip',
-            'X-Pack-Id': packId // Optional hint for server
-        },
-        body: buffer
-    });
-    if (response.status === 401) {
-        throw new Error('Authentication failed. Token may be invalid or expired. Run: npx kustom-mc login');
-    }
-    if (response.status === 403) {
-        throw new Error('Permission denied. You may not have upload permissions.');
-    }
-    const result = await response.json();
-    if (!response.ok) {
-        throw new Error(result.error || result.message || `Server returned ${response.status}`);
+async function pushWatchMode(config, projectDir, serverUrl, token, options) {
+    console.log(chalk.blue('Starting push watch mode...'));
+    console.log(`  Server: ${serverUrl}`);
+    console.log();
+    // Initial build
+    await buildAll(config, options);
+    // Initial push
+    console.log('\nPushing initial build...');
+    await doPush(projectDir, serverUrl, token, options);
+    // Debounce timer
+    let pushTimer = null;
+    function schedulePush() {
+        if (pushTimer)
+            clearTimeout(pushTimer);
+        pushTimer = setTimeout(async () => {
+            pushTimer = null;
+            console.log(chalk.gray('\nPushing changes...'));
+            await doPush(projectDir, serverUrl, token, options);
+        }, PUSH_DEBOUNCE_MS);
     }
-    return result;
+    // Watch script files
+    const patterns = config.include || ['scripts/**/*.ts'];
+    const libDirs = config.lib || ['scripts/lib'];
+    const scriptWatcher = chokidar.watch(patterns, {
+        cwd: projectDir,
+        ignoreInitial: true,
+        ignored: config.exclude
+    });
+    const rebuildAndPush = async (changedFile) => {
+        const isLibFile = libDirs.some(lib => changedFile.startsWith(lib + '/') || changedFile.startsWith(lib + '\\'));
+        if (isLibFile) {
+            console.log(`\nLib file changed: ${changedFile}`);
+            console.log('Rebuilding all scripts...');
+            await buildAll(config, options);
+        }
+        else {
+            console.log(`\nFile changed: ${changedFile}`);
+            try {
+                const outputPath = await buildFile(changedFile, config, options);
+                console.log(`  [OK] ${changedFile} -> ${path.relative(projectDir, outputPath)}`);
+            }
+            catch (error) {
+                console.error(`  [ERROR] ${changedFile}: ${error instanceof Error ? error.message : error}`);
+                return; // Don't push if build failed
+            }
+        }
+        schedulePush();
+    };
+    scriptWatcher.on('change', rebuildAndPush);
+    scriptWatcher.on('add', rebuildAndPush);
+    scriptWatcher.on('unlink', (file) => {
+        console.log(`\nFile deleted: ${file}`);
+        // Delete the compiled output
+        const outDir = config.outDir || 'dist';
+        const outputPath = path.resolve(projectDir, outDir, file.replace(/\.ts$/, '.js'));
+        if (fs.existsSync(outputPath)) {
+            fs.unlinkSync(outputPath);
+        }
+        schedulePush();
+    });
+    // Watch sounds folder for type regeneration + push
+    const soundsWatcher = chokidar.watch('sounds/**/*.ogg', {
+        cwd: projectDir,
+        ignoreInitial: true
+    });
+    soundsWatcher.on('add', async (file) => {
+        console.log(`\nSound added: ${file}`);
+        console.log('Regenerating types...');
+        await prepare(projectDir);
+        schedulePush();
+    });
+    soundsWatcher.on('change', () => {
+        schedulePush();
+    });
+    soundsWatcher.on('unlink', async (file) => {
+        console.log(`\nSound removed: ${file}`);
+        console.log('Regenerating types...');
+        await prepare(projectDir);
+        schedulePush();
+    });
+    // Watch asset folders (textures, models, gui, etc.) — push on change
+    const assetPatterns = [
+        'textures/**/*',
+        'models/**/*',
+        'gui/**/*',
+        'lang/**/*',
+        'definitions/**/*'
+    ];
+    const assetsWatcher = chokidar.watch(assetPatterns, {
+        cwd: projectDir,
+        ignoreInitial: true
+    });
+    assetsWatcher.on('add', (file) => {
+        console.log(`\nAsset added: ${file}`);
+        schedulePush();
+    });
+    assetsWatcher.on('change', (file) => {
+        console.log(`\nAsset changed: ${file}`);
+        schedulePush();
+    });
+    assetsWatcher.on('unlink', (file) => {
+        console.log(`\nAsset removed: ${file}`);
+        schedulePush();
+    });
+    console.log('\nWatching for changes... (Ctrl+C to stop)');
+    // Keep process alive
+    process.on('SIGINT', () => {
+        console.log('\nStopping push watch mode...');
+        if (pushTimer)
+            clearTimeout(pushTimer);
+        scriptWatcher.close();
+        soundsWatcher.close();
+        assetsWatcher.close();
+        process.exit(0);
+    });
 }
 /**
- * Push command - bundle and upload pack to server.
+ * Push command — build, bundle, and upload pack to server.
+ *
+ * This is the primary deployment command. It:
+ * 1. Builds all TypeScript files
+ * 2. Bundles compiled JS + assets into a zip
+ * 3. Uploads the zip to the server via HTTP
  *
  * Usage:
- *   npx kustom-mc push              # Push to configured server
- *   npx kustom-mc push --server <url>  # Push to specific server
+ *   kustom push                    # One-shot build + push
+ *   kustom push --watch            # Watch + auto-push on changes
+ *   kustom push --server <url>     # Push to specific server
+ *   kustom push --dry-run          # Build + bundle, don't upload
  */
 export const pushCommand = new Command('push')
-    .description('Bundle and upload pack to the connected server')
+    .description('Build, bundle, and upload pack to the server')
     .option('-s, --server <url>', 'Server URL (overrides config)')
-    .option('--dry-run', 'Create bundle but do not upload')
+    .option('-w, --watch', 'Watch for changes and auto-push')
+    .option('--dry-run', 'Build and bundle but do not upload')
     .option('-y, --yes', 'Skip confirmation prompt')
+    .option('-v, --verbose', 'Verbose output')
     .action(async (options) => {
     const projectDir = process.cwd();
     const config = loadConfig(projectDir);
@@ -135,22 +203,35 @@ export const pushCommand = new Command('push')
         process.exit(1);
     }
     const cred = getServerCredential(serverUrl);
-    console.log(chalk.blue('Preparing pack for upload...'));
+    // Watch mode
+    if (options?.watch) {
+        if (!token) {
+            console.error(chalk.red('Error: --watch requires authentication'));
+            process.exit(1);
+        }
+        await pushWatchMode(config, projectDir, serverUrl, token, { verbose: options.verbose });
+        return;
+    }
+    // One-shot mode: build → bundle → upload
+    console.log(chalk.blue('Building and pushing pack...'));
     console.log(`  Server: ${serverUrl}`);
     if (cred?.playerName) {
         console.log(`  As: ${cred.playerName}`);
     }
     console.log();
     try {
-        // Create bundle
+        // Build
+        await buildAll(config, { verbose: options?.verbose });
+        console.log();
+        // Bundle
         console.log('Creating bundle...');
-        const { buffer, packId, version } = await createBundle(projectDir);
+        const { buffer, packId, version, fileCount } = await bundleToBuffer(projectDir);
         const sizeKB = (buffer.length / 1024).toFixed(2);
         console.log(chalk.green(`  Pack: ${packId} v${version}`));
-        console.log(chalk.green(`  Size: ${sizeKB} KB`));
+        console.log(chalk.green(`  Size: ${sizeKB} KB (${fileCount} files)`));
+        // Dry run — save to disk instead of uploading
         if (options?.dryRun) {
             console.log(chalk.yellow('\n--dry-run: Bundle created but not uploaded.'));
-            // Optionally save the bundle locally
             const outputPath = path.join(projectDir, 'dist', `${packId}.zip`);
             const outputDir = path.dirname(outputPath);
             if (!fs.existsSync(outputDir)) {
@@ -164,7 +245,6 @@ export const pushCommand = new Command('push')
         if (!options?.yes) {
             console.log(chalk.yellow(`\nThis will upload ${packId} v${version} to ${serverUrl}`));
             console.log(chalk.yellow('If a pack with this ID exists, it will be replaced.'));
-            // Simple confirmation using readline
             const readline = await import('readline');
             const rl = readline.createInterface({
                 input: process.stdin,
@@ -183,15 +263,14 @@ export const pushCommand = new Command('push')
         console.log('\nUploading...');
         const result = await uploadPack(serverUrl, token, buffer, packId);
         if (result.success) {
-            console.log(chalk.green('\nUpload successful!'));
+            console.log(chalk.green('\nPush successful!'));
             if (result.message) {
                 console.log(`  ${result.message}`);
             }
-            console.log(`\nPack ${packId} v${version} is now available on the server.`);
-            console.log(chalk.gray('Run /kustom pack reload to apply changes in-game.'));
+            console.log(`\nPack ${packId} v${version} is now live on the server.`);
         }
         else {
-            console.error(chalk.red('\nUpload failed'));
+            console.error(chalk.red('\nPush failed'));
             if (result.error) {
                 console.error(chalk.red(`  ${result.error}`));
             }

package/dist/commands/validate.js

@@ -30,7 +30,7 @@ export const validateCommand = new Command('validate')
     }
     console.log('Validating scripts...');
     // Find all TypeScript files
-    const patterns = config.include || ['scripts/**/*.ts', 'blocks/**/*.ts', 'items/**/*.ts'];
+    const patterns = config.include || ['scripts/**/*.ts'];
     const excludePatterns = config.exclude || [];
     const files = [];
     for (const pattern of patterns) {

package/dist/config.d.ts

@@ -37,10 +37,6 @@ export interface KustomConfig {
     dependencies?: string[];
     /** Server connection settings */
     server?: ServerConfig;
-    deploy?: {
-        target?: string;
-        reloadCommand?: string;
-    };
     bundle?: {
         output?: string;
         include?: string[];
@@ -84,3 +80,9 @@ export declare function parseCrossPackImport(importPath: string): {
  * Create a fully qualified namespaced ID.
  */
 export declare function createNamespacedId(packId: string, type: string, name: string): string;
+/**
+ * Update the server.url in kustom.config.json.
+ * Preserves all other config properties.
+ * Returns true if the file was updated, false if no config file exists.
+ */
+export declare function saveConfigServerUrl(cwd: string, serverUrl: string): boolean;

package/dist/config.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 const defaultConfig = {
-    include: ['scripts/**/*.ts', 'blocks/**/*.ts', 'items/**/*.ts'],
+    include: ['scripts/**/*.ts'],
     exclude: ['**/*.test.ts', '**/*.spec.ts'],
     outDir: 'dist',
     lib: ['scripts/lib'],
@@ -15,10 +15,6 @@ const defaultConfig = {
     server: {
         url: 'http://localhost:8765'
     },
-    deploy: {
-        target: '../run/plugins/kustom-plugin/packs',
-        reloadCommand: '/kustom pack reload'
-    },
     bundle: {
         output: 'dist/kustompack.zip',
         include: ['**/*.js', 'textures/**/*', 'gui/**/*', 'models/**/*', 'sounds/**/*']
@@ -41,7 +37,6 @@ export function loadConfig(cwd) {
                     id: userConfig.manifest?.id || defaultConfig.manifest?.id || 'my-pack'
                 },
                 server: { ...defaultConfig.server, ...userConfig.server },
-                deploy: { ...defaultConfig.deploy, ...userConfig.deploy },
                 bundle: { ...defaultConfig.bundle, ...userConfig.bundle }
             };
             return merged;
@@ -164,3 +159,27 @@ export function parseCrossPackImport(importPath) {
 export function createNamespacedId(packId, type, name) {
     return `${packId}:${type}/${name}`;
 }
+/**
+ * Update the server.url in kustom.config.json.
+ * Preserves all other config properties.
+ * Returns true if the file was updated, false if no config file exists.
+ */
+export function saveConfigServerUrl(cwd, serverUrl) {
+    const configPath = path.join(cwd, 'kustom.config.json');
+    if (!fs.existsSync(configPath)) {
+        return false;
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content);
+        if (!config.server || typeof config.server !== 'object') {
+            config.server = {};
+        }
+        config.server.url = serverUrl;
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}