@link-assistant/agent 0.0.8

package/src/index.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env bun
+
+import { Server } from './server/server.ts'
+import { Instance } from './project/instance.ts'
+import { Log } from './util/log.ts'
+import { Bus } from './bus/index.ts'
+import { Session } from './session/index.ts'
+import { SessionPrompt } from './session/prompt.ts'
+import { EOL } from 'os'
+import yargs from 'yargs'
+import { hideBin } from 'yargs/helpers'
+
+async function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = ''
+    const onData = chunk => {
+      data += chunk
+    }
+    const onEnd = () => {
+      cleanup()
+      resolve(data)
+    }
+    const onError = err => {
+      cleanup()
+      reject(err)
+    }
+    const cleanup = () => {
+      process.stdin.removeListener('data', onData)
+      process.stdin.removeListener('end', onEnd)
+      process.stdin.removeListener('error', onError)
+    }
+    process.stdin.on('data', onData)
+    process.stdin.on('end', onEnd)
+    process.stdin.on('error', onError)
+  })
+}
+
+async function main() {
+  try {
+    // Parse command line arguments
+    const argv = await yargs(hideBin(process.argv))
+      .option('model', {
+        type: 'string',
+        description: 'Model to use in format providerID/modelID',
+        default: 'opencode/grok-code'
+      })
+      .option('system-message', {
+        type: 'string',
+        description: 'Full override of the system message'
+      })
+      .option('system-message-file', {
+        type: 'string',
+        description: 'Full override of the system message from file'
+      })
+      .option('append-system-message', {
+        type: 'string',
+        description: 'Append to the default system message'
+      })
+      .option('append-system-message-file', {
+        type: 'string',
+        description: 'Append to the default system message from file'
+      })
+      .option('server', {
+        type: 'boolean',
+        description: 'Run in server mode (default)',
+        default: true
+      })
+      .help()
+      .argv
+
+    // Parse model argument
+    const modelParts = argv.model.split('/')
+    const providerID = modelParts[0] || 'opencode'
+    const modelID = modelParts[1] || 'grok-code'
+
+    // Read system message files
+    let systemMessage = argv['system-message']
+    let appendSystemMessage = argv['append-system-message']
+
+    if (argv['system-message-file']) {
+      const resolvedPath = require('path').resolve(process.cwd(), argv['system-message-file'])
+      const file = Bun.file(resolvedPath)
+      if (!(await file.exists())) {
+        console.error(`System message file not found: ${argv['system-message-file']}`)
+        process.exit(1)
+      }
+      systemMessage = await file.text()
+    }
+
+    if (argv['append-system-message-file']) {
+      const resolvedPath = require('path').resolve(process.cwd(), argv['append-system-message-file'])
+      const file = Bun.file(resolvedPath)
+      if (!(await file.exists())) {
+        console.error(`Append system message file not found: ${argv['append-system-message-file']}`)
+        process.exit(1)
+      }
+      appendSystemMessage = await file.text()
+    }
+
+    // Initialize logging to redirect to log file instead of stderr
+    // This prevents log messages from mixing with JSON output
+    await Log.init({
+      print: false,  // Don't print to stderr
+      level: 'INFO'
+    })
+
+    // Read input from stdin
+    const input = await readStdin()
+    const trimmedInput = input.trim()
+
+    // Try to parse as JSON, if it fails treat it as plain text message
+    let request
+    try {
+      request = JSON.parse(trimmedInput)
+    } catch (e) {
+      // Not JSON, treat as plain text message
+      request = {
+        message: trimmedInput
+      }
+    }
+
+    // Wrap in Instance.provide for OpenCode infrastructure
+    await Instance.provide({
+      directory: process.cwd(),
+      fn: async () => {
+        if (argv.server) {
+          // SERVER MODE: Start server and communicate via HTTP
+          await runServerMode()
+        } else {
+          // DIRECT MODE: Run everything in single process
+          await runDirectMode()
+        }
+      }
+    })
+
+    async function runServerMode() {
+      // Start server like OpenCode does
+      const server = Server.listen({ port: 0, hostname: "127.0.0.1" })
+      let unsub = null
+
+      try {
+        // Create a session
+        const createRes = await fetch(`http://${server.hostname}:${server.port}/session`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({})
+        })
+        const session = await createRes.json()
+        const sessionID = session.id
+
+        if (!sessionID) {
+          throw new Error("Failed to create session")
+        }
+
+        // Subscribe to all bus events to output them in OpenCode format
+        const eventPromise = new Promise((resolve) => {
+          unsub = Bus.subscribeAll((event) => {
+            // Output events in OpenCode JSON format
+            if (event.type === 'message.part.updated') {
+              const part = event.properties.part
+              if (part.sessionID !== sessionID) return
+
+              // Output different event types (pretty-printed for readability)
+              if (part.type === 'step-start') {
+                process.stdout.write(JSON.stringify({
+                  type: 'step_start',
+                  timestamp: Date.now(),
+                  sessionID,
+                  part
+                }, null, 2) + EOL)
+              }
+
+              if (part.type === 'step-finish') {
+                process.stdout.write(JSON.stringify({
+                  type: 'step_finish',
+                  timestamp: Date.now(),
+                  sessionID,
+                  part
+                }, null, 2) + EOL)
+              }
+
+              if (part.type === 'text' && part.time?.end) {
+                process.stdout.write(JSON.stringify({
+                  type: 'text',
+                  timestamp: Date.now(),
+                  sessionID,
+                  part
+                }, null, 2) + EOL)
+              }
+
+              if (part.type === 'tool' && part.state.status === 'completed') {
+                process.stdout.write(JSON.stringify({
+                  type: 'tool_use',
+                  timestamp: Date.now(),
+                  sessionID,
+                  part
+                }, null, 2) + EOL)
+              }
+            }
+
+            // Handle session idle to know when to stop
+            if (event.type === 'session.idle' && event.properties.sessionID === sessionID) {
+              resolve()
+            }
+
+            // Handle errors
+            if (event.type === 'session.error') {
+              const props = event.properties
+              if (props.sessionID !== sessionID || !props.error) return
+              process.stdout.write(JSON.stringify({
+                type: 'error',
+                timestamp: Date.now(),
+                sessionID,
+                error: props.error
+              }, null, 2) + EOL)
+            }
+          })
+        })
+
+        // Send message to session with specified model (default: opencode/grok-code)
+        const message = request.message || "hi"
+        const parts = [{ type: "text", text: message }]
+
+        // Start the prompt (don't wait for response, events come via Bus)
+        fetch(`http://${server.hostname}:${server.port}/session/${sessionID}/message`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            parts,
+            model: {
+              providerID,
+              modelID
+            },
+            system: systemMessage,
+            appendSystem: appendSystemMessage
+          })
+        }).catch(() => {
+          // Ignore errors, we're listening to events
+        })
+
+        // Wait for session to become idle
+        await eventPromise
+      } finally {
+        // Always clean up resources
+        if (unsub) unsub()
+        server.stop()
+        await Instance.dispose()
+      }
+    }
+
+    async function runDirectMode() {
+      // DIRECT MODE: Run in single process without server
+      let unsub = null
+
+      try {
+        // Create a session directly
+        const session = await Session.createNext({
+          directory: process.cwd()
+        })
+        const sessionID = session.id
+
+        // Subscribe to all bus events to output them in OpenCode format
+        const eventPromise = new Promise((resolve) => {
+          unsub = Bus.subscribeAll((event) => {
+            // Output events in OpenCode JSON format
+            if (event.type === 'message.part.updated') {
+              const part = event.properties.part
+              if (part.sessionID !== sessionID) return
+
+              // Output different event types (pretty-printed for readability)
+              if (part.type === 'step-start') {
+                process.stdout.write(JSON.stringify({
+                  type: 'step_start',
+                  timestamp: Date.now(),
+                  sessionID,
+                  part
+                }, null, 2) + EOL)
+              }
+
+              if (part.type === 'step-finish') {
+                process.stdout.write(JSON.stringify({
+                  type: 'step_finish',
+                  timestamp: Date.now(),
+                  sessionID,
+                  part
+                }, null, 2) + EOL)
+              }
+
+              if (part.type === 'text' && part.time?.end) {
+                process.stdout.write(JSON.stringify({
+                  type: 'text',
+                  timestamp: Date.now(),
+                  sessionID,
+                  part
+                }, null, 2) + EOL)
+              }
+
+              if (part.type === 'tool' && part.state.status === 'completed') {
+                process.stdout.write(JSON.stringify({
+                  type: 'tool_use',
+                  timestamp: Date.now(),
+                  sessionID,
+                  part
+                }, null, 2) + EOL)
+              }
+            }
+
+            // Handle session idle to know when to stop
+            if (event.type === 'session.idle' && event.properties.sessionID === sessionID) {
+              resolve()
+            }
+
+            // Handle errors
+            if (event.type === 'session.error') {
+              const props = event.properties
+              if (props.sessionID !== sessionID || !props.error) return
+              process.stdout.write(JSON.stringify({
+                type: 'error',
+                timestamp: Date.now(),
+                sessionID,
+                error: props.error
+              }, null, 2) + EOL)
+            }
+          })
+        })
+
+        // Send message to session directly
+        const message = request.message || "hi"
+        const parts = [{ type: "text", text: message }]
+
+        // Start the prompt directly without HTTP
+        SessionPrompt.prompt({
+          sessionID,
+          parts,
+          model: {
+            providerID,
+            modelID
+          },
+          system: systemMessage,
+          appendSystem: appendSystemMessage
+        }).catch((error) => {
+          process.stdout.write(JSON.stringify({
+            type: 'error',
+            timestamp: Date.now(),
+            sessionID,
+            error: error instanceof Error ? error.message : String(error)
+          }, null, 2) + EOL)
+        })
+
+        // Wait for session to become idle
+        await eventPromise
+      } finally {
+        // Always clean up resources
+        if (unsub) unsub()
+        await Instance.dispose()
+      }
+    }
+
+    // Explicitly exit to ensure process terminates
+    process.exit(0)
+  } catch (error) {
+    console.error(JSON.stringify({
+      type: 'error',
+      timestamp: Date.now(),
+      error: error instanceof Error ? error.message : String(error)
+    }))
+    process.exit(1)
+  }
+}
+
+main()

