mirror of
https://github.com/khoaliber/dockhand.git
synced 2026-03-02 13:17:57 +00:00
proper src structure, dockerfile, entrypoint
This commit is contained in:
jarek
996
vite.config.ts
Normal file
996
vite.config.ts
Normal file
@@ -0,0 +1,996 @@
|
||||
import { sveltekit } from '@sveltejs/kit/vite';
|
||||
import tailwindcss from '@tailwindcss/vite';
|
||||
import { defineConfig, type Plugin } from 'vite';
|
||||
import { execSync } from 'child_process';
|
||||
import { existsSync } from 'fs';
|
||||
import { homedir } from 'os';
|
||||
import { join } from 'path';
|
||||
import { Database } from 'bun:sqlite';
|
||||
|
||||
const WS_PORT = 5174;
|
||||
|
||||
// ============ Docker Target Types ============
|
||||
|
||||
interface DockerTarget {
|
||||
type: 'unix' | 'tcp' | 'hawser-edge';
|
||||
socket?: string;
|
||||
host?: string;
|
||||
port?: number;
|
||||
hawserToken?: string;
|
||||
environmentId?: number;
|
||||
}
|
||||
|
||||
interface EnvironmentRow {
|
||||
id: number;
|
||||
is_local?: boolean | number;
|
||||
connection_type?: string;
|
||||
socket_path?: string;
|
||||
host?: string;
|
||||
port?: number;
|
||||
hawser_token?: string;
|
||||
}
|
||||
|
||||
// ============ Docker Target Resolution ============
|
||||
|
||||
function resolveDockerTarget(
|
||||
envId: number | undefined,
|
||||
getEnvironment: (id: number) => EnvironmentRow | null,
|
||||
defaultSocketPath: string
|
||||
): DockerTarget {
|
||||
if (!envId) return { type: 'unix', socket: defaultSocketPath };
|
||||
|
||||
const env = getEnvironment(envId);
|
||||
if (!env) return { type: 'unix', socket: defaultSocketPath };
|
||||
|
||||
const isLocal = typeof env.is_local === 'boolean' ? env.is_local : Boolean(env.is_local);
|
||||
if (isLocal || env.connection_type === 'socket' || !env.connection_type) {
|
||||
return { type: 'unix', socket: env.socket_path || defaultSocketPath };
|
||||
}
|
||||
|
||||
if (env.connection_type === 'hawser-edge') {
|
||||
return { type: 'hawser-edge', environmentId: envId };
|
||||
}
|
||||
|
||||
return {
|
||||
type: 'tcp',
|
||||
host: env.host || 'localhost',
|
||||
port: env.port || 2375,
|
||||
hawserToken: env.connection_type === 'hawser-standard' ? env.hawser_token : undefined
|
||||
};
|
||||
}
|
||||
|
||||
// ============ Exec API Helpers ============
|
||||
|
||||
function buildExecStartHttpRequest(execId: string, target: DockerTarget): string {
|
||||
const body = JSON.stringify({ Detach: false, Tty: true });
|
||||
const tokenHeader = target.type === 'tcp' && target.hawserToken
|
||||
? `X-Hawser-Token: ${target.hawserToken}\r\n`
|
||||
: '';
|
||||
return `POST /exec/${execId}/start HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\n${tokenHeader}Connection: Upgrade\r\nUpgrade: tcp\r\nContent-Length: ${body.length}\r\n\r\n${body}`;
|
||||
}
|
||||
|
||||
// ============ Stream Processing ============
|
||||
|
||||
function processTerminalOutput(
|
||||
data: string,
|
||||
state: { headersStripped: boolean; isChunked: boolean }
|
||||
): string | null {
|
||||
let text = data;
|
||||
|
||||
if (!state.headersStripped) {
|
||||
if (text.toLowerCase().includes('transfer-encoding: chunked')) {
|
||||
state.isChunked = true;
|
||||
}
|
||||
const headerEnd = text.indexOf('\r\n\r\n');
|
||||
if (headerEnd > -1) {
|
||||
text = text.slice(headerEnd + 4);
|
||||
state.headersStripped = true;
|
||||
} else if (text.startsWith('HTTP/')) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
if (state.isChunked && text) {
|
||||
text = text.replace(/^[0-9a-fA-F]+\r\n/gm, '').replace(/\r\n$/g, '');
|
||||
}
|
||||
|
||||
return text || null;
|
||||
}
|
||||
|
||||
// ============ Hawser Edge Exec Messages ============
|
||||
|
||||
function createExecStartMessage(execId: string, containerId: string, shell: string, user: string, cols = 120, rows = 30) {
|
||||
return { type: 'exec_start', execId, containerId, cmd: shell, user, cols, rows };
|
||||
}
|
||||
|
||||
function createExecInputMessage(execId: string, data: string) {
|
||||
return { type: 'exec_input', execId, data: Buffer.from(data).toString('base64') };
|
||||
}
|
||||
|
||||
function createExecResizeMessage(execId: string, cols: number, rows: number) {
|
||||
return { type: 'exec_resize', execId, cols, rows };
|
||||
}
|
||||
|
||||
function createExecEndMessage(execId: string, reason = 'user_closed') {
|
||||
return { type: 'exec_end', execId, reason };
|
||||
}
|
||||
|
||||
// Get build info
|
||||
function getGitCommit(): string | null {
|
||||
// Check COMMIT file (created by CI/CD before docker build)
|
||||
try {
|
||||
if (existsSync('COMMIT')) {
|
||||
const commit = require('fs').readFileSync('COMMIT', 'utf-8').trim();
|
||||
if (commit && commit !== 'unknown') {
|
||||
return commit;
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
// Fall back to git command (local dev)
|
||||
try {
|
||||
return execSync('git rev-parse --short HEAD').toString().trim();
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function getGitBranch(): string | null {
|
||||
// Check BRANCH file (created by CI/CD before docker build)
|
||||
try {
|
||||
if (existsSync('BRANCH')) {
|
||||
const branch = require('fs').readFileSync('BRANCH', 'utf-8').trim();
|
||||
if (branch && branch !== 'unknown') {
|
||||
return branch;
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
// Fall back to git command (local dev)
|
||||
try {
|
||||
return execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function getGitTag(): string | null {
|
||||
// First check env var (set by CI/CD via Docker build-arg)
|
||||
if (process.env.APP_VERSION) {
|
||||
return process.env.APP_VERSION;
|
||||
}
|
||||
// Check VERSION file (created by CI/CD before docker build)
|
||||
try {
|
||||
if (existsSync('VERSION')) {
|
||||
const version = require('fs').readFileSync('VERSION', 'utf-8').trim();
|
||||
if (version && version !== 'unknown') {
|
||||
return version;
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
// Fall back to git tag (local dev)
|
||||
try {
|
||||
return execSync('git describe --tags --abbrev=0 2>/dev/null').toString().trim();
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// Plugin to externalize bun: protocol modules
|
||||
function bunExternals(): Plugin {
|
||||
return {
|
||||
name: 'bun-externals',
|
||||
enforce: 'pre',
|
||||
resolveId(source) {
|
||||
if (source.startsWith('bun:')) {
|
||||
return { id: source, external: true };
|
||||
}
|
||||
return null;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Detect Docker socket path
|
||||
function detectDockerSocket(): string {
|
||||
if (process.env.DOCKER_SOCKET && existsSync(process.env.DOCKER_SOCKET)) return process.env.DOCKER_SOCKET;
|
||||
if (process.env.DOCKER_HOST?.startsWith('unix://')) {
|
||||
const p = process.env.DOCKER_HOST.replace('unix://', '');
|
||||
if (existsSync(p)) return p;
|
||||
}
|
||||
const candidates = [
|
||||
'/var/run/docker.sock',
|
||||
join(homedir(), '.docker/run/docker.sock'),
|
||||
join(homedir(), '.orbstack/run/docker.sock'),
|
||||
'/run/docker.sock'
|
||||
];
|
||||
for (const s of candidates) {
|
||||
if (existsSync(s)) return s;
|
||||
}
|
||||
return '/var/run/docker.sock';
|
||||
}
|
||||
|
||||
// Lazy database connection for environment lookup
|
||||
let _db: Database | null = null;
|
||||
function getDb(): Database | null {
|
||||
if (!_db) {
|
||||
// Database is in data/db/dockhand.db (same as main app)
|
||||
const dbPath = join(process.cwd(), 'data', 'db', 'dockhand.db');
|
||||
if (existsSync(dbPath)) {
|
||||
_db = new Database(dbPath, { readonly: true });
|
||||
}
|
||||
}
|
||||
return _db;
|
||||
}
|
||||
|
||||
function getEnvironment(id: number): { host: string; port: number; is_local: boolean; connection_type?: string; hawser_token?: string } | null {
|
||||
const db = getDb();
|
||||
if (!db) return null;
|
||||
const row = db.prepare('SELECT * FROM environments WHERE id = ?').get(id) as any;
|
||||
return row ? { ...row, is_local: Boolean(row.is_local) } : null;
|
||||
}
|
||||
|
||||
function getDockerTarget(envId?: number): DockerTarget {
|
||||
const dockerSocketPath = detectDockerSocket();
|
||||
return resolveDockerTarget(
|
||||
envId,
|
||||
(id) => getEnvironment(id) as EnvironmentRow | null,
|
||||
dockerSocketPath
|
||||
);
|
||||
}
|
||||
|
||||
async function createExecForWs(containerId: string, cmd: string[], user: string, target: ReturnType<typeof getDockerTarget>): Promise<{ Id: string }> {
|
||||
const headers: Record<string, string> = { 'Content-Type': 'application/json' };
|
||||
const fetchOpts: any = {
|
||||
method: 'POST',
|
||||
headers,
|
||||
body: JSON.stringify({ AttachStdin: true, AttachStdout: true, AttachStderr: true, Tty: true, Cmd: cmd, User: user })
|
||||
};
|
||||
let url: string;
|
||||
if (target.type === 'unix') {
|
||||
url = 'http://localhost/containers/' + containerId + '/exec';
|
||||
fetchOpts.unix = target.socket;
|
||||
} else {
|
||||
url = 'http://' + target.host + ':' + target.port + '/containers/' + containerId + '/exec';
|
||||
if (target.hawserToken) {
|
||||
headers['X-Hawser-Token'] = target.hawserToken;
|
||||
}
|
||||
}
|
||||
const res = await fetch(url, fetchOpts);
|
||||
if (!res.ok) throw new Error('Failed to create exec: ' + (await res.text()));
|
||||
return res.json();
|
||||
}
|
||||
|
||||
async function resizeExecForWs(execId: string, cols: number, rows: number, target: ReturnType<typeof getDockerTarget>): Promise<void> {
|
||||
try {
|
||||
const fetchOpts: any = { method: 'POST' };
|
||||
let url: string;
|
||||
if (target.type === 'unix') {
|
||||
url = 'http://localhost/exec/' + execId + '/resize?h=' + rows + '&w=' + cols;
|
||||
fetchOpts.unix = target.socket;
|
||||
} else {
|
||||
url = 'http://' + target.host + ':' + target.port + '/exec/' + execId + '/resize?h=' + rows + '&w=' + cols;
|
||||
if (target.hawserToken) {
|
||||
fetchOpts.headers = { 'X-Hawser-Token': target.hawserToken };
|
||||
}
|
||||
}
|
||||
await fetch(url, fetchOpts);
|
||||
} catch {
|
||||
// Ignore resize errors
|
||||
}
|
||||
}
|
||||
|
||||
// Map to track Docker streams per WebSocket (keyed by unique connection ID)
|
||||
// Includes WebSocket reference for orphan detection
|
||||
const dockerStreams = new Map<string, { stream: any; execId: string; target: ReturnType<typeof getDockerTarget>; state: { isChunked: boolean }; ws: any }>();
|
||||
|
||||
// Counter for unique WebSocket connection IDs
|
||||
let wsConnectionCounter = 0;
|
||||
|
||||
// Map to track Edge exec sessions (execId -> frontend WebSocket)
|
||||
const edgeExecSessions = new Map<string, { ws: any; execId: string; environmentId: number }>();
|
||||
|
||||
// Cleanup interval reference - only started in dev mode
|
||||
let cleanupInterval: ReturnType<typeof setInterval> | null = null;
|
||||
|
||||
// Cleanup function for orphaned sessions
|
||||
function startCleanupInterval() {
|
||||
if (cleanupInterval) return; // Already running
|
||||
|
||||
// Cleanup orphaned sessions every 5 minutes to prevent memory leaks
|
||||
// Only removes sessions where the WebSocket is no longer open (readyState !== 1)
|
||||
// This catches sessions where close handlers failed to fire
|
||||
cleanupInterval = setInterval(() => {
|
||||
let dockerCleaned = 0;
|
||||
let edgeCleaned = 0;
|
||||
|
||||
for (const [connId, session] of dockerStreams.entries()) {
|
||||
// readyState: 0=CONNECTING, 1=OPEN, 2=CLOSING, 3=CLOSED
|
||||
if (session.ws?.readyState !== 1) {
|
||||
try {
|
||||
session.stream?.end?.();
|
||||
} catch { /* ignore */ }
|
||||
dockerStreams.delete(connId);
|
||||
dockerCleaned++;
|
||||
}
|
||||
}
|
||||
|
||||
for (const [execId, session] of edgeExecSessions.entries()) {
|
||||
if (session.ws?.readyState !== 1) {
|
||||
edgeExecSessions.delete(execId);
|
||||
edgeCleaned++;
|
||||
}
|
||||
}
|
||||
|
||||
if (dockerCleaned > 0 || edgeCleaned > 0) {
|
||||
console.log(`[WS Cleanup] Removed ${dockerCleaned} orphaned docker streams, ${edgeCleaned} orphaned edge sessions`);
|
||||
}
|
||||
}, 5 * 60 * 1000);
|
||||
}
|
||||
|
||||
// Hawser Edge connection types (mirrors hawser.ts)
|
||||
interface EdgeConnection {
|
||||
ws: WebSocket;
|
||||
environmentId: number;
|
||||
agentId: string;
|
||||
agentName: string;
|
||||
agentVersion: string;
|
||||
dockerVersion: string;
|
||||
hostname: string;
|
||||
capabilities: string[];
|
||||
connectedAt: Date;
|
||||
lastHeartbeat: Date;
|
||||
pendingRequests: Map<string, { resolve: Function; reject: Function; timeout: NodeJS.Timeout }>;
|
||||
pendingStreamRequests: Map<string, { onData: Function; onEnd: Function; onError: Function }>;
|
||||
pingInterval?: ReturnType<typeof setInterval>; // Server-side ping to keep connection alive through proxies
|
||||
}
|
||||
|
||||
// Container event from edge agent (matches hawser.ts)
|
||||
interface ContainerEventData {
|
||||
containerId: string;
|
||||
containerName?: string;
|
||||
image?: string;
|
||||
action: string;
|
||||
actorAttributes?: Record<string, string>;
|
||||
timestamp: string;
|
||||
}
|
||||
|
||||
// Metrics data structure from Hawser agent
|
||||
interface HawserMetrics {
|
||||
cpuUsage: number;
|
||||
cpuCores: number;
|
||||
memoryTotal: number;
|
||||
memoryUsed: number;
|
||||
memoryFree: number;
|
||||
diskTotal: number;
|
||||
diskUsed: number;
|
||||
diskFree: number;
|
||||
networkRxBytes: number;
|
||||
networkTxBytes: number;
|
||||
}
|
||||
|
||||
// Use globalThis to share connections with hawser.ts module
|
||||
declare global {
|
||||
var __hawserEdgeConnections: Map<number, EdgeConnection> | undefined;
|
||||
var __hawserSendMessage: ((envId: number, message: string) => boolean) | undefined;
|
||||
var __hawserHandleContainerEvent: ((envId: number, event: ContainerEventData) => Promise<void>) | undefined;
|
||||
var __hawserHandleMetrics: ((envId: number, metrics: HawserMetrics) => Promise<void>) | undefined;
|
||||
}
|
||||
const edgeConnections: Map<number, EdgeConnection> =
|
||||
globalThis.__hawserEdgeConnections ?? (globalThis.__hawserEdgeConnections = new Map());
|
||||
|
||||
// Function to send messages through the WebSocket (needed because ws.send must be called from vite context)
|
||||
globalThis.__hawserSendMessage = (envId: number, message: string): boolean => {
|
||||
const conn = edgeConnections.get(envId);
|
||||
if (!conn || !conn.ws) {
|
||||
return false;
|
||||
}
|
||||
|
||||
try {
|
||||
conn.ws.send(message);
|
||||
return true;
|
||||
} catch (e) {
|
||||
console.error(`[Hawser WS] sendMessage error:`, e);
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
// Map WebSocket to environmentId for quick lookup on close/message
|
||||
const wsToEnvId = new Map<any, number>();
|
||||
|
||||
// WebSocket server for terminal connections and Hawser Edge in development mode
|
||||
function webSocketPlugin(): Plugin {
|
||||
return {
|
||||
name: 'websocket',
|
||||
configureServer() {
|
||||
// Start cleanup interval for dev mode only
|
||||
startCleanupInterval();
|
||||
|
||||
const dockerSocketPath = detectDockerSocket();
|
||||
console.log(`[Terminal WS] Detected Docker socket at: ${dockerSocketPath}`);
|
||||
|
||||
// Start a Bun.serve WebSocket server on a separate port
|
||||
Bun.serve({
|
||||
port: WS_PORT,
|
||||
fetch(req, server) {
|
||||
// Upgrade HTTP requests to WebSocket
|
||||
if (server.upgrade(req, { data: { url: req.url } })) {
|
||||
return; // Return nothing if upgrade succeeds
|
||||
}
|
||||
return new Response('WebSocket server', { status: 200 });
|
||||
},
|
||||
websocket: {
|
||||
async open(ws) {
|
||||
const url = new URL((ws.data as any).url, `http://localhost:${WS_PORT}`);
|
||||
|
||||
// Check if this is a Hawser Edge connection
|
||||
if (url.pathname === '/api/hawser/connect') {
|
||||
console.log('[Hawser WS] New connection pending authentication');
|
||||
// Hawser connections wait for hello message to authenticate
|
||||
return;
|
||||
}
|
||||
|
||||
// Assign unique connection ID to this WebSocket
|
||||
const connId = `ws-${++wsConnectionCounter}`;
|
||||
(ws.data as any).connId = connId;
|
||||
|
||||
// Terminal connection handling
|
||||
const pathParts = url.pathname.split('/');
|
||||
const containerIdIndex = pathParts.indexOf('containers') + 1;
|
||||
const containerId = pathParts[containerIdIndex];
|
||||
|
||||
const shell = url.searchParams.get('shell') || '/bin/sh';
|
||||
const user = url.searchParams.get('user') || 'root';
|
||||
const envIdParam = url.searchParams.get('envId');
|
||||
const envId = envIdParam ? parseInt(envIdParam, 10) : undefined;
|
||||
|
||||
if (!containerId) {
|
||||
ws.send(JSON.stringify({ type: 'error', message: 'No container ID' }));
|
||||
ws.close();
|
||||
return;
|
||||
}
|
||||
|
||||
const target = getDockerTarget(envId);
|
||||
console.log('[Terminal WS] Open connId:', connId, 'container:', containerId, 'target:', target.type);
|
||||
|
||||
try {
|
||||
// Handle Hawser Edge mode differently - use WebSocket protocol
|
||||
if (target.type === 'hawser-edge') {
|
||||
const conn = edgeConnections.get(target.environmentId);
|
||||
if (!conn) {
|
||||
ws.send(JSON.stringify({ type: 'error', message: 'Edge agent not connected' }));
|
||||
ws.close();
|
||||
return;
|
||||
}
|
||||
|
||||
// Generate unique exec ID
|
||||
const execId = crypto.randomUUID();
|
||||
console.log('[Terminal WS] Starting Edge exec:', execId, 'container:', containerId);
|
||||
|
||||
// Track this session
|
||||
edgeExecSessions.set(execId, { ws, execId, environmentId: target.environmentId });
|
||||
(ws.data as any).edgeExecId = execId;
|
||||
|
||||
// Send exec_start to the agent (using shared helper)
|
||||
const execStartMsg = createExecStartMessage(execId, containerId, shell, user);
|
||||
conn.ws.send(JSON.stringify(execStartMsg));
|
||||
return;
|
||||
}
|
||||
|
||||
// Direct Docker connection (unix or tcp/hawser-standard)
|
||||
const exec = await createExecForWs(containerId, [shell], user, target);
|
||||
const execId = exec.Id;
|
||||
|
||||
// Track connection state (using object for mutability across closures)
|
||||
let headersStripped = false;
|
||||
const state = { isChunked: false };
|
||||
|
||||
// Create socket handler for Docker connection
|
||||
const socketHandler = {
|
||||
data(socket: any, data: Buffer) {
|
||||
if (ws.readyState === 1) {
|
||||
let text = new TextDecoder().decode(data);
|
||||
// Skip HTTP headers in first response (only once)
|
||||
if (!headersStripped) {
|
||||
// Check for chunked encoding in headers
|
||||
if (text.toLowerCase().includes('transfer-encoding: chunked')) {
|
||||
state.isChunked = true;
|
||||
}
|
||||
const headerEnd = text.indexOf('\r\n\r\n');
|
||||
if (headerEnd > -1) {
|
||||
text = text.slice(headerEnd + 4);
|
||||
headersStripped = true;
|
||||
} else if (text.startsWith('HTTP/')) {
|
||||
// Headers split across packets, skip this entire packet
|
||||
return;
|
||||
}
|
||||
}
|
||||
// Strip chunked encoding framing if detected
|
||||
if (state.isChunked && text) {
|
||||
// Remove chunk size lines (hex number followed by \r\n)
|
||||
text = text.replace(/^[0-9a-fA-F]+\r\n/gm, '').replace(/\r\n$/g, '');
|
||||
}
|
||||
if (text) {
|
||||
ws.send(JSON.stringify({ type: 'output', data: text }));
|
||||
}
|
||||
}
|
||||
},
|
||||
close() {
|
||||
if (ws.readyState === 1) {
|
||||
ws.send(JSON.stringify({ type: 'exit' }));
|
||||
ws.close();
|
||||
}
|
||||
},
|
||||
error() {},
|
||||
open(socket: any) {
|
||||
// Send exec start request (using shared helper)
|
||||
const httpRequest = buildExecStartHttpRequest(execId, target);
|
||||
socket.write(httpRequest);
|
||||
}
|
||||
};
|
||||
|
||||
let dockerStream: any;
|
||||
if (target.type === 'unix') {
|
||||
dockerStream = await Bun.connect({ unix: target.socket, socket: socketHandler });
|
||||
} else if (target.type === 'tcp') {
|
||||
dockerStream = await Bun.connect({ hostname: target.host, port: target.port, socket: socketHandler });
|
||||
}
|
||||
|
||||
dockerStreams.set(connId, { stream: dockerStream, execId, target, state, ws });
|
||||
console.log('[Terminal WS] Stream stored for connId:', connId, 'total streams:', dockerStreams.size);
|
||||
} catch (error: any) {
|
||||
console.error('[Terminal WS] Error:', error.message);
|
||||
ws.send(JSON.stringify({ type: 'error', message: error.message }));
|
||||
ws.close();
|
||||
}
|
||||
},
|
||||
async message(ws, message) {
|
||||
const url = new URL((ws.data as any).url, `http://localhost:${WS_PORT}`);
|
||||
const connId = (ws.data as any).connId as string | undefined;
|
||||
console.log('[WS Message] connId:', connId, 'edgeExecId:', (ws.data as any)?.edgeExecId, 'pathname:', url.pathname.slice(0, 50));
|
||||
|
||||
// Handle Hawser Edge messages
|
||||
if (url.pathname === '/api/hawser/connect') {
|
||||
try {
|
||||
// Debug: Log raw message info
|
||||
const msgType = typeof message;
|
||||
const msgLen = typeof message === 'string' ? message.length :
|
||||
message instanceof ArrayBuffer ? message.byteLength :
|
||||
(message as Buffer).length || 0;
|
||||
console.log(`[Hawser WS] Received message: type=${msgType}, length=${msgLen}`);
|
||||
|
||||
// Convert message to string properly (handles both string and ArrayBuffer)
|
||||
let messageStr: string;
|
||||
if (typeof message === 'string') {
|
||||
messageStr = message;
|
||||
} else if (message instanceof ArrayBuffer) {
|
||||
messageStr = new TextDecoder().decode(message);
|
||||
} else if (Buffer.isBuffer(message)) {
|
||||
messageStr = message.toString('utf-8');
|
||||
} else {
|
||||
// Uint8Array or similar
|
||||
messageStr = new TextDecoder().decode(new Uint8Array(message as ArrayBuffer));
|
||||
}
|
||||
|
||||
console.log(`[Hawser WS] Decoded string length: ${messageStr.length}`);
|
||||
if (messageStr.length > 0) {
|
||||
console.log(`[Hawser WS] First 200 chars: ${messageStr.slice(0, 200)}`);
|
||||
}
|
||||
|
||||
const msg = JSON.parse(messageStr);
|
||||
console.log(`[Hawser WS] Parsed message type: ${msg.type}`);
|
||||
await handleHawserMessage(ws, msg);
|
||||
} catch (error: any) {
|
||||
console.error('[Hawser WS] Error handling message:', error.message);
|
||||
// More detailed debug output
|
||||
const msgType = typeof message;
|
||||
const msgLen = typeof message === 'string' ? message.length :
|
||||
message instanceof ArrayBuffer ? message.byteLength :
|
||||
(message as Buffer).length || 0;
|
||||
console.error(`[Hawser WS] Message details: type=${msgType}, length=${msgLen}`);
|
||||
if (typeof message === 'string' && message.length > 0) {
|
||||
console.error(`[Hawser WS] Message preview: ${message.slice(0, 500)}`);
|
||||
} else if (message instanceof ArrayBuffer && message.byteLength > 0) {
|
||||
const preview = new TextDecoder().decode(message.slice(0, 500));
|
||||
console.error(`[Hawser WS] ArrayBuffer preview: ${preview}`);
|
||||
} else if (Buffer.isBuffer(message) && message.length > 0) {
|
||||
console.error(`[Hawser WS] Buffer preview: ${message.toString('utf-8').slice(0, 500)}`);
|
||||
}
|
||||
ws.send(JSON.stringify({ type: 'error', error: error.message }));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if this is an Edge exec session
|
||||
const edgeExecId = (ws.data as any)?.edgeExecId;
|
||||
if (edgeExecId) {
|
||||
const session = edgeExecSessions.get(edgeExecId);
|
||||
if (session) {
|
||||
const conn = edgeConnections.get(session.environmentId);
|
||||
if (conn) {
|
||||
try {
|
||||
const msg = JSON.parse(message.toString());
|
||||
if (msg.type === 'input') {
|
||||
// Forward input to agent (using shared helper)
|
||||
conn.ws.send(JSON.stringify(createExecInputMessage(edgeExecId, msg.data)));
|
||||
} else if (msg.type === 'resize') {
|
||||
// Forward resize to agent (using shared helper)
|
||||
conn.ws.send(JSON.stringify(createExecResizeMessage(edgeExecId, msg.cols, msg.rows)));
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('[Terminal WS] Error handling Edge message:', e);
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Terminal message handling (direct Docker connection)
|
||||
if (!connId) {
|
||||
console.log('[Terminal WS] No connId for terminal message');
|
||||
return;
|
||||
}
|
||||
const d = dockerStreams.get(connId);
|
||||
if (!d) {
|
||||
console.log('[Terminal WS] No stream for connId:', connId, 'streams:', [...dockerStreams.keys()]);
|
||||
return;
|
||||
}
|
||||
console.log('[Terminal WS] Found stream for connId:', connId);
|
||||
|
||||
try {
|
||||
const msg = JSON.parse(message.toString());
|
||||
if (msg.type === 'input' && d.stream) {
|
||||
// Always write raw input - chunked encoding only affects reading output
|
||||
d.stream.write(msg.data);
|
||||
} else if (msg.type === 'resize' && d.execId) {
|
||||
resizeExecForWs(d.execId, msg.cols, msg.rows, d.target);
|
||||
}
|
||||
} catch {
|
||||
// If not JSON, treat as raw input
|
||||
if (d.stream) {
|
||||
d.stream.write(message);
|
||||
}
|
||||
}
|
||||
},
|
||||
close(ws) {
|
||||
// Check if it's a Hawser connection
|
||||
const envId = wsToEnvId.get(ws);
|
||||
if (envId) {
|
||||
const conn = edgeConnections.get(envId);
|
||||
if (conn) {
|
||||
console.log(`[Hawser WS] Agent disconnected: ${conn.agentId}`);
|
||||
// Clear server-side ping interval
|
||||
if (conn.pingInterval) {
|
||||
clearInterval(conn.pingInterval);
|
||||
conn.pingInterval = undefined;
|
||||
}
|
||||
// Reject pending requests
|
||||
for (const [, pending] of conn.pendingRequests) {
|
||||
clearTimeout(pending.timeout);
|
||||
pending.reject(new Error('Connection closed'));
|
||||
}
|
||||
// Clean up pending stream requests
|
||||
for (const [, pending] of conn.pendingStreamRequests) {
|
||||
pending.onEnd('Connection closed');
|
||||
}
|
||||
edgeConnections.delete(envId);
|
||||
}
|
||||
wsToEnvId.delete(ws);
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if it's an Edge exec session
|
||||
const edgeExecId = (ws.data as any)?.edgeExecId;
|
||||
if (edgeExecId) {
|
||||
const session = edgeExecSessions.get(edgeExecId);
|
||||
if (session) {
|
||||
// Send exec_end to agent (using shared helper)
|
||||
const conn = edgeConnections.get(session.environmentId);
|
||||
if (conn) {
|
||||
conn.ws.send(JSON.stringify(createExecEndMessage(edgeExecId)));
|
||||
}
|
||||
edgeExecSessions.delete(edgeExecId);
|
||||
console.log(`[Terminal WS] Edge exec session closed: ${edgeExecId}`);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Terminal connection cleanup (direct Docker)
|
||||
const connId = (ws.data as any)?.connId as string | undefined;
|
||||
if (connId) {
|
||||
const d = dockerStreams.get(connId);
|
||||
if (d?.stream) {
|
||||
d.stream.end();
|
||||
}
|
||||
dockerStreams.delete(connId);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
console.log(`[Terminal WS] WebSocket server running on port ${WS_PORT}`);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Handle Hawser Edge protocol messages
|
||||
async function handleHawserMessage(ws: any, msg: any) {
|
||||
if (msg.type === 'hello') {
|
||||
// Validate token using the app's hawser module
|
||||
// For dev mode, we'll do a simplified validation
|
||||
console.log(`[Hawser WS] Hello from agent: ${msg.agentName} (${msg.agentId})`);
|
||||
|
||||
// In dev mode, we need to validate the token against the database
|
||||
const db = getDb();
|
||||
if (!db) {
|
||||
ws.send(JSON.stringify({ type: 'error', error: 'Database not available' }));
|
||||
ws.close();
|
||||
return;
|
||||
}
|
||||
|
||||
// Simple token validation (in production this would use argon2 verification)
|
||||
// For dev mode, just check if a token exists for any environment
|
||||
const tokens = db.prepare('SELECT * FROM hawser_tokens WHERE is_active = 1').all() as any[];
|
||||
|
||||
// For dev mode, accept any valid token format and use the first environment with a token
|
||||
const token = tokens.find((t: any) => msg.token && msg.token.startsWith(t.token_prefix.slice(0, 4)));
|
||||
|
||||
if (!token) {
|
||||
console.log('[Hawser WS] Invalid token');
|
||||
ws.send(JSON.stringify({ type: 'error', error: 'Invalid token' }));
|
||||
ws.close();
|
||||
return;
|
||||
}
|
||||
|
||||
const environmentId = token.environment_id;
|
||||
|
||||
// Update environment with agent info
|
||||
try {
|
||||
db.prepare(`UPDATE environments SET
|
||||
hawser_last_seen = datetime('now'),
|
||||
hawser_agent_id = ?,
|
||||
hawser_agent_name = ?,
|
||||
hawser_version = ?,
|
||||
hawser_capabilities = ?
|
||||
WHERE id = ?`).run(
|
||||
msg.agentId,
|
||||
msg.agentName,
|
||||
msg.version,
|
||||
JSON.stringify(msg.capabilities || []),
|
||||
environmentId
|
||||
);
|
||||
} catch (e) {
|
||||
// Read-only DB in dev mode, ignore
|
||||
}
|
||||
|
||||
// Close any existing connection for this environment
|
||||
const existing = edgeConnections.get(environmentId);
|
||||
if (existing) {
|
||||
const pendingCount = existing.pendingRequests.size;
|
||||
const streamCount = existing.pendingStreamRequests.size;
|
||||
console.log(
|
||||
`[Hawser WS] Replacing existing connection for environment ${environmentId}. ` +
|
||||
`Rejecting ${pendingCount} pending requests and ${streamCount} stream requests.`
|
||||
);
|
||||
|
||||
// Reject all pending requests before closing
|
||||
for (const [requestId, pending] of existing.pendingRequests) {
|
||||
console.log(`[Hawser WS] Rejecting pending request ${requestId} due to connection replacement`);
|
||||
clearTimeout(pending.timeout);
|
||||
pending.reject(new Error('Connection replaced by new agent'));
|
||||
}
|
||||
for (const [requestId, pending] of existing.pendingStreamRequests) {
|
||||
console.log(`[Hawser WS] Ending stream request ${requestId} due to connection replacement`);
|
||||
pending.onEnd?.('Connection replaced by new agent');
|
||||
}
|
||||
existing.pendingRequests.clear();
|
||||
existing.pendingStreamRequests.clear();
|
||||
|
||||
existing.ws.close(1000, 'Replaced by new connection');
|
||||
wsToEnvId.delete(existing.ws);
|
||||
}
|
||||
|
||||
// Store connection in shared map (accessible by hawser.ts via globalThis)
|
||||
const connection: EdgeConnection = {
|
||||
ws,
|
||||
environmentId,
|
||||
agentId: msg.agentId,
|
||||
agentName: msg.agentName,
|
||||
agentVersion: msg.version || 'unknown',
|
||||
dockerVersion: msg.dockerVersion || 'unknown',
|
||||
hostname: msg.hostname || 'unknown',
|
||||
capabilities: msg.capabilities || [],
|
||||
connectedAt: new Date(),
|
||||
lastHeartbeat: new Date(),
|
||||
pendingRequests: new Map(),
|
||||
pendingStreamRequests: new Map()
|
||||
};
|
||||
|
||||
edgeConnections.set(environmentId, connection);
|
||||
wsToEnvId.set(ws, environmentId);
|
||||
|
||||
// Send welcome
|
||||
ws.send(JSON.stringify({
|
||||
type: 'welcome',
|
||||
environmentId,
|
||||
message: `Welcome ${msg.agentName}! Connected to Dockhand dev server.`
|
||||
}));
|
||||
|
||||
// Start server-side ping interval to keep connection alive through Traefik/proxies
|
||||
// Traefik has ~10s idle timeout, so we ping every 5 seconds
|
||||
connection.pingInterval = setInterval(() => {
|
||||
try {
|
||||
ws.send(JSON.stringify({ type: 'ping', timestamp: Date.now() }));
|
||||
} catch (e) {
|
||||
// Connection likely closed, clear interval
|
||||
if (connection.pingInterval) {
|
||||
clearInterval(connection.pingInterval);
|
||||
connection.pingInterval = undefined;
|
||||
}
|
||||
}
|
||||
}, 5000);
|
||||
|
||||
console.log(`[Hawser WS] Agent ${msg.agentName} connected for environment ${environmentId}`);
|
||||
} else if (msg.type === 'ping') {
|
||||
// Agent sent ping - respond with pong to keep connection alive
|
||||
const envId = wsToEnvId.get(ws);
|
||||
if (envId) {
|
||||
const conn = edgeConnections.get(envId);
|
||||
if (conn) {
|
||||
conn.lastHeartbeat = new Date();
|
||||
}
|
||||
}
|
||||
ws.send(JSON.stringify({ type: 'pong', timestamp: Date.now() }));
|
||||
} else if (msg.type === 'pong') {
|
||||
// Heartbeat response - update last seen
|
||||
const envId = wsToEnvId.get(ws);
|
||||
if (envId) {
|
||||
const conn = edgeConnections.get(envId);
|
||||
if (conn) {
|
||||
conn.lastHeartbeat = new Date();
|
||||
}
|
||||
}
|
||||
} else if (msg.type === 'response') {
|
||||
// Response to a request we sent
|
||||
const envId = wsToEnvId.get(ws);
|
||||
if (envId) {
|
||||
const conn = edgeConnections.get(envId);
|
||||
if (conn) {
|
||||
const pending = conn.pendingRequests.get(msg.requestId);
|
||||
if (pending) {
|
||||
clearTimeout(pending.timeout);
|
||||
conn.pendingRequests.delete(msg.requestId);
|
||||
|
||||
// Body is now a string (either plain text/JSON or base64-encoded binary)
|
||||
// isBinary flag indicates if base64 decoding is needed
|
||||
pending.resolve({
|
||||
statusCode: msg.statusCode,
|
||||
headers: msg.headers || {},
|
||||
body: msg.body || '',
|
||||
isBinary: msg.isBinary || false
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (msg.type === 'stream') {
|
||||
// Streaming data from agent
|
||||
const envId = wsToEnvId.get(ws);
|
||||
if (!envId) {
|
||||
console.warn(`[Hawser WS] Stream data from unknown WebSocket, requestId=${msg.requestId}`);
|
||||
return;
|
||||
}
|
||||
const conn = edgeConnections.get(envId);
|
||||
if (!conn) {
|
||||
console.warn(`[Hawser WS] Stream data for unknown environment ${envId}, requestId=${msg.requestId}`);
|
||||
return;
|
||||
}
|
||||
const pending = conn.pendingStreamRequests?.get(msg.requestId);
|
||||
if (!pending) {
|
||||
console.warn(`[Hawser WS] Stream data for unknown request ${msg.requestId} on env ${envId}`);
|
||||
return;
|
||||
}
|
||||
pending.onData(msg.data, msg.stream);
|
||||
} else if (msg.type === 'stream_end') {
|
||||
// Stream ended
|
||||
const envId = wsToEnvId.get(ws);
|
||||
if (!envId) {
|
||||
console.warn(`[Hawser WS] Stream end from unknown WebSocket, requestId=${msg.requestId}`);
|
||||
return;
|
||||
}
|
||||
const conn = edgeConnections.get(envId);
|
||||
if (!conn) {
|
||||
console.warn(`[Hawser WS] Stream end for unknown environment ${envId}, requestId=${msg.requestId}`);
|
||||
return;
|
||||
}
|
||||
const pending = conn.pendingStreamRequests.get(msg.requestId);
|
||||
if (!pending) {
|
||||
console.warn(`[Hawser WS] Stream end for unknown request ${msg.requestId} on env ${envId}`);
|
||||
return;
|
||||
}
|
||||
conn.pendingStreamRequests.delete(msg.requestId);
|
||||
pending.onEnd(msg.reason);
|
||||
} else if (msg.type === 'metrics') {
|
||||
// Metrics from agent - save to database for dashboard graphs
|
||||
const envId = wsToEnvId.get(ws);
|
||||
if (envId && msg.metrics) {
|
||||
if (globalThis.__hawserHandleMetrics) {
|
||||
globalThis.__hawserHandleMetrics(envId, msg.metrics).catch((err) => {
|
||||
console.error(`[Hawser WS] Error saving metrics:`, err);
|
||||
});
|
||||
}
|
||||
}
|
||||
} else if (msg.type === 'exec_ready') {
|
||||
// Exec session is ready
|
||||
const session = edgeExecSessions.get(msg.execId);
|
||||
if (session?.ws?.readyState === 1) {
|
||||
console.log(`[Hawser WS] Exec ready: ${msg.execId}`);
|
||||
// Frontend doesn't need explicit ready message, it's already waiting for output
|
||||
}
|
||||
} else if (msg.type === 'exec_output') {
|
||||
// Terminal output from exec session
|
||||
const session = edgeExecSessions.get(msg.execId);
|
||||
if (session?.ws?.readyState === 1) {
|
||||
// Decode base64 data
|
||||
const data = Buffer.from(msg.data, 'base64').toString('utf-8');
|
||||
session.ws.send(JSON.stringify({ type: 'output', data }));
|
||||
}
|
||||
} else if (msg.type === 'exec_end') {
|
||||
// Exec session ended
|
||||
const session = edgeExecSessions.get(msg.execId);
|
||||
if (session) {
|
||||
console.log(`[Hawser WS] Exec ended: ${msg.execId} (reason: ${msg.reason})`);
|
||||
if (session.ws?.readyState === 1) {
|
||||
session.ws.send(JSON.stringify({ type: 'exit' }));
|
||||
session.ws.close();
|
||||
}
|
||||
edgeExecSessions.delete(msg.execId);
|
||||
}
|
||||
} else if (msg.type === 'container_event') {
|
||||
// Container event from edge agent
|
||||
const envId = wsToEnvId.get(ws);
|
||||
if (envId && msg.event) {
|
||||
// Call the global handler registered by hawser.ts
|
||||
if (globalThis.__hawserHandleContainerEvent) {
|
||||
globalThis.__hawserHandleContainerEvent(envId, msg.event).catch((err) => {
|
||||
console.error('[Hawser WS] Error handling container event:', err);
|
||||
});
|
||||
}
|
||||
}
|
||||
} else if (msg.type === 'error' && msg.requestId) {
|
||||
// Error might be for an exec session
|
||||
const session = edgeExecSessions.get(msg.requestId);
|
||||
if (session?.ws?.readyState === 1) {
|
||||
console.error(`[Hawser WS] Exec error: ${msg.error}`);
|
||||
session.ws.send(JSON.stringify({ type: 'error', message: msg.error }));
|
||||
session.ws.close();
|
||||
edgeExecSessions.delete(msg.requestId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default defineConfig({
|
||||
plugins: [bunExternals(), tailwindcss(), sveltekit(), webSocketPlugin()],
|
||||
define: {
|
||||
__BUILD_DATE__: JSON.stringify(new Date().toISOString()),
|
||||
__BUILD_COMMIT__: JSON.stringify(getGitCommit()),
|
||||
__BUILD_BRANCH__: JSON.stringify(getGitBranch()),
|
||||
__APP_VERSION__: JSON.stringify(getGitTag())
|
||||
},
|
||||
optimizeDeps: {
|
||||
include: ['lucide-svelte', '@xterm/xterm', '@xterm/addon-fit']
|
||||
},
|
||||
build: {
|
||||
target: 'esnext',
|
||||
minify: 'esbuild',
|
||||
sourcemap: false,
|
||||
rollupOptions: {
|
||||
external: [/^bun:/]
|
||||
}
|
||||
},
|
||||
ssr: {
|
||||
external: [/^bun:/]
|
||||
}
|
||||
});
|
||||
Reference in New Issue
Block a user