jonsoc 1.1.43

package/src/share/share-next.ts

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

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

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

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

package/src/skill/skill.ts

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