osborn 0.9.4 → 0.9.6

package/dist/index.js

@@ -10,11 +10,11 @@ initializeLogger({ pretty: true, level: 'info' });
 import { setMaxListeners } from 'node:events';
 setMaxListeners(50);
 import { createServer } from 'http';
-import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, mkdtempSync, cpSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, mkdtempSync, cpSync, rmSync, renameSync, statSync, createWriteStream } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
-import { homedir } from 'node:os';
+import { homedir, tmpdir } from 'node:os';
 // Resolve __dirname for this ESM module so we can find sibling files (e.g.
 // meeting-output.html) relative to the compiled JS location, NOT process.cwd().
 // In production cwd is the user's workspace; the static file lives next to dist/index.js.
@@ -331,6 +331,38 @@ function startApiServer(workingDir, port) {
                 res.destroy(); });
             return;
         }
+        // GET /sessions/manifest — return mtime+size for all .jsonl files per slug (public, no auth)
+        if (req.method === 'GET' && url.pathname === '/sessions/manifest') {
+            const claudeDir = join(homedir(), '.claude', 'projects');
+            const slugMap = {};
+            try {
+                const slugs = readdirSync(claudeDir, { withFileTypes: true })
+                    .filter(d => d.isDirectory())
+                    .map(d => d.name);
+                for (const slug of slugs) {
+                    const slugDir = join(claudeDir, slug);
+                    try {
+                        const jsonlFiles = readdirSync(slugDir)
+                            .filter(f => f.endsWith('.jsonl'));
+                        const fileStats = {};
+                        for (const file of jsonlFiles) {
+                            const st = statSync(join(slugDir, file));
+                            fileStats[file] = { mtime: st.mtimeMs, size: st.size };
+                        }
+                        slugMap[slug] = { files: fileStats };
+                    }
+                    catch {
+                        // skip unreadable dirs
+                    }
+                }
+            }
+            catch {
+                // projects dir doesn't exist yet — return empty
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ slugs: slugMap }));
+            return;
+        }
         // POST /sessions/import — accept a gzipped tar and extract into ~/.claude/projects/
         if (req.method === 'POST' && url.pathname === '/sessions/import') {
             if (syncToken) {
@@ -342,79 +374,250 @@ function startApiServer(workingDir, port) {
                 }
             }
             const targetWorkDir = url.searchParams.get('targetWorkDir');
-            const chunks = [];
-            req.on('data', (chunk) => chunks.push(chunk));
-            req.on('end', () => {
-                const body = Buffer.concat(chunks);
-                const tmpDir = mkdtempSync('/tmp/osborn-import-');
+            const tmpDir = mkdtempSync(join(tmpdir(), 'osborn-import-'));
+            const tarProc = spawn('tar', ['-xf', '-', '-C', tmpDir]);
+            // Streaming: pipe request body directly to tar stdin — no buffering
+            req.pipe(tarProc.stdin);
+            tarProc.stdin.on('error', (err) => {
+                console.error('[import] tar stdin error', err);
+                tarProc.kill('SIGTERM');
+                rmSync(tmpDir, { recursive: true, force: true });
+                if (!res.headersSent) {
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: 'upload error' }));
+                }
+            });
+            req.on('aborted', () => {
+                tarProc.kill('SIGTERM');
+                rmSync(tmpDir, { recursive: true, force: true });
+            });
+            tarProc.stderr.on('data', (d) => console.error('[import]', d.toString()));
+            tarProc.on('close', async (code) => {
                 try {
-                    // Extract archive into temp dir
-                    const tarProc = spawn('tar', ['-xzf', '-', '-C', tmpDir]);
-                    tarProc.stdin.write(body);
+                    if (code !== 0) {
+                        res.writeHead(500);
+                        res.end(JSON.stringify({ error: 'tar extraction failed', code }));
+                        return;
+                    }
+                    const claudeDir = join(homedir(), '.claude');
+                    const projectsDir = join(claudeDir, 'projects');
+                    mkdirSync(projectsDir, { recursive: true });
+                    // The archive should contain a 'projects' subdirectory
+                    const extractedProjects = join(tmpDir, 'projects');
+                    const sourceDir = existsSync(extractedProjects) ? extractedProjects : tmpDir;
+                    // Optionally remap slug: if targetWorkDir is provided, find slug(s)
+                    // that don't match the target and rename them
+                    const remapped = {};
+                    if (targetWorkDir) {
+                        const targetSlug = targetWorkDir.replace(/\//g, '-');
+                        const sourceSlugs = readdirSync(sourceDir);
+                        for (const slug of sourceSlugs) {
+                            if (slug !== targetSlug && !slug.startsWith('.')) {
+                                remapped[slug] = targetSlug;
+                            }
+                        }
+                    }
+                    // Copy subdirectories into ~/.claude/projects/, merging and updating existing files
+                    let filesWritten = 0;
+                    const slugsInSource = readdirSync(sourceDir);
+                    for (const slug of slugsInSource) {
+                        const effectiveSlug = remapped[slug] ?? slug;
+                        const destSlug = join(projectsDir, effectiveSlug);
+                        mkdirSync(destSlug, { recursive: true });
+                        try {
+                            renameSync(join(sourceDir, slug), destSlug);
+                        }
+                        catch (e) {
+                            if (e.code === 'EXDEV') {
+                                // Cross-filesystem fallback
+                                cpSync(join(sourceDir, slug), destSlug, { recursive: true, force: true, errorOnExist: false });
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                        filesWritten++;
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, filesWritten, remapped }));
+                }
+                catch (err) {
+                    console.error('[import] merge error:', err);
+                    if (!res.headersSent) {
+                        res.writeHead(500);
+                        res.end(JSON.stringify({ error: 'Failed to merge sessions', detail: String(err) }));
+                    }
+                }
+                finally {
+                    rmSync(tmpDir, { recursive: true, force: true });
+                }
+            });
+            return;
+        }
+        // POST /sessions/import-chunk — accept a single chunk of a multi-part upload
+        if (req.method === 'POST' && url.pathname === '/sessions/import-chunk') {
+            if (syncToken) {
+                const authHeader = req.headers['authorization'] ?? '';
+                if (authHeader !== `Bearer ${syncToken}`) {
+                    res.writeHead(401, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Unauthorized' }));
+                    return;
+                }
+            }
+            const uploadId = url.searchParams.get('uploadId');
+            const chunkIndex = parseInt(url.searchParams.get('chunk') || '0');
+            if (!uploadId) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: 'uploadId required' }));
+                return;
+            }
+            // Chunk storage dir: /tmp/osborn-upload-<uploadId>/
+            const uploadDir = join(tmpdir(), `osborn-upload-${uploadId}`);
+            mkdirSync(uploadDir, { recursive: true });
+            // Write chunk to padded filename for correct sort order
+            const chunkPath = join(uploadDir, `chunk-${String(chunkIndex).padStart(6, '0')}`);
+            const writeStream = createWriteStream(chunkPath);
+            req.pipe(writeStream);
+            writeStream.on('finish', () => {
+                res.writeHead(200);
+                res.end(JSON.stringify({ ok: true, chunk: chunkIndex }));
+            });
+            writeStream.on('error', (err) => {
+                console.error('[import-chunk] write error', err);
+                if (!res.headersSent) {
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: 'write failed' }));
+                }
+            });
+            req.on('aborted', () => { writeStream.destroy(); });
+            return;
+        }
+        // POST /sessions/import-finalize — reassemble chunks, extract, apply slug merge
+        if (req.method === 'POST' && url.pathname === '/sessions/import-finalize') {
+            if (syncToken) {
+                const authHeader = req.headers['authorization'] ?? '';
+                if (authHeader !== `Bearer ${syncToken}`) {
+                    res.writeHead(401, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Unauthorized' }));
+                    return;
+                }
+            }
+            const uploadId = url.searchParams.get('uploadId');
+            const total = parseInt(url.searchParams.get('total') || '0');
+            const targetWorkDir = url.searchParams.get('targetWorkDir') ?? undefined;
+            if (!uploadId || total === 0) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: 'uploadId and total required' }));
+                return;
+            }
+            const uploadDir = join(tmpdir(), `osborn-upload-${uploadId}`);
+            // Verify all chunks present
+            const expectedChunks = Array.from({ length: total }, (_, i) => `chunk-${String(i).padStart(6, '0')}`);
+            const presentChunks = existsSync(uploadDir) ? readdirSync(uploadDir).filter(f => f.startsWith('chunk-')).sort() : [];
+            const missing = expectedChunks.filter(c => !presentChunks.includes(c));
+            if (missing.length > 0) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: 'missing chunks', missing }));
+                return;
+            }
+            const tmpExtractDir = mkdtempSync(join(tmpdir(), 'osborn-import-'));
+            try {
+                // Reassemble chunks into a single stream and pipe to tar
+                const tarProc = spawn('tar', ['-xf', '-', '-C', tmpExtractDir]);
+                // Stream chunks in order to tar stdin
+                const streamChunks = async () => {
+                    for (const chunkFile of expectedChunks) {
+                        const chunkData = readFileSync(join(uploadDir, chunkFile));
+                        await new Promise((resolve, reject) => {
+                            tarProc.stdin.write(chunkData, (err) => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve();
+                            });
+                        });
+                    }
                     tarProc.stdin.end();
-                    tarProc.stderr.on('data', (d) => console.error('[import]', d.toString()));
-                    tarProc.on('close', (code) => {
+                };
+                streamChunks().catch(err => {
+                    console.error('[import-finalize] chunk stream error', err);
+                    tarProc.kill('SIGTERM');
+                });
+                tarProc.stderr.on('data', (d) => console.error('[import-finalize]', d.toString()));
+                tarProc.on('close', async (code) => {
+                    try {
                         if (code !== 0) {
-                            res.writeHead(500, { 'Content-Type': 'application/json' });
+                            res.writeHead(500);
                             res.end(JSON.stringify({ error: 'tar extraction failed', code }));
                             return;
                         }
-                        try {
-                            const claudeDir = join(homedir(), '.claude');
-                            const projectsDir = join(claudeDir, 'projects');
-                            mkdirSync(projectsDir, { recursive: true });
-                            // The archive should contain a 'projects' subdirectory
-                            const extractedProjects = join(tmpDir, 'projects');
-                            const sourceDir = existsSync(extractedProjects) ? extractedProjects : tmpDir;
-                            // Optionally remap slug: if targetWorkDir is provided, find slug(s)
-                            // that don't match the target and rename them
-                            let remapped = {};
-                            if (targetWorkDir) {
-                                const targetSlug = targetWorkDir.replace(/\//g, '-');
-                                const sourceSlugs = readdirSync(sourceDir);
-                                for (const slug of sourceSlugs) {
-                                    if (slug !== targetSlug && !slug.startsWith('.')) {
-                                        const newSlug = targetSlug;
-                                        remapped[slug] = newSlug;
-                                    }
+                        const claudeDir = join(homedir(), '.claude');
+                        const projectsDir = join(claudeDir, 'projects');
+                        mkdirSync(projectsDir, { recursive: true });
+                        // The archive should contain a 'projects' subdirectory
+                        const extractedProjects = join(tmpExtractDir, 'projects');
+                        const sourceDir = existsSync(extractedProjects) ? extractedProjects : tmpExtractDir;
+                        // Optionally remap slug: if targetWorkDir is provided, find slug(s)
+                        // that don't match the target and rename them
+                        const remapped = {};
+                        if (targetWorkDir) {
+                            const targetSlug = targetWorkDir.replace(/\//g, '-');
+                            const sourceSlugs = readdirSync(sourceDir);
+                            for (const slug of sourceSlugs) {
+                                if (slug !== targetSlug && !slug.startsWith('.')) {
+                                    remapped[slug] = targetSlug;
                                 }
                             }
-                            // Copy subdirectories into ~/.claude/projects/, merging without overwriting
-                            let filesWritten = 0;
-                            const slugsInSource = readdirSync(sourceDir);
-                            for (const slug of slugsInSource) {
-                                const effectiveSlug = remapped[slug] ?? slug;
-                                const destSlug = join(projectsDir, effectiveSlug);
-                                mkdirSync(destSlug, { recursive: true });
-                                cpSync(join(sourceDir, slug), destSlug, {
-                                    recursive: true,
-                                    force: false, // don't overwrite existing files
-                                    errorOnExist: false,
-                                });
-                                filesWritten++;
+                        }
+                        // Copy subdirectories into ~/.claude/projects/, merging and updating existing files
+                        let filesWritten = 0;
+                        const slugsInSource = readdirSync(sourceDir);
+                        for (const slug of slugsInSource) {
+                            const effectiveSlug = remapped[slug] ?? slug;
+                            const destSlug = join(projectsDir, effectiveSlug);
+                            mkdirSync(destSlug, { recursive: true });
+                            try {
+                                renameSync(join(sourceDir, slug), destSlug);
+                            }
+                            catch (e) {
+                                if (e.code === 'EXDEV') {
+                                    // Cross-filesystem fallback
+                                    cpSync(join(sourceDir, slug), destSlug, { recursive: true, force: true, errorOnExist: false });
+                                }
+                                else {
+                                    throw e;
+                                }
                             }
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ ok: true, filesWritten, remapped }));
+                            filesWritten++;
                         }
-                        catch (err) {
-                            console.error('[import] merge error:', err);
-                            res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true, filesWritten, remapped }));
+                    }
+                    catch (err) {
+                        console.error('[import-finalize] merge error:', err);
+                        if (!res.headersSent) {
+                            res.writeHead(500);
                             res.end(JSON.stringify({ error: 'Failed to merge sessions', detail: String(err) }));
                         }
-                    });
-                }
-                catch (err) {
-                    console.error('[import] spawn error:', err);
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'Failed to start extraction', detail: String(err) }));
-                }
-            });
+                    }
+                    finally {
+                        rmSync(uploadDir, { recursive: true, force: true });
+                        rmSync(tmpExtractDir, { recursive: true, force: true });
+                    }
+                });
+            }
+            catch (err) {
+                rmSync(uploadDir, { recursive: true, force: true });
+                rmSync(tmpExtractDir, { recursive: true, force: true });
+                throw err;
+            }
             return;
         }
         res.writeHead(404, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Not found' }));
     });
     const host = process.env.HOST || '0.0.0.0';
+    server.requestTimeout = 0; // no timeout — large uploads can take minutes
     server.listen(port, host, () => {
         console.log(`🌐 API server listening on http://${host}:${port}`);
         console.log(`   Sessions: http://${host}:${port}/sessions`);

package/dist/pipeline-direct-llm.js

@@ -106,7 +106,7 @@ export class PipelineDirectLLM extends llm.LLM {
                 `- If it's a quick side question, answer it then continue where you left off`,
                 `- If they want to change direction, acknowledge and follow their lead`,
                 `- Clarify when asked to or the question requires going over what you just said`,
-                `- Reference unspoken content naturally if relevant`,
+                `- If relevant details were cut off — whether they answer the current question or an earlier one — weave them back in naturally so the user stays in context without having to ask again.`,
             ].join('\n');
             // Modify the last user message in chatCtx
             for (let i = chatCtx.items.length - 1; i >= 0; i--) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {