jonsoc 1.1.49 → 1.1.50

package/src/share/share-next.ts

@@ -1,204 +0,0 @@
-import { Bus } from "@/bus"
-import { Config } from "@/config/config"
-import { ulid } from "ulid"
-import { Provider } from "@/provider/provider"
-import { Session } from "@/session"
-import { MessageV2 } from "@/session/message-v2"
-import { Storage } from "@/storage/storage"
-import { Log } from "@/util/log"
-import type * as SDK from "@jonsoc/sdk/v2"
-
-export namespace ShareNext {
-  const log = Log.create({ service: "share-next" })
-
-  async function url() {
-    return Config.get().then((x) => x.enterprise?.url ?? "https://joc.ai")
-  }
-
-  const disabled =
-    process.env["JONSOC_DISABLE_SHARE"] === "true" ||
-    process.env["JONSOC_DISABLE_SHARE"] === "1" ||
-    process.env["OPENCODE_DISABLE_SHARE"] === "true" ||
-    process.env["OPENCODE_DISABLE_SHARE"] === "1"
-
-  export async function init() {
-    if (disabled) return
-    Bus.subscribe(Session.Event.Updated, async (evt) => {
-      await sync(evt.properties.info.id, [
-        {
-          type: "session",
-          data: evt.properties.info,
-        },
-      ])
-    })
-    Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
-      await sync(evt.properties.info.sessionID, [
-        {
-          type: "message",
-          data: evt.properties.info,
-        },
-      ])
-      if (evt.properties.info.role === "user") {
-        await sync(evt.properties.info.sessionID, [
-          {
-            type: "model",
-            data: [
-              await Provider.getModel(evt.properties.info.model.providerID, evt.properties.info.model.modelID).then(
-                (m) => m,
-              ),
-            ],
-          },
-        ])
-      }
-    })
-    Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
-      await sync(evt.properties.part.sessionID, [
-        {
-          type: "part",
-          data: evt.properties.part,
-        },
-      ])
-    })
-    Bus.subscribe(Session.Event.Diff, async (evt) => {
-      await sync(evt.properties.sessionID, [
-        {
-          type: "session_diff",
-          data: evt.properties.diff,
-        },
-      ])
-    })
-  }
-
-  export async function create(sessionID: string) {
-    if (disabled) return { id: "", url: "", secret: "" }
-    log.info("creating share", { sessionID })
-    const result = await fetch(`${await url()}/api/share`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ sessionID: sessionID }),
-    })
-      .then((x) => x.json())
-      .then((x) => x as { id: string; url: string; secret: string })
-    await Storage.write(["session_share", sessionID], result)
-    fullSync(sessionID)
-    return result
-  }
-
-  function get(sessionID: string) {
-    return Storage.read<{
-      id: string
-      secret: string
-      url: string
-    }>(["session_share", sessionID])
-  }
-
-  type Data =
-    | {
-        type: "session"
-        data: SDK.Session
-      }
-    | {
-        type: "message"
-        data: SDK.Message
-      }
-    | {
-        type: "part"
-        data: SDK.Part
-      }
-    | {
-        type: "session_diff"
-        data: SDK.FileDiff[]
-      }
-    | {
-        type: "model"
-        data: SDK.Model[]
-      }
-
-  const queue = new Map<string, { timeout: NodeJS.Timeout; data: Map<string, Data> }>()
-  async function sync(sessionID: string, data: Data[]) {
-    if (disabled) return
-    const existing = queue.get(sessionID)
-    if (existing) {
-      for (const item of data) {
-        existing.data.set("id" in item ? (item.id as string) : ulid(), item)
-      }
-      return
-    }
-
-    const dataMap = new Map<string, Data>()
-    for (const item of data) {
-      dataMap.set("id" in item ? (item.id as string) : ulid(), item)
-    }
-
-    const timeout = setTimeout(async () => {
-      const queued = queue.get(sessionID)
-      if (!queued) return
-      queue.delete(sessionID)
-      const share = await get(sessionID).catch(() => undefined)
-      if (!share) return
-
-      await fetch(`${await url()}/api/share/${share.id}/sync`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          secret: share.secret,
-          data: Array.from(queued.data.values()),
-        }),
-      })
-    }, 1000)
-    queue.set(sessionID, { timeout, data: dataMap })
-  }
-
-  export async function remove(sessionID: string) {
-    if (disabled) return
-    log.info("removing share", { sessionID })
-    const share = await get(sessionID)
-    if (!share) return
-    await fetch(`${await url()}/api/share/${share.id}`, {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        secret: share.secret,
-      }),
-    })
-    await Storage.remove(["session_share", sessionID])
-  }
-
-  async function fullSync(sessionID: string) {
-    log.info("full sync", { sessionID })
-    const session = await Session.get(sessionID)
-    const diffs = await Session.diff(sessionID)
-    const messages = await Array.fromAsync(MessageV2.stream(sessionID))
-    const models = await Promise.all(
-      messages
-        .filter((m) => m.info.role === "user")
-        .map((m) => (m.info as SDK.UserMessage).model)
-        .map((m) => Provider.getModel(m.providerID, m.modelID).then((m) => m)),
-    )
-    await sync(sessionID, [
-      {
-        type: "session",
-        data: session,
-      },
-      ...messages.map((x) => ({
-        type: "message" as const,
-        data: x.info,
-      })),
-      ...messages.flatMap((x) => x.parts.map((y) => ({ type: "part" as const, data: y }))),
-      {
-        type: "session_diff",
-        data: diffs,
-      },
-      {
-        type: "model",
-        data: models,
-      },
-    ])
-  }
-}

