py-web-ssh 0.1.4__tar.gz → 0.1.5__tar.gz

{py_web_ssh-0.1.4 → py_web_ssh-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-web-ssh
-Version: 0.1.4
+Version: 0.1.5
 Summary: A Python web SSH client with xterm.js, reconnectable sessions, logs, and file transfer.
 License-Expression: MIT
 License-File: LICENSE
@@ -33,7 +33,7 @@ Description-Content-Type: text/markdown
 - 会话回收：同一个 UUID 如果所有浏览器连接都断开并且 5 分钟内无人重连，服务端会主动断开 SSH 并清理内存缓存。
 - 终端恢复：服务端保存 SSH 输出流，浏览器定期回传 xterm serialize 快照；重连时先恢复快照，再补放快照之后的输出。
 - 日志页面：`/sessions/{uuid}/logs` 展示完整连接、认证、错误和文件传输日志。
-- 文件传输：优先 SFTP；SFTP 不可用时参考 `simple-ssh-copy` 思路，使用远端 `base64` shell 命令 fallback 上传/下载。
+- 文件传输：参考 `simple-ssh-copy` 思路，不使用 SFTP/SCP；每次传输都按连接配置新建独立 SSH 连接，使用远端 `base64` shell 命令上传/下载。上传先写远端临时文件，完成后再 `mv` 到最终路径，并支持进度显示和取消。
 - 可选 PIN 门禁：服务端传入 `--pin` 后，网页启动时必须先输入正确 PIN；验证成功后浏览器会保存加盐哈希 cookie，后端会保护 HTTP API、日志页面、文件接口和 WebSocket。
 - 浏览器客户端 session：首次访问时服务端会分配独立的浏览器 session UUID，并写入 HttpOnly cookie；它与 SSH 会话 UUID 分离。
 - 左侧控制面板：连接、会话、文件三个栏目改为互斥折叠面板，一次最多展开一个，也可以全部折叠。

{py_web_ssh-0.1.4 → py_web_ssh-0.1.5}/README.md

@@ -11,7 +11,7 @@
 - 会话回收：同一个 UUID 如果所有浏览器连接都断开并且 5 分钟内无人重连，服务端会主动断开 SSH 并清理内存缓存。
 - 终端恢复：服务端保存 SSH 输出流，浏览器定期回传 xterm serialize 快照；重连时先恢复快照，再补放快照之后的输出。
 - 日志页面：`/sessions/{uuid}/logs` 展示完整连接、认证、错误和文件传输日志。
-- 文件传输：优先 SFTP；SFTP 不可用时参考 `simple-ssh-copy` 思路，使用远端 `base64` shell 命令 fallback 上传/下载。
+- 文件传输：参考 `simple-ssh-copy` 思路，不使用 SFTP/SCP；每次传输都按连接配置新建独立 SSH 连接，使用远端 `base64` shell 命令上传/下载。上传先写远端临时文件，完成后再 `mv` 到最终路径，并支持进度显示和取消。
 - 可选 PIN 门禁：服务端传入 `--pin` 后，网页启动时必须先输入正确 PIN；验证成功后浏览器会保存加盐哈希 cookie，后端会保护 HTTP API、日志页面、文件接口和 WebSocket。
 - 浏览器客户端 session：首次访问时服务端会分配独立的浏览器 session UUID，并写入 HttpOnly cookie；它与 SSH 会话 UUID 分离。
 - 左侧控制面板：连接、会话、文件三个栏目改为互斥折叠面板，一次最多展开一个，也可以全部折叠。

{py_web_ssh-0.1.4 → py_web_ssh-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "py-web-ssh"
-version = "0.1.4"
+version = "0.1.5"
 description = "A Python web SSH client with xterm.js, reconnectable sessions, logs, and file transfer."
 readme = "README.md"
 requires-python = ">=3.10"

{py_web_ssh-0.1.4 → py_web_ssh-0.1.5}/webssh/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.1.4"
+__version__ = "0.1.5"

{py_web_ssh-0.1.4 → py_web_ssh-0.1.5}/webssh/app.py

@@ -14,9 +14,15 @@ from . import __version__
 from . import auth
 from .auth import add_pin_argument, configure_pin
 from .client_session import ensure_client_session_cookie
-from .files import download_file, filename_for_download, upload_file
+from .files import (
+    FileTransferCancelled,
+    download_file_via_ssh,
+    filename_for_download,
+    upload_file_via_ssh,
+)
 from .models import ConnectRequest, CreateSessionResponse, FileTransferResponse
 from .session import SessionManager
+from .transfers import TransferManager
 
 
 BASE_DIR = Path(__file__).resolve().parent
@@ -28,6 +34,7 @@ DEFAULT_PORT = 8022
 app = FastAPI(title="py-web-ssh", version=__version__)
 app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 sessions = SessionManager()
+transfers = TransferManager()
 
 
 @app.middleware("http")
@@ -118,19 +125,35 @@ def upload(
     session_id: str,
     remote_path: Annotated[str, Form(min_length=1)],
     file: Annotated[UploadFile, File()],
+    transfer_id: Annotated[str | None, Form()] = None,
+    total_bytes: Annotated[int | None, Form()] = None,
 ) -> FileTransferResponse:
     session = _require_session(session_id)
+    tracker = transfers.get(transfer_id) if transfer_id else None
+    if transfer_id and tracker is None:
+        raise HTTPException(status_code=404, detail="Transfer not found.")
+    if tracker is None:
+        tracker = transfers.create_upload(total_bytes or _content_length(file), remote_path)
     try:
-        method, transferred = upload_file(
-            session.ssh_client,
+        method, transferred = upload_file_via_ssh(
+            session.config,
             file.file,
             remote_path,
-            _content_length(file),
+            total_bytes or _content_length(file),
+            cancel_event=tracker.cancel_event,
+            progress=tracker.update_progress,
         )
+    except FileTransferCancelled as exc:
+        message = f"File upload cancelled: {exc}"
+        tracker.cancelled(message)
+        session.log("warning", message, None)
+        raise HTTPException(status_code=499, detail=message) from exc
     except Exception as exc:
+        tracker.fail(str(exc))
         session.log("error", f"File upload failed: {exc}", None)
         raise HTTPException(status_code=500, detail=str(exc)) from exc
     message = f"Uploaded {transferred} bytes to {remote_path} using {method}."
+    tracker.complete(transferred, message)
     session.log("info", message, None)
     return FileTransferResponse(
         ok=True,
@@ -138,14 +161,63 @@ def upload(
         bytes_transferred=transferred,
         remote_path=remote_path,
         message=message,
+        transfer_id=tracker.id,
     )
 
 
+@app.post("/api/sessions/{session_id}/files/uploads")
+async def create_upload_task(session_id: str, request: Request) -> JSONResponse:
+    _require_session(session_id)
+    payload = await request.json()
+    remote_path = str(payload.get("remote_path", "")).strip()
+    if not remote_path:
+        raise HTTPException(status_code=422, detail="remote_path is required.")
+    total_bytes = payload.get("total_bytes")
+    if total_bytes is not None:
+        total_bytes = int(total_bytes)
+    tracker = transfers.create_upload(total_bytes, remote_path)
+    return JSONResponse(
+        {
+            "transfer_id": tracker.id,
+            "state": tracker.status().state,
+            "remote_path": remote_path,
+            "total_bytes": total_bytes,
+        }
+    )
+
+
+@app.get("/api/transfers/{transfer_id}")
+def get_transfer(transfer_id: str) -> JSONResponse:
+    tracker = transfers.get(transfer_id)
+    if tracker is None:
+        raise HTTPException(status_code=404, detail="Transfer not found.")
+    status = tracker.status()
+    return JSONResponse(
+        {
+            "transfer_id": status.transfer_id,
+            "state": status.state,
+            "bytes_transferred": status.bytes_transferred,
+            "total_bytes": status.total_bytes,
+            "remote_path": status.remote_path,
+            "message": status.message,
+            "created_at": status.created_at.isoformat(),
+            "updated_at": status.updated_at.isoformat(),
+        }
+    )
+
+
+@app.delete("/api/transfers/{transfer_id}")
+def cancel_transfer(transfer_id: str) -> JSONResponse:
+    if not transfers.cancel(transfer_id):
+        raise HTTPException(status_code=404, detail="Transfer not found.")
+    return JSONResponse({"ok": True})
+
+
 @app.get("/api/sessions/{session_id}/files/download")
 def download(session_id: str, remote_path: str) -> StreamingResponse:
     session = _require_session(session_id)
     try:
-        method, stream = download_file(session.ssh_client, remote_path)
+        method, stream = download_file_via_ssh(session.config, remote_path)
     except Exception as exc:
         session.log("error", f"File download failed: {exc}", None)
         raise HTTPException(status_code=500, detail=str(exc)) from exc

py_web_ssh-0.1.5/webssh/files.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import base64
+import binascii
+import os
+import posixpath
+import shlex
+import threading
+import uuid
+from collections.abc import Callable, Iterator
+from typing import BinaryIO
+
+from .models import ConnectRequest
+from .ssh_client import connect_ssh
+
+
+class FileTransferError(RuntimeError):
+    pass
+
+
+class FileTransferCancelled(FileTransferError):
+    pass
+
+
+ProgressCallback = Callable[[int], None]
+
+
+def upload_file_via_ssh(
+    config: ConnectRequest,
+    source: BinaryIO,
+    remote_path: str,
+    size: int | None,
+    cancel_event: threading.Event | None = None,
+    progress: ProgressCallback | None = None,
+) -> tuple[str, int]:
+    """Upload using only an SSH exec channel and POSIX-ish shell commands.
+
+    This intentionally does not use SFTP or SCP. It follows the simple-ssh-copy
+    style: stream base64 into a remote shell, decode into a temporary file, and
+    atomically move the temp file into place after the complete upload succeeds.
+    """
+
+    connected = connect_ssh(config, lambda _level, _message, _details=None: None)
+    client = connected.client
+    remote_dir = posixpath.dirname(remote_path) or "."
+    temp_path = posixpath.join(remote_dir, f".py-web-ssh-upload-{uuid.uuid4().hex}.tmp")
+    command = _upload_command(remote_dir, temp_path, remote_path)
+    stdin = stdout = stderr = None
+    transferred = 0
+    try:
+        stdin, stdout, stderr = client.exec_command(f"sh -c {shlex.quote(command)}")
+        while True:
+            if cancel_event and cancel_event.is_set():
+                raise FileTransferCancelled("Upload cancelled by client.")
+            chunk = source.read(48 * 1024)
+            if not chunk:
+                break
+            transferred += len(chunk)
+            stdin.write(base64.b64encode(chunk).decode("ascii"))
+            stdin.write("\n")
+            stdin.flush()
+            if progress:
+                progress(transferred)
+
+        if cancel_event and cancel_event.is_set():
+            raise FileTransferCancelled("Upload cancelled by client.")
+
+        stdin.channel.shutdown_write()
+        exit_code = stdout.channel.recv_exit_status()
+        error_text = stderr.read().decode("utf-8", errors="replace")
+    except FileTransferCancelled:
+        _close_transport(client)
+        raise
+    except Exception as exc:
+        _close_transport(client)
+        raise FileTransferError(f"SSH shell upload failed: {exc}") from exc
+    finally:
+        for stream in (stdin, stdout, stderr):
+            if stream is not None:
+                try:
+                    stream.close()
+                except Exception:
+                    pass
+        client.close()
+
+    if exit_code != 0:
+        raise FileTransferError(f"Remote upload command failed with exit code {exit_code}: {error_text}")
+    if size is not None and transferred != size:
+        raise FileTransferError(f"Uploaded {transferred} bytes, expected {size} bytes.")
+    return "shell", transferred
+
+
+def download_file_via_ssh(config: ConnectRequest, remote_path: str) -> tuple[str, Iterator[bytes]]:
+    connected = connect_ssh(config, lambda _level, _message, _details=None: None)
+    client = connected.client
+    command = f"base64 < {shlex.quote(remote_path)}"
+    stdin, stdout, stderr = client.exec_command(f"sh -c {shlex.quote(command)}")
+    stdin.close()
+
+    def iterator() -> Iterator[bytes]:
+        buffered = b""
+        try:
+            while True:
+                chunk = stdout.channel.recv(64 * 1024)
+                if not chunk:
+                    break
+                buffered += b"".join(chunk.split())
+                keep = len(buffered) % 4
+                ready = buffered[:-keep] if keep else buffered
+                buffered = buffered[-keep:] if keep else b""
+                if ready:
+                    yield base64.b64decode(ready)
+            if buffered:
+                yield base64.b64decode(buffered)
+            exit_code = stdout.channel.recv_exit_status()
+            error_text = stderr.read().decode("utf-8", errors="replace")
+            if exit_code != 0:
+                raise FileTransferError(
+                    f"Remote download command failed with exit code {exit_code}: {error_text}"
+                )
+        except binascii.Error as exc:
+            raise FileTransferError(f"Remote command returned invalid base64: {exc}") from exc
+        finally:
+            stdout.close()
+            stderr.close()
+            client.close()
+
+    return "shell", iterator()
+
+
+def _upload_command(remote_dir: str, temp_path: str, remote_path: str) -> str:
+    quoted_temp = shlex.quote(temp_path)
+    return "\n".join(
+        [
+            "set -e",
+            f"mkdir -p -- {shlex.quote(remote_dir)}",
+            f"tmp={quoted_temp}",
+            "cleanup() { rm -f -- \"$tmp\"; }",
+            "trap cleanup EXIT HUP INT TERM",
+            f"if printf '' | base64 -d >/dev/null 2>&1; then base64 -d > {quoted_temp}; "
+            f"else base64 -D > {quoted_temp}; fi",
+            f"mv -- {quoted_temp} {shlex.quote(remote_path)}",
+            "trap - EXIT",
+        ]
+    )
+
+
+def _close_transport(client) -> None:
+    try:
+        transport = client.get_transport()
+        if transport is not None:
+            transport.close()
+    except Exception:
+        pass
+    try:
+        client.close()
+    except Exception:
+        pass
+
+
+def filename_for_download(remote_path: str) -> str:
+    name = posixpath.basename(remote_path.rstrip("/")) or "download.bin"
+    return os.path.basename(name)

{py_web_ssh-0.1.4 → py_web_ssh-0.1.5}/webssh/models.py

@@ -70,7 +70,8 @@ class SessionSummary(BaseModel):
 
 class FileTransferResponse(BaseModel):
     ok: bool
-    method: Literal["sftp", "shell"]
+    method: Literal["shell"]
     bytes_transferred: int
     remote_path: str
     message: str
+    transfer_id: str | None = None

{py_web_ssh-0.1.4 → py_web_ssh-0.1.5}/webssh/static/app.js

@@ -9,6 +9,10 @@ const pinForm = document.querySelector("#pin-form");
 const pinInput = document.querySelector("#pin-input");
 const pinError = document.querySelector("#pin-error");
 const panelToggles = document.querySelectorAll(".panel-toggle");
+const uploadProgress = document.querySelector("#upload-progress");
+const uploadProgressText = document.querySelector("#upload-progress-text");
+const uploadProgressBar = document.querySelector("#upload-progress-bar");
+const cancelUploadButton = document.querySelector("#cancel-upload");
 
 const term = new Terminal({
   cursorBlink: true,
@@ -50,6 +54,7 @@ let ws = null;
 let activeSessionId = localStorage.getItem("py-web-ssh-session") || "";
 let lastAppliedSeq = 0;
 let snapshotTimer = null;
+let activeUpload = null;
 
 if (activeSessionId) {
   sessionInput.value = activeSessionId;
@@ -153,15 +158,81 @@ document.querySelector("#upload-form").addEventListener("submit", async (event)
   }
   const form = new FormData();
   form.append("remote_path", remotePath);
+  form.append("total_bytes", String(file.size));
   form.append("file", file);
+  let xhr = null;
+  const uploadState = {
+    xhr: null,
+    transferId: null,
+    pollTimer: null,
+    cancelled: false,
+    fileSize: file.size,
+  };
+  activeUpload = uploadState;
+  showUploadProgress(0, file.size, "准备上传...");
   setStatus("上传中...");
-  const response = await fetch(`/api/sessions/${activeSessionId}/files/upload`, {
+  try {
+    const task = await createUploadTask(activeSessionId, remotePath, file.size);
+    uploadState.transferId = task.transfer_id;
+    form.append("transfer_id", uploadState.transferId);
+    startUploadPolling(uploadState);
+    xhr = uploadWithXhr(`/api/sessions/${activeSessionId}/files/upload`, form, uploadState);
+    uploadState.xhr = xhr;
+    const result = await xhr;
+    showUploadProgress(result.bytes_transferred, file.size, "上传完成");
+    appendLogLine(`上传完成: ${JSON.stringify(result)}`);
+    setStatus("上传完成");
+  } catch (error) {
+    appendLogLine(uploadState.cancelled ? "上传已取消。" : `上传失败: ${error}`);
+    setStatus(uploadState.cancelled ? "上传已取消" : "上传失败");
+  } finally {
+    stopUploadPolling(uploadState);
+    if (activeUpload === uploadState) activeUpload = null;
+  }
+});
+
+async function createUploadTask(sessionId, remotePath, totalBytes) {
+  const response = await fetch(`/api/sessions/${sessionId}/files/uploads`, {
     method: "POST",
-    body: form,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ remote_path: remotePath, total_bytes: totalBytes }),
+  });
+  if (!response.ok) {
+    throw new Error(await response.text());
+  }
+  return await response.json();
+}
+
+function uploadWithXhr(url, form, uploadState) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("POST", url);
+    xhr.upload.addEventListener("progress", (event) => {
+      if (event.lengthComputable) {
+        showUploadProgress(event.loaded, event.total, "正在发送到服务端...");
+      }
+    });
+    xhr.addEventListener("load", () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        resolve(JSON.parse(xhr.responseText));
+      } else {
+        reject(new Error(xhr.responseText || `HTTP ${xhr.status}`));
+      }
+    });
+    xhr.addEventListener("error", () => reject(new Error("Network error during upload.")));
+    xhr.addEventListener("abort", () => reject(new Error("Upload request aborted.")));
+    xhr.send(form);
   });
-  const body = await response.text();
-  appendLogLine(response.ok ? `上传完成: ${body}` : `上传失败: ${body}`);
-  setStatus(response.ok ? "上传完成" : "上传失败");
+}
+
+cancelUploadButton.addEventListener("click", async () => {
+  if (!activeUpload) return;
+  activeUpload.cancelled = true;
+  showUploadProgress(0, activeUpload.fileSize, "正在取消上传...");
+  if (activeUpload.transferId) {
+    await fetch(`/api/transfers/${activeUpload.transferId}`, { method: "DELETE" });
+  }
+  if (activeUpload.xhr) activeUpload.xhr.abort();
 });
 
 document.querySelector("#download-form").addEventListener("submit", async (event) => {
@@ -390,6 +461,49 @@ function filenameFromResponse(response, fallbackPath) {
   return fallbackPath.split("/").filter(Boolean).pop() || "download.bin";
 }
 
+function showUploadProgress(done, total, message) {
+  uploadProgress.classList.remove("hidden");
+  const percent = total ? Math.min(100, Math.round((done / total) * 100)) : 0;
+  uploadProgressBar.value = percent;
+  uploadProgressText.textContent = `${message} ${formatBytes(done)}${total ? ` / ${formatBytes(total)}` : ""}`;
+}
+
+function startUploadPolling(uploadState) {
+  stopUploadPolling(uploadState);
+  uploadState.pollTimer = window.setInterval(async () => {
+    if (!uploadState.transferId) return;
+    try {
+      const response = await fetch(`/api/transfers/${uploadState.transferId}`);
+      if (!response.ok) return;
+      const status = await response.json();
+      showUploadProgress(
+        status.bytes_transferred || 0,
+        status.total_bytes || uploadState.fileSize,
+        status.message || status.state,
+      );
+      if (["completed", "cancelled", "failed"].includes(status.state)) {
+        stopUploadPolling(uploadState);
+      }
+    } catch (_error) {
+      return;
+    }
+  }, 500);
+}
+
+function stopUploadPolling(uploadState) {
+  if (uploadState.pollTimer) {
+    window.clearInterval(uploadState.pollTimer);
+    uploadState.pollTimer = null;
+  }
+}
+
+function formatBytes(value) {
+  if (!Number.isFinite(value)) return "0 B";
+  if (value < 1024) return `${value} B`;
+  if (value < 1024 * 1024) return `${(value / 1024).toFixed(1)} KiB`;
+  return `${(value / 1024 / 1024).toFixed(1)} MiB`;
+}
+
 function bytesToBase64(bytes) {
   let binary = "";
   const size = 0x8000;

{py_web_ssh-0.1.4 → py_web_ssh-0.1.5}/webssh/static/index.html

@@ -117,6 +117,13 @@
               </label>
               <button type="submit">上传</button>
             </form>
+            <div id="upload-progress" class="transfer-progress hidden">
+              <div class="progress-row">
+                <span id="upload-progress-text">等待上传</span>
+                <button id="cancel-upload" type="button">取消上传</button>
+              </div>
+              <progress id="upload-progress-bar" max="100" value="0"></progress>
+            </div>
             <form id="download-form" class="stack compact">
               <label>
                 下载远端路径

{py_web_ssh-0.1.4 → py_web_ssh-0.1.5}/webssh/static/styles.css

@@ -233,6 +233,33 @@ label {
   text-decoration: none;
 }
 
+.transfer-progress {
+  display: grid;
+  gap: 8px;
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  padding: 10px;
+  background: #0c1116;
+}
+
+.transfer-progress.hidden {
+  display: none;
+}
+
+.progress-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 8px;
+  align-items: center;
+  color: var(--muted);
+  font-size: 12px;
+}
+
+progress {
+  width: 100%;
+  height: 10px;
+}
+
 .workspace {
   display: grid;
   grid-template-rows: 52px minmax(0, 1fr);

py_web_ssh-0.1.5/webssh/transfers.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import threading
+import uuid
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Literal
+
+
+TransferState = Literal["running", "completed", "cancelled", "failed"]
+
+
+@dataclass
+class TransferStatus:
+    transfer_id: str
+    state: TransferState
+    bytes_transferred: int
+    total_bytes: int | None
+    remote_path: str
+    message: str
+    created_at: datetime
+    updated_at: datetime
+
+
+class TransferTracker:
+    def __init__(self, total_bytes: int | None, remote_path: str) -> None:
+        now = datetime.now(timezone.utc)
+        self.id = str(uuid.uuid4())
+        self.cancel_event = threading.Event()
+        self._lock = threading.RLock()
+        self._status = TransferStatus(
+            transfer_id=self.id,
+            state="running",
+            bytes_transferred=0,
+            total_bytes=total_bytes,
+            remote_path=remote_path,
+            message="Upload started.",
+            created_at=now,
+            updated_at=now,
+        )
+
+    def update_progress(self, bytes_transferred: int) -> None:
+        with self._lock:
+            self._status.bytes_transferred = bytes_transferred
+            self._status.message = "Uploading."
+            self._status.updated_at = datetime.now(timezone.utc)
+
+    def complete(self, bytes_transferred: int, message: str) -> None:
+        with self._lock:
+            self._status.state = "completed"
+            self._status.bytes_transferred = bytes_transferred
+            self._status.message = message
+            self._status.updated_at = datetime.now(timezone.utc)
+
+    def fail(self, message: str) -> None:
+        with self._lock:
+            self._status.state = "failed"
+            self._status.message = message
+            self._status.updated_at = datetime.now(timezone.utc)
+
+    def cancel(self) -> None:
+        self.cancel_event.set()
+        with self._lock:
+            self._status.state = "cancelled"
+            self._status.message = "Upload cancellation requested."
+            self._status.updated_at = datetime.now(timezone.utc)
+
+    def cancelled(self, message: str) -> None:
+        self.cancel_event.set()
+        with self._lock:
+            self._status.state = "cancelled"
+            self._status.message = message
+            self._status.updated_at = datetime.now(timezone.utc)
+
+    def status(self) -> TransferStatus:
+        with self._lock:
+            return TransferStatus(**self._status.__dict__)
+
+
+class TransferManager:
+    def __init__(self) -> None:
+        self._lock = threading.RLock()
+        self._transfers: dict[str, TransferTracker] = {}
+
+    def create_upload(self, total_bytes: int | None, remote_path: str) -> TransferTracker:
+        tracker = TransferTracker(total_bytes=total_bytes, remote_path=remote_path)
+        with self._lock:
+            self._transfers[tracker.id] = tracker
+        return tracker
+
+    def get(self, transfer_id: str) -> TransferTracker | None:
+        with self._lock:
+            return self._transfers.get(transfer_id)
+
+    def cancel(self, transfer_id: str) -> bool:
+        tracker = self.get(transfer_id)
+        if tracker is None:
+            return False
+        tracker.cancel()
+        return True

py_web_ssh-0.1.4/webssh/files.py

@@ -1,189 +0,0 @@
-from __future__ import annotations
-
-import base64
-import binascii
-import os
-import posixpath
-import shlex
-import uuid
-from collections.abc import Iterator
-from typing import BinaryIO
-
-import paramiko
-
-
-class FileTransferError(RuntimeError):
-    pass
-
-
-def upload_file(
-    client: paramiko.SSHClient,
-    source: BinaryIO,
-    remote_path: str,
-    size: int | None,
-) -> tuple[str, int]:
-    try:
-        return _upload_sftp(client, source, remote_path, size)
-    except Exception as sftp_exc:
-        source.seek(0)
-        try:
-            return _upload_shell(client, source, remote_path, size)
-        except Exception as shell_exc:
-            raise FileTransferError(
-                f"SFTP upload failed: {sftp_exc}\nShell fallback upload failed: {shell_exc}"
-            ) from shell_exc
-
-
-def download_file(client: paramiko.SSHClient, remote_path: str) -> tuple[str, Iterator[bytes]]:
-    try:
-        return "sftp", _download_sftp(client, remote_path)
-    except Exception as sftp_exc:
-        try:
-            return "shell", _download_shell(client, remote_path)
-        except Exception as shell_exc:
-            raise FileTransferError(
-                f"SFTP download failed: {sftp_exc}\nShell fallback download failed: {shell_exc}"
-            ) from shell_exc
-
-
-def _upload_sftp(
-    client: paramiko.SSHClient,
-    source: BinaryIO,
-    remote_path: str,
-    size: int | None,
-) -> tuple[str, int]:
-    transferred = 0
-
-    def callback(sent: int, _total: int) -> None:
-        nonlocal transferred
-        transferred = max(transferred, sent)
-
-    with client.open_sftp() as sftp:
-        parent = posixpath.dirname(remote_path)
-        if parent and parent != ".":
-            _sftp_mkdirs(sftp, parent)
-        sftp.putfo(source, remote_path, file_size=size or 0, callback=callback)
-
-    if transferred == 0 and size is not None:
-        transferred = size
-    elif transferred == 0:
-        transferred = _remote_size(client, remote_path)
-    return "sftp", transferred
-
-
-def _sftp_mkdirs(sftp: paramiko.SFTPClient, path: str) -> None:
-    if path in ("", "/"):
-        return
-    parts = [part for part in path.split("/") if part]
-    current = "/" if path.startswith("/") else ""
-    for part in parts:
-        current = posixpath.join(current, part) if current else part
-        try:
-            sftp.stat(current)
-        except IOError:
-            sftp.mkdir(current)
-
-
-def _upload_shell(
-    client: paramiko.SSHClient,
-    source: BinaryIO,
-    remote_path: str,
-    size: int | None,
-) -> tuple[str, int]:
-    remote_dir = posixpath.dirname(remote_path) or "."
-    temp_path = posixpath.join(remote_dir, f".py-web-ssh-upload-{uuid.uuid4().hex}.tmp")
-    command = (
-        "set -e; "
-        f"mkdir -p -- {shlex.quote(remote_dir)}; "
-        f"({_base64_decode_command()}) > {shlex.quote(temp_path)}; "
-        f"mv -- {shlex.quote(temp_path)} {shlex.quote(remote_path)}"
-    )
-    stdin, stdout, stderr = client.exec_command(f"sh -c {shlex.quote(command)}")
-    transferred = 0
-    try:
-        while True:
-            chunk = source.read(48 * 1024)
-            if not chunk:
-                break
-            transferred += len(chunk)
-            stdin.write(base64.b64encode(chunk).decode("ascii"))
-            stdin.write("\n")
-        stdin.channel.shutdown_write()
-        exit_code = stdout.channel.recv_exit_status()
-        error_text = stderr.read().decode("utf-8", errors="replace")
-    finally:
-        stdin.close()
-        stdout.close()
-        stderr.close()
-    if exit_code != 0:
-        raise FileTransferError(f"Remote upload command failed with exit code {exit_code}: {error_text}")
-    if size is not None and transferred != size:
-        raise FileTransferError(f"Uploaded {transferred} bytes, expected {size} bytes.")
-    return "shell", transferred
-
-
-def _download_sftp(client: paramiko.SSHClient, remote_path: str) -> Iterator[bytes]:
-    sftp = client.open_sftp()
-    remote_file = sftp.open(remote_path, "rb")
-
-    def iterator() -> Iterator[bytes]:
-        try:
-            while True:
-                chunk = remote_file.read(64 * 1024)
-                if not chunk:
-                    break
-                yield chunk
-        finally:
-            remote_file.close()
-            sftp.close()
-
-    return iterator()
-
-
-def _download_shell(client: paramiko.SSHClient, remote_path: str) -> Iterator[bytes]:
-    command = f"base64 < {shlex.quote(remote_path)}"
-    stdin, stdout, stderr = client.exec_command(f"sh -c {shlex.quote(command)}")
-    stdin.close()
-
-    def iterator() -> Iterator[bytes]:
-        buffered = b""
-        try:
-            while True:
-                chunk = stdout.channel.recv(64 * 1024)
-                if not chunk:
-                    break
-                buffered += b"".join(chunk.split())
-                keep = len(buffered) % 4
-                ready = buffered[:-keep] if keep else buffered
-                buffered = buffered[-keep:] if keep else b""
-                if ready:
-                    yield base64.b64decode(ready)
-            if buffered:
-                yield base64.b64decode(buffered)
-            exit_code = stdout.channel.recv_exit_status()
-            error_text = stderr.read().decode("utf-8", errors="replace")
-            if exit_code != 0:
-                raise FileTransferError(
-                    f"Remote download command failed with exit code {exit_code}: {error_text}"
-                )
-        except binascii.Error as exc:
-            raise FileTransferError(f"Remote command returned invalid base64: {exc}") from exc
-        finally:
-            stdout.close()
-            stderr.close()
-
-    return iterator()
-
-
-def _base64_decode_command() -> str:
-    return "base64 -d 2>/dev/null || base64 -D"
-
-
-def _remote_size(client: paramiko.SSHClient, remote_path: str) -> int:
-    with client.open_sftp() as sftp:
-        return int(sftp.stat(remote_path).st_size or 0)
-
-
-def filename_for_download(remote_path: str) -> str:
-    name = posixpath.basename(remote_path.rstrip("/")) or "download.bin"
-    return os.path.basename(name)