octo-agent 0.11.2

data/lib/octo/default_skills/channel-manager/dingtalk_setup.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# dingtalk_setup.rb — DingTalk channel setup via Device Flow (QR scan).
+#
+# Modes:
+#   --print-qr            Phase 1+2: call init/begin, print QR URL as JSON, exit immediately.
+#   --poll <device_code>  Phase 3+4+5: poll until SUCCESS, save credentials, wait for WS.
+#
+# Environment:
+#   OCTO_SERVER_PORT, OCTO_SERVER_HOST — octo server coordinates
+
+require "json"
+require "net/http"
+require "net/https"
+require "uri"
+
+DINGTALK_REG_BASE  = "https://oapi.dingtalk.com"
+# Registration source ID assigned by DingTalk (not a brand string — do not rebrand).
+DINGTALK_REG_SOURCE = "DING_DWS_CLAW"
+POLL_INTERVAL = 3
+POLL_TIMEOUT  = 300
+
+OCTO_SERVER_URL = begin
+  url = "http://#{ENV.fetch("OCTO_SERVER_HOST")}:#{ENV.fetch("OCTO_SERVER_PORT")}"
+  uri = URI.parse(url)
+  raise "Invalid OCTO_SERVER_URL: #{url}" unless uri.is_a?(URI::HTTP) && uri.host && uri.port
+  url
+end
+
+def step(msg);  puts("[dingtalk-setup] #{msg}"); end
+def ok(msg);    puts("[dingtalk-setup] ✅ #{msg}"); end
+def warn(msg);  puts("[dingtalk-setup] ⚠️  #{msg}"); end
+def fail!(msg)
+  puts("[dingtalk-setup] ❌ #{msg}")
+  exit 1
+end
+
+def post_json(url, payload)
+  uri  = URI.parse(url)
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.use_ssl = uri.scheme == "https"
+  req = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+  req.body = JSON.generate(payload)
+  resp = http.request(req)
+  data = JSON.parse(resp.body)
+  fail! "API error (#{resp.code}): #{data["errmsg"] || resp.body}" if data["errcode"] && data["errcode"] != 0
+  data
+rescue JSON::ParserError => e
+  fail! "JSON parse error from #{url}: #{e.message}"
+end
+
+def server_post(path, body)
+  uri = URI(OCTO_SERVER_URL)
+  Net::HTTP.start(uri.host, uri.port, open_timeout: 3, read_timeout: 10) do |h|
+    req = Net::HTTP::Post.new(path, "Content-Type" => "application/json")
+    req.body = JSON.generate(body)
+    h.request(req)
+  end
+end
+
+def server_get(path)
+  uri = URI(OCTO_SERVER_URL)
+  Net::HTTP.start(uri.host, uri.port, open_timeout: 3, read_timeout: 10) do |h|
+    h.request(Net::HTTP::Get.new(path))
+  end
+end
+
+# ── Mode: --print-qr ─────────────────────────────────────────────────────────
+# Call init + begin, print JSON with qr_url / device_code / expires_in, exit 0.
+def mode_print_qr
+  step "Phase 1 — Starting DingTalk Device Flow registration..."
+
+  init_data = post_json("#{DINGTALK_REG_BASE}/app/registration/init",
+                        { source: DINGTALK_REG_SOURCE })
+  nonce = init_data["nonce"].to_s.strip
+  fail! "Missing nonce in init response" if nonce.empty?
+
+  begin_data   = post_json("#{DINGTALK_REG_BASE}/app/registration/begin", { nonce: nonce })
+  device_code  = begin_data["device_code"].to_s.strip
+  qr_url       = begin_data["verification_uri_complete"].to_s.strip
+  expires_in   = (begin_data["expires_in"] || POLL_TIMEOUT).to_i
+
+  fail! "Missing device_code in begin response"  if device_code.empty?
+  fail! "Missing verification_uri_complete"       if qr_url.empty?
+
+  ok "Device Flow started. QR expires in #{expires_in}s."
+  puts JSON.generate({ qr_url: qr_url, device_code: device_code, expires_in: expires_in })
+end
+
+# ── Mode: --poll <device_code> ────────────────────────────────────────────────
+# Poll until SUCCESS or a terminal state. Exits with:
+#   0  — SUCCESS: credentials saved and adapter started
+#   2  — WAITING: user hasn't scanned yet (Agent should ask user to scan and retry)
+#   1  — terminal failure (expired, fail, or server error)
+def mode_poll(device_code, expires_in: POLL_TIMEOUT, interval: POLL_INTERVAL)
+  step "Phase 3 — Checking DingTalk authorization..."
+
+  client_id     = nil
+  client_secret = nil
+  deadline      = Time.now + expires_in
+
+  loop do
+    if Time.now > deadline
+      puts "[dingtalk-setup] WAITING_TIMEOUT"
+      exit 2
+    end
+
+    poll_data = post_json("#{DINGTALK_REG_BASE}/app/registration/poll",
+                          { device_code: device_code })
+    status = poll_data["status"].to_s.upcase
+
+    case status
+    when "WAITING"
+      puts "[dingtalk-setup] WAITING"
+      exit 2
+    when "SUCCESS"
+      client_id     = poll_data["client_id"].to_s.strip
+      client_secret = poll_data["client_secret"].to_s.strip
+      fail! "Authorization succeeded but missing client credentials" if client_id.empty? || client_secret.empty?
+      ok "Authorization complete! client_id=#{client_id}"
+      break
+    when "EXPIRED"
+      fail! "Authorization QR code expired. Please re-run."
+    when "FAIL"
+      fail! "Authorization failed: #{poll_data["fail_reason"] || "unknown reason"}"
+    else
+      warn "Unknown status=#{status}, retrying..."
+      sleep interval
+    end
+  end
+
+  # ── Phase 4: Save credentials to octo server ─────────────────────────────
+  step "Phase 4 — Saving credentials to octo server..."
+
+  begin
+    res = server_post("/api/channels/dingtalk",
+                      { client_id: client_id, client_secret: client_secret, enabled: true })
+    if res.code.to_i == 200
+      ok "Credentials saved, DingTalk Stream adapter starting..."
+    else
+      body = JSON.parse(res.body) rescue { "error" => res.body }
+      fail! "Server rejected credentials: #{body["error"] || res.body}"
+    end
+  rescue StandardError => e
+    fail! "Could not reach octo server: #{e.message}"
+  end
+
+  # ── Phase 5: Wait for Stream Mode WebSocket to connect ─────────────────────
+  step "Phase 5 — Waiting for DingTalk Stream connection..."
+
+  ws_ready    = false
+  ws_deadline = Time.now + 30
+
+  loop do
+    break if Time.now > ws_deadline
+    begin
+      res      = server_get("/api/channels")
+      channels = JSON.parse(res.body)["channels"] || []
+      dingtalk = channels.find { |c| c["platform"] == "dingtalk" }
+      if dingtalk&.fetch("running", false)
+        ws_ready = true
+        break
+      end
+    rescue StandardError => e
+      warn "Channel status check failed: #{e.message}"
+    end
+    sleep 2
+  end
+
+  if ws_ready
+    ok "DingTalk Stream WebSocket connected."
+  else
+    warn "Stream connection not confirmed within 30s — it may still be starting."
+  end
+
+  ok "🎉 DingTalk channel setup complete! Search for your robot in DingTalk to start chatting."
+  ok "   client_id: #{client_id}"
+end
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+case ARGV[0]
+when "--print-qr"
+  mode_print_qr
+when "--poll"
+  device_code = ARGV[1].to_s.strip
+  fail! "Usage: dingtalk_setup.rb --poll <device_code>" if device_code.empty?
+  mode_poll(device_code)
+else
+  fail! "Usage: dingtalk_setup.rb --print-qr | --poll <device_code>"
+end