package/src/share/share.ts

@@ -1,95 +0,0 @@
-import { Bus } from "../bus"
-import { Installation } from "../installation"
-import { Session } from "../session"
-import { MessageV2 } from "../session/message-v2"
-import { Log } from "../util/log"
-import { Brand } from "../brand"
-
-export namespace Share {
-  const log = Log.create({ service: "share" })
-
-  let queue: Promise<void> = Promise.resolve()
-  const pending = new Map<string, any>()
-
-  export async function sync(key: string, content: any) {
-    if (disabled) return
-    const [root, ...splits] = key.split("/")
-    if (root !== "session") return
-    const [sub, sessionID] = splits
-    if (sub === "share") return
-    const share = await Session.getShare(sessionID).catch(() => {})
-    if (!share) return
-    const { secret } = share
-    pending.set(key, content)
-    queue = queue
-      .then(async () => {
-        const content = pending.get(key)
-        if (content === undefined) return
-        pending.delete(key)
-
-        return fetch(`${URL}/share_sync`, {
-          method: "POST",
-          body: JSON.stringify({
-            sessionID: sessionID,
-            secret,
-            key: key,
-            content,
-          }),
-        })
-      })
-      .then((x) => {
-        if (x) {
-          log.info("synced", {
-            key: key,
-            status: x.status,
-          })
-        }
-      })
-  }
-
-  export function init() {
-    Bus.subscribe(Session.Event.Updated, async (evt) => {
-      await sync("session/info/" + evt.properties.info.id, evt.properties.info)
-    })
-    Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
-      await sync("session/message/" + evt.properties.info.sessionID + "/" + evt.properties.info.id, evt.properties.info)
-    })
-    Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
-      await sync(
-        "session/part/" +
-          evt.properties.part.sessionID +
-          "/" +
-          evt.properties.part.messageID +
-          "/" +
-          evt.properties.part.id,
-        evt.properties.part,
-      )
-    })
-  }
-
-  export const URL = process.env["JONSOC_API"] ?? process.env["OPENCODE_API"] ?? Brand.API_URL
-
-  const disabled =
-    process.env["JONSOC_DISABLE_SHARE"] === "true" ||
-    process.env["JONSOC_DISABLE_SHARE"] === "1" ||
-    process.env["OPENCODE_DISABLE_SHARE"] === "true" ||
-    process.env["OPENCODE_DISABLE_SHARE"] === "1"
-
-  export async function create(sessionID: string) {
-    if (disabled) return { url: "", secret: "" }
-    return fetch(`${URL}/share_create`, {
-      method: "POST",
-      body: JSON.stringify({ sessionID: sessionID }),
-    })
-      .then((x) => x.json())
-      .then((x) => x as { url: string; secret: string })
-  }
-
-  export async function remove(sessionID: string, secret: string) {
-    if (disabled) return {}
-    return fetch(`${URL}/share_delete`, {
-      method: "POST",
-      body: JSON.stringify({ sessionID, secret }),
-    }).then((x) => x.json())
-  }
-}

package/src/shell/shell.ts

@@ -1,67 +0,0 @@
-import { Flag } from "@/flag/flag"
-import { lazy } from "@/util/lazy"
-import path from "path"
-import { spawn, type ChildProcess } from "child_process"
-
-const SIGKILL_TIMEOUT_MS = 200
-
-export namespace Shell {
-  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" })
-        killer.once("exit", () => resolve())
-        killer.once("error", () => resolve())
-      })
-      return
-    }
-
-    try {
-      process.kill(-pid, "SIGTERM")
-      await Bun.sleep(SIGKILL_TIMEOUT_MS)
-      if (!opts?.exited?.()) {
-        process.kill(-pid, "SIGKILL")
-      }
-    } catch (_e) {
-      proc.kill("SIGTERM")
-      await Bun.sleep(SIGKILL_TIMEOUT_MS)
-      if (!opts?.exited?.()) {
-        proc.kill("SIGKILL")
-      }
-    }
-  }
-  const BLACKLIST = new Set(["fish", "nu"])
-
-  function fallback() {
-    if (process.platform === "win32") {
-      if (Flag.OPENCODE_GIT_BASH_PATH) return Flag.OPENCODE_GIT_BASH_PATH
-      const git = Bun.which("git")
-      if (git) {
-        // git.exe is typically at: C:\Program Files\Git\cmd\git.exe
-        // bash.exe is at: C:\Program Files\Git\bin\bash.exe
-        const bash = path.join(git, "..", "..", "bin", "bash.exe")
-        if (Bun.file(bash).size) return bash
-      }
-      return process.env.COMSPEC || "cmd.exe"
-    }
-    if (process.platform === "darwin") return "/bin/zsh"
-    const bash = Bun.which("bash")
-    if (bash) return bash
-    return "/bin/sh"
-  }
-
-  export const preferred = lazy(() => {
-    const s = process.env.SHELL
-    if (s) return s
-    return fallback()
-  })
-
-  export const acceptable = lazy(() => {
-    const s = process.env.SHELL
-    if (s && !BLACKLIST.has(process.platform === "win32" ? path.win32.basename(s) : path.basename(s))) return s
-    return fallback()
-  })
-}

