stagent 0.1.6 → 0.1.9

package/src/components/tasks/task-edit-dialog.tsx

@@ -0,0 +1,277 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
+import { Label } from "@/components/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { Bot, FileText, AlignLeft } from "lucide-react";
+import { toast } from "sonner";
+import {
+  type AgentRuntimeId,
+  DEFAULT_AGENT_RUNTIME,
+  listRuntimeCatalog,
+} from "@/lib/agents/runtime/catalog";
+import {
+  getSupportedRuntimes,
+  profileSupportsRuntime,
+} from "@/lib/agents/profiles/compatibility";
+import type { AgentProfile } from "@/lib/agents/profiles/types";
+import type { TaskItem } from "./task-card";
+
+type ProfileOption = Pick<
+  AgentProfile,
+  "id" | "name" | "description" | "supportedRuntimes"
+>;
+
+const PRIORITY_COLORS: Record<string, string> = {
+  "0": "bg-[var(--priority-critical)]",
+  "1": "bg-[var(--priority-high)]",
+  "2": "bg-[var(--priority-medium)]",
+  "3": "bg-[var(--priority-low)]",
+};
+
+interface TaskEditDialogProps {
+  task: TaskItem | null;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onUpdated: () => void;
+}
+
+export function TaskEditDialog({
+  task,
+  open,
+  onOpenChange,
+  onUpdated,
+}: TaskEditDialogProps) {
+  const runtimeOptions = listRuntimeCatalog();
+  const runtimeLabelMap = new Map(
+    runtimeOptions.map((runtime) => [runtime.id, runtime.label])
+  );
+
+  const [title, setTitle] = useState("");
+  const [description, setDescription] = useState("");
+  const [priority, setPriority] = useState("2");
+  const [assignedAgent, setAssignedAgent] = useState("");
+  const [agentProfile, setAgentProfile] = useState("");
+  const [profiles, setProfiles] = useState<ProfileOption[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    fetch("/api/profiles")
+      .then((r) => r.json())
+      .then((data: ProfileOption[]) => setProfiles(data))
+      .catch(() => {});
+  }, []);
+
+  useEffect(() => {
+    if (task) {
+      setTitle(task.title);
+      setDescription(task.description ?? "");
+      setPriority(String(task.priority));
+      setAssignedAgent(task.assignedAgent ?? "");
+      setAgentProfile(task.agentProfile ?? "");
+    }
+  }, [task]);
+
+  const selectedRuntimeId = (assignedAgent ||
+    DEFAULT_AGENT_RUNTIME) as AgentRuntimeId;
+  const selectedProfile = profiles.find((p) => p.id === agentProfile);
+  const profileCompatibilityError =
+    selectedProfile && !profileSupportsRuntime(selectedProfile, selectedRuntimeId)
+      ? `${selectedProfile.name} does not support ${
+          runtimeLabelMap.get(selectedRuntimeId) ?? selectedRuntimeId
+        }`
+      : null;
+
+  async function handleSubmit(e: React.FormEvent) {
+    e.preventDefault();
+    if (!task || !title.trim()) return;
+    if (profileCompatibilityError) return;
+    setLoading(true);
+    try {
+      const res = await fetch(`/api/tasks/${task.id}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          title: title.trim(),
+          description: description.trim() || undefined,
+          priority: parseInt(priority, 10),
+          assignedAgent: assignedAgent || undefined,
+          agentProfile: agentProfile || undefined,
+        }),
+      });
+      if (res.ok) {
+        toast.success("Task updated");
+        onOpenChange(false);
+        onUpdated();
+      } else {
+        const data = await res.json().catch(() => null);
+        toast.error(data?.error ?? "Failed to update task");
+      }
+    } catch {
+      toast.error("Network error — could not reach server");
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>Edit Task</DialogTitle>
+          <DialogDescription>
+            Update task details. Only planned and queued tasks can be edited.
+          </DialogDescription>
+        </DialogHeader>
+        <form onSubmit={handleSubmit} className="space-y-4">
+          <div className="space-y-2">
+            <Label htmlFor="edit-task-title" className="flex items-center gap-1.5">
+              <FileText className="h-3.5 w-3.5 text-muted-foreground" />
+              Title
+            </Label>
+            <Input
+              id="edit-task-title"
+              value={title}
+              onChange={(e) => setTitle(e.target.value)}
+              required
+              maxLength={200}
+            />
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor="edit-task-desc" className="flex items-center gap-1.5">
+              <AlignLeft className="h-3.5 w-3.5 text-muted-foreground" />
+              Description
+            </Label>
+            <Textarea
+              id="edit-task-desc"
+              value={description}
+              onChange={(e) => setDescription(e.target.value)}
+              rows={3}
+              placeholder="Detailed instructions for the agent"
+            />
+          </div>
+          <div className="space-y-2">
+            <Label>Priority</Label>
+            <Select value={priority} onValueChange={setPriority}>
+              <SelectTrigger>
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {[
+                  { value: "0", label: "P0 - Critical" },
+                  { value: "1", label: "P1 - High" },
+                  { value: "2", label: "P2 - Medium" },
+                  { value: "3", label: "P3 - Low" },
+                ].map((p) => (
+                  <SelectItem key={p.value} value={p.value}>
+                    <span className="flex items-center gap-1.5">
+                      <span className={`h-2 w-2 rounded-full ${PRIORITY_COLORS[p.value]} inline-block`} />
+                      {p.label}
+                    </span>
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+          <div className="space-y-2">
+            <Label className="flex items-center gap-1.5">
+              <Bot className="h-3.5 w-3.5 text-muted-foreground" />
+              Runtime
+            </Label>
+            <Select
+              value={assignedAgent || "default"}
+              onValueChange={(value) =>
+                setAssignedAgent(value === "default" ? "" : value)
+              }
+            >
+              <SelectTrigger>
+                <SelectValue placeholder="Default runtime" />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value="default">Default runtime</SelectItem>
+                {runtimeOptions.map((runtime) => (
+                  <SelectItem key={runtime.id} value={runtime.id}>
+                    {runtime.label}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+          {profiles.length > 0 && (
+            <div className="space-y-2">
+              <Label className="flex items-center gap-1.5">
+                <Bot className="h-3.5 w-3.5 text-muted-foreground" />
+                Agent Profile
+              </Label>
+              <Select
+                value={agentProfile || "auto"}
+                onValueChange={(value) =>
+                  setAgentProfile(value === "auto" ? "" : value)
+                }
+              >
+                <SelectTrigger>
+                  <SelectValue placeholder="Auto-detect" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="auto">Auto-detect</SelectItem>
+                  {profiles.map((p) => (
+                    <SelectItem
+                      key={p.id}
+                      value={p.id}
+                      disabled={!profileSupportsRuntime(p, selectedRuntimeId)}
+                    >
+                      <span className="flex items-center gap-1.5">
+                        <Bot className="h-3 w-3" />
+                        {p.name}
+                      </span>
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+              {selectedProfile && (
+                <p
+                  className={`text-xs ${
+                    profileCompatibilityError
+                      ? "text-destructive"
+                      : "text-muted-foreground"
+                  }`}
+                >
+                  {profileCompatibilityError ??
+                    `Supports ${getSupportedRuntimes(selectedProfile)
+                      .map(
+                        (runtimeId) =>
+                          runtimeLabelMap.get(runtimeId) ?? runtimeId
+                      )
+                      .join(", ")}`}
+                </p>
+              )}
+            </div>
+          )}
+          <Button
+            type="submit"
+            disabled={loading || !title.trim() || !!profileCompatibilityError}
+            className="w-full"
+          >
+            {loading ? "Saving..." : "Save Changes"}
+          </Button>
+        </form>
+      </DialogContent>
+    </Dialog>
+  );
+}

package/src/hooks/__tests__/use-persisted-state.test.ts

@@ -0,0 +1,57 @@
+import { renderHook, act } from "@testing-library/react";
+import { usePersistedState } from "@/hooks/use-persisted-state";
+
+describe("usePersistedState", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it("returns default value when localStorage is empty", () => {
+    const { result } = renderHook(() => usePersistedState("test-key", "default"));
+    expect(result.current[0]).toBe("default");
+  });
+
+  it("reads stored value from localStorage on mount", () => {
+    localStorage.setItem("test-key", "stored-value");
+    const { result } = renderHook(() => usePersistedState("test-key", "default"));
+    // After effect runs, value should be the stored one
+    expect(result.current[0]).toBe("stored-value");
+  });
+
+  it("writes to localStorage when setter is called", () => {
+    const { result } = renderHook(() => usePersistedState("test-key", "default"));
+
+    act(() => {
+      result.current[1]("new-value");
+    });
+
+    expect(result.current[0]).toBe("new-value");
+    expect(localStorage.getItem("test-key")).toBe("new-value");
+  });
+
+  it("handles localStorage errors gracefully", () => {
+    const origGetItem = Storage.prototype.getItem;
+    Storage.prototype.getItem = () => {
+      throw new Error("Quota exceeded");
+    };
+
+    const { result } = renderHook(() => usePersistedState("test-key", "fallback"));
+    expect(result.current[0]).toBe("fallback");
+
+    Storage.prototype.getItem = origGetItem;
+  });
+
+  it("maintains independent values for different keys", () => {
+    const { result: hookA } = renderHook(() => usePersistedState("key-a", "a-default"));
+    const { result: hookB } = renderHook(() => usePersistedState("key-b", "b-default"));
+
+    act(() => {
+      hookA.current[1]("a-updated");
+    });
+
+    expect(hookA.current[0]).toBe("a-updated");
+    expect(hookB.current[0]).toBe("b-default");
+    expect(localStorage.getItem("key-a")).toBe("a-updated");
+    expect(localStorage.getItem("key-b")).toBeNull();
+  });
+});

package/src/hooks/use-persisted-state.ts

@@ -0,0 +1,40 @@
+"use client";
+
+import { useState, useEffect, useCallback } from "react";
+
+/**
+ * useState wrapper that persists to localStorage.
+ * Reads from storage in useEffect to avoid SSR hydration mismatch.
+ */
+export function usePersistedState<T extends string>(
+  key: string,
+  defaultValue: T
+): [T, (value: T) => void] {
+  const [value, setValue] = useState<T>(defaultValue);
+
+  // Restore from localStorage on mount (client-only)
+  useEffect(() => {
+    try {
+      const stored = localStorage.getItem(key);
+      if (stored !== null) {
+        setValue(stored as T);
+      }
+    } catch {
+      // localStorage unavailable (e.g. private browsing)
+    }
+  }, [key]);
+
+  const setPersisted = useCallback(
+    (next: T) => {
+      setValue(next);
+      try {
+        localStorage.setItem(key, next);
+      } catch {
+        // localStorage unavailable
+      }
+    },
+    [key]
+  );
+
+  return [value, setPersisted];
+}

package/src/lib/agents/claude-agent.ts

@@ -1,4 +1,5 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
 import { db } from "@/lib/db";
 import { tasks, projects, agentLogs, notifications } from "@/lib/db/schema";
 import { eq } from "drizzle-orm";
@@ -49,11 +50,13 @@ interface TaskUsageState extends UsageSnapshot {
   scheduleId?: string | null;
 }
 
-interface ToolPermissionResponse {
-  behavior: "allow" | "deny";
-  updatedInput?: unknown;
-  message?: string;
-}
+const toolPermissionResponseSchema = z.object({
+  behavior: z.enum(["allow", "deny"]),
+  updatedInput: z.unknown().optional(),
+  message: z.string().optional(),
+});
+
+type ToolPermissionResponse = z.infer<typeof toolPermissionResponseSchema>;
 
 const inFlightPermissionRequests = new Map<
   string,
@@ -149,8 +152,15 @@ async function waitForToolPermissionResponse(
 
     if (notification?.response) {
       try {
-        return JSON.parse(notification.response) as ToolPermissionResponse;
-      } catch {
+        const parsed = JSON.parse(notification.response);
+        const validated = toolPermissionResponseSchema.safeParse(parsed);
+        if (validated.success) {
+          return validated.data;
+        }
+        console.error("[claude-agent] Invalid permission response shape:", validated.error.message);
+        return { behavior: "deny", message: "Invalid response format" };
+      } catch (err) {
+        console.error("[claude-agent] Failed to parse permission response:", err);
         return { behavior: "deny", message: "Invalid response format" };
       }
     }

package/src/lib/agents/runtime/claude-sdk.ts

@@ -1,12 +1,26 @@
 /**
  * Build the environment for the Claude Agent SDK subprocess.
- * Returns undefined when no changes are needed.
+ *
+ * Always strips CLAUDECODE (prevents nested-session issues) and
+ * ANTHROPIC_API_KEY (prevents SDK from using API-key auth when
+ * OAuth mode is intended).
+ *
+ * - API-key mode: authEnv is provided → key gets merged back in via spread.
+ * - OAuth mode:   authEnv is undefined → key stays stripped, SDK falls
+ *   through to cached OAuth tokens from `claude login`.
  */
 export function buildClaudeSdkEnv(
   authEnv?: Record<string, string>
-): Record<string, string> | undefined {
-  const isNested = "CLAUDECODE" in process.env;
-  if (!authEnv && !isNested) return undefined;
-  const { CLAUDECODE, ...cleanEnv } = process.env as Record<string, string>;
-  return { ...cleanEnv, ...authEnv };
+): Record<string, string> {
+  const { CLAUDECODE, ANTHROPIC_API_KEY, ...cleanEnv } =
+    process.env as Record<string, string>;
+
+  if (authEnv) {
+    // API key mode — merge the provided key into clean env
+    return { ...cleanEnv, ...authEnv };
+  }
+
+  // OAuth mode — return env WITHOUT ANTHROPIC_API_KEY
+  // so the SDK subprocess uses cached OAuth tokens from Claude CLI
+  return cleanEnv;
 }

package/src/lib/agents/runtime/claude.ts

@@ -39,11 +39,20 @@ async function collectResultText(
 
   for await (const raw of response) {
     usage = mergeUsageSnapshot(usage, extractUsageSnapshot(raw));
-    if (raw.type === "result" && "result" in raw) {
-      resultText =
-        typeof raw.result === "string"
-          ? raw.result
-          : JSON.stringify(raw.result);
+
+    if (raw.type === "content_block_delta") {
+      const delta = raw.delta as Record<string, unknown> | undefined;
+      if (delta?.type === "text_delta" && typeof delta.text === "string") {
+        resultText += delta.text;
+      }
+    } else if (raw.type === "result" && "result" in raw) {
+      if (raw.is_error) {
+        throw new Error(typeof raw.result === "string" ? raw.result : "Agent SDK returned an error");
+      }
+      const result = raw.result;
+      if (typeof result === "string" && result.length > 0) {
+        resultText = result;
+      }
       break;
     }
   }
@@ -230,12 +239,19 @@ async function runClaudeTaskAssist(
   const startedAt = new Date();
   let usage: UsageSnapshot = {};
 
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => abortController.abort(), 30_000);
+
   try {
     const response = query({
       prompt,
       options: {
+        abortController,
+        includePartialMessages: true,
         cwd: process.cwd(),
         env: buildClaudeSdkEnv(authEnv),
+        allowedTools: [],   // No tool use — pure text completion
+        maxTurns: 1,        // Single turn only — no agentic loop
       },
     });
 
@@ -283,6 +299,8 @@ async function runClaudeTaskAssist(
       finishedAt: new Date(),
     });
     throw error;
+  } finally {
+    clearTimeout(timeout);
   }
 }
 

package/src/lib/agents/runtime/openai-codex.ts

@@ -643,7 +643,13 @@ async function runAssistTurn({
       ephemeral: true,
     })) as { thread: { id: string } };
 
+    const ASSIST_TIMEOUT_MS = 60_000;
+
     const completion = new Promise<void>((resolve, reject) => {
+      client!.onProcessError = (error: Error) => {
+        reject(new Error(`Codex process died: ${error.message}`));
+      };
+
       client!.onNotification = (notification: JsonRpcLikeNotification) => {
         const params = asRecord(notification.params) ?? {};
         applyUsageSnapshot(usage, params);
@@ -669,6 +675,13 @@ async function runAssistTurn({
       };
     });
 
+    const timeout = new Promise<never>((_, reject) => {
+      setTimeout(
+        () => reject(new Error("Codex task assist timed out after 60s")),
+        ASSIST_TIMEOUT_MS
+      );
+    });
+
     await client.request("turn/start", {
       threadId: threadResponse.thread.id,
       input: buildTurnInput(prompt),
@@ -676,7 +689,7 @@ async function runAssistTurn({
       outputSchema: TASK_ASSIST_OUTPUT_SCHEMA,
     });
 
-    await completion;
+    await Promise.race([completion, timeout]);
 
     return { text: text.trim(), usage };
   } finally {

package/src/lib/db/bootstrap.ts

@@ -193,44 +193,29 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
     CREATE INDEX IF NOT EXISTS idx_learned_context_change_type ON learned_context(change_type);
   `);
 
-  try {
-    sqlite.exec(`ALTER TABLE tasks ADD COLUMN agent_profile TEXT;`);
-  } catch {
-    // Column already exists.
-  }
+  const addColumnIfMissing = (ddl: string) => {
+    try {
+      sqlite.exec(ddl);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!msg.includes("duplicate column")) {
+        console.error("[bootstrap] ALTER TABLE failed:", msg);
+      }
+    }
+  };
+
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN agent_profile TEXT;`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_agent_profile ON tasks(agent_profile);`);
 
