@jlongo78/agent-spaces 0.9.8 → 0.9.10

package/.next/standalone/src/app/api/chat/route.ts

@@ -1,6 +1,7 @@
 import { NextRequest } from 'next/server';
 import { spawn } from 'child_process';
-import { getAuthUser } from '@/lib/auth';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { buildSpawnEnv } from '@/lib/spawn-env';
 
 export const dynamic = 'force-dynamic';
 
@@ -17,69 +18,71 @@ export async function POST(request: NextRequest) {
     });
   }
 
-  const workDir = cwd || require('os').homedir();
-  const encoder = new TextEncoder();
+  return withUser(user, () => {
+    const workDir = cwd || require('os').homedir();
+    const encoder = new TextEncoder();
 
-  const stream = new ReadableStream({
-    start(controller) {
-      const args = [
-        '-p', message,
-        '--output-format', 'stream-json',
-        '--verbose',
-      ];
+    const stream = new ReadableStream({
+      start(controller) {
+        const args = [
+          '-p', message,
+          '--output-format', 'stream-json',
+          '--verbose',
+        ];
 
-      const env = { ...process.env };
-      delete env.CLAUDECODE;
+        const env = buildSpawnEnv();
+        delete env.CLAUDECODE;
 
-      const child = spawn('claude', args, {
-        cwd: workDir,
-        env,
-      });
+        const child = spawn('claude', args, {
+          cwd: workDir,
+          env,
+        });
 
-      let buffer = '';
+        let buffer = '';
 
-      child.stdout.on('data', (chunk: Buffer) => {
-        buffer += chunk.toString();
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
+        child.stdout.on('data', (chunk: Buffer) => {
+          buffer += chunk.toString();
+          const lines = buffer.split('\n');
+          buffer = lines.pop() || '';
 
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const event = JSON.parse(line);
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
-          } catch {
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'text', text: line })}\n\n`));
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const event = JSON.parse(line);
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+            } catch {
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'text', text: line })}\n\n`));
+            }
           }
-        }
-      });
+        });
 
-      child.stderr.on('data', (chunk: Buffer) => {
-        const text = chunk.toString();
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', text })}\n\n`));
-      });
+        child.stderr.on('data', (chunk: Buffer) => {
+          const text = chunk.toString();
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', text })}\n\n`));
+        });
 
-      child.on('close', (code) => {
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: code })}\n\n`));
-        controller.close();
-      });
+        child.on('close', (code) => {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: code })}\n\n`));
+          controller.close();
+        });
 
-      child.on('error', (err) => {
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', text: err.message })}\n\n`));
-        controller.close();
-      });
+        child.on('error', (err) => {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', text: err.message })}\n\n`));
+          controller.close();
+        });
 
-      request.signal.addEventListener('abort', () => {
-        child.kill('SIGTERM');
-      });
-    },
-  });
+        request.signal.addEventListener('abort', () => {
+          child.kill('SIGTERM');
+        });
+      },
+    });
 
-  return new Response(stream, {
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive',
-    },
+    return new Response(stream, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+      },
+    });
   });
 }

package/.next/standalone/src/app/api/claude/usage/route.ts

@@ -0,0 +1,33 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { ensureInitialized } from '@/lib/db/init';
+import { readClaudeAiOauthTokens, isTokenExpired } from '@/lib/claude/credentials';
+import { fetchUtilization } from '@/lib/claude/usage';
+import type { UsageResponse } from '@/types/claude';
+
+export async function GET(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    await ensureInitialized();
+
+    const tokens = await readClaudeAiOauthTokens();
+    if (!tokens) {
+      const body: UsageResponse = { status: 'unauthenticated' };
+      return NextResponse.json(body);
+    }
+
+    if (isTokenExpired(tokens)) {
+      const body: UsageResponse = { status: 'expired' };
+      return NextResponse.json(body);
+    }
+
+    const outcome = await fetchUtilization(tokens.accessToken);
+    if (!outcome.ok) {
+      const body: UsageResponse = { status: 'upstream_error' };
+      return NextResponse.json(body);
+    }
+
+    const body: UsageResponse = { status: 'ok', data: outcome.data };
+    return NextResponse.json(body);
+  });
+}

