@floomhq/signaldash 0.12.0 → 0.22.0

package/README.md

@@ -11,6 +11,14 @@ the server's Unipile access key.
 You need Node.js 20 or newer and a single-use SignalDash invite code. Ask the
 SignalDash administrator for an invite code, then run:
 
+```bash
+npx -y @floomhq/signaldash <invite-code>
+```
+
+This agent-first setup logs in, installs the bundled operating skill, registers
+the MCP server with Claude Code when available, and prints hosted-auth links for
+the human to complete. The equivalent manual sequence is:
+
 ```bash
 npx -y @floomhq/signaldash login <invite-code>
 npx -y @floomhq/signaldash connect linkedin
@@ -74,18 +82,22 @@ The MCP server uses the user token created by `login`. It cannot access a
 LinkedIn, WhatsApp, or email account until that channel has been connected for
 the same logged-in user.
 
-## Give the agent the safety skill
+## Give the agent the operating skill
+
+The canonical [`signaldash` skill](skills/signaldash/SKILL.md) teaches an agent
+when to use SignalDash, how to persist the skill, complete setup, interpret
+connection state, operate every tool, handle server guards, and run safe worked
+flows. It is also served as raw Markdown for agents at:
 
-Before allowing the agent to send messages, give it the bundled
-[`signaldash-safe-usage` skill](skills/signaldash-safe-usage/SKILL.md). The
-skill requires the agent to resolve the exact chat, read recent thread
-history, check for duplicates, and obtain approval when the recipient or text
-has not already been approved.
+```text
+https://signaldash.dev/SKILL.md
+```
 
-The MCP registration does not automatically load the skill yet. Copy
-`skills/signaldash-safe-usage/SKILL.md` into the agent's skills directory or
-attach its contents to the agent instructions. Keep this requirement in both
-Claude Code and Cursor.
+The one-command setup installs the bundled copy into Claude Code. Other clients
+must save the skill in their documented skill directory and reload skill
+discovery. The narrower
+[`signaldash-safe-usage` skill](skills/signaldash-safe-usage/SKILL.md) remains
+available for clients that separate operating and send-safety instructions.
 
 ## MCP tools
 
@@ -94,19 +106,95 @@ SignalDash exposes:
 - `li_list_chats`
 - `li_read_messages(chat_id)`
 - `li_send_message(chat_id, text)`
+- `li_send_invitation(provider_id, note?, confirm?)`
+- `li_invitations_received(limit?, cursor?)`
+- `li_accept_invitation(invitation_id, confirm)`
+- `li_invitations_sent(limit?, cursor?)`
+- `li_withdraw_invitation(invitation_id, confirm)`
+- `sd_contact_state(channel, identifiers, action?, reason?, confirm?)`
+- `sd_budget_status()`
+- `sd_settings_get()`
+- `sd_settings_set(auto_accept_linkedin, auto_accept_linkedin_filters?, confirm)`
+- `sd_auto_accept_status()`
+- `li_search_connections(query, filters?, limit?)`
+- `li_discover_people(query, filters?, limit?, confirm?)`
+- `li_create_invitation_batch(source_label, time_zone, targets)`
+- `li_get_invitation_batch(batch_id)`
+- `li_cancel_invitation_batch(batch_id, approval_view_hash, confirm)`
 - `wa_list_chats`
 - `wa_read_messages(chat_id)`
 - `wa_send_message(chat_id, text)`
 - `email_list(limit)`
 - `email_read(thread_id, limit)`
 - `email_send(to, subject, body)`
+- `li_my_posts(limit, member_id)`
+- `li_post_reactions(post_id, limit)`
+- `li_post_comments(post_id, limit)`
+- `li_draft_post(text, publish)`
 
 Every operation runs through the hosted SignalDash backend. Agents never
 receive the Unipile access key.
 
+LinkedIn invitation auto-accept is off for every user until that user
+explicitly enables it with `confirm:true`. The optional filters are an exact
+public-identifier allowlist and description-keyword matches; when both groups
+are configured, both must match. The single backend worker reads one bounded
+received-invitation page, accepts at most five invitations per run and ten per
+UTC day by default, jitters every action, and also consumes the shared daily
+LinkedIn action budget. Three consecutive parse or provider errors disable the
+setting. `sd_auto_accept_status` exposes accepted counts today and this week,
+failed attempts today, remaining capacity, the stop reason, and sanitized
+records for invitations whose provider shape could not be parsed. Both the current nested
+`specifics.shared_secret` and legacy top-level shape are supported; secrets are
+never returned or logged.
+
+`li_search_connections` is the zero-cost, zero-provider-risk list-building
+path. It searches only the authenticated user's stored connection snapshot by
+name, headline, or company, supports company/headline-keyword/date filters, and
+joins exact local contact state. It never calls LinkedIn, Unipile, or a paid
+discovery API. When no snapshot exists, it points to the paced sync below
+without starting provider work.
+
+`li_discover_people` is the capped paid fallback for people beyond a completed
+stored network. SignalDash runs the same role/company intent against the local
+snapshot first and returns local matches without spending. With no local
+matches, the first call returns an exact paid preview. An identical
+`confirm:true` call can make one serialized HarvestAPI profile-search request.
+That reservation consumes the preview atomically, so every later paid request
+requires a fresh preview and approval.
+Durable per-user pacing, per-user and tenant request caps, and a tenant-wide
+micro-dollar cap are reserved atomically before the request. Hidden cards,
+malformed identities, exact stored connections, and exact contact-state rows
+already marked connected are excluded. Results are read-only planning evidence
+and cannot become invitation-batch targets automatically.
+
+Invitation batches are the narrow executable campaign boundary. An agent turns
+the human's request into 1–10 exact canonical LinkedIn Classic profile URLs,
+inclusion reasons, and optional notes, then creates an immutable durable
+preview. The agent can inspect or cancel the batch but cannot approve it. A
+human opens the returned absolute review URL, reauthenticates with the SignalDash
+invite credential, selects unchecked eligible targets, and approves the exact
+stored payload for up to 24 hours. Five failed credential attempts block that
+batch's authentication surface for 15 minutes. The single backend worker
+rechecks sender binding, exact identity, contact state, prior actions, chats,
+invitations, daily/weekly budgets, weekday work window, pacing, and the tenant
+breaker before each at-most-once write. A tenant provider-authentication
+failure opens the persisted breaker immediately; an open breaker rejects new
+batches and stops queued preview work before provider reads.
+
+This is not a general campaign engine. It has no pause/resume, priority,
+future start, recurring schedule, acceptance polling, automatic message,
+follow-up, discovery-to-send bridge, or runtime target/text generation.
+
+The CLI also provides a paced, resumable LinkedIn connections export:
+
+```bash
+npx -y @floomhq/signaldash connections linkedin-connections.csv
+```
+
 ## Safety limits
 
-SignalDash enforces a daily send cap. The safe-usage skill adds the human
+SignalDash enforces a daily send cap. The operating skill adds the human
 workflow around that runtime control:
 
 - Every successful send includes `rate_limit.limit`, `used`, `remaining`, and
@@ -114,16 +202,37 @@ workflow around that runtime control:
   exhausted, SignalDash returns HTTP 429 with `code: "rate_limit_exceeded"` and
   `Retry-After`. Usage is persisted server-side and resets at midnight UTC.
 - Read the exact thread before every send.
+- Preview an exact invitation target and note before sending it.
+- List the exact received or sent invitation before accepting or withdrawing it.
 - Email sends accept one recipient at a time and require a recent
   `email_read` containing that address.
 - Never infer a recipient from a partial name.
 - Never send a duplicate or retry an ambiguous timeout without re-reading.
+- Invitation auto-accept remains off until explicitly enabled, consumes both
+  its dedicated daily cap and the shared LinkedIn action cap, and disables
+  itself after three consecutive parse or provider errors.
 - Do not parallelize sends or work around a rate limit.
+- Do not bypass paid-discovery previews, pacing, request caps, or cost caps.
 - Stop on a provider warning, checkpoint, restriction, HTTP 403, or HTTP 429.
 - Avoid bulk profile reads, copied message bursts, cold-account automation,
   and unsolicited WhatsApp messaging.
 
-SignalDash exposes no LinkedIn invitation tool.
+LinkedIn invitation writes are single-object actions. SignalDash serializes
+them with other LinkedIn writes, requires an exact preview or list read,
+applies the shared daily action cap, and enforces a separate 100-attempt weekly
+policy by default. For a new invitation, jitter completes before the final
+preflight and action reservation; that preflight verifies relationship state,
+pending invitations in both directions, and absence of an existing one-to-one
+chat. Provider timeouts become non-retryable `outcome_unknown` locks.
+
+The first campaign time boundary is intentionally narrower than scheduled
+messaging. Campaign invitations require a valid sender IANA timezone, run only
+Monday through Friday from 09:00 to 17:00 sender-local time, and reserve a new
+90–180 second per-sender pacing interval atomically with every attempted
+action. Timing is checked before final provider preflight and again during the
+write reservation. Downtime never creates a catch-up burst. Future start
+dates, recurring schedules, automatic follow-ups, acceptance-triggered
+messages, and multi-message sequences are not exposed.
 
 ## Development
 

package/bin/sd.mjs

@@ -4,15 +4,13 @@
 // tools an agent uses all proxy through the backend, so agents access channels
 // THROUGH SignalDash, not around it.
 import {
-  chmodSync,
   readFileSync,
   realpathSync,
-  writeFileSync,
-  mkdirSync,
 } from "node:fs";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
+import { readConfigFile, updateConfigFile } from "../lib/config-file.js";
 
 // Lazy-load presentation deps so `mcp` (stdio, machine-facing) stays clean/fast.
 async function ui() {
@@ -22,6 +20,9 @@ async function ui() {
 }
 
 const DEFAULT_BACKEND = process.env.SIGNALDASH_BACKEND || "https://signaldash-api.floom.dev";
+const PACKAGE_VERSION = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+).version;
 
 function configPaths() {
   const directory = process.env.SIGNALDASH_HOME || `${homedir()}/.signaldash`;
@@ -29,28 +30,41 @@ function configPaths() {
 }
 function loadCfg() {
   try {
-    return JSON.parse(readFileSync(configPaths().file, "utf8"));
+    return readConfigFile(configPaths().file);
   } catch {
     return {};
   }
 }
-function saveCfg(c) {
-  const config = configPaths();
-  mkdirSync(config.directory, { recursive: true, mode: 0o700 });
-  chmodSync(config.directory, 0o700);
-  writeFileSync(config.file, JSON.stringify(c, null, 2), { mode: 0o600 });
-  chmodSync(config.file, 0o600);
+function updateCfg(update) {
+  return updateConfigFile(configPaths().file, update);
 }
 
-async function api(path, body, { auth = true, method = "POST" } = {}) {
+async function api(
+  path,
+  body,
+  { auth = true, method = "POST", backend, token } = {},
+) {
   const cfg = loadCfg();
-  const backend = cfg.backend || DEFAULT_BACKEND;
-  const r = await fetch(backend + path, {
+  const targetBackend = backend || cfg.backend || DEFAULT_BACKEND;
+  const targetToken = token || cfg.token;
+  const r = await fetch(targetBackend + path, {
     method,
-    headers: { "Content-Type": "application/json", ...(auth && cfg.token ? { Authorization: `Bearer ${cfg.token}` } : {}) },
+    headers: {
+      "Content-Type": "application/json",
+      ...(auth && targetToken ? { Authorization: `Bearer ${targetToken}` } : {}),
+    },
     ...(method === "GET" ? {} : { body: JSON.stringify(body || {}) }),
   });
-  return { status: r.status, json: await r.json().catch(() => ({})) };
+  const json = await r.json().catch(() => ({}));
+  if (
+    json &&
+    typeof json === "object" &&
+    typeof json.approval_path === "string" &&
+    json.approval_path.startsWith("/")
+  ) {
+    json.approval_url = new URL(json.approval_path, targetBackend).toString();
+  }
+  return { status: r.status, json };
 }
 
 const wait = milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds));
@@ -66,10 +80,12 @@ export async function cmdLogin(code, backend, dependencies = {}) {
   const request = dependencies.request || api;
   const log = dependencies.log || console.log;
   const error = dependencies.error || console.error;
-  const cfg = loadCfg();
-  cfg.backend = backend || cfg.backend || DEFAULT_BACKEND;
-  saveCfg(cfg);
-  const r = await request("/login", { code }, { auth: false });
+  const targetBackend = backend || loadCfg().backend || DEFAULT_BACKEND;
+  const r = await request(
+    "/login",
+    { code },
+    { auth: false, backend: targetBackend },
+  );
   if (r.status !== 200) {
     const msg = String(r.json.error || r.status);
     if (/used|invalid/i.test(msg) && loadCfg().token) {
@@ -80,8 +96,12 @@ export async function cmdLogin(code, backend, dependencies = {}) {
     if (/used/i.test(msg)) error("Invite codes are single-use. If you already ran this, try: signaldash status");
     process.exitCode = 1; return;
   }
-  cfg.token = r.json.token; saveCfg(cfg);
-  log(`Logged in to SignalDash (${cfg.backend}).`);
+  updateCfg(current => ({
+    ...current,
+    backend: targetBackend,
+    token: r.json.token,
+  }));
+  log(`Logged in to SignalDash (${targetBackend}).`);
   log("Your LinkedIn/WhatsApp/email credentials live on that server, not on this");
   log("machine, and are never exposed to your agent. Only you can see your data.");
 }
@@ -95,14 +115,24 @@ export async function cmdLogout(dependencies = {}) {
     log("Already logged out.");
     return;
   }
-  const response = await request("/logout", {});
+  const response = await request(
+    "/logout",
+    {},
+    { backend: cfg.backend, token: cfg.token },
+  );
   if (response.status !== 200 && response.status !== 401) {
     error("logout failed:", response.json.error || response.status);
     process.exitCode = 1;
     return;
   }
-  delete cfg.token;
-  saveCfg(cfg);
+  updateCfg(current => {
+    if (current.backend !== cfg.backend || current.token !== cfg.token) {
+      return current;
+    }
+    const next = { ...current };
+    delete next.token;
+    return next;
+  });
   log(
     response.status === 200
       ? "Logged out of SignalDash. The session was revoked."
@@ -187,6 +217,345 @@ const TOOLS = [
   { name: "li_list_chats", ch: "li", action: "list_chats", description: "List your LinkedIn chats." },
   { name: "li_read_messages", ch: "li", action: "read", description: "Read messages in a LinkedIn chat. args: chat_id" },
   { name: "li_send_message", ch: "li", action: "send", description: "Send a LinkedIn message (rate-safe). args: chat_id, text" },
+  {
+    name: "li_send_invitation",
+    path: "/li/send_invitation",
+    description: "Preview or send one exact LinkedIn invitation. First call without confirm, obtain approval, then repeat the exact provider_id and note with confirm:true.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        provider_id: { type: "string", minLength: 1, maxLength: 500 },
+        note: { type: "string", maxLength: 300 },
+        confirm: { type: "boolean", default: false },
+      },
+      required: ["provider_id"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_invitations_received",
+    path: "/li/invitations/received",
+    description: "List a bounded page of received LinkedIn invitations and authorize exact later accept actions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "integer", minimum: 1, maximum: 100 },
+        cursor: { type: "string", maxLength: 1000 },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_accept_invitation",
+    path: "/li/accept_invitation",
+    description: "Accept one exact received LinkedIn invitation after listing current received invitations and obtaining approval.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        invitation_id: { type: "string", minLength: 1, maxLength: 500 },
+        confirm: { type: "boolean" },
+      },
+      required: ["invitation_id", "confirm"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_invitations_sent",
+    path: "/li/invitations/sent",
+    description: "List a bounded page of sent LinkedIn invitations and authorize exact later withdrawal actions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "integer", minimum: 1, maximum: 100 },
+        cursor: { type: "string", maxLength: 1000 },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_withdraw_invitation",
+    path: "/li/withdraw_invitation",
+    description: "Withdraw one exact sent LinkedIn invitation after listing current sent invitations and obtaining approval.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        invitation_id: { type: "string", minLength: 1, maxLength: 500 },
+        confirm: { type: "boolean" },
+      },
+      required: ["invitation_id", "confirm"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "sd_contact_state",
+    path: "/sd/contact_state",
+    description: "Inspect exact per-user, per-channel contact state or add a protective suppression. SignalDash never infers cross-channel identity.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel: {
+          type: "string",
+          enum: ["linkedin", "whatsapp", "email"],
+        },
+        identifiers: {
+          type: "array",
+          minItems: 1,
+          maxItems: 8,
+          items: {
+            type: "object",
+            properties: {
+              kind: {
+                type: "string",
+                enum: [
+                  "provider_id",
+                  "public_identifier",
+                  "profile_url",
+                  "member_urn",
+                  "chat_id",
+                  "phone",
+                  "email",
+                ],
+              },
+              value: { type: "string", minLength: 1, maxLength: 1000 },
+            },
+            required: ["kind", "value"],
+            additionalProperties: false,
+          },
+        },
+        action: {
+          type: "string",
+          enum: ["get", "suppress"],
+          default: "get",
+        },
+        reason: {
+          type: "string",
+          enum: [
+            "opt_out",
+            "not_interested",
+            "provider_block",
+            "manual",
+            "legal",
+          ],
+        },
+        confirm: { type: "boolean", default: false },
+      },
+      required: ["channel", "identifiers"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "sd_budget_status",
+    path: "/sd/budget_status",
+    description: "Read authoritative SignalDash LinkedIn attempt capacity for this UTC day and week across manual work and all campaigns. Reports the campaign-excluded portion without promising a reserved manual slot.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "sd_settings_get",
+    path: "/sd/settings/get",
+    description: "Read this SignalDash user's persistent settings. Auto-accept is the first supported setting and is false by default for every existing user.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "sd_settings_set",
+    path: "/sd/settings/set",
+    description: "Update this SignalDash user's persistent settings. Currently supports opt-in, rate-capped LinkedIn invitation auto-accept and exact optional filters. Changing a persistent setting requires explicit approval and confirm:true.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        auto_accept_linkedin: { type: "boolean" },
+        auto_accept_linkedin_filters: {
+          type: "object",
+          properties: {
+            public_identifiers: {
+              type: "array",
+              maxItems: 100,
+              items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 200,
+              },
+            },
+            description_keywords: {
+              type: "array",
+              maxItems: 20,
+              items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 100,
+              },
+            },
+          },
+          additionalProperties: false,
+        },
+        confirm: { type: "boolean" },
+      },
+      required: ["auto_accept_linkedin", "confirm"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "sd_auto_accept_status",
+    path: "/sd/auto_accept/status",
+    description: "Inspect this user's persistent auto-accept setting, filters, accepted/failed attempts today, remaining dedicated cap, repeated-error stop state, and any unparseable invitation records.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_search_connections",
+    path: "/li/connections/search",
+    description: "Search only your locally stored LinkedIn connections by name, headline, or company and join exact local contact state. Makes zero LinkedIn, Unipile, or paid discovery API calls.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", minLength: 1, maxLength: 200 },
+        filters: {
+          type: "object",
+          properties: {
+            company: { type: "string", minLength: 1, maxLength: 200 },
+            headline_keyword: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200,
+            },
+            connected_after: { type: "string", format: "date" },
+            connected_before: { type: "string", format: "date" },
+          },
+          additionalProperties: false,
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 100,
+          default: 20,
+        },
+      },
+      required: ["query"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_discover_people",
+    path: "/li/discover_people",
+    description: "Discover public LinkedIn profile cards beyond your completed stored network through one capped HarvestAPI page. Local matches always win. First preview the exact paid request without confirm, obtain approval, then repeat with confirm:true. Each preview authorizes one provider request.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          minLength: 1,
+          maxLength: 200,
+          description: "Role or title to search.",
+        },
+        filters: {
+          type: "object",
+          properties: {
+            company: { type: "string", minLength: 1, maxLength: 200 },
+            location: { type: "string", minLength: 1, maxLength: 200 },
+          },
+          additionalProperties: false,
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 10,
+          default: 10,
+        },
+        confirm: { type: "boolean", default: false },
+      },
+      required: ["query"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_create_invitation_batch",
+    path: "/li/invitation_batch/create",
+    description: "Create one immutable LinkedIn Classic invitation-batch preview from exact user-approved profile URLs, inclusion reasons, and optional notes. The agent structures the natural-language request; the server never generates targets or text. Maximum 10 targets.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        source_label: {
+          type: "string",
+          minLength: 1,
+          maxLength: 120,
+        },
+        time_zone: {
+          type: "string",
+          minLength: 1,
+          description: "Sender IANA timezone.",
+        },
+        targets: {
+          type: "array",
+          minItems: 1,
+          maxItems: 10,
+          items: {
+            type: "object",
+            properties: {
+              profile_url: {
+                type: "string",
+                format: "uri",
+                description: "Exact LinkedIn Classic https://www.linkedin.com/in/... URL.",
+              },
+              inclusion_reason: {
+                type: "string",
+                minLength: 1,
+                maxLength: 240,
+              },
+              note: {
+                type: "string",
+                maxLength: 200,
+              },
+            },
+            required: ["profile_url", "inclusion_reason"],
+            additionalProperties: false,
+          },
+        },
+      },
+      required: ["source_label", "time_zone", "targets"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_get_invitation_batch",
+    path: "/li/invitation_batch/get",
+    description: "Inspect one exact immutable invitation batch, every target and exclusion, approval hash, timing, capacity, and execution result. This read authorizes a later exact cancel; MCP cannot approve.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        batch_id: { type: "string", minLength: 36, maxLength: 36 },
+      },
+      required: ["batch_id"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_cancel_invitation_batch",
+    path: "/li/invitation_batch/cancel",
+    description: "Permanently cancel one freshly inspected invitation batch. Cancels only unstarted targets and cannot recall an executing invitation. Restart requires a new preview and human approval.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        batch_id: { type: "string", minLength: 36, maxLength: 36 },
+        approval_view_hash: {
+          type: ["string", "null"],
+          pattern: "^[0-9a-f]{64}$",
+        },
+        confirm: { type: "boolean" },
+      },
+      required: ["batch_id", "approval_view_hash", "confirm"],
+      additionalProperties: false,
+    },
+  },
   { name: "wa_list_chats", ch: "wa", action: "list_chats", description: "List your WhatsApp chats." },
   { name: "wa_read_messages", ch: "wa", action: "read", description: "Read messages in a WhatsApp chat. args: chat_id" },
   { name: "wa_send_message", ch: "wa", action: "send", description: "Send a WhatsApp message (rate-safe). args: chat_id, text" },
@@ -250,7 +619,7 @@ export async function runMcp(dependencies = {}) {
   for await (const line of rl) {
     let msg; try { msg = JSON.parse(line); } catch { continue; }
     const { id, method, params } = msg;
-    if (method === "initialize") reply(id, { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "signaldash", version: "0.1.0" } });
+    if (method === "initialize") reply(id, { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "signaldash", version: PACKAGE_VERSION } });
     else if (method === "tools/list") reply(id, { tools: TOOLS.map(t => mcpTool(t.name)) });
     else if (method === "tools/call") {
       const t = TOOLS.find(x => x.name === params.name);
@@ -417,9 +786,10 @@ export async function main(argv = process.argv.slice(2), dependencies = {}) {
   else if (cmd === "mcp") await runMcp(dependencies);
   else if (cmd === "status") await cmdStatus(dependencies);
   else if (cmd === "connections" || (cmd === "export" && a === "connections")) await cmdConnections(cmd === "export" ? b : a, dependencies);
-  else if (cmd === "--version" || cmd === "-v") log("0.7.0");
-  else if (cmd && !["help","--help","-h"].includes(cmd) && !/^[0-9a-f]{8,}$/i.test(cmd)) { (dependencies.error || console.error)(`unknown command: ${cmd}`); printHelp(log); process.exitCode = 1; }
+  else if (cmd === "--version" || cmd === "-v") log(PACKAGE_VERSION);
   else if (cmd === "skill") await cmdSkill(dependencies);
+  else if (cmd === "logout") await cmdLogout(dependencies);
+  else if (cmd && !["help","--help","-h"].includes(cmd) && !/^[0-9a-f]{8,}$/i.test(cmd)) { (dependencies.error || console.error)(`unknown command: ${cmd}`); printHelp(log); process.exitCode = 1; }
   else printHelp(log);
 }