data/lib/octo/default_skills/channel-manager/discord_setup.rb

@@ -0,0 +1,199 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# discord_setup.rb — Discord channel setup helper.
+#
+# Discord's developer portal requires manual interaction (hCaptcha + private API), so the
+# Agent uses the browser only as a container — it navigates to the portal and the user
+# creates the App manually, then pastes back the bot token and application id. This
+# script handles everything a shell can do: emit the portal URL, validate the token
+# against /users/@me, save to the octo server, generate the OAuth2 invite URL, and
+# poll until the bot is in at least one guild.
+#
+# Modes:
+#   --portal-url                Print the Discord developer portal URL (stdout, single line)
+#   --validate <token>          Validate bot_token via /users/@me, then POST to server
+#   --invite-url <client_id>    Print the OAuth2 invite URL (stdout, single line)
+#   --watch-guild               Long-poll /users/@me/guilds via the saved token
+#                               until at least one guild appears (or timeout)
+#   --bot-info <token>          Print {id, username} JSON for an unsaved token
+#
+# Environment:
+#   OCTO_SERVER_HOST  default 127.0.0.1
+#   OCTO_SERVER_PORT  default 8888
+
+require "json"
+require "net/http"
+require "net/https"
+require "uri"
+require "openssl"
+require "cgi"
+require "yaml"
+
+DISCORD_API_BASE      = "https://discord.com/api/v10"
+DISCORD_OAUTH_BASE    = "https://discord.com/oauth2/authorize"
+DISCORD_PORTAL_URL    = "https://discord.com/developers/applications"
+DEFAULT_BOT_PERMS     = "274877990912"
+DEFAULT_BOT_SCOPES    = "bot applications.commands"
+WATCH_GUILD_DEADLINE  = 10 * 60
+WATCH_GUILD_INTERVAL  = 3
+USER_AGENT            = "DiscordBot (https://github.com/octoai/octo, 1.0)"
+
+OCTO_SERVER_URL = begin
+  host = ENV.fetch("OCTO_SERVER_HOST", "127.0.0.1")
+  port = ENV.fetch("OCTO_SERVER_PORT", "8888")
+  "http://#{host}:#{port}"
+end
+
+def step(msg);  $stderr.puts("[discord-setup] #{msg}"); end
+def ok(msg);    $stderr.puts("[discord-setup] #{msg}"); end
+def warn!(msg); $stderr.puts("[discord-setup] #{msg}"); end
+
+def fail!(msg, json: false)
+  if json
+    $stdout.puts(JSON.generate({ error: msg }))
+  else
+    $stderr.puts("[discord-setup] #{msg}")
+  end
+  exit 1
+end
+
+def discord_get(path, bot_token:, timeout: 15)
+  uri  = URI("#{DISCORD_API_BASE}#{path}")
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.use_ssl      = true
+  http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+  http.read_timeout = timeout
+  http.open_timeout = 10
+
+  req = Net::HTTP::Get.new(uri.request_uri)
+  req["Authorization"] = "Bot #{bot_token}"
+  req["User-Agent"]    = USER_AGENT
+  req["Accept"]        = "application/json"
+
+  res    = http.request(req)
+  body   = res.body.to_s
+  parsed = (JSON.parse(body) rescue nil)
+
+  unless res.is_a?(Net::HTTPSuccess)
+    msg = parsed.is_a?(Hash) ? (parsed["message"] || body.slice(0, 200)) : body.slice(0, 200)
+    raise "Discord HTTP #{res.code} #{path}: #{msg}"
+  end
+  parsed
+end
+
+def saved_bot_token
+  yml_path = File.expand_path("~/.octo/channels.yml")
+  return nil unless File.exist?(yml_path)
+  data = YAML.safe_load_file(yml_path, permitted_classes: [Symbol], aliases: true) rescue nil
+  data&.dig("channels", "discord", "bot_token") || data&.dig(:channels, :discord, :bot_token)
+end
+
+def save_to_server(bot_token:)
+  uri  = URI("#{OCTO_SERVER_URL}/api/channels/discord")
+  body = JSON.generate({ bot_token: bot_token })
+
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.read_timeout = 30
+  http.open_timeout = 5
+
+  req = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+  req.body = body
+
+  res  = http.request(req)
+  data = JSON.parse(res.body) rescue {}
+
+  unless res.is_a?(Net::HTTPSuccess) && data["ok"]
+    fail!("Failed to save Discord config: #{data["error"] || res.body.slice(0, 200)}")
+  end
+end
+
+mode_idx = ARGV.index { |a| a.start_with?("--") }
+mode     = mode_idx ? ARGV[mode_idx] : nil
+arg      = mode_idx ? ARGV[mode_idx + 1] : nil
+
+case mode
+when "--portal-url"
+  $stdout.puts(DISCORD_PORTAL_URL)
+  exit 0
+
+when "--validate"
+  fail!("--validate requires <bot_token>") if arg.to_s.strip.empty?
+  bot_token = arg.strip
+  step("Validating bot token against Discord API...")
+  begin
+    me = discord_get("/users/@me", bot_token: bot_token)
+  rescue => e
+    fail!("Token validation failed: #{e.message}")
+  end
+
+  bot_id   = me["id"].to_s
+  username = me["username"].to_s
+  fail!("Empty bot id from /users/@me") if bot_id.empty?
+
+  ok("Authenticated as #{username} (id=#{bot_id})")
+  step("Saving credentials via octo server...")
+  save_to_server(bot_token: bot_token)
+  ok("Discord channel configured")
+
+  $stdout.puts(JSON.generate({ bot_id: bot_id, username: username }))
+  exit 0
+
+when "--bot-info"
+  fail!("--bot-info requires <bot_token>", json: true) if arg.to_s.strip.empty?
+  begin
+    me = discord_get("/users/@me", bot_token: arg.strip)
+  rescue => e
+    fail!(e.message, json: true)
+  end
+  $stdout.puts(JSON.generate({ bot_id: me["id"], username: me["username"] }))
+  exit 0
+
+when "--invite-url"
+  fail!("--invite-url requires <client_id>") if arg.to_s.strip.empty?
+  client_id = arg.strip
+  url = "#{DISCORD_OAUTH_BASE}?client_id=#{CGI.escape(client_id)}" \
+        "&permissions=#{DEFAULT_BOT_PERMS}" \
+        "&scope=#{CGI.escape(DEFAULT_BOT_SCOPES)}"
+  $stdout.puts(url)
+  exit 0
+
+when "--watch-guild"
+  bot_token = saved_bot_token
+  fail!("No saved bot_token in ~/.octo/channels.yml — run --validate first") if bot_token.to_s.empty?
+
+  step("Waiting for the bot to be added to a guild (timeout: #{WATCH_GUILD_DEADLINE / 60} min)...")
+  deadline = Time.now + WATCH_GUILD_DEADLINE
+
+  loop do
+    fail!("Timed out waiting for the bot to join a guild. Open the invite URL again to retry.") if Time.now > deadline
+
+    begin
+      guilds = discord_get("/users/@me/guilds", bot_token: bot_token)
+    rescue => e
+      warn!("Poll error (will retry): #{e.message}")
+      sleep WATCH_GUILD_INTERVAL
+      next
+    end
+
+    if guilds.is_a?(Array) && !guilds.empty?
+      g = guilds.first
+      ok("Bot added to guild: #{g["name"]} (id=#{g["id"]})")
+      $stdout.puts(JSON.generate({ guild_id: g["id"], guild_name: g["name"], total: guilds.length }))
+      exit 0
+    end
+
+    sleep WATCH_GUILD_INTERVAL
+  end
+
+else
+  $stderr.puts(<<~USAGE)
+    Usage:
+      ruby discord_setup.rb --portal-url
+      ruby discord_setup.rb --validate <bot_token>
+      ruby discord_setup.rb --bot-info <bot_token>
+      ruby discord_setup.rb --invite-url <client_id>
+      ruby discord_setup.rb --watch-guild
+  USAGE
+  exit 1
+end