saeeol 1.1.0 → 1.1.1

package/src/saeeol/permission/config-paths.ts

@@ -0,0 +1,168 @@
+import path from "path"
+import { Global } from "@saeeol/core/global"
+import { SaeeolPaths } from "@/saeeol/paths"
+
+export namespace ConfigProtection {
+  /**
+   * Config directory prefixes (relative paths, forward-slash normalized).
+   * Matches .saeeol/, .saeeol/, .saeeol/ at any depth within the project.
+   */
+  const CONFIG_DIRS = [".saeeol/", ".saeeol/", ".saeeol/"]
+
+  /**
+   * Subdirectories under CONFIG_DIRS that are NOT config files (e.g. plan files).
+   * Paths under these subdirs are exempt from config protection.
+   */
+  const EXCLUDED_SUBDIRS = ["plans/"]
+
+  /**
+   * Root-level config files that must be protected.
+   * Matched only when the relative path has no directory component.
+   */
+  const CONFIG_ROOT_FILES = new Set(["saeeol.json", "saeeol.jsonc", "saeeol.json", "saeeol.jsonc", "AGENTS.md"])
+
+  /** Metadata key used to signal the UI to hide the "Allow always" option. */
+  export const DISABLE_ALWAYS_KEY = "disableAlways" as const
+
+  function normalize(p: string): string {
+    return path.posix.normalize(p.replaceAll("\\", "/"))
+  }
+
+  /** Return the remainder after the config dir prefix, or undefined if excluded. */
+  function excluded(remainder: string): boolean {
+    return EXCLUDED_SUBDIRS.some((sub) => remainder.startsWith(sub))
+  }
+
+  /** Check if a project-relative path points to a config file or directory. */
+  export function isRelative(pattern: string): boolean {
+    const normalized = normalize(pattern)
+    for (const dir of CONFIG_DIRS) {
+      const bare = dir.slice(0, -1) // e.g. ".saeeol"
+      // Match at root (e.g. ".saeeol/foo") or nested (e.g. "packages/sub/.saeeol/foo")
+      if (normalized === bare || normalized.endsWith("/" + bare)) return true
+      if (normalized.startsWith(dir)) {
+        if (excluded(normalized.slice(dir.length))) continue
+        return true
+      }
+      const nested = normalized.indexOf("/" + dir)
+      if (nested !== -1) {
+        if (excluded(normalized.slice(nested + 1 + dir.length))) continue
+        return true
+      }
+    }
+    return CONFIG_ROOT_FILES.has(normalized)
+  }
+
+  function keys(p: string): string[] {
+    if (process.platform !== "win32") return [path.resolve(p)]
+
+    const expand = (value: string) => {
+      const full = path.posix.normalize(value.replaceAll("\\", "/")).toLowerCase()
+      const msys = full.replace(/^\/([a-z])(?=\/)/, "$1:")
+      return [full, full.replace(/^[a-z]:/, ""), msys, msys.replace(/^[a-z]:/, "")]
+    }
+
+    return Array.from(new Set([...expand(p), ...expand(path.resolve(p))]))
+  }
+
+  function configs(): string[] {
+    return Array.from(
+      new Set([Global.Path.config, process.env.XDG_CONFIG_HOME ? path.join(process.env.XDG_CONFIG_HOME, "saeeol") : ""]),
+    ).filter(Boolean)
+  }
+
+  function fallback(p: string): boolean {
+    if (process.platform !== "win32") return false
+    return keys(p).some(
+      (key) =>
+        key.endsWith("/config/saeeol") ||
+        key.includes("/config/saeeol/") ||
+        key.endsWith("/.config/saeeol") ||
+        key.includes("/.config/saeeol/"),
+    )
+  }
+
+  /** Check if `child` is equal to or nested inside `parent`. */
+  function within(child: string, parent: string): boolean {
+    const sep = process.platform === "win32" ? "/" : path.sep
+    return keys(child).some((child) =>
+      keys(parent).some((parent) => child === parent || child.startsWith(parent + sep)),
+    )
+  }
+
+  /** Check if an absolute path is inside a known CLI config directory. */
+  export function isAbsolute(filepath: string): boolean {
+    if (fallback(filepath)) return true
+
+    // ~/.config/saeeol/ (XDG config)
+    for (const dir of configs()) {
+      if (within(filepath, dir)) return true
+    }
+
+    // ~/.saeeol/ and ~/.saeeol/ (legacy global dirs)
+    for (const dir of SaeeolPaths.globalDirs()) {
+      if (within(filepath, dir)) return true
+    }
+
+    return false
+  }
+
+  /** Check a single path (absolute or relative) against config protection. */
+  function protected_(p: string): boolean {
+    return path.isAbsolute(p) ? isAbsolute(p) : isRelative(p)
+  }
+
+  /**
+   * Determine if a permission request targets config files.
+   * Gates `edit` permissions and bash-originated `external_directory` requests.
+   * File-tool reads are not restricted.
+   */
+  export function isRequest(request: {
+    permission: string
+    patterns: readonly string[]
+    metadata?: Record<string, any>
+  }): boolean {
+    if (request.permission === "external_directory") {
+      // File tools include metadata.filepath. They may read global config
+      // without prompting, but edits are still protected separately via `edit`.
+      if (request.metadata?.filepath) return false
+      // Bash read-only file commands may read global config when explicitly allowed.
+      if (request.metadata?.access === "read") return false
+      for (const pattern of request.patterns) {
+        const dir = pattern.replace(/[\\/]\*$/, "")
+        if (isAbsolute(dir)) return true
+      }
+      return false
+    }
+
+    if (request.permission !== "edit") return false
+
+    // Check patterns — handle both relative and absolute
+    for (const pattern of request.patterns) {
+      if (protected_(pattern)) return true
+    }
+
+    // Check metadata.filepath (absolute for edit, comma-joined relative for apply_patch)
+    const fp = request.metadata?.filepath
+    if (typeof fp === "string") {
+      // apply_patch joins relative paths with ", "
+      const parts = fp.includes(", ") ? fp.split(", ") : [fp]
+      for (const part of parts) {
+        if (protected_(part)) return true
+      }
+    }
+
+    // Check metadata.files[] (apply_patch file objects with absolute filePath/movePath)
+    const files = request.metadata?.files
+    if (Array.isArray(files)) {
+      for (const file of files) {
+        for (const key of ["filePath", "movePath"] as const) {
+          const val = file?.[key]
+          if (typeof val === "string" && protected_(val)) return true
+        }
+      }
+    }
+
+    return false
+  }
+}

