@lovelybunch/api 1.0.7

package/dist/routes/api/v1/resources/index.js

@@ -0,0 +1,6 @@
+import { Hono } from 'hono';
+import { GET, POST } from './route.js';
+const app = new Hono();
+app.get('/', GET);
+app.post('/', POST);
+export default app;

package/dist/routes/api/v1/resources/route.d.ts

@@ -0,0 +1,51 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        name: string;
+        type: string;
+        size: number;
+        uploadedAt: string;
+        metadata: {
+            tags?: string[];
+            description?: string;
+        };
+        path: string;
+        thumbnailPath?: string;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        name: string;
+        type: string;
+        size: number;
+        uploadedAt: string;
+        metadata: {
+            tags?: string[];
+            description?: string;
+        };
+        path: string;
+        thumbnailPath?: string;
+    };
+}, 201, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;

package/dist/routes/api/v1/resources/route.js

@@ -0,0 +1,147 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+// Generate a random ID
+function generateId() {
+    return `res-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+const RESOURCES_DIR = '.gait/resources';
+const FILES_DIR = path.join(RESOURCES_DIR, 'files');
+const METADATA_DIR = path.join(RESOURCES_DIR, 'metadata');
+const THUMBNAILS_DIR = path.join(RESOURCES_DIR, 'thumbnails');
+async function ensureDirectories() {
+    await fs.mkdir(FILES_DIR, { recursive: true });
+    await fs.mkdir(METADATA_DIR, { recursive: true });
+    await fs.mkdir(THUMBNAILS_DIR, { recursive: true });
+}
+async function getResourceMetadata(id) {
+    try {
+        const metadataPath = path.join(METADATA_DIR, `${id}.json`);
+        const content = await fs.readFile(metadataPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+async function saveResourceMetadata(resource) {
+    const metadataPath = path.join(METADATA_DIR, `${resource.id}.json`);
+    await fs.writeFile(metadataPath, JSON.stringify(resource, null, 2), 'utf-8');
+}
+async function listAllResources() {
+    try {
+        const files = await fs.readdir(METADATA_DIR);
+        const resources = await Promise.all(files
+            .filter(f => f.endsWith('.json'))
+            .map(async (file) => {
+            const content = await fs.readFile(path.join(METADATA_DIR, file), 'utf-8');
+            return JSON.parse(content);
+        }));
+        return resources.sort((a, b) => new Date(b.uploadedAt).getTime() - new Date(a.uploadedAt).getTime());
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+async function generateThumbnail(imageBuffer, id, mimeType) {
+    // For now, we'll create a simple placeholder thumbnail
+    // In a production environment, you'd use a library like Sharp for proper image processing
+    const thumbnailName = `${id}_thumb.jpg`;
+    const thumbnailPath = path.join(THUMBNAILS_DIR, thumbnailName);
+    try {
+        // This is a placeholder - in production, use Sharp or similar
+        // For now, we'll just copy the original image as the thumbnail
+        await fs.writeFile(thumbnailPath, imageBuffer);
+        return thumbnailName;
+    }
+    catch (error) {
+        console.error('Failed to generate thumbnail:', error);
+        throw error;
+    }
+}
+export async function GET(c) {
+    try {
+        await ensureDirectories();
+        const resources = await listAllResources();
+        return c.json({
+            success: true,
+            data: resources
+        });
+    }
+    catch (error) {
+        console.error('Error listing resources:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'LIST_RESOURCES_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}
+export async function POST(c) {
+    try {
+        await ensureDirectories();
+        const formData = await c.req.formData();
+        const file = formData.get('file');
+        const tags = formData.get('tags');
+        const description = formData.get('description');
+        if (!file) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'NO_FILE_PROVIDED',
+                    message: 'No file was provided'
+                }
+            }, 400);
+        }
+        const id = generateId();
+        const fileExtension = path.extname(file.name);
+        const fileName = `${id}${fileExtension}`;
+        const filePath = path.join(FILES_DIR, fileName);
+        // Save the file
+        const arrayBuffer = await file.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        await fs.writeFile(filePath, buffer);
+        // Create resource metadata
+        const resource = {
+            id,
+            name: file.name,
+            type: file.type,
+            size: file.size,
+            uploadedAt: new Date().toISOString(),
+            metadata: {
+                tags: tags ? tags.split(',').map(t => t.trim()) : [],
+                description: description || undefined
+            },
+            path: fileName
+        };
+        // Generate thumbnail for images
+        if (file.type.startsWith('image/')) {
+            try {
+                resource.thumbnailPath = await generateThumbnail(buffer, id, file.type);
+            }
+            catch (error) {
+                console.warn('Failed to generate thumbnail:', error);
+            }
+        }
+        await saveResourceMetadata(resource);
+        return c.json({
+            success: true,
+            data: resource
+        }, 201);
+    }
+    catch (error) {
+        console.error('Error uploading resource:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'UPLOAD_RESOURCE_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}

package/dist/routes/api/v1/search/route.d.ts

@@ -0,0 +1,3 @@
+import { NextRequest } from 'next/server';
+export declare const dynamic = "force-dynamic";
+export declare function GET(request: NextRequest): Promise<any>;

package/dist/routes/api/v1/search/route.js

@@ -0,0 +1,39 @@
+import { NextResponse } from 'next/server';
+import { FileStorageAdapter } from '@/lib/storage/file-storage';
+// Force dynamic rendering for this route since it uses searchParams
+export const dynamic = 'force-dynamic';
+const storage = new FileStorageAdapter();
+export async function GET(request) {
+    try {
+        const searchParams = request.nextUrl.searchParams;
+        const query = searchParams.get('q');
+        if (!query) {
+            return NextResponse.json({
+                success: false,
+                error: {
+                    code: 'MISSING_QUERY',
+                    message: 'Query parameter "q" is required'
+                }
+            }, { status: 400 });
+        }
+        const results = await storage.searchCPs(query);
+        return NextResponse.json({
+            success: true,
+            data: results,
+            metadata: {
+                query,
+                resultCount: results.length
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error searching proposals:', error);
+        return NextResponse.json({
+            success: false,
+            error: {
+                code: 'SEARCH_ERROR',
+                message: error.message
+            }
+        }, { status: 500 });
+    }
+}

package/dist/routes/api/v1/terminal/[proposalId]/create/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const create: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default create;

package/dist/routes/api/v1/terminal/[proposalId]/create/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { POST } from './route.js';
+const create = new Hono();
+create.post('/', POST);
+export default create;

package/dist/routes/api/v1/terminal/[proposalId]/create/route.d.ts

@@ -0,0 +1,10 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    sessionId: string;
+    proposalId: string;
+    createdAt: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

package/dist/routes/api/v1/terminal/[proposalId]/create/route.js

@@ -0,0 +1,27 @@
+import { getGlobalTerminalManager } from '../../../../../../lib/terminal/global-manager.js';
+import { loadUserSettings } from '../../../../../../lib/user-preferences.js';
+export async function POST(c) {
+    try {
+        const proposalId = c.req.param('proposalId');
+        const body = await c.req.json().catch(() => ({}));
+        const { enableLogging = false } = body;
+        if (!proposalId) {
+            return c.json({ error: 'Proposal ID is required' }, 400);
+        }
+        // Load user settings to get shell preference
+        const userSettings = await loadUserSettings();
+        const shellPreference = (userSettings.preferences.terminalShell || 'bash');
+        // Create a new terminal session for this proposal
+        const terminalManager = getGlobalTerminalManager();
+        const session = await terminalManager.createSession(proposalId, enableLogging, shellPreference);
+        return c.json({
+            sessionId: session.id,
+            proposalId: session.proposalId,
+            createdAt: session.createdAt,
+        });
+    }
+    catch (error) {
+        console.error('Error creating terminal session:', error);
+        return c.json({ error: 'Failed to create terminal session' }, 500);
+    }
+}

package/dist/routes/api/v1/terminal/[proposalId]/destroy/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/routes/api/v1/terminal/[proposalId]/destroy/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { POST } from './route.js';
+const app = new Hono();
+app.post('/', POST);
+export default app;

package/dist/routes/api/v1/terminal/[proposalId]/destroy/route.d.ts

@@ -0,0 +1,10 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

package/dist/routes/api/v1/terminal/[proposalId]/destroy/route.js

@@ -0,0 +1,21 @@
+import { getGlobalTerminalManager } from '../../../../../../lib/terminal/global-manager.js';
+export async function POST(c) {
+    try {
+        const proposalId = c.req.param('proposalId');
+        const body = await c.req.json();
+        const { sessionId } = body;
+        if (!sessionId) {
+            return c.json({ error: 'Session ID is required' }, 400);
+        }
+        const terminalManager = getGlobalTerminalManager();
+        const success = terminalManager.destroySession(sessionId);
+        if (!success) {
+            return c.json({ error: 'Session not found' }, 404);
+        }
+        return c.json({ success: true });
+    }
+    catch (error) {
+        console.error('Error destroying terminal session:', error);
+        return c.json({ error: 'Failed to destroy terminal session' }, 500);
+    }
+}

package/dist/routes/api/v1/terminal/[proposalId]/resize/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/routes/api/v1/terminal/[proposalId]/resize/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { POST } from './route.js';
+const app = new Hono();
+app.post('/', POST);
+export default app;

package/dist/routes/api/v1/terminal/[proposalId]/resize/route.d.ts

@@ -0,0 +1,10 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

package/dist/routes/api/v1/terminal/[proposalId]/resize/route.js

@@ -0,0 +1,21 @@
+import { getGlobalTerminalManager } from '../../../../../../lib/terminal/global-manager.js';
+export async function POST(c) {
+    try {
+        const proposalId = c.req.param('proposalId');
+        const body = await c.req.json();
+        const { sessionId, cols, rows } = body;
+        if (!sessionId || !cols || !rows) {
+            return c.json({ error: 'Session ID, cols, and rows are required' }, 400);
+        }
+        const terminalManager = getGlobalTerminalManager();
+        const success = terminalManager.resizeSession(sessionId, cols, rows);
+        if (!success) {
+            return c.json({ error: 'Session not found or resize failed' }, 404);
+        }
+        return c.json({ success: true });
+    }
+    catch (error) {
+        console.error('Error resizing terminal session:', error);
+        return c.json({ error: 'Failed to resize terminal session' }, 500);
+    }
+}

package/dist/routes/api/v1/terminal/sessions/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const sessions: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default sessions;

package/dist/routes/api/v1/terminal/sessions/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { GET } from './route.js';
+const sessions = new Hono();
+sessions.get('/', GET);
+export default sessions;

package/dist/routes/api/v1/terminal/sessions/route.d.ts

@@ -0,0 +1,6 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    sessions: any;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

package/dist/routes/api/v1/terminal/sessions/route.js

@@ -0,0 +1,29 @@
+import { getGlobalTerminalManager } from '../../../../../lib/terminal/global-manager.js';
+export async function GET(c) {
+    try {
+        const url = new URL(c.req.url);
+        const searchParams = url.searchParams;
+        const proposalId = searchParams.get('proposalId');
+        const terminalManager = getGlobalTerminalManager();
+        let sessions;
+        if (proposalId) {
+            sessions = terminalManager.getSessionsByProposal(proposalId);
+        }
+        else {
+            sessions = terminalManager.getAllSessions();
+        }
+        // Return session info without the PTY instance
+        const sessionInfo = sessions.map(session => ({
+            id: session.id,
+            proposalId: session.proposalId,
+            createdAt: session.createdAt,
+            lastActivity: session.lastActivity,
+            connected: !!session.websocket,
+        }));
+        return c.json({ sessions: sessionInfo });
+    }
+    catch (error) {
+        console.error('Error getting terminal sessions:', error);
+        return c.json({ error: 'Failed to get terminal sessions' }, 500);
+    }
+}

package/dist/routes/api/v1/user/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/routes/api/v1/user/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import settings from './settings/index.js';
+const app = new Hono();
+app.route('/settings', settings);
+export default app;

package/dist/routes/api/v1/user/preferences/route.d.ts

@@ -0,0 +1,11 @@
+import { NextRequest } from 'next/server';
+/**
+ * GET /api/v1/user/preferences
+ * Get user preferences
+ */
+export declare function GET(): Promise<any>;
+/**
+ * PUT /api/v1/user/preferences
+ * Update user preferences
+ */
+export declare function PUT(request: NextRequest): Promise<any>;

package/dist/routes/api/v1/user/preferences/route.js

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server';
+import { updateUserPreferences, loadUserSettings } from '@/lib/user-preferences';
+/**
+ * GET /api/v1/user/preferences
+ * Get user preferences
+ */
+export async function GET() {
+    try {
+        const settings = await loadUserSettings();
+        return NextResponse.json({ success: true, data: settings.preferences });
+    }
+    catch (error) {
+        console.error('Failed to load user preferences:', error);
+        return NextResponse.json({ success: false, error: 'Failed to load user preferences' }, { status: 500 });
+    }
+}
+/**
+ * PUT /api/v1/user/preferences
+ * Update user preferences
+ */
+export async function PUT(request) {
+    try {
+        const preferences = await request.json();
+        const settings = await updateUserPreferences(preferences);
+        return NextResponse.json({ success: true, data: settings.preferences });
+    }
+    catch (error) {
+        console.error('Failed to update user preferences:', error);
+        return NextResponse.json({ success: false, error: 'Failed to update user preferences' }, { status: 500 });
+    }
+}

package/dist/routes/api/v1/user/profile/route.d.ts

@@ -0,0 +1,11 @@
+import { NextRequest } from 'next/server';
+/**
+ * GET /api/v1/user/profile
+ * Get user profile information
+ */
+export declare function GET(): Promise<any>;
+/**
+ * PUT /api/v1/user/profile
+ * Update user profile information
+ */
+export declare function PUT(request: NextRequest): Promise<any>;

package/dist/routes/api/v1/user/profile/route.js

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server';
+import { updateUserProfile, loadUserSettings } from '@/lib/user-preferences';
+/**
+ * GET /api/v1/user/profile
+ * Get user profile information
+ */
+export async function GET() {
+    try {
+        const settings = await loadUserSettings();
+        return NextResponse.json({ success: true, data: settings.profile });
+    }
+    catch (error) {
+        console.error('Failed to load user profile:', error);
+        return NextResponse.json({ success: false, error: 'Failed to load user profile' }, { status: 500 });
+    }
+}
+/**
+ * PUT /api/v1/user/profile
+ * Update user profile information
+ */
+export async function PUT(request) {
+    try {
+        const profile = await request.json();
+        const settings = await updateUserProfile(profile);
+        return NextResponse.json({ success: true, data: settings.profile });
+    }
+    catch (error) {
+        console.error('Failed to update user profile:', error);
+        return NextResponse.json({ success: false, error: 'Failed to update user profile' }, { status: 500 });
+    }
+}

package/dist/routes/api/v1/user/settings/index.d.ts

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/user/settings/index.js

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/user/settings/route.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/routes/api/v1/user/settings/route.js

@@ -0,0 +1,51 @@
+import { Hono } from 'hono';
+import { loadUserSettings, saveUserSettings } from '../../../../../lib/user-preferences.js';
+const app = new Hono();
+/**
+ * GET /api/v1/user/settings
+ * Load user settings from ~/.gait/user-settings.json
+ */
+app.get('/', async (c) => {
+    try {
+        const settings = await loadUserSettings();
+        return c.json({ success: true, data: settings });
+    }
+    catch (error) {
+        console.error('Failed to load user settings:', error);
+        return c.json({ success: false, error: 'Failed to load user settings' }, 500);
+    }
+});
+/**
+ * PUT /api/v1/user/settings
+ * Update complete user settings
+ */
+app.put('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        const { profile, preferences } = body;
+        if (!profile && !preferences) {
+            return c.json({ success: false, error: 'Profile or preferences data required' }, 400);
+        }
+        let settings = await loadUserSettings();
+        if (profile) {
+            settings.profile = { ...settings.profile, ...profile };
+        }
+        if (preferences) {
+            settings.preferences = {
+                ...settings.preferences,
+                ...preferences,
+                notifications: {
+                    ...settings.preferences.notifications,
+                    ...preferences.notifications,
+                }
+            };
+        }
+        await saveUserSettings(settings);
+        return c.json({ success: true, data: settings });
+    }
+    catch (error) {
+        console.error('Failed to update user settings:', error);
+        return c.json({ success: false, error: 'Failed to update user settings' }, 500);
+    }
+});
+export default app;

package/dist/server-with-static.d.ts

@@ -0,0 +1,4 @@
+export declare function startServer(options?: {
+    port?: number;
+    host?: string;
+}): Promise<import("@hono/node-server").ServerType>;