import codex "github.com/dominicnunez/codex-sdk-go/appserver/protocol"

func run(ctx context.Context, transport codex.Transport) error {
	client := codex.NewClient(transport, codex.WithRequestTimeout(30*time.Second))

	// Initialize handshake
	_, err := client.Initialize(ctx, codex.InitializeParams{
		ClientInfo: codex.ClientInfo{
			Name:    "my-codex-client",
			Version: "1.0.0",
		},
	})
	if err != nil {
		return err
	}

	// Listen for protocol notifications
	client.OnAgentMessageDelta(func(notif codex.AgentMessageDeltaNotification) {
		fmt.Print(notif.Delta)
	})

	// Start a thread and turn
	threadResp, err := client.Thread.Start(ctx, codex.ThreadStartParams{
		Model: codex.Ptr("gpt-4"),
	})
	if err != nil {
		return err
	}

	_, err = client.Turn.Start(ctx, codex.TurnStartParams{
		ThreadID: threadResp.Thread.ID,
		Input: []codex.UserInput{
			&codex.TextUserInput{Text: "What is the capital of France?"},
		},
	})
	return err
}

import (
	"context"
	"fmt"
	osexec "os/exec"

	"github.com/dominicnunez/codex-sdk-go/appserver"
)

func runCodex(ctx context.Context) error {
	binary, err := osexec.LookPath("codex")
	if err != nil {
		return err
	}

	server, err := appserver.StartProcess(ctx, &appserver.ProcessOptions{
		BinaryPath: binary,
	})
	if err != nil {
		return err
	}
	defer server.Close()

	if _, err := server.Initialize(ctx); err != nil {
		return err
	}

	result, err := server.Run(ctx, appserver.RunOptions{
		Prompt: "Summarize this repository.",
	})
	if err != nil {
		return err
	}

	fmt.Println(result.Response)
	return nil
}

import (
	"context"
	"fmt"
	"sync"

	codex "github.com/dominicnunez/codex-sdk-go/appserver/protocol"
	"github.com/dominicnunez/codex-sdk-go/login"
	"github.com/dominicnunez/codex-sdk-go/login/auth"
)

func loginWithAuthTokens(ctx context.Context, client *codex.Client, credentialPath string) error {
	creds, err := login.Login(ctx, login.LoginOptions{
		Config: login.Config{Originator: "my-codex-client"},
		OnAuthURL: func(ctx context.Context, authURL string) error {
			fmt.Println("Open this URL:", authURL)
			return nil
		},
		ManualCode: func(ctx context.Context, prompt login.AuthPrompt) (string, error) {
			fmt.Println(prompt.Message)
			var input string
			_, err := fmt.Scanln(&input)
			return input, err
		},
	})
	if err != nil {
		return err
	}
	if err := auth.SaveCredentials(credentialPath, creds); err != nil {
		return err
	}

	var credsMu sync.Mutex
	client.SetApprovalHandlers(codex.ApprovalHandlers{
		OnChatgptAuthTokensRefresh: func(ctx context.Context, params codex.ChatgptAuthTokensRefreshParams) (codex.ChatgptAuthTokensRefreshResponse, error) {
			credsMu.Lock()
			defer credsMu.Unlock()

			refreshed, err := login.Refresh(ctx, login.Config{Originator: "my-codex-client"}, creds.RefreshToken)
			if err != nil {
				return codex.ChatgptAuthTokensRefreshResponse{}, err
			}
			if err := auth.SaveCredentials(credentialPath, refreshed); err != nil {
				return codex.ChatgptAuthTokensRefreshResponse{}, err
			}
			creds = refreshed

			payload, err := auth.NewAuthTokensRefreshResponse(refreshed)
			if err != nil {
				return codex.ChatgptAuthTokensRefreshResponse{}, err
			}
			return codex.ChatgptAuthTokensRefreshResponse{
				AccessToken:      payload.AccessToken,
				ChatgptAccountID: payload.ChatGPTAccountID,
				ChatgptPlanType:  payload.ChatGPTPlanType,
			}, nil
		},
	})

	credsMu.Lock()
	payload, err := auth.NewAuthTokensLoginParams(creds)
	credsMu.Unlock()
	if err != nil {
		return err
	}

	_, err = client.Account.Login(ctx, &codex.ChatgptAuthTokensLoginAccountParams{
		Type:             payload.Type,
		AccessToken:      payload.AccessToken,
		ChatgptAccountId: payload.ChatGPTAccountID,
		ChatgptPlanType:  payload.ChatGPTPlanType,
	})
	return err
}

client.SetApprovalHandlers(codex.ApprovalHandlers{
	OnFileChangeRequestApproval: func(ctx context.Context, params codex.FileChangeRequestApprovalParams) (codex.FileChangeRequestApprovalResponse, error) {
		return codex.FileChangeRequestApprovalResponse{Decision: "accept"}, nil
	},
	OnCommandExecutionRequestApproval: func(ctx context.Context, params codex.CommandExecutionRequestApprovalParams) (codex.CommandExecutionRequestApprovalResponse, error) {
		return codex.CommandExecutionRequestApprovalResponse{
			Decision: codex.CommandExecutionApprovalDecisionWrapper{Value: "accept"},
		}, nil
	},
})