atoo-studio 0.0.1 → 0.0.2

package/dist/src/state/store.d.ts

@@ -0,0 +1,37 @@
+import type { Session, SessionEvent } from './types.js';
+import type WebSocket from 'ws';
+export type AgentStatus = 'open' | 'active' | 'attention';
+declare class Store {
+    sessions: Map<string, Session>;
+    agentStatuses: Map<string, AgentStatus>;
+    contextUsages: Map<string, {
+        model: string;
+        usedTokens: number;
+        totalTokens: number;
+        percent: number;
+        freePercent: number;
+    }>;
+    contextInProgressSessions: Set<string>;
+    statusClients: Set<WebSocket>;
+    private eventListeners;
+    /**
+     * Subscribe to ingress events for a session. Returns an unsubscribe function.
+     */
+    addEventListener(sessionId: string, cb: (event: any) => void): () => void;
+    /** Notify event listeners for a session. */
+    notifyEventListeners(sessionId: string, event: any): void;
+    addEvent(sessionId: string, event: SessionEvent): boolean;
+    setAgentStatus(sessionId: string, status: AgentStatus): void;
+    removeAgentStatus(sessionId: string): void;
+    getAgentStatus(sessionId: string): AgentStatus;
+    setContextInProgress(sessionId: string, inProgress: boolean): void;
+    setContextUsage(sessionId: string, usage: {
+        model: string;
+        usedTokens: number;
+        totalTokens: number;
+        percent: number;
+        freePercent: number;
+    }): void;
+}
+export declare const store: Store;
+export {};

package/dist/src/state/store.js

@@ -0,0 +1,108 @@
+class Store {
+    sessions = new Map();
+    agentStatuses = new Map(); // sessionId → status
+    contextUsages = new Map(); // sessionId → token usage
+    contextInProgressSessions = new Set(); // sessions currently running /context flow
+    // WebSocket connections
+    statusClients = new Set(); // global status listeners
+    // Event listeners for agent layer
+    eventListeners = new Map();
+    /**
+     * Subscribe to ingress events for a session. Returns an unsubscribe function.
+     */
+    addEventListener(sessionId, cb) {
+        if (!this.eventListeners.has(sessionId)) {
+            this.eventListeners.set(sessionId, new Set());
+        }
+        this.eventListeners.get(sessionId).add(cb);
+        return () => {
+            this.eventListeners.get(sessionId)?.delete(cb);
+            if (this.eventListeners.get(sessionId)?.size === 0) {
+                this.eventListeners.delete(sessionId);
+            }
+        };
+    }
+    /** Notify event listeners for a session. */
+    notifyEventListeners(sessionId, event) {
+        const listeners = this.eventListeners.get(sessionId);
+        if (!listeners)
+            return;
+        for (const cb of listeners) {
+            try {
+                cb(event);
+            }
+            catch (err) {
+                console.error(`[store] Event listener error for ${sessionId}:`, err);
+            }
+        }
+    }
+    addEvent(sessionId, event) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        // Deduplicate by UUID
+        if (event.uuid && session.events.some((e) => e.uuid === event.uuid)) {
+            return false;
+        }
+        session.events.push(event);
+        // Notify event listeners (agent layer)
+        this.notifyEventListeners(sessionId, event);
+        return true;
+    }
+    setAgentStatus(sessionId, status) {
+        const prev = this.agentStatuses.get(sessionId);
+        if (prev === status)
+            return;
+        this.agentStatuses.set(sessionId, status);
+        const msg = { type: 'agent_status', status, session_id: sessionId };
+        // Broadcast to global status listeners (sidebar)
+        const data = JSON.stringify(msg);
+        for (const ws of this.statusClients) {
+            if (ws.readyState === 1)
+                ws.send(data);
+        }
+    }
+    removeAgentStatus(sessionId) {
+        this.agentStatuses.delete(sessionId);
+        this.contextInProgressSessions.delete(sessionId);
+        this.contextUsages.delete(sessionId);
+        // Broadcast 'exited' so frontends remove the session from active state
+        const msg = { type: 'agent_status', status: 'exited', session_id: sessionId };
+        const data = JSON.stringify(msg);
+        for (const ws of this.statusClients) {
+            if (ws.readyState === 1)
+                ws.send(data);
+        }
+    }
+    getAgentStatus(sessionId) {
+        return this.agentStatuses.get(sessionId) || 'open';
+    }
+    setContextInProgress(sessionId, inProgress) {
+        if (inProgress) {
+            this.contextInProgressSessions.add(sessionId);
+        }
+        else {
+            this.contextInProgressSessions.delete(sessionId);
+        }
+        const listeners = this.eventListeners.get(sessionId);
+        console.log(`[store] setContextInProgress(${sessionId}, ${inProgress}) — eventListeners=${listeners?.size ?? 0}, statusClients=${this.statusClients.size}`);
+        const msg = { type: 'context_in_progress', session_id: sessionId, inProgress };
+        // Notify agent event listeners so the adapter can re-emit with agent session ID
+        this.notifyEventListeners(sessionId, msg);
+        const data = JSON.stringify(msg);
+        for (const ws of this.statusClients) {
+            if (ws.readyState === 1)
+                ws.send(data);
+        }
+    }
+    setContextUsage(sessionId, usage) {
+        this.contextUsages.set(sessionId, usage);
+        const msg = { type: 'context_usage', session_id: sessionId, ...usage };
+        const data = JSON.stringify(msg);
+        for (const ws of this.statusClients) {
+            if (ws.readyState === 1)
+                ws.send(data);
+        }
+    }
+}
+export const store = new Store();

