@sleepy-ai/cli 0.1.6 → 0.1.8

package/src/share/share-next.ts

@@ -1,381 +0,0 @@
-import type * as SDK from "@sleepy-ai/sdk/v2"
-import { Effect, Exit, Layer, Option, Schema, Scope, Context, Stream } from "effect"
-import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { Account } from "@/account/account"
-import { Bus } from "@/bus"
-import { InstanceState } from "@/effect"
-import { Provider } from "@/provider"
-import { ModelID, ProviderID } from "@/provider/schema"
-import { Session } from "@/session"
-import { MessageV2 } from "@/session/message-v2"
-import type { SessionID } from "@/session/schema"
-import { Database, eq } from "@/storage"
-import { Config } from "@/config"
-import { Log } from "@/util"
-import { SessionShareTable } from "./share.sql"
-
-const log = Log.create({ service: "share-next" })
-const disabled = process.env["SLEEPYCODE_DISABLE_SHARE"] === "true" || process.env["SLEEPYCODE_DISABLE_SHARE"] === "1"
-
-export type Api = {
-  create: string
-  sync: (shareID: string) => string
-  remove: (shareID: string) => string
-  data: (shareID: string) => string
-}
-
-export type Req = {
-  headers: Record<string, string>
-  api: Api
-  baseUrl: string
-}
-
-const ShareSchema = Schema.Struct({
-  id: Schema.String,
-  url: Schema.String,
-  secret: Schema.String,
-})
-export type Share = typeof ShareSchema.Type
-
-type State = {
-  queue: Map<SessionID, Map<string, Data>>
-  scope: Scope.Closeable
-  shared: Map<SessionID, Share | null>
-}
-
-type Data =
-  | {
-      type: "session"
-      data: SDK.Session
-    }
-  | {
-      type: "message"
-      data: SDK.Message
-    }
-  | {
-      type: "part"
-      data: SDK.Part
-    }
-  | {
-      type: "session_diff"
-      data: SDK.SnapshotFileDiff[]
-    }
-  | {
-      type: "model"
-      data: SDK.Model[]
-    }
-
-export interface Interface {
-  readonly init: () => Effect.Effect<void, unknown>
-  readonly url: () => Effect.Effect<string, unknown>
-  readonly request: () => Effect.Effect<Req, unknown>
-  readonly create: (sessionID: SessionID) => Effect.Effect<Share, unknown>
-  readonly remove: (sessionID: SessionID) => Effect.Effect<void, unknown>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ShareNext") {}
-
-const db = <T>(fn: (d: Parameters<typeof Database.use>[0] extends (trx: infer D) => any ? D : never) => T) =>
-  Effect.sync(() => Database.use(fn))
-
-function api(resource: string): Api {
-  return {
-    create: `/api/${resource}`,
-    sync: (shareID) => `/api/${resource}/${shareID}/sync`,
-    remove: (shareID) => `/api/${resource}/${shareID}`,
-    data: (shareID) => `/api/${resource}/${shareID}/data`,
-  }
-}
-
-const legacyApi = api("share")
-const consoleApi = api("shares")
-
-function key(item: Data) {
-  switch (item.type) {
-    case "session":
-      return "session"
-    case "message":
-      return `message/${item.data.id}`
-    case "part":
-      return `part/${item.data.messageID}/${item.data.id}`
-    case "session_diff":
-      return "session_diff"
-    case "model":
-      return "model"
-  }
-}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const account = yield* Account.Service
-    const bus = yield* Bus.Service
-    const cfg = yield* Config.Service
-    const http = yield* HttpClient.HttpClient
-    const httpOk = HttpClient.filterStatusOk(http)
-    const provider = yield* Provider.Service
-    const session = yield* Session.Service
-
-    function sync(sessionID: SessionID, data: Data[]): Effect.Effect<void> {
-      return Effect.gen(function* () {
-        if (disabled) return
-        const share = yield* getCached(sessionID)
-        if (!share) return
-
-        const s = yield* InstanceState.get(state)
-        const existing = s.queue.get(sessionID)
-        if (existing) {
-          for (const item of data) {
-            existing.set(key(item), item)
-          }
-          return
-        }
-
-        const next = new Map(data.map((item) => [key(item), item]))
-        s.queue.set(sessionID, next)
-        yield* flush(sessionID).pipe(
-          Effect.delay(1000),
-          Effect.catchCause((cause) =>
-            Effect.sync(() => {
-              log.error("share flush failed", { sessionID, cause })
-            }),
-          ),
-          Effect.forkIn(s.scope),
-        )
-      })
-    }
-
-    const state: InstanceState.InstanceState<State> = yield* InstanceState.make<State>(
-      Effect.fn("ShareNext.state")(function* (_ctx) {
-        const cache: State = { queue: new Map(), scope: yield* Scope.make(), shared: new Map() }
-
-        yield* Effect.addFinalizer(() =>
-          Scope.close(cache.scope, Exit.void).pipe(
-            Effect.andThen(
-              Effect.sync(() => {
-                cache.queue.clear()
-                cache.shared.clear()
-              }),
-            ),
-          ),
-        )
-
-        if (disabled) return cache
-
-        const watch = <D extends { type: string }>(
-          def: D,
-          fn: (evt: { properties: any }) => Effect.Effect<void, unknown>,
-        ) =>
-          bus.subscribe(def as never).pipe(
-            Stream.runForEach((evt) =>
-              fn(evt).pipe(
-                Effect.catchCause((cause) =>
-                  Effect.sync(() => {
-                    log.error("share subscriber failed", { type: def.type, cause })
-                  }),
-                ),
-              ),
-            ),
-            Effect.forkScoped,
-          )
-
-        yield* watch(Session.Event.Updated, (evt) =>
-          Effect.gen(function* () {
-            const info = yield* session.get(evt.properties.sessionID)
-            yield* sync(info.id, [{ type: "session", data: info }])
-          }),
-        )
-        yield* watch(MessageV2.Event.Updated, (evt) =>
-          Effect.gen(function* () {
-            const info = evt.properties.info
-            yield* sync(info.sessionID, [{ type: "message", data: info }])
-            if (info.role !== "user") return
-            const model = yield* provider.getModel(info.model.providerID, info.model.modelID)
-            yield* sync(info.sessionID, [{ type: "model", data: [model] }])
-          }),
-        )
-        yield* watch(MessageV2.Event.PartUpdated, (evt) =>
-          evt.properties.part.type === "compaction"
-            ? Effect.void
-            : sync(evt.properties.part.sessionID, [
-                { type: "part", data: evt.properties.part as SDK.Part },
-              ]),
-        )
-        yield* watch(Session.Event.Diff, (evt) =>
-          sync(evt.properties.sessionID, [{ type: "session_diff", data: evt.properties.diff }]),
-        )
-        yield* watch(Session.Event.Deleted, (evt) => remove(evt.properties.sessionID))
-
-        return cache
-      }),
-    )
-
-    const request = Effect.fn("ShareNext.request")(function* () {
-      const headers: Record<string, string> = {}
-      const active = yield* account.active()
-      if (Option.isNone(active) || !active.value.active_org_id) {
-        const baseUrl = (yield* cfg.get()).enterprise?.url ?? "https://opncd.ai"
-        return { headers, api: legacyApi, baseUrl } satisfies Req
-      }
-
-      const token = yield* account.token(active.value.id)
-      if (Option.isNone(token)) {
-        throw new Error("No active account token available for sharing")
-      }
-
-      headers.authorization = `Bearer ${token.value}`
-      headers["x-org-id"] = active.value.active_org_id
-      return { headers, api: consoleApi, baseUrl: active.value.url } satisfies Req
-    })
-
-    const get = Effect.fnUntraced(function* (sessionID: SessionID) {
-      const row = yield* db((db) =>
-        db.select().from(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).get(),
-      )
-      if (!row) return
-      return { id: row.id, secret: row.secret, url: row.url } satisfies Share
-    })
-
-    const getCached = Effect.fnUntraced(function* (sessionID: SessionID) {
-      const s = yield* InstanceState.get(state)
-      if (s.shared.has(sessionID)) {
-        const cached = s.shared.get(sessionID)
-        return cached === null ? undefined : cached
-      }
-
-      const share = yield* get(sessionID)
-      s.shared.set(sessionID, share ?? null)
-      return share
-    })
-
-    const flush = Effect.fn("ShareNext.flush")(function* (sessionID: SessionID) {
-      if (disabled) return
-      const s = yield* InstanceState.get(state)
-      const queued = s.queue.get(sessionID)
-      if (!queued) return
-
-      s.queue.delete(sessionID)
-
-      const share = yield* getCached(sessionID)
-      if (!share) return
-
-      const req = yield* request()
-      const res = yield* HttpClientRequest.post(`${req.baseUrl}${req.api.sync(share.id)}`).pipe(
-        HttpClientRequest.setHeaders(req.headers),
-        HttpClientRequest.bodyJson({ secret: share.secret, data: Array.from(queued.values()) }),
-        Effect.flatMap((r) => http.execute(r)),
-      )
-
-      if (res.status >= 400) {
-        log.warn("failed to sync share", { sessionID, shareID: share.id, status: res.status })
-      }
-    })
-
-    const full = Effect.fn("ShareNext.full")(function* (sessionID: SessionID) {
-      log.info("full sync", { sessionID })
-      const info = yield* session.get(sessionID)
-      const diffs = yield* session.diff(sessionID)
-      const messages = yield* Effect.sync(() => Array.from(MessageV2.stream(sessionID, { agentID: "*" })))
-      const models = yield* Effect.forEach(
-        Array.from(
-          new Map(
-            messages
-              .filter((msg) => msg.info.role === "user")
-              .map((msg) => (msg.info as SDK.UserMessage).model)
-              .map((item) => [`${item.providerID}/${item.modelID}`, item] as const),
-          ).values(),
-        ),
-        (item) => provider.getModel(ProviderID.make(item.providerID), ModelID.make(item.modelID)),
-        { concurrency: 8 },
-      )
-
-      yield* sync(sessionID, [
-        { type: "session", data: info },
-        ...messages.map((item) => ({ type: "message" as const, data: item.info as SDK.Message })),
-        ...messages.flatMap((item) =>
-          item.parts
-            .filter((part) => part.type !== "compaction")
-            .map((part) => ({ type: "part" as const, data: part as SDK.Part })),
-        ),
-        { type: "session_diff", data: diffs as SDK.SnapshotFileDiff[] },
-        { type: "model", data: models as SDK.Model[] },
-      ])
-    })
-
-    const init = Effect.fn("ShareNext.init")(function* () {
-      if (disabled) return
-      yield* InstanceState.get(state)
-    })
-
-    const url = Effect.fn("ShareNext.url")(function* () {
-      return (yield* request()).baseUrl
-    })
-
-    const create = Effect.fn("ShareNext.create")(function* (sessionID: SessionID) {
-      if (disabled) return { id: "", url: "", secret: "" }
-      log.info("creating share", { sessionID })
-      const req = yield* request()
-      const result = yield* HttpClientRequest.post(`${req.baseUrl}${req.api.create}`).pipe(
-        HttpClientRequest.setHeaders(req.headers),
-        HttpClientRequest.bodyJson({ sessionID }),
-        Effect.flatMap((r) => httpOk.execute(r)),
-        Effect.flatMap(HttpClientResponse.schemaBodyJson(ShareSchema)),
-      )
-      yield* db((db) =>
-        db
-          .insert(SessionShareTable)
-          .values({ session_id: sessionID, id: result.id, secret: result.secret, url: result.url })
-          .onConflictDoUpdate({
-            target: SessionShareTable.session_id,
-            set: { id: result.id, secret: result.secret, url: result.url },
-          })
-          .run(),
-      )
-      const s = yield* InstanceState.get(state)
-      s.shared.set(sessionID, result)
-      yield* full(sessionID).pipe(
-        Effect.catchCause((cause) =>
-          Effect.sync(() => {
-            log.error("share full sync failed", { sessionID, cause })
-          }),
-        ),
-        Effect.forkIn(s.scope),
-      )
-      return result
-    })
-
-    const remove = Effect.fn("ShareNext.remove")(function* (sessionID: SessionID) {
-      if (disabled) return
-      log.info("removing share", { sessionID })
-      const s = yield* InstanceState.get(state)
-      const share = yield* getCached(sessionID)
-      if (!share) {
-        s.shared.delete(sessionID)
-        s.queue.delete(sessionID)
-        return
-      }
-
-      const req = yield* request()
-      yield* HttpClientRequest.delete(`${req.baseUrl}${req.api.remove(share.id)}`).pipe(
-        HttpClientRequest.setHeaders(req.headers),
-        HttpClientRequest.bodyJson({ secret: share.secret }),
-        Effect.flatMap((r) => httpOk.execute(r)),
-      )
-
-      yield* db((db) => db.delete(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).run())
-      s.shared.delete(sessionID)
-      s.queue.delete(sessionID)
-    })
-
-    return Service.of({ init, url, request, create, remove })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(Bus.layer),
-  Layer.provide(Account.defaultLayer),
-  Layer.provide(Config.defaultLayer),
-  Layer.provide(FetchHttpClient.layer),
-  Layer.provide(Provider.defaultLayer),
-  Layer.provide(Session.defaultLayer),
-)