-  try {
-    sqlite.exec(`ALTER TABLE tasks ADD COLUMN workflow_id TEXT REFERENCES workflows(id);`);
-  } catch {
-    // Column already exists.
-  }
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN workflow_id TEXT REFERENCES workflows(id);`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_workflow_id ON tasks(workflow_id);`);
 
-  try {
-    sqlite.exec(`ALTER TABLE tasks ADD COLUMN schedule_id TEXT REFERENCES schedules(id);`);
-  } catch {
-    // Column already exists.
-  }
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN schedule_id TEXT REFERENCES schedules(id);`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_schedule_id ON tasks(schedule_id);`);
 
-  try {
-    sqlite.exec(`ALTER TABLE projects ADD COLUMN working_directory TEXT;`);
-  } catch {
-    // Column already exists.
-  }
-
-  try {
-    sqlite.exec(`ALTER TABLE schedules ADD COLUMN assigned_agent TEXT;`);
-  } catch {
-    // Column already exists.
-  }
-
-  try {
-    sqlite.exec(`ALTER TABLE documents ADD COLUMN version INTEGER NOT NULL DEFAULT 1;`);
-  } catch {
-    // Column already exists.
-  }
+  addColumnIfMissing(`ALTER TABLE projects ADD COLUMN working_directory TEXT;`);
+  addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN assigned_agent TEXT;`);
+  addColumnIfMissing(`ALTER TABLE documents ADD COLUMN version INTEGER NOT NULL DEFAULT 1;`);
 }
 
 export function hasLegacyStagentTables(sqlite: Database.Database): boolean {

package/src/lib/documents/cleanup.ts

@@ -42,8 +42,9 @@ export async function cleanupOrphanedUploads(): Promise<{
         errors.push(`${filename}: ${err instanceof Error ? err.message : "unknown error"}`);
       }
     }
-  } catch {
-    // Upload directory may not exist yet
+  } catch (err) {
+    // Upload directory may not exist yet — log for visibility
+    console.error("[cleanup] Failed to read upload directory:", err);
   }
 
   return { deleted, errors };

package/src/lib/notifications/permissions.ts

@@ -23,7 +23,8 @@ export function parseNotificationToolInput(
     return parsed && typeof parsed === "object"
       ? (parsed as PermissionToolInput)
       : null;
-  } catch {
+  } catch (err) {
+    console.error("[permissions] Failed to parse notification tool input:", err);
     return null;
   }
 }
@@ -163,7 +164,8 @@ export function getPermissionResponseLabel(response: string | null): string | nu
     }
 
     return null;
-  } catch {
+  } catch (err) {
+    console.error("[permissions] Failed to parse permission response:", err);
     return null;
   }
 }

package/src/lib/workflows/engine.ts

@@ -705,8 +705,8 @@ export async function executeChildTask(
 
   try {
     await executeTaskWithRuntime(taskId);
-  } catch {
-    // Runtime adapter handles its own error logging
+  } catch (err) {
+    console.error(`[workflow-engine] Runtime execution failed for task ${taskId}:`, err);
   }
 
   const [completedTask] = await db