package/dist/src/state/types.d.ts

@@ -0,0 +1,13 @@
+import type { SessionEvent } from '../events/types.js';
+export type { SessionEvent } from '../events/types.js';
+export interface Session {
+    id: string;
+    title: string;
+    environmentId: string;
+    status: 'active' | 'archived';
+    events: SessionEvent[];
+    createdAt: Date;
+    source: string;
+    permissionMode?: string;
+    fsUuid?: string;
+}

package/dist/src/state/types.js

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

package/dist/src/web/devtools-proxy.d.ts

@@ -0,0 +1,7 @@
+import express from 'express';
+import http from 'http';
+import { WebSocketServer } from 'ws';
+import { Duplex } from 'stream';
+export declare function devtoolsProxyMiddleware(): express.Router;
+export declare function isDevtoolsWsUpgrade(url: string): boolean;
+export declare function handleDevtoolsWsUpgrade(wss: WebSocketServer, req: http.IncomingMessage, socket: Duplex, head: Buffer): void;

package/dist/src/web/devtools-proxy.js

@@ -0,0 +1,176 @@
+import express from 'express';
+import http from 'http';
+import { WebSocket } from 'ws';
+import { previewManager } from '../services/preview-manager.js';
+/** Make an HTTP GET request to Chrome's CDP endpoint */
+function httpGet(instance, urlPath) {
+    return new Promise((resolve, reject) => {
+        const opts = { host: 'localhost', port: instance.cdpPort, path: urlPath };
+        const req = http.get(opts, (resp) => {
+            const chunks = [];
+            resp.on('data', (c) => chunks.push(c));
+            resp.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        });
+        req.on('error', reject);
+        req.setTimeout(5000, () => { req.destroy(); reject(new Error('timeout')); });
+    });
+}
+/** Build WS URL to Chrome CDP */
+function buildCdpWsUrl(instance, cdpPath) {
+    return `ws://localhost:${instance.cdpPort}/${cdpPath}`;
+}
+// HTTP proxy middleware for Chrome DevTools frontend
+export function devtoolsProxyMiddleware() {
+    const router = express.Router();
+    // Get DevTools URL for a preview instance (returns the correct page target URL)
+    router.get('/apps/:projectId/:tabId/devtools-url', async (req, res) => {
+        const { projectId, tabId } = req.params;
+        const instance = previewManager.get(projectId, tabId);
+        if (!instance) {
+            return res.status(404).json({ error: 'Preview instance not found' });
+        }
+        if (!instance.cdpPort) {
+            return res.status(400).json({ error: 'DevTools not available for this instance' });
+        }
+        try {
+            const targetsJson = await httpGet(instance, '/json');
+            const targets = JSON.parse(targetsJson);
+            const pageTarget = targets.find((t) => t.type === 'page');
+            if (!pageTarget) {
+                return res.status(404).json({ error: 'No page target found' });
+            }
+            const versionJson = await httpGet(instance, '/json/version');
+            const version = JSON.parse(versionJson);
+            const host = req.get('host');
+            const wsPath = `ws/devtools/${encodeURIComponent(projectId)}/${encodeURIComponent(tabId)}/devtools/page/${pageTarget.id}`;
+            const devtoolsFrontend = `/apps/${encodeURIComponent(projectId)}/${encodeURIComponent(tabId)}/devtools/inspector.html?${req.protocol === 'https' ? 'wss' : 'ws'}=${host}/${wsPath}`;
+            console.log(`[devtools-proxy] Target: ${pageTarget.id} (${pageTarget.url})`);
+            console.log(`[devtools-proxy] Frontend URL: ${devtoolsFrontend}`);
+            res.json({
+                url: devtoolsFrontend,
+                targetId: pageTarget.id,
+                targetUrl: pageTarget.url,
+                wsProxy: wsPath,
+                browserWs: version.webSocketDebuggerUrl,
+            });
+        }
+        catch (err) {
+            res.status(502).json({ error: `Failed to get targets: ${err.message}` });
+        }
+    });
+    // Proxy DevTools frontend files: /apps/:projectId/:tabId/devtools/*
+    router.get('/apps/:projectId/:tabId/devtools/{*rest}', async (req, res) => {
+        const projectId = req.params.projectId, tabId = req.params.tabId;
+        const instance = previewManager.get(projectId, tabId);
+        if (!instance) {
+            return res.status(404).json({ error: 'Preview instance not found' });
+        }
+        if (!instance.cdpPort) {
+            return res.status(400).json({ error: 'DevTools not available for this instance' });
+        }
+        const restParam = req.params.rest;
+        const devtoolsPath = Array.isArray(restParam) ? restParam.join('/') : (restParam || '');
+        const queryString = req.url.includes('?') ? '?' + req.url.split('?')[1] : '';
+        const targetPath = `/devtools/${devtoolsPath}${queryString}`;
+        try {
+            const opts = { host: 'localhost', port: instance.cdpPort, path: targetPath };
+            const proxyReq = http.get(opts, (proxyRes) => {
+                res.status(proxyRes.statusCode || 200);
+                for (const [key, val] of Object.entries(proxyRes.headers)) {
+                    if (key !== 'transfer-encoding' && val) {
+                        res.set(key, val);
+                    }
+                }
+                proxyRes.pipe(res);
+            });
+            proxyReq.on('error', (err) => {
+                res.status(502).json({ error: `DevTools proxy error: ${err.message}` });
+            });
+        }
+        catch (err) {
+            res.status(502).json({ error: err.message });
+        }
+    });
+    return router;
+}
+// WebSocket proxy for DevTools
+export function isDevtoolsWsUpgrade(url) {
+    return url.startsWith('/ws/devtools/');
+}
+export function handleDevtoolsWsUpgrade(wss, req, socket, head) {
+    const url = req.url || '';
+    const match = url.match(/^\/ws\/devtools\/([^/?]+)\/([^/?]+)\/(.*)/);
+    if (!match) {
+        socket.destroy();
+        return;
+    }
+    const projectId = decodeURIComponent(match[1]);
+    const tabId = decodeURIComponent(match[2]);
+    const cdpPath = match[3];
+    const instance = previewManager.get(projectId, tabId);
+    if (!instance || !instance.cdpPort) {
+        socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+        socket.destroy();
+        return;
+    }
+    const targetWsUrl = buildCdpWsUrl(instance, cdpPath);
+    console.log(`[devtools-proxy] WS upgrade: ${cdpPath} → ${targetWsUrl}`);
+    wss.handleUpgrade(req, socket, head, (clientWs) => {
+        const targetWs = new WebSocket(targetWsUrl);
+        const bufferedMessages = [];
+        let targetReady = false;
+        // Keepalive: ping both sides every 30s to prevent idle timeout
+        const pingInterval = setInterval(() => {
+            if (clientWs.readyState === 1)
+                clientWs.ping();
+            if (targetWs.readyState === 1)
+                targetWs.ping();
+        }, 30_000);
+        clientWs.on('message', (data, isBinary) => {
+            if (targetReady) {
+                if (targetWs.readyState === 1) {
+                    targetWs.send(data, { binary: isBinary });
+                }
+            }
+            else {
+                bufferedMessages.push(isBinary ? Buffer.from(data) : data.toString());
+            }
+        });
+        targetWs.on('open', () => {
+            console.log(`[devtools-proxy] WS connected to Chrome CDP (${cdpPath})`);
+            targetReady = true;
+            for (const msg of bufferedMessages) {
+                if (targetWs.readyState === 1) {
+                    targetWs.send(msg);
+                }
+            }
+            bufferedMessages.length = 0;
+            targetWs.on('message', (data, isBinary) => {
+                if (clientWs.readyState === 1) {
+                    clientWs.send(data, { binary: isBinary });
+                }
+            });
+        });
+        targetWs.on('error', (err) => {
+            console.error(`[devtools-proxy] Target WS error:`, err.message);
+            clientWs.close(1011, 'Target connection error');
+        });
+        targetWs.on('close', (code, reason) => {
+            clearInterval(pingInterval);
+            console.log(`[devtools-proxy] Target WS closed: ${code} ${reason}`);
+            if (clientWs.readyState <= 1)
+                clientWs.close(code || 1000, reason?.toString() || '');
+        });
+        clientWs.on('close', (code, reason) => {
+            clearInterval(pingInterval);
+            console.log(`[devtools-proxy] Client WS closed: ${code}`);
+            if (targetWs.readyState <= 1)
+                targetWs.close();
+        });
+        clientWs.on('error', (err) => {
+            console.error(`[devtools-proxy] Client WS error:`, err.message);
+            if (targetWs.readyState <= 1)
+                targetWs.close();
+        });
+    });
+}

