@elliotsystems/eai 0.1.3 → 0.1.5

package/lib/gdrive.js

@@ -0,0 +1,238 @@
+"use strict"
+
+/**
+ * `eai connect|status|disconnect gdrive` — this person's own Google Drive.
+ *
+ * PERSONAL, not the team's. The Elliot CLI is an individual's tool: whichever
+ * Elliot teams you belong to — none, one, ten — the Drive reached here is the
+ * Google account YOU connect. Team Drive is a WebChat capability with its own
+ * grants, and the two never resolve to each other.
+ *
+ * ## Why this polls instead of running a loopback server
+ *
+ * The obvious CLI OAuth shape is a `127.0.0.1` listener that Google redirects
+ * to. It does not fit here, and the reason is not preference: the Google OAuth
+ * client is registered against ELLIOT's callback URL, so redirecting to a
+ * loopback port would need every deployment's Google client re-registered with
+ * a new URI, and `http://127.0.0.1:<random>` cannot be pre-registered because
+ * the port is not known in advance.
+ *
+ * So the browser half completes entirely server-side — Google redirects to the
+ * Elliot callback that already exists and already handles state, nonce and
+ * encryption — and this polls `GET /connectors/me/gdrive` to learn when it
+ * landed. The CLI therefore never touches the authorization code or the token,
+ * which is a stronger position than the loopback design would have given: there
+ * is no moment where a credential passes through this process at all.
+ *
+ * ## What this file is careful about
+ *
+ * No dependencies, matching the rest of the launcher. No secret is ever printed
+ * — not the token, not the state, not the JWT. The authorization URL IS shown,
+ * because a user whose browser failed to open needs it and it carries no
+ * credential of ours: it is a Google consent link bound to a signed, expiring,
+ * single-use state.
+ */
+
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const childProcess = require("child_process")
+
+/** How long to wait for the browser half before giving up. */
+const POLL_TIMEOUT_MS = 5 * 60 * 1000
+/** Gap between polls. Two seconds is invisible to a person and gentle on the
+ *  backend for a flow that takes tens of seconds of human time. */
+const POLL_INTERVAL_MS = 2000
+
+/** The provider this file speaks. */
+const PROVIDER = "gdrive"
+
+/** Accepted spellings, because `google-drive` is what people type. */
+const ALIASES = new Set(["gdrive", "google-drive", "googledrive", "drive"])
+
+function elliotConfigPath() {
+  return path.join(os.homedir(), ".elliot", "config.json")
+}
+
+function readConfig() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(elliotConfigPath(), "utf8"))
+    return parsed && typeof parsed === "object" ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Open a URL in the user's browser. Best-effort by design.
+ *
+ * A failure here is not a failure of the command: the URL is printed either
+ * way, and a user on a headless box pasting it into another machine's browser
+ * is a supported path rather than a workaround.
+ */
+function openBrowser(url, spawn = childProcess.spawn) {
+  const [cmd, args] =
+    process.platform === "win32"
+      ? ["cmd", ["/c", "start", "", url]]
+      : process.platform === "darwin"
+        ? ["open", [url]]
+        : ["xdg-open", [url]]
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true })
+    child.on("error", () => {})
+    child.unref()
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** An authenticated call to the Elliot API, or a clear error. */
+async function api(config, method, endpoint, fetchImpl = fetch) {
+  const base = String(config.backend_url || "").replace(/\/+$/, "")
+  if (!base) throw new Error("no backend_url in ~/.elliot/config.json")
+  if (!config.jwt_token) {
+    throw new Error("not signed in — run the setup command from the portal")
+  }
+  const res = await fetchImpl(`${base}${endpoint}`, {
+    method,
+    headers: { Authorization: `Bearer ${config.jwt_token}` },
+  })
+  if (res.status === 401) {
+    throw new Error("your Elliot session has expired — run `eai setup` again")
+  }
+  if (!res.ok) {
+    // The body is deliberately NOT interpolated: a connector error can name a
+    // provider URL, and this string is printed to a terminal and pasted into
+    // issues. The status is enough to act on.
+    throw new Error(`Elliot returned ${res.status} for ${method} ${endpoint}`)
+  }
+  return res.json()
+}
+
+async function status(opts = {}) {
+  const log = opts.log || ((s) => process.stdout.write(s + "\n"))
+  const config = opts.config !== undefined ? opts.config : readConfig()
+  if (!config) {
+    log("Not configured. Copy the setup command from the Elliot portal first.")
+    return 1
+  }
+
+  let info
+  try {
+    info = await api(config, "GET", `/connectors/me/${PROVIDER}`, opts.fetch)
+  } catch (error) {
+    log(`Google Drive: could not check (${error.message})`)
+    return 1
+  }
+
+  log("")
+  log("Google Drive")
+  if (!info.connected) {
+    log("  Status:   Not connected")
+    log("  Connect:  eai connect gdrive")
+    return 0
+  }
+  log("  Status:   Connected")
+  // The account address, never a credential. It is what makes "connected" a
+  // useful answer — a person with two Google accounts needs to know which one.
+  if (info.account) log(`  Account:  ${info.account}`)
+  log("  Scope:    your own My Drive and any Shared Drives Google gives you")
+  return 0
+}
+
+async function connect(opts = {}) {
+  const log = opts.log || ((s) => process.stdout.write(s + "\n"))
+  const config = opts.config !== undefined ? opts.config : readConfig()
+  if (!config) {
+    log("Not configured. Copy the setup command from the Elliot portal first.")
+    return 1
+  }
+
+  let start
+  try {
+    start = await api(
+      config, "POST", `/connectors/me/${PROVIDER}/authorize`, opts.fetch
+    )
+  } catch (error) {
+    log(`Could not start Google authorization: ${error.message}`)
+    return 1
+  }
+  const url = start && start.authorization_url
+  if (!url) {
+    log("Elliot did not return an authorization URL.")
+    return 1
+  }
+
+  log("")
+  log("Opening Google authorization in your browser...")
+  const opened = openBrowser(url, opts.spawn)
+  if (!opened) log("Could not open a browser automatically.")
+  log("")
+  log("If the browser does not open, visit:")
+  log(`  ${url}`)
+  log("")
+  log("Waiting for Google authorization...")
+
+  const deadline = Date.now() + (opts.timeoutMs || POLL_TIMEOUT_MS)
+  const wait = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)))
+  while (Date.now() < deadline) {
+    await wait(opts.intervalMs || POLL_INTERVAL_MS)
+    let info
+    try {
+      info = await api(config, "GET", `/connectors/me/${PROVIDER}`, opts.fetch)
+    } catch {
+      // A transient failure mid-flow must not abandon a connection the user is
+      // in the middle of authorizing. Keep polling until the deadline.
+      continue
+    }
+    if (info.connected) {
+      log("")
+      log("✓ Google Drive connected.")
+      if (info.account) log(`  Account: ${info.account}`)
+      log("")
+      log("Run `eai` and ask for a file — for example:")
+      log("  \"search my Google Drive for the architecture document\"")
+      return 0
+    }
+  }
+
+  log("")
+  log("Timed out waiting for Google authorization.")
+  log("If you completed it in the browser, check with: eai status gdrive")
+  return 1
+}
+
+async function disconnect(opts = {}) {
+  const log = opts.log || ((s) => process.stdout.write(s + "\n"))
+  const config = opts.config !== undefined ? opts.config : readConfig()
+  if (!config) {
+    log("Not configured. Copy the setup command from the Elliot portal first.")
+    return 1
+  }
+  try {
+    await api(config, "DELETE", `/connectors/me/${PROVIDER}`, opts.fetch)
+  } catch (error) {
+    log(`Could not disconnect Google Drive: ${error.message}`)
+    return 1
+  }
+  log("Google Drive disconnected. Your team's Drive is unaffected.")
+  return 0
+}
+
+/** True when `name` is how someone spells Google Drive. */
+function isGdrive(name) {
+  return ALIASES.has(String(name || "").toLowerCase())
+}
+
+module.exports = {
+  connect,
+  disconnect,
+  status,
+  isGdrive,
+  openBrowser,
+  readConfig,
+  elliotConfigPath,
+  PROVIDER,
+  ALIASES,
+}

