@positronic/cli 0.0.2

package/dist/src/commands/helpers.js

@@ -0,0 +1,1315 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import process from 'process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import caz from 'caz';
+import { isText } from 'istextorbinary';
+import * as http from 'http';
+import * as https from 'https';
+import { URL } from 'url';
+import { createMinimalProject } from './test-utils.js';
+// Singleton API client instance
+export var apiClient = {
+    fetch: function(apiPath, options) {
+        return _async_to_generator(function() {
+            var port, baseUrl, fullUrl;
+            return _ts_generator(this, function(_state) {
+                port = process.env.POSITRONIC_PORT || '8787';
+                baseUrl = "http://localhost:".concat(port);
+                fullUrl = "".concat(baseUrl).concat(apiPath.startsWith('/') ? apiPath : '/' + apiPath);
+                return [
+                    2,
+                    fetch(fullUrl, options)
+                ];
+            });
+        })();
+    }
+};
+export function generateProject(projectName, projectDir) {
+    return _async_to_generator(function() {
+        var devPath, newProjectTemplatePath, cazOptions, originalNewProjectPkg, copiedNewProjectPkg;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!(process.env.NODE_ENV === 'test')) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        createMinimalProject(projectDir)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+                case 2:
+                    devPath = process.env.POSITRONIC_LOCAL_PATH;
+                    newProjectTemplatePath = '@positronic/template-new-project';
+                    cazOptions = {
+                        name: projectName
+                    };
+                    _state.label = 3;
+                case 3:
+                    _state.trys.push([
+                        3,
+                        ,
+                        5,
+                        6
+                    ]);
+                    if (devPath) {
+                        // Copying templates, why you ask?
+                        // Well because when caz runs if you pass it a path to the template module
+                        // (e.g. for development environment setting POSITRONIC_LOCAL_PATH)
+                        // it runs npm install --production in the template directory. This is a problem
+                        // in our monorepo because this messes up the node_modules at the root of the
+                        // monorepo which then causes the tests to fail. Also ny time I was generating a new
+                        // project it was a pain to have to run npm install over and over again just
+                        // to get back to a good state.
+                        originalNewProjectPkg = path.resolve(devPath, 'packages', 'template-new-project');
+                        copiedNewProjectPkg = fs.mkdtempSync(path.join(os.tmpdir(), 'positronic-newproj-'));
+                        fs.cpSync(originalNewProjectPkg, copiedNewProjectPkg, {
+                            recursive: true
+                        });
+                        newProjectTemplatePath = copiedNewProjectPkg;
+                        cazOptions = {
+                            name: projectName,
+                            install: true,
+                            pm: 'npm'
+                        };
+                    }
+                    // In test or CI environments, skip interactive prompts and dependency installation
+                    if (process.env.NODE_ENV === 'test') {
+                        cazOptions = _object_spread_props(_object_spread({}, cazOptions), {
+                            backend: 'none',
+                            install: false,
+                            pm: 'npm'
+                        });
+                    }
+                    return [
+                        4,
+                        caz.default(newProjectTemplatePath, projectDir, _object_spread_props(_object_spread({}, cazOptions), {
+                            force: false
+                        }))
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        3,
+                        6
+                    ];
+                case 5:
+                    // Clean up the temporary copied new project package
+                    if (devPath) {
+                        fs.rmSync(newProjectTemplatePath, {
+                            recursive: true,
+                            force: true,
+                            maxRetries: 3
+                        });
+                    }
+                    return [
+                        7
+                    ];
+                case 6:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+export function scanLocalResources(resourcesDir) {
+    var localResources = [];
+    var scanDirectory = function(dir, baseDir) {
+        var entries = fs.readdirSync(dir, {
+            withFileTypes: true
+        });
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var entry = _step.value;
+                var fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    // Recursively scan subdirectories
+                    scanDirectory(fullPath, baseDir);
+                } else if (entry.isFile()) {
+                    // Calculate relative path from resources directory
+                    var relativePath = path.relative(baseDir, fullPath);
+                    // Use forward slashes for consistency across platforms
+                    var key = relativePath.replace(/\\/g, '/');
+                    // Determine file type using istextorbinary
+                    // It checks both filename and content (first few bytes)
+                    var type = isText(entry.name, fs.readFileSync(fullPath)) ? 'text' : 'binary';
+                    localResources.push({
+                        key: key,
+                        path: fullPath,
+                        type: type
+                    });
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    };
+    scanDirectory(resourcesDir, resourcesDir);
+    return localResources;
+}
+/**
+ * Core resource sync logic without UI dependencies
+ */ export function syncResources(_0, _1) {
+    return _async_to_generator(function(projectRootPath) {
+        var client, onProgress, resourcesDir, localResources, response, errorText, data, serverResourceMap, localResourceKeys, uploadCount, skipCount, errorCount, deleteCount, errors, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, resource, fileStats, serverResource, shouldUpload, localModTime, fileContent, formData, uploadResponse, errorText1, error, err, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _step_value, key, serverResource1, deleteResponse, errorText2, error1, err;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    client = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : apiClient, onProgress = _arguments.length > 2 ? _arguments[2] : void 0;
+                    resourcesDir = path.join(projectRootPath, 'resources');
+                    // Ensure resources directory exists
+                    if (!fs.existsSync(resourcesDir)) {
+                        fs.mkdirSync(resourcesDir, {
+                            recursive: true
+                        });
+                    }
+                    localResources = scanLocalResources(resourcesDir);
+                    return [
+                        4,
+                        client.fetch('/resources')
+                    ];
+                case 1:
+                    response = _state.sent();
+                    if (!!response.ok) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        response.text()
+                    ];
+                case 2:
+                    errorText = _state.sent();
+                    throw new Error("Failed to fetch resources: ".concat(response.status, " ").concat(errorText));
+                case 3:
+                    return [
+                        4,
+                        response.json()
+                    ];
+                case 4:
+                    data = _state.sent();
+                    serverResourceMap = new Map(data.resources.map(function(r) {
+                        return [
+                            r.key,
+                            r
+                        ];
+                    }));
+                    // Create a set of local resource keys for easy lookup
+                    localResourceKeys = new Set(localResources.map(function(r) {
+                        return r.key;
+                    }));
+                    uploadCount = 0;
+                    skipCount = 0;
+                    errorCount = 0;
+                    deleteCount = 0;
+                    errors = [];
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 5;
+                case 5:
+                    _state.trys.push([
+                        5,
+                        16,
+                        17,
+                        18
+                    ]);
+                    _iterator = localResources[Symbol.iterator]();
+                    _state.label = 6;
+                case 6:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        15
+                    ];
+                    resource = _step.value;
+                    // Report progress for checking
+                    if (onProgress) {
+                        onProgress({
+                            currentFile: resource.key,
+                            action: 'checking',
+                            stats: {
+                                uploadCount: uploadCount,
+                                skipCount: skipCount,
+                                errorCount: errorCount,
+                                totalCount: localResources.length,
+                                deleteCount: deleteCount,
+                                errors: errors
+                            }
+                        });
+                    }
+                    fileStats = fs.statSync(resource.path);
+                    serverResource = serverResourceMap.get(resource.key);
+                    // Check if we need to upload (new or modified)
+                    shouldUpload = !serverResource;
+                    if (serverResource && serverResource.size !== fileStats.size) {
+                        // Size mismatch indicates file has changed
+                        shouldUpload = true;
+                    } else if (serverResource) {
+                        // For same-size files, check modification time if available
+                        localModTime = fileStats.mtime.toISOString();
+                        if (localModTime > serverResource.lastModified) {
+                            shouldUpload = true;
+                        }
+                    }
+                    if (!shouldUpload) return [
+                        3,
+                        13
+                    ];
+                    _state.label = 7;
+                case 7:
+                    _state.trys.push([
+                        7,
+                        11,
+                        ,
+                        12
+                    ]);
+                    // Report progress for uploading
+                    if (onProgress) {
+                        onProgress({
+                            currentFile: resource.key,
+                            action: 'uploading',
+                            stats: {
+                                uploadCount: uploadCount,
+                                skipCount: skipCount,
+                                errorCount: errorCount,
+                                totalCount: localResources.length,
+                                deleteCount: deleteCount,
+                                errors: errors
+                            }
+                        });
+                    }
+                    fileContent = fs.readFileSync(resource.path);
+                    formData = new FormData();
+                    formData.append('file', new Blob([
+                        fileContent
+                    ]), path.basename(resource.path));
+                    formData.append('type', resource.type);
+                    formData.append('path', resource.key);
+                    formData.append('key', resource.key);
+                    formData.append('local', 'true');
+                    return [
+                        4,
+                        client.fetch('/resources', {
+                            method: 'POST',
+                            body: formData
+                        })
+                    ];
+                case 8:
+                    uploadResponse = _state.sent();
+                    if (!!uploadResponse.ok) return [
+                        3,
+                        10
+                    ];
+                    return [
+                        4,
+                        uploadResponse.text()
+                    ];
+                case 9:
+                    errorText1 = _state.sent();
+                    throw new Error("Upload failed: ".concat(uploadResponse.status, " ").concat(errorText1));
+                case 10:
+                    uploadCount++;
+                    return [
+                        3,
+                        12
+                    ];
+                case 11:
+                    error = _state.sent();
+                    errorCount++;
+                    errors.push({
+                        file: resource.key,
+                        message: error.message || 'Unknown error'
+                    });
+                    return [
+                        3,
+                        12
+                    ];
+                case 12:
+                    return [
+                        3,
+                        14
+                    ];
+                case 13:
+                    skipCount++;
+                    _state.label = 14;
+                case 14:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        6
+                    ];
+                case 15:
+                    return [
+                        3,
+                        18
+                    ];
+                case 16:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        18
+                    ];
+                case 17:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 18:
+                    _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    _state.label = 19;
+                case 19:
+                    _state.trys.push([
+                        19,
+                        28,
+                        29,
+                        30
+                    ]);
+                    _iterator1 = serverResourceMap[Symbol.iterator]();
+                    _state.label = 20;
+                case 20:
+                    if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
+                        3,
+                        27
+                    ];
+                    _step_value = _sliced_to_array(_step1.value, 2), key = _step_value[0], serverResource1 = _step_value[1];
+                    if (!(serverResource1.local && !localResourceKeys.has(key))) return [
+                        3,
+                        26
+                    ];
+                    _state.label = 21;
+                case 21:
+                    _state.trys.push([
+                        21,
+                        25,
+                        ,
+                        26
+                    ]);
+                    // Report progress for deleting
+                    if (onProgress) {
+                        onProgress({
+                            currentFile: key,
+                            action: 'deleting',
+                            stats: {
+                                uploadCount: uploadCount,
+                                skipCount: skipCount,
+                                errorCount: errorCount,
+                                totalCount: localResources.length,
+                                deleteCount: deleteCount,
+                                errors: errors
+                            }
+                        });
+                    }
+                    return [
+                        4,
+                        client.fetch("/resources/".concat(encodeURIComponent(key)), {
+                            method: 'DELETE'
+                        })
+                    ];
+                case 22:
+                    deleteResponse = _state.sent();
+                    if (!(!deleteResponse.ok && deleteResponse.status !== 404)) return [
+                        3,
+                        24
+                    ];
+                    return [
+                        4,
+                        deleteResponse.text()
+                    ];
+                case 23:
+                    errorText2 = _state.sent();
+                    throw new Error("Delete failed: ".concat(deleteResponse.status, " ").concat(errorText2));
+                case 24:
+                    deleteCount++;
+                    return [
+                        3,
+                        26
+                    ];
+                case 25:
+                    error1 = _state.sent();
+                    errorCount++;
+                    errors.push({
+                        file: key,
+                        message: "Failed to delete: ".concat(error1.message || 'Unknown error')
+                    });
+                    return [
+                        3,
+                        26
+                    ];
+                case 26:
+                    _iteratorNormalCompletion1 = true;
+                    return [
+                        3,
+                        20
+                    ];
+                case 27:
+                    return [
+                        3,
+                        30
+                    ];
+                case 28:
+                    err = _state.sent();
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                    return [
+                        3,
+                        30
+                    ];
+                case 29:
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 30:
+                    return [
+                        2,
+                        {
+                            uploadCount: uploadCount,
+                            skipCount: skipCount,
+                            errorCount: errorCount,
+                            totalCount: localResources.length,
+                            deleteCount: deleteCount,
+                            errors: errors
+                        }
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+/**
+ * Check if a string is a valid JavaScript identifier
+ */ function isValidJSIdentifier(name) {
+    // Must start with letter, underscore, or dollar sign
+    // Can contain letters, digits, underscores, dollar signs
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+/**
+ * Build TypeScript structure from resource tree
+ */ function buildTypeStructure(node) {
+    if (!node.children) return [];
+    var properties = [];
+    var processedNames = new Set();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(node.children)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], child = _step_value[1];
+            if (processedNames.has(name)) continue;
+            if (child.type) {
+                // File resource
+                var resourceType = child.type === 'text' ? 'TextResource' : 'BinaryResource';
+                properties.push({
+                    name: name,
+                    type: resourceType
+                });
+                processedNames.add(name);
+                if (child.fullName) {
+                    processedNames.add(child.fullName);
+                }
+            } else if (child.children) {
+                // Directory with nested resources
+                var nestedProps = buildTypeStructure(child);
+                if (nestedProps.length > 0) {
+                    properties.push({
+                        name: name,
+                        type: {
+                            properties: nestedProps
+                        }
+                    });
+                    processedNames.add(name);
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return properties;
+}
+/**
+ * Render TypeScript from structure
+ */ function renderTypeScript(properties) {
+    var indent = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : '    ';
+    return properties.map(function(prop) {
+        if (typeof prop.type === 'string') {
+            return "".concat(indent).concat(prop.name, ": ").concat(prop.type, ";");
+        } else {
+            var nestedContent = renderTypeScript(prop.type.properties, indent + '  ');
+            return "".concat(indent).concat(prop.name, ": {\n").concat(nestedContent, "\n").concat(indent, "};");
+        }
+    }).join('\n');
+}
+/**
+ * Generate TypeScript declarations for resources
+ */ function generateResourceTypes(resources) {
+    var root = {
+        children: {}
+    };
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        // Build the tree structure
+        for(var _iterator = resources[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var resource = _step.value;
+            var parts = resource.key.split('/');
+            var current = root;
+            for(var i = 0; i < parts.length; i++){
+                var part = parts[i];
+                var isLeaf = i === parts.length - 1;
+                if (!current.children) {
+                    current.children = {};
+                }
+                if (isLeaf) {
+                    var resourceNode = {
+                        type: resource.type,
+                        fullName: part
+                    };
+                    if (isValidJSIdentifier(part)) {
+                        current.children[part] = resourceNode;
+                    }
+                    var withoutExt = part.replace(/\.[^/.]+$/, '');
+                    if (withoutExt !== part && isValidJSIdentifier(withoutExt)) {
+                        if (!current.children[withoutExt]) {
+                            current.children[withoutExt] = resourceNode;
+                        }
+                    }
+                } else {
+                    if (isValidJSIdentifier(part)) {
+                        if (!current.children[part]) {
+                            current.children[part] = {
+                                children: {}
+                            };
+                        }
+                        current = current.children[part];
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var typeStructure = buildTypeStructure(root);
+    var interfaceContent = renderTypeScript(typeStructure);
+    return "// Generated by Positronic CLI\n// This file provides TypeScript types for your resources\n\ndeclare module '@positronic/core' {\n  interface TextResource {\n    load(): Promise<string>;\n  }\n\n  interface BinaryResource {\n    load(): Promise<Buffer>;\n  }\n\n  interface Resources {\n    // Method signatures for loading resources by path\n    loadText(path: string): Promise<string>;\n    loadBinary(path: string): Promise<Buffer>;\n\n    // Resource properties accessible via dot notation\n".concat(interfaceContent, "\n  }\n}\n\nexport {}; // Make this a module\n");
+}
+/**
+ * Core type generation logic without UI dependencies
+ */ export function generateTypes(_0) {
+    return _async_to_generator(function(projectRootPath) {
+        var client, typesFilePath, response, errorText, data, typeDefinitions;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    client = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : apiClient;
+                    typesFilePath = path.join(projectRootPath, 'resources.d.ts');
+                    return [
+                        4,
+                        client.fetch('/resources')
+                    ];
+                case 1:
+                    response = _state.sent();
+                    if (!!response.ok) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        response.text()
+                    ];
+                case 2:
+                    errorText = _state.sent();
+                    throw new Error("Failed to fetch resources: ".concat(response.status, " ").concat(errorText));
+                case 3:
+                    return [
+                        4,
+                        response.json()
+                    ];
+                case 4:
+                    data = _state.sent();
+                    typeDefinitions = generateResourceTypes(data.resources);
+                    fs.writeFileSync(typesFilePath, typeDefinitions, 'utf-8');
+                    return [
+                        2,
+                        path.relative(process.cwd(), typesFilePath)
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+/**
+ * Wait for resources to stabilize (indicating initial sync is complete)
+ */ function waitForResources(maxWaitMs, startTime) {
+    return _async_to_generator(function() {
+        var lastCount, stableCount, response, data, e;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    lastCount = -1;
+                    stableCount = 0;
+                    _state.label = 1;
+                case 1:
+                    if (!(Date.now() - startTime < maxWaitMs)) return [
+                        3,
+                        9
+                    ];
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        6,
+                        ,
+                        7
+                    ]);
+                    return [
+                        4,
+                        apiClient.fetch("/resources")
+                    ];
+                case 3:
+                    response = _state.sent();
+                    if (!response.ok) return [
+                        3,
+                        5
+                    ];
+                    return [
+                        4,
+                        response.json()
+                    ];
+                case 4:
+                    data = _state.sent();
+                    // If the count hasn't changed for 3 checks, we consider it stable
+                    if (data.count === lastCount) {
+                        stableCount++;
+                        if (stableCount >= 3) {
+                            return [
+                                2,
+                                true
+                            ]; // Resources are stable
+                        }
+                    } else {
+                        lastCount = data.count;
+                        stableCount = 0;
+                    }
+                    _state.label = 5;
+                case 5:
+                    return [
+                        3,
+                        7
+                    ];
+                case 6:
+                    e = _state.sent();
+                    return [
+                        3,
+                        7
+                    ];
+                case 7:
+                    return [
+                        4,
+                        new Promise(function(resolve) {
+                            return setTimeout(resolve, 100);
+                        })
+                    ];
+                case 8:
+                    _state.sent();
+                    return [
+                        3,
+                        1
+                    ];
+                case 9:
+                    return [
+                        2,
+                        false
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Helper function to wait for server to be ready
+ */ export function waitUntilReady(port) {
+    var maxWaitMs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 5000;
+    return _async_to_generator(function() {
+        var serverPort, startTime, response, status, e;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    serverPort = port || Number(process.env.POSITRONIC_PORT) || 8787;
+                    startTime = Date.now();
+                    _state.label = 1;
+                case 1:
+                    if (!(Date.now() - startTime < maxWaitMs)) return [
+                        3,
+                        9
+                    ];
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        6,
+                        ,
+                        7
+                    ]);
+                    return [
+                        4,
+                        apiClient.fetch("/status")
+                    ];
+                case 3:
+                    response = _state.sent();
+                    if (!response.ok) return [
+                        3,
+                        5
+                    ];
+                    return [
+                        4,
+                        response.json()
+                    ];
+                case 4:
+                    status = _state.sent();
+                    if (status.ready) {
+                        return [
+                            3,
+                            9
+                        ]; // HTTP server is ready
+                    }
+                    _state.label = 5;
+                case 5:
+                    return [
+                        3,
+                        7
+                    ];
+                case 6:
+                    e = _state.sent();
+                    return [
+                        3,
+                        7
+                    ];
+                case 7:
+                    return [
+                        4,
+                        new Promise(function(resolve) {
+                            return setTimeout(resolve, 100);
+                        })
+                    ];
+                case 8:
+                    _state.sent();
+                    return [
+                        3,
+                        1
+                    ];
+                case 9:
+                    // Now wait for resources to stabilize (indicating initial sync is done)
+                    return [
+                        2,
+                        waitForResources(maxWaitMs, startTime)
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Upload a file using presigned URL for large files
+ * This function is used by the `px resources upload` command to upload files
+ * directly to R2 storage, bypassing the 100MB Worker limit.
+ *
+ * @param filePath - Path to the file to upload
+ * @param customKey - The key (path) where the file will be stored in R2
+ * @param client - Optional API client (defaults to singleton)
+ * @param onProgress - Optional progress callback
+ * @param signal - Optional AbortSignal for cancellation
+ */ export function uploadFileWithPresignedUrl(_0, _1, _2, _3) {
+    return _async_to_generator(function(filePath, customKey) {
+        var client, onProgress, signal, stats, fileName, fileType, fileContent, presignedResponse, errorText, errorMessage, errorData, _ref, url, method, requiredHeaders, fileContent1, parsedUrl, httpModule, uploadResponse;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    client = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : apiClient, onProgress = _arguments.length > 3 ? _arguments[3] : void 0, signal = _arguments.length > 4 ? _arguments[4] : void 0;
+                    // Get file info
+                    stats = fs.statSync(filePath);
+                    fileName = path.basename(filePath);
+                    if (stats.size < 1024 * 1024) {
+                        // 1MB
+                        fileContent = fs.readFileSync(filePath);
+                        fileType = isText(fileName, fileContent) ? 'text' : 'binary';
+                    } else {
+                        // For large files, use extension-based detection
+                        fileType = isText(fileName) ? 'text' : 'binary';
+                    }
+                    return [
+                        4,
+                        client.fetch('/resources/presigned-link', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json'
+                            },
+                            body: JSON.stringify({
+                                key: customKey,
+                                type: fileType,
+                                size: stats.size
+                            })
+                        })
+                    ];
+                case 1:
+                    presignedResponse = _state.sent();
+                    if (!!presignedResponse.ok) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        presignedResponse.text()
+                    ];
+                case 2:
+                    errorText = _state.sent();
+                    errorMessage = "Failed to get presigned URL: ".concat(presignedResponse.status);
+                    // Parse error response if it's JSON
+                    try {
+                        errorData = JSON.parse(errorText);
+                        if (errorData.error) {
+                            errorMessage = errorData.error;
+                        }
+                    } catch (e) {
+                        errorMessage += " ".concat(errorText);
+                    }
+                    throw new Error(errorMessage);
+                case 3:
+                    return [
+                        4,
+                        presignedResponse.json()
+                    ];
+                case 4:
+                    _ref = _state.sent(), url = _ref.url, method = _ref.method;
+                    // Headers that must be included in the upload to match the presigned URL signature
+                    requiredHeaders = {
+                        'x-amz-meta-type': fileType,
+                        'x-amz-meta-local': 'false'
+                    };
+                    if (!(stats.size > 10 * 1024 * 1024)) return [
+                        3,
+                        6
+                    ];
+                    // 10MB
+                    return [
+                        4,
+                        uploadLargeFileWithProgress(filePath, url, method, stats.size, requiredHeaders, onProgress, signal)
+                    ];
+                case 5:
+                    _state.sent();
+                    return [
+                        3,
+                        8
+                    ];
+                case 6:
+                    // For small files, use simple upload
+                    fileContent1 = fs.readFileSync(filePath);
+                    // Use native http/https for the upload
+                    parsedUrl = new URL(url);
+                    httpModule = parsedUrl.protocol === 'https:' ? https : http;
+                    return [
+                        4,
+                        new Promise(function(resolve, reject) {
+                            var requestOptions = {
+                                hostname: parsedUrl.hostname,
+                                port: parseInt(parsedUrl.port || (parsedUrl.protocol === 'https:' ? '443' : '80'), 10),
+                                path: parsedUrl.pathname + parsedUrl.search,
+                                method: method,
+                                headers: _object_spread_props(_object_spread({}, requiredHeaders), {
+                                    'Content-Length': fileContent1.length.toString()
+                                })
+                            };
+                            var req = httpModule.request(requestOptions, function(res) {
+                                var chunks = [];
+                                res.on('data', function(chunk) {
+                                    chunks.push(chunk);
+                                });
+                                res.on('end', function() {
+                                    var responseBody = Buffer.concat(chunks);
+                                    resolve(new Response(responseBody, {
+                                        status: res.statusCode,
+                                        statusText: res.statusMessage,
+                                        headers: Object.fromEntries(Object.entries(res.headers).map(function(param) {
+                                            var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+                                            return [
+                                                key,
+                                                Array.isArray(value) ? value.join(', ') : value || ''
+                                            ];
+                                        }))
+                                    }));
+                                });
+                                res.on('error', reject);
+                            });
+                            req.on('error', reject);
+                            if (signal) {
+                                signal.addEventListener('abort', function() {
+                                    req.destroy();
+                                    reject(new Error('AbortError'));
+                                });
+                            }
+                            req.write(fileContent1);
+                            req.end();
+                        })
+                    ];
+                case 7:
+                    uploadResponse = _state.sent();
+                    if (!uploadResponse.ok) {
+                        throw new Error("Failed to upload file: ".concat(uploadResponse.status, " ").concat(uploadResponse.statusText));
+                    }
+                    _state.label = 8;
+                case 8:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+/**
+ * Stream upload large file with progress tracking
+ * Uses Node.js https module for true streaming without loading entire file into memory
+ */ function uploadLargeFileWithProgress(filePath, url, method, totalSize, requiredHeaders, onProgress, signal) {
+    return _async_to_generator(function() {
+        var parsedUrl, httpModule;
+        return _ts_generator(this, function(_state) {
+            parsedUrl = new URL(url);
+            httpModule = parsedUrl.protocol === 'https:' ? https : http;
+            return [
+                2,
+                new Promise(function(resolve, reject) {
+                    // Abort handler
+                    var onAbort = function() {
+                        req.destroy();
+                        reject(new Error('AbortError'));
+                    };
+                    if (signal) {
+                        signal.addEventListener('abort', onAbort);
+                    }
+                    var options = {
+                        hostname: parsedUrl.hostname,
+                        port: parsedUrl.port ? parseInt(parsedUrl.port, 10) : undefined,
+                        path: parsedUrl.pathname + parsedUrl.search,
+                        method: method,
+                        headers: _object_spread_props(_object_spread({}, requiredHeaders), {
+                            'Content-Length': totalSize.toString()
+                        })
+                    };
+                    var req = httpModule.request(options, function(res) {
+                        var responseBody = '';
+                        res.on('data', function(chunk) {
+                            responseBody += chunk.toString();
+                        });
+                        res.on('end', function() {
+                            if (signal) {
+                                signal.removeEventListener('abort', onAbort);
+                            }
+                            if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                                resolve();
+                            } else {
+                                reject(new Error("Failed to upload file: ".concat(res.statusCode, " ").concat(res.statusMessage, ". Response: ").concat(responseBody)));
+                            }
+                        });
+                    });
+                    req.on('error', function(err) {
+                        if (signal) {
+                            signal.removeEventListener('abort', onAbort);
+                        }
+                        reject(err);
+                    });
+                    // Stream the file directly to the request
+                    var fileStream = fs.createReadStream(filePath);
+                    var uploadedBytes = 0;
+                    fileStream.on('data', function(chunk) {
+                        var chunkLength = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(chunk);
+                        uploadedBytes += chunkLength;
+                        if (onProgress) {
+                            onProgress({
+                                loaded: uploadedBytes,
+                                total: totalSize,
+                                percentage: Math.round(uploadedBytes / totalSize * 100)
+                            });
+                        }
+                    });
+                    fileStream.on('error', function(err) {
+                        req.destroy();
+                        reject(err);
+                    });
+                    // Pipe the file stream to the request
+                    fileStream.pipe(req);
+                })
+            ];
+        });
+    })();
+}