package/dist/src/web/port-proxy.d.ts

@@ -0,0 +1,15 @@
+import http from 'http';
+import httpProxy from 'http-proxy';
+import type { Request, Response, NextFunction } from 'express';
+import type { Duplex } from 'stream';
+interface ProxyTarget {
+    port: number;
+    path: string;
+    connectionId?: string;
+}
+export declare function extractPortProxyTarget(req: http.IncomingMessage): ProxyTarget | null;
+export declare function createPortProxy(): httpProxy;
+export declare function portProxyMiddleware(proxy: httpProxy): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export declare function isPortProxyUpgrade(req: http.IncomingMessage): boolean;
+export declare function handlePortProxyUpgrade(proxy: httpProxy, req: http.IncomingMessage, socket: Duplex, head: Buffer): Promise<void>;
+export {};

package/dist/src/web/port-proxy.js

@@ -0,0 +1,124 @@
+import httpProxy from 'http-proxy';
+import { WEB_PORT } from '../config.js';
+import { sshManager } from '../services/ssh-manager.js';
+const SUBDOMAIN_RE = /^(\d+)\.port\.on\./;
+const PATH_PREFIX_RE = /^\/at\/port\/(\d+)(\/.*)?$/;
+const REMOTE_PATH_PREFIX_RE = /^\/at\/remote\/([^/]+)\/port\/(\d+)(\/.*)?$/;
+const REMOTE_SUBDOMAIN_RE = /^(\d+)\.remote\.([^.]+)\.on\./;
+export function extractPortProxyTarget(req) {
+    const host = req.headers.host || '';
+    const hostWithoutPort = host.replace(/:\d+$/, '');
+    // Subdomain format: {portnr}.port.on.{domain}
+    const subdomainMatch = hostWithoutPort.match(SUBDOMAIN_RE);
+    if (subdomainMatch) {
+        const port = parseInt(subdomainMatch[1], 10);
+        if (port > 0 && port <= 65535 && port !== WEB_PORT) {
+            return { port, path: req.url || '/' };
+        }
+    }
+    // Path format: /at/port/{portnr}[/rest]
+    const url = req.url || '/';
+    const pathMatch = url.match(PATH_PREFIX_RE);
+    if (pathMatch) {
+        const port = parseInt(pathMatch[1], 10);
+        if (port > 0 && port <= 65535 && port !== WEB_PORT) {
+            return { port, path: pathMatch[2] || '/' };
+        }
+    }
+    // Remote path format: /at/remote/{connId}/port/{portnr}[/rest]
+    const remotePathMatch = url.match(REMOTE_PATH_PREFIX_RE);
+    if (remotePathMatch) {
+        const connectionId = remotePathMatch[1];
+        const port = parseInt(remotePathMatch[2], 10);
+        if (port > 0 && port <= 65535) {
+            return { port, path: remotePathMatch[3] || '/', connectionId };
+        }
+    }
+    // Remote subdomain format: {port}.remote.{connId}.on.{domain}
+    const remoteSubMatch = hostWithoutPort.match(REMOTE_SUBDOMAIN_RE);
+    if (remoteSubMatch) {
+        const port = parseInt(remoteSubMatch[1], 10);
+        const connectionId = remoteSubMatch[2];
+        if (port > 0 && port <= 65535) {
+            return { port, path: req.url || '/', connectionId };
+        }
+    }
+    return null;
+}
+export function createPortProxy() {
+    const proxy = httpProxy.createProxyServer({
+        ws: true,
+        xfwd: true,
+        changeOrigin: true,
+    });
+    proxy.on('error', (err, req, res) => {
+        const target = extractPortProxyTarget(req);
+        const port = target?.port || 'unknown';
+        console.error(`[port-proxy] Error proxying to localhost:${port}:`, err.message);
+        if (res && 'writeHead' in res && !res.headersSent) {
+            res.writeHead(502, { 'Content-Type': 'text/plain' });
+            res.end(`Port proxy error: could not connect to localhost:${port}`);
+        }
+    });
+    return proxy;
+}
+export function portProxyMiddleware(proxy) {
+    return async (req, res, next) => {
+        const target = extractPortProxyTarget(req);
+        if (!target) {
+            next();
+            return;
+        }
+        req.url = target.path;
+        if (target.connectionId) {
+            // Remote proxy via SSH tunnel
+            try {
+                const localPort = await sshManager.getOrCreateForwardTunnel(target.connectionId, target.port);
+                console.log(`[port-proxy] HTTP ${req.method} -> SSH:${target.connectionId}:${target.port} (via local:${localPort})${target.path}`);
+                proxy.web(req, res, { target: `http://127.0.0.1:${localPort}` });
+            }
+            catch (err) {
+                console.error(`[port-proxy] SSH tunnel error:`, err.message);
+                res.status(502).send(`SSH tunnel error: ${err.message}`);
+            }
+        }
+        else {
+            console.log(`[port-proxy] HTTP ${req.method} -> localhost:${target.port}${target.path}`);
+            proxy.web(req, res, { target: `http://127.0.0.1:${target.port}` });
+        }
+    };
+}
+export function isPortProxyUpgrade(req) {
+    return extractPortProxyTarget(req) !== null;
+}
+export async function handlePortProxyUpgrade(proxy, req, socket, head) {
+    const target = extractPortProxyTarget(req);
+    if (!target) {
+        socket.destroy();
+        return;
+    }
+    req.url = target.path;
+    let localPort = target.port;
+    if (target.connectionId) {
+        try {
+            localPort = await sshManager.getOrCreateForwardTunnel(target.connectionId, target.port);
+            console.log(`[port-proxy] WS upgrade -> SSH:${target.connectionId}:${target.port} (via local:${localPort})${target.path}`);
+        }
+        catch (err) {
+            console.error(`[port-proxy] SSH tunnel error for WS upgrade:`, err.message);
+            socket.destroy();
+            return;
+        }
+    }
+    else {
+        console.log(`[port-proxy] WS upgrade -> localhost:${target.port}${target.path}`);
+    }
+    proxy.ws(req, socket, head, {
+        target: `http://127.0.0.1:${localPort}`,
+    }, (err) => {
+        if (err) {
+            console.error(`[port-proxy] WS upgrade error to localhost:${localPort}:`, err.message);
+            socket.destroy();
+        }
+    });
+}

package/dist/src/web/preview-ws.d.ts

@@ -0,0 +1,5 @@
+import { WebSocketServer } from 'ws';
+import http from 'http';
+import { Duplex } from 'stream';
+export declare function isPreviewWsUpgrade(url: string): boolean;
+export declare function handlePreviewWsUpgrade(wss: WebSocketServer, req: http.IncomingMessage, socket: Duplex, head: Buffer): void;