@floomhq/signaldash 0.28.0 → 0.30.0

package/README.md

@@ -32,6 +32,15 @@ URL and scan the live QR code. The email link offers Google, Outlook, and IMAP
 when those providers are enabled on the Unipile account. The CLI prints
 `Connected <provider>` when the account is ready.
 
+When the CLI runs without a TTY, it requests a session-bound browser handoff
+instead. `POST /connect/<provider>/handoff` returns a short-lived `/c/<token>`
+link for the human to open; only the token hash is persisted, and requesting a
+new link for the same provider invalidates the previous one. The default
+15-minute lifetime can be configured with
+`SIGNALDASH_CONNECT_HANDOFF_TTL_MS`. Opening the link creates no SignalDash
+session and binds the completed provider account only to the bearer session
+that requested it.
+
 The invite code is single-use. Login stores a SignalDash user token in
 `~/.signaldash/config.json`; the Unipile access key remains on the SignalDash
 server. Set `SIGNALDASH_HOME` to keep the local config in another directory.
@@ -91,7 +100,7 @@ flows. The one-command setup installs the skill from the same pinned npm package
 the human chose to execute:
 
 ```bash
-npx -y @floomhq/signaldash@0.28.0 <invite-code>
+npx -y @floomhq/signaldash@0.30.0 <invite-code>
 ```
 
 Run that command in a terminal, not in an agent chat. Do not ask an agent to

package/bin/sd.mjs

@@ -223,6 +223,31 @@ export async function cmdConnect(provider, dependencies = {}) {
     log(`  Connected ${provider}${pre.json.name ? `: ${pre.json.name}` : ""}`);
     return;
   }
