stella-coder 5.2.1 → 5.3.0

package/stella-cli/gmail.mjs

@@ -0,0 +1,415 @@
+import fs from "node:fs"
+import path from "node:path"
+import os from "node:os"
+import { execSync } from "node:child_process"
+
+const CONFIG_DIR = path.join(os.homedir(), ".stella", "gmail")
+const TOKEN_FILE = path.join(CONFIG_DIR, "token.json")
+const CREDS_FILE = path.join(CONFIG_DIR, "credentials.json")
+const SENT_DIR = path.join(CONFIG_DIR, "sent")
+
+function ensureDirs() {
+  for (const dir of [CONFIG_DIR, SENT_DIR]) {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+  }
+}
+
+function getOAuth2URL(clientId, redirectUri) {
+  const scopes = [
+    "https://www.googleapis.com/auth/gmail.send",
+    "https://www.googleapis.com/auth/gmail.readonly",
+    "https://www.googleapis.com/auth/gmail.modify",
+    "https://www.googleapis.com/auth/gmail.labels",
+  ]
+  const params = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: scopes.join(" "),
+    access_type: "offline",
+    prompt: "consent",
+  })
+  return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`
+}
+
+async function exchangeCode(clientId, clientSecret, code, redirectUri) {
+  const resp = await fetch("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: clientId,
+      client_secret: clientSecret,
+      code,
+      grant_type: "authorization_code",
+      redirect_uri: redirectUri,
+    }).toString(),
+  })
+  return await resp.json()
+}
+
+async function refreshToken(clientId, clientSecret, refreshTokenValue) {
+  const resp = await fetch("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: clientId,
+      client_secret: clientSecret,
+      refresh_token: refreshTokenValue,
+      grant_type: "refresh_token",
+    }).toString(),
+  })
+  return await resp.json()
+}
+
+function loadToken() {
+  if (!fs.existsSync(TOKEN_FILE)) return null
+  return JSON.parse(fs.readFileSync(TOKEN_FILE, "utf8"))
+}
+
+function saveToken(token) {
+  ensureDirs()
+  fs.writeFileSync(TOKEN_FILE, JSON.stringify(token, null, 2))
+}
+
+function loadCredentials() {
+  if (!fs.existsSync(CREDS_FILE)) return null
+  return JSON.parse(fs.readFileSync(CREDS_FILE, "utf8"))
+}
+
+function buildMimeMessage({ to, cc, bcc, subject, body, isHtml, attachments }) {
+  const boundary = `stella_boundary_${Date.now()}_${Math.random().toString(36).slice(2)}`
+  const lines = []
+
+  lines.push(`To: ${to}`)
+  if (cc) lines.push(`Cc: ${cc}`)
+  if (bcc) lines.push(`Bcc: ${bcc}`)
+  lines.push(`Subject: ${subject}`)
+  lines.push("MIME-Version: 1.0")
+
+  if (attachments && attachments.length > 0) {
+    lines.push(`Content-Type: multipart/mixed; boundary="${boundary}"`)
+    lines.push("")
+    lines.push(`--${boundary}`)
+    if (isHtml) {
+      lines.push("Content-Type: text/html; charset=UTF-8")
+    } else {
+      lines.push("Content-Type: text/plain; charset=UTF-8")
+    }
+    lines.push("")
+    lines.push(body)
+    for (const att of attachments) {
+      const filePath = att
+      if (fs.existsSync(filePath)) {
+        const content = fs.readFileSync(filePath)
+        const b64 = content.toString("base64")
+        const name = path.basename(filePath)
+        lines.push("")
+        lines.push(`--${boundary}`)
+        lines.push(`Content-Type: application/octet-stream; name="${name}"`)
+        lines.push(`Content-Disposition: attachment; filename="${name}"`)
+        lines.push("Content-Transfer-Encoding: base64")
+        lines.push("")
+        lines.push(b64.match(/.{1,76}/g).join("\n"))
+      }
+    }
+    lines.push("")
+    lines.push(`--${boundary}--`)
+  } else {
+    if (isHtml) {
+      lines.push("Content-Type: text/html; charset=UTF-8")
+    } else {
+      lines.push("Content-Type: text/plain; charset=UTF-8")
+    }
+    lines.push("")
+    lines.push(body)
+  }
+
+  return Buffer.from(lines.join("\r\n")).toString("base64url")
+}
+
+async function gmailApiRequest(accessToken, method, url, body) {
+  const opts = {
+    method,
+    headers: { Authorization: `Bearer ${accessToken}` },
+  }
+  if (body) {
+    opts.headers["Content-Type"] = "application/json"
+    opts.body = JSON.stringify(body)
+  }
+  const resp = await fetch(url, opts)
+  return await resp.json()
+}
+
+export class GmailClient {
+  constructor() {
+    ensureDirs()
+  }
+
+  isConfigured() {
+    return fs.existsSync(CREDS_FILE) && fs.existsSync(TOKEN_FILE)
+  }
+
+  getSetupURL() {
+    const creds = loadCredentials()
+    if (!creds || !creds.installed || !creds.installed.client_id) return null
+    const redirectUri = creds.installed.redirect_uris?.[0] || "http://localhost:3456/callback"
+    return getOAuth2URL(creds.installed.client_id, redirectUri)
+  }
+
+  async completeAuth(code) {
+    const creds = loadCredentials()
+    if (!creds || !creds.installed) return { success: false, error: "No credentials.json" }
+    const redirectUri = creds.installed.redirect_uris?.[0] || "http://localhost:3456/callback"
+    const token = await exchangeCode(
+      creds.installed.client_id,
+      creds.installed.client_secret,
+      code,
+      redirectUri
+    )
+    if (token.error) return { success: false, error: token.error_description || token.error }
+    saveToken(token)
+    return { success: true }
+  }
+
+  async getAccessToken() {
+    const creds = loadCredentials()
+    const token = loadToken()
+    if (!creds || !token) return null
+    if (token.expiry_date && token.expiry_date > Date.now()) return token.access_token
+    const refreshed = await refreshToken(
+      creds.installed.client_id,
+      creds.installed.client_secret,
+      token.refresh_token
+    )
+    if (refreshed.access_token) {
+      token.access_token = refreshed.access_token
+      token.expiry_date = Date.now() + (refreshed.expires_in || 3600) * 1000
+      saveToken(token)
+      return refreshed.access_token
+    }
+    return null
+  }
+
+  async sendEmail({ to, cc, bcc, subject, body, isHtml = false, attachments = [] }) {
+    const accessToken = await this.getAccessToken()
+    if (!accessToken) return { success: false, error: "Not authenticated. Run /gmail-setup first." }
+
+    const raw = buildMimeMessage({ to, cc, bcc, subject, body, isHtml, attachments })
+    const result = await gmailApiRequest(
+      accessToken,
+      "POST",
+      "https://gmail.googleapis.com/gmail/v1/users/me/messages/send",
+      { raw }
+    )
+
+    if (result.id) {
+      const sentFile = path.join(SENT_DIR, `${Date.now()}.json`)
+      fs.writeFileSync(sentFile, JSON.stringify({
+        id: result.id,
+        to, cc, bcc, subject,
+        date: new Date().toISOString(),
+      }, null, 2))
+      return { success: true, messageId: result.id }
+    }
+    return { success: false, error: result.error?.message || "Send failed" }
+  }
+
+  async listMessages({ query = "", maxResults = 20, labelIds = [] } = {}) {
+    const accessToken = await this.getAccessToken()
+    if (!accessToken) return { success: false, error: "Not authenticated" }
+
+    const params = new URLSearchParams({ maxResults: String(maxResults) })
+    if (query) params.set("q", query)
+    for (const lid of labelIds) params.append("labelIds", lid)
+
+    const list = await gmailApiRequest(
+      accessToken,
+      "GET",
+      `https://gmail.googleapis.com/gmail/v1/users/me/messages?${params.toString()}`
+    )
+
+    if (!list.messages) return { success: true, messages: [] }
+
+    const messages = []
+    for (const msg of list.messages.slice(0, maxResults)) {
+      const detail = await gmailApiRequest(
+        accessToken,
+        "GET",
+        `https://gmail.googleapis.com/gmail/v1/users/me/messages/${msg.id}?format=metadata`
+      )
+      const headers = detail.payload?.headers || []
+      const get = (name) => headers.find(h => h.name.toLowerCase() === name.toLowerCase())?.value || ""
+      messages.push({
+        id: msg.id,
+        threadId: msg.threadId,
+        subject: get("Subject"),
+        from: get("From"),
+        to: get("To"),
+        date: get("Date"),
+        snippet: detail.snippet || "",
+        labels: detail.labelIds || [],
+      })
+    }
+    return { success: true, messages }
+  }
+
+  async getMessage(messageId) {
+    const accessToken = await this.getAccessToken()
+    if (!accessToken) return { success: false, error: "Not authenticated" }
+
+    const msg = await gmailApiRequest(
+      accessToken,
+      "GET",
+      `https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}?format=full`
+    )
+
+    if (!msg.id) return { success: false, error: "Message not found" }
+
+    const headers = msg.payload?.headers || []
+    const get = (name) => headers.find(h => h.name.toLowerCase() === name.toLowerCase())?.value || ""
+
+    let textBody = ""
+    let htmlBody = ""
+    const attachments = []
+
+    function extractParts(payload) {
+      if (!payload) return
+      if (payload.mimeType === "text/plain" && payload.body?.data) {
+        textBody += Buffer.from(payload.body.data, "base64url").toString("utf8")
+      }
+      if (payload.mimeType === "text/html" && payload.body?.data) {
+        htmlBody += Buffer.from(payload.body.data, "base64url").toString("utf8")
+      }
+      if (payload.filename && payload.body?.attachmentId) {
+        attachments.push({
+          filename: payload.filename,
+          mimeType: payload.mimeType,
+          size: payload.body.size,
+          attachmentId: payload.body.attachmentId,
+        })
+      }
+      for (const part of payload.parts || []) {
+        extractParts(part)
+      }
+    }
+
+    extractParts(msg.payload)
+
+    return {
+      success: true,
+      message: {
+        id: msg.id,
+        threadId: msg.threadId,
+        subject: get("Subject"),
+        from: get("From"),
+        to: get("To"),
+        cc: get("Cc"),
+        date: get("Date"),
+        textBody,
+        htmlBody,
+        attachments,
+        labels: msg.labelIds || [],
+        snippet: msg.snippet || "",
+      },
+    }
+  }
+
+  async getAttachment(messageId, attachmentId, filename) {
+    const accessToken = await this.getAccessToken()
+    if (!accessToken) return { success: false, error: "Not authenticated" }
+
+    const resp = await fetch(
+      `https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}/attachments/${attachmentId}`,
+      { headers: { Authorization: `Bearer ${accessToken}` } }
+    )
+    const data = await resp.json()
+    if (data.data) {
+      const buffer = Buffer.from(data.data, "base64url")
+      const savePath = path.join(SENT_DIR, filename)
+      fs.writeFileSync(savePath, buffer)
+      return { success: true, path: savePath, size: buffer.length }
+    }
+    return { success: false, error: "Attachment not found" }
+  }
+
+  async listLabels() {
+    const accessToken = await this.getAccessToken()
+    if (!accessToken) return { success: false, error: "Not authenticated" }
+
+    const result = await gmailApiRequest(
+      accessToken,
+      "GET",
+      "https://gmail.googleapis.com/gmail/v1/users/me/labels"
+    )
+
+    return {
+      success: true,
+      labels: (result.labels || []).map(l => ({ id: l.id, name: l.name, type: l.type })),
+    }
+  }
+
+  async markAsRead(messageId) {
+    const accessToken = await this.getAccessToken()
+    if (!accessToken) return { success: false, error: "Not authenticated" }
+
+    await gmailApiRequest(
+      accessToken,
+      "POST",
+      `https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}/modify`,
+      { removeLabelIds: ["UNREAD"] }
+    )
+    return { success: true }
+  }
+
+  async markAsUnread(messageId) {
+    const accessToken = await this.getAccessToken()
+    if (!accessToken) return { success: false, error: "Not authenticated" }
+
+    await gmailApiRequest(
+      accessToken,
+      "POST",
+      `https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}/modify`,
+      { addLabelIds: ["UNREAD"] }
+    )
+    return { success: true }
+  }
+
+  async deleteMessage(messageId) {
+    const accessToken = await this.getAccessToken()
+    if (!accessToken) return { success: false, error: "Not authenticated" }
+
+    await gmailApiRequest(
+      accessToken,
+      "DELETE",
+      `https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}`
+    )
+    return { success: true }
+  }
+
+  async getProfile() {
+    const accessToken = await this.getAccessToken()
+    if (!accessToken) return { success: false, error: "Not authenticated" }
+
+    const result = await gmailApiRequest(
+      accessToken,
+      "GET",
+      "https://gmail.googleapis.com/gmail/v1/users/me/profile"
+    )
+    return {
+      success: true,
+      email: result.emailAddress,
+      totalMessages: result.messagesTotal,
+    }
+  }
+
+  async searchMessages(query, maxResults = 10) {
+    return this.listMessages({ query, maxResults })
+  }
+
+  async getUnreadCount() {
+    const result = await this.listMessages({ query: "is:unread", maxResults: 1, labelIds: ["INBOX"] })
+    if (!result.success) return 0
+    const full = await this.listMessages({ query: "is:unread", maxResults: 100 })
+    return full.messages?.length || 0
+  }
+}