package/.next/standalone/src/app/api/config/route.ts

@@ -24,6 +24,9 @@ export async function PUT(request: NextRequest) {
         .filter((d: unknown) => typeof d === 'string' && isAbsolute(d))
         .map((d: string) => resolve(d));
     }
+    if (typeof body.todosEnabled === 'boolean') {
+      updates.todosEnabled = body.todosEnabled;
+    }
     const config = writeConfig(user, updates);
     return NextResponse.json(config);
   });

package/.next/standalone/src/app/api/sessions/[id]/chat/route.ts

@@ -3,6 +3,7 @@ import { spawn } from 'child_process';
 import { getAuthUser, withUser } from '@/lib/auth';
 import { ensureInitialized } from '@/lib/db/init';
 import { getSessionById } from '@/lib/db/queries';
+import { buildSpawnEnv } from '@/lib/spawn-env';
 
 export const dynamic = 'force-dynamic';
 
@@ -39,7 +40,7 @@ export async function POST(
         ];
 
         // Strip CLAUDECODE so claude doesn't think it's nested
-        const env = { ...process.env };
+        const env = buildSpawnEnv();
         delete env.CLAUDECODE;
 
         const child = spawn('claude', args, {

package/.next/standalone/src/app/api/workspaces/[id]/todos/[todoId]/route.ts

@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { ensureInitialized } from '@/lib/db/init';
+import { updateWorkspaceTodo, deleteWorkspaceTodo } from '@/lib/db/queries';
+
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; todoId: string }> }
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    await ensureInitialized();
+    const { id, todoId } = await params;
+    const wsId = parseInt(id, 10);
+    const tid = parseInt(todoId, 10);
+    if (!Number.isFinite(wsId) || !Number.isFinite(tid)) {
+      return NextResponse.json({ error: 'invalid workspace or todo id' }, { status: 400 });
+    }
+    const body = await request.json().catch(() => null);
+    if (!body || (body.text === undefined && body.completed === undefined)) {
+      return NextResponse.json({ error: 'text or completed required' }, { status: 400 });
+    }
+    try {
+      const updated = updateWorkspaceTodo(wsId, tid, {
+        text: typeof body.text === 'string' ? body.text : undefined,
+        completed: typeof body.completed === 'boolean' ? body.completed : undefined,
+      });
+      if (!updated) {
+        return NextResponse.json({ error: 'not found' }, { status: 404 });
+      }
+      return NextResponse.json(updated);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'update failed';
+      return NextResponse.json({ error: message }, { status: 400 });
+    }
+  });
+}
+
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; todoId: string }> }
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    await ensureInitialized();
+    const { id, todoId } = await params;
+    const wsId = parseInt(id, 10);
+    const tid = parseInt(todoId, 10);
+    if (!Number.isFinite(wsId) || !Number.isFinite(tid)) {
+      return NextResponse.json({ error: 'invalid workspace or todo id' }, { status: 400 });
+    }
+    deleteWorkspaceTodo(wsId, tid);
+    return NextResponse.json({ ok: true });
+  });
+}

package/.next/standalone/src/app/api/workspaces/[id]/todos/route.ts

