@saeeol/core 7.3.1

package/src/effect/observability.ts

@@ -0,0 +1,107 @@
+import { Effect, Layer, Logger } from "effect"
+import { FetchHttpClient } from "effect/unstable/http"
+import { OtlpLogger, OtlpSerialization } from "effect/unstable/observability"
+import * as EffectLogger from "./logger"
+import { Flag } from "../flag/flag"
+import { InstallationChannel, InstallationVersion } from "../installation/version"
+import { ensureProcessMetadata } from "../util/saeeol-process"
+
+const base = Flag.OTEL_EXPORTER_OTLP_ENDPOINT
+export const enabled = !!base
+const processID = crypto.randomUUID()
+
+const headers = Flag.OTEL_EXPORTER_OTLP_HEADERS
+  ? Flag.OTEL_EXPORTER_OTLP_HEADERS.split(",").reduce(
+      (acc, x) => {
+        const [key, ...value] = x.split("=")
+        acc[key] = value.join("=")
+        return acc
+      },
+      {} as Record<string, string>,
+    )
+  : undefined
+
+export function resource(): { serviceName: string; serviceVersion: string; attributes: Record<string, string> } {
+  const processMetadata = ensureProcessMetadata("main")
+  const attributes: Record<string, string> = (() => {
+    const value = process.env.OTEL_RESOURCE_ATTRIBUTES
+    if (!value) return {}
+    try {
+      return Object.fromEntries(
+        value.split(",").map((entry) => {
+          const index = entry.indexOf("=")
+          if (index < 1) throw new Error("Invalid OTEL_RESOURCE_ATTRIBUTES entry")
+          return [decodeURIComponent(entry.slice(0, index)), decodeURIComponent(entry.slice(index + 1))]
+        }),
+      )
+    } catch {
+      return {}
+    }
+  })()
+
+  return {
+    serviceName: "saeeol",
+    serviceVersion: InstallationVersion,
+    attributes: {
+      ...attributes,
+      "deployment.environment.name": InstallationChannel,
+      "saeeol.client": Flag.SAEEOL_CLIENT,
+      "saeeol.process_role": processMetadata.processRole,
+      "saeeol.run_id": processMetadata.runID,
+      "service.instance.id": processID,
+    },
+  }
+}
+
+function logs() {
+  return Logger.layer(
+    [
+      EffectLogger.logger,
+      OtlpLogger.make({
+        url: `${base}/v1/logs`,
+        resource: resource(),
+        headers,
+      }),
+    ],
+    { mergeWithExisting: false },
+  ).pipe(Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer))
+}
+
+const traces = async () => {
+  const NodeSdk = await import("@effect/opentelemetry/NodeSdk")
+  const OTLP = await import("@opentelemetry/exporter-trace-otlp-http")
+  const SdkBase = await import("@opentelemetry/sdk-trace-base")
+
+  // @effect/opentelemetry creates a NodeTracerProvider but never calls
+  // register(), so the global @opentelemetry/api context manager stays
+  // as the no-op default. Non-Effect code (like the AI SDK) that calls
+  // tracer.startActiveSpan() relies on context.active() to find the
+  // parent span - without a real context manager every span starts a
+  // new trace. Registering AsyncLocalStorageContextManager fixes this.
+  const { AsyncLocalStorageContextManager } = await import("@opentelemetry/context-async-hooks")
+  const { context } = await import("@opentelemetry/api")
+  const mgr = new AsyncLocalStorageContextManager()
+  mgr.enable()
+  context.setGlobalContextManager(mgr)
+
+  return NodeSdk.layer(() => ({
+    resource: resource(),
+    spanProcessor: new SdkBase.BatchSpanProcessor(
+      new OTLP.OTLPTraceExporter({
+        url: `${base}/v1/traces`,
+        headers,
+      }),
+    ),
+  }))
+}
+
+export const layer = !base
+  ? EffectLogger.layer
+  : Layer.unwrap(
+      Effect.gen(function* () {
+        const trace = yield* Effect.promise(traces)
+        return Layer.mergeAll(trace, logs())
+      }),
+    )
+
+export const Observability = { enabled, layer }

package/src/effect/runtime.ts