package/src/skill/index.ts

@@ -1 +0,0 @@
-export * from "./skill"

package/src/skill/skill.ts

@@ -1,135 +0,0 @@
-import z from "zod"
-import path from "path"
-import { Config } from "../config/config"
-import { Instance } from "../project/instance"
-import { NamedError } from "@jonsoc/util/error"
-import { ConfigMarkdown } from "../config/markdown"
-import { Log } from "../util/log"
-import { Global } from "@/global"
-import { Filesystem } from "@/util/filesystem"
-import { Flag } from "@/flag/flag"
-import { Bus } from "@/bus"
-import { Session } from "@/session"
-
-export namespace Skill {
-  const log = Log.create({ service: "skill" })
-  export const Info = z.object({
-    name: z.string(),
-    description: z.string(),
-    location: z.string(),
-  })
-  export type Info = z.infer<typeof Info>
-
-  export const InvalidError = NamedError.create(
-    "SkillInvalidError",
-    z.object({
-      path: z.string(),
-      message: z.string().optional(),
-      issues: z.custom<z.core.$ZodIssue[]>().optional(),
-    }),
-  )
-
-  export const NameMismatchError = NamedError.create(
-    "SkillNameMismatchError",
-    z.object({
-      path: z.string(),
-      expected: z.string(),
-      actual: z.string(),
-    }),
-  )
-
-  const JONSOC_SKILL_GLOB = new Bun.Glob("{skill,skills}/**/SKILL.md")
-  const CLAUDE_SKILL_GLOB = new Bun.Glob("skills/**/SKILL.md")
-
-  export const state = Instance.state(async () => {
-    const skills: Record<string, Info> = {}
-
-    const addSkill = async (match: string) => {
-      const md = await ConfigMarkdown.parse(match).catch((err) => {
-        const message = ConfigMarkdown.FrontmatterError.isInstance(err)
-          ? err.data.message
-          : `Failed to parse skill ${match}`
-        Bus.publish(Session.Event.Error, { error: new NamedError.Unknown({ message }).toObject() })
-        log.error("failed to load skill", { skill: match, err })
-        return undefined
-      })
-
-      if (!md) return
-
-      const parsed = Info.pick({ name: true, description: true }).safeParse(md.data)
-      if (!parsed.success) return
-
-      // Warn on duplicate skill names
-      if (skills[parsed.data.name]) {
-        log.warn("duplicate skill name", {
-          name: parsed.data.name,
-          existing: skills[parsed.data.name].location,
-          duplicate: match,
-        })
-      }
-
-      skills[parsed.data.name] = {
-        name: parsed.data.name,
-        description: parsed.data.description,
-        location: match,
-      }
-    }
-
-    // Scan .claude/skills/ directories (project-level)
-    const claudeDirs = await Array.fromAsync(
-      Filesystem.up({
-        targets: [".claude"],
-        start: Instance.directory,
-        stop: Instance.worktree,
-      }),
-    )
-    // Also include global ~/.claude/skills/
-    const globalClaude = `${Global.Path.home}/.claude`
-    if (await Filesystem.isDir(globalClaude)) {
-      claudeDirs.push(globalClaude)
-    }
-
-    if (!Flag.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS) {
-      for (const dir of claudeDirs) {
-        const matches = await Array.fromAsync(
-          CLAUDE_SKILL_GLOB.scan({
-            cwd: dir,
-            absolute: true,
-            onlyFiles: true,
-            followSymlinks: true,
-            dot: true,
-          }),
-        ).catch((error) => {
-          log.error("failed .claude directory scan for skills", { dir, error })
-          return []
-        })
-
-        for (const match of matches) {
-          await addSkill(match)
-        }
-      }
-    }
-
-    // Scan .jonsoc/skill/ directories
-    for (const dir of await Config.directories()) {
-      for await (const match of JONSOC_SKILL_GLOB.scan({
-        cwd: dir,
-        absolute: true,
-        onlyFiles: true,
-        followSymlinks: true,
-      })) {
-        await addSkill(match)
-      }
-    }
-
-    return skills
-  })
-
-  export async function get(name: string) {
-    return state().then((x) => x[name])
-  }
-
-  export async function all() {
-    return state().then((x) => Object.values(x))
-  }
-}