@abide/abide 0.58.0 → 0.100.0

package/src/lib/mcp/types/McpServer.ts

@@ -1,9 +0,0 @@
-/*
-Public shape returned by createMcpServer. The bun route handler at
-/__abide/mcp delegates inbound requests to `handle(request)`, which
-parses the JSON-RPC envelope, dispatches to tools/resources, and returns
-a Response carrying the JSON-RPC reply.
-*/
-export type McpServer = {
-    handle(request: Request): Promise<Response>
-}

package/src/lib/mcp/types/McpServerOptions.ts

@@ -1,16 +0,0 @@
-/*
-User-facing options for createMcpServer. All fields optional — the
-zero-arg call works for any abide project (server info is derived from
-package.json by the bundler when MCP is wired into createServer).
-
-- `name` / `version`: identify the server in the MCP `initialize`
-  response. Defaults come from the project's package.json.
-- `authorize`: optional boundary check. Runs once per MCP request before
-  any tool/resource dispatch. Throw HttpError (or any Error) to reject.
-  Per-tool authorization stays in the underlying rpc handler.
-*/
-export type McpServerOptions = {
-    name?: string
-    version?: string
-    authorize?: (request: Request) => Promise<void> | void
-}

package/src/lib/mcp/types/McpSurface.ts

@@ -1,15 +0,0 @@
-import type { McpResourceContents } from './McpResourceContents.ts'
-import type { McpResourceDescriptor } from './McpResourceDescriptor.ts'
-import type { PromptDescriptor } from './PromptDescriptor.ts'
-import type { PromptMessage } from './PromptMessage.ts'
-import type { ToolDescriptor } from './ToolDescriptor.ts'
-import type { ToolResult } from './ToolResult.ts'
-
-export type McpSurface = {
-    tools: ToolDescriptor[]
-    call(name: string, args: Record<string, unknown> | undefined): Promise<ToolResult>
-    prompts: PromptDescriptor[]
-    getPrompt(name: string, args?: Record<string, unknown>): PromptMessage[]
-    listResources(): Promise<McpResourceDescriptor[]>
-    readResource(uri: string): Promise<McpResourceContents | undefined>
-}

package/src/lib/mcp/types/PromptDescriptor.ts

@@ -1,5 +0,0 @@
-export type PromptDescriptor = {
-    name: string
-    description?: string
-    arguments: Array<{ name: string; description?: string; required: boolean }>
-}

package/src/lib/mcp/types/PromptMessage.ts

@@ -1,2 +0,0 @@
-// A prompt rendered to plain messages — the user turn(s) that seed a conversation.
-export type PromptMessage = { role: 'user'; text: string }

package/src/lib/mcp/types/ToolDescriptor.ts

@@ -1,7 +0,0 @@
-export type ToolDescriptor = {
-    name: string
-    description: string
-    inputSchema: Record<string, unknown>
-    outputSchema?: Record<string, unknown>
-    annotations?: Record<string, boolean>
-}

package/src/lib/mcp/types/ToolResult.ts

@@ -1,2 +0,0 @@
-// The MCP tools/call result shape (a text content block plus optional structuredContent).
-export type ToolResult = Record<string, unknown>

package/src/lib/server/AppModule.ts

