@phystack/device-phyos 4.5.64-dev → 5.0.1

package/bin/index.js

@@ -1,23 +1,27 @@
 #!/usr/bin/env node
-const { spawnSync } = require('child_process');
-const path = require('path');
+const { spawnSync } = require("child_process");
+const path = require("path");
 
-const BINARY = 'phydevice';
+const BINARY = "phydevice";
 const key = `${process.platform}-${process.arch}`;
 const pkg = `@phystack/${BINARY}-${key}`;
 
 let binPath;
 try {
-  binPath = path.join(path.dirname(require.resolve(`${pkg}/package.json`)), 'bin', BINARY);
+  binPath = path.join(
+    path.dirname(require.resolve(`${pkg}/package.json`)),
+    "bin",
+    BINARY,
+  );
 } catch {
   console.error(
     `Unsupported or missing platform package: ${pkg}\n` +
-    `Platform: ${key}\n\n` +
-    `Install manually:  npm install ${pkg}\n` +
-    `Or download:       npx ${pkg}`
+      `Platform: ${key}\n\n` +
+      `Install manually:  npm install ${pkg}\n` +
+      `Or download:       bunx ${pkg}`,
   );
   process.exit(1);
 }
 
-const result = spawnSync(binPath, process.argv.slice(2), { stdio: 'inherit' });
+const result = spawnSync(binPath, process.argv.slice(2), { stdio: "inherit" });
 process.exit(result.status ?? 1);

package/dist/index.js

