@agent-spaces/server 0.3.0 → 0.3.2

package/dist/agents/issue-agent-runner.js

@@ -35,7 +35,6 @@ export async function runIssueAutomation(workspaceId, issueId, ctx) {
         return;
     }
     console.warn(`[issue-runner] no workflow configured for issue workspaceId=${workspaceId} issueId=${issueId}`);
-    markIssueError(workspaceId, issueId, 'No workflow configured for issue', ctx);
 }
 export function hasActiveIssueAutomation(workspaceId) {
     return agentService.list(workspaceId).some((session) => session.status === 'active' &&

package/dist/agents/issue-task-controller.js

@@ -7,6 +7,7 @@ import * as workspaceService from '../services/workspace.js';
 import { mapWorkflowToTaskDrafts, validateWorkflowForRun } from '../services/workflow.js';
 import { createIssueFunctionTools } from '../services/builtin-tools.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
+import { prependPersistentAgentContext } from '../services/persistent-agent-context.js';
 import { completeIssueAgentProgress, createIssueAgentProgress, createIssueAgentProgressTracker } from './issue-agent-progress.js';
 const ACTIVE_TASK_STATUSES = ['running', 'reviewing', 'retrying', 'waiting_review'];
 export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, ctx) {
@@ -45,7 +46,7 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
         },
     });
     const runtime = createRuntimeForPreset(taskSyncPreset);
-    const result = await runtime.execute(buildTaskSyncPrompt(issue, input, taskSyncWorkingDir), taskSyncWorkingDir, {
+    const result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskSyncPrompt(issue, input, taskSyncWorkingDir), taskSyncWorkingDir, taskSyncPreset), taskSyncWorkingDir, {
         maxTurns: 20,
         mcpServers: undefined,
         functionTools: createTaskSyncTools(workspaceId, issue, taskSyncPreset, ctx),
@@ -184,7 +185,7 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
         agentId: taskAgent.id,
         data: `[debug] workflow agentConfigId=${taskAgentPreset.id} role=${taskAgentPreset.role} taskAgentConfigId=${runningTask.agentConfigId || '(fallback)'} runtime=${taskAgentPreset.runtimeKind ?? 'open-agent-sdk'}`,
     });