@@ -1,47 +0,0 @@
-import type { Server } from 'bun'
-
-/*
-Optional hooks exported from src/app.ts. All hooks are optional; defaults
-kick in when an export is missing. init returns an optional cleanup
-function that runs on SIGINT/SIGTERM. handle is single-middleware with
-next so user code can mutate the response or branch on the URL.
-
-WebSockets are not exposed here — abide's only native WebSocket
-surface is the sockets hub (see `abide/server/socket`), multiplexed onto a
-single framework-owned connection per client at `/__abide/sockets`.
-Inside request scopes, the live Bun.Server is reachable via the
-exported `server()` function from `abide/server/server`; `init` receives it
-explicitly because it runs outside a request.
-*/
-// @documentation plumbing
-export type AppModule = {
-    /*
-    Extra inbound header names to forward onto in-process rpc Requests, on
-    top of abide's built-in auth/identity set (cookie, authorization, the
-    x-forwarded-* hints). Names a handler reads during SSR or an MCP call
-    that aren't in the default allowlist — e.g. 'accept-language',
-    'x-request-id', a custom 'x-tenant-id'. Case-insensitive.
-    */
-    forwardHeaders?: string[]
-    init?: (ctx: {
-        server: Server<unknown>
-    }) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)>
-    handle?: (
-        request: Request,
-        next: (req: Request) => Promise<Response>,
-    ) => Promise<Response> | Response
-    handleError?: (error: unknown, request: Request) => Promise<Response> | Response
-    /*
-    App fields merged into the /__abide/health payload the client `health()`
-    polls — e.g. `{ authenticated: await sessionValid(request) }`. Runs ahead
-    of `handle` (the endpoint must answer without auth — reporting
-    "authenticated: false" requires exactly that), so the request arrives
-    unfiltered: cookies are readable, nothing is guaranteed valid. The
-    payload is public and unauthenticated — never put secrets in it. The
-    framework's identity keys (abide/name/version) win on collision; a
-    thrown hook is logged and the base payload still serves, so an app bug
-    can't masquerade as an unreachable server. Keep it cheap: the client
-    probe times out at 5s.
-    */
-    health?: (request: Request) => unknown | Promise<unknown>
-}

package/src/lib/server/DELETE.ts

@@ -1,10 +0,0 @@
-import type { MutatingRpcHelper } from './rpc/types/RpcHelper.ts'
-import { unprocessed } from './rpc/unprocessed.ts'
-
-/*
-DELETE rpc helper. The bundler rewrites every `export const x = DELETE(fn)` inside
-`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
-remoteProxy stub (client target). Calling this directly throws.
-*/
-// @documentation rpc
-export const DELETE: MutatingRpcHelper = (_fn: any, _opts?: any) => unprocessed('DELETE')

package/src/lib/server/GET.ts

@@ -1,10 +0,0 @@
-import type { RpcHelper } from './rpc/types/RpcHelper.ts'
-import { unprocessed } from './rpc/unprocessed.ts'
-
-/*
-GET rpc helper. The bundler rewrites every `export const x = GET(fn)` inside
-`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
-remoteProxy stub (client target). Calling this directly throws.
-*/
-// @documentation rpc
-export const GET: RpcHelper = (_fn: any, _opts?: any) => unprocessed('GET')

package/src/lib/server/HEAD.ts

@@ -1,10 +0,0 @@
-import type { RpcHelper } from './rpc/types/RpcHelper.ts'
-import { unprocessed } from './rpc/unprocessed.ts'
-
-/*
-HEAD rpc helper. The bundler rewrites every `export const x = HEAD(fn)` inside
-`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
-remoteProxy stub (client target). Calling this directly throws.
-*/
-// @documentation rpc
-export const HEAD: RpcHelper = (_fn: any, _opts?: any) => unprocessed('HEAD')

package/src/lib/server/PATCH.ts

@@ -1,10 +0,0 @@
-import type { MutatingRpcHelper } from './rpc/types/RpcHelper.ts'
-import { unprocessed } from './rpc/unprocessed.ts'
-
-/*
-PATCH rpc helper. The bundler rewrites every `export const x = PATCH(fn)` inside
-`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
-remoteProxy stub (client target). Calling this directly throws.
-*/
-// @documentation rpc
-export const PATCH: MutatingRpcHelper = (_fn: any, _opts?: any) => unprocessed('PATCH')

package/src/lib/server/POST.ts

@@ -1,10 +0,0 @@
-import type { MutatingRpcHelper } from './rpc/types/RpcHelper.ts'
-import { unprocessed } from './rpc/unprocessed.ts'
-
-/*
-POST rpc helper. The bundler rewrites every `export const x = POST(fn)` inside
-`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
-remoteProxy stub (client target). Calling this directly throws.
-*/
-// @documentation rpc
-export const POST: MutatingRpcHelper = (_fn: any, _opts?: any) => unprocessed('POST')

package/src/lib/server/PUT.ts