package/src/saeeol/permission/drain.ts

@@ -0,0 +1,58 @@
+import { Bus } from "@/bus"
+import { Deferred, Effect } from "effect"
+import { Permission } from "@/permission"
+import { ConfigProtection } from "@/saeeol/permission/config-paths"
+
+interface PendingEntry {
+  info: Permission.Request
+  ruleset: Permission.Ruleset
+  hardRuleset?: Permission.Ruleset
+  deferred: Deferred.Deferred<void, Permission.RejectedError | Permission.CorrectedError>
+}
+
+/**
+ * Auto-resolve pending permissions now fully covered by approved or denied rules.
+ * When the user approves/denies a rule on subagent A, sibling subagent B's
+ * pending permission for the same pattern resolves or rejects automatically.
+ */
+export function drainCovered(
+  pending: Map<string, PendingEntry>,
+  approved: Permission.Ruleset,
+  _Denied: typeof Permission.DeniedError,
+  exclude?: string,
+): Effect.Effect<void> {
+  return Effect.gen(function* () {
+    for (const [id, entry] of pending) {
+      if (id === exclude) continue
+      // Never auto-resolve config file edit permissions
+      if (ConfigProtection.isRequest(entry.info)) continue
+      const actions = entry.info.patterns.map((pattern: string) => {
+        const rule = Permission.resolve(entry.info.permission, pattern, entry.ruleset, approved)
+        const hard = entry.hardRuleset
+          ? Permission.evaluate(entry.info.permission, pattern, entry.hardRuleset)
+          : undefined
+        if (hard?.action === "deny") return hard
+        return rule
+      })
+      const denied = actions.some((r: Permission.Rule) => r.action === "deny")
+      const allowed = !denied && actions.every((r: Permission.Rule) => r.action === "allow")
+      if (!denied && !allowed) continue
+      pending.delete(id)
+      if (denied) {
+        void Bus.publish(Permission.Event.Replied, {
+          sessionID: entry.info.sessionID,
+          requestID: entry.info.id,
+          reply: "reject",
+        })
+        yield* Deferred.fail(entry.deferred, new Permission.RejectedError())
+      } else {
+        void Bus.publish(Permission.Event.Replied, {
+          sessionID: entry.info.sessionID,
+          requestID: entry.info.id,
+          reply: "always",
+        })
+        yield* Deferred.succeed(entry.deferred, undefined)
+      }
+    }
+  })
+}

