fix: go2rtc proxy ws upgrade

This commit is contained in:
2026-10-25 02:10:35 +01:00
parent d9f300c1e9
commit b9d497e993
8 changed files with 562 additions and 11 deletions
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
Binary file not shown.

After

Width:  |  Height:  |  Size: 3.4 KiB

+14
View File
@@ -0,0 +1,14 @@
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Kai-Sa-Cam</title>
<meta name="theme-color" content="#1a1a2e" />
<script type="module" crossorigin src="/assets/index-CG2sCz3I.js"></script>
<link rel="stylesheet" crossorigin href="/assets/index-1rRaNqus.css">
</head>
<body>
<div id="root"></div>
</body>
</html>
BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 331 KiB

+482
View File
@@ -0,0 +1,482 @@
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// src/server/index.ts
var import_express5 = __toESM(require("express"), 1);
var import_http_proxy_middleware = require("http-proxy-middleware");
var import_http = require("http");
var import_ws = require("ws");
var import_child_process2 = require("child_process");
var import_path3 = require("path");
// src/server/recorder.ts
var import_express = require("express");
var import_child_process = require("child_process");
var import_fs = require("fs");
var import_path = require("path");
var router = (0, import_express.Router)();
var MEDIA_DIR = process.env.MEDIA_DIR || "/media";
var CONFIG_DIR = process.env.CONFIG_DIR || "/config";
var GO2RTC_RTSP_URL = process.env.GO2RTC_RTSP_URL || "rtsp://kai-sa-go2rtc:8554/webcam";
var MAX_RECORDING_MINUTES = parseInt(process.env.MAX_RECORDING_MINUTES || "120", 10);
var DISK_MIN_FREE_GB = parseInt(process.env.DISK_MIN_FREE_GB || "2", 10);
var recordingProcess = null;
var recordingStartTime = null;
var currentRecordingFile = null;
if (!(0, import_fs.existsSync)(MEDIA_DIR)) {
(0, import_fs.mkdirSync)(MEDIA_DIR, { recursive: true });
}
function checkDiskSpace() {
try {
const stats = (0, import_fs.statSync)(MEDIA_DIR);
return true;
} catch {
return false;
}
}
function generateFilename(ext) {
const now = /* @__PURE__ */ new Date();
const timestamp = now.toISOString().replace(/[:.]/g, "-").split("T").join("_");
return `recording_${timestamp}.${ext}`;
}
function finalizeRecording(partPath) {
if (!partPath) return;
if (!(0, import_fs.existsSync)(partPath)) {
console.log("No part file to finalize");
return;
}
try {
const stats = (0, import_fs.statSync)(partPath);
if (stats.size < 1024) {
console.error(`Recording file too small (${stats.size} bytes), removing: ${partPath}`);
try {
(0, import_fs.unlinkSync)(partPath);
} catch {
}
return;
}
const finalPath = partPath.replace(/\.part$/, ".mp4");
(0, import_fs.renameSync)(partPath, finalPath);
console.log(`Recording saved: ${finalPath} (${stats.size} bytes)`);
} catch (e) {
console.error("Failed to finalize recording:", e);
}
}
router.post("/start", async (req, res) => {
if (recordingProcess) {
return res.status(409).json({ error: "Enregistrement d\xE9j\xE0 en cours" });
}
if (!checkDiskSpace()) {
return res.status(507).json({ error: "Espace disque insuffisant" });
}
const filename = generateFilename("part");
const filepath = (0, import_path.join)(MEDIA_DIR, filename);
currentRecordingFile = filepath;
recordingStartTime = Date.now();
const args = [
"-hide_banner",
"-loglevel",
"warning",
"-rtsp_transport",
"tcp",
"-fflags",
"+genpts",
"-use_wallclock_as_timestamps",
"1",
"-avoid_negative_ts",
"make_zero",
"-i",
GO2RTC_RTSP_URL,
"-c:v",
"libx264",
"-preset",
"ultrafast",
"-tune",
"zerolatency",
"-profile:v",
"baseline",
"-pix_fmt",
"yuv420p",
"-g",
"30",
"-an",
// no audio
"-f",
"mp4",
"-movflags",
"+frag_keyframe+empty_moov+default_base_moof",
"-t",
`${MAX_RECORDING_MINUTES * 60}`,
filepath
];
const ffmpegPath = process.env.FFMPEG_PATH || "ffmpeg";
console.log("Starting ffmpeg with args:", args.join(" "));
console.log("Working directory:", process.cwd());
console.log("User:", process.getuid?.() || "N/A");
recordingProcess = (0, import_child_process.spawn)(ffmpegPath, args, {
stdio: ["ignore", "pipe", "pipe"],
cwd: process.cwd()
});
recordingProcess.stdout?.on("data", (data) => {
console.log(`ffmpeg stdout: ${data}`);
});
recordingProcess.stderr?.on("data", (data) => {
const msg = data.toString();
if (msg.trim()) console.log(`ffmpeg stderr: ${msg}`);
});
recordingProcess.stdout?.resume();
recordingProcess.stderr?.resume();
recordingProcess.on("close", (code) => {
console.log(`Recording ffmpeg exited with code ${code}`);
const fileToFinalize = currentRecordingFile;
finalizeRecording(fileToFinalize);
recordingProcess = null;
currentRecordingFile = null;
recordingStartTime = null;
});
recordingProcess.on("error", (err) => {
console.error("Recording process error:", err);
const fileToFinalize = currentRecordingFile;
finalizeRecording(fileToFinalize);
recordingProcess = null;
currentRecordingFile = null;
recordingStartTime = null;
});
res.json({ status: "started", filename: currentRecordingFile.replace(/\.part$/, ".mp4") });
});
router.post("/stop", async (req, res) => {
if (!recordingProcess) {
return res.status(409).json({ error: "Aucun enregistrement en cours" });
}
const proc = recordingProcess;
const fileToFinalize = currentRecordingFile;
try {
proc.kill("SIGINT");
} catch (e) {
console.error("Error sending SIGINT:", e);
}
let waited = 0;
while (recordingProcess && waited < 15e3) {
await new Promise((r) => setTimeout(r, 100));
waited += 100;
}
if (recordingProcess) {
try {
recordingProcess.kill("SIGKILL");
} catch (e) {
console.error("Error sending SIGKILL:", e);
}
await new Promise((r) => setTimeout(r, 500));
recordingProcess = null;
currentRecordingFile = null;
recordingStartTime = null;
finalizeRecording(fileToFinalize);
return res.status(500).json({ error: "\xC9chec arr\xEAt enregistrement" });
}
res.json({ status: "stopped" });
});
router.get("/status", async (req, res) => {
res.json({
isRecording: !!recordingProcess,
startTime: recordingStartTime,
currentFile: currentRecordingFile?.replace(/\.part$/, ".mp4")
});
});
// src/server/media.ts
var import_express2 = require("express");
var import_fs2 = require("fs");
var import_path2 = require("path");
var import_archiver = __toESM(require("archiver"), 1);
var router2 = (0, import_express2.Router)();
var MEDIA_DIR2 = process.env.MEDIA_DIR || "/media";
var CONFIG_DIR2 = process.env.CONFIG_DIR || "/config";
if (!(0, import_fs2.existsSync)(MEDIA_DIR2)) {
require("fs").mkdirSync(MEDIA_DIR2, { recursive: true });
}
function getMediaType(filename) {
const ext = (0, import_path2.extname)(filename).toLowerCase();
if ([".mp4", ".webm", ".mov", ".mkv"].includes(ext)) return "video";
if ([".jpg", ".jpeg", ".png", ".webp", ".bmp"].includes(ext)) return "image";
return "other";
}
router2.get("/", async (req, res) => {
try {
const files = (0, import_fs2.readdirSync)(MEDIA_DIR2);
const media = files.filter((f) => getMediaType(f) !== "other").map((filename) => {
const filepath = (0, import_path2.join)(MEDIA_DIR2, filename);
const stats = (0, import_fs2.statSync)(filepath);
return {
filename,
type: getMediaType(filename),
size: stats.size,
mtime: stats.mtime.toISOString(),
url: `/api/media/${filename}`
};
}).sort((a, b) => new Date(b.mtime).getTime() - new Date(a.mtime).getTime());
res.json(media);
} catch (e) {
console.error("Media list error:", e);
res.status(500).json({ error: "Failed to list media" });
}
});
router2.get("/:filename", async (req, res) => {
const { filename } = req.params;
const filepath = (0, import_path2.join)(MEDIA_DIR2, filename);
if (!(0, import_fs2.existsSync)(filepath)) {
return res.status(404).json({ error: "File not found" });
}
const resolved = require("path").resolve(filepath);
if (!resolved.startsWith(require("path").resolve(MEDIA_DIR2))) {
return res.status(403).json({ error: "Forbidden" });
}
const stats = (0, import_fs2.statSync)(filepath);
const download = req.query.download === "1";
if (download) {
res.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
}
res.setHeader("Content-Length", stats.size);
res.setHeader("Accept-Ranges", "bytes");
const range = req.headers.range;
if (range) {
const parts = range.replace(/bytes=/, "").split("-");
const start = parseInt(parts[0], 10);
const end = parts[1] ? parseInt(parts[1], 10) : stats.size - 1;
const chunksize = end - start + 1;
res.status(206);
res.setHeader("Content-Range", `bytes ${start}-${end}/${stats.size}`);
res.setHeader("Content-Length", chunksize);
const stream2 = (0, import_fs2.createReadStream)(filepath, { start, end });
return stream2.pipe(res);
}
const stream = (0, import_fs2.createReadStream)(filepath);
stream.pipe(res);
});
router2.post("/snapshots", async (req, res) => {
const { spawn: spawn3 } = await import("child_process");
const GO2RTC_RTSP_URL2 = process.env.GO2RTC_RTSP_URL || "rtsp://kai-sa-go2rtc:8554/webcam";
const MEDIA_DIR3 = process.env.MEDIA_DIR || "/media";
const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").split("T").join("_");
const filename = `snapshot_${timestamp}.jpg`;
const filepath = (0, import_path2.join)(MEDIA_DIR3, filename);
const ffmpegPath = process.env.FFMPEG_PATH || "ffmpeg";
const args = [
"-hide_banner",
"-loglevel",
"warning",
"-rtsp_transport",
"tcp",
"-i",
GO2RTC_RTSP_URL2,
"-frames:v",
"1",
"-q:v",
"2",
"-update",
"1",
filepath
];
const child = spawn3(ffmpegPath, args);
return new Promise((resolve, reject) => {
let stderr = "";
child.stderr?.on("data", (data) => {
stderr += data.toString();
});
child.on("close", (code) => {
if (code === 0) {
res.json({ filename });
resolve();
} else {
console.error("Snapshot ffmpeg failed:", stderr);
res.status(500).json({ error: "Snapshot failed", details: stderr });
reject(new Error("Snapshot failed"));
}
});
child.on("error", (err) => {
res.status(500).json({ error: "Snapshot error", details: err.message });
reject(err);
});
});
});
router2.delete("/:filename", async (req, res) => {
const { filename } = req.params;
const filepath = (0, import_path2.join)(MEDIA_DIR2, filename);
if (!(0, import_fs2.existsSync)(filepath)) {
return res.status(404).json({ error: "File not found" });
}
const resolved = require("path").resolve(filepath);
if (!resolved.startsWith(require("path").resolve(MEDIA_DIR2))) {
return res.status(403).json({ error: "Forbidden" });
}
try {
(0, import_fs2.unlinkSync)(filepath);
res.json({ status: "deleted" });
} catch (e) {
console.error("Delete error:", e);
res.status(500).json({ error: "Failed to delete" });
}
});
router2.post("/export", async (req, res) => {
try {
const files = (0, import_fs2.readdirSync)(MEDIA_DIR2).filter((f) => getMediaType(f) !== "other");
if (files.length === 0) {
return res.status(404).json({ error: "No media to export" });
}
const archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } });
let completed = false;
let aborted = false;
res.setHeader("Content-Type", "application/zip");
res.setHeader("Content-Disposition", `attachment; filename="kai-sa-cam-media-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.zip"`);
archive.on("error", (err) => {
console.error("Archive error:", err);
if (!completed) {
res.status(500).json({ error: "Archive creation failed" });
}
});
archive.on("end", () => {
completed = true;
console.log("Archive completed");
setTimeout(() => {
for (const file of files) {
try {
const filepath = (0, import_path2.join)(MEDIA_DIR2, file);
if ((0, import_fs2.existsSync)(filepath)) {
(0, import_fs2.unlinkSync)(filepath);
console.log(`Deleted after export: ${file}`);
}
} catch (e) {
console.error(`Failed to delete ${file}:`, e);
}
}
}, 100);
});
req.on("aborted", () => {
aborted = true;
console.log("Export aborted by client");
});
res.on("close", () => {
if (!res.writableFinished) {
aborted = true;
console.log("Export connection closed prematurely");
}
});
archive.pipe(res);
for (const file of files) {
const filepath = (0, import_path2.join)(MEDIA_DIR2, file);
if ((0, import_fs2.existsSync)(filepath)) {
archive.file(filepath, { name: file });
}
}
await archive.finalize();
} catch (e) {
console.error("Export error:", e);
if (!res.headersSent) {
res.status(500).json({ error: "Export failed" });
}
}
});
// src/server/talk.ts
var import_express3 = require("express");
var router3 = (0, import_express3.Router)();
router3.get("/status", async (req, res) => {
res.json({ status: "ok", message: "Talk endpoint available at /api/talk WebSocket" });
});
// src/server/health.ts
var import_express4 = require("express");
var router4 = (0, import_express4.Router)();
router4.get("/health", async (req, res) => {
res.json({ status: "ok", service: "kai-sa-cam", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
});
// src/server/index.ts
var __dirname = process.cwd();
var app = (0, import_express5.default)();
var PORT = process.env.PORT || 8090;
app.use(import_express5.default.json({ limit: "10mb" }));
app.use(import_express5.default.urlencoded({ extended: true }));
app.use(import_express5.default.static((0, import_path3.join)(__dirname, "dist")));
var go2rtcProxy = (0, import_http_proxy_middleware.createProxyMiddleware)({
target: process.env.GO2RTC_URL || "http://kai-sa-go2rtc:1984",
changeOrigin: true,
ws: true,
pathRewrite: {
"^/go2rtc": ""
}
});
app.use("/go2rtc", go2rtcProxy);
app.use("/api/recordings", router);
app.use("/api/media", router2);
app.use("/api/talk", router3);
app.use("/api", router4);
app.get("*", (req, res, next) => {
if (req.path.startsWith("/api") || req.path.startsWith("/go2rtc")) {
return next();
}
res.sendFile((0, import_path3.join)(__dirname, "dist/index.html"));
});
var server = (0, import_http.createServer)(app);
server.on("upgrade", (req, socket, head) => {
if (req.url?.startsWith("/go2rtc")) {
go2rtcProxy.upgrade(req, socket, head);
}
});
var wss = new import_ws.WebSocketServer({ server, path: "/api/talk" });
wss.on("connection", (ws, _req) => {
console.log("Talk WS connection established");
let paplayProcess = null;
ws.on("message", (data, isBinary) => {
if (!isBinary) {
try {
const msg = JSON.parse(data.toString());
if (msg.rate && !paplayProcess) {
paplayProcess = (0, import_child_process2.spawn)("paplay", [
"--raw",
`--rate=${msg.rate}`,
"--format=s16le",
"--channels=1",
"--latency-msec=150"
]);
paplayProcess.on("error", (e) => console.error("paplay error:", e.message));
}
} catch (e) {
console.error("Talk WS message parse error:", e);
}
return;
}
if (paplayProcess?.stdin) {
paplayProcess.stdin.write(data);
}
});
ws.on("close", () => {
if (paplayProcess) {
paplayProcess.stdin.end();
paplayProcess = null;
}
});
});
server.listen(PORT, () => {
console.log(`kai-sa-cam server running on port ${PORT}`);
});
+11 -11
View File
@@ -23,22 +23,16 @@ app.use(express.urlencoded({ extended: true }))
app.use(express.static(join(__dirname, 'dist')))
// Proxy go2rtc requests
const proxyConfig = {
const go2rtcProxy = createProxyMiddleware({
target: process.env.GO2RTC_URL || 'http://kai-sa-go2rtc:1984',
changeOrigin: true,
ws: true,
onProxyReq: (proxyReq: any, _req: any, _res: any) => {
// Add basic auth if credentials provided
const user = process.env.GO2RTC_USERNAME
const pass = process.env.GO2RTC_PASSWORD
if (user && pass) {
const auth = Buffer.from(`${user}:${pass}`).toString('base64')
proxyReq.setHeader('Authorization', `Basic ${auth}`)
}
pathRewrite: {
'^/go2rtc': '',
},
}
})
app.use('/go2rtc', createProxyMiddleware(proxyConfig))
app.use('/go2rtc', go2rtcProxy)
// API routes
app.use('/api/recordings', recorderRouter)
@@ -56,6 +50,12 @@ app.get('*', (req, res, next) => {
const server = createServer(app)
server.on('upgrade', (req: any, socket: any, head: any) => {
if (req.url?.startsWith('/go2rtc')) {
go2rtcProxy.upgrade(req, socket, head)
}
})
// WebSocket server for talk
const wss = new WebSocketServer({ server, path: '/api/talk' })