@@ -1,10 +0,0 @@
-import type { MutatingRpcHelper } from './rpc/types/RpcHelper.ts'
-import { unprocessed } from './rpc/unprocessed.ts'
-
-/*
-PUT rpc helper. The bundler rewrites every `export const x = PUT(fn)` inside
-`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
-remoteProxy stub (client target). Calling this directly throws.
-*/
-// @documentation rpc
-export const PUT: MutatingRpcHelper = (_fn: any, _opts?: any) => unprocessed('PUT')

package/src/lib/server/agent.ts

@@ -1,86 +0,0 @@
-import { mcpSurface } from '../mcp/mcpSurface.ts'
-import type { McpSurface } from '../mcp/types/McpSurface.ts'
-import { request } from './request.ts'
-
-/*
-The in-app agent surface. `agent(engine, messages)` runs a model engine
-against the app's own MCP surface and returns the engine's frame stream —
-it does NOT pick a transport. The handler wraps it in `jsonl()` or `sse()`,
-so consumption is the app's choice, same as any other streaming rpc:
-
-  // src/server/rpc/chat.ts
-  import { agent } from '@abide/abide/server/agent'
-  import { jsonl } from '@abide/abide/server/jsonl'
-  import { engine } from '@abide/anthropic'
-
-  const chatEngine = engine({ model: 'claude-opus-4-8', apiKey: config.ANTHROPIC_API_KEY })
-  export const chat = POST(({ messages }) => jsonl(agent(chatEngine, messages)), { inputSchema })
-
-The engine — provider-specific, lives in a `@abide/<provider>` package —
-only sees the surface in and yields frames out, so swapping providers never
-touches the rpc or the UI.
-
-Permission is decided server-side, not negotiated at runtime: the surface
-is already gated by each rpc's `clients.mcp` declaration plus its own
-per-call handler auth, and any provider built-ins (e.g. Claude Code's bash
-tool) are fenced by static rules in the engine's config.
-*/
-
-// A turn in the conversation, provider-neutral. The engine maps these to its provider's wire shape.
-// @documentation agent
-export type NeutralMessage =
-    | { role: 'user'; text: string }
-    | {
-          role: 'assistant'
-          text?: string
-          toolUses?: { id: string; name: string; input: unknown }[]
-      }
-    | { role: 'tool'; results: { id: string; content: string; isError?: boolean }[] }
-
-// What the engine streams out; the handler frames it via jsonl()/sse() for the client.
-export type AgentFrame =
-    | { type: 'text'; delta: string }
-    | { type: 'tool_use'; id: string; name: string; input: unknown }
-    | { type: 'tool_result'; id: string; name: string; ok: boolean }
-    /*
-    `stop` is the reason the engine's loop ended. `error` covers an abnormal
-    stop the model didn't choose — a provider error/limit (e.g. Claude Code's
-    max-turns) or the engine's own tool-loop cap — so a client can tell a cut-off
-    answer from a clean `end`.
-    */
-    | {
-          type: 'done'
-          stop: 'end' | 'tool_use' | 'max_tokens' | 'refusal' | 'error'
-      }
-
-// The app's tool/prompt/resource surface handed to an engine (already gated).
-export type AgentSurface = McpSurface
-
-/*
-A model engine: surface + conversation in, frames out. It owns its own loop
-(a raw-model tool loop, or driving a full agent harness) — core only sees
-the frame stream. `origin` lets engines that reach the MCP endpoint over
-HTTP address this server. Implementations live in `@abide/<provider>`
-packages.
-*/
-export type AgentEngine = (input: {
-    surface: AgentSurface
-    messages: NeutralMessage[]
-    origin: string
-}) => AsyncIterable<AgentFrame>
-
-/*
-Runs an engine against the current request's MCP surface and returns its
-AgentFrame stream. Must be called inside a rpc's request scope —
-mcpSurface() forwards the caller's auth into every tool dispatch. The
-handler chooses the transport: `jsonl(agent(engine, messages))` or
-`sse(agent(engine, messages))`.
-*/
-export function agent(engine: AgentEngine, messages: NeutralMessage[]): AsyncIterable<AgentFrame> {
-    const inbound = request()
-    return engine({
-        surface: mcpSurface(inbound),
-        messages,
-        origin: new URL(inbound.url).origin,
-    })
-}

