@sleepy-ai/cli 0.1.6 → 0.1.8

package/src/plugin/sleepy.ts

@@ -1,244 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

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

package/src/project/instance.ts

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