awel 0.1.0

package/dist/cli/server.js

@@ -0,0 +1,104 @@
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import httpProxy from 'http-proxy';
+import { createProxyMiddleware } from './proxy.js';
+import { createAgentRoute } from './agent.js';
+import { createUndoRoute } from './undo.js';
+import { createInspectorRoute } from './inspector.js';
+import { createCommentPopupRoute } from './comment-popup.js';
+import { trackProxySocket } from './devserver.js';
+import { getMimeType } from './config.js';
+import { awel } from './logger.js';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFileSync, existsSync } from 'fs';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Serves a static file with proper MIME type, or returns null if not found
+ */
+function serveStaticFile(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    const buffer = readFileSync(filePath);
+    // Convert Node Buffer to ArrayBuffer for Hono compatibility
+    const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    return {
+        content: arrayBuffer,
+        mimeType: getMimeType(filePath)
+    };
+}
+/**
+ * Serves the dashboard index.html, or returns null if not found
+ */
+function serveDashboardIndex() {
+    const indexPath = join(__dirname, '../dashboard/index.html');
+    if (!existsSync(indexPath))
+        return null;
+    return readFileSync(indexPath, 'utf-8');
+}
+export async function startServer({ awelPort, targetPort, projectCwd }) {
+    const app = new Hono();
+    // Create a proxy for WebSocket connections
+    const wsProxy = httpProxy.createProxyServer({
+        target: `http://localhost:${targetPort}`,
+        ws: true,
+    });
+    wsProxy.on('error', (err) => {
+        console.error('WebSocket proxy error:', err.message);
+    });
+    // Track target-side sockets so we can pause HMR during agent streams
+    wsProxy.on('open', (proxySocket) => {
+        trackProxySocket(proxySocket);
+    });
+    // Mount agent API routes
+    app.route('/', createAgentRoute(projectCwd, targetPort));
+    // Mount undo API routes
+    app.route('/', createUndoRoute(projectCwd));
+    // Mount inspector relay routes
+    app.route('/', createInspectorRoute(projectCwd));
+    // Serve the comment popup page (loaded in an iframe by the host script)
+    app.route('/', createCommentPopupRoute());
+    // Serve the host script
+    app.get('/_awel/host.js', async (c) => {
+        const hostDistPath = join(__dirname, '../host/host.js');
+        const file = serveStaticFile(hostDistPath);
+        if (file) {
+            return c.body(file.content, 200, { 'Content-Type': file.mimeType });
+        }
+        return c.text('Host script not found. Run npm run build:host first.', 404);
+    });
+    // Serve the dashboard app
+    app.get('/_awel/dashboard', async (c) => {
+        const html = serveDashboardIndex();
+        if (html)
+            return c.html(html);
+        return c.text('Dashboard not found. Run npm run build:dashboard first.', 404);
+    });
+    app.get('/_awel/dashboard/*', async (c) => {
+        const path = c.req.path.replace('/_awel/dashboard/', '');
+        const filePath = join(__dirname, '../dashboard', path);
+        const file = serveStaticFile(filePath);
+        if (file) {
+            return c.body(file.content, 200, { 'Content-Type': file.mimeType });
+        }
+        // Fallback to index.html for SPA routing
+        const html = serveDashboardIndex();
+        if (html)
+            return c.html(html);
+        return c.text('Not found', 404);
+    });
+    // Proxy all other requests to the target app
+    app.all('*', createProxyMiddleware(targetPort, projectCwd));
+    // Create the HTTP server with Hono
+    const server = serve({
+        fetch: app.fetch,
+        port: awelPort,
+    }, (info) => {
+        awel.log(`🎛️  Awel control server running on http://localhost:${info.port}`);
+    });
+    // Handle WebSocket upgrades for HMR
+    server.on('upgrade', (req, socket, head) => {
+        wsProxy.ws(req, socket, head);
+    });
+}

package/dist/cli/session.d.ts

