id: string

databaseId: string

body: string

author: GitHubAuthor

createdAt: string

oid: string

message: string

author: {

name: string

email: string

}

path: string

additions: number

deletions: number

changeType: string

id: string

databaseId: string

author: GitHubAuthor

body: string

state: string

submittedAt: string

comments: {

nodes: GitHubReviewComment[]

}

title: string

body: string

author: GitHubAuthor

baseRefName: string

headRefName: string

headRefOid: string

createdAt: string

additions: number

deletions: number

state: string

baseRepository: {

nameWithOwner: string

}

headRepository: {

nameWithOwner: string

}

commits: {

totalCount: number

nodes: Array<{

commit: GitHubCommit

}>

}

files: {

nodes: GitHubFile[]

}

comments: {

nodes: GitHubComment[]

}

reviews: {

nodes: GitHubReview[]

}

title: string

body: string

author: GitHubAuthor

createdAt: string

state: string

comments: {

nodes: GitHubComment[]

}

repository: {

pullRequest: GitHubPullRequest

}

repository: {

issue: GitHubIssue

}

const match = url.match(/^(?:(?:https?|ssh):\/\/)?(?:git@)?github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/)

if (!match) return null

return { owner: match[1], repo: match[2] }

const textPart = parts.findLast((p) => p.type === "text")

if (textPart) return textPart.text

// Non-text parts (tools, reasoning, step-start/step-finish, etc.) - signal summary needed

if (parts.length > 0) return null

throw new Error("Failed to parse response: no parts returned")

const fileDetails =

files.length > 0

? `\n\nFiles in prompt:\n${files.map((f) => ` - ${f.filename} (${((f.content.length * 0.75) / 1024).toFixed(0)} KB)`).join("\n")}`

: ""

return `PROMPT_TOO_LARGE: The prompt exceeds the model's context limit.${fileDetails}`