-    const result = await runtime.execute(buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, {
+    const result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, taskAgentPreset), agentWorkingDir, {
         maxTurns: 100,
         mcpServers: agentService.getMcpServers(taskAgentPreset.mcps),
         functionTools: createCurrentIssueTools(workspaceId, issue, taskAgentPreset),
@@ -324,10 +325,10 @@ export function createTasksFromWorkflow(workspaceId, issueId, template, ctx) {
     }
     const drafts = mapWorkflowToTaskDrafts(template);
     issueService.updateStatus(workspaceId, issueId, 'planned');
-    ctx.broadcast('issue.status_changed', { issueId, oldStatus: issue.status, newStatus: 'planned' });
+    ctx.broadcast('issue.status_changed', { issueId, from: issue.status, to: 'planned' });
     replaceIssueTasksFromDrafts(workspaceId, issueId, ctx, drafts);
     issueService.updateStatus(workspaceId, issueId, 'in_progress');
-    ctx.broadcast('issue.status_changed', { issueId, oldStatus: 'planned', newStatus: 'in_progress' });
+    ctx.broadcast('issue.status_changed', { issueId, from: 'planned', to: 'in_progress' });
     ctx.broadcast('issue.updated', issueService.getById(workspaceId, issueId));
     scheduleRunnableIssueTasks(workspaceId, issueId, ctx).catch((err) => {
         console.error(`[workflow] task scheduling failed for issue ${issueId}:`, err);
@@ -435,6 +436,15 @@ function createRuntimeForPreset(preset) {
 function resolveIssueWorkspaceRoot(workspaceId) {
     return workspaceService.getById(workspaceId)?.boundDirs?.[0] || process.cwd();
 }
+function buildIssueAgentPrompt(workspaceId, prompt, workingDir, preset) {
+    return prependPersistentAgentContext(prompt, {
+        workspaceId,
+        workingDir,
+        boundDirs: workspaceService.getById(workspaceId)?.boundDirs,
+        includeWorkspacePrompt: false,
+        excludeNativeClaudeMd: preset.runtimeKind === 'claude-code',
+    });
+}
 function buildTaskSyncPrompt(issue, input, workingDir) {
     return [
         'You are the issue task synchronization controller.',

package/dist/app.js

@@ -27,6 +27,7 @@ import subscriptionRouter from './routes/subscription.js';
 import agentSseRouter from './routes/agent-sse.js';
 import searchRouter from './routes/search.js';
 import notificationRouter from './routes/notification.js';
+import speechRecognitionRouter, { handleSpeechStream } from './routes/speech-recognition.js';
 import { getUserSettings, setUserAvatarUrl, removeUserAvatarUrl } from './storage/user-settings-store.js';
 import { authMiddleware, verifyToken } from './middleware/auth.js';
 import { handleConnection } from './ws/handler.js';
@@ -100,6 +101,27 @@ app.use('/api/workspaces/:id/commands', commandRouter);
 app.use('/api/workspaces/:id/agents', agentRouter);
 app.use('/api/workspaces/:id/tasks', taskRouter);
 app.use('/api/workspaces/:id/git', gitRouter);
+// Global git config (no workspace context needed)
+import { gitGetConfig as _gitGetConfig, gitSetConfig as _gitSetConfig } from './adapters/git.js';
+app.get('/api/git-config', async (_req, res) => {
+    try {
+        const config = await _gitGetConfig('global');
+        res.json(config);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+app.post('/api/git-config', async (req, res) => {
+    try {
+        const { name, email, proxy } = req.body;
+        await _gitSetConfig('global', { name, email, proxy });
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
 app.use('/api/workspaces/:id/search', searchRouter);
 app.use('/api/workspaces/:id/notifications', notificationRouter);
 app.use('/api/agents', agentRouter);
@@ -108,6 +130,7 @@ app.use('/api/folder', folderRouter);
 app.use('/api/skills', skillRouter);
 app.use('/api/mcps', mcpRouter);
 app.use('/api/subscriptions', subscriptionRouter);
+app.use('/api/speech-recognition', speechRecognitionRouter);
 // Serve static web frontend in production (after API routes, before catch-all)
 const webDir = resolveRuntimeDir('web');
 if (existsSync(webDir)) {
@@ -134,7 +157,18 @@ else {
     console.warn('[server] web frontend not found at', webDir, '- run \`pnpm build\` first');
 }
 const server = createServer(app);
-const wss = new WebSocketServer({ server, path: '/ws' });
+const wss = new WebSocketServer({ noServer: true });
+// Speech recognition WebSocket on /ws/speech
+const speechWss = new WebSocketServer({ noServer: true });
+speechWss.on('connection', (ws, req) => {
+    const token = new URL(req.url || '', `http://localhost:${PORT}`).searchParams.get('token');
+    if (!verifyToken(token)) {
+        ws.close(4003, 'Unauthorized');
+        return;
+    }
+    const configId = new URL(req.url || '', `http://localhost:${PORT}`).searchParams.get('configId') || undefined;
+    handleSpeechStream(ws, configId);
+});
 wss.on('connection', (ws, req) => {
     const url = new URL(req.url || '', `http://localhost:${PORT}`);
     const workspaceId = url.searchParams.get('workspaceId');
@@ -149,6 +183,22 @@ wss.on('connection', (ws, req) => {
     }
     handleConnection(ws, workspaceId);
 });
+server.on('upgrade', (req, socket, head) => {
+    const { pathname } = new URL(req.url || '/', `http://localhost:${PORT}`);
+    if (pathname === '/ws') {
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            wss.emit('connection', ws, req);
+        });
+        return;
+    }
+    if (pathname === '/ws/speech') {
+        speechWss.handleUpgrade(req, socket, head, (ws) => {
+            speechWss.emit('connection', ws, req);
+        });
+        return;
+    }
+    socket.destroy();
+});
 const HOST = process.env.HOST || '0.0.0.0';
 server.listen(PORT, HOST, () => {
     console.log(`[server] listening on http://${HOST}:${PORT}`);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-spaces/server",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "app.js",
   "packageManager": "pnpm@10.17.1",

package/dist/routes/agent-sse.js

@@ -45,6 +45,7 @@ router.post('/run', async (req, res) => {
     const configDir = agentService.getAgentConfigDir(workspaceId, { ...preset, skills: requestedSkills });
     const skills = agentService.getAvailableSkillNames(configDir, requestedSkills);
     const output = [];
+    const workingDir = agentService.resolveWorkingDir(workspaceId, preset);
     let completed = false;
     prepareSse(res);
     writeSse(res, 'session', { session, workspaceId });
@@ -68,8 +69,10 @@ router.post('/run', async (req, res) => {
             mcpServers: Object.keys(mcpServers ?? {}),
             skills,
             boundDirs: workspace.boundDirs,
+            workingDir,
+            excludeNativeClaudeMd: preset.runtimeKind === 'claude-code',
             builtInTools: [],
-        }), agentService.resolveWorkingDir(workspaceId, preset), {
+        }), workingDir, {
             maxTurns: normalizeMaxTurns(body.maxTurns),
             mcpServers,
             skills,

package/dist/routes/agent.js

@@ -1,5 +1,6 @@
 import { Router } from 'express';
 import * as agentService from '../services/agent.js';
+import { generateAgentDesign } from '../agents/agent-designer.js';
 const router = Router({ mergeParams: true });
 router.get('/usage/dashboard', (req, res) => {
     const days = Number(req.query.days ?? 30);
@@ -21,6 +22,20 @@ router.post('/presets', (req, res) => {
     const preset = agentService.createPreset(req.params.id, body);
     res.status(201).json(preset);
 });
+router.post('/presets/generate', async (req, res) => {
+    const { prompt } = req.body;
+    if (!prompt?.trim()) {
+        res.status(400).json({ error: 'prompt is required' });
+        return;
+    }
+    try {
+        res.json(await generateAgentDesign(prompt));
+    }
+    catch (err) {
+        console.error('[agent-designer] generate failed', err);
+        res.status(400).json({ error: err instanceof Error ? err.message : 'agent generation failed' });
+    }
+});
 router.post('/presets/test-connection', async (req, res) => {
     const workspaceId = req.params.id;
     const data = req.body;

package/dist/routes/channel.js

@@ -24,7 +24,7 @@ router.post('/', (req, res) => {
 router.put('/:channelId', (req, res) => {
     const { id, channelId } = req.params;
     const patch = {};
-    for (const key of ['name', 'type', 'issueId', 'members', 'pinnedMentionId', 'draft', 'todos']) {
+    for (const key of ['name', 'type', 'issueId', 'members', 'pinnedMentionId', 'draft', 'todos', 'archived']) {
         if (Object.hasOwn(req.body, key))
             patch[key] = req.body[key];
     }

package/dist/routes/file.js

@@ -12,7 +12,8 @@ router.get('/tree', async (req, res) => {
         return;
     }
     const path = req.query.path || '';
-    const tree = await fileService.readTree(ws, path);
+    const depth = parseInt(req.query.depth) || undefined;
+    const tree = await fileService.readTree(ws, path, depth);
     res.json(tree);
 });
 router.get('/content', async (req, res) => {
@@ -144,5 +145,100 @@ router.post('/reveal', async (req, res) => {
         res.json({ ok: true, path: fullPath });
     });
 });
+router.post('/rename', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { oldPath, newPath } = req.body;
+    if (!oldPath || !newPath) {
+        res.status(400).json({ error: 'oldPath and newPath are required' });
+        return;
+    }
+    const ok = await fileService.renamePath(ws, oldPath, newPath);
+    if (!ok) {
+        res.status(500).json({ error: 'Failed to rename' });
+        return;
+    }
+    res.json({ ok: true });
+});
+router.post('/copy', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { srcPath, destPath } = req.body;
+    if (!srcPath || !destPath) {
+        res.status(400).json({ error: 'srcPath and destPath are required' });
+        return;
+    }
+    const ok = await fileService.copyPath(ws, srcPath, destPath);
+    if (!ok) {
+        res.status(500).json({ error: 'Failed to copy' });
+        return;
+    }
+    res.json({ ok: true });
+});
+router.post('/import-url', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { url, targetDir } = req.body;
+    if (!url) {
+        res.status(400).json({ error: 'url is required' });
+        return;
+    }
+    const result = await fileService.importFromUrl(ws, url, targetDir || '');
+    if (!result) {
+        res.status(500).json({ error: 'Failed to import from URL' });
+        return;
+    }
+    res.json({ ok: true, path: result });
+});
+router.post('/import-path', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { absPath, targetDir } = req.body;
+    if (!absPath) {
+        res.status(400).json({ error: 'absPath is required' });
+        return;
+    }
+    const result = await fileService.importFromAbsPath(ws, absPath, targetDir || '');
+    if (!result) {
+        res.status(500).json({ error: 'Failed to import file' });
+        return;
+    }
+    res.json({ ok: true, path: result });
+});
+router.post('/upload', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { targetDir, files } = req.body;
+    if (!Array.isArray(files) || files.length === 0) {
+        res.status(400).json({ error: 'files are required' });
+        return;
+    }
+    const results = [];
+    for (const f of files) {
+        if (!f.name || !f.content)
+            continue;
+        const buffer = Buffer.from(f.content, 'base64');
+        const relPath = targetDir ? `${targetDir}/${f.name}` : f.name;
+        const ok = await fileService.writeFileBinary(ws, relPath, buffer);
+        if (ok)
+            results.push(relPath);
+    }
+    res.json({ ok: true, paths: results });
+});
 export default router;
 //# sourceMappingURL=file.js.map

package/dist/routes/git.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { gitStatus, gitDiff, gitLog, gitCommit, gitDiscard, gitDiscardAll, gitBranches, gitCheckout, gitInit, gitGenerateCommitMsg, gitPush, gitPull, gitGetRemotes, gitAddRemote } from '../adapters/git.js';
+import { gitStatus, gitDiff, gitLog, gitCommit, gitDiscard, gitDiscardAll, gitBranches, gitCheckout, gitInit, gitGenerateCommitMsg, gitPush, gitPull, gitGetRemotes, gitAddRemote, gitCheckoutDetached, gitCherryPick, gitCreateBranch, gitDeleteBranch, gitCreateTag, gitCommitDiff, gitGetRemoteUrl, gitMergeBase, gitGetConfig, gitSetConfig } from '../adapters/git.js';
 const router = Router({ mergeParams: true });
 router.get('/status', async (req, res) => {
     try {
@@ -149,5 +149,126 @@ router.post('/remotes', async (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+router.post('/checkout-detached', async (req, res) => {
+    try {
+        const { commitHash } = req.body;
+        if (!commitHash) {
+            res.status(400).json({ error: 'commitHash is required' });
+            return;
+        }
+        await gitCheckoutDetached(req.params.id, commitHash);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/cherry-pick', async (req, res) => {
+    try {
+        const { commitHash } = req.body;
+        if (!commitHash) {
+            res.status(400).json({ error: 'commitHash is required' });
+            return;
+        }
+        await gitCherryPick(req.params.id, commitHash);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/create-branch', async (req, res) => {
+    try {
+        const { name, startPoint } = req.body;
+        if (!name) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        await gitCreateBranch(req.params.id, name, startPoint);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/delete-branch', async (req, res) => {
+    try {
+        const { name, force } = req.body;
+        if (!name) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        await gitDeleteBranch(req.params.id, name, force);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/create-tag', async (req, res) => {
+    try {
+        const { name, commitHash } = req.body;
+        if (!name) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        await gitCreateTag(req.params.id, name, commitHash);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.get('/commit-diff', async (req, res) => {
+    try {
+        const hash = req.query.hash;
+        if (!hash) {
+            res.status(400).json({ error: 'hash is required' });
+            return;
+        }
+        const diffs = await gitCommitDiff(req.params.id, hash);
+        res.json(diffs);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.get('/remote-url', async (req, res) => {
+    try {
+        const url = await gitGetRemoteUrl(req.params.id);
+        res.json({ url });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.get('/merge-base', async (req, res) => {
+    try {
+        const hash = await gitMergeBase(req.params.id);
+        res.json({ hash });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.get('/config', async (req, res) => {
+    try {
+        const config = await gitGetConfig('local', req.params.id);
+        res.json(config);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/config', async (req, res) => {
+    try {
+        const { name, email, proxy } = req.body;
+        await gitSetConfig('local', { name, email, proxy }, req.params.id);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
 export default router;
 //# sourceMappingURL=git.js.map

package/dist/routes/iframe-bookmarks.js

@@ -0,0 +1,33 @@
+import { Router } from 'express';
+import * as store from '../storage/iframe-bookmarks-store.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    res.json(store.listBookmarks());
+});
+router.post('/', (req, res) => {
+    const { title, url, size } = req.body;
+    if (!title || !url) {
+        res.status(400).json({ error: 'title and url are required' });
+        return;
+    }
+    res.status(201).json(store.addBookmark({ title, url, size }));
+});
+router.put('/:id', (req, res) => {
+    const { title, url, size } = req.body;
+    const updated = store.updateBookmark(req.params.id, { title, url, size });
+    if (!updated) {
+        res.status(404).json({ error: 'bookmark not found' });
+        return;
+    }
+    res.json(updated);
+});
+router.delete('/:id', (req, res) => {
+    const ok = store.removeBookmark(req.params.id);
+    if (!ok) {
+        res.status(404).json({ error: 'bookmark not found' });
+        return;
+    }
+    res.json({ ok: true });
+});
+export default router;
+//# sourceMappingURL=iframe-bookmarks.js.map

package/dist/routes/issue.js

@@ -5,6 +5,7 @@ import * as channelService from '../services/channel.js';
 import { broadcastToWorkspace } from '../ws/connection-manager.js';
 import { stopChannelRuns } from '../ws/agent-runner.js';
 import * as agentService from '../services/agent.js';
+import * as taskService from '../services/task.js';
 import { retryIssue } from '../services/issue-retry.js';
 import { hasActiveIssueAutomation, runIssueAutomation } from '../agents/issue-agent-runner.js';
 import * as workflowService from '../services/workflow.js';
@@ -83,6 +84,17 @@ router.post('/:issueId/start', (req, res) => {
     const workspaceId = req.params.id;
     const { issueId } = req.params;
     const before = issueService.getById(workspaceId, issueId);
+    if (!before) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    // Pre-check: must have workflow or existing tasks
+    const hasWorkflow = Boolean(before.workflowId);
+    const existingTasks = taskService.list(workspaceId, issueId);
+    if (!hasWorkflow && existingTasks.length === 0) {
+        res.status(400).json({ error: 'No workflow or tasks configured for this issue' });
+        return;
+    }
     const issue = issueService.updateStatus(workspaceId, issueId, 'planned');
     if (!issue) {
         res.status(404).json({ error: 'issue not found' });

package/dist/routes/speech-recognition.js

@@ -0,0 +1,99 @@
+import { Router } from 'express';
+import * as store from '../storage/speech-recognition-store.js';
+import { createSpeechSession } from '../services/speech-recognition/index.js';
+const router = Router();
+// REST: CRUD for speech recognition configs
+router.get('/', (_req, res) => {
+    res.json(store.listSpeechConfigs());
+});
+router.post('/', (req, res) => {
+    const { provider, label, credentials } = req.body;
+    if (!provider || !credentials) {
+        res.status(400).json({ error: 'provider and credentials are required' });
+        return;
+    }
+    const item = store.createSpeechConfig({ provider, label: label || provider, credentials });
+    res.status(201).json(item);
+});
+router.put('/:id', (req, res) => {
+    const { label, credentials, enabled } = req.body;
+    const updated = store.updateSpeechConfig(req.params.id, { label, credentials, enabled });
+    if (!updated) {
+        res.status(404).json({ error: 'Config not found' });
+        return;
+    }
+    res.json(updated);
+});
+router.delete('/:id', (req, res) => {
+    if (!store.deleteSpeechConfig(req.params.id)) {
+        res.status(404).json({ error: 'Config not found' });
+        return;
+    }
+    res.status(204).end();
+});
+// Export a handler for WebSocket upgrade (speech streaming)
+export async function handleSpeechStream(clientWs, configId) {
+    console.log('[speech-ws] new connection, configId:', configId || '(default)');
+    const config = configId
+        ? store.getSpeechConfig(configId)
+        : store.getDefaultSpeechConfig();
+    if (!config) {
+        console.warn('[speech-ws] no config found, closing');
+        clientWs.close(4004, 'No speech recognition config found');
+        return;
+    }
+    console.log('[speech-ws] using config:', config.id, 'provider:', config.provider);
+    try {
+        console.log('[speech-ws] creating session...');
+        const session = await createSpeechSession(config);
+        console.log('[speech-ws] session created');
+        let audioPackets = 0;
+        let lastLogTime = Date.now();
+        session.onResult((result) => {
+            console.log('[speech-ws] result:', result.text, 'isFinal:', result.isFinal);
+            if (clientWs.readyState === 1) {
+                clientWs.send(JSON.stringify(result));
+            }
+        });
+        session.onError((err) => {
+            console.error('[speech-ws] session error:', err.message);
+            if (clientWs.readyState === 1) {
+                clientWs.send(JSON.stringify({ error: err.message }));
+            }
+        });
+        session.onClose(() => {
+            console.log('[speech-ws] session closed, total audio packets:', audioPackets);
+            if (clientWs.readyState === 1) {
+                clientWs.close(1000, 'Session ended');
+            }
+        });
+        clientWs.on('message', (data) => {
+            if (Buffer.isBuffer(data)) {
+                session.sendAudio(data);
+                audioPackets++;
+                const now = Date.now();
+                if (audioPackets <= 3 || now - lastLogTime > 5000) {
+                    console.log('[speech-ws] audio packet #', audioPackets, 'size:', data.byteLength);
+                    lastLogTime = now;
+                }
+            }
+            else {
+                const msg = data.toString();
+                console.log('[speech-ws] text message:', msg);
+                if (msg === '{"type":"end"}' || msg === '{"type":"end"}') {
+                    session.end();
+                }
+            }
+        });
+        clientWs.on('close', () => {
+            console.log('[speech-ws] client disconnected, total audio packets:', audioPackets);
+            session.end();
+        });
+    }
+    catch (err) {
+        console.error('[speech-ws] failed to create session:', err.message);
+        clientWs.close(1011, err.message || 'Failed to create speech session');
+    }
+}
+export default router;
+//# sourceMappingURL=speech-recognition.js.map