@@ -0,0 +1,43 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { ensureInitialized } from '@/lib/db/init';
+import { getWorkspaceTodos, addWorkspaceTodo } from '@/lib/db/queries';
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    await ensureInitialized();
+    const { id } = await params;
+    const wsId = parseInt(id, 10);
+    if (!Number.isFinite(wsId)) {
+      return NextResponse.json({ error: 'invalid workspace id' }, { status: 400 });
+    }
+    const todos = getWorkspaceTodos(wsId);
+    return NextResponse.json(todos);
+  });
+}
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    await ensureInitialized();
+    const { id } = await params;
+    const wsId = parseInt(id, 10);
+    if (!Number.isFinite(wsId)) {
+      return NextResponse.json({ error: 'invalid workspace id' }, { status: 400 });
+    }
+    const body = await request.json().catch(() => null);
+    const text = typeof body?.text === 'string' ? body.text : '';
+    if (!text.trim()) {
+      return NextResponse.json({ error: 'text is required' }, { status: 400 });
+    }
+    const todo = addWorkspaceTodo(wsId, text);
+    return NextResponse.json(todo, { status: 201 });
+  });
+}

package/.next/standalone/src/components/claude/claude-usage-strip.tsx

@@ -0,0 +1,175 @@
+'use client';
+
+import { useEffect, useRef, useState } from 'react';
+import { Zap, LogIn } from 'lucide-react';
+import { useClaudeUsage } from '@/hooks/use-claude-usage';
+import type { RateLimit } from '@/types/claude';
+
+interface Props {
+  enabled: boolean;
+}
+
+function utilizationColor(pct: number | null): string {
+  if (pct == null) return '#52525b'; // zinc-600 — unknown
+  if (pct <= 70) return '#22c55e';    // green-500
+  if (pct <= 90) return '#f59e0b';    // amber-500
+  return '#ef4444';                    // red-500
+}
+
+function formatReset(resetsAt: string | null): string {
+  if (!resetsAt) return '';
+  const ms = new Date(resetsAt).getTime() - Date.now();
+  if (ms <= 0) return 'now';
+  const h = Math.floor(ms / 3_600_000);
+  const m = Math.floor((ms % 3_600_000) / 60_000);
+  if (h >= 24) {
+    const d = Math.floor(h / 24);
+    const rh = h - d * 24;
+    return `${d}d ${rh}h`;
+  }
+  if (h > 0) return `${h}h ${m}m`;
+  return `${m}m`;
+}
+
+function Bar({ label, limit }: { label: string; limit: RateLimit | null | undefined }) {
+  if (!limit || limit.utilization == null) return null;
+  const pct = Math.min(100, Math.max(0, limit.utilization));
+  const color = utilizationColor(pct);
+  const reset = formatReset(limit.resets_at);
+  return (
+    <div
+      className="flex items-center gap-1.5 text-[10px]"
+      title={reset ? `${label}: ${Math.floor(pct)}% used · resets in ${reset}` : `${label}: ${Math.floor(pct)}% used`}
+    >
+      <span className="text-zinc-400 font-medium">{label}</span>
+      <div className="w-12 h-1 bg-zinc-800 rounded-full overflow-hidden">
+        <div
+          className="h-full transition-all"
+          style={{ width: `${pct}%`, backgroundColor: color }}
+        />
+      </div>
+      <span className="text-zinc-500 tabular-nums w-7 text-right">{Math.floor(pct)}%</span>
+    </div>
+  );
+}
+
+export function ClaudeUsageStrip({ enabled }: Props) {
+  const response = useClaudeUsage(enabled);
+  const [expanded, setExpanded] = useState(false);
+  const popoverRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!expanded) return;
+    function handleClick(e: MouseEvent) {
+      if (popoverRef.current && !popoverRef.current.contains(e.target as Node)) {
+        setExpanded(false);
+      }
+    }
+    document.addEventListener('mousedown', handleClick);
+    return () => document.removeEventListener('mousedown', handleClick);
+  }, [expanded]);
+
+  if (!enabled || !response) return null;
+
+  if (response.status === 'unauthenticated' || response.status === 'expired') {
+    return (
+      <div
+        className="flex items-center gap-1.5 px-2 py-1 text-[10px] text-zinc-500 border border-zinc-800 rounded-md"
+        title={response.status === 'expired' ? 'OAuth token expired — run any Claude Code command to refresh' : 'No Claude.ai credentials found'}
+      >
+        <LogIn className="w-3 h-3" />
+        sign in via Claude Code
+      </div>
+    );
+  }
+
+  if (response.status === 'upstream_error') {
+    return null; // Silent — per spec.
+  }
+
+  const { data } = response;
+  const extra = data.extra_usage;
+  const hasOverage = !!(extra?.is_enabled && extra?.used_credits && extra.used_credits > 0);
+
+  return (
+    <div className="relative">
+      <button
+        onClick={() => setExpanded(v => !v)}
+        className="flex items-center gap-2.5 px-2.5 py-1 border border-zinc-800 rounded-md hover:border-zinc-700 transition-colors"
+        title="Click for full usage detail"
+      >
+        <Zap className="w-3 h-3 text-amber-400" />
+        <Bar label="5h" limit={data.five_hour} />
+        <Bar label="7d" limit={data.seven_day} />
+        <Bar label="Opus" limit={data.seven_day_opus} />
+        <Bar label="Sonnet" limit={data.seven_day_sonnet} />
+        {hasOverage && extra?.used_credits != null && (
+          <span className="text-[10px] text-amber-400 border-l border-zinc-800 pl-2">
+            +${extra.used_credits.toFixed(2)} overage
+          </span>
+        )}
+      </button>
+
+      {expanded && (
+        <div
+          ref={popoverRef}
+          className="absolute top-full right-0 mt-1.5 z-50 w-80 p-3 bg-zinc-900 border border-zinc-700 rounded-md shadow-xl"
+        >
+          <div className="text-[10px] uppercase tracking-wider text-zinc-500 font-medium mb-2">
+            Plan Usage
+          </div>
+          <div className="space-y-2">
+            <ExpandedRow label="5-hour window" limit={data.five_hour} />
+            <ExpandedRow label="7-day (overall)" limit={data.seven_day} />
+            <ExpandedRow label="7-day · Opus" limit={data.seven_day_opus} />
+            <ExpandedRow label="7-day · Sonnet" limit={data.seven_day_sonnet} />
+            <ExpandedRow label="7-day · OAuth apps" limit={data.seven_day_oauth_apps} />
+          </div>
+          {extra?.is_enabled && (
+            <div className="mt-3 pt-3 border-t border-zinc-800">
+              <div className="text-[10px] uppercase tracking-wider text-zinc-500 font-medium mb-1.5">
+                Overage credits
+              </div>
+              <div className="text-xs text-zinc-300">
+                {extra.used_credits != null ? `$${extra.used_credits.toFixed(2)}` : '—'}
+                {extra.monthly_limit != null && (
+                  <span className="text-zinc-500"> / ${extra.monthly_limit.toFixed(2)} monthly</span>
+                )}
+              </div>
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function ExpandedRow({ label, limit }: { label: string; limit: RateLimit | null | undefined }) {
+  if (!limit || limit.utilization == null) {
+    return (
+      <div className="flex items-center justify-between text-xs">
+        <span className="text-zinc-400">{label}</span>
+        <span className="text-zinc-600">—</span>
+      </div>
+    );
+  }
+  const pct = Math.min(100, Math.max(0, limit.utilization));
+  const color = utilizationColor(pct);
+  const reset = formatReset(limit.resets_at);
+  return (
+    <div>
+      <div className="flex items-center justify-between text-xs mb-1">
+        <span className="text-zinc-300">{label}</span>
+        <span className="text-zinc-500 tabular-nums">
+          {Math.floor(pct)}%{reset && <span className="ml-1.5 text-zinc-600">· {reset}</span>}
+        </span>
+      </div>
+      <div className="h-1.5 bg-zinc-800 rounded-full overflow-hidden">
+        <div
+          className="h-full transition-all"
+          style={{ width: `${pct}%`, backgroundColor: color }}
+        />
+      </div>
+    </div>
+  );
+}