@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.4

package/src/plugin/sleepy.ts

@@ -0,0 +1,244 @@
+import type { Hooks, PluginInput } from "@sleepy-ai/plugin"
+import { Log } from "../util"
+import { createServer } from "http"
+import crypto from "crypto"
+import { exec } from "child_process"
+import { Global } from "../global"
+import path from "path"
+import fs from "fs"
+
+const log = Log.create({ service: "plugin.sleepy" })
+
+const PLATFORM_URL = process.env.SLEEPY_PLATFORM_URL || "https://www.sleepyai.org"
+
+function getKeyName(): string {
+  const filePath = path.join(Global.Path.data, "sleepy-key-name")
+  try {
+    const existing = fs.readFileSync(filePath, "utf-8").trim()
+    if (existing) return existing
+  } catch {}
+  const name = `sleepy-code-cli-key-${crypto.randomBytes(4).toString("hex")}`
+  fs.writeFileSync(filePath, name)
+  return name
+}
+
+function generateKeyPair() {
+  const keyPair = crypto.generateKeyPairSync("x25519", {
+    publicKeyEncoding: { type: "spki", format: "der" },
+    privateKeyEncoding: { type: "pkcs8", format: "der" },
+  })
+  const publicKeyBase64 = Buffer.from(keyPair.publicKey).toString("base64url")
+  return { publicKey: publicKeyBase64, privateKeyDer: keyPair.privateKey }
+}
+
+function decrypt(privateKeyDer: Buffer, encryptedBase64: string): { sk?: string; uid: string; url?: string } {
+  const encrypted = Buffer.from(encryptedBase64, "base64url")
+  // Format: ephemeralPublicKey(32 bytes) + nonce(12 bytes) + ciphertext + tag(16 bytes)
+  const ephemeralPub = encrypted.subarray(0, 32)
+  const nonce = encrypted.subarray(32, 44)
+  const ciphertextAndTag = encrypted.subarray(44)
+  const tag = ciphertextAndTag.subarray(ciphertextAndTag.length - 16)
+  const ciphertext = ciphertextAndTag.subarray(0, ciphertextAndTag.length - 16)
+
+  const privateKey = crypto.createPrivateKey({ key: privateKeyDer, format: "der", type: "pkcs8" })
+  const ephemeralPublicKey = crypto.createPublicKey({
+    key: Buffer.concat([Buffer.from("302a300506032b656e032100", "hex"), ephemeralPub]),
+    format: "der",
+    type: "spki",
+  })
+
+  const sharedSecret = crypto.diffieHellman({ privateKey, publicKey: ephemeralPublicKey })
+  const derivedKey = crypto.createHash("sha256").update(sharedSecret).digest()
+
+  const decipher = crypto.createDecipheriv("aes-256-gcm", derivedKey, nonce)
+  decipher.setAuthTag(tag)
+  const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()])
+
+  return JSON.parse(decrypted.toString("utf-8"))
+}
+
+function openBrowser(url: string) {
+  if (process.env.CI || process.env.NODE_ENV === "test") return
+  const command =
+    process.platform === "darwin"
+      ? `open "${url}"`
+      : process.platform === "win32"
+        ? `start "" "${url}"`
+        : `xdg-open "${url}"`
+  exec(command, (error) => {
+    if (error) {
+      log.warn("could not open browser automatically", { error })
+    }
+  })
+}
+
+function buildAuthorizeUrl(publicKey: string, redirectUri: string): string {
+  const params = new URLSearchParams({
+    pk: publicKey,
+    redirect_uri: redirectUri,
+    kn: "sleepycode",
+    key_name: getKeyName(),
+  })
+  return `${PLATFORM_URL}/authorize?${params.toString()}`
+}
+
+export async function SleepyAuthPlugin(_input: PluginInput): Promise<Hooks> {
+  return {
+    config: async (input) => {
+      input.provider ??= {}
+      // Register sleepy as a config provider so it shows up even before login.
+      // name/api are intentionally left to the models.dev database (name: "Xiaomi",
+      // api: https://www.sleepyai.org/api/v1) — hardcoding "Sleepy" here collided with
+      // the free "sleepy" provider's display name and confused users.
+      input.provider.sleepy ??= {}
+      // Both "opencode" and "opencode-go" stay enabled. The opencode custom
+      // loader strips the free/public tier (and hides paid models until the
+      // user authenticates). "opencode-go" has no free models and no custom
+      // loader, so it only loads once a subscription key/auth is present.
+    },
+    auth: {
+      provider: "sleepy",
+      async loader(getAuth) {
+        const auth = (await getAuth()) as { type: string; metadata?: Record<string, string> }
+        if (auth?.type !== "api" || !auth.metadata?.base_url) return {}
+        return { baseURL: auth.metadata.base_url }
+      },
+      methods: [
+        {
+          label: "浏览器登录",
+          type: "oauth" as const,
+          authorize: async () => {
+            const { publicKey, privateKeyDer } = generateKeyPair()
+
+            const server = createServer()
+            await new Promise<void>((resolve, reject) => {
+              server.listen(0, () => resolve())
+              server.on("error", reject)
+            })
+            const addr = server.address()
+            const port = typeof addr === "object" && addr ? addr.port : 0
+            log.info("sleepy oauth server started", { port })
+
+            const redirectUri = `http://localhost:${port}/`
+            const authUrl = buildAuthorizeUrl(publicKey, redirectUri)
+            const manualUrl = buildAuthorizeUrl(publicKey, `${PLATFORM_URL}/authorize/code/callback`)
+
+            openBrowser(authUrl)
+
+            const serverCallbackPromise = new Promise<{ sk?: string; uid: string; url?: string }>((resolve, reject) => {
+              const timeout = setTimeout(() => {
+                server.close()
+                reject(new Error("Authorization timeout"))
+              }, 5 * 60 * 1000)
+
+              server.on("request", (req, res) => {
+                const url = new URL(req.url || "/", `http://localhost`)
+                log.info("sleepy oauth callback received", { path: url.pathname, query: url.search.substring(0, 100) })
+
+                const u = url.searchParams.get("u")
+
+                if (!u) {
+                  log.warn("sleepy oauth callback missing u param")
+                  res.writeHead(302, { Location: `${PLATFORM_URL}/authorize/callback?status=error&message=missing_data` })
+                  res.end()
+                  reject(new Error("Missing encrypted data"))
+                  return
+                }
+
+                try {
+                  const result = decrypt(privateKeyDer, u)
+                  log.info("sleepy oauth decrypt success", { uid: result.uid, url: result.url })
+                  res.writeHead(302, { Location: `${PLATFORM_URL}/authorize/callback?status=success` })
+                  res.end()
+                  clearTimeout(timeout)
+                  resolve(result)
+                } catch (err) {
+                  log.error("sleepy oauth decrypt failed", { error: err })
+                  res.writeHead(302, { Location: `${PLATFORM_URL}/authorize/callback?status=error&message=decrypt_failed` })
+                  res.end()
+                  reject(new Error("Decryption failed"))
+                }
+              })
+            })
+            serverCallbackPromise.catch(() => {})
+
+            return {
+              url: manualUrl,
+              method: "auto" as const,
+              instructions: "在浏览器中完成授权，或粘贴 Code 完成登录。",
+              callback: async (code?: string) => {
+                if (code) {
+                  try {
+                    const result = decrypt(privateKeyDer, code.trim())
+                    server.close()
+                    const metadata: Record<string, string> = { uid: result.uid }
+                    if (result.url) metadata.base_url = result.url
+                    return { type: "success" as const, key: result.sk ?? "", metadata }
+                  } catch {
+                    return { type: "failed" as const }
+                  }
+                }
+                try {
+                  const result = await serverCallbackPromise
+                  server.close()
+                  const metadata: Record<string, string> = { uid: result.uid }
+                  if (result.url) metadata.base_url = result.url
+                  return { type: "success" as const, key: result.sk ?? "", metadata }
+                } catch {
+                  server.close()
+                  return { type: "failed" as const }
+                }
+              },
+            }
+          },
+        },
+      ],
+    },
+    "chat.headers": async (input, output) => {
+      if (input.model.providerID !== "sleepy") return
+      output.headers["X-Sleepy-Source"] = "sleepycode-cli"
+    },
+  }
+}
+
+export async function AnthropicProxyPlugin(_input: PluginInput): Promise<Hooks> {
+  return {
+    auth: {
+      provider: "anthropic",
+      async loader(_getAuth, provider) {
+        if (!provider?.options?.baseURL) return {}
+        return {
+          async fetch(url: any, init: any) {
+            if (init?.headers && typeof init.headers === "object" && !Array.isArray(init.headers)) {
+              delete init.headers["anthropic-beta"]
+            }
+            const res = await fetch(url, init)
+            if (!res.body || !res.headers.get("content-type")?.includes("text/event-stream")) return res
+            const reader = res.body.getReader()
+            const decoder = new TextDecoder()
+            let done = false
+            let buffer = ""
+            const body = new ReadableStream<Uint8Array>({
+              async pull(ctrl) {
+                if (done) { ctrl.close(); return }
+                const chunk = await reader.read()
+                if (chunk.done) { ctrl.close(); return }
+                ctrl.enqueue(chunk.value)
+                buffer += decoder.decode(chunk.value, { stream: true })
+                if (buffer.includes("\nevent: message_stop\n") || buffer.includes("\ndata: {\"type\":\"message_stop\"}")) {
+                  done = true
+                  void reader.cancel()
+                  ctrl.close()
+                }
+                if (buffer.length > 512) buffer = buffer.slice(-256)
+              },
+              cancel() { reader.cancel() },
+            })
+            return new Response(body, { headers: res.headers, status: res.status })
+          },
+        }
+      },
+      methods: [],
+    },
+  }
+}