package/src/lib/server/appDataDir.ts

@@ -1,16 +0,0 @@
-// @ts-expect-error virtual module resolved by abideResolverPlugin
-import cliProgramName from '../../_virtual/cli-name.ts'
-import { appDataDir as appDataDirForName } from '../shared/appDataDir.ts'
-
-/*
-The running bundle's per-user data dir — keyed by the same program name abide
-uses for the user's `.env` and `last-connection.json`, so an app's DB/cache lands
-beside abide's own config instead of a drifted sibling directory. cwd-independent:
-the path derives from the bundler-injected program name, not the process working
-directory (which `open` sets to `/`). Pure: computes the path, never touches the
-filesystem.
-*/
-// @documentation bundle
-export function appDataDir(): string {
-    return appDataDirForName(cliProgramName)
-}

package/src/lib/server/cli/buildEnvContent.ts

@@ -1,19 +0,0 @@
-import { serializeEnv } from '../../shared/serializeEnv.ts'
-
-/*
-Generates the `.env` file content shipped alongside the CLI binary in
-the download tarball. ABIDE_APP_URL is always present (derived from the
-inbound request's origin); ABIDE_APP_TOKEN is included only when the inbound
-request carried an Authorization: Bearer header, so an authenticated
-download bakes the caller's credential into the binary's env.
-
-Tokens forward verbatim — the framework doesn't issue or refresh; the
-user's auth code at the actual RPC endpoints validates whatever value
-arrives back in subsequent calls.
-*/
-export function buildEnvContent(appUrl: string, bearerToken: string | undefined): string {
-    return serializeEnv({
-        ABIDE_APP_URL: appUrl,
-        ...(bearerToken ? { ABIDE_APP_TOKEN: bearerToken } : {}),
-    })
-}

package/src/lib/server/cli/createTarGz.ts

@@ -1,77 +0,0 @@
-/*
-Minimal ustar tarball writer. Each entry is a 512-byte header followed
-by the content padded to a 512-byte boundary; the archive ends with two
-512-byte zero blocks. After assembly the buffer is gzipped via
-Bun.gzipSync — no external `tar` invocation, no extra deps.
-
-Format constraints:
-  - File names ≤ 100 bytes (we never write longer paths).
-  - Numeric fields are zero-padded octal ASCII strings (POSIX rule).
-  - Checksum is the sum of all header bytes treating the checksum
-    field as spaces; encoded as 6 octal digits + NUL + space.
-*/
-
-type TarEntry = {
-    name: string
-    content: Uint8Array
-    mode?: number
-}
-
-const BLOCK = 512
-const ENC = new TextEncoder()
-
-function writeString(buf: Uint8Array, offset: number, length: number, value: string): void {
-    const bytes = ENC.encode(value)
-    buf.set(bytes.subarray(0, Math.min(bytes.length, length)), offset)
-}
-
-function writeOctal(buf: Uint8Array, offset: number, length: number, value: number): void {
-    // length-1 octal digits + trailing NUL
-    const oct = value.toString(8).padStart(length - 1, '0')
-    writeString(buf, offset, length - 1, oct)
-    buf[offset + length - 1] = 0
-}
-
-function buildHeader(entry: TarEntry): Uint8Array {
-    const header = new Uint8Array(BLOCK)
-    writeString(header, 0, 100, entry.name)
-    writeOctal(header, 100, 8, entry.mode ?? 0o644)
-    writeOctal(header, 108, 8, 0)
-    writeOctal(header, 116, 8, 0)
-    writeOctal(header, 124, 12, entry.content.length)
-    writeOctal(header, 136, 12, Math.floor(Date.now() / 1000))
-    header.fill(0x20, 148, 156)
-    header[156] = 0x30 // '0' = regular file
-    writeString(header, 257, 6, 'ustar\0')
-    writeString(header, 263, 2, '00')
-    // Checksum: sum of all bytes with checksum field treated as spaces.
-    let sum = 0
-    for (let index = 0; index < BLOCK; index++) {
-        sum += header[index] ?? 0
-    }
-    writeOctal(header, 148, 7, sum)
-    header[155] = 0x20 // trailing space after checksum digits
-    return header
-}
-
-/*
-Builds a gzipped tarball from the given entries and returns the bytes.
-Sized eagerly (sum of headers + padded contents + 2 trailing blocks).
-*/
-export function createTarGz(entries: TarEntry[]): Uint8Array<ArrayBuffer> {
-    let totalSize = BLOCK * 2 // trailing zero blocks
-    for (const entry of entries) {
-        totalSize += BLOCK
-        totalSize += Math.ceil(entry.content.length / BLOCK) * BLOCK
-    }
-    const tar = new Uint8Array(totalSize)
-    let offset = 0
-    for (const entry of entries) {
-        tar.set(buildHeader(entry), offset)
-        offset += BLOCK
-        tar.set(entry.content, offset)
-        offset += Math.ceil(entry.content.length / BLOCK) * BLOCK
-    }
-    /* gzipSync allocates a fresh plain ArrayBuffer; @types/bun widens it to ArrayBufferLike, which BodyInit rejects. */
-    return Bun.gzipSync(tar) as Uint8Array<ArrayBuffer>
-}

package/src/lib/server/cli/handleCliDownload.ts

@@ -1,152 +0,0 @@
-import { abideLog } from '../../shared/abideLog.ts'
-import { NO_STORE } from '../../shared/CACHE_CONTROL_VALUES.ts'
-import { exeSuffix } from '../../shared/exeSuffix.ts'
-import { isCompileTarget } from '../../shared/isCompileTarget.ts'
-import { normalizeTarget } from '../../shared/normalizeTarget.ts'
-import { buildEnvContent } from './buildEnvContent.ts'
-import { createTarGz } from './createTarGz.ts'
-import { maxSourceMtime } from './maxSourceMtime.ts'
-
-// The sibling server binary's name for a platform — `server` / `server.exe` — must
-// match what resolveServerBinary() looks for next to the unpacked CLI binary.
-function serverBinaryName(platform: string): string {
-    return `server${exeSuffix(normalizeTarget(platform))}`
-}
-
-/*
-Process-wide per-platform build coalescing. Two concurrent curls for
-the same /__abide/cli/<platform> share one promise; the later requests
-await the same one the first installed. The promise both runs the
-freshness check AND the rebuild, so the map insertion is synchronous
-relative to the first request's entry into the function — no window
-between an `await` and `pendingBuilds.set` for a second concurrent
-request to slip through and fire its own buildCli against the same
-output paths.
-*/
-const pendingBuilds = new Map<string, Promise<string | undefined>>()
-
-async function ensurePlatformBinary(
-    platform: string,
-    programName: string,
-    cwd: string,
-): Promise<string | undefined> {
-    const existing = pendingBuilds.get(platform)
-    if (existing) {
-        return existing
-    }
-    const promise = computeBinary(platform, programName, cwd)
-    pendingBuilds.set(platform, promise)
-    /*
-    Drop the entry after settlement so a later request rebuilds if the
-    source has changed again. Identity-guard so a still-pending entry
-    installed by a follow-up request isn't evicted by ours.
-    */
-    promise.finally(() => {
-        if (pendingBuilds.get(platform) === promise) {
-            pendingBuilds.delete(platform)
-        }
-    })
-    return promise
-}
-
-async function computeBinary(
-    platform: string,
-    programName: string,
-    cwd: string,
-): Promise<string | undefined> {
-    const dir = `${cwd}/dist/cli-thin/${platform}`
-    const binaryPath = `${dir}/${programName}`
-    const serverPath = `${dir}/${serverBinaryName(platform)}`
-    /*
-    On-disk binaries are fresh when both the CLI and its sibling server exist AND
-    the CLI's mtime beats the newest rpc/socket source mtime. The mtime check
-    catches the common dev iteration where the user edits an rpc handler but didn't
-    run `abide cli` again; the server-exists check forces a rebuild for a dist
-    produced before the CLI co-shipped a server. Other source paths (project lib,
-    transitive imports) fall back to manual rebuild.
-    */
-    const binaryFile = Bun.file(binaryPath)
-    const serverFile = Bun.file(serverPath)
-    if ((await binaryFile.exists()) && (await serverFile.exists())) {
-        const binaryMtime = (await binaryFile.stat()).mtimeMs
-        const sourceMtime = await maxSourceMtime(cwd)
-        if (binaryMtime >= sourceMtime) {
-            return binaryPath
-        }
-        abideLog.info(`thin cli for ${platform} is stale — rebuilding`)
-    }
-    try {
-        abideLog.info(`lazy-building cli + server for ${platform}…`)
-        // Lazy-import buildCli so the build pipeline isn't pulled into
-        // production processes that never serve a download.
-        const { buildCli } = await import('../../../buildCli.ts')
-        await buildCli({
-            cwd,
-            platforms: [normalizeTarget(platform)],
-        })
-        return (await binaryFile.exists()) && (await serverFile.exists()) ? binaryPath : undefined
-    } catch (error) {
-        abideLog.error(error)
-        return undefined
-    }
-}
-
-/*
-Handles GET /__abide/cli/<platform> — streams a gzipped tarball containing
-the platform-specific thin binary, the sibling server binary, and a `.env`
-carrying ABIDE_APP_URL (and ABIDE_APP_TOKEN if the inbound request was
-authenticated).
-
-Thin binaries live at `dist/cli-thin/<platform>/<programName>` (produced
-lazily by `buildCli` on first request). The `.env` baking `ABIDE_APP_URL`
-is generated at download time, not build time. Missing platforms produce
-404 — the install script reports it, doesn't try to fall back.
-*/
-export async function handleCliDownload(
-    request: Request,
-    platform: string,
-    programName: string,
-    cwd: string,
-): Promise<Response> {
-    /*
-    Validate the URL-supplied platform against the known target set before any
-    filesystem access or lazy build. Without this, an arbitrary `platform`
-    segment flows into `dist/cli-thin/<platform>` paths (a traversal/oracle
-    surface) and a cache miss triggers an expensive cross-compile — so spraying
-    distinct junk strings amplifies into unbounded concurrent builds.
-    */
-    const binaryPath = isCompileTarget(normalizeTarget(platform))
-        ? await ensurePlatformBinary(platform, programName, cwd)
-        : undefined
-    if (!binaryPath) {
-        return new Response(`unknown platform: ${platform}`, {
-            status: 404,
-            headers: { 'Cache-Control': NO_STORE },
-        })
-    }
-    const appUrl = new URL(request.url).origin
-    const auth = request.headers.get('authorization')
-    const bearer = auth?.toLowerCase().startsWith('bearer ')
-        ? auth.slice('bearer '.length)
-        : undefined
-    const envContent = buildEnvContent(appUrl, bearer)
-
-    const serverPath = `${cwd}/dist/cli-thin/${platform}/${serverBinaryName(platform)}`
-    const [binaryBytes, serverBytes] = await Promise.all([
-        Bun.file(binaryPath).bytes(),
-        Bun.file(serverPath).bytes(),
-    ])
-    // Ship the server beside the CLI so `/start` can spawn a local instance.
-    const archive = createTarGz([
-        { name: programName, content: binaryBytes, mode: 0o755 },
-        { name: serverBinaryName(platform), content: serverBytes, mode: 0o755 },
-        { name: '.env', content: new TextEncoder().encode(envContent), mode: 0o644 },
-    ])
-    return new Response(archive, {
-        headers: {
-            'Content-Type': 'application/gzip',
-            'Content-Disposition': `attachment; filename="${programName}-${platform}.tar.gz"`,
-            'Cache-Control': NO_STORE,
-        },
-    })
-}

package/src/lib/server/cli/handleCliInstall.ts

@@ -1,37 +0,0 @@
-import { NO_STORE } from '../../shared/CACHE_CONTROL_VALUES.ts'
-import { installScript } from './installScript.ts'
-
-/*
-The request host is reflected verbatim into a shell script the user pipes
-to `sh`, so it's constrained to the strict authority charset: letters,
-digits, `.`, `-`, `_`, `:` (port + IPv6 separators), and IPv6 `[` `]`
-brackets. That set excludes every character that could break out of the
-interpolated `URL="…"` line in installScript (`"`, `$`, backtick, `\`,
-whitespace), neutralising shell injection via a crafted Host header
-regardless of how lenient the upstream URL parser is.
-*/
-const SAFE_HOST = /^[A-Za-z0-9._:[\]-]+$/
-
-/*
-Handles GET /__abide/cli — returns the platform-detecting shell script.
-Authoritative URL for the tarball is derived from the inbound request
-(so the script's curl line points at whatever host the user reached us
-on). Program name is the bundler-emitted `abide:cli-name` value.
-*/
-export function handleCliInstall(request: Request, programName: string): Response {
-    const url = new URL(request.url)
-    if (!SAFE_HOST.test(url.host)) {
-        return new Response('Bad Request', {
-            status: 400,
-            headers: { 'Cache-Control': NO_STORE },
-        })
-    }
-    const appUrl = url.origin
-    const script = installScript(appUrl, programName)
-    return new Response(script, {
-        headers: {
-            'Content-Type': 'text/x-shellscript; charset=utf-8',
-            'Cache-Control': NO_STORE,
-        },
-    })
-}

package/src/lib/server/cli/installScript.ts

@@ -1,31 +0,0 @@
-import { CLI_PATH } from '../../shared/CLI_PATH.ts'
-
-/*
-The shell script returned by `GET /__abide/cli` (no platform). Detects
-uname OS + arch, normalises common arch aliases, then curls the right
-platform-specific tarball and extracts it into `$ABIDE_INSTALL_DIR`
-(default `~/.local/bin`). The tarball already contains the `.env` next
-to the binary — no separate config write step in the script.
-
-The script is rendered server-side so the request origin is baked into the
-`URL` variable at generation time and the embedded curl URL needs no escaping
-or quoting beyond basic shell hygiene.
-*/
-export function installScript(appUrl: string, programName: string): string {
-    return `#!/usr/bin/env sh
-set -e
-OS=$(uname -s | tr '[:upper:]' '[:lower:]')
-case "$(uname -m)" in
-  x86_64|amd64)   ARCH=x64 ;;
-  aarch64|arm64)  ARCH=arm64 ;;
-  *)              echo "unsupported architecture: $(uname -m)" >&2 ; exit 1 ;;
-esac
-INSTALL_DIR="\${ABIDE_INSTALL_DIR:-$HOME/.local/bin}"
-mkdir -p "$INSTALL_DIR"
-URL="${appUrl.replace(/\/$/, '')}${CLI_PATH}/\${OS}-\${ARCH}"
-echo "installing ${programName} from $URL into $INSTALL_DIR"
-curl -fsSL "$URL" | tar -xz -C "$INSTALL_DIR"
-echo "installed: $INSTALL_DIR/${programName}"
-echo "ensure $INSTALL_DIR is in your PATH"
-`
-}

package/src/lib/server/cli/maxSourceMtime.ts

@@ -1,26 +0,0 @@
-import { existsSync } from 'node:fs'
-import { Glob } from 'bun'
-
-/*
-Returns the most-recent mtime across every rpc + socket source file in
-the project, or 0 when both directories are absent. The lazy CLI
-download path compares this to the binary's mtime to decide whether to
-rebuild — covers the common dev iteration of "user edited an rpc
-handler" without needing to scan transitively-imported modules. Globs and
-stats run concurrently since each file is independent.
-*/
-export async function maxSourceMtime(cwd: string): Promise<number> {
-    const roots = [`${cwd}/src/server/rpc`, `${cwd}/src/server/sockets`].filter(existsSync)
-    const perRoot = await Promise.all(
-        roots.map(async (root) => {
-            const files = await Array.fromAsync(
-                new Glob('**/*.ts').scan({ cwd: root, onlyFiles: true }),
-            )
-            return files.map((file) => `${root}/${file}`)
-        }),
-    )
-    const mtimes = await Promise.all(
-        perRoot.flat().map(async (path) => (await Bun.file(path).stat()).mtimeMs),
-    )
-    return mtimes.reduce((newest, mtime) => Math.max(newest, mtime), 0)
-}