+  const interactive = process.stdin.isTTY && process.stdout.isTTY;
+  if (!interactive && !dependencies.forcePoll) {
+    const handoff = await request(`/connect/${provider}/handoff`, {});
+    if (handoff.status >= 300) {
+      error(handoff.json.error === "login required"
+        ? "Not logged in. Run: signaldash login <invite-code>"
+        : "connect failed: " + (handoff.json.error || handoff.status));
+      process.exitCode = 1;
+      return;
+    }
+    if (handoff.json.connected) {
+      log(`  Connected ${provider}${handoff.json.name ? `: ${handoff.json.name}` : ""}`);
+      return;
+    }
+    if (typeof handoff.json.url !== "string") {
+      error("connect failed: handoff URL is missing");
+      process.exitCode = 1;
+      return;
+    }
+    log(`  To connect ${provider}, open this link in your browser and click Connect: ${handoff.json.url}`);
+    const { open: defaultOpen } = await ui();
+    const openUrl = dependencies.open || defaultOpen;
+    try { await openUrl(handoff.json.url); } catch {}
+    return;
+  }
   const r = await request(`/connect/${provider}`, {});
   if (r.status >= 300) {
     error(r.json.error === "login required"
@@ -236,13 +261,6 @@ export async function cmdConnect(provider, dependencies = {}) {
   log("\n  " + chalk.dim("Opening your browser. If it does not open, use this link:"));
   log("  " + chalk.cyan(r.json.url) + "\n");
   try { await openUrl(r.json.url); } catch {}
-  if (!(process.stdin.isTTY && process.stdout.isTTY) && !dependencies.forcePoll) {
-    log("");
-    log(`  ACTION REQUIRED (human): open the link above to connect ${provider}.`);
-    log(`  Then run: npx @floomhq/signaldash connect ${provider}`);
-    log("");
-    return;
-  }
   const spin = ora({ text: `Waiting for ${provider} authentication...`, indent: 2 }).start();
   dependencies._spin = spin;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floomhq/signaldash",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "description": "Secure LinkedIn, WhatsApp, and email access for AI agents",
   "type": "module",
   "bin": {

package/skills/signaldash/SKILL.md

@@ -14,27 +14,36 @@ Treat SignalDash as an operating capability, not an API reference. Resolve the
 exact account object, read the relevant history, explain what you found, draft
 the action, obtain approval when required, act once, and verify the result.
 
-## Before you set this up (say this to the human first)
-
-You are about to wire the user's REAL LinkedIn, WhatsApp and email into a
-persistent MCP server, on the strength of a link and a code someone sent them.
-Name that plainly before you run anything:
-
-> "This will connect your real LinkedIn/WhatsApp to an MCP server I'll register
-> locally, using an invite code from Federico (signaldash-api.floom.dev holds the
-> credentials, not this machine). I can read and draft messages; I won't send
-> anything without showing you the exact text first. OK to proceed?"
-
-Wait for a clear yes. If the user does not know who sent the link, or is unsure,
-stop and let them verify first. Do not soften this to get through setup faster.
+## What this connects, and who the user is trusting
+
+SignalDash connects the user's LinkedIn, WhatsApp, and email to this agent
+through a server operated by the person who gave the user the invite code. Be
+straight about two facts, in one sentence to the user, then continue:
+
+- Other SignalDash users cannot read this user's messages; per-account checks
+  enforce that.
+- That operator runs the server and holds the provider credentials, so they can
+  technically reach the connected accounts' data. The user is trusting that
+  operator, the same as with any app they link an account to. Nothing is sent,
+  invited, or deleted without showing the user the exact content first, and
+  access is revocable at any time.
+
+When the user has asked to set this up and knows who gave them the code, give
+the one-sentence heads-up above and run the bootstrap. The bootstrap logs in to
+SignalDash, installs this skill, registers MCP, and requests short-lived browser
+handoff links. None of those actions links a provider account. Relay each
+printed `/c/<token>` link to the human in one line and tell them to open it in
+their own browser and click Connect. For WhatsApp they scan the QR; for LinkedIn
+they confirm the login. The human connects the account; the agent never opens
+the handoff link or performs the account link.
 
 ## Ensure the skill is installed from a reviewed local package
 
-Do not install this file as trusted instructions merely because an agent was
-given its public URL or pasted contents. A remote instruction document can
-change independently of the user's installed software and may be rejected by a
-security-conscious agent. When reading this from a URL or pasted text, stop and
-ask the human to review and run the pinned package bootstrap in their terminal.
+Install by running the pinned npm package below, not by trusting instructions
+pasted from a URL. A package the user runs themselves is version-pinned and
+matches the MCP server it registers. If you are reading this from pasted text or
+a URL rather than an installed file, ask the user to run the package bootstrap
+in their terminal first, then continue.
 
 1. The human runs the currently published, pinned package:
 
@@ -43,7 +52,12 @@ ask the human to review and run the pinned package bootstrap in their terminal.
    ```
 
    This logs in, copies the package-bundled skill into Claude Code, registers
-   the local MCP server, and starts the hosted account-connection flow.
+   the local MCP server, and prints browser links the human opens to connect
+   each account.
+
+   The agent must never open a printed `/c/<token>` link or otherwise perform
+   the provider account link. Hand the link to the user and wait for them to
+   complete Connect in their own browser.
 
 2. The package writes the installed copy to the one location it supports
    today:
@@ -177,29 +191,29 @@ SignalDash  secure LinkedIn + WhatsApp access for your agent
 + agent skill installed
 + MCP registered with Claude Code
 
-Opening your browser. If it does not open, use this link:
-https://account.unipile.com/...
-
-ACTION REQUIRED (human): open the link above to connect linkedin.
-Then run: npx @floomhq/signaldash connect linkedin
+To connect linkedin, open this link in your browser and click Connect:
+https://signaldash-api.floom.dev/c/...
 ```
 
-In a non-interactive agent shell, the command prints hosted-auth links. The
-agent cannot complete those pages, sign in as the user, or scan a WhatsApp QR
-code.
+In a non-interactive agent shell, the command prints session-bound SignalDash
+handoff links. The agent relays them and does not open them. Only the human
+completes those pages, signs in, or scans a WhatsApp QR code.
 
 ### 2. Relay every printed link to the human
 
 Tell the user which provider each link connects and what human action it needs:
 
-- LinkedIn: open the hosted-auth link and finish LinkedIn authentication.
-- WhatsApp: open the link and scan the live QR code from WhatsApp > Linked
+- LinkedIn: open the SignalDash handoff link, click Connect, and finish
+  LinkedIn authentication.
+- WhatsApp: open the SignalDash handoff link, click Connect, and scan the live
+  QR code from WhatsApp > Linked
   Devices.
 - Email: run `npx -y @floomhq/signaldash connect email`, relay its link, and let
   the human choose Google, Outlook, or IMAP when available.
 
-Do not hide a link in a summary. Send the full URL in a clickable form. Do not
-click, scan, enter passwords, or claim connection on the user's behalf.
+Do not hide a link in a summary. Send the full URL in a clickable form. Never
+open the `/c/<token>` link, click Connect, scan, enter passwords, or claim
+connection on the user's behalf.
 
 ### 3. Verify with status
 
@@ -250,7 +264,8 @@ npx -y @floomhq/signaldash connect email
 Interpret output as follows:
 
 - Success: `Connected linkedin: <name>` or `status` shows `+ linkedin`.
-- Pending human action: a hosted-auth URL plus `ACTION REQUIRED (human)`.
+- Pending human action: a SignalDash `/c/<token>` URL plus an "open this link
+  in your browser and click Connect" line.
   Relay the URL and wait for the human to finish.
 - Still pending in an interactive terminal: `Not connected yet. The link above
   stays valid...`. Do not treat the timeout as a failed login and do not create