@phystack/phyctl-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 = 'phyctl';
+const BINARY = "phyctl";
 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,618 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const inquirer_1 = __importDefault(require("inquirer"));
+const hub_client_1 = require("@phystack/hub-client");
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const readline_1 = __importDefault(require("readline"));
+const wifi_dialog_1 = require("./dialog/network/wifi.dialog");
+const lan_dialog_1 = require("./dialog/network/lan.dialog");
+const proxy_dialog_1 = require("./dialog/network/proxy.dialog");
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const local_1 = require("./commands/local");
+const program = new commander_1.Command();
+let phyClientInstance;
+let deviceStatus;
+let inMenu = false;
+setInterval(() => { }, 1000);
+function getVersion() {
+    if (typeof __PKG_VERSION__ !== 'undefined') {
+        return __PKG_VERSION__;
+    }
+    const pkgPath = path_1.default.resolve(__dirname, '../package.json');
+    try {
+        const content = fs_1.default.readFileSync(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        return pkg.version || 'N/A';
+    }
+    catch (error) {
+        console.error('Failed to read version from package.json:', error);
+        return 'N/A';
+    }
+}
+async function getGlobalDNSServers() {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)('systemd-resolve --status', (error, stdout, _stderr) => {
+            if (error) {
+                return reject(error);
+            }
+            const lines = stdout.split('\n');
+            let fallbackLine = lines.find(line => line.trim().startsWith('Fallback DNS Servers:'));
+            let servers = [];
+            if (fallbackLine) {
+                fallbackLine = fallbackLine.replace('Fallback DNS Servers:', '').trim();
+                servers = fallbackLine.split(/\s+/).map(entry => entry.split('#')[0]).filter(entry => entry);
+            }
+            resolve(servers);
+        });
+    });
+}
+async function getGatewayForInterface(iface) {
+    return new Promise((resolve, _reject) => {
+        (0, child_process_1.exec)(`ip route show default dev ${iface}`, (error, stdout, _stderr) => {
+            if (error || !stdout) {
+                return resolve('N/A');
+            }
+            const match = stdout.match(/default via (\S+)/);
+            if (match) {
+                resolve(match[1]);
+            }
+            else {
+                resolve('N/A');
+            }
+        });
+    });
+}
+async function getDNSServersForInterface(iface) {
+    return new Promise((resolve) => {
+        (0, child_process_1.exec)('systemd-resolve --status', (error, stdout) => {
+            if (error || !stdout) {
+                return resolve([]);
+            }
+            const lines = stdout.split('\n');
+            let blockStarted = false;
+            let dnsServers = [];
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (line.startsWith('Link') && line.includes(`(${iface})`)) {
+                    blockStarted = true;
+                    continue;
+                }
+                if (blockStarted) {
+                    if (line.trim() === '' || line.startsWith('Link')) {
+                        break;
+                    }
+                    if (line.trim().startsWith('DNS Servers:')) {
+                        let serversLine = line.replace('DNS Servers:', '').trim();
+                        dnsServers = serversLine.split(/\s+/).map(entry => entry.split('#')[0]).filter(entry => entry);
+                    }
+                    else if (dnsServers.length && line.startsWith('      ')) {
+                        let additional = line.trim().split(/\s+/).map(entry => entry.split('#')[0]).filter(entry => entry);
+                        dnsServers = dnsServers.concat(additional);
+                    }
+                }
+            }
+            resolve(dnsServers);
+        });
+    });
+}
+async function main() {
+    program.version(getVersion());
+    const args = process.argv.slice(2);
+    await connectToPhyClientAndUpdateStatus();
+    const phyClient = await (0, hub_client_1.connectPhyClient)({ moduleName: 'phyctl' });
+    program.addCommand((0, local_1.setupLocalCommands)(phyClient));
+    if (args.length > 0) {
+        await program.parseAsync(process.argv);
+        return process.exit(0);
+    }
+    watchDeviceStatus();
+    handleUserInput();
+}
+async function connectToPhyClientAndUpdateStatus() {
+    console.log('Connecting to PhyClient...');
+    phyClientInstance = await (0, hub_client_1.connectPhyClient)({ instanceId: 'phyctl' });
+    if (phyClientInstance) {
+        try {
+            while (true) {
+                if (phyClientInstance.isConnected()) {
+                    deviceStatus = await phyClientInstance.getDeviceStatus();
+                    break;
+                }
+                console.error('Socket not connected to PhyClient');
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+            }
+        }
+        catch (error) {
+            console.error('Failed to get status from PhyClient:', error);
+        }
+    }
+    else {
+        console.error('Failed to connect to PhyClient');
+    }
+}
+function watchDeviceStatus() {
+    setInterval(async () => {
+        if (!phyClientInstance || !phyClientInstance.isConnected() || inMenu) {
+            return;
+        }
+        try {
+            const newStatus = await phyClientInstance.getDeviceStatus();
+            if (JSON.stringify(newStatus) !== JSON.stringify(deviceStatus)) {
+                deviceStatus = newStatus;
+                displayInfo();
+            }
+        }
+        catch (error) {
+            console.error('Failed to refresh status from PhyClient:', error);
+        }
+    }, 5000);
+    displayInfo();
+}
+function displayInfo() {
+    console.clear();
+    console.log('=====================================');
+    console.log('|     PhyOS Device Configuration    |');
+    console.log('=====================================');
+    if (!phyClientInstance || !phyClientInstance.isConnected()) {
+        console.log('PhyDevice is not running or disconnected');
+        console.log('=====================================');
+        console.log('\nPress ENTER to open the menu (or press Ctrl+C to exit):');
+        return;
+    }
+    const { deviceId, deviceSerial, gridEnv, osVersion, socketConnected, socketAuthenticated, provisioningCode, displayName, } = deviceStatus || {};
+    if (socketConnected) {
+        console.log(`Device Name: ${displayName || 'N/A'}`);
+    }
+    console.log(`Device Serial: ${deviceSerial || 'N/A'}`);
+    console.log(`OS Version: ${osVersion || 'N/A'}`);
+    console.log(`PhyCTL Version: ${getVersion() || 'N/A'}`);
+    console.log(`Grid Environment: ${gridEnv || 'N/A'}`);
+    console.log(`Socket Connected: ${socketConnected || 'false'}`);
+    if (socketConnected) {
+        console.log(`Device ID: ${deviceId || 'N/A'}`);
+        console.log(`Socket Authenticated: ${socketAuthenticated || 'false'}`);
+    }
+    else {
+        console.log(`Provisioning Code: ${deviceId ? 'PROVISIONED' : provisioningCode || 'N/A'}`);
+    }
+    console.log('=====================================');
+    console.log('\nPress ENTER to open the menu (or press Ctrl+C to exit):');
+}
+async function showMenu() {
+    const menuChoices = [
+        { name: 'Shell (Open shell)', value: 'shell' },
+        { name: 'Networking (setup network)', value: 'network' },
+        { name: 'Exit menu', value: 'exit' },
+        new inquirer_1.default.Separator(),
+        { name: 'Advanced', value: 'advanced' },
+        { name: 'Reboot', value: 'reboot' },
+        new inquirer_1.default.Separator(),
+    ];
+    while (true) {
+        if (!phyClientInstance || !phyClientInstance.isConnected()) {
+            console.log('PhyDevice is not running or disconnected');
+            break;
+        }
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'menu',
+                message: 'Select an option:',
+                choices: [...menuChoices],
+            },
+        ]);
+        switch (answers.menu) {
+            case 'network':
+                await setupNetwork();
+                break;
+            case 'shell':
+                await openShell();
+                break;
+            case 'advanced':
+                await showAdvancedMenu();
+                break;
+            case 'reboot':
+                await rebootDevice();
+                break;
+            case 'exit':
+                displayInfo();
+                return;
+        }
+    }
+}
+async function setupNetwork() {
+    while (true) {
+        if (!phyClientInstance || !phyClientInstance.isConnected()) {
+            console.log('PhyDevice is not running or disconnected');
+            break;
+        }
+        const networkAnswers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'network',
+                message: 'Select network type:',
+                choices: [
+                    { name: 'Ethernet', value: 'ethernet' },
+                    { name: 'WiFi', value: 'wifi' },
+                    { name: 'View current network configuration', value: 'viewConfig' },
+                    new inquirer_1.default.Separator(),
+                    { name: 'Go back', value: 'back' },
+                    new inquirer_1.default.Separator(),
+                ],
+            },
+        ]);
+        if (networkAnswers.network === 'back') {
+            break;
+        }
+        switch (networkAnswers.network) {
+            case 'wifi':
+                await (0, wifi_dialog_1.setupWifi)(phyClientInstance);
+                break;
+            case 'ethernet':
+                await (0, lan_dialog_1.setupEthernet)(phyClientInstance);
+                break;
+            case 'viewConfig':
+                await viewNetworkConfiguration(phyClientInstance);
+                break;
+        }
+    }
+}
+async function showAdvancedMenu() {
+    const advancedChoices = [
+        { name: 'Change Phystack environment', value: 'changeEnv' },
+        { name: 'Enable Developer Mode', value: 'enableDevMode' },
+        { name: 'CA (add certificate authority trust)', value: 'ca' },
+        { name: 'Set Custom Proxy', value: 'proxy' },
+        new inquirer_1.default.Separator(),
+        { name: 'Go back', value: 'back' },
+    ];
+    while (true) {
+        if (!phyClientInstance || !phyClientInstance.isConnected()) {
+            console.log('PhyDevice is not running or disconnected');
+            break;
+        }
+        const advancedAnswers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'advanced',
+                message: 'Select an advanced option:',
+                choices: [...advancedChoices],
+            },
+        ]);
+        if (advancedAnswers.advanced === 'back') {
+            break;
+        }
+        switch (advancedAnswers.advanced) {
+            case 'proxy':
+                await (0, proxy_dialog_1.setupProxy)(phyClientInstance);
+                break;
+            case 'ca':
+                await addCertificateAuthority();
+                break;
+            case 'enableDevMode':
+                await enableDeveloperMode();
+                break;
+            case 'changeEnv':
+                await changePhygridEnvironment();
+                break;
+        }
+    }
+}
+async function changePhygridEnvironment() {
+    const envChoices = [
+        { name: 'LOCAL', value: 'LOCAL' },
+        { name: 'DEV', value: 'DEV' },
+        { name: 'QA', value: 'QA' },
+        { name: 'PROD', value: 'PROD' },
+        new inquirer_1.default.Separator(),
+        { name: 'Go back', value: 'back' },
+    ];
+    const envAnswers = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'env',
+            message: 'Select Phystack environment:',
+            choices: envChoices,
+        },
+    ]);
+    if (envAnswers.env === 'back') {
+        return;
+    }
+    const confirmAnswer = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `WARNING: Changing the environment to ${envAnswers.env} will:\n` +
+                '1. Delete all device settings\n' +
+                '2. Require device reprovisioning\n' +
+                '3. Restart the device services\n' +
+                '\nAre you sure you want to continue?',
+            default: false,
+        },
+    ]);
+    if (!confirmAnswer.confirm) {
+        console.log('Environment change cancelled');
+        return;
+    }
+    console.log(`Setting Phystack environment to ${envAnswers.env}...`);
+    await new Promise((resolve) => {
+        phyClientInstance.emit('setEnv', {
+            data: {
+                env: envAnswers.env
+            }
+        }, (response) => {
+            if (response.status === 'success') {
+                console.log(`Phystack environment set to ${envAnswers.env}`);
+                console.log('Device will now unprovision...');
+                setTimeout(() => process.exit(0), 1000);
+            }
+            else {
+                console.error('Failed to set environment:', response.message);
+            }
+            resolve();
+        });
+    });
+}
+async function enableDeveloperMode() {
+    try {
+        console.log(chalk_1.default.yellow('Enabling developer mode...'));
+        const authMethod = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'method',
+                message: 'Choose authentication method:',
+                choices: [
+                    { name: 'Set password', value: 'password' },
+                    { name: 'Provide SSH public key', value: 'ssh' },
+                    { name: 'Use default password (123)', value: 'default' },
+                ],
+            },
+        ]);
+        let payload = {};
+        if (authMethod.method === 'password') {
+            const passwordPrompt = await inquirer_1.default.prompt([
+                {
+                    type: 'password',
+                    name: 'password',
+                    message: 'Enter new password for dev user:',
+                    mask: '*',
+                    validate: (input) => {
+                        if (input.length < 6) {
+                            return 'Password must be at least 6 characters long';
+                        }
+                        return true;
+                    },
+                },
+                {
+                    type: 'password',
+                    name: 'confirmPassword',
+                    message: 'Confirm password:',
+                    mask: '*',
+                    validate: (input, answers) => {
+                        if (input !== answers.password) {
+                            return 'Passwords do not match';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            payload = {
+                authType: 'password',
+                password: passwordPrompt.password,
+            };
+        }
+        else if (authMethod.method === 'ssh') {
+            const sshPrompt = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'sshKey',
+                    message: 'Enter your SSH public key:',
+                    validate: (input) => {
+                        if (!input.trim().startsWith('ssh-')) {
+                            return 'Invalid SSH public key format';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            payload = {
+                authType: 'ssh',
+                sshKey: sshPrompt.sshKey,
+            };
+        }
+        else {
+            payload = {
+                authType: 'password',
+                password: '123',
+            };
+        }
+        await phyClientInstance.emit('devdevice', payload);
+        console.log(chalk_1.default.green('Developer mode enabled successfully.'));
+        if (authMethod.method === 'default') {
+            console.log(chalk_1.default.yellow('\nDev user credentials:'));
+            console.log(chalk_1.default.yellow('Username: dev'));
+            console.log(chalk_1.default.yellow('Password: 123'));
+        }
+        else if (authMethod.method === 'password') {
+            console.log(chalk_1.default.yellow('\nDev user credentials:'));
+            console.log(chalk_1.default.yellow('Username: dev'));
+            console.log(chalk_1.default.yellow('Password: <your chosen password>'));
+        }
+        else {
+            console.log(chalk_1.default.yellow('\nSSH key has been configured for the dev user'));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to enable developer mode:'), error);
+    }
+}
+async function addCertificateAuthority() {
+    const urlAnswer = await inquirer_1.default.prompt({
+        type: 'input',
+        name: 'certUrl',
+        message: 'Enter URL of the CA certificate:',
+        validate: (input) => {
+            try {
+                new URL(input);
+                return true;
+            }
+            catch {
+                return 'Invalid URL';
+            }
+        },
+    });
+    const proxyAnswer = await inquirer_1.default.prompt({
+        type: 'confirm',
+        name: 'useProxy',
+        message: 'Do you need to use a proxy to download the certificate?',
+        default: false,
+    });
+    let proxyDetails = {};
+    if (proxyAnswer.useProxy) {
+        const proxyPrompts = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'hostname',
+                message: 'Enter Proxy Hostname for Certificate Download:',
+                validate: (input) => input.trim() !== '' || 'Hostname cannot be empty',
+            },
+            {
+                type: 'input',
+                name: 'port',
+                message: 'Enter Proxy Port for Certificate Download:',
+                validate: (input) => !isNaN(Number(input)) && input.trim() !== '' || 'Port must be a valid number',
+            },
+            {
+                type: 'input',
+                name: 'username',
+                message: 'Enter Proxy Username for Certificate Download (optional):',
+            },
+            {
+                type: 'password',
+                name: 'password',
+                message: 'Enter Proxy Password for Certificate Download (if username provided):',
+                mask: '*',
+                when: (answers) => answers.username && answers.username.trim() !== '',
+            }
+        ]);
+        proxyDetails = {
+            hostname: proxyPrompts.hostname,
+            port: Number(proxyPrompts.port),
+            username: proxyPrompts.username,
+            password: proxyPrompts.password,
+        };
+    }
+    phyClientInstance.emit('setCACertificate', {
+        data: {
+            certUrl: urlAnswer.certUrl,
+            proxy: proxyDetails,
+        },
+    }, () => {
+        console.log('Certificate installation completed.');
+    });
+}
+async function openShell() {
+    console.log('Opening shell...');
+    const shell = (0, child_process_1.spawn)('bash', ['-c', 'sudo su -'], {
+        stdio: 'inherit',
+    });
+    await new Promise((resolve) => {
+        shell.on('exit', (code) => {
+            console.log(`Shell exited with code ${code}`);
+            resolve();
+        });
+    });
+}
+async function rebootDevice() {
+    const confirmAnswers = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'confirm',
+            message: 'Type "yes" to confirm reboot:',
+        },
+    ]);
+    if (confirmAnswers.confirm.toLowerCase() === 'yes') {
+        console.log('Rebooting device...');
+        phyClientInstance.emit('reboot', async () => {
+            console.log('Reboot command sent');
+        });
+    }
+    else {
+        console.log('Reboot cancelled.');
+    }
+}
+function handleUserInput() {
+    function setupReadline() {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.on('line', async () => {
+            if (!inMenu) {
+                inMenu = true;
+                console.clear();
+                await showMenu();
+                inMenu = false;
+                displayInfo();
+                rl.close();
+                setupReadline();
+            }
+        });
+    }
+    setupReadline();
+}
+async function viewNetworkConfiguration(phyClientInstance) {
+    if (!phyClientInstance || !phyClientInstance.isConnected()) {
+        console.log('PhyDevice is not running or disconnected');
+        return;
+    }
+    const deviceNetworksResponse = await phyClientInstance.getDeviceNetworks();
+    const networks = deviceNetworksResponse.data;
+    console.clear();
+    console.log('=== Current Network Configuration ===');
+    if (networks.networkInterfaces && networks.networkInterfaces.length > 0) {
+        for (const ni of networks.networkInterfaces) {
+            const gateway = await getGatewayForInterface(ni.iface);
+            const dnsServers = await getDNSServersForInterface(ni.iface);
+            console.log(`Interface: ${ni.ifaceName} (${ni.iface})`);
+            console.log(`  Mode: ${ni.dhcp ? 'DHCP' : 'Static'}`);
+            console.log(`  IP Address: ${ni.ip4 || 'N/A'}`);
+            console.log(`  Netmask: ${ni.ip4subnet || 'N/A'}`);
+            console.log(`  Gateway: ${gateway}`);
+            console.log(`  Default Route: ${ni.default ? 'Yes' : 'No'}`);
+            console.log(`  DNS Server(s): ${dnsServers.length > 0 ? dnsServers.join(', ') : 'N/A'}`);
+            console.log('');
+        }
+    }
+    else {
+        console.log('No network interfaces found.');
+    }
+    const defaultInterface = networks.networkInterfaces.find((ni) => ni.default);
+    if (defaultInterface) {
+        console.log('Global Default Route:');
+        console.log(`  Interface: ${defaultInterface.ifaceName} (${defaultInterface.iface})`);
+        console.log(`  IP Address: ${defaultInterface.ip4 || 'N/A'}`);
+    }
+    else {
+        console.log('No default route found.');
+    }
+    try {
+        const globalDNS = await getGlobalDNSServers();
+        console.log(`Global DNS Server(s): ${globalDNS.length > 0 ? globalDNS.join(', ') : 'N/A'}`);
+    }
+    catch (error) {
+        console.log('Global DNS Server: N/A');
+    }
+    console.log('=====================================');
+    await inquirer_1.default.prompt([{ type: 'input', name: 'continue', message: 'Press ENTER to continue' }]);
+}
+main().catch((error) => {
+    console.error('An error occurred:', error);
+});
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,39 +1,32 @@
 {
   "name": "@phystack/phyctl-phyos",
-  "version": "4.5.64-dev",
-  "exports": "./index.js",
-  "main": "index.js",
+  "version": "5.0.1",
+  "description": "PhyOS device management CLI",
+  "main": "dist/index.js",
+  "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "compilerOptions": {
-    "module": "ESNext",
-    "moduleResolution": "node"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "rimraf dist && tsc",
-    "build:binary": "bash build-binary.sh",
-    "start": "yarn build && node --inspect --enable-source-maps dist/index",
-    "dev": "NODE_ENV=development yarn start"
-  },
   "bin": {
     "phyctl": "./bin/index.js"
   },
