import path from "path"

import { exec } from "child_process"

import { Filesystem } from "@/util/filesystem"

import * as prompts from "@clack/prompts"

import { map, pipe, sortBy, values } from "remeda"

import { Octokit } from "@octokit/rest"

import { graphql } from "@octokit/graphql"

import * as core from "@actions/core"

import * as github from "@actions/github"

import type { Context } from "@actions/github/lib/context"

import type {

IssueCommentEvent,

IssuesEvent,

PullRequestReviewCommentEvent,

WorkflowDispatchEvent,

WorkflowRunEvent,

PullRequestEvent,

} from "@octokit/webhooks-types"

import { UI } from "../ui"

import { ModelsDev } from "@opencode-ai/core/models-dev"

import { InstanceRef } from "@/effect/instance-ref"

import { SessionShare } from "@/share/session"

import { Session } from "@/session/session"

import type { SessionID } from "../../session/schema"

import { MessageID, PartID } from "../../session/schema"

import { Provider } from "@/provider/provider"

import { MessageV2 } from "../../session/message-v2"

import { EventV2Bridge } from "@/event-v2-bridge"

import { EventV2 } from "@opencode-ai/core/event"

import { SessionPrompt } from "@/session/prompt"

import { Git } from "@/git"

import { setTimeout as sleep } from "node:timers/promises"

import { Process } from "@/util/process"

import { parseGitHubRemote } from "@/util/repository"

import { Effect } from "effect"

import { extractResponseText, formatPromptTooLargeError } from "./github.shared"

type GitHubAuthor = {

login: string

name?: string

type GitHubComment = {

type GitHubReviewComment = GitHubComment & {

path: string

line: number | null

type GitHubCommit = {

type GitHubFile = {

type GitHubReview = {

type GitHubPullRequest = {

type GitHubIssue = {

type PullRequestQueryResponse = {

type IssueQueryResponse = {

const AGENT_USERNAME = "opencode-agent[bot]"

const AGENT_REACTION = "eyes"

const WORKFLOW_FILE = ".github/workflows/opencode.yml"

const USER_EVENTS = ["issue_comment", "pull_request_review_comment", "issues", "pull_request"] as const

const REPO_EVENTS = ["schedule", "workflow_dispatch"] as const

const SUPPORTED_EVENTS = [...USER_EVENTS, ...REPO_EVENTS] as const

type UserEvent = (typeof USER_EVENTS)[number]

type RepoEvent = (typeof REPO_EVENTS)[number]

export const githubInstall = Effect.fn("Cli.github.install")(function* () {

const maybeCtx = yield* InstanceRef

if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")

const ctx = maybeCtx

const modelsDev = yield* ModelsDev.Service

const gitSvc = yield* Git.Service

yield* Effect.promise(async () => {

{

UI.empty()

prompts.intro("Install GitHub agent")

const app = await getAppInfo()

await installGitHubApp()

const providers = await Effect.runPromise(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() {

}

async function getAppInfo() {

}

async function promptProvider() {

}

async function promptModel() {

}

async function installGitHubApp() {

}

async function addWorkflowFiles() {

}

}

})

export const githubRun = Effect.fn("Cli.github.run")(function* (args: { event?: string; token?: string }) {

const ctx = yield* InstanceRef

if (!ctx) return yield* Effect.die("InstanceRef not provided")

const gitSvc = yield* Git.Service

const sessionSvc = yield* Session.Service

const sessionShare = yield* SessionShare.Service

const sessionPrompt = yield* SessionPrompt.Service

const events = yield* EventV2Bridge.Service

const runLocalEffect = <A, E>(effect: Effect.Effect<A, E>) =>

Effect.runPromise(effect.pipe(Effect.provideService(InstanceRef, ctx)))

yield* Effect.promise(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

let githubClientReady = false

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 gitRun = async (args: string[]) => {

}

const gitStatus = (args: string[]) => Effect.runPromise(gitSvc.run(args, { cwd: ctx.worktree }))

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

}

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}` },

})

githubClientReady = true

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 runLocalEffect(

sessionSvc.create({

permission: [

{

permission: "question",

action: "deny",

pattern: "*",

},

],

}),

)

await subscribeSessionEvents()

shareId = await (async () => {

if (share === false) return

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

await runLocalEffect(sessionShare.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 && githubClientReady) {

try {

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

await removeReaction(commentType)

} catch (error) {

console.error("Failed to report error on GitHub:", error)

}

}

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() {

}

function normalizeRunId() {

}

function normalizeShare() {

}

function normalizeUseGithubToken() {

}

function normalizeOidcBaseUrl(): string {

}

function isIssueCommentEvent(

}

function getReviewCommentContext() {

}

async function getUserPrompt() {