easc-cli 1.1.28

package/src/auth/eliseart.ts

@@ -0,0 +1,76 @@
+import { Auth } from "./index"
+
+export const ELISEART_SUPABASE_URL = "https://ageywitwxbvartiphlrl.supabase.co";
+export const ELISEART_SUPABASE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFnZXl3aXR3eGJ2YXJ0aXBobHJsIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTIxNTQ2MjEsImV4cCI6MjA2NzczMDYyMX0.GWqBU9Ywj-td67BDf6TgxN4ZDPLuQb8-jx3qV7n-rkY";
+
+export namespace EliseArtAuth {
+    export async function login(email: string, password: string) {
+        const response = await fetch(`${ELISEART_SUPABASE_URL}/auth/v1/token?grant_type=password`, {
+            method: "POST",
+            headers: {
+                "apikey": ELISEART_SUPABASE_KEY,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ email, password }),
+        });
+
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.error_description || error.msg || "Login failed");
+        }
+
+        const data = await response.json();
+
+        // Save to opencode auth system
+        await Auth.set("eliseart", {
+            type: "oauth",
+            access: data.access_token,
+            refresh: data.refresh_token,
+            expires: Date.now() + (data.expires_in * 1000),
+            accountId: data.user.id
+        });
+
+        return data;
+    }
+
+    export async function loginWithToken(accessToken: string, refreshToken: string = "") {
+        // Validate token by fetching user
+        const response = await fetch(`${ELISEART_SUPABASE_URL}/auth/v1/user`, {
+            method: "GET",
+            headers: {
+                "apikey": ELISEART_SUPABASE_KEY,
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        });
+
+        if (!response.ok) {
+            throw new Error("Invalid access token");
+        }
+
+        const user = await response.json();
+
+        // Save to opencode auth system
+        await Auth.set("eliseart", {
+            type: "oauth",
+            access: accessToken,
+            refresh: refreshToken, // Might be empty, meaning no refresh capability
+            accountId: user.id,
+            expires: Date.now() + (3600 * 1000), // Assume 1 hour validity if unknown
+        });
+
+        return { user, access_token: accessToken, refresh_token: refreshToken };
+    }
+
+    export async function getSession() {
+        return await Auth.get("eliseart");
+    }
+
+    export async function getAuthHeaders(): Promise<Record<string, string>> {
+        const session = await getSession();
+        const headers: Record<string, string> = { "apikey": ELISEART_SUPABASE_KEY };
+        if (session?.type === "oauth") {
+            headers["Authorization"] = `Bearer ${session.access}`;
+        }
+        return headers;
+    }
+}

package/src/auth/index.ts

@@ -0,0 +1,73 @@
+import path from "path"
+import { Global } from "../global"
+import fs from "fs/promises"
+import z from "zod"
+
+export const OAUTH_DUMMY_KEY = "opencode-oauth-dummy-key"
+
+export namespace Auth {
+  export const Oauth = z
+    .object({
+      type: z.literal("oauth"),
+      refresh: z.string(),
+      access: z.string(),
+      expires: z.number(),
+      accountId: z.string().optional(),
+      enterpriseUrl: z.string().optional(),
+    })
+    .meta({ ref: "OAuth" })
+
+  export const Api = z
+    .object({
+      type: z.literal("api"),
+      key: z.string(),
+    })
+    .meta({ ref: "ApiAuth" })
+
+  export const WellKnown = z
+    .object({
+      type: z.literal("wellknown"),
+      key: z.string(),
+      token: z.string(),
+    })
+    .meta({ ref: "WellKnownAuth" })
+
+  export const Info = z.discriminatedUnion("type", [Oauth, Api, WellKnown]).meta({ ref: "Auth" })
+  export type Info = z.infer<typeof Info>
+
+  const filepath = path.join(Global.Path.data, "auth.json")
+
+  export async function get(providerID: string) {
+    const auth = await all()
+    return auth[providerID]
+  }
+
+  export async function all(): Promise<Record<string, Info>> {
+    const file = Bun.file(filepath)
+    const data = await file.json().catch(() => ({}) as Record<string, unknown>)
+    return Object.entries(data).reduce(
+      (acc, [key, value]) => {
+        const parsed = Info.safeParse(value)
+        if (!parsed.success) return acc
+        acc[key] = parsed.data
+        return acc
+      },
+      {} as Record<string, Info>,
+    )
+  }
+
+  export async function set(key: string, info: Info) {
+    const file = Bun.file(filepath)
+    const data = await all()
+    await Bun.write(file, JSON.stringify({ ...data, [key]: info }, null, 2))
+    await fs.chmod(file.name!, 0o600)
+  }
+
+  export async function remove(key: string) {
+    const file = Bun.file(filepath)
+    const data = await all()
+    delete data[key]
+    await Bun.write(file, JSON.stringify(data, null, 2))
+    await fs.chmod(file.name!, 0o600)
+  }
+}

