ai-cli-online 2.1.0

package/server/dist/pty.js

@@ -0,0 +1,75 @@
+import * as pty from 'node-pty';
+/**
+ * Wraps node-pty to attach to a tmux session.
+ * When the WebSocket disconnects, we kill only the PTY (detach from tmux),
+ * leaving the tmux session alive for later reconnection.
+ */
+/** Keys to strip from the environment passed to PTY subprocesses */
+const SENSITIVE_ENV_KEYS = ['AUTH_TOKEN', 'SECRET', 'PASSWORD', 'API_KEY', 'PRIVATE_KEY', 'ACCESS_TOKEN'];
+function sanitizedEnv() {
+    const env = { ...process.env };
+    for (const key of Object.keys(env)) {
+        if (SENSITIVE_ENV_KEYS.some((s) => key.toUpperCase().includes(s))) {
+            delete env[key];
+        }
+    }
+    return env;
+}
+export class PtySession {
+    proc;
+    dataListeners = [];
+    exitListeners = [];
+    alive = true;
+    constructor(sessionName, cols, rows) {
+        this.proc = pty.spawn('tmux', ['attach-session', '-t', sessionName], {
+            name: 'xterm-256color',
+            cols,
+            rows,
+            env: sanitizedEnv(),
+        });
+        this.proc.onData((data) => {
+            for (const cb of this.dataListeners) {
+                cb(data);
+            }
+        });
+        this.proc.onExit(({ exitCode, signal }) => {
+            this.alive = false;
+            for (const cb of this.exitListeners) {
+                cb(exitCode ?? 0, signal ?? 0);
+            }
+        });
+    }
+    onData(cb) {
+        this.dataListeners.push(cb);
+    }
+    onExit(cb) {
+        this.exitListeners.push(cb);
+    }
+    write(data) {
+        if (this.alive) {
+            this.proc.write(data);
+        }
+    }
+    resize(cols, rows) {
+        if (this.alive) {
+            this.proc.resize(cols, rows);
+        }
+    }
+    kill() {
+        if (this.alive) {
+            this.alive = false;
+            try {
+                this.proc.kill();
+            }
+            catch (err) {
+                console.error('[PTY] kill() error (process may have already exited):', err);
+            }
+        }
+        // Clear listener arrays to release closure references for GC
+        this.dataListeners = [];
+        this.exitListeners = [];
+    }
+    isAlive() {
+        return this.alive;
+    }
+}

package/server/dist/storage.d.ts

@@ -0,0 +1,22 @@
+import type { Conversation, Message } from './types.js';
+export declare class Storage {
+    private data;
+    private config;
+    constructor();
+    getWorkingDir(): string;
+    setWorkingDir(dir: string): void;
+    getCurrentConversationId(): string | null;
+    setCurrentConversationId(id: string | null): void;
+    createConversation(id: string): Conversation;
+    getConversation(id: string): Conversation | null;
+    getCurrentConversation(): Conversation | null;
+    getAllConversations(): Conversation[];
+    addMessage(conversationId: string, message: Message): void;
+    updateMessage(conversationId: string, messageId: string, updates: Partial<Message>): void;
+    updateConversationWorkingDir(conversationId: string, workingDir: string): void;
+    getConversationWorkingDir(conversationId: string): string;
+    setClaudeSessionId(conversationId: string, sessionId: string): void;
+    getClaudeSessionId(conversationId: string): string | undefined;
+    deleteConversation(id: string): void;
+}
+export declare const storage: Storage;

package/server/dist/storage.js

