saeeol 1.4.2 → 1.4.3

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

@@ -1,168 +0,0 @@
-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/overlay/permission/drain.ts

@@ -1,58 +0,0 @@
-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/overlay/permission/external-directory.ts

@@ -1,14 +0,0 @@
-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/overlay/permission/read.ts

@@ -1,19 +0,0 @@
-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/overlay/permission/routes.ts

@@ -1,87 +0,0 @@
-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/overlay/permission/rule.ts

@@ -1,17 +0,0 @@
-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/overlay/plan-followup-handover.ts

@@ -1,64 +0,0 @@
-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/overlay/plan-followup-runtime.ts

@@ -1,86 +0,0 @@
-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/overlay/plan-followup-session.ts

@@ -1,111 +0,0 @@
-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
-      }
-    },
-  })
-}