package/stella-cli/home-assistant.mjs

@@ -0,0 +1,168 @@
+import fs from "node:fs"
+import path from "node:path"
+import os from "node:os"
+
+const CONFIG_DIR = path.join(os.homedir(), ".stella", "ha")
+
+export class HomeAssistant {
+  constructor(url = "", token = "") {
+    this.url = (url || process.env.HA_URL || "").replace(/\/$/, "")
+    this.token = token || process.env.HA_TOKEN || ""
+    if (!this.url && fs.existsSync(path.join(CONFIG_DIR, "config.json"))) {
+      try {
+        const cfg = JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, "config.json"), "utf8"))
+        this.url = cfg.url || ""
+        this.token = cfg.token || ""
+      } catch {}
+    }
+  }
+
+  isConfigured() { return !!(this.url && this.token) }
+
+  configure(url, token) {
+    this.url = url.replace(/\/$/, "")
+    this.token = token
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true })
+    fs.writeFileSync(path.join(CONFIG_DIR, "config.json"), JSON.stringify({ url: this.url, token: this.token }, null, 2))
+  }
+
+  async request(method, endpoint, body) {
+    const resp = await fetch(`${this.url}/api/${endpoint}`, {
+      method,
+      headers: { Authorization: `Bearer ${this.token}`, "Content-Type": "application/json" },
+      ...(body ? { body: JSON.stringify(body) } : {}),
+    })
+    if (resp.status === 404) return { success: false, error: "Not found" }
+    if (!resp.ok) return { success: false, error: `HTTP ${resp.status}` }
+    const text = await resp.text()
+    try { return { success: true, data: JSON.parse(text) } }
+    catch { return { success: true, data: text } }
+  }
+
+  async getStates() { return this.request("GET", "states") }
+  async getState(entityId) { return this.request("GET", `states/${entityId}`) }
+
+  async callService(domain, service, data = {}) {
+    return this.request("POST", `services/${domain}/${service}`, data)
+  }
+
+  async toggle(entityId) { return this.callService("homeassistant", "toggle", { entity_id: entityId }) }
+  async turnOn(entityId) { return this.callService("homeassistant", "turn_on", { entity_id: entityId }) }
+  async turnOff(entityId) { return this.callService("homeassistant", "turn_off", { entity_id: entityId }) }
+
+  async getConfig() { return this.request("GET", "config") }
+  async getLogbook(startTimestamp) {
+    const start = startTimestamp || new Date(Date.now() - 86400000).toISOString()
+    return this.request("GET", `logbook/${start}`)
+  }
+
+  async getHistory(entityId, hours = 24) {
+    const start = new Date(Date.now() - hours * 3600000).toISOString()
+    return this.request("GET", `history/period/${start}?filter_entity_id=${entityId}`)
+  }
+
+  async getTemplate(template) {
+    return this.request("POST", "template", { template })
+  }
+
+  async fireEvent(eventType, data = {}) {
+    return this.request("POST", `events/${eventType}`, data)
+  }
+
+  async getServices() { return this.request("GET", "services") }
+
+  async getEntitySources() { return this.request("GET", "config/entity_registry") }
+
+  async getAutoInfo() {
+    const s = await this.request("GET", "config")
+    return { success: true, haVersion: s.data?.version, locationName: s.data?.location_name, timezone: s.data?.time_zone }
+  }
+
+  async getLights() {
+    const states = await this.getStates()
+    if (!states.success) return states
+    const lights = states.data.filter(s => s.entity_id.startsWith("light."))
+    return { success: true, lights: lights.map(l => ({ entity: l.entity_id, state: l.state, brightness: l.attributes?.brightness, friendlyName: l.attributes?.friendly_name })) }
+  }
+
+  async getSensors() {
+    const states = await this.getStates()
+    if (!states.success) return states
+    const sensors = states.data.filter(s => s.entity_id.startsWith("sensor."))
+    return { success: true, sensors: sensors.map(s => ({ entity: s.entity_id, state: s.state, unit: s.attributes?.unit_of_measurement, friendlyName: s.attributes?.friendly_name })) }
+  }
+
+  async getSwitches() {
+    const states = await this.getStates()
+    if (!states.success) return states
+    const switches = states.data.filter(s => s.entity_id.startsWith("switch."))
+    return { success: true, switches: switches.map(s => ({ entity: s.entity_id, state: s.state, friendlyName: s.attributes?.friendly_name })) }
+  }
+
+  async getClimate() {
+    const states = await this.getStates()
+    if (!states.success) return states
+    const climate = states.data.filter(s => s.entity_id.startsWith("climate."))
+    return { success: true, devices: climate.map(c => ({ entity: c.entity_id, state: c.state, temp: c.attributes?.temperature, currentTemp: c.attributes?.current_temperature, mode: c.attributes?.hvac_mode, friendlyName: c.attributes?.friendly_name })) }
+  }
+
+  async setClimateTemp(entityId, temp) {
+    return this.callService("climate", "set_temperature", { entity_id: entityId, temperature: temp })
+  }
+
+  async setClimateMode(entityId, mode) {
+    return this.callService("climate", "set_hvac_mode", { entity_id: entityId, hvac_mode: mode })
+  }
+
+  async getMediaPlayers() {
+    const states = await this.getStates()
+    if (!states.success) return states
+    return { success: true, players: states.data.filter(s => s.entity_id.startsWith("media_player.")).map(p => ({ entity: p.entity_id, state: p.state, friendlyName: p.attributes?.friendly_name, source: p.attributes?.source, volume: p.attributes?.volume_level })) }
+  }
+
+  async mediaPlay(entityId) { return this.callService("media_player", "media_play", { entity_id: entityId }) }
+  async mediaPause(entityId) { return this.callService("media_player", "media_pause", { entity_id: entityId }) }
+  async mediaStop(entityId) { return this.callService("media_player", "media_stop", { entity_id: entityId }) }
+  async mediaNext(entityId) { return this.callService("media_player", "media_next_track", { entity_id: entityId }) }
+  async mediaPrev(entityId) { return this.callService("media_player", "media_previous_track", { entity_id: entityId }) }
+  async setVolume(entityId, level) { return this.callService("media_player", "volume_set", { entity_id: entityId, volume_level: level }) }
+  async selectSource(entityId, source) { return this.callService("media_player", "select_source", { entity_id: entityId, source }) }
+
+  async getCovers() {
+    const states = await this.getStates()
+    if (!states.success) return states
+    return { success: true, covers: states.data.filter(s => s.entity_id.startsWith("cover.")).map(c => ({ entity: c.entity_id, state: c.state, friendlyName: c.attributes?.friendly_name, position: c.attributes?.current_position })) }
+  }
+
+  async openCover(entityId) { return this.callService("cover", "open_cover", { entity_id: entityId }) }
+  async closeCover(entityId) { return this.callService("cover", "close_cover", { entity_id: entityId }) }
+  async stopCover(entityId) { return this.callService("cover", "stop_cover", { entity_id: entityId }) }
+  async setCoverPosition(entityId, pos) { return this.callService("cover", "set_cover_position", { entity_id: entityId, position: pos }) }
+
+  async setBrightness(entityId, brightness) {
+    return this.callService("light", "turn_on", { entity_id: entityId, brightness })
+  }
+
+  async setColor(entityId, color) {
+    return this.callService("light", "turn_on", { entity_id: entityId, rgb_color: color })
+  }
+
+  async getGroup(entityId) {
+    return this.request("GET", `states/${entityId}`)
+  }
+
+  async ping() {
+    try {
+      const resp = await fetch(`${this.url}/api/`, { headers: { Authorization: `Bearer ${this.token}` } })
+      return { success: resp.ok, status: resp.status }
+    } catch (e) {
+      return { success: false, error: e.message }
+    }
+  }
+
+  async getAllEntityIds() {
+    const states = await this.getStates()
+    if (!states.success) return states
+    return { success: true, entities: states.data.map(s => s.entity_id).sort() }
+  }
+}