package/src/plugin/subagent-progress-checker.ts

@@ -0,0 +1,147 @@
+import type { Hooks, PluginInput } from "@sleepy-ai/plugin"
+import fs from "fs/promises"
+import path from "path"
+import { Log } from "../util"
+import { progressPath } from "../session/checkpoint-paths"
+import type { SessionID } from "../session/schema"
+
+const log = Log.create({ service: "plugin.subagent-progress-checker" })
+
+const REQUIRED_SECTIONS = [
+  "## §1 Task identity",
+  "## §2 Subagent intent",
+  "## §3 Files and code sections",
+  "## §4 Verbatim commands",
+  "## §5 Outcome and discoveries",
+] as const
+
+const TEMPLATE = `## §1 Task identity
+- task_id: <TID>
+- short summary: <one line>
+
+## §2 Subagent intent
+What this subagent was asked to do (one paragraph).
+
+## §3 Files and code sections
+- path/to/file.ext: <what you did with it>
+
+## §4 Verbatim commands
+Exact commands you ran or commands the user/task asked to be runnable later. Keep BACKTICK-FENCED for grep-ability.
+\`\`\`
+<command>
+\`\`\`
+
+## §5 Outcome and discoveries
+- Outcome (success/partial/failed): <reason>
+- Discoveries that may matter for other tasks: <bullets>
+`
+
+function buildFeedback(args: {
+  kind: "missing" | "incomplete"
+  taskId: string
+  filePath: string
+  missing?: readonly string[]
+}): string {
+  if (args.kind === "missing") {
+    return [
+      "Before terminating, write the task progress journal to:",
+      `  ${args.filePath}`,
+      "",
+      "Required structure (5 sections, headings exact):",
+      "",
+      TEMPLATE.replace("<TID>", args.taskId),
+      "",
+      "Write the file now using the Write tool, then terminate normally.",
+    ].join("\n")
+  }
+
+  return [
+    `tasks/${args.taskId}/progress.md exists but is missing required sections:`,
+    ...(args.missing ?? []).map((s) => `  - ${s}`),
+    "",
+    "Add the missing sections. For reference, the full required template is:",
+    "",
+    TEMPLATE.replace("<TID>", args.taskId),
+    "",
+    "Re-write the file using Write tool, then terminate normally.",
+  ].join("\n")
+}
+
+async function injectFrontmatter(filePath: string, body: string): Promise<void> {
+  const now = Date.now()
+  const frontmatterBlock = `---\nwritten-at: ${now}\n---\n`
+  // Replace existing leading frontmatter if present (idempotent across ReAct retries)
+  const fmMatch = body.match(/^---\n[\s\S]*?\n---\n/)
+  const newBody = fmMatch
+    ? frontmatterBlock + body.slice(fmMatch[0].length)
+    : frontmatterBlock + body
+  await Bun.write(filePath, newBody)
+}
+
+export async function SubagentProgressCheckerPlugin(_pluginInput: PluginInput): Promise<Hooks> {
+  return {
+    "actor.postStop": {
+      // Use excludeOnly so the matcher fires for ALL actor types EXCEPT those
+      // listed (including built-in subagents like general/explore/build/title).
+      // The default matcher path (`!isBuiltIn`) would silently skip built-ins
+      // — which are exactly the most common task-bound subagents this plugin
+      // exists to validate. checkpoint-writer / title / summary / dream /
+      // distill / compaction never have task_id semantics, so excluding them
+      // is harmless even though task_id check below would already short-circuit.
+      // See packages/opencode/src/plugin/matcher.ts.
+      matcher: {
+        agentType: {
+          excludeOnly: [
+            "checkpoint-writer",
+            "title",
+            "summary",
+            "dream",
+            "distill",
+            "compaction",
+            "main",
+          ],
+        },
+      },
+      run: async (input, output) => {
+        const taskId = (input as { task_id?: string }).task_id
+        if (!taskId) return // caller didn't bind to a task → no-op
+        // Read-only agents (canWrite === false) cannot satisfy a "write the journal" nudge —
+        // skip the check entirely so we don't burn postStop re-entries on an impossible ask.
+        // `=== false` (not falsy): an absent canWrite must NOT suppress (fail-open).
+        if ((input as { canWrite?: boolean }).canWrite === false) return
+
+        const sessionID = input.sessionID as SessionID
+        const filePath = progressPath(sessionID, taskId)
+
+        let body: string | undefined
+        try {
+          body = await Bun.file(filePath).text()
+        } catch {
+          body = undefined
+        }
+
+        if (body === undefined) {
+          output.continue = true
+          output.reason = buildFeedback({ kind: "missing", taskId, filePath })
+          return
+        }
+
+        const missing = REQUIRED_SECTIONS.filter((s) => !body!.includes(s))
+        if (missing.length > 0) {
+          output.continue = true
+          output.reason = buildFeedback({ kind: "incomplete", taskId, filePath, missing })
+          return
+        }
+
+        // PASS: inject frontmatter (runtime owns this, not the LLM)
+        try {
+          await fs.mkdir(path.dirname(filePath), { recursive: true })
+          await injectFrontmatter(filePath, body)
+        } catch (err) {
+          log.error("frontmatter injection failed", { err, filePath })
+        }
+        // do not set output.continue; subagent exits postStop loop cleanly
+      },
+    },
+  }
+}