await Instance.provide({

directory: process.cwd(),

async fn() {

{

UI.empty()

prompts.intro("Install GitHub agent")

const app = await getAppInfo()

await installGitHubApp()

const providers = await ModelsDev.get().then((p) => {

// TODO: add guide for copilot, for now just hide it

delete p["github-copilot"]

return p

})

const provider = await promptProvider()

const model = await promptModel()

//const key = await promptKey()

await addWorkflowFiles()

printNextSteps()

function printNextSteps() {

let step2

if (provider === "amazon-bedrock") {

step2 =

"Configure OIDC in AWS - https://docs.github.com/en/actions/how-tos/security-for-github-actions/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services"

} else {

step2 = [

` 2. Add the following secrets in org or repo (${app.owner}/${app.repo}) settings`,

"",

...providers[provider].env.map((e) => ` - ${e}`),

].join("\n")

}

prompts.outro(

[

"Next steps:",

"",

` 1. Commit the \`${WORKFLOW_FILE}\` file and push`,

step2,

"",

" 3. Go to a GitHub issue and comment `/oc summarize` to see the agent in action",

"",

" Learn more about the GitHub agent - https://opencode.ai/docs/github/#usage-examples",

].join("\n"),

)

}

async function getAppInfo() {

const project = Instance.project

if (project.vcs !== "git") {

prompts.log.error(`Could not find git repository. Please run this command from a git repository.`)

throw new UI.CancelledError()

}

// Get repo info

const info = (await git(["remote", "get-url", "origin"], { cwd: Instance.worktree })).text().trim()

const parsed = parseGitHubRemote(info)

if (!parsed) {

prompts.log.error(`Could not find git repository. Please run this command from a git repository.`)

throw new UI.CancelledError()

}

return { owner: parsed.owner, repo: parsed.repo, root: Instance.worktree }

}

async function promptProvider() {

const priority: Record<string, number> = {

opencode: 0,

anthropic: 1,

openai: 2,

google: 3,

}

let provider = await prompts.select({

message: "Select provider",

maxItems: 8,

options: pipe(

providers,

values(),

sortBy(

(x) => priority[x.id] ?? 99,

(x) => x.name ?? x.id,

),

map((x) => ({

label: x.name,

value: x.id,

hint: priority[x.id] === 0 ? "recommended" : undefined,

})),

),

})

if (prompts.isCancel(provider)) throw new UI.CancelledError()

return provider

}

async function promptModel() {

const providerData = providers[provider]!

const model = await prompts.select({

message: "Select model",

maxItems: 8,

options: pipe(

providerData.models,

values(),

sortBy((x) => x.name ?? x.id),

map((x) => ({

label: x.name ?? x.id,

value: x.id,

})),

),

})

if (prompts.isCancel(model)) throw new UI.CancelledError()

return model

}

async function installGitHubApp() {

const s = prompts.spinner()

s.start("Installing GitHub app")

// Get installation

const installation = await getInstallation()

if (installation) return s.stop("GitHub app already installed")

// Open browser

const url = "https://github.com/apps/opencode-agent"

const command =

process.platform === "darwin"

? `open "${url}"`

: process.platform === "win32"

? `start "" "${url}"`

: `xdg-open "${url}"`

exec(command, (error) => {

if (error) {

prompts.log.warn(`Could not open browser. Please visit: ${url}`)

}

})

// Wait for installation

s.message("Waiting for GitHub app to be installed")

const MAX_RETRIES = 120

let retries = 0

do {

const installation = await getInstallation()

if (installation) break

if (retries > MAX_RETRIES) {

s.stop(

`Failed to detect GitHub app installation. Make sure to install the app for the \`${app.owner}/${app.repo}\` repository.`,

)

throw new UI.CancelledError()

}

retries++

await sleep(1000)

} while (true)

s.stop("Installed GitHub app")

async function getInstallation() {

return await fetch(

`https://api.opencode.ai/get_github_app_installation?owner=${app.owner}&repo=${app.repo}`,

)

.then((res) => res.json())

.then((data) => data.installation)

}

}

async function addWorkflowFiles() {

const envStr =

provider === "amazon-bedrock"

? ""

: `\n env:${providers[provider].env.map((e) => `\n ${e}: \${{ secrets.${e} }}`).join("")}`

await Filesystem.write(

path.join(app.root, WORKFLOW_FILE),

`name: opencode

)

prompts.log.success(`Added workflow file: "${WORKFLOW_FILE}"`)

}

}

},

})

yargs

.option("event", {

type: "string",

describe: "GitHub mock event to run the agent for",

})

.option("token", {

type: "string",

describe: "GitHub personal access token (github_pat_********)",

await bootstrap(process.cwd(), async () => {

const isMock = args.token || args.event

const context = isMock ? (JSON.parse(args.event!) as Context) : github.context

if (!SUPPORTED_EVENTS.includes(context.eventName as (typeof SUPPORTED_EVENTS)[number])) {

core.setFailed(`Unsupported event type: ${context.eventName}`)

process.exit(1)

}

// Determine event category for routing

// USER_EVENTS: have actor, issueId, support reactions/comments

// REPO_EVENTS: no actor/issueId, output to logs/PR only

const isUserEvent = USER_EVENTS.includes(context.eventName as UserEvent)

const isRepoEvent = REPO_EVENTS.includes(context.eventName as RepoEvent)

const isCommentEvent = ["issue_comment", "pull_request_review_comment"].includes(context.eventName)

const isIssuesEvent = context.eventName === "issues"

const isScheduleEvent = context.eventName === "schedule"

const isWorkflowDispatchEvent = context.eventName === "workflow_dispatch"

const { providerID, modelID } = normalizeModel()

const variant = process.env["VARIANT"] || undefined

const runId = normalizeRunId()

const share = normalizeShare()

const oidcBaseUrl = normalizeOidcBaseUrl()

const { owner, repo } = context.repo

// For repo events (schedule, workflow_dispatch), payload has no issue/comment data

const payload = context.payload as

| IssueCommentEvent

| IssuesEvent

| PullRequestReviewCommentEvent

| WorkflowDispatchEvent

| WorkflowRunEvent

| PullRequestEvent

const issueEvent = isIssueCommentEvent(payload) ? payload : undefined

// workflow_dispatch has an actor (the user who triggered it), schedule does not

const actor = isScheduleEvent ? undefined : context.actor

const issueId = isRepoEvent

? undefined

: context.eventName === "issue_comment" || context.eventName === "issues"

? (payload as IssueCommentEvent | IssuesEvent).issue.number

: (payload as PullRequestEvent | PullRequestReviewCommentEvent).pull_request.number

const runUrl = `/${owner}/${repo}/actions/runs/${runId}`

const shareBaseUrl = isMock ? "https://dev.opencode.ai" : "https://opencode.ai"

let appToken: string

let octoRest: Octokit

let octoGraph: typeof graphql

let gitConfig: string

let session: { id: SessionID; title: string; version: string }

let shareId: string | undefined

let exitCode = 0

type PromptFiles = Awaited<ReturnType<typeof getUserPrompt>>["promptFiles"]

const triggerCommentId = isCommentEvent

? (payload as IssueCommentEvent | PullRequestReviewCommentEvent).comment.id

: undefined

const useGithubToken = normalizeUseGithubToken()

const commentType = isCommentEvent

? context.eventName === "pull_request_review_comment"

? "pr_review"

: "issue"

: undefined

const gitText = async (args: string[]) => {

const result = await git(args, { cwd: Instance.worktree })

if (result.exitCode !== 0) {

throw new Process.RunFailedError(["git", ...args], result.exitCode, result.stdout, result.stderr)

}

return result.text().trim()

}

const gitRun = async (args: string[]) => {

const result = await git(args, { cwd: Instance.worktree })

if (result.exitCode !== 0) {

throw new Process.RunFailedError(["git", ...args], result.exitCode, result.stdout, result.stderr)

}

return result

}

const gitStatus = (args: string[]) => git(args, { cwd: Instance.worktree })

const commitChanges = async (summary: string, actor?: string) => {

const args = ["commit", "-m", summary]

if (actor) args.push("-m", `Co-authored-by: ${actor} <${actor}@users.noreply.github.com>`)

await gitRun(args)

}

try {

if (useGithubToken) {

const githubToken = process.env["GITHUB_TOKEN"]

if (!githubToken) {

throw new Error(

"GITHUB_TOKEN environment variable is not set. When using use_github_token, you must provide GITHUB_TOKEN.",

)

}

appToken = githubToken

} else {

const actionToken = isMock ? args.token! : await getOidcToken()

appToken = await exchangeForAppToken(actionToken)

}

octoRest = new Octokit({ auth: appToken })

octoGraph = graphql.defaults({

headers: { authorization: `token ${appToken}` },

})

const { userPrompt, promptFiles } = await getUserPrompt()

if (!useGithubToken) {

await configureGit(appToken)

}

// Skip permission check and reactions for repo events (no actor to check, no issue to react to)

if (isUserEvent) {

await assertPermissions()

await addReaction(commentType)

}

// Setup opencode session

const repoData = await fetchRepo()

session = await Session.create({

permission: [

{

permission: "question",

action: "deny",

pattern: "*",

},

],

})

subscribeSessionEvents()

shareId = await (async () => {

if (share === false) return

if (!share && repoData.data.private) return

await Session.share(session.id)

return session.id.slice(-8)

})()

console.log("opencode session", session.id)

// Handle event types:

// REPO_EVENTS (schedule, workflow_dispatch): no issue/PR context, output to logs/PR only

// USER_EVENTS on PR (pull_request, pull_request_review_comment, issue_comment on PR): work on PR branch

// USER_EVENTS on Issue (issue_comment on issue, issues): create new branch, may create PR

if (isRepoEvent) {

// Repo event - no issue/PR context, output goes to logs

if (isWorkflowDispatchEvent && actor) {

console.log(`Triggered by: ${actor}`)

}

const branchPrefix = isWorkflowDispatchEvent ? "dispatch" : "schedule"

const branch = await checkoutNewBranch(branchPrefix)

const head = await gitText(["rev-parse", "HEAD"])

const response = await chat(userPrompt, promptFiles)

const { dirty, uncommittedChanges, switched } = await branchIsDirty(head, branch)

if (switched) {

// Agent switched branches (likely created its own branch/PR)

console.log("Agent managed its own branch, skipping infrastructure push/PR")

console.log("Response:", response)

} else if (dirty) {

const summary = await summarize(response)

// workflow_dispatch has an actor for co-author attribution, schedule does not

await pushToNewBranch(summary, branch, uncommittedChanges, isScheduleEvent)

const triggerType = isWorkflowDispatchEvent ? "workflow_dispatch" : "scheduled workflow"

const pr = await createPR(

repoData.data.default_branch,

branch,

summary,

`${response}\n\nTriggered by ${triggerType}${footer({ image: true })}`,

)

if (pr) {

console.log(`Created PR #${pr}`)

} else {

console.log("Skipped PR creation (no new commits)")

}

} else {

console.log("Response:", response)

}

} else if (

["pull_request", "pull_request_review_comment"].includes(context.eventName) ||

issueEvent?.issue.pull_request

) {

const prData = await fetchPR()

// Local PR

if (prData.headRepository.nameWithOwner === prData.baseRepository.nameWithOwner) {

await checkoutLocalBranch(prData)

const head = await gitText(["rev-parse", "HEAD"])

const dataPrompt = buildPromptDataForPR(prData)

const response = await chat(`${userPrompt}\n\n${dataPrompt}`, promptFiles)

const { dirty, uncommittedChanges, switched } = await branchIsDirty(head, prData.headRefName)

if (switched) {

console.log("Agent managed its own branch, skipping infrastructure push")

}

if (dirty && !switched) {

const summary = await summarize(response)

await pushToLocalBranch(summary, uncommittedChanges)

}

const hasShared = prData.comments.nodes.some((c) => c.body.includes(`${shareBaseUrl}/s/${shareId}`))

await createComment(`${response}${footer({ image: !hasShared })}`)

await removeReaction(commentType)

}

// Fork PR

else {

const forkBranch = await checkoutForkBranch(prData)

const head = await gitText(["rev-parse", "HEAD"])

const dataPrompt = buildPromptDataForPR(prData)

const response = await chat(`${userPrompt}\n\n${dataPrompt}`, promptFiles)

const { dirty, uncommittedChanges, switched } = await branchIsDirty(head, forkBranch)

if (switched) {

console.log("Agent managed its own branch, skipping infrastructure push")

}

if (dirty && !switched) {

const summary = await summarize(response)

await pushToForkBranch(summary, prData, uncommittedChanges)

}

const hasShared = prData.comments.nodes.some((c) => c.body.includes(`${shareBaseUrl}/s/${shareId}`))

await createComment(`${response}${footer({ image: !hasShared })}`)

await removeReaction(commentType)

}

}

// Issue

else {

const branch = await checkoutNewBranch("issue")

const head = await gitText(["rev-parse", "HEAD"])

const issueData = await fetchIssue()

const dataPrompt = buildPromptDataForIssue(issueData)

const response = await chat(`${userPrompt}\n\n${dataPrompt}`, promptFiles)

const { dirty, uncommittedChanges, switched } = await branchIsDirty(head, branch)

if (switched) {

// Agent switched branches (likely created its own branch/PR).

// Don't push the stale infrastructure branch — just comment.

await createComment(`${response}${footer({ image: true })}`)

await removeReaction(commentType)

} else if (dirty) {

const summary = await summarize(response)

await pushToNewBranch(summary, branch, uncommittedChanges, false)

const pr = await createPR(

repoData.data.default_branch,

branch,

summary,

`${response}\n\nCloses #${issueId}${footer({ image: true })}`,

)

if (pr) {

await createComment(`Created PR #${pr}${footer({ image: true })}`)

} else {

await createComment(`${response}${footer({ image: true })}`)

}

await removeReaction(commentType)

} else {

await createComment(`${response}${footer({ image: true })}`)

await removeReaction(commentType)

}

}

} catch (e: any) {

exitCode = 1

console.error(e instanceof Error ? e.message : String(e))

let msg = e

if (e instanceof Process.RunFailedError) {

msg = e.stderr.toString()

} else if (e instanceof Error) {

msg = e.message

}

if (isUserEvent) {

await createComment(`${msg}${footer()}`)

await removeReaction(commentType)

}

core.setFailed(msg)

// Also output the clean error message for the action to capture

//core.setOutput("prepare_error", e.message);

} finally {

if (!useGithubToken) {

await restoreGitConfig()

await revokeAppToken()

}

}

process.exit(exitCode)

function normalizeModel() {

const value = process.env["MODEL"]

if (!value) throw new Error(`Environment variable "MODEL" is not set`)

const { providerID, modelID } = Provider.parseModel(value)

if (!providerID.length || !modelID.length)

throw new Error(`Invalid model ${value}. Model must be in the format "provider/model".`)

return { providerID, modelID }

}

function normalizeRunId() {

const value = process.env["GITHUB_RUN_ID"]

if (!value) throw new Error(`Environment variable "GITHUB_RUN_ID" is not set`)

return value

}

function normalizeShare() {

const value = process.env["SHARE"]

if (!value) return undefined

if (value === "true") return true

if (value === "false") return false

throw new Error(`Invalid share value: ${value}. Share must be a boolean.`)

}

function normalizeUseGithubToken() {

const value = process.env["USE_GITHUB_TOKEN"]

if (!value) return false

if (value === "true") return true

if (value === "false") return false

throw new Error(`Invalid use_github_token value: ${value}. Must be a boolean.`)

}

function normalizeOidcBaseUrl(): string {

const value = process.env["OIDC_BASE_URL"]

if (!value) return "https://api.opencode.ai"

return value.replace(/\/+$/, "")

}

function isIssueCommentEvent(

event:

| IssueCommentEvent

| IssuesEvent

| PullRequestReviewCommentEvent

| WorkflowDispatchEvent

| WorkflowRunEvent

| PullRequestEvent,

): event is IssueCommentEvent {

return "issue" in event && "comment" in event

}

function getReviewCommentContext() {

if (context.eventName !== "pull_request_review_comment") {

return null

}

const reviewPayload = payload as PullRequestReviewCommentEvent

return {

file: reviewPayload.comment.path,

diffHunk: reviewPayload.comment.diff_hunk,

line: reviewPayload.comment.line,

originalLine: reviewPayload.comment.original_line,

position: reviewPayload.comment.position,

commitId: reviewPayload.comment.commit_id,

originalCommitId: reviewPayload.comment.original_commit_id,

}

}

async function getUserPrompt() {

const customPrompt = process.env["PROMPT"]

// For repo events and issues events, PROMPT is required since there's no comment to extract from

if (isRepoEvent || isIssuesEvent) {

if (!customPrompt) {

const eventType = isRepoEvent ? "scheduled and workflow_dispatch" : "issues"

throw new Error(`PROMPT input is required for ${eventType} events`)

}

return { userPrompt: customPrompt, promptFiles: [] }

}

if (customPrompt) {

return { userPrompt: customPrompt, promptFiles: [] }

}

const reviewContext = getReviewCommentContext()

const mentions = (process.env["MENTIONS"] || "/opencode,/oc")

.split(",")

.map((m) => m.trim().toLowerCase())

.filter(Boolean)

let prompt = (() => {

if (!isCommentEvent) {

return "Review this pull request"

}

const body = (payload as IssueCommentEvent | PullRequestReviewCommentEvent).comment.body.trim()

const bodyLower = body.toLowerCase()

if (mentions.some((m) => bodyLower === m)) {

if (reviewContext) {

return `Review this code change and suggest improvements for the commented lines:\n\nFile: ${reviewContext.file}\nLines: ${reviewContext.line}\n\n${reviewContext.diffHunk}`

}

return "Summarize this thread"

}

if (mentions.some((m) => bodyLower.includes(m))) {

if (reviewContext) {

return `${body}\n\nContext: You are reviewing a comment on file "${reviewContext.file}" at line ${reviewContext.line}.\n\nDiff context:\n${reviewContext.diffHunk}`

}

return body

}

throw new Error(`Comments must mention ${mentions.map((m) => "`" + m + "`").join(" or ")}`)

})()

// Handle images

const imgData: {

filename: string

mime: string

content: string

start: number

end: number

replacement: string

}[] = []

// Search for files

// ie. <img alt="Image" src="https://github.com/user-attachments/assets/xxxx" />

// ie. [api.json](https://github.com/user-attachments/files/21433810/api.json)

// ie. 

const mdMatches = prompt.matchAll(/!?\[.*?\]\((https:\/\/github\.com\/user-attachments\/[^)]+)\)/gi)