package/src/share/share.sql.ts

@@ -1,13 +0,0 @@
-import { sqliteTable, text } from "drizzle-orm/sqlite-core"
-import { SessionTable } from "../session/session.sql"
-import { Timestamps } from "../storage/schema.sql"
-
-export const SessionShareTable = sqliteTable("session_share", {
-  session_id: text()
-    .primaryKey()
-    .references(() => SessionTable.id, { onDelete: "cascade" }),
-  id: text().notNull(),
-  secret: text().notNull(),
-  url: text().notNull(),
-  ...Timestamps,
-})

package/src/shell/shell.ts

@@ -1,124 +0,0 @@
-import { Flag } from "@/flag/flag"
-import { lazy } from "@/util/lazy"
-import { Filesystem } from "@/util"
-import { which } from "@/util/which"
-import path from "path"
-import { spawn, type ChildProcess } from "child_process"
-import { setTimeout as sleep } from "node:timers/promises"
-
-const SIGKILL_TIMEOUT_MS = 200
-
-const BLACKLIST = new Set(["fish", "nu"])
-const LOGIN = new Set(["bash", "dash", "fish", "ksh", "sh", "zsh"])
-const POSIX = new Set(["bash", "dash", "ksh", "sh", "zsh"])
-
-export async function killTree(proc: ChildProcess, opts?: { exited?: () => boolean }): Promise<void> {
-  const pid = proc.pid
-  if (!pid || opts?.exited?.()) return
-
-  if (process.platform === "win32") {
-    await new Promise<void>((resolve) => {
-      const killer = spawn("taskkill", ["/pid", String(pid), "/f", "/t"], {
-        stdio: "ignore",
-        windowsHide: true,
-      })
-      killer.once("exit", () => resolve())
-      killer.once("error", () => resolve())
-    })
-    return
-  }
-
-  try {
-    process.kill(-pid, "SIGTERM")
-    await sleep(SIGKILL_TIMEOUT_MS)
-    if (!opts?.exited?.()) {
-      process.kill(-pid, "SIGKILL")
-    }
-  } catch (_e) {
-    proc.kill("SIGTERM")
-    await sleep(SIGKILL_TIMEOUT_MS)
-    if (!opts?.exited?.()) {
-      proc.kill("SIGKILL")
-    }
-  }
-}
-
-function full(file: string) {
-  if (process.platform !== "win32") return file
-  const shell = Filesystem.windowsPath(file)
-  if (path.win32.dirname(shell) !== ".") {
-    if (shell.startsWith("/") && name(shell) === "bash") return gitbash() || shell
-    return shell
-  }
-  return which(shell) || shell
-}
-
-function pick() {
-  const pwsh = which("pwsh.exe")
-  if (pwsh) return pwsh
-  const powershell = which("powershell.exe")
-  if (powershell) return powershell
-}
-
-function select(file: string | undefined, opts?: { acceptable?: boolean }) {
-  if (file && (!opts?.acceptable || !BLACKLIST.has(name(file)))) return full(file)
-  if (process.platform === "win32") {
-    const shell = pick()
-    if (shell) return shell
-  }
-  return fallback()
-}
-
-export function gitbash() {
-  if (process.platform !== "win32") return
-  if (Flag.SLEEPYCODE_GIT_BASH_PATH) return Flag.SLEEPYCODE_GIT_BASH_PATH
-  const git = which("git")
-  if (!git) return
-  const file = path.join(git, "..", "..", "bin", "bash.exe")
-  if (Filesystem.stat(file)?.size) return file
-}
-
-function fallback() {
-  if (process.platform === "win32") {
-    const file = gitbash()
-    if (file) return file
-    return process.env.COMSPEC || "cmd.exe"
-  }
-  if (process.platform === "darwin") return "/bin/zsh"
-  const bash = which("bash")
-  if (bash) return bash
-  return "/bin/sh"
-}
-
-export function name(file: string) {
-  if (process.platform === "win32") return path.win32.parse(Filesystem.windowsPath(file)).name.toLowerCase()
-  return path.basename(file).toLowerCase()
-}
-
-export function login(file: string) {
-  return LOGIN.has(name(file))
-}
-
-export function posix(file: string) {
-  return POSIX.has(name(file))
-}
-
-export const preferred = lazy(() => select(process.env.SHELL))
-
-export const acceptable = lazy(() => select(process.env.SHELL, { acceptable: true }))
-
-// On non-UTF-8 Windows locales (e.g. zh-CN ACP 936/GBK) shell subprocesses emit
-// output in the legacy code page, which we decode as UTF-8 → mojibake. These
-// prefixes force UTF-8 output before the user command runs.
-
-// PowerShell/pwsh: set both the output pipe encoding and the console encoding.
-// UTF8Encoding($false) is BOM-less to avoid leading garbage bytes.
-export const POWERSHELL_UTF8_PREFIX =
-  "$OutputEncoding = [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false);"
-
-// cmd.exe: switch the code page to 65001. `&` (not `&&`) so the user command's
-// exit code is preserved and a chcp failure doesn't block it; redirect both
-// stdout and stderr so chcp output never pollutes the result.
-export const CMD_UTF8_PREFIX = "chcp 65001 >nul 2>nul & "
-
-export * as Shell from "./shell"

