stagent 0.1.10 → 0.1.12

package/src/lib/settings/permission-presets.ts

@@ -0,0 +1,150 @@
+import { getAllowedPermissions, addAllowedPermission, removeAllowedPermission } from "./permissions";
+
+// ---------------------------------------------------------------------------
+// Preset definitions
+// ---------------------------------------------------------------------------
+
+export interface PermissionPreset {
+  id: string;
+  name: string;
+  description: string;
+  risk: "low" | "medium" | "high";
+  patterns: string[];
+}
+
+/**
+ * Built-in permission presets. Presets are layered — higher-risk presets
+ * include all patterns from lower-risk ones.
+ */
+export const PRESETS: PermissionPreset[] = [
+  {
+    id: "read-only",
+    name: "Read Only",
+    description: "Safe read operations — no file mutations or shell commands",
+    risk: "low",
+    patterns: ["Read", "Glob", "Grep", "LS", "NotebookRead"],
+  },
+  {
+    id: "git-safe",
+    name: "Git Safe",
+    description: "Read operations plus file editing and git commands",
+    risk: "medium",
+    patterns: [
+      // Includes all read-only patterns
+      "Read",
+      "Glob",
+      "Grep",
+      "LS",
+      "NotebookRead",
+      // Plus write + git
+      "Write",
+      "Edit",
+      "Bash(command:git *)",
+    ],
+  },
+  {
+    id: "full-auto",
+    name: "Full Auto",
+    description: "All tools auto-approved — maximum agent autonomy",
+    risk: "high",
+    patterns: [
+      // All safe tools
+      "Read",
+      "Glob",
+      "Grep",
+      "LS",
+      "NotebookRead",
+      "Write",
+      "Edit",
+      // All bash and other tools
+      "Bash",
+      "NotebookEdit",
+      "WebFetch",
+      "WebSearch",
+    ],
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Preset operations
+// ---------------------------------------------------------------------------
+
+/**
+ * Get a preset by ID, or undefined if not found.
+ */
+export function getPreset(presetId: string): PermissionPreset | undefined {
+  return PRESETS.find((p) => p.id === presetId);
+}
+
+/**
+ * Check which presets are currently fully active (all patterns present).
+ */
+export async function getActivePresets(): Promise<string[]> {
+  const current = await getAllowedPermissions();
+  const currentSet = new Set(current);
+
+  return PRESETS.filter((preset) =>
+    preset.patterns.every((p) => currentSet.has(p))
+  ).map((p) => p.id);
+}
+
+/**
+ * Check if a specific preset is fully active.
+ */
+export async function isPresetActive(presetId: string): Promise<boolean> {
+  const preset = getPreset(presetId);
+  if (!preset) return false;
+
+  const current = await getAllowedPermissions();
+  const currentSet = new Set(current);
+  return preset.patterns.every((p) => currentSet.has(p));
+}
+
+/**
+ * Enable a preset — adds all its patterns to the permission store.
+ * Existing patterns are preserved (additive, no duplicates).
+ */
+export async function applyPreset(presetId: string): Promise<void> {
+  const preset = getPreset(presetId);
+  if (!preset) {
+    throw new Error(`Unknown preset: ${presetId}`);
+  }
+
+  for (const pattern of preset.patterns) {
+    await addAllowedPermission(pattern);
+  }
+}
+
+/**
+ * Disable a preset — removes only patterns that are unique to this preset
+ * (not present in any other active preset or individually approved).
+ *
+ * Patterns shared with other active presets are kept.
+ */
+export async function removePreset(presetId: string): Promise<void> {
+  const preset = getPreset(presetId);
+  if (!preset) {
+    throw new Error(`Unknown preset: ${presetId}`);
+  }
+
+  // Gather patterns that belong to OTHER presets (excluding the one being removed)
+  const otherPresetPatterns = new Set<string>();
+  const activePresets = await getActivePresets();
+
+  for (const otherId of activePresets) {
+    if (otherId === presetId) continue;
+    const other = getPreset(otherId);
+    if (other) {
+      for (const p of other.patterns) {
+        otherPresetPatterns.add(p);
+      }
+    }
+  }
+
+  // Remove only patterns unique to this preset
+  for (const pattern of preset.patterns) {
+    if (!otherPresetPatterns.has(pattern)) {
+      await removeAllowedPermission(pattern);
+    }
+  }
+}

package/src/lib/settings/runtime-setup.ts

@@ -0,0 +1,71 @@
+import {
+  getRuntimeCatalogEntry,
+  SUPPORTED_AGENT_RUNTIMES,
+  type AgentRuntimeId,
+} from "@/lib/agents/runtime/catalog";
+import { getAuthSettings } from "./auth";
+import { getOpenAIAuthSettings } from "./openai-auth";
+import type { ApiKeySource, AuthMethod } from "@/lib/constants/settings";
+
+export type RuntimeBillingMode = "usage" | "subscription";
+export type RuntimeSetupMethod = AuthMethod | "none";
+
+export interface RuntimeSetupState {
+  runtimeId: AgentRuntimeId;
+  label: string;
+  providerId: "anthropic" | "openai";
+  configured: boolean;
+  authMethod: RuntimeSetupMethod;
+  apiKeySource: ApiKeySource;
+  billingMode: RuntimeBillingMode;
+}
+
+export async function getRuntimeSetupStates(): Promise<
+  Record<AgentRuntimeId, RuntimeSetupState>
+> {
+  const [claudeAuth, openAIAuth] = await Promise.all([
+    getAuthSettings(),
+    getOpenAIAuthSettings(),
+  ]);
+
+  const claudeRuntime = getRuntimeCatalogEntry("claude-code");
+  const openAIRuntime = getRuntimeCatalogEntry("openai-codex-app-server");
+
+  const claudeAuthMethod: RuntimeSetupMethod =
+    claudeAuth.method === "oauth" || claudeAuth.apiKeySource === "oauth"
+      ? "oauth"
+      : claudeAuth.hasKey
+        ? "api_key"
+        : "none";
+  const claudeConfigured =
+    claudeAuth.hasKey || claudeAuth.apiKeySource === "oauth";
+
+  const states = {
+    "claude-code": {
+      runtimeId: "claude-code",
+      label: claudeRuntime.label,
+      providerId: claudeRuntime.providerId,
+      configured: claudeConfigured,
+      authMethod: claudeAuthMethod,
+      apiKeySource: claudeAuth.apiKeySource,
+      billingMode: claudeAuthMethod === "oauth" ? "subscription" : "usage",
+    },
+    "openai-codex-app-server": {
+      runtimeId: "openai-codex-app-server",
+      label: openAIRuntime.label,
+      providerId: openAIRuntime.providerId,
+      configured: openAIAuth.hasKey,
+      authMethod: openAIAuth.hasKey ? "api_key" : "none",
+      apiKeySource: openAIAuth.apiKeySource,
+      billingMode: "usage",
+    },
+  } satisfies Record<AgentRuntimeId, RuntimeSetupState>;
+
+  return states;
+}
+
+export function listConfiguredRuntimeIds(
+  states: Record<AgentRuntimeId, RuntimeSetupState>
+) {
+  return SUPPORTED_AGENT_RUNTIMES.filter((runtimeId) => states[runtimeId].configured);
+}

package/src/lib/usage/__tests__/ledger.test.ts

@@ -33,9 +33,10 @@ function formatLocalDay(date: Date) {
 }
 
 describe("usage ledger", () => {
-  it("records normalized ledger rows with derived and unknown pricing states", async () => {
+  it("records normalized ledger rows with derived, fallback, and unknown pricing states", async () => {
     const { db, usageLedger, recordUsageLedgerEntry } = await loadUsageModules();
 
+    // Known model — gets specific pricing rule
     await recordUsageLedgerEntry({
       activityType: "task_assist",
       runtimeId: "claude-code",
@@ -49,6 +50,7 @@ describe("usage ledger", () => {
       finishedAt: new Date("2026-03-10T08:01:00.000Z"),
     });
 
+    // Unknown model — hits catch-all fallback pricing (conservative estimate)
     await recordUsageLedgerEntry({
       activityType: "task_assist",
       runtimeId: "openai-codex-app-server",
@@ -62,15 +64,37 @@ describe("usage ledger", () => {
       finishedAt: new Date("2026-03-10T09:01:00.000Z"),
     });
 
+    // Null modelId — gets unknown_pricing (no model to match)
+    await recordUsageLedgerEntry({
+      activityType: "task_run",
+      runtimeId: "claude-code",
+      providerId: "anthropic",
+      modelId: null,
+      inputTokens: 100,
+      outputTokens: 50,
+      totalTokens: 150,
+      status: "completed",
+      startedAt: new Date("2026-03-10T10:00:00.000Z"),
+      finishedAt: new Date("2026-03-10T10:01:00.000Z"),
+    });
+
     const rows = await db.select().from(usageLedger);
-    expect(rows).toHaveLength(2);
+    expect(rows).toHaveLength(3);
 
-    const priced = rows.find((row) => row.providerId === "anthropic");
+    // Known: specific pricing
+    const priced = rows.find((row) => row.modelId === "claude-sonnet-4-20250514");
     expect(priced?.costMicros).toBe(10_500);
     expect(priced?.status).toBe("completed");
-    expect(priced?.pricingVersion).toBe("registry-2026-03-12");
+    expect(priced?.pricingVersion).toBe("anthropic-claude-sonnet");
+
+    // Unknown model: fallback pricing (conservative Opus-tier for OpenAI: $10/$30)
+    const fallback = rows.find((row) => row.modelId === "codex-unknown");
+    expect(fallback?.costMicros).toBeGreaterThan(0);
+    expect(fallback?.status).toBe("completed");
+    expect(fallback?.pricingVersion).toBe("openai-fallback");
 
-    const unknown = rows.find((row) => row.providerId === "openai");
+    // Null modelId: truly unknown
+    const unknown = rows.find((row) => row.modelId === null);
     expect(unknown?.costMicros).toBeNull();
     expect(unknown?.status).toBe("unknown_pricing");
     expect(unknown?.pricingVersion).toBeNull();

package/src/lib/usage/__tests__/pricing-registry.test.ts

@@ -0,0 +1,78 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "stagent-pricing-registry-"));
+  vi.resetModules();
+  vi.stubEnv("STAGENT_DATA_DIR", tempDir);
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe("pricing registry", () => {
+  it("refreshes pricing from official provider pages and updates visible rows", async () => {
+    const fetch = vi.fn(async (input: string) => {
+      if (input.includes("anthropic.com")) {
+        return new Response(`
+          <html>
+            <body>
+              Claude Sonnet 4 $3 / 1M input tokens $15 / 1M output tokens
+              Claude Opus 4 $15 / 1M input tokens $75 / 1M output tokens
+              Claude Haiku 3.5 $0.80 / 1M input tokens $4 / 1M output tokens
+              Claude Pro $20
+              Max 5x $100
+              Max 20x $200
+            </body>
+          </html>
+        `);
+      }
+
+      return new Response(`
+        <html>
+          <body>
+            GPT-5 $10 / 1M input tokens $30 / 1M output tokens
+            GPT-4o $2.50 / 1M input tokens $10 / 1M output tokens
+          </body>
+        </html>
+      `);
+    });
+    vi.stubGlobal("fetch", fetch);
+
+    const { refreshPricingRegistry } = await import("../pricing-registry");
+    const snapshot = await refreshPricingRegistry();
+
+    expect(snapshot.providers.anthropic.rows.find((row) => row.key === "anthropic-plan-pro")?.monthlyPriceUsd).toBe(20);
+    expect(snapshot.providers.anthropic.rows.find((row) => row.key === "anthropic-claude-sonnet")?.inputCostPerMillionMicros).toBe(3_000_000);
+    expect(snapshot.providers.openai.rows.find((row) => row.key === "openai-gpt-5")?.outputCostPerMillionMicros).toBe(30_000_000);
+  });
+
+  it("keeps last-known-good pricing when a refresh fails", async () => {
+    const fetch = vi.fn(async (input: string) => {
+      if (input.includes("anthropic.com")) {
+        return new Response(`<html><body>Claude Pro $20</body></html>`);
+      }
+
+      throw new Error("network down");
+    });
+    vi.stubGlobal("fetch", fetch);
+
+    const { refreshPricingRegistry, getPricingRegistrySnapshot } = await import(
+      "../pricing-registry"
+    );
+
+    await refreshPricingRegistry();
+    const snapshot = await getPricingRegistrySnapshot();
+
+    expect(snapshot.providers.anthropic.refreshError).toBeNull();
+    expect(snapshot.providers.openai.refreshError).toContain("network down");
+    expect(snapshot.providers.openai.rows.find((row) => row.key === "openai-gpt-5")?.inputCostPerMillionMicros).toBe(10_000_000);
+  });
+});

package/src/lib/usage/ledger.ts

@@ -15,7 +15,9 @@ export type UsageActivityType =
   | "workflow_step"
   | "scheduled_firing"
   | "task_assist"
-  | "profile_test";
+  | "profile_test"
+  | "pattern_extraction"
+  | "context_summarization";
 
 export type UsageLedgerStatus =
   | "completed"
@@ -205,7 +207,7 @@ export async function recordUsageLedgerEntry(input: UsageLedgerWriteInput) {
     (normalizedInputTokens != null && normalizedOutputTokens != null
       ? normalizedInputTokens + normalizedOutputTokens
       : null);
-  const { costMicros, pricingVersion } = deriveUsageCostMicros({
+  const { costMicros, pricingVersion } = await deriveUsageCostMicros({
     providerId: input.providerId,
     modelId: input.modelId,
     inputTokens: normalizedInputTokens,