package/src/mcp/index.ts

@@ -0,0 +1,289 @@
+import { experimental_createMCPClient } from "@ai-sdk/mcp"
+import { type Tool } from "ai"
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
+import { Config } from "../config/config"
+import { Log } from "../util/log"
+import { NamedError } from "../util/error"
+import z from "zod/v4"
+import { Instance } from "../project/instance"
+import { withTimeout } from "../util/timeout"
+
+export namespace MCP {
+  const log = Log.create({ service: "mcp" })
+
+  export const Failed = NamedError.create(
+    "MCPFailed",
+    z.object({
+      name: z.string(),
+    }),
+  )
+
+  type Client = Awaited<ReturnType<typeof experimental_createMCPClient>>
+
+  export const Status = z
+    .discriminatedUnion("status", [
+      z
+        .object({
+          status: z.literal("connected"),
+        })
+        .meta({
+          ref: "MCPStatusConnected",
+        }),
+      z
+        .object({
+          status: z.literal("disabled"),
+        })
+        .meta({
+          ref: "MCPStatusDisabled",
+        }),
+      z
+        .object({
+          status: z.literal("failed"),
+          error: z.string(),
+        })
+        .meta({
+          ref: "MCPStatusFailed",
+        }),
+    ])
+    .meta({
+      ref: "MCPStatus",
+    })
+  export type Status = z.infer<typeof Status>
+  type MCPClient = Awaited<ReturnType<typeof experimental_createMCPClient>>
+
+  const state = Instance.state(
+    async () => {
+      const cfg = await Config.get()
+      const config = cfg.mcp ?? {}
+      const clients: Record<string, Client> = {}
+      const status: Record<string, Status> = {}
+
+      await Promise.all(
+        Object.entries(config).map(async ([key, mcp]) => {
+          const result = await create(key, mcp).catch(() => undefined)
+          if (!result) return
+
+          status[key] = result.status
+
+          if (result.mcpClient) {
+            clients[key] = result.mcpClient
+          }
+        }),
+      )
+      return {
+        status,
+        clients,
+      }
+    },
+    async (state) => {
+      await Promise.all(
+        Object.values(state.clients).map((client) =>
+          client.close().catch((error) => {
+            log.error("Failed to close MCP client", {
+              error,
+            })
+          }),
+        ),
+      )
+    },
+  )
+
+  export async function add(name: string, mcp: Config.Mcp) {
+    const s = await state()
+    const result = await create(name, mcp)
+    if (!result) {
+      const status = {
+        status: "failed" as const,
+        error: "unknown error",
+      }
+      s.status[name] = status
+      return {
+        status,
+      }
+    }
+    if (!result.mcpClient) {
+      s.status[name] = result.status
+      return {
+        status: s.status,
+      }
+    }
+    s.clients[name] = result.mcpClient
+    s.status[name] = result.status
+
+    return {
+      status: s.status,
+    }
+  }
+
+  async function create(key: string, mcp: Config.Mcp) {
+    if (mcp.enabled === false) {
+      log.info("mcp server disabled", { key })
+      return
+    }
+    log.info("found", { key, type: mcp.type })
+    let mcpClient: MCPClient | undefined
+    let status: Status | undefined = undefined
+
+    if (mcp.type === "remote") {
+      const transports = [
+        {
+          name: "StreamableHTTP",
+          transport: new StreamableHTTPClientTransport(new URL(mcp.url), {
+            requestInit: {
+              headers: mcp.headers,
+            },
+          }),
+        },
+        {
+          name: "SSE",
+          transport: new SSEClientTransport(new URL(mcp.url), {
+            requestInit: {
+              headers: mcp.headers,
+            },
+          }),
+        },
+      ]
+      let lastError: Error | undefined
+      for (const { name, transport } of transports) {
+        const result = await experimental_createMCPClient({
+          name: "opencode",
+          transport,
+        })
+          .then((client) => {
+            log.info("connected", { key, transport: name })
+            mcpClient = client
+            status = { status: "connected" }
+            return true
+          })
+          .catch((error) => {
+            lastError = error instanceof Error ? error : new Error(String(error))
+            log.debug("transport connection failed", {
+              key,
+              transport: name,
+              url: mcp.url,
+              error: lastError.message,
+            })
+            status = {
+              status: "failed" as const,
+              error: lastError.message,
+            }
+            return false
+          })
+        if (result) break
+      }
+    }
+
+    if (mcp.type === "local") {
+      const [cmd, ...args] = mcp.command
+      await experimental_createMCPClient({
+        name: "opencode",
+        transport: new StdioClientTransport({
+          stderr: "ignore",
+          command: cmd,
+          args,
+          env: {
+            ...process.env,
+            ...(cmd === "opencode" ? { BUN_BE_BUN: "1" } : {}),
+            ...mcp.environment,
+          },
+        }),
+      })
+        .then((client) => {
+          mcpClient = client
+          status = {
+            status: "connected",
+          }
+        })
+        .catch((error) => {
+          log.error("local mcp startup failed", {
+            key,
+            command: mcp.command,
+            error: error instanceof Error ? error.message : String(error),
+          })
+          status = {
+            status: "failed" as const,
+            error: error instanceof Error ? error.message : String(error),
+          }
+        })
+    }
+
+    if (!status) {
+      status = {
+        status: "failed" as const,
+        error: "Unknown error",
+      }
+    }
+
+    if (!mcpClient) {
+      return {
+        mcpClient: undefined,
+        status,
+      }
+    }
+
+    const result = await withTimeout(mcpClient.tools(), mcp.timeout ?? 5000).catch((err) => {
+      log.error("failed to get tools from client", { key, error: err })
+      return undefined
+    })
+    if (!result) {
+      await mcpClient.close().catch((error) => {
+        log.error("Failed to close MCP client", {
+          error,
+        })
+      })
+      status = {
+        status: "failed",
+        error: "Failed to get tools",
+      }
+      return {
+        mcpClient: undefined,
+        status: {
+          status: "failed" as const,
+          error: "Failed to get tools",
+        },
+      }
+    }
+
+    log.info("create() successfully created client", { key, toolCount: Object.keys(result).length })
+    return {
+      mcpClient,
+      status,
+    }
+  }
+
+  export async function status() {
+    return state().then((state) => state.status)
+  }
+
+  export async function clients() {
+    return state().then((state) => state.clients)
+  }
+
+  export async function tools() {
+    const result: Record<string, Tool> = {}
+    const s = await state()
+    const clientsSnapshot = await clients()
+    for (const [clientName, client] of Object.entries(clientsSnapshot)) {
+      const tools = await client.tools().catch((e) => {
+        log.error("failed to get tools", { clientName, error: e.message })
+        const failedStatus = {
+          status: "failed" as const,
+          error: e instanceof Error ? e.message : String(e),
+        }
+        s.status[clientName] = failedStatus
+        delete s.clients[clientName]
+      })
+      if (!tools) {
+        continue
+      }
+      for (const [toolName, tool] of Object.entries(tools)) {
+        const sanitizedClientName = clientName.replace(/[^a-zA-Z0-9_-]/g, "_")
+        const sanitizedToolName = toolName.replace(/[^a-zA-Z0-9_-]/g, "_")
+        result[sanitizedClientName + "_" + sanitizedToolName] = tool
+      }
+    }
+    return result
+  }
+}