package/src/saeeol/permission/external-directory.ts

@@ -0,0 +1,14 @@
+import { evaluate as evalRule } from "@/permission/evaluate"
+import { PermissionRule, type Ruleset } from "@/saeeol/permission/rule"
+
+function rules(permission: string, ruleset?: Ruleset) {
+  if (!ruleset) return []
+  if (permission !== "external_directory") return ruleset
+  return ruleset.filter((rule) => !PermissionRule.mode(rule))
+}
+
+export namespace ExternalDirectoryPermission {
+  export function evaluate(permission: string, pattern: string, ...sets: Array<Ruleset | undefined>) {
+    return evalRule(permission, pattern, ...sets.map((set) => rules(permission, set)))
+  }
+}

package/src/saeeol/permission/read.ts

@@ -0,0 +1,19 @@
+import { Wildcard } from "@/util/wildcard"
+import { PermissionRule, type Rule } from "@/saeeol/permission/rule"
+
+function guard(pattern: string) {
+  if (Wildcard.match(pattern, "*.env.example")) return
+  if (Wildcard.match(pattern, "*.env")) return "*.env"
+  if (Wildcard.match(pattern, "*.env.*")) return "*.env.*"
+}
+
+export namespace ReadPermission {
+  export function harden(permission: string, pattern: string, rule: Rule): Rule {
+    if (permission !== "read") return rule
+    if (rule.action !== "allow") return rule
+    const match = guard(pattern)
+    if (!match) return rule
+    if (!PermissionRule.broad(rule)) return rule
+    return { permission, pattern: match, action: "ask" }
+  }
+}

package/src/saeeol/permission/routes.ts

@@ -0,0 +1,87 @@
+import { Hono } from "hono"
+import { describeRoute, resolver, validator } from "hono-openapi"
+import z from "zod"
+import { Bus } from "@/bus"
+import * as Config from "@/config/config"
+import { AppRuntime } from "@/effect/app-runtime"
+import { Permission } from "@/permission"
+import { Session } from "@/session/session"
+import { SessionID } from "@/session/schema" 
+import { Event } from "../../server/event"
+import { errors } from "../../server/error"
+import { lazy } from "../../util/lazy"
+
+const allowEverything = (input: z.infer<typeof Permission.AllowEverythingInput>) =>
+  AppRuntime.runPromise(Permission.Service.use((svc) => svc.allowEverything(input)))
+
+export const PermissionSaeeolRoutes = lazy(() =>
+  new Hono().post(
+    "/allow-everything",
+    describeRoute({
+      summary: "Allow everything",
+      description: "Enable or disable allowing all permissions without prompts.",
+      operationId: "permission.allowEverything",
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: resolver(z.boolean()),
+            },
+          },
+        },
+        ...errors(400, 404),
+      },
+    }),
+    validator(
+      "json",
+      z.object({
+        enable: z.boolean(),
+        requestID: z.string().optional(),
+        sessionID: z.string().optional(),
+      }),
+    ),
+    async (c) => {
+      const body = c.req.valid("json")
+      const rules: Permission.Ruleset = [{ permission: "*", pattern: "*", action: "allow" }]
+
+      if (!body.enable) {
+        if (body.sessionID) {
+          const session = await Session.get(SessionID.make(body.sessionID))
+          await Session.setPermission({
+            sessionID: SessionID.make(body.sessionID),
+            permission: (session.permission ?? []).filter(
+              (rule) => !(rule.permission === "*" && rule.pattern === "*" && rule.action === "allow"),
+            ),
+          })
+          await allowEverything({ enable: false, sessionID: SessionID.make(body.sessionID) })
+          return c.json(true)
+        }
+
+        await Config.updateGlobal({ permission: { "*": { "*": null } } }, { dispose: false })
+        await allowEverything({ enable: false })
+        await Bus.publish(Event.ConfigUpdated, {})
+        return c.json(true)
+      }
+
+      if (body.sessionID) {
+        const session = await Session.get(SessionID.make(body.sessionID))
+        await Session.setPermission({
+          sessionID: SessionID.make(body.sessionID),
+          permission: [...(session.permission ?? []), ...rules],
+        })
+      } else {
+        await Config.updateGlobal({ permission: Permission.toConfig(rules) }, { dispose: false })
+        await Bus.publish(Event.ConfigUpdated, {})
+      }
+
+      await allowEverything({
+        enable: true,
+        requestID: body.requestID,
+        sessionID: body.sessionID ? SessionID.make(body.sessionID) : undefined,
+      })
+
+      return c.json(true)
+    },
+  ),
+)

