osborn 0.8.6 → 0.8.8

package/dist/claude-auth.js

@@ -150,6 +150,13 @@ export async function checkClaudeAuthStatus() {
  * Strips ALL whitespace first (like vutran1710/claudebox) to handle
  * Ink UI wrapping the URL across multiple lines.
  * Also cleans trailing "Pastecodehereifprompted" that Ink appends.
+ *
+ * IMPORTANT: strips the `redirect_uri` query parameter (which points to a
+ * localhost callback server on the *sprite*, not the user's machine). With
+ * no redirect_uri, claude.com falls back to showing the auth code in-page,
+ * which the user pastes back into the modal. This is the only flow that
+ * works for cloud sandboxes — the localhost redirect breaks both on phones
+ * (no listener) AND on desktops (sprite's localhost is unreachable).
  */
 function extractOAuthUrl(text) {
     // Strip ANSI codes
@@ -168,6 +175,39 @@ function extractOAuthUrl(text) {
         if (idx > 0)
             url = url.substring(0, idx);
     }
+    // Strip the localhost redirect_uri so claude.com shows a pasteable code
+    // instead of trying to redirect. URL() can't be used here because it
+    // re-encodes the path, so we surgically delete the redirect_uri param.
+    url = stripRedirectUri(url);
+    return url;
+}
+/**
+ * Strip the `redirect_uri` query param from an OAuth URL.
+ *
+ * Background: `claude setup-token` spawns a one-shot localhost HTTP server on
+ * a random port and registers it as the redirect_uri. That works fine when the
+ * user is on the same machine as the CLI, but on a sprite the URL points to
+ * the *sprite's* localhost — unreachable from the user's browser regardless
+ * of whether they open the auth link on their PC or their phone. With no
+ * redirect_uri at all, claude.ai falls back to its in-page code display
+ * (the same flow that `claude setup-token`'s "Paste code here if prompted"
+ * Ink input is built to consume), and the user can paste the code back into
+ * our modal — which works whether they signed in on phone or desktop.
+ *
+ * Done with regex rather than `new URL()` because the URL constructor
+ * normalizes the path (which can break Claude's strict redirect check)
+ * and re-encodes spaces/special chars in other params.
+ */
+function stripRedirectUri(url) {
+    const before = url;
+    // Three cases: leading param (?redirect_uri=...&), middle/trailing (&redirect_uri=...),
+    // and only param (?redirect_uri=...). Order matters so cleanup leaves the URL well-formed.
+    url = url.replace(/&redirect_uri=[^&]*/g, '');
+    url = url.replace(/\?redirect_uri=[^&]*&/g, '?');
+    url = url.replace(/\?redirect_uri=[^&]*$/g, '');
+    if (before !== url) {
+        console.log('🔑 Stripped localhost redirect_uri from OAuth URL — claude.ai will show a pasteable code instead of redirecting');
+    }
     return url;
 }
 // ─────────────────────────────────────────

package/dist/config.js

@@ -37,8 +37,13 @@ export const MCP_CATALOG = [
     },
 ];
 // Default config template
+// Note: workingDirectory is intentionally OMITTED here. Baking process.cwd() into the
+// default config at module-load time freezes whatever directory osborn happened to be
+// invoked from on first boot — which on cloud sandboxes can be the npm install dir
+// (`/usr/local/nvm/.../osborn`) and gets persisted to ~/.osborn/config.yaml forever.
+// Leaving it undefined lets the runtime self-heal in index.ts resolve it on every boot
+// from OSBORN_CWD → process.cwd() at the actual time the agent starts.
 const DEFAULT_CONFIG = {
-    workingDirectory: process.cwd(),
     defaultProvider: 'gemini',
     defaultCodingAgent: 'claude',
     // Voice mode: 'direct' (Claude Agent SDK) or 'realtime' (OpenAI/Gemini native)
@@ -504,36 +509,83 @@ export function sessionExists(sessionId, projectPath) {
     return existsSync(sessionFile);
 }
 /**
- * Reverse a project slug back to a path (best-effort — replace leading dash, then dashes→slashes).
- * "-Users-foo-bar" → "/Users/foo/bar"
+ * Reverse a project slug back to a path — LAST-RESORT fallback only.
+ *
+ * Claude's slug encoding (`/` → `-`, `.` → `-`) is LOSSY: you can't tell from a
+ * slug whether a given `-` was originally `/`, `.`, or a literal `-` inside a
+ * directory name like `pensive-bohr`. So this function cannot reliably
+ * round-trip an arbitrary path.
+ *
+ * Strategy: produce the naive guess (with a small `--` → `/.` improvement for
+ * dot-directories like `.claude`), then VALIDATE it with `existsSync`. If the
+ * guess doesn't exist, return empty string — that way the caller knows the
+ * reverse failed and can fall back cleanly instead of passing a broken path
+ * to `child_process.spawn` and crashing with ENOENT.
+ *
+ * The primary source of cwd is `extractCwd()` which reads the actual cwd from
+ * the JSONL file. This function is only reached when that fails.
  */
 function slugToPath(slug) {
-    return slug.replace(/^-/, '/').replace(/-/g, '/');
+    // Naive reverse: leading `-` → `/`, `--` → `/.`, remaining `-` → `/`.
+    // The `--` → `/.` pass handles dot-prefixed directories like `.claude`.
+    const guess = slug
+        .replace(/^-/, '/')
+        .replace(/--/g, '/.')
+        .replace(/-/g, '/');
+    // Validate — lossy encoding means we cannot trust the guess.
+    return existsSync(guess) ? guess : '';
 }
 const UUID_JSONL_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/i;
 /**
- * Extract cwd from first user message in a JSONL file.
- * Reuses the existing readline-based parsing pattern.
+ * Extract cwd from the first JSONL entry that carries a `cwd` field.
+ *
+ * Previously: read only the first 8KB and only accepted `type === 'user'`. That
+ * broke for sessions whose first JSONL entry was larger than 8KB — e.g. a
+ * `queue-operation` containing pasted email/page text. readline never emits the
+ * `line` event for an incomplete final chunk, so the scan finds nothing,
+ * `listAllClaudeSessions` falls through to the lossy `slugToPath` reverse, and
+ * the mangled path ends up as a `cwd` passed to `child_process.spawn`, producing
+ * the misleading "Claude Code executable not found" error (see MEMORY bug #11).
+ *
+ * Now: stream line-by-line with no byte cap, short-circuit on the first entry
+ * with a `cwd` field regardless of `type` (every `user` / `attachment` /
+ * `assistant` / `system` entry in a Claude JSONL session carries `cwd`, so the
+ * scan finishes in the first few KB of any normal session).
  */
 async function extractCwd(filePath) {
     return new Promise((resolve) => {
-        const fileStream = createReadStream(filePath, { end: 8192 }); // first 8KB
+        const fileStream = createReadStream(filePath);
         const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+        let resolved = false;
+        const done = (value) => {
+            if (resolved)
+                return;
+            resolved = true;
+            try {
+                rl.close();
+            }
+            catch { }
+            try {
+                fileStream.destroy();
+            }
+            catch { }
+            resolve(value);
+        };
         rl.on('line', (line) => {
+            if (resolved)
+                return;
             if (!line.trim())
                 return;
             try {
                 const obj = JSON.parse(line);
-                if (obj.type === 'user' && obj.cwd) {
-                    rl.close();
-                    fileStream.destroy();
-                    resolve(obj.cwd);
+                if (typeof obj?.cwd === 'string' && obj.cwd.length > 0) {
+                    done(obj.cwd);
                 }
             }
             catch { }
         });
-        rl.on('close', () => resolve(''));
-        rl.on('error', () => resolve(''));
+        rl.on('close', () => done(''));
+        rl.on('error', () => done(''));
     });
 }
 /**

package/dist/index.js

@@ -1680,10 +1680,26 @@ async function main() {
                 preSelectedSessionId = metadata.sessionId;
                 console.log(`📂 Pre-selected session from frontend: ${preSelectedSessionId}`);
             }
-            // Read working directory override from frontend
+            // Read working directory override from frontend.
+            //
+            // Must validate with existsSync before accepting: a broken reverse-slug in
+            // the frontend's session list (see `slugToPath` in config.ts — the encoding
+            // is lossy), a deleted project, or a bad legacy client can all produce a
+            // non-existent path here. Passing a non-existent cwd to
+            // `child_process.spawn` in the Claude SDK errors with ENOENT, which the
+            // SDK then reports as the misleading "Claude Code executable not found at
+            // .../cli.js" error (see MEMORY bug fix #11). Fall back to defaultWorkingDir
+            // (which is itself existsSync-verified at startup).
             if (metadata.workingDirectory && typeof metadata.workingDirectory === 'string' && metadata.workingDirectory.length > 0) {
-                workingDir = metadata.workingDirectory;
-                console.log(`📂 Working directory from frontend: ${workingDir}`);
+                if (existsSync(metadata.workingDirectory)) {
+                    workingDir = metadata.workingDirectory;
+                    console.log(`📂 Working directory from frontend: ${workingDir}`);
+                }
+                else {
+                    console.log(`⚠️  Frontend sent workingDirectory that does not exist: ${metadata.workingDirectory}`);
+                    console.log(`   Falling back to default: ${defaultWorkingDir}`);
+                    workingDir = defaultWorkingDir;
+                }
             }
             else {
                 // Reset to default for new connections (in case previous session changed it)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {
@@ -8,6 +8,8 @@
   },
   "scripts": {
     "dev": "tsx src/index.ts",
+    "dev:logged": "tsx scripts/dev-logged.ts",
+    "review": "tsx scripts/review.ts",
     "start": "tsx src/index.ts",
     "build": "tsc",
     "room": "tsx src/index.ts --room",

package/scripts/dev-logged.ts

@@ -0,0 +1,81 @@
+/**
+ * Dev-logger wrapper: spawns `tsx src/index.ts` as a child, tees its stdout /
+ * stderr to BOTH the user's terminal AND a timestamped log file under
+ * `.osborn/dev-logs/`. Forwards SIGINT / SIGTERM so Ctrl-C cleanly shuts down
+ * the agent child before the wrapper exits.
+ *
+ * This is an OUT-OF-LOOP process — the agent itself (src/index.ts) is
+ * unmodified and unaware of this wrapper. Removing the dev-logger means
+ * deleting this file and the `"dev:logged"` script in package.json — zero
+ * impact on the agent's runtime behavior.
+ *
+ * Usage:
+ *   npm run dev:logged        # capture to .osborn/dev-logs/<ts>.log
+ *
+ * After shutdown, review with:
+ *   npm run review
+ */
+
+import { spawn } from 'node:child_process'
+import { createWriteStream, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+
+// Invoked via `npm run dev:logged` from `agent/`, so process.cwd() === agent/.
+// Log dir is co-located with the agent install — follows the existing
+// `.osborn/` convention (already matched by the root .gitignore).
+const logDir = join(process.cwd(), '.osborn', 'dev-logs')
+mkdirSync(logDir, { recursive: true })
+
+// YYYYMMDDHHMMSS timestamp — sortable, filesystem-safe on every OS.
+const ts = new Date().toISOString().replace(/[-:T.]/g, '').slice(0, 14)
+const logPath = join(logDir, `${ts}.log`)
+const logStream = createWriteStream(logPath, { flags: 'a' })
+
+console.log(`📝 [dev-logger] Capturing to ${logPath}`)
+console.log(`📝 [dev-logger] Review later with: npm run review\n`)
+logStream.write(`=== dev-logged session started at ${new Date().toISOString()} ===\n`)
+
+// `tsx` resolves to `node_modules/.bin/tsx` because npm run <script> prepends
+// the local node_modules/.bin to PATH. No need to hardcode the path.
+const child = spawn('tsx', ['src/index.ts'], {
+  stdio: ['inherit', 'pipe', 'pipe'],
+  env: process.env,
+})
+
+child.stdout.on('data', (chunk: Buffer) => {
+  process.stdout.write(chunk)
+  logStream.write(chunk)
+})
+
+child.stderr.on('data', (chunk: Buffer) => {
+  process.stderr.write(chunk)
+  logStream.write(chunk)
+})
+
+// Forward termination signals exactly once — if the user hits Ctrl-C multiple
+// times, only the first SIGINT goes to the child; subsequent ones are ignored
+// to avoid racing the graceful shutdown.
+let forwarded = false
+const forward = (sig: NodeJS.Signals) => {
+  if (forwarded) return
+  forwarded = true
+  try { child.kill(sig) } catch {}
+}
+process.on('SIGINT', () => forward('SIGINT'))
+process.on('SIGTERM', () => forward('SIGTERM'))
+
+child.on('exit', (code) => {
+  logStream.write(`\n=== dev-logged session ended at ${new Date().toISOString()} (exit ${code}) ===\n`)
+  // Wait for the log file to finish flushing BEFORE process.exit — otherwise
+  // the final marker may be lost on disk.
+  logStream.end(() => {
+    console.log(`\n📝 [dev-logger] Log saved: ${logPath}`)
+    console.log(`📝 [dev-logger] Review: npm run review`)
+    process.exit(code ?? 0)
+  })
+})
+
+child.on('error', (err) => {
+  console.error(`❌ [dev-logger] Failed to spawn agent: ${err.message}`)
+  logStream.end(() => process.exit(1))
+})