@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.5

package/src/cli/cmd/import.ts

@@ -0,0 +1,208 @@
+import type { Argv } from "yargs"
+import type { Session as SDKSession, Message, Part } from "@sleepy-ai/sdk/v2"
+import { Session } from "../../session"
+import { MessageV2 } from "../../session/message-v2"
+import { cmd } from "./cmd"
+import { bootstrap } from "../bootstrap"
+import { Database } from "../../storage"
+import { SessionTable, MessageTable, PartTable } from "../../session/session.sql"
+import { Instance } from "../../project/instance"
+import { ShareNext } from "../../share"
+import { EOL } from "os"
+import { Filesystem } from "../../util"
+import { AppRuntime } from "@/effect/app-runtime"
+
+/** Discriminated union returned by the ShareNext API (GET /api/shares/:id/data) */
+export type ShareData =
+  | { type: "session"; data: SDKSession }
+  | { type: "message"; data: Message }
+  | { type: "part"; data: Part }
+  | { type: "session_diff"; data: unknown }
+  | { type: "model"; data: unknown }
+
+/** Extract share ID from a share URL like https://opncd.ai/share/abc123 */
+export function parseShareUrl(url: string): string | null {
+  const match = url.match(/^https?:\/\/[^/]+\/share\/([a-zA-Z0-9_-]+)$/)
+  return match ? match[1] : null
+}
+
+export function shouldAttachShareAuthHeaders(shareUrl: string, accountBaseUrl: string): boolean {
+  try {
+    return new URL(shareUrl).origin === new URL(accountBaseUrl).origin
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Transform ShareNext API response (flat array) into the nested structure for local file storage.
+ *
+ * The API returns a flat array: [session, message, message, part, part, ...]
+ * Local storage expects: { info: session, messages: [{ info: message, parts: [part, ...] }, ...] }
+ *
+ * This groups parts by their messageID to reconstruct the hierarchy before writing to disk.
+ */
+export function transformShareData(shareData: ShareData[]): {
+  info: SDKSession
+  messages: Array<{ info: Message; parts: Part[] }>
+} | null {
+  const sessionItem = shareData.find((d) => d.type === "session")
+  if (!sessionItem) return null
+
+  const messageMap = new Map<string, Message>()
+  const partMap = new Map<string, Part[]>()
+
+  for (const item of shareData) {
+    if (item.type === "message") {
+      messageMap.set(item.data.id, item.data)
+    } else if (item.type === "part") {
+      if (!partMap.has(item.data.messageID)) {
+        partMap.set(item.data.messageID, [])
+      }
+      partMap.get(item.data.messageID)!.push(item.data)
+    }
+  }
+
+  if (messageMap.size === 0) return null
+
+  return {
+    info: sessionItem.data,
+    messages: Array.from(messageMap.values()).map((msg) => ({
+      info: msg,
+      parts: partMap.get(msg.id) ?? [],
+    })),
+  }
+}
+
+export const ImportCommand = cmd({
+  command: "import <file>",
+  describe: "import session data from JSON file or URL",
+  builder: (yargs: Argv) => {
+    return yargs.positional("file", {
+      describe: "path to JSON file or share URL",
+      type: "string",
+      demandOption: true,
+    })
+  },
+  handler: async (args) => {
+    await bootstrap(process.cwd(), async () => {
+      let exportData:
+        | {
+            info: SDKSession
+            messages: Array<{
+              info: Message
+              parts: Part[]
+            }>
+          }
+        | undefined
+
+      const isUrl = args.file.startsWith("http://") || args.file.startsWith("https://")
+
+      if (isUrl) {
+        const slug = parseShareUrl(args.file)
+        if (!slug) {
+          const baseUrl = await AppRuntime.runPromise(ShareNext.Service.use((svc) => svc.url()))
+          process.stdout.write(`Invalid URL format. Expected: ${baseUrl}/share/<slug>`)
+          process.stdout.write(EOL)
+          return
+        }
+
+        const parsed = new URL(args.file)
+        const baseUrl = parsed.origin
+        const req = await AppRuntime.runPromise(ShareNext.Service.use((svc) => svc.request()))
+        const headers = shouldAttachShareAuthHeaders(args.file, req.baseUrl) ? req.headers : {}
+
+        const dataPath = req.api.data(slug)
+        let response = await fetch(`${baseUrl}${dataPath}`, {
+          headers,
+        })
+
+        if (!response.ok && dataPath !== `/api/share/${slug}/data`) {
+          response = await fetch(`${baseUrl}/api/share/${slug}/data`, {
+            headers,
+          })
+        }
+
+        if (!response.ok) {
+          process.stdout.write(`Failed to fetch share data: ${response.statusText}`)
+          process.stdout.write(EOL)
+          return
+        }
+
+        const shareData: ShareData[] = await response.json()
+        const transformed = transformShareData(shareData)
+
+        if (!transformed) {
+          process.stdout.write(`Share not found or empty: ${slug}`)
+          process.stdout.write(EOL)
+          return
+        }
+
+        exportData = transformed
+      } else {
+        exportData = await Filesystem.readJson<NonNullable<typeof exportData>>(args.file).catch(() => undefined)
+        if (!exportData) {
+          process.stdout.write(`File not found: ${args.file}`)
+          process.stdout.write(EOL)
+          return
+        }
+      }
+
+      if (!exportData) {
+        process.stdout.write(`Failed to read session data`)
+        process.stdout.write(EOL)
+        return
+      }
+
+      const info = Session.Info.parse({
+        ...exportData.info,
+        projectID: Instance.project.id,
+      })
+      const row = Session.toRow(info)
+      Database.use((db) =>
+        db
+          .insert(SessionTable)
+          .values(row)
+          .onConflictDoUpdate({ target: SessionTable.id, set: { project_id: row.project_id } })
+          .run(),
+      )
+
+      for (const msg of exportData.messages) {
+        const msgInfo = MessageV2.Info.parse(msg.info)
+        const { id, sessionID: _, ...msgData } = msgInfo
+        Database.use((db) =>
+          db
+            .insert(MessageTable)
+            .values({
+              id,
+              session_id: row.id,
+              time_created: msgInfo.time?.created ?? Date.now(),
+              data: msgData,
+            })
+            .onConflictDoNothing()
+            .run(),
+        )
+
+        for (const part of msg.parts) {
+          const partInfo = MessageV2.Part.parse(part)
+          const { id: partId, sessionID: _s, messageID, ...partData } = partInfo
+          Database.use((db) =>
+            db
+              .insert(PartTable)
+              .values({
+                id: partId,
+                message_id: messageID,
+                session_id: row.id,
+                data: partData,
+              })
+              .onConflictDoNothing()
+              .run(),
+          )
+        }
+      }
+
+      process.stdout.write(`Imported session: ${exportData.info.id}`)
+      process.stdout.write(EOL)
+    })
+  },
+})

package/src/cli/cmd/init.ts

@@ -0,0 +1,97 @@
+import { cmd } from "./cmd"
+import fs from "fs/promises"
+import path from "path"
+import { UI } from "../ui"
+
+const SLEEPY_JSON_TEMPLATE = JSON.stringify(
+  {
+    $schema: "https://opencode.ai/config.json",
+    model: "anthropic/claude-sonnet-4-20250514",
+    small_model: "anthropic/claude-sonnet-4-20250514",
+    mcp: {
+      supabase: {
+        type: "remote",
+        url: "https://mcp.supabase.com/sse",
+      },
+      websearch: {
+        type: "local",
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-brave-search"],
+        env: {
+          BRAVE_API_KEY: "YOUR_BRAVE_API_KEY",
+        },
+      },
+    },
+  },
+  null,
+  2,
+)
+
+const AGENTS_MD_TEMPLATE = `# AGENTS.md
+
+## Workflow Guidelines
+
+### Test-Driven Development (TDD)
+
+All new features and bug fixes MUST follow TDD:
+
+1. **Write a failing test first** — define the expected behavior before implementation.
+2. **Implement the minimum code** — make the test pass with the simplest possible change.
+3. **Refactor** — clean up while keeping tests green.
+4. **Never skip tests** — untested code is incomplete code.
+
+### Commit Guidelines
+
+- Write clear, concise commit messages describing the change.
+- Each commit should be a single logical unit of work.
+- Include context in the commit body when the subject line is insufficient.
+- Reference issue numbers where applicable.
+
+### Code Quality
+
+- Prefer functional array methods (flatMap, filter, map) over for loops.
+- Use type inference; avoid explicit type annotations unless necessary.
+- Prefer \`const\` over \`let\`. Use ternaries or early returns instead of reassignment.
+- Avoid \`try\`/\`catch\` where possible; prefer Effect-based error handling.
+- Avoid \`else\` statements; prefer early returns.
+
+### Testing
+
+- Avoid mocks as much as possible; test actual implementation.
+- Each test should be self-contained and deterministic.
+- Use \`await using\` for automatic cleanup of temporary resources.
+- Run \`bun typecheck\` from the package directory before committing.
+
+### Dependencies
+
+- Keep dependencies minimal and well-justified.
+- Prefer built-in APIs over external packages when functionality overlaps.
+- Pin exact versions for production dependencies.
+`
+
+export const InitCommand = cmd({
+  command: "init",
+  describe: "Initialize a new Sleepy project in the current directory",
+  async handler() {
+    UI.empty()
+    UI.println(UI.Style.TEXT_HIGHLIGHT_BOLD + "Initializing Sleepy project..." + UI.Style.TEXT_NORMAL)
+
+    const cwd = process.cwd()
+    const sleepyJsonPath = path.join(cwd, "sleepy.json")
+    const agentsMdPath = path.join(cwd, "AGENTS.md")
+
+    // Write sleepy.json
+    await fs.writeFile(sleepyJsonPath, SLEEPY_JSON_TEMPLATE, "utf-8")
+    UI.println(UI.Style.TEXT_DIM + "  Created sleepy.json" + UI.Style.TEXT_NORMAL)
+
+    // Write AGENTS.md
+    await fs.writeFile(agentsMdPath, AGENTS_MD_TEMPLATE, "utf-8")
+    UI.println(UI.Style.TEXT_DIM + "  Created AGENTS.md" + UI.Style.TEXT_NORMAL)
+
+    UI.println("")
+    UI.println(UI.Style.TEXT_SUCCESS_BOLD + "✓ Project initialized!" + UI.Style.TEXT_NORMAL)
+    UI.println(UI.Style.TEXT_DIM + "  Configuration saved to: " + UI.Style.TEXT_NORMAL + sleepyJsonPath)
+    UI.println(UI.Style.TEXT_DIM + "  Workflow guidelines saved to: " + UI.Style.TEXT_NORMAL + agentsMdPath)
+    UI.println("")
+  },
+})

package/src/cli/cmd/login.ts

@@ -0,0 +1,402 @@
+import { cmd } from "./cmd"
+import { createServer, type Server, type IncomingMessage, type ServerResponse } from "http"
+import open from "open"
+import fs from "fs/promises"
+import path from "path"
+import { setTimeout as sleep } from "timers/promises"
+import { Global } from "../../global"
+import { UI } from "../ui"
+import * as prompts from "@clack/prompts"
+
+const PORT = 40821
+
+export const getDashboardUrl = (): string => process.env.SLEEPY_DASHBOARD_URL || "https://www.sleepyai.org"
+
+export const buildAuthorizeUrl = (dashboardUrl: string): string => {
+  const params = new URLSearchParams({
+    client_id: "sleepy-cli",
+    redirect_uri: `http://localhost:${PORT}/callback`,
+    response_type: "code",
+  })
+  return `${dashboardUrl}/api/auth/oauth/authorize?${params.toString()}`
+}
+
+export const exchangeCodeForToken = async (code: string, dashboardUrl: string) => {
+  const response = await fetch(`${dashboardUrl}/api/auth/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ code, client_id: "sleepy-cli" }),
+  })
+
+  if (!response.ok) {
+    throw new Error(`Token exchange failed: ${response.statusText}`)
+  }
+
+  return response.json() as Promise<{
+    access_token: string
+    refresh_token: string
+    expires_in: number
+    endpoint: string
+    tier: string
+    email: string
+  }>
+}
+
+export const writeConfig = async (
+  configPath: string,
+  data: { access_token: string; refresh_token?: string; expires_at?: number; endpoint: string; tier: string; email: string; dashboard_url?: string }
+) => {
+  await fs.mkdir(path.dirname(configPath), { recursive: true })
+  await fs.writeFile(configPath, JSON.stringify(data, null, 2), "utf-8")
+}
+
+let codeResolver: ((code: string) => void) | null = null
+let codePromise: Promise<string> | null = null
+
+export const waitForCode = (): Promise<string> => {
+  if (!codePromise) {
+    codePromise = new Promise<string>((resolve) => {
+      codeResolver = resolve
+    })
+  }
+  return codePromise
+}
+
+export const startLoginServer = (): Promise<Server> => {
+  return new Promise((resolve) => {
+    const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+      const url = new URL(req.url || "/", `http://localhost:${PORT}`)
+
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code")
+
+        if (code) {
+          res.writeHead(200, { "Content-Type": "text/html" })
+          res.end(`
+            <!DOCTYPE html>
+            <html>
+            <head>
+              <title>Sleepy CLI - Login Successful</title>
+              <style>
+                body {
+                  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+                  display: flex;
+                  justify-content: center;
+                  align-items: center;
+                  min-height: 100vh;
+                  margin: 0;
+                  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                }
+                .card {
+                  background: white;
+                  padding: 40px;
+                  border-radius: 12px;
+                  box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+                  text-align: center;
+                }
+                .success {
+                  color: #10b981;
+                  font-size: 48px;
+                  margin-bottom: 20px;
+                }
+                h1 {
+                  color: #1f2937;
+                  margin: 0 0 10px 0;
+                }
+                p {
+                  color: #6b7280;
+                  margin: 0;
+                }
+              </style>
+            </head>
+            <body>
+              <div class="card">
+                <div class="success">✓</div>
+                <h1>Login Successful!</h1>
+                <p>You can close this window and return to the CLI.</p>
+              </div>
+            </body>
+            </html>
+          `)
+
+          if (codeResolver) {
+            codeResolver(code)
+            codeResolver = null
+            codePromise = null
+          }
+        } else {
+          res.writeHead(400, { "Content-Type": "text/html" })
+          res.end(`
+            <!DOCTYPE html>
+            <html>
+            <head>
+              <title>Sleepy CLI - Login Failed</title>
+              <style>
+                body {
+                  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+                  display: flex;
+                  justify-content: center;
+                  align-items: center;
+                  min-height: 100vh;
+                  margin: 0;
+                  background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
+                }
+                .card {
+                  background: white;
+                  padding: 40px;
+                  border-radius: 12px;
+                  box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+                  text-align: center;
+                }
+                .error {
+                  color: #ef4444;
+                  font-size: 48px;
+                  margin-bottom: 20px;
+                }
+                h1 {
+                  color: #1f2937;
+                  margin: 0 0 10px 0;
+                }
+                p {
+                  color: #6b7280;
+                  margin: 0;
+                }
+              </style>
+            </head>
+            <body>
+              <div class="card">
+                <div class="error">✗</div>
+                <h1>Login Failed</h1>
+                <p>No authorization code received. Please try again.</p>
+              </div>
+            </body>
+            </html>
+          `)
+        }
+      } else {
+        res.writeHead(404, { "Content-Type": "text/plain" })
+        res.end("Not Found")
+      }
+    })
+
+    server.listen(PORT, () => {
+      resolve(server)
+    })
+  })
+}
+
+const handleAuthCodeFlow = async () => {
+  UI.empty()
+  UI.println(UI.Style.TEXT_HIGHLIGHT_BOLD + "Starting OAuth login..." + UI.Style.TEXT_NORMAL)
+
+  const dashboardUrl = getDashboardUrl()
+  const authorizeUrl = buildAuthorizeUrl(dashboardUrl)
+
+  const server = await startLoginServer()
+
+  UI.println(UI.Style.TEXT_DIM + "Waiting for authorization at:" + UI.Style.TEXT_NORMAL)
+  UI.println(authorizeUrl)
+  UI.println("")
+  UI.println(UI.Style.TEXT_DIM + "Opening browser..." + UI.Style.TEXT_NORMAL)
+
+  try {
+    await open(authorizeUrl)
+  } catch (e) {
+    UI.println(UI.Style.TEXT_WARNING + "Could not open browser automatically." + UI.Style.TEXT_NORMAL)
+    UI.println(UI.Style.TEXT_DIM + "Please open the URL above in your browser." + UI.Style.TEXT_NORMAL)
+  }
+
+  UI.println(UI.Style.TEXT_DIM + "Waiting for authorization..." + UI.Style.TEXT_NORMAL)
+
+  const code = await waitForCode()
+  server.close()
+
+  UI.println(UI.Style.TEXT_DIM + "Exchanging code for token..." + UI.Style.TEXT_NORMAL)
+
+  const tokenData = await exchangeCodeForToken(code, dashboardUrl)
+
+  const configPath = path.join(Global.Path.config, "gateway.json")
+  await writeConfig(configPath, {
+    access_token: tokenData.access_token,
+    refresh_token: tokenData.refresh_token,
+    expires_at: Date.now() + (tokenData.expires_in ?? 3600) * 1000,
+    endpoint: tokenData.endpoint,
+    tier: tokenData.tier,
+    email: tokenData.email,
+    dashboard_url: dashboardUrl,
+  })
+
+  UI.println("")
+  UI.println(UI.Style.TEXT_SUCCESS_BOLD + "✓ Login successful!" + UI.Style.TEXT_NORMAL)
+  UI.println(UI.Style.TEXT_DIM + "  Email: " + UI.Style.TEXT_NORMAL + tokenData.email)
+  UI.println(UI.Style.TEXT_DIM + "  Tier: " + UI.Style.TEXT_NORMAL + tokenData.tier)
+  UI.println(UI.Style.TEXT_DIM + "  Config saved to: " + UI.Style.TEXT_NORMAL + configPath)
+  UI.println("")
+}
+
+export interface DeviceCodeResponse {
+  device_code: string
+  user_code: string
+  verification_uri: string
+  verification_uri_complete: string
+  interval: number
+}
+
+export interface DeviceTokenResponse {
+  access_token: string
+  refresh_token: string
+  expires_in: number
+  endpoint: string
+  tier: string
+  email: string
+}
+
+export const startDeviceFlow = async (dashboardUrl: string): Promise<DeviceCodeResponse> => {
+  const res = await fetch(`${dashboardUrl}/api/auth/oauth/device`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ client_id: "sleepy-cli" }),
+  })
+  if (!res.ok) throw new Error("Failed to start device login")
+  return res.json()
+}
+
+export const pollDeviceToken = async (
+  dashboardUrl: string,
+  deviceCode: string,
+): Promise<DeviceTokenResponse> => {
+  const res = await fetch(`${dashboardUrl}/api/auth/oauth/device/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: deviceCode,
+      client_id: "sleepy-cli",
+    }),
+  })
+
+  if (res.ok) return res.json()
+
+  let body: Record<string, unknown> | null = null
+  try {
+    body = await res.json()
+  } catch {
+    const text = await res.text().catch(() => "")
+    throw Object.assign(new Error(text ? `Server error: ${text.substring(0, 200)}` : `HTTP ${res.status}`), {
+      code: "server_error",
+    })
+  }
+
+  const err: any = new Error((body?.error as string) || "Unknown error")
+  err.code = body?.error ?? "server_error"
+  throw err
+}
+
+const handleDeviceFlow = async () => {
+  UI.empty()
+  UI.println(UI.Style.TEXT_HIGHLIGHT_BOLD + "Starting device login..." + UI.Style.TEXT_NORMAL)
+
+  const dashboardUrl = getDashboardUrl()
+  let deviceData: DeviceCodeResponse
+  try {
+    deviceData = await startDeviceFlow(dashboardUrl)
+  } catch {
+    UI.println(UI.Style.TEXT_DANGER_BOLD + "Failed to start device login." + UI.Style.TEXT_NORMAL)
+    return
+  }
+
+  const { device_code, user_code, verification_uri_complete, interval } = deviceData
+
+  UI.println("")
+  UI.println(UI.Style.TEXT_DIM + "Open this URL in your browser:" + UI.Style.TEXT_NORMAL)
+  UI.println(UI.Style.TEXT_HIGHLIGHT_BOLD + "  " + verification_uri_complete + UI.Style.TEXT_NORMAL)
+  UI.println("")
+  UI.println(UI.Style.TEXT_DIM + "Enter the following code:" + UI.Style.TEXT_NORMAL)
+  UI.println(UI.Style.TEXT_HIGHLIGHT_BOLD + "  " + user_code + UI.Style.TEXT_NORMAL)
+  UI.println("")
+
+  try {
+    await open(verification_uri_complete)
+    UI.println(UI.Style.TEXT_DIM + "Browser opened automatically." + UI.Style.TEXT_NORMAL)
+  } catch {
+    UI.println(UI.Style.TEXT_WARNING + "Could not open browser automatically." + UI.Style.TEXT_NORMAL)
+    UI.println(UI.Style.TEXT_DIM + "Please open the URL above and enter the code in your browser." + UI.Style.TEXT_NORMAL)
+  }
+
+  UI.println(UI.Style.TEXT_DIM + "Waiting for authorization..." + UI.Style.TEXT_NORMAL)
+
+  const pollMs = (interval ?? 5) * 1000
+  let tokenData: DeviceTokenResponse | null = null
+
+  while (true) {
+    await sleep(pollMs)
+
+    try {
+      tokenData = await pollDeviceToken(dashboardUrl, device_code)
+      break
+    } catch (err: any) {
+      if (err.code === "authorization_pending" || err.code === "slow_down") continue
+      if (err.code === "expired_token") {
+        UI.println(UI.Style.TEXT_DANGER_BOLD + "Login expired. Please try again." + UI.Style.TEXT_NORMAL)
+        return
+      }
+      if (err.code === "access_denied") {
+        UI.println(UI.Style.TEXT_DANGER_BOLD + "Login denied." + UI.Style.TEXT_NORMAL)
+        return
+      }
+      UI.println(UI.Style.TEXT_DANGER_BOLD + "Login failed: " + (err.message || "Unknown error") + UI.Style.TEXT_NORMAL)
+      return
+    }
+  }
+
+  const configPath = path.join(Global.Path.config, "gateway.json")
+  await writeConfig(configPath, {
+    access_token: tokenData.access_token,
+    refresh_token: tokenData.refresh_token,
+    expires_at: Date.now() + (tokenData.expires_in ?? 3600) * 1000,
+    endpoint: tokenData.endpoint,
+    tier: tokenData.tier,
+    email: tokenData.email,
+    dashboard_url: dashboardUrl,
+  })
+
+  UI.println("")
+  UI.println(UI.Style.TEXT_SUCCESS_BOLD + "✓ Login successful!" + UI.Style.TEXT_NORMAL)
+  UI.println(UI.Style.TEXT_DIM + "  Email: " + UI.Style.TEXT_NORMAL + tokenData.email)
+  UI.println(UI.Style.TEXT_DIM + "  Tier: " + UI.Style.TEXT_NORMAL + tokenData.tier)
+  UI.println(UI.Style.TEXT_DIM + "  Config saved to: " + UI.Style.TEXT_NORMAL + configPath)
+  UI.println("")
+}
+
+export const LoginCommand = cmd({
+  command: "login",
+  describe: "Log in to Sleepy CLI via OAuth",
+  builder: (yargs) =>
+    yargs.option("device", {
+      type: "boolean",
+      description: "Use device code flow for environments without a browser",
+    }),
+  async handler(args) {
+    if (args.device) {
+      return handleDeviceFlow()
+    }
+
+    prompts.intro("Login to Sleepy")
+    const method = await prompts.select({
+      message: "How would you like to log in?",
+      options: [
+        { value: "browser", label: "Open in Browser", hint: "recommended" },
+        { value: "device", label: "Use Activation Code" },
+        { value: "exit", label: "Exit" },
+      ],
+    })
+
+    if (prompts.isCancel(method) || method === "exit") {
+      prompts.outro("Goodbye!")
+      return
+    }
+
+    if (method === "device") return handleDeviceFlow()
+    return handleAuthCodeFlow()
+  },
+})