pywebexec 0.1.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

pywebexec/pywebexec.py

@@ -12,24 +12,99 @@ import string
 from datetime import datetime
 import shlex
 from gunicorn.app.base import Application
+from datetime import timezone, timedelta
+import ipaddress
+from socket import gethostname, gethostbyname_ex
 
 app = Flask(__name__)
 auth = HTTPBasicAuth()
 
-# Directory to store the script status and output
-SCRIPT_STATUS_DIR = '.web_status'
+# Directory to store the command status and output
+COMMAND_STATUS_DIR = '.web_status'
 CONFDIR = os.path.expanduser("~/")
 if os.path.isdir(f"{CONFDIR}/.config"):
     CONFDIR += '/.config'
 CONFDIR += "/.pywebexec"
 
-if not os.path.exists(SCRIPT_STATUS_DIR):
-    os.makedirs(SCRIPT_STATUS_DIR)
+if not os.path.exists(COMMAND_STATUS_DIR):
+    os.makedirs(COMMAND_STATUS_DIR)
 
 def generate_random_password(length=12):
     characters = string.ascii_letters + string.digits + string.punctuation
     return ''.join(random.choice(characters) for i in range(length))
 
+
+def resolve_hostname(host):
+    """try get fqdn from DNS"""
+    try:
+        return gethostbyname_ex(host)[0]
+    except OSError:
+        return host
+
+
+def generate_selfsigned_cert(hostname, ip_addresses=None, key=None):
+    """Generates self signed certificate for a hostname, and optional IP addresses.
+    from: https://gist.github.com/bloodearnest/9017111a313777b9cce5
+    """
+    from cryptography import x509
+    from cryptography.x509.oid import NameOID
+    from cryptography.hazmat.primitives import hashes
+    from cryptography.hazmat.backends import default_backend
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.hazmat.primitives.asymmetric import rsa
+    
+    # Generate our key
+    if key is None:
+        key = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=2048,
+            backend=default_backend(),
+        )
+    
+    name = x509.Name([
+        x509.NameAttribute(NameOID.COMMON_NAME, hostname)
+    ])
+ 
+    # best practice seem to be to include the hostname in the SAN, which *SHOULD* mean COMMON_NAME is ignored.    
+    alt_names = [x509.DNSName(hostname)]
+    alt_names.append(x509.DNSName("localhost"))
+    
+    # allow addressing by IP, for when you don't have real DNS (common in most testing scenarios 
+    if ip_addresses:
+        for addr in ip_addresses:
+            # openssl wants DNSnames for ips...
+            alt_names.append(x509.DNSName(addr))
+            # ... whereas golang's crypto/tls is stricter, and needs IPAddresses
+            # note: older versions of cryptography do not understand ip_address objects
+            alt_names.append(x509.IPAddress(ipaddress.ip_address(addr)))
+    san = x509.SubjectAlternativeName(alt_names)
+    
+    # path_len=0 means this cert can only sign itself, not other certs.
+    basic_contraints = x509.BasicConstraints(ca=True, path_length=0)
+    now = datetime.now(timezone.utc)
+    cert = (
+        x509.CertificateBuilder()
+        .subject_name(name)
+        .issuer_name(name)
+        .public_key(key.public_key())
+        .serial_number(1000)
+        .not_valid_before(now)
+        .not_valid_after(now + timedelta(days=10*365))
+        .add_extension(basic_contraints, False)
+        .add_extension(san, False)
+        .sign(key, hashes.SHA256(), default_backend())
+    )
+    cert_pem = cert.public_bytes(encoding=serialization.Encoding.PEM)
+    key_pem = key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.TraditionalOpenSSL,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+
+    return cert_pem, key_pem
+
+
+
 class StandaloneApplication(Application):
 
     def __init__(self, app, options=None):
@@ -110,7 +185,7 @@ def daemon_d(action, pidfilepath, hostname=None, args=None):
 
 def parseargs():
     global app, args