@@ -0,0 +1,491 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const hub_device_1 = __importDefault(require("@phystack/hub-device"));
+const phy_logger_1 = require("@phystack/phy-logger");
+const edge_hub_1 = require("./edge-hub");
+const instances_1 = require("./utilities/instances");
+const methods_1 = require("./methods");
+const scheduler_service_1 = require("./services/scheduler.service");
+const time_sync_1 = __importDefault(require("./time-sync"));
+const environment_1 = require("./methods/environment");
+const ca_1 = require("./methods/network/ca");
+const twin_manager_1 = require("./utilities/twin-manager");
+const { connectToPhyHub } = hub_device_1.default;
+const phyosEnvPath = '/etc/phyos.env';
+const phyosVersionPath = '/etc/phyos.version';
+const credentialsMigrationPath = '/data/migration.json';
+const environmentFilePath = '/etc/environment';
+const regionFilePath = '/data/settings/phyhub/region.json';
+const customProxyFilePath = '/data/environment-custom-proxy';
+const logger = new phy_logger_1.PhyLogger({
+    logToFile: false,
+    logToConsole: true,
+    includeTrace: true,
+    namespace: 'device-phyos',
+});
+function sourceEnvironment() {
+    let gridEnv = 'PROD';
+    try {
+        const symlinkFixed = (0, environment_1.ensureEnvironmentSymlink)();
+        try {
+            if (fs_1.default.existsSync(phyosEnvPath)) {
+                const envContent = fs_1.default.readFileSync(phyosEnvPath, 'utf8').trim().toUpperCase();
+                if (envContent === 'DEV' || envContent === 'QA') {
+                    gridEnv = envContent;
+                }
+            }
+        }
+        catch (error) {
+            logger.warn('Error reading grid environment, defaulting to prod:', error);
+        }
+        if (symlinkFixed || !fs_1.default.existsSync(environmentFilePath)) {
+            (0, environment_1.setDefaultEnvironmentConfiguration)(gridEnv);
+        }
+        const envContent = fs_1.default.readFileSync(environmentFilePath, 'utf8');
+        const envLines = envContent.split('\n');
+        for (const line of envLines) {
+            if (line.trim() && !line.startsWith('#')) {
+                const [key, value] = line.split('=');
+                if (key && value) {
+                    process.env[key.trim()] = value.trim().replace(/["']/g, '');
+                }
+            }
+        }
+    }
+    catch (error) {
+        logger.error('Failed to read /etc/environment:', error);
+        try {
+            (0, environment_1.setDefaultEnvironmentConfiguration)(gridEnv);
+        }
+        catch (innerError) {
+            logger.error('Failed to set default proxy configuration:', innerError);
+        }
+    }
+}
+function getSystemdJournalGid() {
+    try {
+        const groupFile = fs_1.default.readFileSync('/etc/group', 'utf8');
+        const groups = groupFile.split('\n');
+        const journalGroup = groups.find(line => line.startsWith('systemd-journal:'));
+        if (!journalGroup) {
+            throw new Error('systemd-journal group not found');
+        }
+        const gid = parseInt(journalGroup.split(':')[2]);
+        if (isNaN(gid)) {
+            throw new Error('Invalid GID for systemd-journal');
+        }
+        return gid;
+    }
+    catch (error) {
+        logger.error('Failed to get systemd-journal GID:', error);
+        return 0;
+    }
+}
+function initializeFiles() {
+    const PROVISIONING_CODE_PATH = '/tmp/provisioning_code';
+    const LOG_PATH = '/data/log';
+    try {
+        if (!fs_1.default.existsSync(PROVISIONING_CODE_PATH)) {
+            fs_1.default.writeFileSync(PROVISIONING_CODE_PATH, '');
+        }
+        fs_1.default.chmodSync(PROVISIONING_CODE_PATH, 0o666);
+        if (!fs_1.default.existsSync(LOG_PATH)) {
+            fs_1.default.mkdirSync(LOG_PATH, { recursive: true });
+        }
+        try {
+            const journalGid = getSystemdJournalGid();
+            fs_1.default.chownSync(LOG_PATH, 0, journalGid);
+            fs_1.default.chmodSync(LOG_PATH, 0o2775);
+        }
+        catch (error) {
+            logger.error('Failed to set log directory permissions:', error);
+            setTimeout(() => process.exit(1), 1000);
+        }
+    }
+    catch (error) {
+        logger.error('Failed to initialize required files:', error);
+        setTimeout(() => process.exit(1), 1000);
+    }
+}
+function initializeProxy() {
+    try {
+        let needsDefaultConfig = true;
+        if (fs_1.default.existsSync(environmentFilePath)) {
+            const envContent = fs_1.default.readFileSync(environmentFilePath, 'utf8');
+            const hasHttpProxy = envContent.includes('http_proxy=');
+            const hasHttpsProxy = envContent.includes('https_proxy=');
+            needsDefaultConfig = !hasHttpProxy && !hasHttpsProxy;
+        }
+        let gridEnv = 'PROD';
+        try {
+            if (fs_1.default.existsSync(phyosEnvPath)) {
+                const envContent = fs_1.default.readFileSync(phyosEnvPath, 'utf8').trim().toUpperCase();
+                if (envContent === 'DEV' || envContent === 'QA') {
+                    gridEnv = envContent;
+                }
+            }
+        }
+        catch (error) {
+            logger.warn('initializeProxy(): Error reading grid environment, defaulting to prod:', error);
+        }
+        if (needsDefaultConfig) {
+            logger.info('Proxy settings not found, setting default configuration for environment:', gridEnv);
+            (0, environment_1.setDefaultEnvironmentConfiguration)(gridEnv);
+        }
+        else {
+            logger.info('Proxy settings already exist, skipping default configuration');
+        }
+    }
+    catch (error) {
+        logger.error('Failed to check proxy settings:', error);
+        try {
+            (0, environment_1.setDefaultEnvironmentConfiguration)('PROD');
+        }
+        catch (innerError) {
+            logger.error('Failed to set default proxy configuration:', innerError);
+            setTimeout(() => process.exit(1), 1000);
+        }
+    }
+}
+try {
+    initializeFiles();
+    initializeProxy();
+    sourceEnvironment();
+    (0, environment_1.checkProxySettings)();
+}
+catch (error) {
+    logger.error('Failed to initialize environment:', error);
+    setTimeout(() => process.exit(1), 1000);
+}
+class DevicePhyos {
+    GRID_ENV;
+    PHYOS_VERSION;
+    firstConnect;
+    phyHubInterval;
+    logger;
+    scheduler = new scheduler_service_1.Scheduler();
+    twinManager;
+    constructor() {
+        this.GRID_ENV = 'PROD';
+        this.PHYOS_VERSION = 'N/A';
+        this.firstConnect = false;
+        this.phyHubInterval = null;
+        this.logger = new phy_logger_1.PhyLogger({
+            logToFile: false,
+            logToConsole: true,
+            includeTrace: true,
+            namespace: 'device-phyos',
+        });
+    }
+    async initialize() {
+        await this.initializeEnvironment();
+        await this.initializeTimeSync();
+        this.logger.info(`Starting device phyos service 🟢-⚪-⚪-⚪-⚪`, {
+            GRID_ENV: this.GRID_ENV,
+            PHYOS_VERSION: this.PHYOS_VERSION
+        });
+    }
+    async initializeEnvironment() {
+        try {
+            this.GRID_ENV = await fs_1.default.promises.readFile(phyosEnvPath, 'utf8').then(data => data.trim() || 'LOCAL');
+            this.logger.info('initializeEnvironment(): Setting grid environment', {
+                GRID_ENV: this.GRID_ENV,
+            });
+        }
+        catch (error) {
+            this.logger.error('initializeEnvironment(): Error reading grid environment', error);
+            this.GRID_ENV = 'PROD';
+        }
+        try {
+            this.PHYOS_VERSION = await fs_1.default.promises.readFile(phyosVersionPath, 'utf8').then(data => data.trim());
+            this.logger.info('initializeEnvironment(): Setting PhyOS version', {
+                PHYOS_VERSION: this.PHYOS_VERSION
+            });
+        }
+        catch (error) {
+            this.logger.error('initializeEnvironment(): Error reading PhyOS version', error);
+            this.PHYOS_VERSION = 'N/A';
+        }
+    }
+    async initializeTimeSync() {
+        try {
+            this.logger.info('initializeTimeSync(): Performing initial time sync');
+            await (0, time_sync_1.default)();
+        }
+        catch (error) {
+            this.logger.error('initializeTimeSync(): Initial time sync failed:', error);
+        }
+    }
+    async initializeCachedInstances(twinManager) {
+        const twinsInfoCache = await twinManager.getCachedTwins();
+        console.log('initializeCachedInstances(): twinsInfoCache', twinsInfoCache);
+        if (!twinsInfoCache || typeof twinsInfoCache !== 'object') {
+            this.logger.info('initializeCachedInstances(): No cached twins found');
+            return;
+        }
+        const allTwins = [];
+        for (const type of Object.keys(twinsInfoCache)) {
+            const twinIds = twinsInfoCache[type];
+            if (!Array.isArray(twinIds))
+                continue;
+            const twins = await Promise.all(twinIds.map(async (twinId) => {
+                const twin = await twinManager.getCachedTwins(twinId);
+                return twin;
+            }));
+            allTwins.push(...twins.filter(Boolean));
+        }
+        if (allTwins.length > 0) {
+            this.logger.info(`initializeCachedInstances(): Found ${allTwins.length} cached twin(s), initializing...`);
+            await (0, instances_1.initInstances)(this.twinManager, allTwins);
+        }
+        else {
+            this.logger.info('initializeCachedInstances(): No valid twins to initialize');
+        }
+    }
+    async connectPhyHub(hubDevice) {
+        this.twinManager = await (0, twin_manager_1.getTwinManagerInstance)();
+        this.twinManager.setHubDevice(hubDevice);
+        this.scheduler.setHubDevice(hubDevice);
+        hubDevice.setScheduler(this.scheduler);
+        hubDevice.onAuthReconnect(async () => {
+            this.logger.info('connectPhyHub(): Device authenticated, resubscribing twins...');
+            await edge_hub_1.EdgeHubServer.getInstance().resubscribeAllTwins();
+            try {
+                const cachedTwinsInfo = await this.twinManager.getCachedTwins();
+                if (cachedTwinsInfo && typeof cachedTwinsInfo === 'object' && 'Device' in cachedTwinsInfo && Array.isArray(cachedTwinsInfo.Device) && cachedTwinsInfo.Device.length > 0) {
+                    const deviceTwinId = cachedTwinsInfo.Device[0];
+                    const deviceTwin = await this.twinManager.getCachedTwins(deviceTwinId);
+                    if (deviceTwin && deviceTwin.type === 'Device' && 'properties' in deviceTwin && deviceTwin.properties) {
+                        const deviceProps = deviceTwin.properties;
+                        const jobs = deviceProps.reported?.jobs || [];
+                        const timezone = deviceProps.desired?.timezone || 'UTC';
+                        this.logger.info(`connectPhyHub(): Re-processing ${jobs.length} jobs after reconnection`);
+                        this.scheduler.processJobs(jobs, timezone, deviceTwinId);
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.error('connectPhyHub(): Failed to re-process scheduler jobs after reconnection', error);
+            }
+        });
+        await hubDevice.connect();
+        this.logger.info('connectPhyHub(): Connected to PhyHub');
+        hubDevice.connectDevice(async (response) => {
+            const { twins } = response;
+            console.log('connectPhyHub(): response', response);
+            const deviceTwin = twins?.find((twin) => twin.type === 'Device');
+            const deviceId = deviceTwin?.deviceId;
+            if (!deviceId) {
+                this.logger.warn('connectPhyHub(): Missing required device ID in response');
+                return;
+            }
+            this.logger.info(`connectPhyHub(): Device connected with details:`, { deviceId });
+            if (deviceId) {
+                let shouldUpdateEnvironment = false;
+                try {
+                    if (fs_1.default.existsSync(environmentFilePath)) {
+                        const envContent = fs_1.default.readFileSync(environmentFilePath, 'utf8');
+                        shouldUpdateEnvironment = envContent.includes('unprovisioned:device@');
+                    }
+                    else {
+                        shouldUpdateEnvironment = true;
+                    }
+                }
+                catch (error) {
+                    this.logger.warn('connectPhyHub(): Failed to read environment file:', error);
+                    shouldUpdateEnvironment = true;
+                }
+                if (shouldUpdateEnvironment) {
+                    try {
+                        const proxyConfig = {
+                            region: hubDevice.region,
+                            port: 443,
+                            username: deviceId,
+                            password: 'device',
+                            timezone: deviceTwin?.properties?.desired?.timezone || 'Etc/UTC'
+                        };
+                        this.logger.info('connectPhyHub(): Environment contains unprovisioned username, configuring with device credentials:', proxyConfig);
+                        await (0, environment_1.setEnvironmentConfiguration)(proxyConfig);
+                        this.logger.info('connectPhyHub(): Environment configuration completed successfully');
+                    }
+                    catch (error) {
+                        this.logger.error('connectPhyHub(): Failed to configure provisioned environment, continuing with unprovisioned environment:', error);
+                    }
+                }
+                else {
+                    this.logger.info('connectPhyHub(): Environment already provisioned with device credentials, skipping configuration');
+                }
+            }
+            if (!this.firstConnect) {
+                this.firstConnect = true;
+            }
+            if (twins?.length) {
+                this.logger.info('connectPhyHub(): Caching twins from server response...');
+                await Promise.all(twins.map((twin) => this.twinManager.cacheHubTwin(twin)));
+                this.logger.info(`connectPhyHub(): Cached ${twins.length} twins from hub`);
+                const twinsByType = await this.twinManager.getCachedTwins();
+                const allTwinIds = Object.values(twinsByType).flat();
+                this.logger.info(`connectPhyHub(): Found ${allTwinIds.length} total twins after caching`);
+                const allTwins = await Promise.all(allTwinIds.map(id => this.twinManager.getCachedTwins(id)));
+                console.log(`connectPhyHub(): allTwins ${allTwins.length}`);
+                await (0, instances_1.initInstances)(this.twinManager, allTwins);
+                await (0, methods_1.initMethods)(hubDevice);
+            }
+        });
+        await this.initializeCachedInstances(this.twinManager);
+        hubDevice.setTwinUpdateHandler(async (twin) => {
+            this.logger.info('connectPhyHub() on setTwinUpdateHandler(): Twin update received, updating instance...');
+            await this.twinManager.cacheHubTwin(twin);
+            if (twin.type === 'Device' && twin.properties?.desired?.timezone) {
+                try {
+                    const region = JSON.parse(fs_1.default.readFileSync(regionFilePath, 'utf8'));
+                    const proxyConfig = {
+                        region,
+                        port: 443,
+                        username: twin.deviceId,
+                        password: 'device',
+                        timezone: twin.properties.desired.timezone
+                    };
+                    this.logger.info('connectPhyHub(): Updating environment with:', proxyConfig);
+                    await (0, environment_1.setTZinEnvFile)(twin.properties.desired.timezone);
+                }
+                catch (error) {
+                    this.logger.error('connectPhyHub(): Failed to update environment with new timezone:', error);
+                }
+            }
+            await (0, instances_1.updateInstances)(this.twinManager, [
+                (await this.twinManager.getCachedTwins(twin.id)),
+            ]);
+        });
+        hubDevice.setTwinRemoveHandler(async (twin) => {
+            this.logger.info('connectPhyHub() on setTwinRemoveHandler(): Twin remove event received, removing instance twin...', twin);
+            await (0, instances_1.removeInstances)(this.twinManager, [twin]);
+        });
+        hubDevice.on('setCACertificate', async (payload, callback) => {
+            try {
+                const config = payload.data;
+                const result = await (0, ca_1.configureCACertificate)(config);
+                callback && callback(null, { status: result ? 'success' : 'error' });
+            }
+            catch (error) {
+                console.error('Error configuring CA certificate:', error);
+                callback && callback(error);
+            }
+        });
+        hubDevice.on('twinMessage', async (payload, callback) => {
+            await edge_hub_1.EdgeHubServer.getInstance().handleTwinMessage(payload, callback, true);
+        });
+        hubDevice.on('twinUpdated', async (payload, callback) => {
+            this.logger.info('connectPhyHub() on twinUpdated(): Twin update received, forwarding to edge-hub...');
+            await edge_hub_1.EdgeHubServer.getInstance().handleTwinUpdated(payload, callback, true);
+        });
+    }
+    migrateDeviceCredentialsToPhyOS() {
+        this.logger.info('migrateDeviceCredentialsToPhyOS(): Checking if legacy GridOS/PhyOS device');
+        try {
+            if (fs_1.default.existsSync(customProxyFilePath)) {
+                this.logger.info('migrateDeviceCredentialsToPhyOS(): Custom proxy file found, migrating proxy settings');
+                (0, child_process_1.execSync)('sudo mv /data/environment-custom-proxy /data/settings/environment');
+                (0, child_process_1.execSync)('sudo rm /etc/environment');
+                (0, child_process_1.execSync)('sudo ln -sf /data/settings/environment /etc/environment');
+                process.exit(0);
+            }
+            if (fs_1.default.existsSync(credentialsMigrationPath)) {
+                const data = fs_1.default.readFileSync(credentialsMigrationPath, 'utf-8');
+                const credentials = JSON.parse(data);
+                if (credentials.deviceId && credentials.accessKey && credentials.deviceSerial && credentials.region) {
+                    fs_1.default.unlinkSync(credentialsMigrationPath);
+                    return credentials;
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error(`migrateDeviceCredentialsToPhyOS(): Error reading file: ${error}`);
+        }
+        return undefined;
+    }
+    async getPhyHub() {
+        this.logger.info('getPhyHub(): Attempting to connect to PhyHub');
+        let credentials = undefined;
+        this.logger.info('getPhyHub(): Checking if migrating legacy device');
+        credentials = this.migrateDeviceCredentialsToPhyOS();
+        if (credentials && credentials.deviceId && credentials.accessKey && credentials.deviceSerial) {
+            this.logger.info('getPhyHub(): Migrating credentials for legacy device');
+        }
+        else {
+            this.logger.info('getPhyHub(): Not a legacy device, attempting to provision device');
+        }
+        const connectionStatus = await connectToPhyHub(this.GRID_ENV, this.PHYOS_VERSION, credentials);
+        if (!connectionStatus) {
+            this.logger.warn('getPhyHub(): No connection status received from PhyHub');
+            return;
+        }
+        this.logger.info('getPhyHub(): PhyHub connection details', { connectionStatus });
+        const { phyHub: phyHubInstance } = connectionStatus;
+        if (phyHubInstance) {
+            console.log('found phyHubInstance', { phyHubInstance });
+            if (this.phyHubInterval) {
+                clearInterval(this.phyHubInterval);
+            }
+            phyHubInstance.setScheduler(this.scheduler);
+            await this.connectPhyHub(phyHubInstance);
+        }
+    }
+    async start() {
+        try {
+            await this.initialize();
+            this.logger.info('start(): Verifying scheduler initialization');
+            if (!this.scheduler) {
+                this.scheduler = new scheduler_service_1.Scheduler();
+                this.logger.info('start(): Created new scheduler instance');
+            }
+            (0, edge_hub_1.startEdgeHub)().catch(error => {
+                this.logger.error('start(): Error starting edgeHub messaging', error);
+            });
+            this.phyHubInterval = setInterval(() => this.getPhyHub(), 30000);
+            await this.getPhyHub();
+        }
+        catch (error) {
+            this.logger.error('start(): Initialization failed:', error);
+            process.exit(1);
+        }
+    }
+    stop() {
+        if (this.phyHubInterval) {
+            clearInterval(this.phyHubInterval);
+            this.phyHubInterval = null;
+        }
+    }
+}
+exports.default = DevicePhyos;
+const initializeDevicePhyos = async () => {
+    try {
+        const devicePhyos = new DevicePhyos();
+        await devicePhyos.start();
+    }
+    catch (error) {
+        console.error('initializeDevicePhyos(): Failed to initialize device phyos', error);
+        process.exit(1);
+    }
+};
+const HEARTBEAT_PATH = '/tmp/phydevice-heartbeat';
+setInterval(() => {
+    fs_1.default.writeFileSync(HEARTBEAT_PATH, new Date().toISOString());
+}, 1000);
+process.on('SIGTERM', async () => {
+    console.log('Received SIGTERM, exiting');
+    try {
+        fs_1.default.unlinkSync(HEARTBEAT_PATH);
+    }
+    catch (e) {
+        console.error(e.toString());
+    }
+    process.exit(1);
+});
+initializeDevicePhyos();
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,19 +1,12 @@
 {
   "name": "@phystack/device-phyos",
-  "version": "4.5.64-dev",
-  "main": "index.js",
+  "version": "5.0.1",
+  "description": "PhyOS device agent",
+  "main": "dist/index.js",
+  "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "rimraf dist && tsc",
-    "build:binary": "VERSION=$(node -p \"require('./package.json').version\") && npx bun build --compile --minify --define \"__PKG_VERSION__=\\\"$VERSION\\\"\" ./src/index.ts --outfile phydevice",
-    "start": "yarn build && node --inspect --enable-source-maps dist/index",
-    "dev": "NODE_ENV=development npx nodemon",
-    "format": "prettier --write \"src/**/*.{ts,js,json,md}\"",
-    "format:check": "prettier --check \"src/**/*.{ts,js,json,md}\""
-  },
   "bin": {
     "phydevice": "./bin/index.js"
   },
@@ -23,14 +16,18 @@
   "engines": {
     "node": ">=20.0.0"
   },
-  "author": "PhyStack.com",
-  "license": "MIT",
-  "description": "",
-  "optionalDependencies": {
-    "@phystack/phydevice-darwin-arm64": "4.5.64-dev",
-    "@phystack/phydevice-darwin-x64": "4.5.64-dev",
-    "@phystack/phydevice-linux-arm64": "4.5.64-dev",
-    "@phystack/phydevice-linux-x64": "4.5.64-dev"
+  "scripts": {
+    "build": "tsc",
+    "build:binary": "VERSION=$(bun -e \"console.log(require('./package.json').version)\") && bun build --compile --minify --external cpu-features --define \"__PKG_VERSION__=\\\"$VERSION\\\"\" ./src/index.ts --outfile phydevice",
+    "dev": "bun --watch src/index.ts",
+    "lint": "tsc --noEmit",
+    "test:ci": "echo 'no tests' && exit 0",
+    "format": "prettier --write \"src/**/*.{ts,js,json,md}\""
   },
-  "gitHead": "e29cb3adee4f709ac3f5f2b3de62fe7f14a7a7b3"
+  "optionalDependencies": {
+    "@phystack/phydevice-darwin-arm64": "5.0.1",
+    "@phystack/phydevice-darwin-x64": "5.0.1",
+    "@phystack/phydevice-linux-arm64": "5.0.1",
+    "@phystack/phydevice-linux-x64": "5.0.1"
+  }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 PhyStack.com
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,71 +0,0 @@
-# phydevice
-
-PhyStack device agent for PhyOS. Compiled as a standalone Bun binary.
-
-## Installation
-
-### Via npm (recommended)
-
-```bash
-npm install -g @phystack/device-phyos
-```
-
-npm automatically downloads the correct binary for your platform.
-
-### Direct binary download (no npm required)
-
-```bash
-VERSION=4.5.62-dev  # replace with desired version
-
-# Linux ARM64
-sudo curl -sL "https://registry.npmjs.org/@phystack/phydevice-linux-arm64/-/phydevice-linux-arm64-${VERSION}.tgz" | sudo tar xz --strip-components=2 -C /usr/bin package/bin/phydevice
-
-# Linux x86_64
-sudo curl -sL "https://registry.npmjs.org/@phystack/phydevice-linux-x64/-/phydevice-linux-x64-${VERSION}.tgz" | sudo tar xz --strip-components=2 -C /usr/bin package/bin/phydevice
-
-# macOS Apple Silicon
-curl -sL "https://registry.npmjs.org/@phystack/phydevice-darwin-arm64/-/phydevice-darwin-arm64-${VERSION}.tgz" | tar xz --strip-components=2 -C /usr/local/bin package/bin/phydevice
-
-# macOS Intel
-curl -sL "https://registry.npmjs.org/@phystack/phydevice-darwin-x64/-/phydevice-darwin-x64-${VERSION}.tgz" | tar xz --strip-components=2 -C /usr/local/bin package/bin/phydevice
-```
-
-To check available versions:
-
-```bash
-npm view @phystack/phydevice-linux-arm64 versions --json
-```
-
-## Supported platforms
-
-| Platform | Architecture | npm package |
-|----------|-------------|-------------|
-| Linux    | ARM64       | `@phystack/phydevice-linux-arm64` |
-| Linux    | x86_64      | `@phystack/phydevice-linux-x64` |
-| macOS    | ARM64       | `@phystack/phydevice-darwin-arm64` |
-| macOS    | x86_64      | `@phystack/phydevice-darwin-x64` |
-
-## Building from source
-
-```bash
-yarn build:binary     # compile for current platform
-```
-
-Or use the central build script for cross-compilation:
-
-```bash
-# from repo root
-yarn build:binaries              # current platform
-yarn build:binaries:cross        # all platforms
-```
-
-Output: `dist-binaries/<platform>/phydevice`
-
-## Local development
-
-Ensure the process can write to `/etc/phyos.env`. On macOS:
-
-```bash
-sudo sh -c 'echo LOCAL > /etc/phyos.env'
-sudo chmod 666 /etc/phyos.env
-```