2024 lines
54 KiB
Plaintext
2024 lines
54 KiB
Plaintext
var toml = use('toml')
|
|
var json = use('json')
|
|
var fd = use('fd')
|
|
var http = use('http')
|
|
var miniz = use('miniz')
|
|
var time = use('time')
|
|
var js = use('js')
|
|
var crypto = use('crypto')
|
|
var utf8 = use('utf8')
|
|
var blob = use('blob')
|
|
var build_utils = use('build')
|
|
|
|
var core = "core"
|
|
|
|
function pull_from_cache(content)
|
|
{
|
|
var path = hash_path(content)
|
|
if (fd.is_file(path))
|
|
return fd.slurp(path)
|
|
}
|
|
|
|
function put_into_cache(content, obj)
|
|
{
|
|
var path = hash_path(content)
|
|
fd.slurpwrite(path, obj)
|
|
}
|
|
|
|
function content_hash(content)
|
|
{
|
|
return text(crypto.blake2(content), 'h')
|
|
}
|
|
|
|
function hash_path(content)
|
|
{
|
|
return get_global_build_dir() + '/' + content_hash(content)
|
|
}
|
|
|
|
var Shop = {}
|
|
|
|
// Global shop path - this is where all packages, builds, and cache are stored
|
|
// Located at ~/.cell on the user's machine
|
|
var global_shop_path = null
|
|
|
|
var SCOPE_LOCAL = 0
|
|
var SCOPE_PACKAGE = 1
|
|
var SCOPE_CORE = 2
|
|
|
|
var MOD_EXT = '.cm'
|
|
var ACTOR_EXT = '.ce'
|
|
|
|
var dylib_ext = '.so' // Default extension
|
|
|
|
var os
|
|
var use_cache
|
|
var platform
|
|
var $_
|
|
|
|
// Initialize the global shop path
|
|
function init_global_shop() {
|
|
if (global_shop_path) return global_shop_path
|
|
|
|
var home = os.getenv('HOME')
|
|
if (!home) {
|
|
// Try Windows-style
|
|
home = os.getenv('USERPROFILE')
|
|
}
|
|
if (!home) {
|
|
throw new Error('Could not determine home directory. Set HOME environment variable.')
|
|
}
|
|
|
|
global_shop_path = home + '/.cell'
|
|
|
|
// Verify the shop exists
|
|
if (!fd.is_dir(global_shop_path)) {
|
|
throw new Error('Cell shop not found at ' + global_shop_path + '. Run "cell install" to set up.')
|
|
}
|
|
|
|
return global_shop_path
|
|
}
|
|
|
|
// Get the global shop path
|
|
Shop.get_shop_path = function() {
|
|
return init_global_shop()
|
|
}
|
|
|
|
// Find the package directory containing a file by looking for cell.toml
|
|
// Returns the absolute path to the package directory, or null if not in a package
|
|
Shop.find_package_dir = function(file_path) {
|
|
if (!file_path) return null
|
|
|
|
// Walk up directories looking for cell.toml
|
|
var dir = file_path
|
|
if (fd.is_file(dir)) {
|
|
// if it's a file, start from parent
|
|
var last_slash = dir.lastIndexOf('/')
|
|
if (last_slash > 0) dir = dir.substring(0, last_slash)
|
|
}
|
|
|
|
while (dir && dir.length > 0) {
|
|
var toml_path = dir + '/cell.toml'
|
|
if (fd.is_file(toml_path)) {
|
|
return fd.realpath(dir)
|
|
}
|
|
var last_slash = dir.lastIndexOf('/')
|
|
if (last_slash <= 0) break
|
|
dir = dir.substring(0, last_slash)
|
|
}
|
|
|
|
// Check current directory as fallback
|
|
if (fd.is_file('cell.toml')) {
|
|
return fd.realpath('.')
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
function slurp_package_file(file, package)
|
|
{
|
|
return fd.slurp(get_packages_dir() + '/' + package + '/' + file)
|
|
}
|
|
|
|
// Link a local package into the shop
|
|
function ensure_package_link(abs_path) {
|
|
if (!abs_path || !abs_path.startsWith('/')) return false
|
|
|
|
var packages_dir = get_packages_dir()
|
|
var target_link = packages_dir + abs_path
|
|
|
|
// If link already exists and points to correct place, we are good
|
|
if (fd.is_link(target_link)) {
|
|
var points_to = fd.readlink(target_link)
|
|
if (points_to == abs_path) {
|
|
update_local_lock(abs_path)
|
|
return true
|
|
}
|
|
// Incorrect link, remove it
|
|
fd.unlink(target_link)
|
|
} else if (fd.is_dir(target_link)) {
|
|
// If it's a real directory, that's weird for a local package mirror, but let's assume it might be a copy?
|
|
// User wants symlinks.
|
|
// If it's not a link, maybe we should leave it or warn?
|
|
// Use user instructions: "shop should ... ensure it's there ... symlink local dirs"
|
|
// safely assuming we can replace if it's not the right thing might be dangerous if user put real files there.
|
|
// For now, if it's a dir, check if it's the package itself?
|
|
// simpler: proceed to link logic
|
|
}
|
|
|
|
// Create parent dirs
|
|
var parent = target_link.substring(0, target_link.lastIndexOf('/'))
|
|
ensure_dir(parent)
|
|
|
|
try {
|
|
fd.symlink(abs_path, target_link)
|
|
// log.console("Linked " + abs_path + " -> " + target_link)
|
|
update_local_lock(abs_path)
|
|
return true
|
|
} catch (e) {
|
|
log.error("Failed to link package " + abs_path + ": " + e)
|
|
return false
|
|
}
|
|
}
|
|
|
|
function update_local_lock(abs_path) {
|
|
var lock = Shop.load_lock()
|
|
var name = abs_path.split('/').pop()
|
|
|
|
// Check if we can find a better name from cell.toml
|
|
var toml_path = abs_path + '/cell.toml'
|
|
if (fd.is_file(toml_path)) {
|
|
// We could parse it, but for now directory name is usually the package alias
|
|
}
|
|
|
|
lock[name] = {
|
|
package: abs_path,
|
|
type: 'local',
|
|
updated: time.number()
|
|
}
|
|
Shop.save_lock(lock)
|
|
}
|
|
|
|
Shop.ensure_package_link = ensure_package_link
|
|
|
|
// Set the current package context from a program path
|
|
|
|
|
|
Shop.set_os = function(o, $guy)
|
|
{
|
|
os = o
|
|
$_ = $guy
|
|
use_cache = os.use_cache
|
|
|
|
platform = os.platform()
|
|
if (platform == 'macOS') dylib_ext = '.dylib'
|
|
else if (platform == 'Windows') dylib_ext = '.dll'
|
|
|
|
// Initialize the global shop
|
|
init_global_shop()
|
|
}
|
|
|
|
var config = null
|
|
|
|
// Get the config path for a package
|
|
// If package_path is null, uses current_package_path
|
|
function get_config_path(package_path) {
|
|
if (package_path) {
|
|
return package_path + '/cell.toml'
|
|
}
|
|
// Fallback to current directory
|
|
return 'cell.toml'
|
|
}
|
|
|
|
// Get the lock file path (in the global shop)
|
|
function get_lock_path() {
|
|
return global_shop_path + '/lock.toml'
|
|
}
|
|
|
|
// Get the packages directory (in the global shop)
|
|
function get_packages_dir() {
|
|
return global_shop_path + '/packages'
|
|
}
|
|
|
|
// Get the cache directory (in the global shop)
|
|
function get_cache_dir() {
|
|
return global_shop_path + '/cache'
|
|
}
|
|
|
|
// Get the build directory (in the global shop)
|
|
function get_global_build_dir() {
|
|
return global_shop_path + '/build'
|
|
}
|
|
|
|
// Get the core directory (in the global shop)
|
|
Shop.get_core_dir = function() {
|
|
return global_shop_path + '/core'
|
|
}
|
|
|
|
function get_core_package()
|
|
{
|
|
return "gitea.pockle.world/john/cell"
|
|
}
|
|
|
|
// Get the links file path (in the global shop)
|
|
function get_links_path() {
|
|
return global_shop_path + '/link.toml'
|
|
}
|
|
|
|
// Get the reports directory (in the global shop)
|
|
Shop.get_reports_dir = function() {
|
|
return global_shop_path + '/reports'
|
|
}
|
|
|
|
var open_dl = {}
|
|
|
|
function get_import_package(name) {
|
|
var parts = name.split('/')
|
|
if (parts.length > 1)
|
|
return parts[0]
|
|
|
|
return null
|
|
}
|
|
|
|
Shop.file_info = function(file) {
|
|
var info = {
|
|
path: file,
|
|
is_module: false,
|
|
is_actor: false,
|
|
package: null,
|
|
name: null
|
|
}
|
|
|
|
if (file.endsWith(MOD_EXT)) {
|
|
info.is_module = true
|
|
} else if (file.endsWith(ACTOR_EXT)) {
|
|
info.is_actor = true
|
|
}
|
|
|
|
// Strip extension for name
|
|
var name_without_ext = file
|
|
if (info.is_module) {
|
|
name_without_ext = file.substring(0, file.length - MOD_EXT.length)
|
|
} else if (info.is_actor) {
|
|
name_without_ext = file.substring(0, file.length - ACTOR_EXT.length)
|
|
}
|
|
|
|
// Check if file is in a package (in global shop packages dir)
|
|
var packages_prefix = get_packages_dir() + '/'
|
|
if (file.startsWith(packages_prefix)) {
|
|
var rest = file.substring(packages_prefix.length)
|
|
|
|
// Get all packages and find which one matches this path
|
|
// With the new structure, everything in packages/ is a package
|
|
// gitea.pockle.world/user/repo/file.cm
|
|
|
|
var parts = rest.split('/')
|
|
// Heuristic: packages form is host/user/repo
|
|
if (parts.length >= 3) {
|
|
var pkg_path = parts.slice(0, 3).join('/')
|
|
info.package = pkg_path
|
|
if (rest.length > pkg_path.length) {
|
|
info.name = rest.substring(pkg_path.length + 1)
|
|
} else {
|
|
info.name = "" // root?
|
|
}
|
|
} else {
|
|
// fallback
|
|
info.package = rest
|
|
}
|
|
|
|
if (info.name) {
|
|
if (info.is_module && info.name.endsWith(MOD_EXT))
|
|
info.name = info.name.substring(0, info.name.length - MOD_EXT.length)
|
|
if (info.is_actor && info.name.endsWith(ACTOR_EXT))
|
|
info.name = info.name.substring(0, info.name.length - ACTOR_EXT.length)
|
|
}
|
|
|
|
} else {
|
|
// Check if it's in any other package via cell.toml lookup
|
|
var pkg_dir = Shop.find_package_dir(file)
|
|
if (pkg_dir) {
|
|
info.package = pkg_dir
|
|
if (file.startsWith(pkg_dir + '/')) {
|
|
var rel = file.substring(pkg_dir.length + 1)
|
|
info.name = rel
|
|
if (info.is_module && info.name.endsWith(MOD_EXT))
|
|
info.name = info.name.substring(0, info.name.length - MOD_EXT.length)
|
|
if (info.is_actor && info.name.endsWith(ACTOR_EXT))
|
|
info.name = info.name.substring(0, info.name.length - ACTOR_EXT.length)
|
|
}
|
|
} else {
|
|
info.package = 'local' // Should we keep 'local' for truly orphan files?
|
|
info.name = name_without_ext
|
|
}
|
|
}
|
|
|
|
return info
|
|
}
|
|
|
|
function get_import_name(path)
|
|
{
|
|
var parts = path.split('/')
|
|
if (parts.length < 2) return null
|
|
return parts.slice(1).join('/')
|
|
}
|
|
|
|
function get_aliased_path(path, pkg)
|
|
{
|
|
|
|
}
|
|
|
|
function validate_package_name(pkg)
|
|
{
|
|
if (!pkg) return false
|
|
|
|
// Check for unsafe filesystem characters (except @ and . which are allowed)
|
|
// Disallow: : \ ? * " < > | and control characters
|
|
if (/[:\\\?\*"<>\|]/.test(pkg)) return false
|
|
|
|
// Disallow control characters (0-31)
|
|
for (var i = 0; i < pkg.length; i++) {
|
|
var code = pkg.charCodeAt(i)
|
|
if (code < 32) return false
|
|
}
|
|
|
|
// Disallow empty segments or trailing/leading slashes
|
|
if (pkg.startsWith('/') || pkg.endsWith('/')) return false
|
|
if (pkg.includes('//')) return false
|
|
|
|
// Disallow . and .. as path segments
|
|
var parts = pkg.split('/')
|
|
for (var i = 0; i < parts.length; i++) {
|
|
if (parts[i] == '' || parts[i] == '.' || parts[i] == '..') return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// return the safe path for the package
|
|
// guaranteed to be validated
|
|
function get_package_path(pkg)
|
|
{
|
|
return pkg.replace('@', '_')
|
|
}
|
|
|
|
function get_shared_lib_path()
|
|
{
|
|
return get_global_build_dir() + '/' + 'lib'
|
|
}
|
|
|
|
function get_aliased_package(alias, pkg)
|
|
{
|
|
if (alias.split('/').length > 1)
|
|
throw new Error(`alias ${alias} is invalid, as it contains slashes`)
|
|
|
|
var cfg = Shop.load_config(pkg)
|
|
|
|
if (!cfg.dependencies)
|
|
return null
|
|
|
|
return cfg.dependencies[alias]
|
|
}
|
|
|
|
// taking the package ctx into account, find the canonical name
|
|
function get_canonical_package(alias, ctx) {
|
|
var cfg = Shop.load_config(ctx)
|
|
|
|
if (!cfg || !cfg.dependencies)
|
|
return null
|
|
|
|
var pkg = cfg.dependencies[alias]
|
|
if (!pkg)
|
|
return null
|
|
|
|
var parsed = Shop.parse_package(pkg)
|
|
if (!parsed)
|
|
return null
|
|
|
|
return parsed.path
|
|
}
|
|
|
|
function get_import_dl(name) {
|
|
var pkg = get_import_package(name)
|
|
if (!pkg) return null
|
|
if (open_dl[pkg]) return open_dl[pkg]
|
|
var dlpath = get_packages_dir() + '/' + pkg + '/' + pkg + dylib_ext
|
|
var dl = os.dylib_open(dlpath)
|
|
if (dl) {
|
|
open_dl[pkg] = dl
|
|
return dl
|
|
}
|
|
return null
|
|
}
|
|
|
|
Shop.get_c_symbol = function get_c_symbol(name) {
|
|
var dl = get_import_dl(name)
|
|
var symname = `js_${name.replace('/', '_')}_use`
|
|
|
|
if (dl)
|
|
return os.dylib_symbol(dl, symname)
|
|
else
|
|
return os.load_internal(symname)
|
|
}
|
|
|
|
// Use ensure_dir from build_utils
|
|
var ensure_dir = build_utils.ensure_dir
|
|
|
|
Shop.load_config = function(module) {
|
|
var content
|
|
var config_path
|
|
if (!module) {
|
|
config_path = get_config_path()
|
|
if (!fd.is_file(config_path))
|
|
return null
|
|
content = fd.slurp(config_path)
|
|
} else {
|
|
// Module config is at <modules_dir>/<module>/cell.toml
|
|
var module_path = get_packages_dir() + '/' + module + '/cell.toml'
|
|
if (!fd.is_file(module_path))
|
|
return null
|
|
|
|
content = fd.slurp(module_path)
|
|
}
|
|
|
|
if (!(content instanceof blob)) {
|
|
log.console(`critical error`)
|
|
for (var k in content)
|
|
log.console(k)
|
|
throw new Error("fucked up bad")
|
|
}
|
|
|
|
if (!content.length) return {}
|
|
var cfg = toml.decode(text(content))
|
|
if (cfg.dependencies) {
|
|
var changed = false
|
|
for (var k in cfg.dependencies) {
|
|
if (cfg.dependencies[k].startsWith('https://')) {
|
|
cfg.dependencies[k] = cfg.dependencies[k].substring(8)
|
|
changed = true
|
|
} else if (cfg.dependencies[k].includes('://')) {
|
|
// If it has another protocol, we should probably strip it too or warn
|
|
// But for now assuming mostly https/http
|
|
var parts = cfg.dependencies[k].split('://')
|
|
if (parts.length == 2) {
|
|
cfg.dependencies[k] = parts[1]
|
|
changed = true
|
|
}
|
|
}
|
|
}
|
|
|
|
if (changed && !module) {
|
|
Shop.save_config(cfg)
|
|
}
|
|
}
|
|
return cfg
|
|
}
|
|
|
|
// Save cell.toml configuration
|
|
Shop.save_config = function(config) {
|
|
var config_path = get_config_path()
|
|
fd.slurpwrite(config_path, utf8.encode(toml.encode(config)));
|
|
}
|
|
|
|
// Load lock.toml configuration (from global shop)
|
|
Shop.load_lock = function() {
|
|
var path = get_lock_path()
|
|
|
|
if (!fd.is_file(path))
|
|
return {}
|
|
|
|
var content = text(fd.slurp(path))
|
|
if (!content.length) return {}
|
|
|
|
var lock = toml.decode(content)
|
|
|
|
return lock
|
|
}
|
|
|
|
// Save lock.toml configuration (to global shop)
|
|
Shop.save_lock = function(lock) {
|
|
var path = get_lock_path()
|
|
ensure_dir(global_shop_path)
|
|
fd.slurpwrite(path, utf8.encode(toml.encode(lock)));
|
|
}
|
|
|
|
var link_cache = null
|
|
Shop.load_links = function() {
|
|
if (link_cache) return link_cache
|
|
var path = get_links_path()
|
|
if (!fd.is_file(path)) {
|
|
link_cache = {}
|
|
return link_cache
|
|
}
|
|
|
|
try {
|
|
var content = text(fd.slurp(path))
|
|
var cfg = toml.decode(content)
|
|
link_cache = cfg.links || {}
|
|
} catch (e) {
|
|
log.console("Warning: Failed to load link.toml: " + e)
|
|
link_cache = {}
|
|
}
|
|
return link_cache
|
|
}
|
|
|
|
Shop.save_links = function(links) {
|
|
link_cache = links
|
|
var cfg = { links: links }
|
|
var path = get_links_path()
|
|
ensure_dir(global_shop_path)
|
|
fd.slurpwrite(path, utf8.encode(toml.encode(cfg)))
|
|
}
|
|
|
|
Shop.add_link = function(canonical, target) {
|
|
var links = Shop.load_links()
|
|
links[canonical] = target
|
|
Shop.save_links(links)
|
|
log.console("Linked " + canonical + " -> " + target)
|
|
return true
|
|
}
|
|
|
|
Shop.remove_link = function(canonical) {
|
|
var links = Shop.load_links()
|
|
if (!links[canonical]) return false
|
|
delete links[canonical]
|
|
Shop.save_links(links)
|
|
log.console("Unlinked " + canonical)
|
|
return true
|
|
}
|
|
|
|
Shop.clear_links = function() {
|
|
Shop.save_links({})
|
|
log.console("Cleared all links")
|
|
return true
|
|
}
|
|
|
|
// given a package, return the path in the shop
|
|
function package_shop_path(pkg)
|
|
{
|
|
|
|
}
|
|
|
|
// Parse module package string (e.g., "git.world/jj/mod@v0.6.3")
|
|
// returns {path, name, version}
|
|
Shop.parse_package = function(pkg) {
|
|
Shop.verify_package_name(pkg)
|
|
var path = pkg
|
|
var version = null
|
|
|
|
// Extract version if present
|
|
if (path.includes('@')) {
|
|
var versionParts = path.split('@')
|
|
path = versionParts[0]
|
|
version = versionParts[1]
|
|
}
|
|
|
|
// Check for links
|
|
var links = Shop.load_links()
|
|
if (links[path]) {
|
|
path = links[path]
|
|
}
|
|
|
|
// Handle absolute paths (local modules)
|
|
// /User/john/mod -> User/john/mod
|
|
if (path.startsWith('/')) {
|
|
path = path.substring(1)
|
|
}
|
|
|
|
// Extract name (last part of path)
|
|
var name = path.split('/').pop()
|
|
|
|
return {
|
|
path,
|
|
name,
|
|
version
|
|
}
|
|
}
|
|
|
|
// Get information about how to resolve a package
|
|
Shop.resolve_package_info = function(pkg) {
|
|
// Check links first
|
|
// We need to check the raw package string against links
|
|
// But we also need to handle the case where pkg is already a local path
|
|
// If pkg is "gitea...", check if it's linked
|
|
|
|
var path = pkg
|
|
if (path.includes('@')) path = path.split('@')[0]
|
|
|
|
var links = Shop.load_links()
|
|
if (links[path]) {
|
|
var resolved = links[path]
|
|
if (resolved.startsWith('/')) {
|
|
return { type: 'local', path: resolved }
|
|
}
|
|
return { type: 'package', path: resolved }
|
|
}
|
|
|
|
if (pkg.startsWith('/')) {
|
|
return { type: 'local', path: pkg }
|
|
}
|
|
if (pkg.includes('gitea.')) {
|
|
return { type: 'gitea' }
|
|
}
|
|
|
|
// If it looks like a path but isn't absolute, might be relative in future, but for now strict
|
|
return { type: 'unknown' }
|
|
}
|
|
|
|
// Resolve a filesystem path to a package identifier in the shop
|
|
Shop.resolve_path_to_package = function(path_str) {
|
|
var abs = fd.realpath(path_str)
|
|
if (!abs) return null
|
|
|
|
var modules_dir = get_packages_dir()
|
|
|
|
// Case 1: Path is inside the modules directory (e.g. downloaded package)
|
|
if (abs.startsWith(modules_dir + '/')) {
|
|
var rel = abs.substring(modules_dir.length + 1)
|
|
// Remove trailing slash if any
|
|
if (rel.endsWith('/')) rel = rel.substring(0, rel.length - 1)
|
|
return rel
|
|
}
|
|
|
|
// Case 2: Path is a local directory linked into the shop
|
|
// Local links are stored as modules_dir + abs_path (mirrored)
|
|
var target = modules_dir + abs
|
|
if (fd.is_dir(target)) {
|
|
if (abs.startsWith('/')) return abs.substring(1)
|
|
return abs
|
|
}
|
|
|
|
// Case 3: Path is not linked. Return null.
|
|
return null
|
|
}
|
|
|
|
// Verify if a package name is valid and return status
|
|
Shop.verify_package_name = function(pkg) {
|
|
if (!pkg) throw new Error("Empty package name")
|
|
if (pkg == 'local') throw new Error("local is not a valid package name")
|
|
if (pkg == 'core') throw new Error("core is not a valid package name")
|
|
|
|
if (pkg.includes('://'))
|
|
throw new Error(`Invalid package name: ${pkg}; did you mean ${pkg.split('://')[1]}?`)
|
|
}
|
|
|
|
// Convert module package to download URL
|
|
Shop.get_download_url = function(pkg, commit_hash) {
|
|
var info = Shop.resolve_package_info(pkg)
|
|
if (info.type == 'local') return null
|
|
|
|
var parsed = Shop.parse_package(pkg)
|
|
if (!parsed) return null
|
|
|
|
if (parsed.path.includes('gitea.')) {
|
|
var parts = parsed.path.split('/')
|
|
var host = parts[0]
|
|
var user = parts[1]
|
|
var repo = parts[2]
|
|
|
|
if (!commit_hash) {
|
|
log.error("No commit hash available for download URL")
|
|
return null
|
|
}
|
|
|
|
return 'https://' + host + '/' + user + '/' + repo + '/archive/' + commit_hash + '.zip'
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
// Remove a dependency
|
|
Shop.remove_dependency = function(alias) {
|
|
var config = Shop.load_config()
|
|
if (!config) {
|
|
log.error("No cell.toml found")
|
|
return false
|
|
}
|
|
|
|
if (!config.dependencies || !config.dependencies[alias]) {
|
|
return false
|
|
}
|
|
|
|
delete config.dependencies[alias]
|
|
Shop.save_config(config)
|
|
return true
|
|
}
|
|
|
|
// Get the API URL for checking remote git commits
|
|
Shop.get_api_url = function(pkg) {
|
|
var info = Shop.resolve_package_info(pkg)
|
|
if (info.type == 'local') return null
|
|
|
|
var parsed = Shop.parse_package(pkg)
|
|
if (!parsed) return null
|
|
|
|
var parts = parsed.path.split('/')
|
|
// Gitea pattern: gitea.pockle.world/user/repo@branch
|
|
if (parsed.path.includes('gitea.')) {
|
|
var host = parts[0]
|
|
var user = parts[1]
|
|
var repo = parts[2]
|
|
var url = 'https://' + host + '/api/v1/repos/' + user + '/' + repo + '/branches/'
|
|
if (parsed.version) url += parsed.version
|
|
return url
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
// Extract commit hash from API response
|
|
Shop.extract_commit_hash = function(pkg, response) {
|
|
if (!response) return null
|
|
|
|
var data = json.decode(response)
|
|
|
|
if (pkg.includes('gitea.')) {
|
|
// Gitea: response.commit.id
|
|
if (Array.isArray(data))
|
|
data = data[0]
|
|
return data.commit && data.commit.id
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
// Get the module directory for a given alias
|
|
Shop.get_module_dir = function(alias) {
|
|
var config = Shop.load_config()
|
|
if (!config || !config.dependencies || !config.dependencies[alias]) {
|
|
return null
|
|
}
|
|
|
|
var pkg = config.dependencies[alias]
|
|
var parsed = Shop.parse_package(pkg)
|
|
if (!parsed) return null
|
|
|
|
return get_packages_dir() + '/' + parsed.path
|
|
}
|
|
|
|
function lock_package(loc)
|
|
{
|
|
var lock = Shop.load_lock()
|
|
|
|
}
|
|
|
|
Shop.check_cache = function(pkg) {
|
|
var parsed = Shop.parse_package(pkg)
|
|
if (!parsed) return null
|
|
|
|
var cache_path = get_cache_dir() + '/' + parsed.path + '.zip'
|
|
if (fd.is_file(cache_path)) {
|
|
log.console("Found cached zip: " + cache_path)
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
var open_dls = {}
|
|
|
|
// for script forms, path is the canonical path of the module
|
|
var script_form = function(path, script, pkg) {
|
|
var pkg_arg = pkg ? `'${pkg}'` : 'null'
|
|
var relative_use_fn = `def use = function(path) { return globalThis.use(path, ${pkg_arg});}`
|
|
var fn = `(function setup_module($_){ ${relative_use_fn}; ${script}})`
|
|
return fn
|
|
}
|
|
|
|
// Get flags from config
|
|
function get_flags(config, platform, key) {
|
|
var flags = ''
|
|
if (config.compilation && config.compilation[key]) {
|
|
flags += config.compilation[key]
|
|
}
|
|
if (config.compilation && config.compilation[platform] && config.compilation[platform][key]) {
|
|
if (flags != '') flags += ' '
|
|
flags += config.compilation[platform][key]
|
|
}
|
|
return flags
|
|
}
|
|
|
|
Shop.get_flags = get_flags
|
|
|
|
// Resolve module function, hashing it in the process
|
|
function resolve_mod_fn(path, pkg) {
|
|
if (!fd.is_file(path)) throw new Error(`path ${path} is not a file`)
|
|
|
|
var content = fd.slurp(path)
|
|
var obj = pull_from_cache(content)
|
|
if (obj) {
|
|
var fn = js.compile_unblob(obj)
|
|
return js.eval_compile(fn)
|
|
}
|
|
|
|
var form = script_form
|
|
|
|
var script = form(path, text(content), pkg);
|
|
|
|
// Compile name is just for debug/stack traces
|
|
var compile_name = pkg ? pkg + ':' + path : 'local:' + path
|
|
|
|
var fn = js.compile(compile_name, script)
|
|
|
|
put_into_cache(content, js.compile_blob(fn))
|
|
|
|
return js.eval_compile(fn)
|
|
}
|
|
|
|
|
|
// given a path and a package context
|
|
// return module info about where it was found
|
|
function resolve_locator(path, ctx)
|
|
{
|
|
// 1. If no context, resolve from core only
|
|
if (!ctx) {
|
|
var core_dir = Shop.get_core_dir()
|
|
var core_file_path = core_dir + '/' + path
|
|
if (fd.is_file(core_file_path)) {
|
|
var fn = resolve_mod_fn(core_file_path, 'core')
|
|
return {path: core_file_path, scope: SCOPE_CORE, symbol: fn}
|
|
}
|
|
return null
|
|
}
|
|
|
|
// check in ctx package
|
|
var ctx_path = get_packages_dir() + '/' + get_package_path(ctx) + '/' + path
|
|
|
|
if (fd.is_file(ctx_path)) {
|
|
var fn = resolve_mod_fn(ctx_path, ctx)
|
|
return {path: ctx_path, scope: SCOPE_LOCAL, symbol: fn}
|
|
}
|
|
|
|
// check for aliased dependency
|
|
var alias = path.split('/')
|
|
if (alias.length > 1) {
|
|
var alias_pkg = get_aliased_package(alias[0], ctx)
|
|
if (alias_pkg) {
|
|
var alias_path = get_packages_dir() + '/' + get_package_path(alias_pkg) + '/' + alias.slice(1).join('/')
|
|
if (fd.is_file(alias_path)){
|
|
var fn = resolve_mod_fn(alias_path, ctx)
|
|
return {path: alias_path, scope:SCOPE_PACKAGE, symbol:fn}
|
|
}
|
|
}
|
|
}
|
|
|
|
var package_path = get_packages_dir() + '/' + get_package_path(path)
|
|
if (fd.is_file(package_path)) {
|
|
var fn = resolve_mod_fn(package_path, ctx)
|
|
return {path: package_path, scope: SCOPE_PACKAGE, symbol: fn}
|
|
}
|
|
|
|
// 4. Check core as fallback
|
|
var core_dir = Shop.get_core_dir()
|
|
var core_file_path = core_dir + '/' + path
|
|
if (fd.is_file(core_file_path)) {
|
|
var fn = resolve_mod_fn(core_file_path, 'core')
|
|
return {path: core_file_path, scope: SCOPE_CORE, symbol: fn}
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
// given a C path like 'foo/bar/baz.c', return 'foo_bar_baz_use'
|
|
function c_sym_path(path)
|
|
{
|
|
return path.substring(0, path.lastIndexOf('.')).replace(/\//g, '_').replace(/\\/g, '_').replace(/\./g, '_').replace(/-/g, '_') + '_use'
|
|
}
|
|
|
|
function c_sym_prefix(package)
|
|
{
|
|
'js_' + package.replace(/\//g, '_').replace(/\./g, '_').replace(/-/g, '_') + '_'
|
|
}
|
|
|
|
function resolve_c_symbol(path, package_context)
|
|
{
|
|
var static_only = cell.static_only
|
|
var local_sym_base = c_sym_path(path)
|
|
|
|
// Candidates for symbol names
|
|
function symbol_candidates(pkg_path, mod_sym) {
|
|
var variants = []
|
|
// if pkg_path is 'gitea.pockle.world/john/prosperon', we want:
|
|
// js_gitea_pockle_world_john_prosperon_mod_use
|
|
// and maybe with leading slash?
|
|
var paths = [pkg_path]
|
|
// if (!pkg_path.startsWith('/')) paths.push('/' + pkg_path) // unlikely to need slash variant for standard pkgs
|
|
for (var i = 0; i < paths.length; i++) {
|
|
var candidate = `js_${c_sym_path(paths[i])}_${mod_sym}_use`
|
|
if (variants.indexOf(candidate) < 0)
|
|
variants.push(candidate)
|
|
}
|
|
return variants
|
|
}
|
|
|
|
// 1. Check internal symbols (statically linked)
|
|
// If we have a package context, we check package-prefixed symbols
|
|
// If not, we look for 'js_local_...' or 'js_path_use' directly?
|
|
|
|
if (package_context) {
|
|
// Check package internal symbols
|
|
var variants = symbol_candidates(package_context, local_sym_base)
|
|
for (var i = 0; i < variants.length; i++) {
|
|
if (os.internal_exists(variants[i])) {
|
|
return {
|
|
symbol: function() { return os.load_internal(variants[i]); },
|
|
scope: SCOPE_PACKAGE,
|
|
path: variants[i]
|
|
}
|
|
}
|
|
}
|
|
|
|
// In static_only mode, skip dynamic library lookups
|
|
if (!static_only) {
|
|
// Then try dynamic library
|
|
// Use ./libcellmod for local?
|
|
var local_dl_name = './libcellmod' + dylib_ext
|
|
// Or check package context dir if it's a local package path?
|
|
if (package_context && package_context.startsWith('/')) {
|
|
local_dl_name = package_context + '/libcellmod' + dylib_ext
|
|
}
|
|
|
|
if (fd.is_file(local_dl_name)) {
|
|
if (!open_dls[local_dl_name])
|
|
open_dls[local_dl_name] = os.dylib_open(local_dl_name);
|
|
|
|
if (open_dls[local_dl_name]) {
|
|
var locals = package_context ? symbol_candidates(package_context, local_sym_base) : [`js_local_${local_sym_base}_use`]
|
|
for (var i = 0; i < locals.length; i++) {
|
|
var candidate = locals[i]
|
|
if (os.dylib_has_symbol(open_dls[local_dl_name], candidate))
|
|
return {
|
|
symbol: function() { return os.dylib_symbol(open_dls[local_dl_name], candidate); },
|
|
scope: SCOPE_LOCAL,
|
|
path: candidate
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Local context
|
|
var local_sym = `js_local_${local_sym_base}_use`
|
|
if (os.internal_exists(local_sym)) {
|
|
return {
|
|
symbol: function() { return os.load_internal(local_sym); },
|
|
scope: SCOPE_LOCAL,
|
|
path: local_sym
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. Check if valid package import (e.g. 'prosperon/sprite')
|
|
var pkg_alias = get_import_package(path)
|
|
if (pkg_alias) {
|
|
var canon_pkg = get_aliased_package(path, package_context)
|
|
if (canon_pkg) {
|
|
var mod_name = get_import_name(path)
|
|
var mod_sym = mod_name.replace(/\//g, '_').replace(/-/g, '_').replace(/\./g, '_')
|
|
var sym_names = symbol_candidates(canon_pkg, mod_sym)
|
|
|
|
for (var i = 0; i < sym_names.length; i++) {
|
|
if (os.internal_exists(sym_names[i])) {
|
|
return {
|
|
symbol: function() { return os.load_internal(sym_names[i]); },
|
|
scope: SCOPE_PACKAGE,
|
|
package: canon_pkg,
|
|
path: sym_names[i]
|
|
}
|
|
}
|
|
}
|
|
// Then try dynamic library for package (skip in static_only mode)
|
|
if (!static_only) {
|
|
// Check package dir for libcellmod
|
|
var pkg_build_dir = get_packages_dir() + '/' + canon_pkg
|
|
var dl_path = pkg_build_dir + '/libcellmod' + dylib_ext
|
|
if (fd.is_file(dl_path)) {
|
|
if (!open_dls[dl_path]) open_dls[dl_path] = os.dylib_open(dl_path)
|
|
if (open_dls[dl_path]) {
|
|
for (var si = 0; si < sym_names.length; si++) {
|
|
var sym_name = sym_names[si]
|
|
if (os.dylib_has_symbol(open_dls[dl_path], sym_name))
|
|
return {
|
|
symbol: function() { return os.dylib_symbol(open_dls[dl_path], sym_name) },
|
|
scope: SCOPE_PACKAGE,
|
|
package: canon_pkg,
|
|
path: sym_name
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. Check Core/General fallback (js_path_use)
|
|
var core_sym = `js_${path.replace(/\//g, '_')}_use`;
|
|
if (os.internal_exists(core_sym))
|
|
return {
|
|
symbol: function() { return os.load_internal(core_sym); },
|
|
scope: SCOPE_CORE,
|
|
path: core_sym
|
|
};
|
|
|
|
return null
|
|
}
|
|
|
|
function resolve_module_info(path, package_context) {
|
|
var c_resolve = resolve_c_symbol(path, package_context) || {scope:999}
|
|
var mod_resolve = resolve_locator(path + '.cm', package_context) || {scope:999}
|
|
var min_scope = Math.min(c_resolve.scope, mod_resolve.scope)
|
|
|
|
if (min_scope == 999)
|
|
return null
|
|
|
|
var resolved_path
|
|
if (mod_resolve.scope != 999) resolved_path = mod_resolve.path
|
|
else resolved_path = c_resolve.path
|
|
|
|
var cache_scope = min_scope == SCOPE_CORE ? 2 : 0
|
|
var cache_key
|
|
if (min_scope == SCOPE_CORE)
|
|
cache_key = `2::${path}`
|
|
else
|
|
cache_key = `${text(cache_scope)}::${resolved_path}`
|
|
|
|
cache_key = cache_key.replace('//', '/')
|
|
|
|
return {
|
|
cache_key: cache_key,
|
|
c_resolve: c_resolve,
|
|
mod_resolve: mod_resolve,
|
|
min_scope: min_scope
|
|
}
|
|
}
|
|
|
|
function get_module_cache_key(path, package_context) {
|
|
var info = resolve_module_info(path, package_context)
|
|
return info ? info.cache_key : null
|
|
}
|
|
|
|
Shop.is_loaded = function(path, package_context) {
|
|
var cache_key = get_module_cache_key(path, package_context)
|
|
return use_cache[cache_key] != null
|
|
}
|
|
|
|
function execute_module(info)
|
|
{
|
|
var c_resolve = info.c_resolve
|
|
var mod_resolve = info.mod_resolve
|
|
var cache_key = info.cache_key
|
|
|
|
var used
|
|
|
|
// If we have a script, it always takes precedence (containing the C symbol if available)
|
|
// This supports "Hybrid" modules where JS wraps C.
|
|
if (mod_resolve.scope < 900) {
|
|
var context = null
|
|
if (c_resolve.scope < 900) {
|
|
context = c_resolve.symbol(null, $_)
|
|
}
|
|
used = mod_resolve.symbol.call(context, $_)
|
|
} else if (c_resolve.scope < 900) {
|
|
// C only
|
|
used = c_resolve.symbol(null, $_)
|
|
} else {
|
|
throw new Error(`Module ${info.path} could not be found`)
|
|
} if (!used)
|
|
throw new Error(`Module ${json.encode(info)} returned null`)
|
|
|
|
return used
|
|
}
|
|
|
|
function get_module(path, package_context) {
|
|
var info = resolve_module_info(path, package_context)
|
|
|
|
if (!info)
|
|
throw new Error(`Module ${path} could not be found in ${package_context}`)
|
|
|
|
return execute_module(info)
|
|
}
|
|
|
|
Shop.use = function(path, package_context) {
|
|
var info = resolve_module_info(path, package_context)
|
|
if (!info)
|
|
throw new Error(`Module ${path} could not be found in ${package_context}`)
|
|
|
|
if (use_cache[info.cache_key])
|
|
return use_cache[info.cache_key]
|
|
|
|
use_cache[info.cache_key] = execute_module(info)
|
|
return use_cache[info.cache_key]
|
|
}
|
|
|
|
Shop.resolve_locator = resolve_locator
|
|
|
|
// Get cache path for a package and commit
|
|
function get_cache_path(pkg, commit) {
|
|
var parsed = Shop.parse_package(pkg)
|
|
if (!parsed) return null
|
|
|
|
var slug = parsed.path.split('/').join('_')
|
|
return get_cache_dir() + '/' + slug + '_' + commit + '.zip'
|
|
}
|
|
|
|
function rm_recursive(path) {
|
|
try {
|
|
fd.rm(path)
|
|
} catch (e) {
|
|
log.error("Failed to remove " + path + ": " + e)
|
|
}
|
|
}
|
|
|
|
function get_all_files(dir, prefix, results) {
|
|
prefix = prefix || ""
|
|
results = results || []
|
|
|
|
var list = fd.readdir(dir)
|
|
if (!list) return results
|
|
|
|
for (var i = 0; i < list.length; i++) {
|
|
var item = list[i]
|
|
if (item == '.' || item == '..') continue
|
|
|
|
var full_path = dir + "/" + item
|
|
var rel_path = prefix ? prefix + "/" + item : item
|
|
|
|
var st = fd.stat(full_path)
|
|
if (st.isDirectory) {
|
|
get_all_files(full_path, rel_path, results)
|
|
} else {
|
|
results.push(rel_path)
|
|
}
|
|
}
|
|
return results
|
|
}
|
|
|
|
|
|
// Verify zip contents against target directory
|
|
function verify_zip_contents(zip, target_dir) {
|
|
var count = zip.count()
|
|
var expected_files = {}
|
|
for (var i = 0; i < count; i++) {
|
|
if (zip.is_directory(i)) continue
|
|
var filename = zip.get_filename(i)
|
|
var parts = filename.split('/')
|
|
if (parts.length > 1) {
|
|
parts.shift()
|
|
var rel_path = parts.join('/')
|
|
expected_files[rel_path] = true
|
|
|
|
var full_path = target_dir + '/' + rel_path
|
|
if (!fd.is_file(full_path)) return false
|
|
|
|
var content_zip = zip.slurp(filename)
|
|
var content_disk = fd.slurp(full_path)
|
|
|
|
if (content_zip.length != content_disk.length) return false
|
|
|
|
var hash_zip = text(crypto.blake2(content_zip), 'h')
|
|
var hash_disk = text(crypto.blake2(content_disk), 'h')
|
|
|
|
if (hash_zip != hash_disk) return false
|
|
}
|
|
}
|
|
|
|
// Check for extra files
|
|
var existing_files = get_all_files(target_dir)
|
|
for (var i = 0; i < existing_files.length; i++)
|
|
if (!expected_files[existing_files[i]]) return false
|
|
|
|
return true
|
|
}
|
|
|
|
// High-level: Add a package, install it, and install all transitive dependencies
|
|
// Like `bun add` or `npm install <pkg>`
|
|
Shop.get = function(pkg, alias) {
|
|
if (fd.is_dir(pkg)) {
|
|
log.console("Found directory: " + pkg)
|
|
pkg = fd.realpath(pkg)
|
|
log.console("Resolved to: " + pkg)
|
|
}
|
|
var info = Shop.resolve_package_info(pkg)
|
|
if (info.type == 'unknown') {
|
|
log.error("Could not resolve package: " + pkg)
|
|
return false
|
|
}
|
|
var parsed = Shop.parse_package(pkg)
|
|
if (!alias) alias = parsed.name
|
|
|
|
log.console("Adding dependency: " + alias + " = " + pkg)
|
|
|
|
// Add to config
|
|
var config = Shop.load_config() || { dependencies: {} }
|
|
if (!config.dependencies) config.dependencies = {}
|
|
config.dependencies[alias] = pkg
|
|
Shop.save_config(config)
|
|
return true
|
|
}
|
|
|
|
// Update a specific package
|
|
Shop.update = function(pkg) {
|
|
var config = Shop.load_config()
|
|
var lock = Shop.load_lock()
|
|
var parsed = Shop.parse_package(pkg)
|
|
var info = Shop.resolve_package_info(pkg)
|
|
var target_dir = get_packages_dir() + '/' + parsed.path
|
|
|
|
var result = info.type == 'local'
|
|
? update_local(pkg, info, target_dir)
|
|
: update_remote(pkg, info, target_dir, lock[pkg])
|
|
|
|
if (!result) {
|
|
log.error("Failed to update " + parsed.path)
|
|
return false
|
|
}
|
|
|
|
lock[pkg] = {
|
|
package: pkg,
|
|
commit: result.commit,
|
|
zip_hash: result.zip_hash,
|
|
updated: time.number()
|
|
}
|
|
Shop.save_lock(lock)
|
|
log.console("Updated " + parsed.path + ".")
|
|
return true
|
|
}
|
|
|
|
function update_local(pkg, info, target_dir) {
|
|
if (fd.is_link(target_dir)) {
|
|
if (fd.readlink(target_dir) == info.path)
|
|
return { commit: "local", package: pkg, zip_hash: "local" }
|
|
else
|
|
fd.unlink(target_dir)
|
|
}
|
|
|
|
var parent_dir = target_dir.substring(0, target_dir.lastIndexOf('/'))
|
|
ensure_dir(parent_dir)
|
|
|
|
if (fd.is_dir(target_dir)) fd.rmdir(target_dir)
|
|
|
|
try {
|
|
fd.symlink(info.path, target_dir)
|
|
log.console("Linked " + target_dir + " -> " + info.path)
|
|
return { commit: "local", package: pkg, zip_hash: "local" }
|
|
} catch(e) {
|
|
log.error("Failed to create symlink: " + e)
|
|
return null
|
|
}
|
|
}
|
|
|
|
function update_remote(pkg, info, target_dir, lock_info) {
|
|
var local_hash = lock_info ? lock_info.commit : null
|
|
var remote_hash = fetch_remote_hash(pkg)
|
|
|
|
if (!remote_hash && !local_hash) {
|
|
log.error("Could not resolve commit for " + pkg)
|
|
return null
|
|
}
|
|
|
|
var target_hash = remote_hash || local_hash
|
|
|
|
if (local_hash == target_hash) {
|
|
log.console(pkg + " is already up to date.")
|
|
return lock_info
|
|
}
|
|
|
|
if (local_hash)
|
|
log.console("Updating " + pkg + " " + local_hash.substring(0,8) + " -> " + target_hash.substring(0,8))
|
|
else
|
|
log.console("Installing " + pkg + "...")
|
|
|
|
var zip_blob = get_or_download_zip(pkg, target_hash)
|
|
if (!zip_blob) return null
|
|
|
|
var zip_hash = text(crypto.blake2(zip_blob), 'h')
|
|
install_zip(zip_blob, target_dir)
|
|
|
|
return { commit: target_hash, package: pkg, zip_hash: zip_hash }
|
|
}
|
|
|
|
function fetch_remote_hash(pkg) {
|
|
var api_url = Shop.get_api_url(pkg)
|
|
if (!api_url) return null
|
|
|
|
try {
|
|
var resp = http.fetch(api_url)
|
|
return Shop.extract_commit_hash(pkg, text(resp))
|
|
} catch (e) {
|
|
log.console("Warning: Could not check for updates for " + pkg)
|
|
return null
|
|
}
|
|
}
|
|
|
|
function get_or_download_zip(pkg, commit_hash) {
|
|
var cache_path = get_cache_path(pkg, commit_hash)
|
|
|
|
if (fd.is_file(cache_path)) {
|
|
log.console("Found cached zip: " + cache_path)
|
|
try {
|
|
return fd.slurp(cache_path)
|
|
} catch (e) {
|
|
log.error("Failed to read cache: " + e)
|
|
}
|
|
}
|
|
|
|
var download_url = Shop.get_download_url(pkg, commit_hash)
|
|
if (!download_url) {
|
|
log.error("Could not determine download URL for " + pkg)
|
|
return null
|
|
}
|
|
|
|
log.console("Downloading from " + download_url)
|
|
try {
|
|
var zip_blob = http.fetch(download_url)
|
|
ensure_dir(cache_path.substring(0, cache_path.lastIndexOf('/')))
|
|
fd.slurpwrite(cache_path, zip_blob)
|
|
log.console("Cached to " + cache_path)
|
|
return zip_blob
|
|
} catch (e) {
|
|
log.error(e)
|
|
return null
|
|
}
|
|
}
|
|
|
|
function install_zip(zip_blob, target_dir) {
|
|
var zip = miniz.read(zip_blob)
|
|
if (!zip) throw new Error("Failed to read zip archive")
|
|
|
|
if (fd.is_link(target_dir)) fd.unlink(target_dir)
|
|
|
|
log.console("Syncing to " + target_dir)
|
|
ensure_dir(target_dir)
|
|
|
|
var zip_files = {}
|
|
var count = zip.count()
|
|
|
|
for (var i = 0; i < count; i++) {
|
|
if (zip.is_directory(i)) continue
|
|
var filename = zip.get_filename(i)
|
|
var parts = filename.split('/')
|
|
if (parts.length <= 1) continue
|
|
|
|
parts.shift()
|
|
var rel_path = parts.join('/')
|
|
zip_files[rel_path] = { index: i, filename: filename }
|
|
}
|
|
|
|
var existing_files = fd.is_dir(target_dir) ? get_all_files(target_dir) : []
|
|
|
|
for (var i = 0; i < existing_files.length; i++) {
|
|
var rel_path = existing_files[i]
|
|
if (!zip_files[rel_path]) {
|
|
var full_path = target_dir + '/' + rel_path
|
|
log.console("Removing " + rel_path)
|
|
fd.rm(full_path)
|
|
}
|
|
}
|
|
|
|
for (var rel_path in zip_files) {
|
|
var zip_info = zip_files[rel_path]
|
|
var full_path = target_dir + '/' + rel_path
|
|
var dir_path = full_path.substring(0, full_path.lastIndexOf('/'))
|
|
|
|
var zip_content = zip.slurp(zip_info.filename)
|
|
var needs_write = true
|
|
|
|
if (fd.is_file(full_path)) {
|
|
var disk_content = fd.slurp(full_path)
|
|
if (disk_content.length == zip_content.length && disk_content.length != 0) {
|
|
var hash_zip = text(crypto.blake2(zip_content), 'h')
|
|
var hash_disk = text(crypto.blake2(disk_content), 'h')
|
|
if (hash_zip == hash_disk) {
|
|
needs_write = false
|
|
}
|
|
}
|
|
}
|
|
|
|
if (needs_write) {
|
|
ensure_dir(dir_path)
|
|
log.console("Writing " + rel_path)
|
|
fd.slurpwrite(full_path, zip_content)
|
|
}
|
|
}
|
|
}
|
|
|
|
// High-level: Remove a package and clean up
|
|
// Like `bun remove`
|
|
Shop.remove = function(alias_or_path) {
|
|
var config = Shop.load_config()
|
|
var is_dependency = config && config.dependencies && config.dependencies[alias_or_path]
|
|
|
|
var target_pkg = null
|
|
var locator = null
|
|
|
|
if (is_dependency) {
|
|
locator = config.dependencies[alias_or_path]
|
|
var parsed = Shop.parse_package(locator)
|
|
target_pkg = parsed.path
|
|
|
|
// Remove from config
|
|
delete config.dependencies[alias_or_path]
|
|
Shop.save_config(config)
|
|
} else {
|
|
// Check if it's a resolvable path
|
|
var resolved = Shop.resolve_path_to_package(alias_or_path)
|
|
if (resolved) {
|
|
target_pkg = resolved
|
|
} else {
|
|
// Check if alias_or_path exists directly in modules dir?
|
|
var direct_path = get_packages_dir() + '/' + alias_or_path
|
|
if (fd.exists(direct_path)) {
|
|
target_pkg = alias_or_path
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!target_pkg) {
|
|
log.error("Package/Dependency not found: " + alias_or_path)
|
|
return false
|
|
}
|
|
|
|
var target_dir = get_packages_dir() + '/' + target_pkg
|
|
|
|
// Remove from lock
|
|
var lock = Shop.load_lock()
|
|
var lock_changed = false
|
|
|
|
if (locator && lock[locator]) {
|
|
delete lock[locator]
|
|
lock_changed = true
|
|
}
|
|
if (lock[alias_or_path]) {
|
|
delete lock[alias_or_path]
|
|
lock_changed = true
|
|
}
|
|
|
|
// Scan for any entry pointing to this target
|
|
for (var k in lock) {
|
|
if (lock[k].package == target_pkg || lock[k].package == '/' + target_pkg) {
|
|
delete lock[k]
|
|
lock_changed = true
|
|
}
|
|
}
|
|
|
|
if (lock_changed) Shop.save_lock(lock)
|
|
|
|
// Remove directory
|
|
if (fd.is_link(target_dir)) {
|
|
log.console("Unlinking " + target_dir)
|
|
fd.unlink(target_dir)
|
|
} else if (fd.is_dir(target_dir)) {
|
|
log.console("Removing " + target_dir)
|
|
fd.rmdir(target_dir)
|
|
}
|
|
|
|
log.console("Removed " + (is_dependency ? alias_or_path : target_pkg))
|
|
return true
|
|
}
|
|
|
|
Shop.add_replacement = function(alias, replacement) {
|
|
var config = Shop.load_config()
|
|
if (!config) config = {}
|
|
if (!config.replace) config.replace = {}
|
|
|
|
config.replace[alias] = replacement
|
|
Shop.save_config(config)
|
|
|
|
log.console("Added replacement: " + alias + " = " + replacement)
|
|
return true
|
|
}
|
|
|
|
Shop.remove_replacement = function(alias) {
|
|
var config = Shop.load_config()
|
|
if (!config || !config.replace || !config.replace[alias]) {
|
|
log.error("No replacement found for " + alias)
|
|
return false
|
|
}
|
|
|
|
delete config.replace[alias]
|
|
Shop.save_config(config)
|
|
|
|
log.console("Removed replacement for " + alias)
|
|
log.console("Run 'cell update " + alias + "' to restore the package.")
|
|
return true
|
|
}
|
|
|
|
// Compile a module
|
|
// List all files in a package
|
|
Shop.list_files = function(pkg) {
|
|
var dir
|
|
if (!pkg) dir = '.'
|
|
else dir = get_packages_dir() + '/' + pkg
|
|
|
|
var files = []
|
|
|
|
var walk = function(current_dir, current_prefix) {
|
|
var list = fd.readdir(current_dir)
|
|
if (!list) return
|
|
|
|
for (var i = 0; i < list.length; i++) {
|
|
var item = list[i]
|
|
if (item == '.' || item == '..') continue
|
|
if (item.startsWith('.')) continue
|
|
|
|
// Skip build directories in root
|
|
|
|
var full_path = current_dir + "/" + item
|
|
var rel_path = current_prefix ? current_prefix + "/" + item : item
|
|
|
|
var st = fd.stat(full_path)
|
|
if (st.isDirectory) {
|
|
walk(full_path, rel_path)
|
|
} else {
|
|
files.push(rel_path)
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fd.is_dir(dir)) {
|
|
walk(dir, "")
|
|
}
|
|
return files
|
|
}
|
|
|
|
Shop.get_c_objects = function(pkg) {
|
|
var files = Shop.list_files(pkg)
|
|
var objects = []
|
|
var build_dir = get_build_dir(pkg)
|
|
|
|
for (var i=0; i<files.length; i++) {
|
|
var file = files[i]
|
|
if (file.endsWith('.c') || file.endsWith('.cpp')) {
|
|
objects.push(build_dir + '/' + file + '.o')
|
|
}
|
|
}
|
|
return objects
|
|
}
|
|
|
|
Shop.compile_module = function(alias) {
|
|
var module_dir = Shop.get_module_dir(alias)
|
|
if (!module_dir) {
|
|
log.error("Module not found: " + alias)
|
|
return false
|
|
}
|
|
|
|
log.console("Would compile module: " + alias + " from " + module_dir)
|
|
return true
|
|
}
|
|
|
|
var debug = use('debug')
|
|
|
|
Shop.module_reload = function(path, package) {
|
|
if (!Shop.is_loaded(path,package)) return
|
|
var info = resolve_module_info(path, package)
|
|
if (!info) return
|
|
|
|
var cache_key = info.cache_key
|
|
var old = use_cache[cache_key]
|
|
var newmod = get_module(path, package)
|
|
|
|
for (var i in newmod)
|
|
old[i] = newmod[i]
|
|
|
|
for (var i in old) {
|
|
if (!(i in newmod))
|
|
old[i] = null
|
|
}
|
|
}
|
|
|
|
// Filter out main*.c files (they're only for static builds)
|
|
function is_main_file(file) {
|
|
var basename = file
|
|
var slash = file.lastIndexOf('/')
|
|
if (slash >= 0) basename = file.substring(slash + 1)
|
|
if (basename == 'main.c') return true
|
|
if (basename.startsWith('main_') && basename.endsWith('.c')) return true
|
|
return false
|
|
}
|
|
|
|
// Get the core build directory for linking
|
|
function get_core_build_dir() {
|
|
return get_global_build_dir() + '/core'
|
|
}
|
|
|
|
function get_package_scripts(package)
|
|
{
|
|
var files = Shop.list_files(package)
|
|
var scripts = []
|
|
|
|
for (var i = 0; i < files.length; i++) {
|
|
var file = files[i]
|
|
if (file.endsWith('.cm') || file.endsWith('.ce')) {
|
|
scripts.push(file)
|
|
}
|
|
}
|
|
|
|
return scripts
|
|
}
|
|
|
|
function get_package_c_files(package)
|
|
{
|
|
var files = Shop.list_files(package)
|
|
var c_files = []
|
|
|
|
for (var i = 0; i < files.length; i++) {
|
|
var file = files[i]
|
|
if (file.endsWith('.c') || file.endsWith('.cpp')) {
|
|
c_files.push(file)
|
|
}
|
|
}
|
|
|
|
return c_files
|
|
}
|
|
|
|
Shop.build_package_scripts = function(package)
|
|
{
|
|
// compiles all .ce and .cm files in a package
|
|
var scripts = get_package_scripts(package)
|
|
for (var script of scripts)
|
|
resolve_mod_fn(script, package)
|
|
}
|
|
|
|
function get_target_dynamic_files(package, target)
|
|
{
|
|
var files = get_package_c_files(package)
|
|
var result = []
|
|
|
|
// Build a map of base names to their variants
|
|
var variants = {}
|
|
for (var i = 0; i < files.length; i++) {
|
|
var file = files[i]
|
|
var basename = file.substring(0, file.lastIndexOf('.'))
|
|
var ext = file.substring(file.lastIndexOf('.'))
|
|
|
|
// Check if this is a target-specific variant (name_target.ext)
|
|
var underscore = basename.lastIndexOf('_')
|
|
if (underscore >= 0) {
|
|
var base = basename.substring(0, underscore)
|
|
var suffix = basename.substring(underscore + 1)
|
|
if (!variants[base]) variants[base] = {}
|
|
variants[base][suffix] = file
|
|
} else {
|
|
if (!variants[basename]) variants[basename] = {}
|
|
variants[basename]['default'] = file
|
|
}
|
|
}
|
|
|
|
// Select appropriate files
|
|
for (var base in variants) {
|
|
var v = variants[base]
|
|
// Skip main files entirely for dynamic builds
|
|
if (base == 'main' || base.endsWith('/main')) continue
|
|
|
|
if (target && v[target]) {
|
|
result.push(v[target])
|
|
} else if (v['default']) {
|
|
result.push(v['default'])
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
Shop.build_package = function(package)
|
|
{
|
|
Shop.build_package_scripts(package)
|
|
|
|
var dynamic_files = get_target_dynamic_files(package, os.platform())
|
|
|
|
var files = Shop.list_files(package)
|
|
var build_dir = get_build_dir(package)
|
|
ensure_dir(build_dir)
|
|
|
|
var module_dir = package ? get_packages_dir() + '/' + package : (current_package_path || '.')
|
|
|
|
log.console(`Building package ${package ? package : 'local'} to ${build_dir}`)
|
|
|
|
// For C compilation
|
|
var config = Shop.load_config(package) || {}
|
|
var cflags = get_flags(config, platform, 'CFLAGS')
|
|
|
|
// Determine usage prefix for C symbols
|
|
var use_prefix = c_sym_prefix(package)
|
|
|
|
var c_objects = []
|
|
|
|
// Use get_hash from build_utils
|
|
var get_hash = build_utils.get_hash
|
|
|
|
for (var i=0; i<files.length; i++) {
|
|
var file = files[i]
|
|
// Compile C
|
|
var obj_path = build_dir + '/' + file + '.o'
|
|
|
|
var use_name = use_prefix + c_sym_path(file)
|
|
var comp_src = file
|
|
var comp_obj = file + '.o'
|
|
var base_cmd = 'cc -fPIC '
|
|
var compile_flags = '-c ' + comp_src + ' -O3 -DCELL_USE_NAME=' + use_name
|
|
if (cflags != '') compile_flags += ' ' + cflags
|
|
|
|
var full_compile_cmd = 'cd ' + module_dir + ' && ' + base_cmd + compile_flags + ' -o ' + comp_obj
|
|
var file_content = slurp_package_file(file, package)
|
|
var obj_path = hash_path(full_compile_cmd + text(file_content))
|
|
|
|
if (fd.is_file(obj_path)) {
|
|
log.console("Compiling " + src_path + " -> " + obj_path)
|
|
var ret = os.system(full_compile_cmd)
|
|
if (ret != 0) {
|
|
log.error("Compilation failed for " + src_path)
|
|
return false
|
|
}
|
|
|
|
// 3. Move object
|
|
os.system('mv ' + module_dir + '/' + comp_obj + ' ' + obj_path)
|
|
}
|
|
c_objects.push(obj_path)
|
|
}
|
|
|
|
|
|
// Link if there are C objects
|
|
if (c_objects.length > 0) {
|
|
var lib_name = get_shared_lib_path() + '/lib' + get_package_path(package) + dylib_ext
|
|
|
|
var link_flags = '-fPIC -shared'
|
|
|
|
// Link against core package dylib (unless we ARE the core)
|
|
var core_pkg = get_core_package()
|
|
if (package != core_pkg) {
|
|
var lib_dir = get_shared_lib_path()
|
|
if (platform == 'macOS') {
|
|
link_flags += ' -L' + lib_dir + ' -Wl,-rpath,@loader_path'
|
|
} else if (platform == 'Linux' || platform == 'linux') {
|
|
link_flags += ' -L' + lib_dir + ' -Wl,-rpath,$ORIGIN'
|
|
} else if (platform == 'Windows') {
|
|
link_flags += ' -L' + lib_dir
|
|
}
|
|
link_flags += ' -l' + get_core_package()
|
|
}
|
|
|
|
var ldflags = get_flags(config, platform, 'LDFLAGS')
|
|
if (ldflags != '') link_flags += ' ' + ldflags
|
|
|
|
var objs_str = ''
|
|
for (var i=0; i<c_objects.length; i++) {
|
|
objs_str += '"' + c_objects[i] + '" '
|
|
}
|
|
|
|
var link_cmd = 'cc ' + link_flags + ' ' + objs_str + ' -lc -lc++ -o ' + lib_name
|
|
|
|
log.console("Linking " + lib_name)
|
|
|
|
var ret = os.system(link_cmd)
|
|
if (ret != 0) {
|
|
log.error("Linking failed")
|
|
return false
|
|
}
|
|
log.console("Built " + lib_name)
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// Get dependencies for a specific context (package canonical path)
|
|
// If ctx is null, returns dependencies for the local project
|
|
Shop.dependencies = function(ctx) {
|
|
var config = Shop.load_config(ctx)
|
|
if (!config || !config.dependencies) {
|
|
return {}
|
|
}
|
|
return config.dependencies
|
|
}
|
|
|
|
Shop.list_packages = function(root)
|
|
{
|
|
var queue = []
|
|
var processed = {}
|
|
var result = []
|
|
|
|
var deps = Shop.dependencies(root)
|
|
for (var alias in deps) {
|
|
var pkg = deps[alias]
|
|
if (!processed[pkg]) {
|
|
queue.push(pkg)
|
|
}
|
|
}
|
|
|
|
while (queue.length > 0) {
|
|
var pkg = queue.shift()
|
|
if (processed[pkg]) continue
|
|
processed[pkg] = true
|
|
|
|
result.push(pkg)
|
|
|
|
var parsed = Shop.parse_package(pkg)
|
|
var pkg_config = Shop.load_config(parsed.path)
|
|
|
|
if (pkg_config && pkg_config.dependencies) {
|
|
for (var alias in pkg_config.dependencies) {
|
|
var dep_pkg = pkg_config.dependencies[alias]
|
|
if (!processed[dep_pkg]) {
|
|
queue.push(dep_pkg)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// List all .cm and .ce files in a package
|
|
// If ctx is null, lists local files
|
|
// If ctx is a canonical path, lists files in that module
|
|
Shop.list_modules = function(ctx) {
|
|
var files = Shop.list_files(ctx)
|
|
var modules = []
|
|
for (var i=0; i<files.length; i++) {
|
|
var f = files[i]
|
|
if (f.endsWith('.cm') || f.endsWith('.ce')) {
|
|
modules.push(f)
|
|
}
|
|
}
|
|
return modules
|
|
}
|
|
|
|
// Resolve a module path given a package context
|
|
// Returns { path, package_name } or null if not found
|
|
// Resolution order:
|
|
// 1. Local to the current package (if package_name is set)
|
|
// 2. Declared dependencies (by alias)
|
|
// 3. Core modules (handled by caller)
|
|
Shop.resolve_module = function(module_name, package_name, is_file_fn) {
|
|
var config = Shop.load_config()
|
|
var dependencies = (config && config.dependencies) || {}
|
|
|
|
// If we're in a package context, check the package first
|
|
if (package_name) {
|
|
var pkg_path = get_packages_dir() + '/' + package_name + '/' + module_name + '.cm'
|
|
if (is_file_fn(pkg_path)) {
|
|
return { path: pkg_path, package_name: package_name }
|
|
}
|
|
}
|
|
|
|
// Check if module_name contains a slash (explicit package reference)
|
|
if (module_name.includes('/')) {
|
|
var parts = module_name.split('/')
|
|
var pkg_alias = parts[0]
|
|
var sub_module = parts.slice(1).join('/')
|
|
|
|
// Check if it's a declared dependency
|
|
if (dependencies[pkg_alias]) {
|
|
// Need to resolve alias to canonical path
|
|
var pkg = dependencies[pkg_alias]
|
|
var parsed = Shop.parse_package(pkg)
|
|
var canonical_path = parsed.path
|
|
|
|
var dep_path = get_packages_dir() + '/' + canonical_path + '/' + sub_module + '.cm'
|
|
if (is_file_fn(dep_path)) {
|
|
return { path: dep_path, package_name: pkg_alias }
|
|
}
|
|
}
|
|
|
|
// Check local path (relative to current package)
|
|
var local_base = current_package_path || '.'
|
|
var local_path = local_base + '/' + module_name + '.cm'
|
|
if (is_file_fn(local_path)) {
|
|
return { path: local_path, package_name: null }
|
|
}
|
|
} else {
|
|
// Simple module name - check local first, then dependencies
|
|
var local_base = current_package_path || '.'
|
|
var local_path = local_base + '/' + module_name + '.cm'
|
|
if (is_file_fn(local_path)) {
|
|
return { path: local_path, package_name: null }
|
|
}
|
|
|
|
// Check each declared dependency for this module
|
|
for (var alias in dependencies) {
|
|
var pkg = dependencies[alias]
|
|
var parsed = Shop.parse_package(pkg)
|
|
var canonical_path = parsed.path
|
|
|
|
var dep_path = get_packages_dir() + '/' + canonical_path + '/' + module_name + '.cm'
|
|
if (is_file_fn(dep_path)) {
|
|
return { path: dep_path, package_name: alias }
|
|
}
|
|
}
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
Shop.resolve_alias = function(name, ctx) {
|
|
var deps = Shop.dependencies(ctx)
|
|
if (deps && deps[name]) return { alias: name, pkg: Shop.get_canonical_package(name, ctx) }
|
|
|
|
for (var alias in deps) {
|
|
var pkg = deps[alias]
|
|
var parsed = Shop.parse_package(pkg)
|
|
if (parsed && (parsed.name == name || parsed.path == name)) {
|
|
return { alias: alias, pkg: parsed.path }
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
Shop.get_canonical_package = get_canonical_package
|
|
|
|
Shop.upgrade_core = function() {
|
|
var pkg = "gitea.pockle.world/john/cell"
|
|
var hash = fetch_remote_hash(pkg)
|
|
|
|
if (!hash) {
|
|
// Fallback to master?
|
|
log.console("Could not fetch remote hash for core, assuming master.")
|
|
hash = "master"
|
|
}
|
|
|
|
var zip = get_or_download_zip(pkg, hash)
|
|
if (!zip) return false
|
|
|
|
var core_dir = Shop.get_core_dir()
|
|
install_zip(zip, core_dir)
|
|
|
|
var lock = Shop.load_lock()
|
|
lock['core'] = {
|
|
package: pkg,
|
|
commit: hash,
|
|
updated: time.number()
|
|
}
|
|
Shop.save_lock(lock)
|
|
|
|
log.console("Core updated to " + hash)
|
|
return true
|
|
}
|
|
|
|
Shop.link_core = function(target) {
|
|
if (!fd.is_dir(target)) return false
|
|
var core_dir = Shop.get_core_dir()
|
|
|
|
if (fd.is_link(core_dir)) fd.unlink(core_dir)
|
|
else if (fd.is_dir(core_dir)) {
|
|
// Safety check?
|
|
// For now, we assume user knows what they are doing.
|
|
// We can't easily rm recursive if it's a real dir unless we use system rm or implement it.
|
|
// shop.cm has rm_recursive? No, I implemented it?
|
|
// I saw `function rm_recursive` at line 1141. internal.
|
|
rm_recursive(core_dir)
|
|
}
|
|
|
|
fd.symlink(fd.realpath(target), core_dir)
|
|
|
|
var lock = Shop.load_lock()
|
|
lock['core'] = {
|
|
package: fd.realpath(target),
|
|
type: 'local',
|
|
updated: time.number()
|
|
}
|
|
Shop.save_lock(lock)
|
|
return true
|
|
}
|
|
|
|
Shop.unlink_core = function() {
|
|
var core_dir = Shop.get_core_dir()
|
|
if (fd.is_link(core_dir)) {
|
|
fd.unlink(core_dir)
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
Shop.is_core_linked = function() {
|
|
var core_dir = Shop.get_core_dir()
|
|
return fd.is_link(core_dir)
|
|
}
|
|
|
|
Shop.list_shop_packages = function() {
|
|
var lock = Shop.load_lock()
|
|
var list = []
|
|
for (var k in lock) {
|
|
if (lock[k]) list.push(lock[k])
|
|
}
|
|
return list
|
|
}
|
|
|
|
return Shop |