@microtronics/studio-cli 0.44.0 → 0.45.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.45.0 (2026-02-04)
+
+### Features
+
+* add development deployment workflow with USB and myDatanet integration ([0503666](https://bitbucket.org/microtronics-core/vscode-studio/commits/05036666d0a80f419b76ed4140037e11281d0621))
+* add VSCode extension support to MyDatanetClient ([67866fc](https://bitbucket.org/microtronics-core/vscode-studio/commits/67866fc2ab069a108df4594124fcb38b13ca1b68))
+
 ## 0.44.0 (2026-01-19)
 
 ## 0.43.0 (2026-01-19)

package/README.md

@@ -117,6 +117,57 @@ $ studio-cli pack --phase alpha
 $ studio-cli pack --env wynni
 ```
 
+### run
+Build, upload to USB device, and create development site on myDatanet. This command is designed for development and integration testing purposes.
+
+```console
+$ studio-cli run -s <serial> --server <url> [options]
+```
+
+**Options:**
+- `-s, --serial <serial>` - Device serial number (16 characters hex) **[required]**
+- `--server <url>` - myDatanet instance URL (https:// prefix optional). Defaults to `MYDATANET_HOST` environment variable
+- `--customer <customerId>` - myDatanet customer UID or ID. Defaults to `MYDATANET_CUSTOMER` environment variable
+- `--mdn-token <token>` - myDatanet API token. Defaults to `MYDATANET_TOKEN` environment variable
+- `-p, --part <APM part>` - APM part that should be built
+  - Available parts: `dde`, `dlo`, `pov`, `blo`, `dfiles`
+- `-e, --env <environment>` - CLI target environment
+  - Available environments: `lucky`, `wynni`, `production` (default)
+- `--token <API-token>` - Studio API Access Token
+- `--debug` - Enable debug logging
+
+**Exit Codes:**
+- `0` - Success
+- `1` - Build failed
+- `2` - USB device not found
+- `3` - USB upload failed
+- `4` - myDatanet authentication failed
+- `5` - Development tag upload failed
+- `6` - Site creation failed
+
+**Output:**
+On success, the command outputs:
+- Site UID of the newly created/reused development site
+- APM ID of the development tag
+
+**Examples:**
+```console
+# Basic usage with environment variables
+$ export MYDATANET_TOKEN=your_token
+$ export MYDATANET_HOST=myserver.mydatanet.net
+$ export MYDATANET_CUSTOMER=your_customer_id
+$ studio-cli run -s 1234567890ABCDEF
+
+# Explicit options
+$ studio-cli run -s 1234567890ABCDEF --server myserver.mydatanet.net --customer CUST123 --mdn-token your_token
+
+# With build part selection
+$ studio-cli run -s 1234567890ABCDEF --server myserver.mydatanet.net --part dlo --debug
+
+# With manifest overrides
+$ studio-cli run -s 1234567890ABCDEF --server myserver.mydatanet.net --dlo.mainFile="./dlo/test.dlo"
+```
+
 ### usb
 USB device management commands.
 

package/dist/studio-cli.d.ts

@@ -135,6 +135,11 @@ export declare function build(cwd: URI, fs: LocalFS, logger: Log.Logger, env: Gl
     [APM.Part.dfiles]: Diagnostics.File[];
 }>;
 
+/**
+ * Build development installation info from manifest and options
+ */
+export declare function buildDevelopmentInstallInfo(cwd: URI, fs: LocalFS, serialNumber: string, userName: string, customerUid: string | null): Promise<DevelopmentInstallInfo>;
+
 declare interface components {
     schemas: {
         /** @default 25 */
@@ -1708,6 +1713,23 @@ export declare namespace Dependencies {
     export function getApmPartDependencies(cwd: URI, fs: LocalFS, apmPart: APM.Part.dlo | APM.Part.dfiles): Promise<APMPartLibrary[]>;
 }
 
+/**
+ * Development installation information
+ */
+export declare interface DevelopmentInstallInfo {
+    apmId: string;
+    applicationId: string | null;
+    name: string;
+    version: number;
+    serialNumber?: string;
+    siteUid: string | null;
+    siteName?: string;
+    customerUid: string | null;
+    customerName?: string;
+    /** Whether a registration code is needed (used by VSCode extension) */
+    registrationCodeNeeded?: boolean;
+}
+
 export declare const DeviceProfiles: any;
 
 export declare namespace DFILES {
@@ -1947,6 +1969,11 @@ declare enum FileType {
     SymbolicLink = 64
 }
 
+/**
+ * Generate a development APM ID based on a reference string
+ */
+export declare function generateDevApmId(developmentReference: string): string;
+
 export declare namespace Globals {
     /**
      * Supported ENV for the studio environment
@@ -2035,6 +2062,16 @@ export declare namespace Helper {
     export function defer(token: string, timeout: number, callback: any): void;
 }
 
+/**
+ * HTTP methods supported by the myDatanet API
+ */
+export declare enum HttpMethod {
+    Get = "GET",
+    Post = "POST",
+    Put = "PUT",
+    Delete = "DELETE"
+}
+
 /**
  * Installs the specified dependencies or all dependencies if none are provided.
  *
@@ -2311,6 +2348,134 @@ export declare namespace Manifest {
     export function isApmPartEnabled(cwd: URI, fs: LocalFS, apmPart: APM.Part, manifest?: Manifest.Manifest): Promise<boolean>;
 }
 
+/**
+ * MyDatanet API client for CLI and extension operations
+ */
+export declare class MyDatanetClient {
+    private domain;
+    private auth;
+    private logger?;
+    private userInfo;
+    /**
+     * Create a new MyDatanetClient
+     * @param serverUrl - Server URL (https:// prefix is optional)
+     * @param apiTokenOrLogger - API token string OR Logger instance for backward compatibility
+     * @param loggerOrUndefined - Logger instance (only when apiTokenOrLogger is a string)
+     */
+    constructor(serverUrl: string, apiTokenOrLogger: string | Log.Logger, loggerOrUndefined?: Log.Logger);
+    /**
+     * Create a new MyDatanetClient with options
+     * @param options - Client configuration options
+     */
+    constructor(options: MyDatanetClientOptions);
+    /**
+     * Set or update the authentication header
+     */
+    setAuth(authHeader: string): void;
+    /**
+     * Get the current domain
+     */
+    getDomain(): string;
+    /**
+     * Normalize server URL to ensure https:// prefix
+     */
+    private normalizeServerUrl;
+    /**
+     * Remove protocol from domain for display purposes
+     */
+    private trimDomain;
+    /**
+     * Make an authenticated JSON request to the myDatanet API
+     */
+    fetchJSON<T>(method: HttpMethod, path: string, body?: any): Promise<T>;
+    /**
+     * Authenticate and get user information
+     */
+    authenticate(): Promise<MyDatanetUserInfo>;
+    /**
+     * Get the current user info (must call authenticate first)
+     */
+    getUserInfo(): MyDatanetUserInfo | null;
+    /**
+     * Upload a development APM tag to the app-center
+     */
+    uploadDevTag(apmId: string, apmBuffer: FormData): Promise<string>;
+    /**
+     * Get customer information by UID or name
+     */
+    getCustomer(customerIdOrUid: string): Promise<MyDatanetCustomer>;
+    /**
+     * Get all customers accessible by the current user
+     */
+    getCustomers(): Promise<MyDatanetCustomer[]>;
+    /**
+     * Get device site information
+     */
+    getDeviceSite(serialNumber: string): Promise<{
+        app: {
+            phase: string;
+            apmid: string;
+            appl_id: string;
+        };
+        _uid: string;
+        name: string;
+        customer_uid: string;
+    } | null>;
+    /**
+     * Get device information
+     */
+    getDevice(serialNumber: string): Promise<{
+        customer_uid: string;
+    } | null>;
+    /**
+     * Get or create a site by name within a customer
+     */
+    getSite(customerUid: string, siteName: string): Promise<{
+        _uid: string;
+        name: string;
+    } | null>;
+    /**
+     * Create a development site
+     */
+    createDevelopmentSite(customerUid: string, installInfo: DevelopmentInstallInfo, registrationCode?: string): Promise<string>;
+    /**
+     * Update site name
+     */
+    updateSiteName(siteUid: string, name: string): Promise<void>;
+}
+
+/**
+ * Options for creating a MyDatanetClient
+ */
+export declare interface MyDatanetClientOptions {
+    /** Server URL (https:// prefix is optional) */
+    serverUrl: string;
+    /** API token for Bearer authentication */
+    apiToken?: string;
+    /** Pre-formatted authentication header (e.g., "Basic 1-xxx" or "Bearer xxx") */
+    authHeader?: string;
+    /** Logger instance (optional) */
+    logger?: Log.Logger;
+}
+
+/**
+ * Customer information from myDatanet
+ */
+export declare interface MyDatanetCustomer {
+    _uid: string;
+    name: string;
+}
+
+/**
+ * User information returned from myDatanet /api/1/me endpoint
+ */
+export declare interface MyDatanetUserInfo {
+    name: string;
+    email: string;
+    group?: number;
+    customers?: MyDatanetCustomer[];
+}
+
 /**
  * Packs the given directory into a deployable package using the specified configuration.
  *

package/out/api.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Log = exports.ENV = exports.DFILES = exports.Library = exports.APM = exports.Package = exports.DLO = exports.Globals = exports.DeviceProfiles = exports.DefaultFiles = exports.Diagnostics = exports.Helper = exports.DDE = exports.DDE_Core = exports.Registry = exports.Manifest = exports.Dependencies = void 0;
+exports.buildDevelopmentInstallInfo = exports.generateDevApmId = exports.HttpMethod = exports.MyDatanetClient = exports.Log = exports.ENV = exports.DFILES = exports.Library = exports.APM = exports.Package = exports.DLO = exports.Globals = exports.DeviceProfiles = exports.DefaultFiles = exports.Diagnostics = exports.Helper = exports.DDE = exports.DDE_Core = exports.Registry = exports.Manifest = exports.Dependencies = void 0;
 exports.install = install;
 exports.build = build;
 exports.publish = publish;
@@ -134,4 +134,10 @@ async function publish(cwd, fs, logger, env, apiToken, optsAllowedBackends, opts
 async function pack(cwd, fs, logger, env, apiToken, optsPhase) {
     return package_1.Package.pack(cwd, fs, logger, env, apiToken, optsPhase);
 }
+// Re-export myDatanet client types and helpers for external use
+var myDatanetClient_1 = require("./myDatanetClient");
+Object.defineProperty(exports, "MyDatanetClient", { enumerable: true, get: function () { return myDatanetClient_1.MyDatanetClient; } });
+Object.defineProperty(exports, "HttpMethod", { enumerable: true, get: function () { return myDatanetClient_1.HttpMethod; } });
+Object.defineProperty(exports, "generateDevApmId", { enumerable: true, get: function () { return myDatanetClient_1.generateDevApmId; } });
+Object.defineProperty(exports, "buildDevelopmentInstallInfo", { enumerable: true, get: function () { return myDatanetClient_1.buildDevelopmentInstallInfo; } });
 //# sourceMappingURL=api.js.map

package/out/main.js

@@ -14,6 +14,7 @@ const api_1 = require("./api");
 const log_1 = require("./log");
 const argumentParser_1 = require("./argumentParser");
 const usb_1 = require("./usb");
+const run_1 = require("./run");
 const program = new commander_1.Command();
 const notifier = (0, update_notifier_1.default)({ pkg: package_json_1.default });
 const logger = new log_1.Log.Logger();
@@ -98,6 +99,30 @@ const releasePhaseArguments = Object.values(apm_1.APM.TagPhase);
 const optionReleasePhase = new commander_1.Option('-ph --phase <release phase>', 'specify a release phase')
     .choices(releasePhaseArguments)
     .default('release');
+/**
+ * Option for specifying the APM part to build
+ */
+const optionApmPart = new commander_1.Option('-p --part <APM part>', 'APM part that should be built').choices(Object.values(apm_1.APM.Part));
+/**
+ * Option for device serial number (16 characters hex)
+ */
+const optionDeviceSerial = new commander_1.Option('-s, --serial <serial>', 'Device serial number (16 characters hex)');
+/**
+ * Option for enabling debug logging
+ */
+const optionDebug = new commander_1.Option('--debug', 'Enable debug logging').default(false);
+/**
+ * Option for myDatanet instance URL
+ */
+const optionMdnServer = new commander_1.Option('--server <url>', 'myDatanet instance URL (https:// prefix optional)').default(process.env['MYDATANET_HOST']);
+/**
+ * Option for myDatanet customer UID or ID
+ */
+const optionMdnCustomer = new commander_1.Option('--customer <customerId>', 'myDatanet customer UID or ID').default(process.env['MYDATANET_CUSTOMER']);
+/**
+ * Option for myDatanet API token
+ */
+const optionMdnToken = new commander_1.Option('--mdn-token <token>', 'myDatanet API token').default(process.env['MYDATANET_TOKEN']);
 program
     .command('install')
     .aliases(['i'])
@@ -113,7 +138,7 @@ program
 });
 program
     .command('build')
-    .addOption(new commander_1.Option('-p --part <APM part>', 'APM part that should be build').choices(Object.values(apm_1.APM.Part)))
+    .addOption(optionApmPart)
     .allowExcessArguments(true)
     .addOption(optionStudioEnv)
     .addOption(optionStudioToken)
@@ -146,6 +171,53 @@ program
     const { env, token } = getDefaultOptions(opts);
     main(command, (0, api_1.pack)(cwd, cliFS_1.cliFS, logger, env, token, opts.phase));
 });
+// Run command - Build, upload to device, and create development site
+program
+    .command('run')
+    .description('Build, upload to USB device, and create development site on myDatanet')
+    .addOption(optionDeviceSerial.makeOptionMandatory(true))
+    .addOption(optionMdnServer)
+    .addOption(optionMdnCustomer)
+    .addOption(optionMdnToken)
+    .addOption(optionApmPart)
+    .addOption(optionStudioEnv)
+    .addOption(optionStudioToken)
+    .addOption(optionDebug)
+    .allowUnknownOption(true)
+    .action(async (opts, command) => {
+    const { env, token } = getDefaultOptions(opts);
+    const mdnToken = opts.mdnToken;
+    const server = opts.server;
+    // Validate required options
+    if (!mdnToken) {
+        logger.error('MYDATANET_TOKEN is required. Set via --mdn-token or MYDATANET_TOKEN environment variable');
+        notifier.notify();
+        process.exit(run_1.RunExitCode.AuthenticationFailed);
+    }
+    if (!server) {
+        logger.error('Server URL is required. Set via --server or MYDATANET_HOST environment variable');
+        notifier.notify();
+        process.exit(run_1.RunExitCode.AuthenticationFailed);
+    }
+    const manifestOptions = (0, argumentParser_1.parseUnknownLongOptions)(command);
+    api_1.Manifest.setOverwrites(manifestOptions);
+    const result = await (0, run_1.run)(cwd, cliFS_1.cliFS, logger, env, token, {
+        serial: opts.serial,
+        server: server,
+        customer: opts.customer,
+        mdnToken: mdnToken,
+        debug: opts.debug,
+        part: opts.part ? [opts.part] : undefined
+    });
+    notifier.notify();
+    if (result.success) {
+        process.exit(run_1.RunExitCode.Success);
+    }
+    else {
+        logger.error(result.message);
+        process.exit(result.errorCode || 1);
+    }
+});
 // USB commands
 const usbCommand = program.command('usb').description('USB device management commands');
 usbCommand
@@ -158,9 +230,9 @@ usbCommand
 usbCommand
     .command('upload')
     .description('Upload an AMX binary to a USB device')
-    .requiredOption('-s, --serial <serial>', 'Device serial number (16 characters hex)')
+    .addOption(optionDeviceSerial.makeOptionMandatory(true))
     .requiredOption('-f, --file <path>', 'Path to the AMX file (relative to current directory)')
-    .requiredOption('--debug', 'Enable debug logging', false)
+    .addOption(optionDebug)
     .action(async (opts) => {
     const fileUri = vscode_uri_1.Utils.joinPath(cwd, opts.file);
     const result = await (0, usb_1.uploadToDevice)(opts.serial, fileUri, cliFS_1.cliFS, logger, opts.debug);

package/out/myDatanetClient.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyDatanetClient = exports.RunExitCode = exports.HttpMethod = void 0;
+exports.generateDevApmId = generateDevApmId;
+exports.buildDevelopmentInstallInfo = buildDevelopmentInstallInfo;
+const manifest_1 = require("./manifest");
+const apm_1 = require("./package/apm");
+const uuid_1 = require("uuid");
+// Used to generate reproducible apmids
+const UUID_NAMESPACE = 'b4baec47-0ba4-4e37-b237-8f9cde42b8dd';
+/**
+ * HTTP methods supported by the myDatanet API
+ */
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["Get"] = "GET";
+    HttpMethod["Post"] = "POST";
+    HttpMethod["Put"] = "PUT";
+    HttpMethod["Delete"] = "DELETE";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+/**
+ * Exit codes for the run command
+ */
+var RunExitCode;
+(function (RunExitCode) {
+    RunExitCode[RunExitCode["Success"] = 0] = "Success";
+    RunExitCode[RunExitCode["BuildFailed"] = 1] = "BuildFailed";
+    RunExitCode[RunExitCode["DeviceNotFound"] = 2] = "DeviceNotFound";
+    RunExitCode[RunExitCode["UsbUploadFailed"] = 3] = "UsbUploadFailed";
+    RunExitCode[RunExitCode["AuthenticationFailed"] = 4] = "AuthenticationFailed";
+    RunExitCode[RunExitCode["DevTagUploadFailed"] = 5] = "DevTagUploadFailed";
+    RunExitCode[RunExitCode["SiteCreationFailed"] = 6] = "SiteCreationFailed";
+})(RunExitCode || (exports.RunExitCode = RunExitCode = {}));
+/**
+ * MyDatanet API client for CLI and extension operations
+ */
+class MyDatanetClient {
+    domain;
+    auth;
+    logger;
+    userInfo = null;
+    constructor(serverUrlOrOptions, apiTokenOrLogger, loggerOrUndefined) {
+        if (typeof serverUrlOrOptions === 'object') {
+            // New options-based constructor
+            const { serverUrl, apiToken, authHeader, logger } = serverUrlOrOptions;
+            this.domain = this.normalizeServerUrl(serverUrl);
+            this.auth = authHeader || (apiToken ? `Bearer ${apiToken}` : '');
+            this.logger = logger;
+        }
+        else {
+            // Legacy constructor for backward compatibility
+            this.domain = this.normalizeServerUrl(serverUrlOrOptions);
+            if (typeof apiTokenOrLogger === 'string') {
+                this.auth = `Bearer ${apiTokenOrLogger}`;
+                this.logger = loggerOrUndefined;
+            }
+            else {
+                this.auth = '';
+                this.logger = apiTokenOrLogger;
+            }
+        }
+    }
+    /**
+     * Set or update the authentication header
+     */
+    setAuth(authHeader) {
+        this.auth = authHeader;
+    }
+    /**
+     * Get the current domain
+     */
+    getDomain() {
+        return this.domain;
+    }
+    /**
+     * Normalize server URL to ensure https:// prefix
+     */
+    normalizeServerUrl(url) {
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            return `https://${url}`;
+        }
+        return url;
+    }
+    /**
+     * Remove protocol from domain for display purposes
+     */
+    trimDomain(domain) {
+        return domain.replace(/(^\w+:|^)\/\//, '');
+    }
+    /**
+     * Make an authenticated JSON request to the myDatanet API
+     */
+    async fetchJSON(method, path, body) {
+        const url = `${this.domain}${path}`;
+        const headers = {
+            Authorization: this.auth
+        };
+        const options = {
+            method,
+            headers
+        };
+        if (body) {
+            if (body instanceof FormData) {
+                options.body = body;
+            }
+            else {
+                headers['Content-Type'] = 'application/json';
+                options.body = JSON.stringify(body);
+            }
+        }
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => 'Unknown error');
+            throw new Error(`HTTP ${response.status}: ${errorText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Authenticate and get user information
+     */
+    async authenticate() {
+        this.logger?.info(`Authenticating with ${this.trimDomain(this.domain)}...`);
+        try {
+            const { user, customers } = await this.fetchJSON(HttpMethod.Get, '/api/1/me');
+            this.userInfo = {
+                name: user.name,
+                email: user.email,
+                group: user.group,
+                customers: customers
+            };
+            this.logger?.info(`Authenticated as ${this.userInfo.name}`);
+            return this.userInfo;
+        }
+        catch (error) {
+            throw new Error(`Authentication failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get the current user info (must call authenticate first)
+     */
+    getUserInfo() {
+        return this.userInfo;
+    }
+    /**
+     * Upload a development APM tag to the app-center
+     */
+    async uploadDevTag(apmId, apmBuffer) {
+        this.logger?.info(`Uploading development tag ${apmId}...`);
+        const { applid } = await this.fetchJSON(HttpMethod.Post, `/api/1/app-center/__dev/${apmId}`, apmBuffer);
+        this.logger?.info(`Development tag uploaded, application ID: ${applid}`);
+        return applid;
+    }
+    /**
+     * Get customer information by UID or name
+     */
+    async getCustomer(customerIdOrUid) {
+        const { _uid, name } = await this.fetchJSON(HttpMethod.Get, `/api/1/customers/${customerIdOrUid}`);
+        return { _uid, name };
+    }
+    /**
+     * Get all customers accessible by the current user
+     */
+    async getCustomers() {
+        return this.fetchJSON(HttpMethod.Get, '/api/1/customers');
+    }
+    /**
+     * Get device site information
+     */
+    async getDeviceSite(serialNumber) {
+        try {
+            return await this.fetchJSON(HttpMethod.Get, `/api/1/devices/${serialNumber}/site`);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get device information
+     */
+    async getDevice(serialNumber) {
+        try {
+            return await this.fetchJSON(HttpMethod.Get, `/api/1/devices/${serialNumber}`);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get or create a site by name within a customer
+     */
+    async getSite(customerUid, siteName) {
+        try {
+            return await this.fetchJSON(HttpMethod.Get, `/api/1/customers/${customerUid}/sites/${siteName}`);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Create a development site
+     */
+    async createDevelopmentSite(customerUid, installInfo, registrationCode) {
+        this.logger?.info(`Creating development site "${installInfo.name}"...`);
+        // Check if device is already attached to a site
+        if (installInfo.serialNumber) {
+            const existingSite = await this.getSite(customerUid, installInfo.name.toLowerCase());
+            if (existingSite) {
+                // Try to attach device to existing site
+                try {
+                    await this.fetchJSON(HttpMethod.Post, `/api/1/customers/${customerUid}/sites/${existingSite._uid}/cn-attach-device`, {
+                        device_id: installInfo.serialNumber,
+                        allow_overwrite: true,
+                        detach_from_old_site: true,
+                        acquire: true,
+                        create: true
+                    });
+                    this.logger?.info(`Device attached to existing site ${existingSite._uid}`);
+                    return existingSite._uid;
+                }
+                catch (error) {
+                    // 304 means device is already attached - that's OK
+                    if (error.message && !error.message.includes('304')) {
+                        this.logger?.warn(`Could not attach device to existing site: ${error.message}`);
+                    }
+                    else {
+                        return existingSite._uid;
+                    }
+                }
+            }
+        }
+        // Create new site
+        const { _uid } = await this.fetchJSON(HttpMethod.Post, `/api/1/customers/${customerUid}/sites`, {
+            name: installInfo.name,
+            create: true,
+            force: true,
+            note: 'This is a Studio development site',
+            applid: installInfo.applicationId,
+            device_id: installInfo.serialNumber,
+            reg_code: registrationCode,
+            servicetariff: '0000000000000000',
+            servicetariff_indiv_cost: 0
+        });
+        this.logger?.info(`Development site created: ${_uid}`);
+        return _uid;
+    }
+    /**
+     * Update site name
+     */
+    async updateSiteName(siteUid, name) {
+        try {
+            await this.fetchJSON(HttpMethod.Put, `/api/1/sites/${siteUid}`, { name });
+        }
+        catch {
+            // Ignore update failures
+        }
+    }
+}
+exports.MyDatanetClient = MyDatanetClient;
+/**
+ * Generate a development APM ID based on a reference string
+ */
+function generateDevApmId(developmentReference) {
+    return (0, uuid_1.v5)(developmentReference, UUID_NAMESPACE);
+}
+/**
+ * Build development installation info from manifest and options
+ */
+async function buildDevelopmentInstallInfo(cwd, fs, serialNumber, userName, customerUid) {
+    const manifest = await manifest_1.Manifest.read(cwd, fs);
+    const currentUserId = userName.replaceAll(' ', '_').replace(/[^a-zA-Z0-9-]+/g, '');
+    const appName = manifest.name.replaceAll(' ', '_').replace(/[^a-zA-Z0-9-]+/g, '');
+    const hasDlo = await manifest_1.Manifest.isApmPartEnabled(cwd, fs, apm_1.APM.Part.dlo, manifest);
+    const useDeviceSerial = hasDlo && serialNumber;
+    const siteName = useDeviceSerial ? serialNumber.toUpperCase() : `${appName}_${currentUserId}`;
+    const developmentReference = useDeviceSerial ? serialNumber : siteName;
+    return {
+        apmId: generateDevApmId(developmentReference),
+        applicationId: null,
+        name: `Development_${siteName}`,
+        version: 1,
+        serialNumber: hasDlo ? serialNumber : undefined,
+        siteUid: null,
+        customerUid: customerUid
+    };
+}
+//# sourceMappingURL=myDatanetClient.js.map

package/out/run.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunExitCode = void 0;
+exports.run = run;
+const vscode_uri_1 = require("vscode-uri");
+const apm_1 = require("./package/apm");
+const defaultFiles_1 = require("./defaultFiles");
+const package_1 = require("./package/package");
+const manifest_1 = require("./manifest");
+const myDatanetClient_1 = require("./myDatanetClient");
+Object.defineProperty(exports, "RunExitCode", { enumerable: true, get: function () { return myDatanetClient_1.RunExitCode; } });
+const usb_1 = require("./usb");
+/**
+ * Helper to extract error message from unknown error
+ */
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Helper to create a failure result
+ */
+function failureResult(errorCode, message) {
+    return { success: false, errorCode, message };
+}
+/**
+ * Step 1: Build the project
+ */
+async function buildProject(ctx) {
+    const { cwd, fs, logger, env, apiToken, options } = ctx;
+    logger.info('[1/5] Building project...');
+    try {
+        const partsToBuild = options.part ? options.part : true;
+        await manifest_1.Manifest.validateBasicManifest(cwd, fs, null);
+        await package_1.Package.buildAll(cwd, fs, logger, env, apiToken, partsToBuild, true);
+        logger.done('Build completed successfully');
+        return null;
+    }
+    catch (error) {
+        return failureResult(myDatanetClient_1.RunExitCode.BuildFailed, `Build failed: ${getErrorMessage(error)}`);
+    }
+}
+/**
+ * Step 2: Find and validate USB device
+ */
+async function findDevice(ctx) {
+    const { logger, options } = ctx;
+    const { serial } = options;
+    logger.info(`[2/5] Searching for USB device with serial: ${serial}...`);
+    const device = await (0, usb_1.findDeviceBySerialNumber)(serial);
+    if (!device) {
+        return failureResult(myDatanetClient_1.RunExitCode.DeviceNotFound, `USB device not found with serial number: ${serial}`);
+    }
+    logger.done(`Device found: ${device.productName}`);
+    return device;
+}
+/**
+ * Step 3: Upload binary to USB device
+ */
+async function uploadToUsbDevice(ctx) {
+    const { cwd, fs, logger, options } = ctx;
+    const { serial, debug } = options;
+    logger.info('[3/5] Uploading binary to USB device...');
+    const amxPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.mainAmxPath);
+    const uploadResult = await (0, usb_1.uploadToDevice)(serial, amxPath, fs, logger, debug);
+    if (!uploadResult.success) {
+        return failureResult(myDatanetClient_1.RunExitCode.UsbUploadFailed, `USB upload failed: ${uploadResult.message}`);
+    }
+    logger.done('USB upload completed');
+    return null;
+}
+/**
+ * Step 4a: Authenticate with myDatanet
+ */
+async function authenticateWithMyDatanet(mdnClient, logger) {
+    logger.info('[4/5] Connecting to myDatanet server...');
+    try {
+        return await mdnClient.authenticate();
+    }
+    catch (error) {
+        return failureResult(myDatanetClient_1.RunExitCode.AuthenticationFailed, `myDatanet authentication failed: ${getErrorMessage(error)}`);
+    }
+}
+/**
+ * Step 4b: Resolve customer UID
+ */
+async function resolveCustomer(mdnClient, customer, logger) {
+    if (customer) {
+        try {
+            const customerInfo = await mdnClient.getCustomer(customer);
+            logger.info(`Using customer: ${customerInfo.name} (${customerInfo._uid})`);
+            return customerInfo._uid;
+        }
+        catch {
+            return failureResult(myDatanetClient_1.RunExitCode.SiteCreationFailed, `Customer "${customer}" not found`);
+        }
+    }
+    // Try to get customer from available customers
+    const customers = await mdnClient.getCustomers();
+    if (customers.length === 0) {
+        return failureResult(myDatanetClient_1.RunExitCode.SiteCreationFailed, 'No customers available. Please specify --customer or set MYDATANET_CUSTOMER');
+    }
+    if (customers.length === 1) {
+        logger.info(`Using customer: ${customers[0].name} (${customers[0]._uid})`);
+        return customers[0]._uid;
+    }
+    const customerNames = customers.map(c => c.name).join(', ');
+    return failureResult(myDatanetClient_1.RunExitCode.SiteCreationFailed, `Multiple customers available. Please specify --customer or set MYDATANET_CUSTOMER. Available: ${customerNames}`);
+}
+/**
+ * Step 4c: Update install info with existing site data if available
+ */
+async function updateInstallInfoFromExistingSite(mdnClient, serial, installInfo, logger) {
+    const existingSite = await mdnClient.getDeviceSite(serial);
+    if (!existingSite) {
+        return;
+    }
+    if (existingSite.app.phase === 'dev') {
+        installInfo.apmId = existingSite.app.apmid;
+        installInfo.applicationId = existingSite.app.appl_id;
+    }
+    installInfo.siteUid = existingSite._uid;
+    installInfo.siteName = existingSite.name;
+    installInfo.customerUid = existingSite.customer_uid;
+    logger.info(`Found existing site: ${existingSite.name}`);
+}
+/**
+ * Step 4d: Create and upload development APM tag
+ */
+async function uploadDevTag(ctx, mdnClient, installInfo) {
+    const { cwd, fs, logger } = ctx;
+    logger.info('Creating development APM tag...');
+    try {
+        const apmBuffer = await apm_1.APM.createDevTag(cwd, fs);
+        const applicationId = await mdnClient.uploadDevTag(installInfo.apmId, apmBuffer);
+        installInfo.applicationId = applicationId;
+        logger.done('Development tag uploaded');
+        return null;
+    }
+    catch (error) {
+        return failureResult(myDatanetClient_1.RunExitCode.DevTagUploadFailed, `Development tag upload failed: ${getErrorMessage(error)}`);
+    }
+}
+/**
+ * Step 5: Create or update development site
+ */
+async function createOrUpdateSite(mdnClient, customerUid, installInfo, logger) {
+    logger.info('[5/5] Creating development site...');
+    try {
+        if (installInfo.siteUid) {
+            // Update site name if different
+            if (installInfo.siteName !== installInfo.name) {
+                await mdnClient.updateSiteName(installInfo.siteUid, installInfo.name);
+            }
+            logger.info(`Reusing existing site: ${installInfo.siteUid}`);
+            return installInfo.siteUid;
+        }
+        return await mdnClient.createDevelopmentSite(customerUid, installInfo);
+    }
+    catch (error) {
+        return failureResult(myDatanetClient_1.RunExitCode.SiteCreationFailed, `Site creation failed: ${getErrorMessage(error)}`);
+    }
+}
+/**
+ * Log the deployment summary
+ */
+function logDeploymentSummary(logger, siteUid, apmId) {
+    logger.done('Development deployment completed successfully!');
+    logger.info('');
+    logger.info('=== Deployment Summary ===');
+    logger.info(`Site UID: ${siteUid}`);
+    logger.info(`APM ID: ${apmId}`);
+    logger.info('==========================');
+}
+/**
+ * Check if result is a failure
+ */
+function isFailure(result) {
+    return typeof result === 'object' && result !== null && 'errorCode' in result;
+}
+/**
+ * Builds, uploads to USB device, and creates a development site on myDatanet.
+ *
+ * This function orchestrates the complete development deployment workflow:
+ * 1. Builds the project
+ * 2. Uploads the binary to the USB device
+ * 3. Authenticates with myDatanet
+ * 4. Creates and uploads a development APM tag
+ * 5. Creates or reuses a development site
+ *
+ * @param {URI} cwd - The current working directory of the project.
+ * @param {LocalFS} fs - The file system interface for file operations.
+ * @param {Log.Logger} logger - Logger instance for logging progress.
+ * @param {Globals.ENV} env - The environment configuration.
+ * @param {string | null} apiToken - The Studio API token for registry operations.
+ * @param {RunOptions} options - Options for the run command.
+ * @return {Promise<RunResult>} A promise that resolves to the result of the run command.
+ */
+async function run(cwd, fs, logger, env, apiToken, options) {
+    const ctx = { cwd, fs, logger, env, apiToken, options };
+    const { serial, server, customer, mdnToken } = options;
+    logger.info('Starting development deployment...');
+    // Step 1: Build the project
+    const buildResult = await buildProject(ctx);
+    if (buildResult) {
+        return buildResult;
+    }
+    // Step 2: Find and validate USB device
+    const deviceResult = await findDevice(ctx);
+    if (isFailure(deviceResult)) {
+        return deviceResult;
+    }
+    // Step 3: Upload binary to USB device
+    const uploadResult = await uploadToUsbDevice(ctx);
+    if (uploadResult) {
+        return uploadResult;
+    }
+    // Step 4: myDatanet operations
+    const mdnClient = new myDatanetClient_1.MyDatanetClient(server, mdnToken, logger);
+    // 4a: Authenticate
+    const authResult = await authenticateWithMyDatanet(mdnClient, logger);
+    if (isFailure(authResult)) {
+        return authResult;
+    }
+    const userInfo = authResult;
+    // 4b: Resolve customer
+    const customerResult = await resolveCustomer(mdnClient, customer, logger);
+    if (isFailure(customerResult)) {
+        return customerResult;
+    }
+    const customerUid = customerResult;
+    // Build development install info
+    const installInfo = await (0, myDatanetClient_1.buildDevelopmentInstallInfo)(cwd, fs, serial, userInfo.name, customerUid);
+    // 4c: Check for existing site
+    await updateInstallInfoFromExistingSite(mdnClient, serial, installInfo, logger);
+    // 4d: Upload dev tag
+    const devTagResult = await uploadDevTag(ctx, mdnClient, installInfo);
+    if (devTagResult) {
+        return devTagResult;
+    }
+    // Step 5: Create or update development site
+    const siteResult = await createOrUpdateSite(mdnClient, customerUid, installInfo, logger);
+    if (isFailure(siteResult)) {
+        return siteResult;
+    }
+    const siteUid = siteResult;
+    logDeploymentSummary(logger, siteUid, installInfo.apmId);
+    return {
+        success: true,
+        siteUid,
+        apmId: installInfo.apmId,
+        message: 'Development deployment completed successfully'
+    };
+}
+//# sourceMappingURL=run.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@microtronics/studio-cli",
-	"version": "0.44.0",
+	"version": "0.45.0",
 	"description": "Microtronics Studio CLI Tool",
 	"main": "./out/api.js",
 	"typings": "./dist/studio-cli.d.ts",