package/src/bun/index.ts

@@ -0,0 +1,134 @@
+import z from "zod"
+import { Global } from "../global"
+import { Log } from "../util/log"
+import path from "path"
+import { Filesystem } from "../util/filesystem"
+import { NamedError } from "@eliseart.ai/util/error"
+import { readableStreamToText } from "bun"
+import { createRequire } from "module"
+import { Lock } from "../util/lock"
+
+export namespace BunProc {
+  const log = Log.create({ service: "bun" })
+  const req = createRequire(import.meta.url)
+
+  export async function run(cmd: string[], options?: Bun.SpawnOptions.OptionsObject<any, any, any>) {
+    log.info("running", {
+      cmd: [which(), ...cmd],
+      ...options,
+    })
+    const result = Bun.spawn([which(), ...cmd], {
+      ...options,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        ...options?.env,
+        BUN_BE_BUN: "1",
+      },
+    })
+    const code = await result.exited
+    const stdout = result.stdout
+      ? typeof result.stdout === "number"
+        ? result.stdout
+        : await readableStreamToText(result.stdout)
+      : undefined
+    const stderr = result.stderr
+      ? typeof result.stderr === "number"
+        ? result.stderr
+        : await readableStreamToText(result.stderr)
+      : undefined
+    log.info("done", {
+      code,
+      stdout,
+      stderr,
+    })
+    if (code !== 0) {
+      throw new Error(`Command failed with exit code ${result.exitCode}`)
+    }
+    return result
+  }
+
+  export function which() {
+    return process.execPath
+  }
+
+  export const InstallFailedError = NamedError.create(
+    "BunInstallFailedError",
+    z.object({
+      pkg: z.string(),
+      version: z.string(),
+    }),
+  )
+
+  export async function install(pkg: string, version = "latest") {
+    // Use lock to ensure only one install at a time
+    using _ = await Lock.write("bun-install")
+
+    const mod = path.join(Global.Path.cache, "node_modules", pkg)
+    const pkgjson = Bun.file(path.join(Global.Path.cache, "package.json"))
+    const parsed = await pkgjson.json().catch(async () => {
+      const result = { dependencies: {} }
+      await Bun.write(pkgjson.name!, JSON.stringify(result, null, 2))
+      return result
+    })
+    const dependencies = parsed.dependencies ?? {}
+    if (!parsed.dependencies) parsed.dependencies = dependencies
+    const modExists = await Filesystem.exists(mod)
+    if (dependencies[pkg] === version && modExists) return mod
+
+    const proxied = !!(
+      process.env.HTTP_PROXY ||
+      process.env.HTTPS_PROXY ||
+      process.env.http_proxy ||
+      process.env.https_proxy
+    )
+
+    // Build command arguments
+    const args = [
+      "add",
+      "--force",
+      "--exact",
+      // TODO: get rid of this case (see: https://github.com/oven-sh/bun/issues/19936)
+      ...(proxied ? ["--no-cache"] : []),
+      "--cwd",
+      Global.Path.cache,
+      pkg + "@" + version,
+    ]
+
+    // Let Bun handle registry resolution:
+    // - If .npmrc files exist, Bun will use them automatically
+    // - If no .npmrc files exist, Bun will default to https://registry.npmjs.org
+    // - No need to pass --registry flag
+    log.info("installing package using Bun's default registry resolution", {
+      pkg,
+      version,
+    })
+
+    await BunProc.run(args, {
+      cwd: Global.Path.cache,
+    }).catch((e) => {
+      throw new InstallFailedError(
+        { pkg, version },
+        {
+          cause: e,
+        },
+      )
+    })
+
+    // Resolve actual version from installed package when using "latest"
+    // This ensures subsequent starts use the cached version until explicitly updated
+    let resolvedVersion = version
+    if (version === "latest") {
+      const installedPkgJson = Bun.file(path.join(mod, "package.json"))
+      const installedPkg = await installedPkgJson.json().catch(() => null)
+      if (installedPkg?.version) {
+        resolvedVersion = installedPkg.version
+      }
+    }
+
+    parsed.dependencies[pkg] = resolvedVersion
+    await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2))
+    return mod
+  }
+}

package/src/bus/bus-event.ts

@@ -0,0 +1,43 @@
+import z from "zod"
+import type { ZodType } from "zod"
+import { Log } from "../util/log"
+
+export namespace BusEvent {
+  const log = Log.create({ service: "event" })
+
+  export type Definition = ReturnType<typeof define>
+
+  const registry = new Map<string, Definition>()
+
+  export function define<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
+    const result = {
+      type,
+      properties,
+    }
+    registry.set(type, result)
+    return result
+  }
+
+  export function payloads() {
+    return z
+      .discriminatedUnion(
+        "type",
+        registry
+          .entries()
+          .map(([type, def]) => {
+            return z
+              .object({
+                type: z.literal(type),
+                properties: def.properties,
+              })
+              .meta({
+                ref: "Event" + "." + def.type,
+              })
+          })
+          .toArray() as any,
+      )
+      .meta({
+        ref: "Event",
+      })
+  }
+}

package/src/bus/global.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "events"
+
+export const GlobalBus = new EventEmitter<{
+  event: [
+    {
+      directory?: string
+      payload: any
+    },
+  ]
+}>()

package/src/bus/index.ts

@@ -0,0 +1,105 @@
+import z from "zod"
+import { Log } from "../util/log"
+import { Instance } from "../project/instance"
+import { BusEvent } from "./bus-event"
+import { GlobalBus } from "./global"
+
+export namespace Bus {
+  const log = Log.create({ service: "bus" })
+  type Subscription = (event: any) => void
+
+  export const InstanceDisposed = BusEvent.define(
+    "server.instance.disposed",
+    z.object({
+      directory: z.string(),
+    }),
+  )
+
+  const state = Instance.state(
+    () => {
+      const subscriptions = new Map<any, Subscription[]>()
+
+      return {
+        subscriptions,
+      }
+    },
+    async (entry) => {
+      const wildcard = entry.subscriptions.get("*")
+      if (!wildcard) return
+      const event = {
+        type: InstanceDisposed.type,
+        properties: {
+          directory: Instance.directory,
+        },
+      }
+      for (const sub of [...wildcard]) {
+        sub(event)
+      }
+    },
+  )
+
+  export async function publish<Definition extends BusEvent.Definition>(
+    def: Definition,
+    properties: z.output<Definition["properties"]>,
+  ) {
+    const payload = {
+      type: def.type,
+      properties,
+    }
+    log.info("publishing", {
+      type: def.type,
+    })
+    const pending = []
+    for (const key of [def.type, "*"]) {
+      const match = state().subscriptions.get(key)
+      for (const sub of match ?? []) {
+        pending.push(sub(payload))
+      }
+    }
+    GlobalBus.emit("event", {
+      directory: Instance.directory,
+      payload,
+    })
+    return Promise.all(pending)
+  }
+
+  export function subscribe<Definition extends BusEvent.Definition>(
+    def: Definition,
+    callback: (event: { type: Definition["type"]; properties: z.infer<Definition["properties"]> }) => void,
+  ) {
+    return raw(def.type, callback)
+  }
+
+  export function once<Definition extends BusEvent.Definition>(
+    def: Definition,
+    callback: (event: {
+      type: Definition["type"]
+      properties: z.infer<Definition["properties"]>
+    }) => "done" | undefined,
+  ) {
+    const unsub = subscribe(def, (event) => {
+      if (callback(event)) unsub()
+    })
+  }
+
+  export function subscribeAll(callback: (event: any) => void) {
+    return raw("*", callback)
+  }
+
+  function raw(type: string, callback: (event: any) => void) {
+    log.info("subscribing", { type })
+    const subscriptions = state().subscriptions
+    let match = subscriptions.get(type) ?? []
+    match.push(callback)
+    subscriptions.set(type, match)
+
+    return () => {
+      log.info("unsubscribing", { type })
+      const match = subscriptions.get(type)
+      if (!match) return
+      const index = match.indexOf(callback)
+      if (index === -1) return
+      match.splice(index, 1)
+    }
+  }
+}

package/src/cli/bootstrap.ts

@@ -0,0 +1,17 @@
+import { InstanceBootstrap } from "../project/bootstrap"
+import { Instance } from "../project/instance"
+
+export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
+  return Instance.provide({
+    directory,
+    init: InstanceBootstrap,
+    fn: async () => {
+      try {
+        const result = await cb()
+        return result
+      } finally {
+        await Instance.dispose()
+      }
+    },
+  })
+}

package/src/cli/cmd/account.ts