@@ -0,0 +1,32 @@
+import type { StreamProvider, ResponseMessage } from './providers/types.js';
+import type { ModelMessage, UserContent } from 'ai';
+/**
+ * Returns the existing session if the model matches, otherwise creates a new
+ * provider while preserving message history. Messages are only reset when
+ * switching to or from the claude-code provider, whose self-contained tool
+ * set is incompatible with messages produced by other providers.
+ */
+export declare function getOrCreateSession(modelId: string): {
+    provider: StreamProvider;
+};
+/**
+ * Builds the messages array to send to the provider.
+ * Returns the full accumulated history plus the new user message.
+ *
+ * Includes a safety net: if the session ends with an orphan user message
+ * (e.g. from an aborted stream that didn't clean up), it's removed to
+ * avoid consecutive user messages that cause API 400 errors.
+ */
+export declare function getSessionMessages(prompt: string | UserContent): ModelMessage[];
+/**
+ * Appends a user message to the session history.
+ */
+export declare function appendUserMessage(content: string | UserContent): void;
+/**
+ * Appends LLM response messages to the session history.
+ */
+export declare function appendResponseMessages(msgs: ResponseMessage[]): void;
+/**
+ * Resets the session entirely (called on history clear).
+ */
+export declare function resetSession(): void;

package/dist/cli/session.js

@@ -0,0 +1,77 @@
+// ─── Chat Session ────────────────────────────────────────────
+// Module-level singleton managing multi-turn conversation state.
+// The provider is cached and reused across requests; a model switch
+// swaps the provider while preserving message history (unless switching
+// to or from the self-contained claude-code provider).
+import { resolveProvider } from './providers/registry.js';
+let session = null;
+/**
+ * Returns the existing session if the model matches, otherwise creates a new
+ * provider while preserving message history. Messages are only reset when
+ * switching to or from the claude-code provider, whose self-contained tool
+ * set is incompatible with messages produced by other providers.
+ */
+export function getOrCreateSession(modelId) {
+    if (session && session.modelId === modelId) {
+        return { provider: session.provider };
+    }
+    const { provider, modelProvider } = resolveProvider(modelId);
+    const canPreserveMessages = session !== null &&
+        session.modelProvider !== 'claude-code' &&
+        modelProvider !== 'claude-code';
+    session = {
+        modelId,
+        modelProvider,
+        provider,
+        messages: canPreserveMessages ? session.messages : [],
+    };
+    return { provider: session.provider };
+}
+/**
+ * Builds the messages array to send to the provider.
+ * Returns the full accumulated history plus the new user message.
+ *
+ * Includes a safety net: if the session ends with an orphan user message
+ * (e.g. from an aborted stream that didn't clean up), it's removed to
+ * avoid consecutive user messages that cause API 400 errors.
+ */
+export function getSessionMessages(prompt) {
+    const userMessage = { role: 'user', content: prompt };
+    if (!session) {
+        return [userMessage];
+    }
+    // Safety net: strip trailing orphan user messages to maintain alternation.
+    // This can happen if a stream was aborted between appendUserMessage and
+    // appendResponseMessages in a previous request.
+    const messages = [...session.messages];
+    while (messages.length > 0 && messages[messages.length - 1].role === 'user') {
+        messages.pop();
+    }
+    // Also fix the actual session to prevent accumulation
+    if (messages.length !== session.messages.length) {
+        session.messages = messages;
+    }
+    return [...messages, userMessage];
+}
+/**
+ * Appends a user message to the session history.
+ */
+export function appendUserMessage(content) {
+    if (!session)
+        return;
+    session.messages.push({ role: 'user', content });
+}
+/**
+ * Appends LLM response messages to the session history.
+ */
+export function appendResponseMessages(msgs) {
+    if (!session)
+        return;
+    session.messages.push(...msgs);
+}
+/**
+ * Resets the session entirely (called on history clear).
+ */
+export function resetSession() {
+    session = null;
+}