package/src/saeeol/permission/rule.ts

@@ -0,0 +1,17 @@
+export type Rule = {
+  permission: string
+  pattern: string
+  action: "allow" | "deny" | "ask"
+}
+
+export type Ruleset = Rule[]
+
+export namespace PermissionRule {
+  export function broad(rule: Rule) {
+    return rule.permission === "*" || rule.pattern === "*"
+  }
+
+  export function mode(rule: Rule) {
+    return rule.permission === "*" && rule.pattern === "*" && rule.action === "deny"
+  }
+}

package/src/saeeol/plan-followup-handover.ts

@@ -0,0 +1,64 @@
+import { SessionID, MessageID } from "@/session/schema"
+import { Identifier } from "@/id/id"
+import { LLM } from "@/session/llm"
+import { MessageV2 } from "@/session/message-v2"
+import * as Log from "@saeeol/core/util/log"
+import { PlanFollowupRuntime } from "./plan-followup-runtime"
+
+export function formatTodos(todos: { status: string; content: string }[]): string {
+  if (!todos.length) return ""
+  const icons: Record<string, string> = {
+    completed: "[x]",
+    in_progress: "[~]",
+    cancelled: "[-]",
+  }
+  return todos.map((t) => `- ${icons[t.status] ?? "[ ]"} ${t.content}`).join("\n")
+}
+
+export async function generateHandover(input: {
+  messages: MessageV2.WithParts[]
+  model: MessageV2.User["model"]
+  abort?: AbortSignal
+}): Promise<string> {
+  const log = Log.create({ service: "plan.followup" })
+  try {
+    const entry = await PlanFollowupRuntime.agent("compaction")
+    const model = entry?.model
+      ? await PlanFollowupRuntime.model(entry.model.providerID, entry.model.modelID)
+      : await PlanFollowupRuntime.model(input.model.providerID, input.model.modelID)
+
+    const sessionID = SessionID.make(Identifier.ascending("session"))
+    const userMsg: MessageV2.User = {
+      id: MessageID.ascending(),
+      sessionID,
+      role: "user",
+      time: { created: Date.now() },
+      agent: "plan",
+      model: input.model,
+    }
+
+    const { HANDOVER_PROMPT } = await import("./plan-followup-runtime")
+    const stream = await LLM.stream({
+      agent: entry ?? { name: "compaction", mode: "subagent", permission: [], options: {} },
+      user: userMsg,
+      tools: {},
+      model,
+      small: true,
+      messages: [
+        ...(await MessageV2.toModelMessages(input.messages, model)),
+        { role: "user" as const, content: HANDOVER_PROMPT },
+      ],
+      abort: input.abort ? AbortSignal.any([input.abort, AbortSignal.timeout(60_000)]) : AbortSignal.timeout(60_000),
+      sessionID,
+      system: [],
+      retries: 1,
+    })
+
+    const result = await stream.text
+    return result.trim()
+  } catch (error) {
+    if (input.abort?.aborted) return ""
+    log.error("handover generation failed", { error })
+    return ""
+  }
+}

