zerg-ztc 0.1.0

package/vite.config.ts

@@ -0,0 +1,363 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { resolve, join, basename } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+import { loadEmulationProfiles } from './src/emulation/catalog.js';
+import { configStore } from './src/config.js';
+import { runShellCommand, resolveWorkingDir } from './src/utils/shell.js';
+import { createAgentFromConfig } from './src/agent/factory.js';
+import { listModels } from './src/utils/models.js';
+import { autoActivateSkills, buildSkillPrompt } from './src/skills/index.js';
+import { getSkillRegistry } from './src/skills/registry.js';
+
+export default defineConfig({
+  root: 'web/dev',
+  plugins: [
+    react(),
+    {
+      name: 'ztc-emulation',
+      configureServer(server) {
+        let skillCache: any[] | null = null;
+        const loadSkills = async () => {
+          if (skillCache) return skillCache;
+          skillCache = await getSkillRegistry();
+          return skillCache;
+        };
+        server.middlewares.use('/__emulation/list', (_req, res) => {
+          const payload = JSON.stringify(loadEmulationProfiles().map(profile => ({
+            id: profile.id,
+            name: profile.name,
+            description: profile.description,
+            systemPrompt: profile.systemPrompt,
+            tools: profile.tools
+          })));
+          res.statusCode = 200;
+          res.setHeader('Content-Type', 'application/json');
+          res.end(payload);
+        });
+        server.middlewares.use('/__config/get', async (_req, res) => {
+          await configStore.load(true);
+          const payload = JSON.stringify({
+            config: configStore.get(),
+            locationLabel: configStore.getConfigPath()
+          });
+          res.statusCode = 200;
+          res.setHeader('Content-Type', 'application/json');
+          res.end(payload);
+        });
+        server.middlewares.use('/__config/save', async (req, res) => {
+          const body = await new Promise<string>((resolve) => {
+            let data = '';
+            req.on('data', chunk => { data += chunk; });
+            req.on('end', () => resolve(data));
+          });
+          try {
+            const parsed = JSON.parse(body) as { config?: Record<string, unknown> };
+            if (parsed.config && typeof parsed.config === 'object') {
+              configStore.setAll(parsed.config);
+              await configStore.save();
+            }
+          } catch {
+            // ignore invalid payloads
+          }
+          const payload = JSON.stringify({
+            config: configStore.get(),
+            locationLabel: configStore.getConfigPath()
+          });
+          res.statusCode = 200;
+          res.setHeader('Content-Type', 'application/json');
+          res.end(payload);
+        });
+        server.middlewares.use('/__shell/cwd', (_req, res) => {
+          const payload = JSON.stringify({ cwd: process.cwd() });
+          res.statusCode = 200;
+          res.setHeader('Content-Type', 'application/json');
+          res.end(payload);
+        });
+        server.middlewares.use('/__shell/resolve', async (req, res) => {
+          const body = await new Promise<string>((resolve) => {
+            let data = '';
+            req.on('data', chunk => { data += chunk; });
+            req.on('end', () => resolve(data));
+          });
+          try {
+            const parsed = JSON.parse(body) as { cwd?: string; path?: string };
+            const base = parsed.cwd || process.cwd();
+            const next = await resolveWorkingDir(base, parsed.path || '');
+            const payload = JSON.stringify({ cwd: next });
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(payload);
+            return;
+          } catch (err) {
+            res.statusCode = 400;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: 'Invalid path' }));
+            return;
+          }
+        });
+        server.middlewares.use('/__shell/run', async (req, res) => {
+          const body = await new Promise<string>((resolve) => {
+            let data = '';
+            req.on('data', chunk => { data += chunk; });
+            req.on('end', () => resolve(data));
+          });
+          try {
+            const parsed = JSON.parse(body) as { command?: string; cwd?: string };
+            const command = parsed.command || '';
+            const cwd = parsed.cwd || process.cwd();
+            const result = await runShellCommand(command, cwd);
+            const payload = JSON.stringify(result);
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(payload);
+            return;
+          } catch (err) {
+            res.statusCode = 500;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: 'Command failed' }));
+            return;
+          }
+        });
+        server.middlewares.use('/__upload', async (req, res) => {
+          if (req.method !== 'POST') {
+            res.statusCode = 405;
+            res.end();
+            return;
+          }
+          const buffer = await new Promise<Buffer>((resolve) => {
+            const chunks: Buffer[] = [];
+            req.on('data', chunk => { chunks.push(Buffer.from(chunk)); });
+            req.on('end', () => resolve(Buffer.concat(chunks)));
+          });
+          const headerName = req.headers['x-filename'];
+          const rawName = typeof headerName === 'string' && headerName.trim().length > 0 ? headerName : 'upload.bin';
+          const safeName = basename(rawName).replace(/[^a-zA-Z0-9._-]/g, '_');
+          const dir = join(homedir(), '.ztc', 'uploads');
+          await mkdir(dir, { recursive: true });
+          const filePath = join(dir, `${Date.now()}-${randomUUID().slice(0, 8)}-${safeName}`);
+          await writeFile(filePath, buffer);
+          res.statusCode = 200;
+          res.setHeader('Content-Type', 'application/json');
+          res.end(JSON.stringify({ path: filePath }));
+        });
+        server.middlewares.use('/__file', async (req, res) => {
+          const url = new URL(req.url || '', 'http://localhost');
+          const rawPath = url.searchParams.get('path');
+          if (!rawPath) {
+            res.statusCode = 400;
+            res.end();
+            return;
+          }
+          const allowedRoots = [
+            join(homedir(), '.ztc', 'uploads'),
+            join(homedir(), '.ztc', 'clipboard')
+          ];
+          const resolvedPath = resolve(rawPath);
+          const allowed = allowedRoots.some(root => resolvedPath.startsWith(resolve(root)));
+          if (!allowed) {
+            res.statusCode = 403;
+            res.end();
+            return;
+          }
+          try {
+            const data = await (await import('fs/promises')).readFile(resolvedPath);
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'application/octet-stream');
+            res.end(data);
+          } catch {
+            res.statusCode = 404;
+            res.end();
+          }
+        });
+        server.middlewares.use('/__agent/run', async (req, res) => {
+          const body = await new Promise<string>((resolve) => {
+            let data = '';
+            req.on('data', chunk => { data += chunk; });
+            req.on('end', () => resolve(data));
+          });
+          try {
+            const parsed = JSON.parse(body) as { messages?: unknown[] };
+            const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+            const lastUser = [...messages].reverse().find(msg => msg && typeof msg === 'object' && (msg as any).role === 'user');
+            const text = lastUser && typeof (lastUser as any).content === 'string' ? (lastUser as any).content : '';
+            const skills = await loadSkills();
+            const activated = autoActivateSkills(text, skills);
+            const skillPrompt = buildSkillPrompt(activated);
+            await configStore.load();
+            const provider = configStore.getProvider();
+            const apiKey = configStore.getApiKey(provider);
+            const agent = createAgentFromConfig({
+              config: configStore.get(),
+              provider,
+              apiKey,
+              openaiCompatibleBaseUrl: configStore.getOpenAICompatibleBaseUrl(),
+              emulationId: configStore.getEmulationId(),
+              skillPrompt
+            });
+            if (!agent) {
+              res.statusCode = 400;
+              res.setHeader('Content-Type', 'application/json');
+              res.end(JSON.stringify({ error: 'No API key configured' }));
+              return;
+            }
+            const result = await agent.run(messages as any);
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({
+              content: result.content,
+              toolCalls: result.toolCalls,
+              usage: result.usage
+            }));
+            return;
+          } catch (err) {
+            const message = err instanceof Error ? err.message : 'Agent error';
+            res.statusCode = 500;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: message }));
+          }
+        });
+        server.middlewares.use('/__agent/stream', async (req, res) => {
+          const body = await new Promise<string>((resolve) => {
+            let data = '';
+            req.on('data', chunk => { data += chunk; });
+            req.on('end', () => resolve(data));
+          });
+          res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive'
+          });
+          const send = (event: string, payload: unknown) => {
+            res.write(`event: ${event}\n`);
+            res.write(`data: ${JSON.stringify(payload)}\n\n`);
+          };
+          let cleanup: (() => void) | null = null;
+          try {
+            const parsed = JSON.parse(body) as { messages?: unknown[] };
+            const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+            const lastUser = [...messages].reverse().find(msg => msg && typeof msg === 'object' && (msg as any).role === 'user');
+            const text = lastUser && typeof (lastUser as any).content === 'string' ? (lastUser as any).content : '';
+            const skills = await loadSkills();
+            const activated = autoActivateSkills(text, skills);
+            const skillPrompt = buildSkillPrompt(activated);
+            if (activated.length > 0) {
+              send('skill_activated', { skills: activated.map(skill => ({ id: skill.id, name: skill.name })) });
+            }
+            await configStore.load();
+            const provider = configStore.getProvider();
+            const apiKey = configStore.getApiKey(provider);
+            const agent = createAgentFromConfig({
+              config: configStore.get(),
+              provider,
+              apiKey,
+              openaiCompatibleBaseUrl: configStore.getOpenAICompatibleBaseUrl(),
+              emulationId: configStore.getEmulationId(),
+              skillPrompt
+            });
+            if (!agent) {
+              send('error', { error: 'No API key configured' });
+              res.end();
+              return;
+            }
+            cleanup = agent.on((event) => {
+              if (event.type === 'stream_start') {
+                send('stream_start', {});
+              } else if (event.type === 'stream_delta') {
+                send('stream_delta', { content: event.content });
+              } else if (event.type === 'stream_end') {
+                send('stream_end', {});
+              } else if (event.type === 'token_usage') {
+                send('token_usage', { usage: event.usage });
+              } else if (event.type === 'tool_start') {
+                send('tool_start', { tool: event.tool, args: event.args });
+              } else if (event.type === 'tool_end') {
+                send('tool_end', { tool: event.tool, result: event.result });
+              } else if (event.type === 'tool_error') {
+                send('tool_error', { tool: event.tool, error: event.error });
+              }
+            });
+            const result = await agent.run(messages as any);
+            send('result', {
+              content: result.content,
+              toolCalls: result.toolCalls,
+              usage: result.usage
+            });
+            res.end();
+          } catch (err) {
+            const message = err instanceof Error ? err.message : 'Agent error';
+            send('error', { error: message });
+            res.end();
+          } finally {
+            cleanup?.();
+          }
+        });
+        server.middlewares.use('/__models/list', async (req, res) => {
+          try {
+            await configStore.load();
+            const url = new URL(req.url || '', 'http://localhost');
+            const provider = url.searchParams.get('provider') || configStore.getProvider();
+            const models = await listModels({
+              provider,
+              apiKey: configStore.getApiKey(provider),
+              baseUrl: configStore.getOpenAICompatibleBaseUrl()
+            });
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ models }));
+          } catch (err) {
+            const message = err instanceof Error ? err.message : 'Models error';
+            res.statusCode = 500;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: message }));
+          }
+        });
+        server.middlewares.use('/__skills/list', async (_req, res) => {
+          try {
+            const skills = await loadSkills();
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ skills }));
+          } catch (err) {
+            const message = err instanceof Error ? err.message : 'Skills error';
+            res.statusCode = 500;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: message }));
+          }
+        });
+      }
+    }
+  ],
+  esbuild: {
+    target: 'esnext'
+  },
+  resolve: {
+    alias: [
+      { find: '@src', replacement: resolve(__dirname, 'src') }
+    ]
+  },
+  build: {
+    target: 'esnext',
+    outDir: '../../dist-web',
+    emptyOutDir: true
+  },
+  optimizeDeps: {
+    esbuildOptions: {
+      target: 'esnext'
+    }
+  },
+  ssr: {
+    target: 'esnext'
+  },
+  define: {
+    'import.meta.env.LEGACY': 'false'
+  },
+  server: {
+    port: 5175,
+    fs: {
+      allow: ['.']
+    }
+  }
+});