@@ -0,0 +1,81 @@
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+import { EliseArtAuth, ELISEART_SUPABASE_URL } from "../../auth/eliseart"
+
+export const AccountCommand = cmd({
+    command: "account",
+    describe: "view EliseArt account info, plan & AI credits",
+    async handler() {
+        UI.empty()
+        const session = await EliseArtAuth.getSession()
+        if (!session || session.type !== "oauth") {
+            prompts.log.error("Not logged in to EliseArt. Run 'easc auth login' and select 'eliseart'.")
+            return
+        }
+
+        const headers = await EliseArtAuth.getAuthHeaders()
+        const spinner = prompts.spinner()
+        spinner.start("Fetching account details...")
+
+        try {
+            // Fetch AI credits
+            const creditsResponse = await fetch(
+                `${ELISEART_SUPABASE_URL}/rest/v1/ai_credits?user_id=eq.${session.accountId}&select=balance,last_reset_at`,
+                {
+                    method: "GET",
+                    headers: {
+                        ...headers,
+                        "Content-Type": "application/json",
+                    },
+                }
+            )
+
+            let aiCredits = 0
+            if (creditsResponse.ok) {
+                const creditsData = await creditsResponse.json() as any[]
+                if (creditsData && creditsData.length > 0) {
+                    aiCredits = creditsData[0].balance || 0
+                }
+            }
+
+            // Fetch plan
+            const subResponse = await fetch(
+                `${ELISEART_SUPABASE_URL}/rest/v1/user_subscriptions?user_id=eq.${session.accountId}&select=*,plan:subscription_plans(name)&status=eq.active`,
+                {
+                    method: "GET",
+                    headers: {
+                        ...headers,
+                        "Content-Type": "application/json",
+                    },
+                }
+            )
+
+            let plan = "free"
+            let planExpiresAt: string | null = null
+            if (subResponse.ok) {
+                const subData = await subResponse.json() as any[]
+                if (subData && subData.length > 0) {
+                    plan = subData[0].plan?.name || "premium"
+                    planExpiresAt = subData[0].current_period_end || subData[0].ends_at
+                }
+            }
+
+            spinner.stop("Account details loaded")
+
+            console.log("\n\x1b[36m╭─────────────────────────────────────╮\x1b[0m")
+            console.log("\x1b[36m│\x1b[0m       \x1b[1m🎨 EliseArt Account\x1b[0m          \x1b[36m│\x1b[0m")
+            console.log("\x1b[36m├─────────────────────────────────────┤\x1b[0m")
+            console.log(`\x1b[36m│\x1b[0m  Plan:       ${plan.toUpperCase().padEnd(22)} \x1b[36m│\x1b[0m`)
+            console.log(`\x1b[36m│\x1b[0m  AI Credits: ${String(aiCredits).padEnd(22)} \x1b[36m│\x1b[0m`)
+            if (planExpiresAt) {
+                const expires = new Date(planExpiresAt).toLocaleDateString()
+                console.log(`\x1b[36m│\x1b[0m  Renews:     ${expires.padEnd(22)} \x1b[36m│\x1b[0m`)
+            }
+            console.log("\x1b[36m╰─────────────────────────────────────╯\x1b[0m\n")
+
+        } catch (e: any) {
+            spinner.stop("Failed to fetch account info: " + e.message, 1)
+        }
+    },
+})

package/src/cli/cmd/acp.ts

@@ -0,0 +1,69 @@
+import { Log } from "@/util/log"
+import { bootstrap } from "../bootstrap"
+import { cmd } from "./cmd"
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
+import { ACP } from "@/acp/agent"
+import { Server } from "@/server/server"
+import { createOpencodeClient } from "@eliseart.ai/sdk/v2"
+import { withNetworkOptions, resolveNetworkOptions } from "../network"
+
+const log = Log.create({ service: "acp-command" })
+
+export const AcpCommand = cmd({
+  command: "acp",
+  describe: "start ACP (Agent Client Protocol) server",
+  builder: (yargs) => {
+    return withNetworkOptions(yargs).option("cwd", {
+      describe: "working directory",
+      type: "string",
+      default: process.cwd(),
+    })
+  },
+  handler: async (args) => {
+    await bootstrap(process.cwd(), async () => {
+      const opts = await resolveNetworkOptions(args)
+      const server = Server.listen(opts)
+
+      const sdk = createOpencodeClient({
+        baseUrl: `http://${server.hostname}:${server.port}`,
+      })
+
+      const input = new WritableStream<Uint8Array>({
+        write(chunk) {
+          return new Promise<void>((resolve, reject) => {
+            process.stdout.write(chunk, (err) => {
+              if (err) {
+                reject(err)
+              } else {
+                resolve()
+              }
+            })
+          })
+        },
+      })
+      const output = new ReadableStream<Uint8Array>({
+        start(controller) {
+          process.stdin.on("data", (chunk: Buffer) => {
+            controller.enqueue(new Uint8Array(chunk))
+          })
+          process.stdin.on("end", () => controller.close())
+          process.stdin.on("error", (err) => controller.error(err))
+        },
+      })
+
+      const stream = ndJsonStream(input, output)
+      const agent = await ACP.init({ sdk })
+
+      new AgentSideConnection((conn) => {
+        return agent.create(conn, { sdk })
+      }, stream)
+
+      log.info("setup connection")
+      process.stdin.resume()
+      await new Promise((resolve, reject) => {
+        process.stdin.on("end", resolve)
+        process.stdin.on("error", reject)
+      })
+    })
+  },
+})