package/src/skill/builtin/.bundle/self-extend/SKILL.md

@@ -1,131 +0,0 @@
----
-name: self-extend
-description: Use when you want to evolve your own capabilities — create new tools to avoid repeating patterns, add hooks to improve your own behavior, build skills to accumulate domain knowledge, or override built-in tools to adapt to project needs. This is your self-iteration interface.
----
-
-# Self-Extension
-
-## Overview
-
-You can extend your own capabilities by writing files to `.mimocode/`. Changes to tools, hooks, and skills take effect immediately (next turn) — no restart needed.
-
-## Creating Tools
-
-Write to `.mimocode/tools/<name>.ts`:
-
-```ts
-import { tool } from "@sleepy-ai/plugin"
-
-export default tool({
-  description: "What this tool does",
-  args: {
-    param1: tool.schema.string().describe("Parameter description"),
-  },
-  async execute(args, ctx) {
-    // ctx.directory — project root
-    // ctx.worktree — git worktree root
-    // ctx.abort — AbortSignal
-    return `Result: ${args.param1}`
-  },
-})
-```
-
-Multiple tools per file: use named exports instead of default.
-
-## Creating Hooks
-
-Write to `.mimocode/hooks/<name>.ts` — export a Hooks object:
-
-```ts
-export default {
-  "tool.execute.before": async (input, output) => {
-    if (input.tool === "bash" && output.args.command?.includes("rm -rf /")) {
-      output.cancel = true
-      output.cancelReason = "Blocked dangerous command"
-    }
-  },
-  "experimental.chat.system.transform": async (input, output) => {
-    output.system.push("Additional instruction here.")
-  },
-}
-```
-
-### Hook Events
-
-| Event | Capability |
-|-------|-----------|
-| `tool.execute.before` | Modify args or `cancel=true` to block |
-| `tool.execute.after` | Modify tool output |
-| `tool.definition` | Modify tool description/parameters |
-| `chat.params` | Modify temperature, topP, maxOutputTokens |
-| `experimental.chat.system.transform` | Append to system prompt |
-| `experimental.chat.messages.transform` | Modify message list sent to LLM |
-| `permission.ask` | Auto-allow/deny permission requests |
-| `shell.env` | Inject environment variables |
-
-## Tool Override
-
-A custom tool with the same id as a built-in replaces it:
-
-```ts
-// .mimocode/tools/bash.ts — overrides built-in bash
-import { tool } from "@sleepy-ai/plugin"
-import { execSync } from "child_process"
-
-export default tool({
-  description: "Shell with safety checks",
-  args: { command: tool.schema.string() },
-  async execute(args, ctx) {
-    if (args.command.includes("sudo")) return "Error: sudo not allowed"
-    return execSync(args.command, { encoding: "utf-8", cwd: ctx.directory })
-  },
-})
-```
-
-## Creating Skills
-
-Write to `.mimocode/skills/<name>/SKILL.md`:
-
-```markdown
----
-name: my-skill
-description: Use when [conditions]
----
-Instructions here...
-```
-
-## File Locations
-
-| Type | Path | Hot-reload |
-|------|------|-----------|
-| Tools | `.mimocode/tools/*.ts` | next turn |
-| Hooks | `.mimocode/hooks/*.ts` | next turn |
-| Skills | `.mimocode/skills/*/SKILL.md` | next turn |
-| TUI | `.mimocode/tui/*.tsx` | restart |
-
-## When to Use What
-
-| I want to... | Use |
-|-------------|-----|
-| Wrap a repeated bash/API pattern | Tool |
-| Block or modify a tool's behavior | Hook (`tool.execute.before`) |
-| Inject context into system prompt | Hook (`chat.system.transform`) |
-| Accumulate domain knowledge for future use | Skill |
-| Override how a built-in tool works | Tool (same name as builtin) |
-| Add a custom UI panel or command | TUI plugin |
-
-## Detailed API Reference
-
-For full type signatures, all available fields, and more examples:
-
-- See @reference/tool-api.md for Tool schema and ToolContext
-- See @reference/hook-api.md for all hook events with input/output types
-- See @reference/skill-api.md for SKILL.md format and frontmatter fields
-- See @reference/tui-api.md for TUI plugin slots, commands, dialogs, and state
-
-## Constraints
-
-- Tools/hooks have same permissions as bash — no privilege escalation
-- Cannot modify the permission system
-- Tool output truncated at 50KB / 2000 lines
-- Prefer small, composable extensions over monolithic ones