-    parser = argparse.ArgumentParser(description='Run the script execution server.')
+    parser = argparse.ArgumentParser(description='Run the command execution server.')
     parser.add_argument('--user', help='Username for basic auth')
     parser.add_argument('--password', help='Password for basic auth')
     parser.add_argument(
@@ -126,11 +201,12 @@ def parseargs():
         "-t",
         "--title",
         type=str,
-        default="FileBrowser",
+        default="pywebexec",
         help="Web html title",
     )
     parser.add_argument("-c", "--cert", type=str, help="Path to https certificate")
     parser.add_argument("-k", "--key", type=str, help="Path to https certificate key")
+    parser.add_argument("-g", "--gencert", action="store_true", help="https server self signed cert")
     parser.add_argument("action", nargs="?", help="daemon action start/stop/restart/status", choices=["start","stop","restart","status"])
 
     args = parser.parse_args()
@@ -144,6 +220,17 @@ def parseargs():
         print(f"Error: {args.dir} not found", file=sys.stderr)
         sys.exit(1)
 
+    if args.gencert:
+        hostname = resolve_hostname(gethostname())
+        args.cert = args.cert or f"{CONFDIR}/pywebexec.crt"
+        args.key = args.key or f"{CONFDIR}/pywebexec.key"
+        if not os.path.exists(args.cert):
+            (cert, key) = generate_selfsigned_cert(hostname)
+            with open(args.cert, "wb") as fd:
+                fd.write(cert)
+            with open(args.key, "wb") as fd:
+                fd.write(key)
+
     if args.user:
         app.config['USER'] = args.user
         if args.password:
@@ -158,18 +245,18 @@ def parseargs():
 
 parseargs()
 
-def get_status_file_path(script_id):
-    return os.path.join(SCRIPT_STATUS_DIR, f'{script_id}.json')
+def get_status_file_path(command_id):
+    return os.path.join(COMMAND_STATUS_DIR, f'{command_id}.json')
 
-def get_output_file_path(script_id):
-    return os.path.join(SCRIPT_STATUS_DIR, f'{script_id}_output.txt')
+def get_output_file_path(command_id):
+    return os.path.join(COMMAND_STATUS_DIR, f'{command_id}_output.txt')
 
-def update_script_status(script_id, status, script_name=None, params=None, start_time=None, end_time=None, exit_code=None, pid=None):
-    status_file_path = get_status_file_path(script_id)
-    status_data = read_script_status(script_id) or {}
+def update_command_status(command_id, status, command=None, params=None, start_time=None, end_time=None, exit_code=None, pid=None):
+    status_file_path = get_status_file_path(command_id)
+    status_data = read_command_status(command_id) or {}
     status_data['status'] = status
-    if script_name is not None:
-        status_data['script_name'] = script_name
+    if command is not None:
+        status_data['command'] = command
     if params is not None:
         status_data['params'] = params
     if start_time is not None:
@@ -183,8 +270,8 @@ def update_script_status(script_id, status, script_name=None, params=None, start
     with open(status_file_path, 'w') as f:
         json.dump(status_data, f)
 
-def read_script_status(script_id):
-    status_file_path = get_status_file_path(script_id)
+def read_command_status(command_id):
+    status_file_path = get_status_file_path(command_id)
     if not os.path.exists(status_file_path):
         return None
     with open(status_file_path, 'r') as f:
@@ -193,31 +280,31 @@ def read_script_status(script_id):
 # Dictionary to store the process objects
 processes = {}
 
-def run_script(script_name, params, script_id):
+def run_command(command, params, command_id):
     start_time = datetime.now().isoformat()
-    update_script_status(script_id, 'running', script_name=script_name, params=params, start_time=start_time)
+    update_command_status(command_id, 'running', command=command, params=params, start_time=start_time)
     try:
-        output_file_path = get_output_file_path(script_id)
+        output_file_path = get_output_file_path(command_id)
         with open(output_file_path, 'w') as output_file:
-            # Run the script with parameters and redirect stdout and stderr to the file
-            process = subprocess.Popen([script_name] + params, stdout=output_file, stderr=output_file, bufsize=0) #text=True)
-            update_script_status(script_id, 'running', pid=process.pid)
-            processes[script_id] = process
+            # Run the command with parameters and redirect stdout and stderr to the file
+            process = subprocess.Popen([command] + params, stdout=output_file, stderr=output_file, bufsize=0) #text=True)
+            update_command_status(command_id, 'running', pid=process.pid)
+            processes[command_id] = process
             process.wait()
-            processes.pop(script_id, None)
+            processes.pop(command_id, None)
 
         end_time = datetime.now().isoformat()
         # Update the status based on the result
         if process.returncode == 0:
-            update_script_status(script_id, 'success', end_time=end_time, exit_code=process.returncode)
+            update_command_status(command_id, 'success', end_time=end_time, exit_code=process.returncode)
         elif process.returncode == -15:
-            update_script_status(script_id, 'aborted', end_time=end_time, exit_code=process.returncode)
+            update_command_status(command_id, 'aborted', end_time=end_time, exit_code=process.returncode)
         else:
-            update_script_status(script_id, 'failed', end_time=end_time, exit_code=process.returncode)
+            update_command_status(command_id, 'failed', end_time=end_time, exit_code=process.returncode)
     except Exception as e:
         end_time = datetime.now().isoformat()
-        update_script_status(script_id, 'failed', end_time=end_time, exit_code=1)
-        with open(get_output_file_path(script_id), 'a') as output_file:
+        update_command_status(command_id, 'failed', end_time=end_time, exit_code=1)
+        with open(get_output_file_path(command_id), 'a') as output_file:
             output_file.write(str(e))
 
 def auth_required(f):
@@ -225,20 +312,20 @@ def auth_required(f):
         return auth.login_required(f)
     return f
 
-@app.route('/run_script', methods=['POST'])
+@app.route('/run_command', methods=['POST'])
 @auth_required
-def run_script_endpoint():
+def run_command_endpoint():
     data = request.json
-    script_name = data.get('script_name')
+    command = data.get('command')
     params = data.get('params', [])
 
-    if not script_name:
-        return jsonify({'error': 'script_name is required'}), 400
+    if not command:
+        return jsonify({'error': 'command is required'}), 400
 
-    # Ensure the script is an executable in the current directory
-    script_path = os.path.join(".", os.path.basename(script_name))
-    if not os.path.isfile(script_path) or not os.access(script_path, os.X_OK):
-        return jsonify({'error': 'script_name must be an executable in the current directory'}), 400
+    # Ensure the command is an executable in the current directory
+    command_path = os.path.join(".", os.path.basename(command))
+    if not os.path.isfile(command_path) or not os.access(command_path, os.X_OK):
+        return jsonify({'error': 'command must be an executable in the current directory'}), 400
 
     # Split params using shell-like syntax
     try:
@@ -246,98 +333,98 @@ def run_script_endpoint():
     except ValueError as e:
         return jsonify({'error': str(e)}), 400
 
-    # Generate a unique script_id
-    script_id = str(uuid.uuid4())
+    # Generate a unique command_id
+    command_id = str(uuid.uuid4())
 
-    # Set the initial status to running and save script details
-    update_script_status(script_id, 'running', script_name, params)
+    # Set the initial status to running and save command details
+    update_command_status(command_id, 'running', command, params)
 
-    # Run the script in a separate thread
-    thread = threading.Thread(target=run_script, args=(script_path, params, script_id))
+    # Run the command in a separate thread
+    thread = threading.Thread(target=run_command, args=(command_path, params, command_id))
     thread.start()
 
-    return jsonify({'message': 'Script is running', 'script_id': script_id})
+    return jsonify({'message': 'Command is running', 'command_id': command_id})
 
-@app.route('/stop_script/<script_id>', methods=['POST'])
+@app.route('/stop_command/<command_id>', methods=['POST'])
 @auth_required
-def stop_script(script_id):
-    status = read_script_status(script_id)
+def stop_command(command_id):
+    status = read_command_status(command_id)
     if not status or 'pid' not in status:
-        return jsonify({'error': 'Invalid script_id or script not running'}), 400
+        return jsonify({'error': 'Invalid command_id or command not running'}), 400
 
     pid = status['pid']
     end_time = datetime.now().isoformat()
     try:
         os.kill(pid, 15)  # Send SIGTERM
-        update_script_status(script_id, 'aborted', end_time=end_time, exit_code=-15)
-        return jsonify({'message': 'Script aborted'})
+        update_command_status(command_id, 'aborted', end_time=end_time, exit_code=-15)
+        return jsonify({'message': 'Command aborted'})
     except Exception as e:
-        status_data = read_script_status(script_id) or {}
+        status_data = read_command_status(command_id) or {}
         status_data['status'] = 'failed'
         status_data['end_time'] = end_time
         status_data['exit_code'] = 1
-        with open(get_status_file_path(script_id), 'w') as f:
+        with open(get_status_file_path(command_id), 'w') as f:
             json.dump(status_data, f)
-        with open(get_output_file_path(script_id), 'a') as output_file:
+        with open(get_output_file_path(command_id), 'a') as output_file:
             output_file.write(str(e))
-        return jsonify({'error': 'Failed to terminate script'}), 500
+        return jsonify({'error': 'Failed to terminate command'}), 500
 
-@app.route('/script_status/<script_id>', methods=['GET'])
+@app.route('/command_status/<command_id>', methods=['GET'])
 @auth_required
-def get_script_status(script_id):
-    status = read_script_status(script_id)
+def get_command_status(command_id):
+    status = read_command_status(command_id)
     if not status:
-        return jsonify({'error': 'Invalid script_id'}), 404
+        return jsonify({'error': 'Invalid command_id'}), 404
 
-    output_file_path = get_output_file_path(script_id)
-    if os.path.exists(output_file_path):
-        with open(output_file_path, 'r') as output_file:
-            output = output_file.read()
-        status['output'] = output
+    # output_file_path = get_output_file_path(command_id)
+    # if os.path.exists(output_file_path):
+    #     with open(output_file_path, 'r') as output_file:
+    #         output = output_file.read()
+    #     status['output'] = output
 
     return jsonify(status)
 
 @app.route('/')
 @auth_required
 def index():
-    return render_template('index.html')
+    return render_template('index.html', title=args.title)
 
-@app.route('/scripts', methods=['GET'])
+@app.route('/commands', methods=['GET'])
 @auth_required
-def list_scripts():
-    scripts = []
-    for filename in os.listdir(SCRIPT_STATUS_DIR):
+def list_commands():
+    commands = []
+    for filename in os.listdir(COMMAND_STATUS_DIR):
         if filename.endswith('.json'):
-            script_id = filename[:-5]
-            status = read_script_status(script_id)
+            command_id = filename[:-5]
+            status = read_command_status(command_id)
             if status:
                 try:
                     params = shlex.join(status['params'])
                 except AttributeError:
                     params = " ".join([shlex.quote(p) if " " in p else p for p in status['params']])
-                command = status['script_name'] + ' ' + params
-                scripts.append({
-                    'script_id': script_id,
+                command = status['command'] + ' ' + params
+                commands.append({
+                    'command_id': command_id,
                     'status': status['status'],
                     'start_time': status.get('start_time', 'N/A'),
                     'end_time': status.get('end_time', 'N/A'),
                     'command': command,
                     'exit_code': status.get('exit_code', 'N/A')
                 })
-    # Sort scripts by start_time in descending order
-    scripts.sort(key=lambda x: x['start_time'], reverse=True)
-    return jsonify(scripts)
+    # Sort commands by start_time in descending order
+    commands.sort(key=lambda x: x['start_time'], reverse=True)
+    return jsonify(commands)
 
-@app.route('/script_output/<script_id>', methods=['GET'])
+@app.route('/command_output/<command_id>', methods=['GET'])
 @auth_required
-def get_script_output(script_id):
-    output_file_path = get_output_file_path(script_id)
+def get_command_output(command_id):
+    output_file_path = get_output_file_path(command_id)
     if os.path.exists(output_file_path):
         with open(output_file_path, 'r') as output_file:
             output = output_file.read()
-        status_data = read_script_status(script_id) or {}
+        status_data = read_command_status(command_id) or {}
         return jsonify({'output': output, 'status': status_data.get("status")})
-    return jsonify({'error': 'Invalid script_id'}), 404
+    return jsonify({'error': 'Invalid command_id'}), 404
 
 @app.route('/executables', methods=['GET'])
 @auth_required

pywebexec/templates/index.html

@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
     <meta charset="UTF-8">
-    <title>pywebexec</title>
+    <title>{{ title }}</title>
     <style>
         body { font-family: Arial, sans-serif; }
         .table-container { height: 380px; overflow-y: auto; position: relative; }
@@ -83,7 +83,7 @@
         input {
             width: 50%
         }
-        .currentscript {
+        .currentcommand {
             background-color: #eef;
         }
         .resizer {
@@ -103,11 +103,11 @@
     </style>
 </head>
 <body>
-    <h1>pywebexec</h1>
+    <h1>{{ title }}</h1>
     <form id="launchForm">
-        <label for="scriptName">Command:</label>
-        <select id="scriptName" name="scriptName"></select>
-        <label for="params">Params:</label>
+        <label for="commandName">Command</label>
+        <select id="commandName" name="commandName"></select>
+        <label for="params">Params</label>
         <input type="text" id="params" name="params">
         <button type="submit">Launch</button>
     </form>
@@ -115,7 +115,7 @@
         <table>
             <thead>
                 <tr>
-                    <th>Script ID</th>
+                    <th>Command ID</th>
                     <th>Status</th>
                     <th>Start Time</th>
                     <th>Duration</th>
@@ -124,7 +124,7 @@
                     <th>Actions</th>
                 </tr>
             </thead>
-            <tbody id="scripts"></tbody>
+            <tbody id="commands"></tbody>
         </table>
     </div>
     <div class="resizer-container">
@@ -133,69 +133,69 @@
     <div id="output" class="output"></div>
 
     <script>
-        let currentScriptId = null;
+        let currentCommandId = null;
         let outputInterval = null;
 
         document.getElementById('launchForm').addEventListener('submit', async (event) => {
             event.preventDefault();
-            const scriptName = document.getElementById('scriptName').value;
+            const commandName = document.getElementById('commandName').value;
             const params = document.getElementById('params').value.split(' ');
-            const response = await fetch('/run_script', {
+            const response = await fetch('/run_command', {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json'
                 },
-                body: JSON.stringify({ script_name: scriptName, params: params })
+                body: JSON.stringify({ command: commandName, params: params })
             });
             const data = await response.json();
-            fetchScripts();
-            viewOutput(data.script_id);
+            fetchCommands();
+            viewOutput(data.command_id);
         });
 
-        async function fetchScripts() {
-            const response = await fetch('/scripts');
-            const scripts = await response.json();
-            scripts.sort((a, b) => new Date(b.start_time) - new Date(a.start_time));
-            const scriptsTbody = document.getElementById('scripts');
-            scriptsTbody.innerHTML = '';
-            scripts.forEach(script => {
-                const scriptRow = document.createElement('tr');
-                scriptRow.className = script.script_id === currentScriptId ? 'currentscript' : '';
-                scriptRow.innerHTML = `
+        async function fetchCommands() {
+            const response = await fetch('/commands');
+            const commands = await response.json();
+            commands.sort((a, b) => new Date(b.start_time) - new Date(a.start_time));
+            const commandsTbody = document.getElementById('commands');
+            commandsTbody.innerHTML = '';
+            commands.forEach(command => {
+                const commandRow = document.createElement('tr');
+                commandRow.className = command.command_id === currentCommandId ? 'currentcommand' : '';
+                commandRow.innerHTML = `
                     <td class="monospace">
-                        <span class="copy_clip" onclick="copyToClipboard('${script.script_id}', this)">${script.script_id.slice(0, 8)}</span>
+                        <span class="copy_clip" onclick="copyToClipboard('${command.command_id}', this)">${command.command_id.slice(0, 8)}</span>
                     </td>
-                    <td><span class="status-icon status-${script.status}"></span>${script.status}</td>
-                    <td>${formatTime(script.start_time)}</td>
-                    <td>${script.status === 'running' ? formatDuration(script.start_time, new Date().toISOString()) : formatDuration(script.start_time, script.end_time)}</td>
-                    <td>${script.exit_code}</td>
-                    <td>${script.command.replace(/^\.\//, '')}</td>
+                    <td><span class="status-icon status-${command.status}"></span>${command.status}</td>
+                    <td>${formatTime(command.start_time)}</td>
+                    <td>${command.status === 'running' ? formatDuration(command.start_time, new Date().toISOString()) : formatDuration(command.start_time, command.end_time)}</td>
+                    <td>${command.exit_code}</td>
+                    <td>${command.command.replace(/^\.\//, '')}</td>
                     <td>
-                        <button onclick="viewOutput('${script.script_id}')">Log</button>
-                        <button onclick="relaunchScript('${script.script_id}')">Relaunch</button>
-                        ${script.status === 'running' ? `<button onclick="stopScript('${script.script_id}')">Stop</button>` : ''}
+                        <button onclick="viewOutput('${command.command_id}')">Log</button>
+                        <button onclick="relaunchCommand('${command.command_id}')">Relaunch</button>
+                        ${command.status === 'running' ? `<button onclick="stopCommand('${command.command_id}')">Stop</button>` : ''}
                     </td>
                 `;
-                scriptsTbody.appendChild(scriptRow);
+                commandsTbody.appendChild(commandRow);
             });
         }
 
         async function fetchExecutables() {
             const response = await fetch('/executables');
             const executables = await response.json();
-            const scriptNameSelect = document.getElementById('scriptName');
-            scriptNameSelect.innerHTML = '';
+            const commandNameSelect = document.getElementById('commandName');
+            commandNameSelect.innerHTML = '';
             executables.forEach(executable => {
                 const option = document.createElement('option');
                 option.value = executable;
                 option.textContent = executable;
-                scriptNameSelect.appendChild(option);
+                commandNameSelect.appendChild(option);
             });
         }
 
-        async function fetchOutput(script_id) {
+        async function fetchOutput(command_id) {
             const outputDiv = document.getElementById('output');
-            const response = await fetch(`/script_output/${script_id}`);
+            const response = await fetch(`/command_output/${command_id}`);
             const data = await response.json();
             if (data.error) {
                 outputDiv.innerHTML = data.error;
@@ -209,45 +209,45 @@
             }
         }
 
-        async function viewOutput(script_id) {
+        async function viewOutput(command_id) {
             adjustOutputHeight();
-            currentScriptId = script_id;
+            currentCommandId = command_id;
             clearInterval(outputInterval);
-            const response = await fetch(`/script_status/${script_id}`);
+            const response = await fetch(`/command_status/${command_id}`);
             const data = await response.json();
             if (data.status === 'running') {
-                fetchOutput(script_id);
-                outputInterval = setInterval(() => fetchOutput(script_id), 1000);
+                fetchOutput(command_id);
+                outputInterval = setInterval(() => fetchOutput(command_id), 1000);
             } else {
-                fetchOutput(script_id);
+                fetchOutput(command_id);
             }
-            fetchScripts(); // Refresh the script list to highlight the current script
+            fetchCommands(); // Refresh the command list to highlight the current command
         }
 
-        async function relaunchScript(script_id) {
-            const response = await fetch(`/script_status/${script_id}`);
+        async function relaunchCommand(command_id) {
+            const response = await fetch(`/command_status/${command_id}`);
             const data = await response.json();
             if (data.error) {
                 alert(data.error);
                 return;
             }
-            const relaunchResponse = await fetch('/run_script', {
+            const relaunchResponse = await fetch('/run_command', {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json'
                 },
                 body: JSON.stringify({
-                    script_name: data.script_name,
+                    command: data.command,
                     params: data.params
                 })
             });
             const relaunchData = await relaunchResponse.json();
-            fetchScripts();
-            viewOutput(relaunchData.script_id);
+            fetchCommands();
+            viewOutput(relaunchData.command_id);
         }
 
-        async function stopScript(script_id) {
-            const response = await fetch(`/stop_script/${script_id}`, {
+        async function stopCommand(command_id) {
+            const response = await fetch(`/stop_command/${command_id}`, {
                 method: 'POST'
             });
             const data = await response.json();
@@ -255,7 +255,7 @@
                 alert(data.error);
             } else {
                 alert(data.message);
-                fetchScripts();
+                fetchCommands();
             }
         }
 
@@ -322,9 +322,9 @@
             initResizer();
         });
 
-        fetchScripts();
+        fetchCommands();
         fetchExecutables();
-        setInterval(fetchScripts, 5000);
+        setInterval(fetchCommands, 5000);
     </script>
 </body>
 </html>

pywebexec/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.1'
-__version_tuple__ = version_tuple = (0, 1, 1)
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)

{pywebexec-0.1.1.dist-info → pywebexec-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pywebexec
-Version: 0.1.1
+Version: 1.0.0
 Summary: Simple Python HTTP Exec Server
 Home-page: https://github.com/joknarf/pywebexec
 Author: Franck Jouvanceau
@@ -85,7 +85,7 @@ $ pywebexec
 
 ## features
 
-* Serve executables in current directory
+* Serve executables in a directory
 * Launch commands with params from web browser or API call
 * Follow live output
 * Stop command
@@ -94,11 +94,12 @@ $ pywebexec
 * HTTPS self-signed certificate generator
 * Can be started as a daemon (POSIX)
 * uses gunicorn to serve http/https
+* compatible Linux/MacOS
 
 ## Customize server
 ```
-$ pywebexec --listen 0.0.0.0 --port 8080
-$ pywebexec -l 0.0.0.0 -p 8080
+$ pywebexec --dir ~/myscripts --listen 0.0.0.0 --port 8080
+$ pywebexec -d ~/myscripts -l 0.0.0.0 -p 8080
 ```
 
 ## Basic auth user/password
@@ -122,7 +123,7 @@ $ pywebfs --cert /pathto/host.cert --key /pathto/host.key
 $ pywebfs -c /pathto/host.cert -k /pathto/host.key
 ```
 
-## Launch server as a daemon (Linux)
+## Launch server as a daemon
 
 ```
 $ pywebexec start
@@ -131,3 +132,20 @@ $ pywebexec stop
 ```
 * log of server are stored in directory `[.config/].pywebexec/pywebexec_<listen>:<port>.log`
 
+## Launch command through API
+
+```
+# curl http://myhost:8080/run_script -H 'Content-Type: application/json' -X POST -d '{ "script_name":"myscript", "param":["param1", ...]}
+```
+
+## API reference
+
+
+| method    | route                       | params/payload     | returns
+|-----------|-----------------------------|--------------------|---------------------|
+| POST      | /run_command                | command: str<br>params: array[str]       | command_id: uuid<br>message: str    |
+| POST      | /stop_command/command_id    |                    | message: str        |
+| GET       | /command_status/command_id  |                    | command_id: uuid<br>command: str<br>params: array[str]<br>start_time: isotime<br>end_time: isotime<br>status: str<br>exit_code: int      |
+| GET       | /command_output/command_id  |                    | output: str<br>status: str         |
+| GET       | /commands                   |                    | array of<br>command_id: uuid<br>command: str<br>start_time: isotime<br>end_time: isotime<br>status: str<br>exit_code: int      |
+| GET       | /executables                |                    | array of str        |

{pywebexec-0.1.1.dist-info → pywebexec-1.0.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pywebexec/__init__.py,sha256=4spIsVaF8RJt8S58AG_wWoORRNkws9Iwqprj27C3ljM,99
-pywebexec/pywebexec.py,sha256=IyNVTDepd5UPfKBHqctIyNez9McNb7z9xN01rXGIK44,12928
-pywebexec/version.py,sha256=PKIMyjdUACH4-ONvtunQCnYE2UhlMfp9su83e3HXl5E,411
+pywebexec/pywebexec.py,sha256=2lVnQd9BgaUunjUtgYKIwgIRllX11v64jZQgfweteFg,16281
+pywebexec/version.py,sha256=DGJ4pj32xs3_DRJhSzQwCiRNnAQrMgo09USYpyMZsKc,411
 pywebexec/static/images/aborted.svg,sha256=_mP43hU5QdRLFZIknBgjx-dIXrHgQG23-QV27ApXK2A,381
 pywebexec/static/images/copy.svg,sha256=d9OwtGh5GzzZHzYcDrLfNxZYLth1Q64x7bRyYxu4Px0,622
 pywebexec/static/images/copy_ok.svg,sha256=mEqUVUhSq8xaJK2msQkxRawnz_KwlCZ-tok8QS6hJ3g,451
@@ -8,10 +8,10 @@ pywebexec/static/images/failed.svg,sha256=ADZ7IKrUyOXtqpivnz3VcH0-Wru-I5MOi3OJAk
 pywebexec/static/images/running.svg,sha256=vBpiG6ClNUNCArkwsyqK7O-qhIKJX1NI7MSjclNSp_8,1537
 pywebexec/static/images/success.svg,sha256=PJDcCSTevJh7rkfSFLtc7P0pbeh8PVQBS8DaOLQemmc,489
 pywebexec/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pywebexec/templates/index.html,sha256=0628YJ1TIH7WPA-UJPfYqEjBo8joYn9685R9Zm5Zz30,12356
-pywebexec-0.1.1.dist-info/LICENSE,sha256=gRJf0JPT_wsZJsUGlWPTS8Vypfl9vQ1qjp6sNbKykuA,1064
-pywebexec-0.1.1.dist-info/METADATA,sha256=83vtZn2DbTfVaOFejyAiKhef_rYEiE6-ko_LMi8yPhg,4770
-pywebexec-0.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-pywebexec-0.1.1.dist-info/entry_points.txt,sha256=l52GBkPCXRkmlHfEyoVauyfBdg8o-CAtC8qQpOIjJK0,55
-pywebexec-0.1.1.dist-info/top_level.txt,sha256=vHoHyzngrfGdm_nM7Xn_5iLmaCrf10XO1EhldgNLEQ8,10
-pywebexec-0.1.1.dist-info/RECORD,,
+pywebexec/templates/index.html,sha256=taMeaWiX7ijHI-kWVyjIBH0E0Fj5RY7-9ocOXOiTZCk,12431
+pywebexec-1.0.0.dist-info/LICENSE,sha256=gRJf0JPT_wsZJsUGlWPTS8Vypfl9vQ1qjp6sNbKykuA,1064
+pywebexec-1.0.0.dist-info/METADATA,sha256=CrooVWXHqkcV0PtBpWzHedlZVLvoR0b77O_MxojvK6E,5970
+pywebexec-1.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pywebexec-1.0.0.dist-info/entry_points.txt,sha256=l52GBkPCXRkmlHfEyoVauyfBdg8o-CAtC8qQpOIjJK0,55
+pywebexec-1.0.0.dist-info/top_level.txt,sha256=vHoHyzngrfGdm_nM7Xn_5iLmaCrf10XO1EhldgNLEQ8,10
+pywebexec-1.0.0.dist-info/RECORD,,