package/src/project/bootstrap.ts

@@ -0,0 +1,59 @@
+import { Plugin } from "../plugin"
+import { Format } from "../format"
+import { LSP } from "../lsp"
+import { File } from "../file"
+import { Snapshot } from "../snapshot"
+import * as Project from "./project"
+import * as Vcs from "./vcs"
+import { Bus } from "../bus"
+import { Command } from "../command"
+import { Instance } from "./instance"
+import { Log } from "@/util"
+import { FileWatcher } from "@/file/watcher"
+import { ShareNext } from "@/share"
+import * as Effect from "effect/Effect"
+import { Config } from "@/config"
+import { Metrics } from "@/metrics"
+import { Memory } from "@/memory"
+import { WriterService, BackfillService } from "@/history"
+
+export const InstanceBootstrap = Effect.gen(function* () {
+  Log.Default.info("bootstrapping", { directory: Instance.directory })
+  // everything depends on config so eager load it for nice traces
+  yield* Config.Service.use((svc) => svc.get())
+  // Plugin can mutate config so it has to be initialized before anything else.
+  yield* Plugin.Service.use((svc) => svc.init())
+  yield* Effect.all(
+    [
+      LSP.Service,
+      ShareNext.Service,
+      Format.Service,
+      File.Service,
+      FileWatcher.Service,
+      Vcs.Service,
+      Snapshot.Service,
+      WriterService,
+      BackfillService,
+    ].map((s) => Effect.forkDetach(s.use((i) => i.init()))),
+  ).pipe(Effect.withSpan("InstanceBootstrap.init"))
+
+  // Warm the FTS index off the boot path. Off-tool writes between
+  // process invocations are picked up here without blocking startup;
+  // a missing memory dir or partial sync must not fail boot.
+  yield* Memory.Service.use((svc) => svc.reconcile()).pipe(
+    Effect.catch((err: unknown) =>
+      Effect.sync(() => Log.Default.warn("memory reconcile failed", { error: String(err) })),
+    ),
+    Effect.forkDetach,
+  )
+
+  yield* Bus.Service.use((svc) =>
+    svc.subscribeCallback(Command.Event.Executed, async (payload) => {
+      if (payload.properties.name === Command.Default.INIT) {
+        Project.setInitialized(Instance.project.id)
+      }
+    }),
+  )
+
+  yield* Metrics.subscribe()
+}).pipe(Effect.withSpan("InstanceBootstrap"))