package/lib/logout.js

@@ -0,0 +1,73 @@
+"use strict"
+
+/**
+ * `eai logout` — disconnect this machine from its Elliot workspace.
+ *
+ * Migrated from `elliot-ai logout` as that CLI is retired. Without it the only
+ * way to leave a workspace was to know that `~/.elliot/config.json` exists and
+ * delete it by hand — which is also how people end up deleting the wrong thing.
+ *
+ * It removes ONLY that file. `~/.config/opencode/opencode.json` is left alone
+ * on purpose: it is the user's own config, carrying their MCP servers, theme
+ * and anything else they put there, and a logout that silently discarded it
+ * would be destroying work the user never offered up. The provider block left
+ * behind is inert without a token.
+ *
+ * Confirmation is required and defaults to NO, because this is irreversible
+ * from the CLI's side: recovering means fetching a fresh token from the portal.
+ */
+
+const fs = require("fs")
+const readline = require("readline")
+
+const { elliotConfigPath } = require("./setup.js")
+const { readElliotConfig } = require("./status.js")
+
+/** Ask once on the TTY. Any answer but y/yes is a no, including empty. */
+function confirm(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+    rl.question(question, (answer) => {
+      rl.close()
+      const normalised = String(answer || "").trim().toLowerCase()
+      resolve(normalised === "y" || normalised === "yes")
+    })
+  })
+}
+
+/**
+ * @param {{log?: (s: string) => void, confirm?: (q: string) => Promise<boolean>, force?: boolean}} [opts]
+ * @returns {Promise<number>} the process exit code
+ */
+async function runLogout(opts = {}) {
+  const log = opts.log || ((s) => process.stdout.write(s + "\n"))
+  const ask = opts.confirm || confirm
+  const file = elliotConfigPath()
+
+  const config = readElliotConfig()
+  if (!config) {
+    // Not an error: "make this machine logged out" is already true, and exiting
+    // non-zero would fail a script that is just ensuring a clean state.
+    log("Already logged out — no Elliot configuration on this machine.")
+    return 0
+  }
+
+  const where = config.org_name || config.tenant_id || "this workspace"
+  if (!opts.force && !(await ask(`Log out of ${where}? [y/N] `))) {
+    log("Cancelled.")
+    return 0
+  }
+
+  try {
+    fs.rmSync(file, { force: true })
+  } catch (error) {
+    log(`Could not remove ${file}: ${error.message}`)
+    return 1
+  }
+
+  log(`Removed ${file}`)
+  log("Logged out. Copy the setup command from the Elliot portal to reconnect.")
+  return 0
+}
+
+module.exports = { runLogout, confirm }