-  "engines": {
-    "node": ">=20.0.0"
-  },
   "files": [
     "bin/**/*"
   ],
-  "author": "PhyStack.com",
-  "license": "MIT",
-  "description": "",
-  "optionalDependencies": {
-    "@phystack/phyctl-darwin-arm64": "4.5.64-dev",
-    "@phystack/phyctl-darwin-x64": "4.5.64-dev",
-    "@phystack/phyctl-linux-arm64": "4.5.64-dev",
-    "@phystack/phyctl-linux-x64": "4.5.64-dev"
+  "engines": {
+    "node": ">=20.0.0"
   },
-  "gitHead": "e29cb3adee4f709ac3f5f2b3de62fe7f14a7a7b3"
+  "scripts": {
+    "build": "tsc",
+    "build:binary": "bash build-binary.sh",
+    "dev": "bun --watch src/index.ts",
+    "lint": "tsc --noEmit",
+    "test:ci": "echo 'no tests' && exit 0"
+  },
+  "optionalDependencies": {
+    "@phystack/phyctl-darwin-arm64": "5.0.1",
+    "@phystack/phyctl-darwin-x64": "5.0.1",
+    "@phystack/phyctl-linux-arm64": "5.0.1",
+    "@phystack/phyctl-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,62 +0,0 @@
-# phyctl
-
-PhyStack control plane CLI for managing PhyOS devices. Compiled as a standalone Bun binary.
-
-## Installation
-
-### Via npm (recommended)
-
-```bash
-npm install -g @phystack/phyctl-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/phyctl-linux-arm64/-/phyctl-linux-arm64-${VERSION}.tgz" | sudo tar xz --strip-components=2 -C /usr/bin package/bin/phyctl
-
-# Linux x86_64
-sudo curl -sL "https://registry.npmjs.org/@phystack/phyctl-linux-x64/-/phyctl-linux-x64-${VERSION}.tgz" | sudo tar xz --strip-components=2 -C /usr/bin package/bin/phyctl
-
-# macOS Apple Silicon
-curl -sL "https://registry.npmjs.org/@phystack/phyctl-darwin-arm64/-/phyctl-darwin-arm64-${VERSION}.tgz" | tar xz --strip-components=2 -C /usr/local/bin package/bin/phyctl
-
-# macOS Intel
-curl -sL "https://registry.npmjs.org/@phystack/phyctl-darwin-x64/-/phyctl-darwin-x64-${VERSION}.tgz" | tar xz --strip-components=2 -C /usr/local/bin package/bin/phyctl
-```
-
-To check available versions:
-
-```bash
-npm view @phystack/phyctl-linux-arm64 versions --json
-```
-
-## Supported platforms
-
-| Platform | Architecture | npm package |
-|----------|-------------|-------------|
-| Linux    | ARM64       | `@phystack/phyctl-linux-arm64` |
-| Linux    | x86_64      | `@phystack/phyctl-linux-x64` |
-| macOS    | ARM64       | `@phystack/phyctl-darwin-arm64` |
-| macOS    | x86_64      | `@phystack/phyctl-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>/phyctl`