package/src/project/index.ts

@@ -0,0 +1,2 @@
+export * as Vcs from "./vcs"
+export * as Project from "./project"

package/src/project/instance.ts

@@ -0,0 +1,215 @@
+import { GlobalBus } from "@/bus/global"
+import { disposeInstance } from "@/effect/instance-registry"
+import { makeRuntime } from "@/effect/run-service"
+import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
+import { iife } from "@/util/iife"
+import { Log } from "@/util"
+import { LocalContext } from "../util"
+import * as Project from "./project"
+import { WorkspaceContext } from "@/control-plane/workspace-context"
+import { parse as pathParse } from "path"
+
+export interface InstanceContext {
+  directory: string
+  worktree: string
+  project: Project.Info
+}
+
+const context = LocalContext.create<InstanceContext>("instance")
+const cache = new Map<string, Promise<InstanceContext>>()
+const project = makeRuntime(Project.Service, Project.defaultLayer)
+
+const FORBIDDEN_PREFIXES = [
+  "/etc",
+  "/proc",
+  "/sys",
+  "/dev",
+  "/boot",
+  "/private/etc",
+] as const
+
+function assertSafeDirectory(directory: string): void {
+  const resolved = AppFileSystem.resolve(directory)
+  if (resolved === pathParse(resolved).root) {
+    throw new Error("Access denied: filesystem root is not a valid project directory")
+  }
+  if (process.platform !== "win32") {
+    for (const prefix of FORBIDDEN_PREFIXES) {
+      if (resolved === prefix || resolved.startsWith(`${prefix}/`)) {
+        throw new Error("Access denied: target is a protected system directory")
+      }
+    }
+  }
+}
+
+const disposal = {
+  all: undefined as Promise<void> | undefined,
+}
+
+function boot(input: { directory: string; init?: () => Promise<any>; worktree?: string; project?: Project.Info }) {
+  return iife(async () => {
+    const ctx =
+      input.project && input.worktree
+        ? {
+            directory: input.directory,
+            worktree: input.worktree,
+            project: input.project,
+          }
+        : await project
+            .runPromise((svc) => svc.fromDirectory(input.directory))
+            .then(({ project, sandbox }) => ({
+              directory: input.directory,
+              worktree: sandbox,
+              project,
+            }))
+    await context.provide(ctx, async () => {
+      await input.init?.()
+    })
+    return ctx
+  })
+}
+
+function track(directory: string, next: Promise<InstanceContext>) {
+  const task = next.catch((error) => {
+    if (cache.get(directory) === task) cache.delete(directory)
+    throw error
+  })
+  cache.set(directory, task)
+  return task
+}
+
+export const Instance = {
+  async provide<R>(input: { directory: string; init?: () => Promise<any>; fn: () => R }): Promise<R> {
+    const directory = AppFileSystem.resolve(input.directory)
+    assertSafeDirectory(directory)
+    let existing = cache.get(directory)
+    if (!existing) {
+      Log.Default.info("creating instance", { directory })
+      existing = track(
+        directory,
+        boot({
+          directory,
+          init: input.init,
+        }),
+      )
+    }
+    const ctx = await existing
+    return context.provide(ctx, async () => {
+      return input.fn()
+    })
+  },
+  get current() {
+    return context.use()
+  },
+  get directory() {
+    return context.use().directory
+  },
+  get worktree() {
+    return context.use().worktree
+  },
+  get project() {
+    return context.use().project
+  },
+
+  /**
+   * Check if a path is within the project boundary.
+   * Returns true if path is inside Instance.directory OR Instance.worktree.
+   * Paths within the worktree but outside the working directory should not trigger external_directory permission.
+   */
+  containsPath(filepath: string, ctx?: InstanceContext) {
+    const instance = ctx ?? Instance
+    if (AppFileSystem.contains(instance.directory, filepath)) return true
+    // Non-git projects set worktree to "/" which would match ANY absolute path.
+    // Skip worktree check in this case to preserve external_directory permissions.
+    if (instance.worktree === "/") return false
+    return AppFileSystem.contains(instance.worktree, filepath)
+  },
+  /**
+   * Captures the current instance ALS context and returns a wrapper that
+   * restores it when called. Use this for callbacks that fire outside the
+   * instance async context (native addons, event emitters, timers, etc.).
+   */
+  bind<F extends (...args: any[]) => any>(fn: F): F {
+    const ctx = context.use()
+    return ((...args: any[]) => context.provide(ctx, () => fn(...args))) as F
+  },
+  /**
+   * Run a synchronous function within the given instance context ALS.
+   * Use this to bridge from Effect (where InstanceRef carries context)
+   * back to sync code that reads Instance.directory from ALS.
+   */
+  restore<R>(ctx: InstanceContext, fn: () => R): R {
+    return context.provide(ctx, fn)
+  },
+  async reload(input: { directory: string; init?: () => Promise<any>; project?: Project.Info; worktree?: string }) {
+    const directory = AppFileSystem.resolve(input.directory)
+    Log.Default.info("reloading instance", { directory })
+    await disposeInstance(directory)
+    cache.delete(directory)
+    const next = track(directory, boot({ ...input, directory }))
+
+    GlobalBus.emit("event", {
+      directory,
+      project: input.project?.id,
+      workspace: WorkspaceContext.workspaceID,
+      payload: {
+        type: "server.instance.disposed",
+        properties: {
+          directory,
+        },
+      },
+    })
+
+    return await next
+  },
+  async dispose() {
+    const directory = Instance.directory
+    const project = Instance.project
+    Log.Default.info("disposing instance", { directory })
+    await disposeInstance(directory)
+    cache.delete(directory)
+
+    GlobalBus.emit("event", {
+      directory,
+      project: project.id,
+      workspace: WorkspaceContext.workspaceID,
+      payload: {
+        type: "server.instance.disposed",
+        properties: {
+          directory,
+        },
+      },
+    })
+  },
+  async disposeAll() {
+    if (disposal.all) return disposal.all
+
+    disposal.all = iife(async () => {
+      Log.Default.info("disposing all instances")
+      const entries = [...cache.entries()]
+      for (const [key, value] of entries) {
+        if (cache.get(key) !== value) continue
+
+        const ctx = await value.catch((error) => {
+          Log.Default.warn("instance dispose failed", { key, error })
+          return undefined
+        })
+
+        if (!ctx) {
+          if (cache.get(key) === value) cache.delete(key)
+          continue
+        }
+
+        if (cache.get(key) !== value) continue
+
+        await context.provide(ctx, async () => {
+          await Instance.dispose()
+        })
+      }
+    }).finally(() => {
+      disposal.all = undefined
+    })
+
+    return disposal.all
+  },
+}