package/src/saeeol/plan-followup-runtime.ts

@@ -0,0 +1,86 @@
+import { Layer } from "effect"
+import { Agent } from "@/agent/agent"
+import { Provider } from "@/provider/provider"
+import { ProviderID, ModelID } from "@/provider/schema"
+import { Question } from "@/question"
+import { Todo } from "@/session/todo"
+import { makeRuntime } from "@/effect/run-service"
+import { SessionID } from "@/session/schema"
+import { Session } from "@/session/session"
+import * as Log from "@saeeol/core/util/log"
+import { defaultLayer as subtaskLayer } from "@/session/subtask"
+import { defaultLayer as shellLayer } from "@/session/shell-exec"
+import { MessageV2 } from "@/session/message-v2"
+
+const agents = makeRuntime(Agent.Service, Agent.defaultLayer)
+const providers = makeRuntime(Provider.Service, Provider.defaultLayer)
+const questions = makeRuntime(Question.Service, Question.defaultLayer)
+const todo = makeRuntime(Todo.Service, Todo.defaultLayer)
+
+export const pending = new Map<SessionID, AbortController>()
+
+export function toText(item: MessageV2.WithParts): string {
+  return item.parts
+    .filter((part): part is MessageV2.TextPart => part.type === "text")
+    .map((part) => part.text)
+    .join("\n")
+    .trim()
+}
+
+export const HANDOVER_PROMPT = `You are summarizing a planning session to hand off to an implementation session.
+
+The plan itself will be provided separately — do NOT repeat it. Instead, focus on information discovered during planning that would help the implementing agent but is NOT already in the plan text.
+
+Produce a concise summary using this template:
+---
+## Discoveries
+
+[Key findings from code exploration — architecture patterns, gotchas, edge cases, relevant existing code that the plan references but doesn't fully explain]
+
+## Relevant Files
+
+[Structured list of files/directories that were read or discussed, with brief notes on what's relevant in each]
+
+## Implementation Notes
+
+[Any important context: conventions to follow, potential pitfalls, dependencies between steps, things the implementing agent should watch out for]
+---
+
+If there is nothing useful to add beyond what the plan already says, respond with an empty string.
+Keep the summary concise — focus on high-entropy information that would save the implementing agent time.`
+
+export const PlanFollowupRuntime = {
+  agent(name: string): Promise<Agent.Info | undefined> {
+    return agents.runPromise((svc) => svc.get(name))
+  },
+  model(providerID: ProviderID, modelID: ModelID): Promise<Provider.Model> {
+    return providers.runPromise((svc) => svc.getModel(providerID, modelID))
+  },
+  question: {
+    ask(input: Parameters<Question.Interface["ask"]>[0]) {
+      return questions.runPromise((svc) => svc.ask(input))
+    },
+    list() {
+      return questions.runPromise((svc) => svc.list())
+    },
+    reject(requestID: Parameters<Question.Interface["reject"]>[0]) {
+      return questions.runPromise((svc) => svc.reject(requestID))
+    },
+  },
+  todo: {
+    get(sessionID: SessionID) {
+      return todo.runPromise((svc) => svc.get(sessionID))
+    },
+    update(input: Parameters<Todo.Interface["update"]>[0]) {
+      return todo.runPromise((svc) => svc.update(input))
+    },
+  },
+  async loop(sessionID: SessionID) {
+    const item = await import("@/session/prompt")
+    const prompt = makeRuntime(item.SessionPrompt.Service, item.SessionPrompt.defaultLayer.pipe(
+      Layer.provide(subtaskLayer),
+      Layer.provide(shellLayer),
+    ))
+    return prompt.runPromise((svc) => svc.loop({ sessionID }))
+  },
+}

package/src/saeeol/plan-followup-session.ts