@@ -0,0 +1,149 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+const DATA_DIR = process.env.DATA_DIR || join(process.cwd(), 'data');
+// Ensure data directory exists
+if (!existsSync(DATA_DIR)) {
+    mkdirSync(DATA_DIR, { recursive: true });
+}
+const CONVERSATIONS_FILE = join(DATA_DIR, 'conversations.json');
+const CONFIG_FILE = join(DATA_DIR, 'config.json');
+function loadData() {
+    if (!existsSync(CONVERSATIONS_FILE)) {
+        return { conversations: {} };
+    }
+    try {
+        const data = readFileSync(CONVERSATIONS_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return { conversations: {} };
+    }
+}
+function saveData(data) {
+    writeFileSync(CONVERSATIONS_FILE, JSON.stringify(data, null, 2));
+}
+function loadConfig() {
+    const defaultConfig = {
+        currentConversationId: null,
+        workingDir: process.env.DEFAULT_WORKING_DIR || process.env.HOME || '/home/ubuntu',
+    };
+    if (!existsSync(CONFIG_FILE)) {
+        return defaultConfig;
+    }
+    try {
+        const data = readFileSync(CONFIG_FILE, 'utf-8');
+        return { ...defaultConfig, ...JSON.parse(data) };
+    }
+    catch {
+        return defaultConfig;
+    }
+}
+function saveConfig(config) {
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export class Storage {
+    data;
+    config;
+    constructor() {
+        this.data = loadData();
+        this.config = loadConfig();
+    }
+    // Config methods
+    getWorkingDir() {
+        return this.config.workingDir;
+    }
+    setWorkingDir(dir) {
+        this.config.workingDir = dir;
+        saveConfig(this.config);
+    }
+    getCurrentConversationId() {
+        return this.config.currentConversationId;
+    }
+    setCurrentConversationId(id) {
+        this.config.currentConversationId = id;
+        saveConfig(this.config);
+    }
+    // Conversation methods
+    createConversation(id) {
+        const conversation = {
+            id,
+            workingDir: this.config.workingDir,
+            messages: [],
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        this.data.conversations[id] = conversation;
+        this.config.currentConversationId = id;
+        saveData(this.data);
+        saveConfig(this.config);
+        return conversation;
+    }
+    getConversation(id) {
+        return this.data.conversations[id] || null;
+    }
+    getCurrentConversation() {
+        if (!this.config.currentConversationId) {
+            return null;
+        }
+        return this.getConversation(this.config.currentConversationId);
+    }
+    getAllConversations() {
+        return Object.values(this.data.conversations).sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    addMessage(conversationId, message) {
+        const conversation = this.data.conversations[conversationId];
+        if (conversation) {
+            conversation.messages.push(message);
+            conversation.updatedAt = Date.now();
+            saveData(this.data);
+        }
+    }
+    updateMessage(conversationId, messageId, updates) {
+        const conversation = this.data.conversations[conversationId];
+        if (conversation) {
+            const messageIndex = conversation.messages.findIndex((m) => m.id === messageId);
+            if (messageIndex !== -1) {
+                conversation.messages[messageIndex] = {
+                    ...conversation.messages[messageIndex],
+                    ...updates,
+                };
+                conversation.updatedAt = Date.now();
+                saveData(this.data);
+            }
+        }
+    }
+    updateConversationWorkingDir(conversationId, workingDir) {
+        const conversation = this.data.conversations[conversationId];
+        if (conversation) {
+            conversation.workingDir = workingDir;
+            conversation.updatedAt = Date.now();
+            saveData(this.data);
+        }
+    }
+    getConversationWorkingDir(conversationId) {
+        const conversation = this.data.conversations[conversationId];
+        return conversation?.workingDir || this.config.workingDir;
+    }
+    setClaudeSessionId(conversationId, sessionId) {
+        const conversation = this.data.conversations[conversationId];
+        if (conversation) {
+            conversation.claudeSessionId = sessionId;
+            conversation.updatedAt = Date.now();
+            saveData(this.data);
+        }
+    }
+    getClaudeSessionId(conversationId) {
+        const conversation = this.data.conversations[conversationId];
+        return conversation?.claudeSessionId;
+    }
+    deleteConversation(id) {
+        delete this.data.conversations[id];
+        if (this.config.currentConversationId === id) {
+            this.config.currentConversationId = null;
+        }
+        saveData(this.data);
+        saveConfig(this.config);
+    }
+}
+// Singleton instance
+export const storage = new Storage();

package/server/dist/tmux.d.ts

@@ -0,0 +1,40 @@
+export interface TmuxSessionInfo {
+    sessionName: string;
+    sessionId: string;
+    createdAt: number;
+}
+/**
+ * Generate a tmux session name from an auth token.
+ * Uses SHA256 prefix to avoid leaking the token.
+ */
+export declare function tokenToSessionName(token: string): string;
+/** Validate sessionId: only allow alphanumeric, underscore, hyphen, max 32 chars */
+export declare function isValidSessionId(sessionId: string): boolean;
+/**
+ * Build a tmux session name from token + optional sessionId.
+ * Without sessionId, behaves identically to tokenToSessionName (backward compat).
+ */
+export declare function buildSessionName(token: string, sessionId?: string): string;
+/** Check if a tmux session exists */
+export declare function hasSession(name: string): Promise<boolean>;
+/** Create a new tmux session (detached) */
+export declare function createSession(name: string, cols: number, rows: number, cwd: string): Promise<void>;
+/**
+ * Capture scrollback buffer with ANSI escape sequences preserved.
+ * Returns the last 10000 lines of the pane.
+ */
+export declare function captureScrollback(name: string): Promise<string>;
+/** Resize tmux window to match terminal dimensions */
+export declare function resizeSession(name: string, cols: number, rows: number): Promise<void>;
+/** Kill a tmux session */
+export declare function killSession(name: string): Promise<void>;
+/** List all tmux sessions belonging to a given token */
+export declare function listSessions(token: string): Promise<TmuxSessionInfo[]>;
+/** Clean up idle tmux sessions older than the given TTL (hours) */
+export declare function cleanupStaleSessions(ttlHours: number): Promise<void>;
+/** 获取 tmux session 当前活动 pane 的工作目录 */
+export declare function getCwd(sessionName: string): Promise<string>;
+/** 获取 tmux pane 当前运行的命令名称 */
+export declare function getPaneCommand(sessionName: string): Promise<string>;
+/** Check if tmux is available on the system (sync — startup only) */
+export declare function isTmuxAvailable(): boolean;

package/server/dist/tmux.js

@@ -0,0 +1,191 @@
+import { execFile as execFileCb, execFileSync } from 'child_process';
+import { promisify } from 'util';
+import { createHash } from 'crypto';
+const execFile = promisify(execFileCb);
+/**
+ * Generate a tmux session name from an auth token.
+ * Uses SHA256 prefix to avoid leaking the token.
+ */
+export function tokenToSessionName(token) {
+    const hash = createHash('sha256').update(token).digest('hex');
+    return `ai-cli-online-${hash.slice(0, 8)}`;
+}
+/** Validate sessionId: only allow alphanumeric, underscore, hyphen, max 32 chars */
+export function isValidSessionId(sessionId) {
+    return /^[a-zA-Z0-9_-]{1,32}$/.test(sessionId);
+}
+/**
+ * Build a tmux session name from token + optional sessionId.
+ * Without sessionId, behaves identically to tokenToSessionName (backward compat).
+ */
+export function buildSessionName(token, sessionId) {
+    const base = tokenToSessionName(token);
+    return sessionId ? `${base}-${sessionId}` : base;
+}
+/** Check if a tmux session exists */
+export async function hasSession(name) {
+    try {
+        await execFile('tmux', ['has-session', '-t', name]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Create a new tmux session (detached) */
+export async function createSession(name, cols, rows, cwd) {
+    await execFile('tmux', [
+        'new-session',
+        '-d',
+        '-s', name,
+        '-x', String(cols),
+        '-y', String(rows),
+    ], { cwd });
+    // Configure tmux for web terminal usage (parallel for faster session creation)
+    await Promise.all([
+        execFile('tmux', ['set-option', '-t', name, 'history-limit', '50000']).catch(() => { }),
+        execFile('tmux', ['set-option', '-t', name, 'status', 'off']).catch(() => { }),
+        execFile('tmux', ['set-option', '-t', name, 'mouse', 'off']).catch(() => { }),
+    ]);
+    console.log(`[tmux] Created session: ${name} (${cols}x${rows}) in ${cwd}`);
+}
+/**
+ * Capture scrollback buffer with ANSI escape sequences preserved.
+ * Returns the last 10000 lines of the pane.
+ */
+export async function captureScrollback(name) {
+    try {
+        const { stdout } = await execFile('tmux', [
+            'capture-pane',
+            '-t', name,
+            '-p',
+            '-e',
+            '-S', '-10000',
+        ], { encoding: 'utf-8', maxBuffer: 5 * 1024 * 1024 });
+        return stdout;
+    }
+    catch (err) {
+        console.error(`[tmux] Failed to capture scrollback for ${name}:`, err);
+        return '';
+    }
+}
+/** Resize tmux window to match terminal dimensions */
+export async function resizeSession(name, cols, rows) {
+    try {
+        await execFile('tmux', [
+            'resize-window',
+            '-t', name,
+            '-x', String(cols),
+            '-y', String(rows),
+        ]);
+    }
+    catch {
+        // Resize can fail if dimensions haven't changed, ignore
+    }
+}
+/** Kill a tmux session */
+export async function killSession(name) {
+    try {
+        await execFile('tmux', ['kill-session', '-t', name]);
+        console.log(`[tmux] Killed session: ${name}`);
+    }
+    catch {
+        // Session may already be gone
+    }
+}
+/** List all tmux sessions belonging to a given token */
+export async function listSessions(token) {
+    const prefix = tokenToSessionName(token) + '-';
+    try {
+        const { stdout } = await execFile('tmux', [
+            'list-sessions',
+            '-F',
+            '#{session_name}:#{session_created}',
+        ], { encoding: 'utf-8' });
+        const results = [];
+        for (const line of stdout.trim().split('\n')) {
+            if (!line)
+                continue;
+            const lastColon = line.lastIndexOf(':');
+            if (lastColon === -1)
+                continue;
+            const sessionName = line.slice(0, lastColon);
+            const createdAt = parseInt(line.slice(lastColon + 1), 10);
+            if (!sessionName.startsWith(prefix))
+                continue;
+            const sessionId = sessionName.slice(prefix.length);
+            results.push({ sessionName, sessionId, createdAt });
+        }
+        return results;
+    }
+    catch {
+        // tmux server not running or no sessions
+        return [];
+    }
+}
+/** Clean up idle tmux sessions older than the given TTL (hours) */
+export async function cleanupStaleSessions(ttlHours) {
+    const cutoff = Math.floor(Date.now() / 1000) - ttlHours * 3600;
+    try {
+        const { stdout } = await execFile('tmux', [
+            'list-sessions',
+            '-F',
+            '#{session_name}:#{session_created}:#{session_attached}',
+        ], { encoding: 'utf-8' });
+        for (const line of stdout.trim().split('\n')) {
+            if (!line)
+                continue;
+            // Use lastIndexOf to safely parse (consistent with listSessions)
+            const lastColon = line.lastIndexOf(':');
+            if (lastColon === -1)
+                continue;
+            const attached = parseInt(line.slice(lastColon + 1), 10);
+            const rest = line.slice(0, lastColon);
+            const secondLastColon = rest.lastIndexOf(':');
+            if (secondLastColon === -1)
+                continue;
+            const created = parseInt(rest.slice(secondLastColon + 1), 10);
+            const name = rest.slice(0, secondLastColon);
+            if (!name.startsWith('ai-cli-online-'))
+                continue;
+            if (attached > 0)
+                continue;
+            if (created < cutoff) {
+                console.log(`[tmux] Cleaning up stale session: ${name} (created ${new Date(created * 1000).toISOString()})`);
+                await killSession(name);
+            }
+        }
+    }
+    catch {
+        // No tmux server or no sessions
+    }
+}
+/** 获取 tmux session 当前活动 pane 的工作目录 */
+export async function getCwd(sessionName) {
+    const { stdout } = await execFile('tmux', [
+        'display-message', '-p', '-t', sessionName, '#{pane_current_path}',
+    ], { encoding: 'utf-8' });
+    return stdout.trim();
+}
+/** 获取 tmux pane 当前运行的命令名称 */
+export async function getPaneCommand(sessionName) {
+    try {
+        const { stdout } = await execFile('tmux', [
+            'display-message', '-p', '-t', sessionName, '#{pane_current_command}',
+        ], { encoding: 'utf-8' });
+        return stdout.trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** Check if tmux is available on the system (sync — startup only) */
+export function isTmuxAvailable() {
+    try {
+        execFileSync('tmux', ['-V'], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/server/dist/types.d.ts

@@ -0,0 +1 @@
+export type { ClientMessage, ServerMessage, FileEntry } from 'ai-cli-online-shared';

package/server/dist/types.js

@@ -0,0 +1 @@
+export {};

package/server/dist/websocket.d.ts

@@ -0,0 +1,4 @@
+import { WebSocketServer } from 'ws';
+/** Get the set of session names with active open WebSocket connections */
+export declare function getActiveSessionNames(): Set<string>;
+export declare function setupWebSocket(wss: WebSocketServer, authToken: string, defaultCwd: string, tokenCompare: (a: string, b: string) => boolean, maxConnections?: number): void;