@@ -0,0 +1,21 @@
+import { Layer, type Context, ManagedRuntime, type Effect } from "effect"
+import { memoMap } from "./memo-map"
+import { Observability } from "./observability"
+
+export function makeRuntime<I, S, E>(service: Context.Service<I, S>, layer: Layer.Layer<I, E>) {
+  let rt: ManagedRuntime.ManagedRuntime<I, E> | undefined
+  const getRuntime = () =>
+    (rt ??= ManagedRuntime.make(Layer.provideMerge(layer, Observability.layer) as Layer.Layer<I, E>, {
+      memoMap,
+    }))
+
+  return {
+    runSync: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runSync(service.use(fn)),
+    runPromiseExit: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) =>
+      getRuntime().runPromiseExit(service.use(fn), options),
+    runPromise: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) =>
+      getRuntime().runPromise(service.use(fn), options),
+    runFork: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runFork(service.use(fn)),
+    runCallback: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runCallback(service.use(fn)),
+  }
+}

package/src/filesystem.ts

@@ -0,0 +1,262 @@
+import { NodeFileSystem } from "@effect/platform-node"
+import { dirname, isAbsolute, join, relative, resolve as pathResolve, sep } from "path" 
+import { realpathSync } from "fs"
+import * as NFS from "fs/promises"
+import { lookup } from "mime-types"
+import { Effect, FileSystem, Layer, Schema, Context } from "effect"
+import type { PlatformError } from "effect/PlatformError"
+import { Glob } from "./util/glob"
+// fs.mkdir(dir, { recursive: true }) should be idempotent, but on Windows
+// with NTFS reparse points (OneDrive), directory junctions, or WSL-served
+// paths, libuv can still throw EEXIST. This wrapper catches that specific
+// error so callers get the promised directory-exists semantics.
+//
+//   https://github.com/Saeeol-Org/saeeol/issues/9618
+//   https://github.com/Saeeol-Org/saeeol/issues/9755
+function isEexist(err: unknown): boolean {
+  return typeof err === "object" && err !== null && "code" in err && (err as NodeJS.ErrnoException).code === "EEXIST"
+}
+
+async function mkdirSafe(dir: string): Promise<void> {
+  try {
+    await NFS.mkdir(dir, { recursive: true })
+  } catch (err: unknown) {
+    if (isEexist(err)) return
+    throw err
+  }
+}
+
+export namespace AppFileSystem {
+  export class FileSystemError extends Schema.TaggedErrorClass<FileSystemError>()("FileSystemError", {
+    method: Schema.String,
+    cause: Schema.optional(Schema.Defect),
+  }) {}
+
+  export type Error = PlatformError | FileSystemError
+
+  export interface DirEntry {
+    readonly name: string
+    readonly type: "file" | "directory" | "symlink" | "other"
+  }
+
+  export interface Interface extends FileSystem.FileSystem {
+    readonly isDir: (path: string) => Effect.Effect<boolean>
+    readonly isFile: (path: string) => Effect.Effect<boolean>
+    readonly existsSafe: (path: string) => Effect.Effect<boolean>
+    readonly readJson: (path: string) => Effect.Effect<unknown, Error>
+    readonly writeJson: (path: string, data: unknown, mode?: number) => Effect.Effect<void, Error>
+    readonly ensureDir: (path: string) => Effect.Effect<void, Error>
+    readonly writeWithDirs: (path: string, content: string | Uint8Array, mode?: number) => Effect.Effect<void, Error>
+    readonly readDirectoryEntries: (path: string) => Effect.Effect<DirEntry[], Error>
+    readonly findUp: (target: string, start: string, stop?: string) => Effect.Effect<string[], Error>
+    readonly up: (options: { targets: string[]; start: string; stop?: string }) => Effect.Effect<string[], Error>
+    readonly globUp: (pattern: string, start: string, stop?: string) => Effect.Effect<string[], Error>
+    readonly glob: (pattern: string, options?: Glob.Options) => Effect.Effect<string[], Error>
+    readonly globMatch: (pattern: string, filepath: string) => boolean
+  }
+
+  export class Service extends Context.Service<Service, Interface>()("@saeeol/FileSystem") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem
+
+      const existsSafe = Effect.fn("FileSystem.existsSafe")(function* (path: string) {
+        return yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false))
+      })
+
+      const isDir = Effect.fn("FileSystem.isDir")(function* (path: string) {
+        const info = yield* fs.stat(path).pipe(Effect.catch(() => Effect.void))
+        return info?.type === "Directory"
+      })
+
+      const isFile = Effect.fn("FileSystem.isFile")(function* (path: string) {
+        const info = yield* fs.stat(path).pipe(Effect.catch(() => Effect.void))
+        return info?.type === "File"
+      })
+
+      const readDirectoryEntries = Effect.fn("FileSystem.readDirectoryEntries")(function* (dirPath: string) {
+        return yield* Effect.tryPromise({
+          try: async () => {
+            const entries = await NFS.readdir(dirPath, { withFileTypes: true })
+            return entries.map(
+              (e): DirEntry => ({
+                name: e.name,
+                type: e.isDirectory() ? "directory" : e.isSymbolicLink() ? "symlink" : e.isFile() ? "file" : "other",
+              }),
+            )
+          },
+          catch: (cause) => new FileSystemError({ method: "readDirectoryEntries", cause }),
+        })
+      })
+
+      const readJson = Effect.fn("FileSystem.readJson")(function* (path: string) {
+        const text = yield* fs.readFileString(path)
+        return JSON.parse(text)
+      })
+
+      const writeJson = Effect.fn("FileSystem.writeJson")(function* (path: string, data: unknown, mode?: number) {
+        const content = JSON.stringify(data, null, 2)
+        yield* fs.writeFileString(path, content)
+        if (mode) yield* fs.chmod(path, mode)
+      })
+
+      const ensureDir = Effect.fn("FileSystem.ensureDir")(function* (path: string) {
+        yield* Effect.tryPromise({
+          try: () => mkdirSafe(path),
+          catch: (cause) => new FileSystemError({ method: "ensureDir", cause }),
+        })
+      })
+
+      const writeWithDirs = Effect.fn("FileSystem.writeWithDirs")(function* (
+        path: string,
+        content: string | Uint8Array,
+        mode?: number,
+      ) {
+        const write = typeof content === "string" ? fs.writeFileString(path, content) : fs.writeFile(path, content)
+
+        yield* write.pipe(
+          Effect.catchIf(
+            (e) => e.reason._tag === "NotFound",
+            () =>
+              Effect.gen(function* () {
+                yield* Effect.tryPromise({
+                  try: () => mkdirSafe(dirname(path)),
+                  catch: (cause) => new FileSystemError({ method: "writeWithDirs:mkdir", cause }),
+                })
+                yield* write
+              }),
+          ),
+        )
+        if (mode) yield* fs.chmod(path, mode)
+      })
+
+      const glob = Effect.fn("FileSystem.glob")(function* (pattern: string, options?: Glob.Options) {
+        return yield* Effect.tryPromise({
+          try: () => Glob.scan(pattern, options),
+          catch: (cause) => new FileSystemError({ method: "glob", cause }),
+        })
+      })
+
+      const findUp = Effect.fn("FileSystem.findUp")(function* (target: string, start: string, stop?: string) {
+        const result: string[] = []
+        let current = start
+        while (true) {
+          const search = join(current, target)
+          if (yield* fs.exists(search)) result.push(search)
+          if (stop === current) break
+          const parent = dirname(current)
+          if (parent === current) break
+          current = parent
+        }
+        return result
+      })
+
+      const up = Effect.fn("FileSystem.up")(function* (options: { targets: string[]; start: string; stop?: string }) {
+        const result: string[] = []
+        let current = options.start
+        while (true) {
+          for (const target of options.targets) {
+            const search = join(current, target)
+            if (yield* fs.exists(search)) result.push(search)
+          }
+          if (options.stop === current) break
+          const parent = dirname(current)
+          if (parent === current) break
+          current = parent
+        }
+        return result
+      })
+
+      const globUp = Effect.fn("FileSystem.globUp")(function* (pattern: string, start: string, stop?: string) {
+        const result: string[] = []
+        let current = start
+        while (true) {
+          const matches = yield* glob(pattern, { cwd: current, absolute: true, include: "file", dot: true }).pipe(
+            Effect.catch(() => Effect.succeed([] as string[])),
+          )
+          result.push(...matches)
+          if (stop === current) break
+          const parent = dirname(current)
+          if (parent === current) break
+          current = parent
+        }
+        return result
+      })
+
+      return Service.of({
+        ...fs,
+        existsSafe,
+        isDir,
+        isFile,
+        readDirectoryEntries,
+        readJson,
+        writeJson,
+        ensureDir,
+        writeWithDirs,
+        findUp,
+        up,
+        globUp,
+        glob,
+        globMatch: Glob.match,
+      })
+    }),
+  )
+
+  export const defaultLayer = layer.pipe(Layer.provide(NodeFileSystem.layer))
+
+  // Pure helpers that don't need Effect (path manipulation, sync operations)
+  export function mimeType(p: string): string {
+    return lookup(p) || "application/octet-stream"
+  }
+
+  export function normalizePath(p: string): string {
+    if (process.platform !== "win32") return p
+    const resolved = pathResolve(windowsPath(p))
+    try {
+      return realpathSync.native(resolved)
+    } catch {
+      return resolved
+    }
+  }
+
+  export function normalizePathPattern(p: string): string {
+    if (process.platform !== "win32") return p
+    if (p === "*") return p
+    const match = p.match(/^(.*)[\\/]\*$/)
+    if (!match) return normalizePath(p)
+    const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1]
+    return join(normalizePath(dir), "*")
+  }
+
+  export function resolve(p: string): string {
+    const resolved = pathResolve(windowsPath(p))
+    try {
+      return normalizePath(realpathSync(resolved))
+    } catch (e: any) {
+      if (e?.code === "ENOENT") return normalizePath(resolved)
+      throw e
+    }
+  }
+
+  export function windowsPath(p: string): string {
+    if (process.platform !== "win32") return p
+    return p
+      .replace(/^\/([a-zA-Z]):(?:[\\/]|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+      .replace(/^\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+      .replace(/^\/cygdrive\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+      .replace(/^\/mnt\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+  }
+
+  export function overlaps(a: string, b: string) {
+    const relA = relative(a, b)
+    const relB = relative(b, a)
+    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..")
+  }
+
+  export function contains(parent: string, child: string) {
+    const rel = relative(parent, child)
+    return rel === "" || (!isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`))
+  }
+}

package/src/flag/flag.ts

@@ -0,0 +1,107 @@
+import { Config } from "effect"
+
+function truthy(key: string) {
+  const value = process.env[key]?.toLowerCase()
+  return value === "true" || value === "1"
+}
+
+function falsy(key: string) {
+  const value = process.env[key]?.toLowerCase()
+  return value === "false" || value === "0"
+}
+
+function number(key: string) {
+  const value = process.env[key]
+  if (!value) return undefined
+  const parsed = Number(value)
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined
+}
+
+const SAEEOL_EXPERIMENTAL = truthy("SAEEOL_EXPERIMENTAL")
+const SAEEOL_DISABLE_CLAUDE_CODE = truthy("SAEEOL_DISABLE_CLAUDE_CODE")
+const SAEEOL_DISABLE_CLAUDE_CODE_SKILLS = SAEEOL_DISABLE_CLAUDE_CODE || truthy("SAEEOL_DISABLE_CLAUDE_CODE_SKILLS")
+const copy = process.env["SAEEOL_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"]
+
+export const Flag = {
+  OTEL_EXPORTER_OTLP_ENDPOINT: process.env["OTEL_EXPORTER_OTLP_ENDPOINT"],
+  OTEL_EXPORTER_OTLP_HEADERS: process.env["OTEL_EXPORTER_OTLP_HEADERS"],
+
+  SAEEOL_AUTO_SHARE: truthy("SAEEOL_AUTO_SHARE"),
+  SAEEOL_AUTO_HEAP_SNAPSHOT: truthy("SAEEOL_AUTO_HEAP_SNAPSHOT"),
+  SAEEOL_GIT_BASH_PATH: process.env["SAEEOL_GIT_BASH_PATH"],
+  SAEEOL_CONFIG: process.env["SAEEOL_CONFIG"],
+  SAEEOL_CONFIG_CONTENT: process.env["SAEEOL_CONFIG_CONTENT"],
+  SAEEOL_DISABLE_AUTOUPDATE: truthy("SAEEOL_DISABLE_AUTOUPDATE"),
+  SAEEOL_ALWAYS_NOTIFY_UPDATE: truthy("SAEEOL_ALWAYS_NOTIFY_UPDATE"),
+  SAEEOL_DISABLE_PRUNE: truthy("SAEEOL_DISABLE_PRUNE"),
+  SAEEOL_DISABLE_TERMINAL_TITLE: truthy("SAEEOL_DISABLE_TERMINAL_TITLE"),
+  SAEEOL_SHOW_TTFD: truthy("SAEEOL_SHOW_TTFD"),
+  SAEEOL_PERMISSION: process.env["SAEEOL_PERMISSION"],
+  SAEEOL_DISABLE_DEFAULT_PLUGINS: truthy("SAEEOL_DISABLE_DEFAULT_PLUGINS"),
+  SAEEOL_DISABLE_LSP_DOWNLOAD: truthy("SAEEOL_DISABLE_LSP_DOWNLOAD"),
+  SAEEOL_ENABLE_EXPERIMENTAL_MODELS: truthy("SAEEOL_ENABLE_EXPERIMENTAL_MODELS"),
+  SAEEOL_DISABLE_AUTOCOMPACT: truthy("SAEEOL_DISABLE_AUTOCOMPACT"),
+  SAEEOL_DISABLE_MODELS_FETCH: truthy("SAEEOL_DISABLE_MODELS_FETCH"),
+  SAEEOL_DISABLE_MOUSE: truthy("SAEEOL_DISABLE_MOUSE"),
+  SAEEOL_DISABLE_CLAUDE_CODE,
+  SAEEOL_DISABLE_CLAUDE_CODE_PROMPT: SAEEOL_DISABLE_CLAUDE_CODE || truthy("SAEEOL_DISABLE_CLAUDE_CODE_PROMPT"),
+  SAEEOL_DISABLE_CLAUDE_CODE_SKILLS,
+  SAEEOL_DISABLE_EXTERNAL_SKILLS: SAEEOL_DISABLE_CLAUDE_CODE_SKILLS || truthy("SAEEOL_DISABLE_EXTERNAL_SKILLS"),
+  SAEEOL_FAKE_VCS: process.env["SAEEOL_FAKE_VCS"],
+  SAEEOL_SERVER_PASSWORD: process.env["SAEEOL_SERVER_PASSWORD"],
+  SAEEOL_SERVER_USERNAME: process.env["SAEEOL_SERVER_USERNAME"],
+  SAEEOL_ENABLE_QUESTION_TOOL: truthy("SAEEOL_ENABLE_QUESTION_TOOL"),
+
+  // Experimental
+  SAEEOL_EXPERIMENTAL,
+  SAEEOL_EXPERIMENTAL_FILEWATCHER: Config.boolean("SAEEOL_EXPERIMENTAL_FILEWATCHER").pipe(Config.withDefault(false)),
+  SAEEOL_EXPERIMENTAL_DISABLE_FILEWATCHER: Config.boolean("SAEEOL_EXPERIMENTAL_DISABLE_FILEWATCHER").pipe(
+    Config.withDefault(false),
+  ),
+  SAEEOL_EXPERIMENTAL_ICON_DISCOVERY: SAEEOL_EXPERIMENTAL || truthy("SAEEOL_EXPERIMENTAL_ICON_DISCOVERY"),
+  SAEEOL_EXPERIMENTAL_DISABLE_COPY_ON_SELECT:
+    copy === undefined ? process.platform === "win32" : truthy("SAEEOL_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"),
+  SAEEOL_ENABLE_EXA: truthy("SAEEOL_ENABLE_EXA") || SAEEOL_EXPERIMENTAL || truthy("SAEEOL_EXPERIMENTAL_EXA"),
+  SAEEOL_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS: number("SAEEOL_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS"),
+  SAEEOL_EXPERIMENTAL_OUTPUT_TOKEN_MAX: number("SAEEOL_EXPERIMENTAL_OUTPUT_TOKEN_MAX"),
+  SAEEOL_EXPERIMENTAL_OXFMT: SAEEOL_EXPERIMENTAL || truthy("SAEEOL_EXPERIMENTAL_OXFMT"),
+  SAEEOL_EXPERIMENTAL_LSP_TY: truthy("SAEEOL_EXPERIMENTAL_LSP_TY"),
+  SAEEOL_EXPERIMENTAL_LSP_TOOL: SAEEOL_EXPERIMENTAL || truthy("SAEEOL_EXPERIMENTAL_LSP_TOOL"),
+  SAEEOL_EXPERIMENTAL_PLAN_MODE: SAEEOL_EXPERIMENTAL || truthy("SAEEOL_EXPERIMENTAL_PLAN_MODE"),
+  SAEEOL_EXPERIMENTAL_MARKDOWN: !falsy("SAEEOL_EXPERIMENTAL_MARKDOWN"),
+  SAEEOL_MODELS_URL: process.env["SAEEOL_MODELS_URL"],
+  SAEEOL_MODELS_PATH: process.env["SAEEOL_MODELS_PATH"],
+  SAEEOL_DISABLE_EMBEDDED_WEB_UI: truthy("SAEEOL_DISABLE_EMBEDDED_WEB_UI"),
+  SAEEOL_DB: process.env["SAEEOL_DB"],
+  SAEEOL_DISABLE_CHANNEL_DB: truthy("SAEEOL_DISABLE_CHANNEL_DB"),
+  SAEEOL_SKIP_MIGRATIONS: truthy("SAEEOL_SKIP_MIGRATIONS"),
+  SAEEOL_STRICT_CONFIG_DEPS: truthy("SAEEOL_STRICT_CONFIG_DEPS"),
+
+  SAEEOL_WORKSPACE_ID: process.env["SAEEOL_WORKSPACE_ID"],
+  SAEEOL_EXPERIMENTAL_HTTPAPI: truthy("SAEEOL_EXPERIMENTAL_HTTPAPI"),
+  SAEEOL_EXPERIMENTAL_WORKSPACES: SAEEOL_EXPERIMENTAL || truthy("SAEEOL_EXPERIMENTAL_WORKSPACES"),
+
+  // Evaluated at access time (not module load) because tests, the CLI, and
+  // external tooling set these env vars at runtime.
+  get SAEEOL_DISABLE_PROJECT_CONFIG() {
+    return truthy("SAEEOL_DISABLE_PROJECT_CONFIG")
+  },
+  get SAEEOL_TUI_CONFIG() {
+    return process.env["SAEEOL_TUI_CONFIG"]
+  },
+  get SAEEOL_CONFIG_DIR() {
+    return process.env["SAEEOL_CONFIG_DIR"]
+  },
+  get SAEEOL_PURE() {
+    return truthy("SAEEOL_PURE")
+  },
+  get SAEEOL_PLUGIN_META_FILE() {
+    return process.env["SAEEOL_PLUGIN_META_FILE"]
+  },
+  get SAEEOL_CLIENT() {
+    return process.env["SAEEOL_CLIENT"] ?? "cli"
+  },
+  get SAEEOL_SESSION_RETRY_LIMIT() {
+    return number("SAEEOL_SESSION_RETRY_LIMIT")
+  },
+}

package/src/global.ts

@@ -0,0 +1,91 @@
+import path from "path"
+import fs from "fs/promises"
+import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
+import os from "os"
+import { Context, Effect, Layer } from "effect"
+import { Flock } from "./util/flock"
+import { markNoIndex } from "./saeeol/spotlight" 
+import { ensureRealDir } from "./saeeol/global" 
+import { Flag } from "./flag/flag"
+
+const app = "saeeol" 
+// Defensively strip newline characters from the resolved XDG paths.
+// If `$HOME` (or any `$XDG_*_HOME` override) has a trailing newline in
+// the user's shell — e.g. because a shell snippet did `export HOME=$(cmd)`
+// against a command with an implicit newline — the unsanitised path
+// makes `fs.mkdir` try to create `/Users/<name>\n` and fail with EACCES,
+// which breaks every `saeeol` invocation at startup (including the SDK
+// regen that runs during `bun run extension`).
+const clean = (p: string | undefined) => p?.replace(/[\r\n]+/g, "")
+const data = path.join(clean(xdgData)!, app)
+const cache = path.join(clean(xdgCache)!, app)
+const config = path.join(clean(xdgConfig)!, app)
+const state = path.join(clean(xdgState)!, app)
+const tmp = path.join(os.tmpdir(), app)
+
+const paths = {
+  get home() {
+    return (process.env.SAEEOL_TEST_HOME ?? os.homedir()).trim() 
+  },
+  data,
+  bin: path.join(cache, "bin"),
+  log: path.join(data, "log"),
+  cache,
+  config,
+  state,
+  tmp,
+}
+
+export const Path = paths
+
+Flock.setGlobal({ state })
+
+await Promise.all([
+  ensureRealDir(Path.data), 
+  ensureRealDir(Path.config), 
+  ensureRealDir(Path.state), 
+  ensureRealDir(Path.tmp), 
+  ensureRealDir(Path.log), 
+  ensureRealDir(Path.bin), 
+])
+await Promise.all([Path.data, Path.cache, Path.state].map(markNoIndex))
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/Global") {}
+
+export interface Interface {
+  readonly home: string
+  readonly data: string
+  readonly cache: string
+  readonly config: string
+  readonly state: string
+  readonly tmp: string
+  readonly bin: string
+  readonly log: string
+}
+
+export function make(input: Partial<Interface> = {}): Interface {
+  return {
+    home: Path.home,
+    data: Path.data,
+    cache: Path.cache,
+    config: Flag.SAEEOL_CONFIG_DIR ?? Path.config,
+    state: Path.state,
+    tmp: Path.tmp,
+    bin: Path.bin,
+    log: Path.log,
+    ...input,
+  }
+}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.sync(() => Service.of(make())),
+)
+
+export const layerWith = (input: Partial<Interface>) =>
+  Layer.effect(
+    Service,
+    Effect.sync(() => Service.of(make(input))),
+  )
+
+export * as Global from "./global"

package/src/installation/version.ts

@@ -0,0 +1,11 @@
+declare global {
+  const SAEEOL_VERSION: string
+  const SAEEOL_CHANNEL: string
+  const SAEEOL_BUILD_KIND: string 
+}
+
+export const InstallationVersion = typeof SAEEOL_VERSION === "string" ? SAEEOL_VERSION : "local"
+export const InstallationChannel = typeof SAEEOL_CHANNEL === "string" ? SAEEOL_CHANNEL : "local"
+export const InstallationLocal = InstallationChannel === "local"
+export const InstallationBuildKind: "source" | "release" =
+  typeof SAEEOL_BUILD_KIND === "string" && SAEEOL_BUILD_KIND === "release" ? "release" : "source"

package/src/npm-config.ts

@@ -0,0 +1,40 @@
+export * as NpmConfig from "./npm-config"
+
+import { fileURLToPath } from "url"
+// @ts-expect-error npm does not publish types for this internal config API.
+import Config from "@npmcli/config"
+// @ts-expect-error npm does not publish types for this internal config API.
+import { definitions, flatten, nerfDarts, shorthands } from "@npmcli/config/lib/definitions/index.js"
+import { Effect } from "effect"
+
+const npmPath = fileURLToPath(new URL("..", import.meta.url))
+
+export const load = (dir: string) =>
+  Effect.tryPromise({
+    try: async () => {
+      const config = new Config({
+        npmPath,
+        cwd: dir,
+        env: { ...process.env },
+        argv: [process.execPath, process.execPath],
+        execPath: process.execPath,
+        platform: process.platform,
+        definitions,
+        flatten,
+        nerfDarts,
+        shorthands,
+        warn: false,
+      })
+      await config.load()
+      return config.flat as Record<string, unknown>
+    },
+    catch: (cause) => cause,
+  }).pipe(Effect.orElseSucceed(() => ({}) as Record<string, unknown>))
+
+export const registry = (dir: string) =>
+  load(dir).pipe(
+    Effect.map((config) => {
+      const registry = typeof config.registry === "string" ? config.registry : "https://registry.npmjs.org"
+      return registry.endsWith("/") ? registry.slice(0, -1) : registry
+    }),
+  )