@@ -0,0 +1,111 @@
+import { Bus } from "@/bus"
+import { TuiEvent } from "@/cli/cmd/tui/event"
+import { Instance } from "@/project/instance"
+import { Session } from "@/session/session"
+import { SessionID, MessageID, PartID } from "@/session/schema"
+import { SessionStatus } from "@/session/status"
+import { MessageV2 } from "@/session/message-v2"
+import * as Log from "@saeeol/core/util/log"
+import { pending, PlanFollowupRuntime } from "./plan-followup-runtime"
+import { formatTodos, generateHandover } from "./plan-followup-handover"
+import { SaeeolSessionPromptQueue } from "@/saeeol/session/prompt-queue"
+
+const log = Log.create({ service: "plan.followup" })
+
+export async function startNew(input: {
+  sessionID: SessionID
+  plan: string
+  messages: MessageV2.WithParts[]
+  model: MessageV2.User["model"]
+  abort?: AbortSignal
+  resolveCodeModel: (m: Pick<MessageV2.User, "model">) => Promise<{ model: MessageV2.User["model"] }>
+}) {
+  const code = await input.resolveCodeModel({ model: input.model })
+  const session = await Session.get(input.sessionID)
+
+  await Instance.provide({
+    directory: session.directory,
+    fn: async () => {
+      const next = await Session.create({})
+      const ctl = new AbortController()
+      pending.set(next.id, ctl)
+      await SessionStatus.set(next.id, { type: "busy" })
+      await Bus.publish(TuiEvent.SessionSelect, { sessionID: next.id })
+
+      const idle = () =>
+        SessionStatus.set(next.id, { type: "idle" }).catch((err) => {
+          log.warn("failed to clear follow-up busy status", { sessionID: next.id, err })
+        })
+
+      try {
+        const file = Session.plan(session, Instance.current)
+        const todos = await PlanFollowupRuntime.todo.get(input.sessionID)
+        const todoList = formatTodos(todos)
+
+        const compose = (handover: string) => {
+          const sections = [
+            `Plan file: ${file}\nRead this file first and treat it as the source of truth for implementation.`,
+            `Implement the following plan:\n\n${input.plan}`,
+          ]
+          if (handover) sections.push(`## Handover from Planning Session\n\n${handover}`)
+          if (todoList) sections.push(`## Todo List\n\n${todoList}`)
+          return sections.join("\n\n")
+        }
+
+        const msg: MessageV2.User = {
+          id: MessageID.ascending(),
+          sessionID: next.id,
+          role: "user",
+          time: { created: Date.now() },
+          agent: "code",
+          model: code.model,
+        }
+        await Session.updateMessage(msg)
+        const pid = PartID.ascending()
+        await Session.updatePart({
+          id: pid,
+          messageID: msg.id,
+          sessionID: next.id,
+          type: "text",
+          text: compose(""),
+          synthetic: false,
+        } satisfies MessageV2.TextPart)
+
+        if (todos.length) {
+          await PlanFollowupRuntime.todo.update({ sessionID: next.id, todos })
+        }
+
+        const handover = await generateHandover({
+          messages: input.messages,
+          model: input.model,
+          abort: input.abort ? AbortSignal.any([input.abort, ctl.signal]) : ctl.signal,
+        })
+        if (ctl.signal.aborted) { await idle(); return }
+
+        if (handover) {
+          await Session.updatePart({
+            id: pid, messageID: msg.id, sessionID: next.id,
+            type: "text", text: compose(handover), synthetic: false,
+          } satisfies MessageV2.TextPart)
+        }
+        if (ctl.signal.aborted) { await idle(); return }
+
+        const queue = Instance.provide({
+          directory: next.directory,
+          fn: async () => {
+            if (ctl.signal.aborted) { await idle(); return }
+            await PlanFollowupRuntime.loop(next.id)
+          },
+        })
+
+        void queue
+          .catch((error) => { log.error("failed to start follow-up session", { sessionID: next.id, error }); void idle() })
+          .finally(() => { if (pending.get(next.id) === ctl) pending.delete(next.id) })
+      } catch (error) {
+        if (pending.get(next.id) === ctl) pending.delete(next.id)
+        await idle()
+        throw error
+      }
+    },
+  })
+}