package/lib/resolve.js

@@ -87,20 +87,14 @@ function candidates(opts) {
     // opencode-ai not installed.
   }
 
-  // 3. Per-platform npm optionalDependency package — the shape a published,
-  //    `npm install`-ed `@elliotsystems/eai` gets its runtime from. Resolved via
-  //    `require.resolve` so it works no matter where npm hoisted node_modules.
-  try {
-    const p = requireResolve(`@elliotsystems/eai-${platform}-${arch}/package.json`)
-    out.push({ source: "platform package (optionalDependency)", path: path.join(path.dirname(p), "bin", binary) })
-  } catch {
-    // Platform package not installed (e.g. running from a dev checkout).
-  }
-
-  // 4. Bundled runtime — the shape a published/installed Elliot package will
-  //    have. Nothing populates this yet; packaging is a later, approved phase.
-  out.push({ source: "bundled vendor runtime", path: path.join(root, "vendor", dir, "bin", binary) })
-
+  // The fork's per-platform packages (@elliotsystems/eai-<os>-<arch>) and the
+  // `vendor/` directory used to sit here. Both shipped a fork-built OpenCode;
+  // the runtime now comes from upstream's own opencode-ai above, the packages
+  // are being retired on npm, and nothing populates `vendor/` since the script
+  // that did was removed. Kept as a note rather than dead branches so nobody
+  // re-adds them wondering why stock is the only source.
+
+  // 3. A configured fork location. Accepts either a checkout root or a dist
   // 5. A configured fork location. Accepts either a checkout root or a dist
   //    root, because both are things a person reasonably points this at.
   if (env.ELLIOT_OPENCODE_HOME) {
@@ -112,7 +106,7 @@ function candidates(opts) {
     out.push({ source: "ELLIOT_OPENCODE_HOME (dist)", path: path.join(home, dir, "bin", binary) })
   }
 
-  // 5. Development convenience ONLY: the fork lives in this repo at `opencode/`
+  // 4. Development convenience ONLY: the fork lives in this repo at `opencode/`
   //    (subtree), so from the launcher package root that is one level up. Kept
   //    explicitly last before PATH so a dev build can never silently win over an
   //    override or a packaged runtime.