@signaliz/cli 1.0.48 → 1.0.50

package/README.md

@@ -1,6 +1,6 @@
 # @signaliz/cli
 
-The Signaliz CLI exposes four product commands:
+The Signaliz CLI exposes all five core products:
 
 ```bash
 npm install -g @signaliz/cli
@@ -11,6 +11,7 @@ signaliz auth login
 # https://api.signaliz.com/functions/v1/api/v1/verify-email
 # https://api.signaliz.com/functions/v1/api/v1/company-signals
 # https://api.signaliz.com/functions/v1/api/v1/signal-to-copy
+# https://api.signaliz.com/functions/v1/api/v1/signals
 
 signaliz find-email --company-domain example.com --full-name "Jane Doe"
 # Force a fresh-provider quality check instead of reusing cached email or verification data
@@ -33,11 +34,16 @@ signaliz signal-to-copy \
 # Force fresh signals or opt into slower deep research only when needed
 signaliz signal-to-copy --company-domain example.com --person-name "Jane Doe" \
   --title "VP Sales" --campaign-offer "pipeline intelligence" --skip-cache --deep-search
+
+# Signals Everything returns distinct companies with a source-backed signal.
+# It is asynchronous by default; add --wait or resume the returned run ID.
+signaliz signals "companies that just got funded" --limit 100 --sources web,news
+signaliz signals --signal-search-run-id run_... --wait --json
 ```
 
 Use `--json` with any product command for structured output.
 
-Every product command also accepts a JSON array or JSONL file for scale:
+The four row-oriented products accept a JSON array or JSONL file for scale:
 
 ```bash
 signaliz find-email --input contacts.jsonl --concurrency 20 --json
@@ -76,15 +82,26 @@ calls, jobs, writes, or spend.
 Batch input is capped at 5,000 records, concurrency is bounded to `1-50`, input
 order is preserved, and a failed item does not abort successful items.
 Exact duplicate tasks are single-flighted across the full input before
-transport. All four core products use one recoverable REST job for inputs larger
+transport. The four row-oriented core products use one recoverable REST job for inputs larger
 than 25; the CLI waits for completion and retrieves every result page before it
 emits complete results or terminal per-row errors. Find Email, Verify Email, and
 Signal to Copy use 500-row pages, while Company Signal Enrichment uses 25-row
 pages. Durable Signal to Copy jobs use available company-signal data only. If a
+Company Signal row contains `signal_run_id`, the CLI preserves the recovery-read
+contract with direct batches of at most 25. If a
 copy row explicitly requests fresh or deep research, the CLI preserves that
 behavior with synchronous chunks of at most 25. Signal to Copy also shares
 company research across recipients.
 
+Signals Everything is a query-first company discovery command rather than a
+row batch. It returns only dated, source-linked signals that contain both a
+company name and company domain. The default request is 100 companies and the
+maximum is 1,000. It is included on Team and Agency plans, is resumable with
+`signal_search_run_id`, and reports a strict source-cost guardrail: results are
+only returned when source cost is below $0.01 per qualified company. A request
+is a ceiling, not a promise: it can return fewer results when public evidence
+cannot verify both a date and company identity.
+
 Connection commands are limited to access infrastructure:
 
 ```bash

package/dist/bin.js

@@ -11,15 +11,17 @@ var CONFIG_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".sig
 var CONFIG_FILE = (0, import_node_path.join)(CONFIG_DIR, "config.json");
 var HELP = `Signaliz CLI
 
-Four product commands:
+Five product commands:
   signaliz find-email --company-domain example.com --full-name "Jane Doe" [--skip-cache]
   signaliz verify-email [jane@example.com] [--verification-run-id run_...] [--no-wait] [--max-wait-ms 600000]
-  signaliz company-signals --domain example.com [--research-prompt "..."] [--search-mode fast|balanced|coverage] [--no-summary] [--max-wait-ms 120000]
+  signaliz company-signals --domain example.com [--research-prompt "..."] [--search-mode fast|balanced|coverage] [--include-candidate-evidence] [--no-summary] [--max-wait-ms 120000]
   signaliz company-signals --signal-run-id run_...  Read a completed run without duplicate spend
   signaliz signal-to-copy --company-domain example.com --person-name "Jane Doe" \\
     --title "VP Sales" --campaign-offer "pipeline intelligence" [--signal-run-id run_...] \\
     [--skip-cache] [--deep-search] [--max-wait-ms 120000]
   signaliz signal-to-copy --signal-run-id copy_...  Reuse a completed signal run
+  signaliz signals "companies that just got funded" [--limit 100] [--sources web,news] [--wait]
+  signaliz signals --signal-search-run-id run_...  Resume an existing company-attributed signal search
 
 Access and connection:
   signaliz auth login
@@ -42,7 +44,7 @@ Common flags:
   --idempotency-key <key>       Reuse after an ambiguous response to recover the same request or job
   --dry-run                     Return a no-spend plan without provider calls, jobs, or writes
 
-Company Signals and Signal to Copy always wait for complete results or terminal errors.
+Company Signals and Signal to Copy always wait for complete results or terminal errors. Signals Everything is asynchronous by default; use --wait to poll until it completes.
 `;
 function loadConfig() {
   if (!(0, import_node_fs.existsSync)(CONFIG_FILE)) return {};
@@ -170,12 +172,126 @@ function resolveApiKey() {
   if (!key) fail("No API key configured. Run: signaliz auth login");
   return key;
 }
-function createClient() {
+function resolveBaseUrl() {
   const config = loadConfig();
+  return (flag("base-url") || process.env.SIGNALIZ_BASE_URL || process.env.SIGNALIZ_API_URL || config.baseUrl || "https://api.signaliz.com/functions/v1").replace(/\/$/, "");
+}
+function createClient() {
   return new import_sdk.Signaliz({
     apiKey: resolveApiKey(),
-    baseUrl: flag("base-url") || process.env.SIGNALIZ_BASE_URL || process.env.SIGNALIZ_API_URL || config.baseUrl
+    baseUrl: resolveBaseUrl()
+  });
+}
+function numberValue(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : void 0;
+}
+function stringValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function signalsEverythingErrorType(status) {
+  if (status === 400 || status === 422) return "validation";
+  if (status === 401) return "auth_expired";
+  if (status === 402) return "insufficient_credits";
+  if (status === 404) return "not_found";
+  if (status === 429) return "rate_limited";
+  if (status === 504) return "timeout";
+  return status >= 500 ? "provider_error" : "unknown";
+}
+function normalizeSignalsEverythingResult(request, value) {
+  const rawSignals = Array.isArray(value.signals) ? value.signals : [];
+  const signals2 = rawSignals.map((rawSignal) => {
+    const signal = record(rawSignal);
+    const company = record(signal.company);
+    const name = stringValue(company.name || signal.company_name);
+    const domain = stringValue(company.domain || signal.company_domain);
+    if (!name || !domain) {
+      throw new Error("Signals Everything response violated the company attribution contract.");
+    }
+    const evidence = Array.isArray(signal.evidence) ? signal.evidence.map((rawEvidence) => {
+      const item = record(rawEvidence);
+      return {
+        url: stringValue(item.url),
+        publishedAt: stringValue(item.published_at || item.publishedAt),
+        source: stringValue(item.source)
+      };
+    }).filter((item) => Boolean(item.url)) : [];
+    return {
+      company: { name, domain },
+      title: stringValue(signal.title || signal.summary || signal.content),
+      sourceUrl: stringValue(signal.source_url || signal.url) || null,
+      evidence
+    };
+  });
+  const statusValue = stringValue(value.status).toLowerCase();
+  const statuses = /* @__PURE__ */ new Set([
+    "planned",
+    "queued",
+    "processing",
+    "completed",
+    "completed_with_warnings",
+    "failed"
+  ]);
+  const status = statuses.has(statusValue) ? statusValue : signals2.length > 0 ? "completed" : "failed";
+  const guardrail = record(value.cost_guardrail);
+  const maxCost = numberValue(guardrail.max_cost_per_qualified_signal_usd);
+  const warnings = Array.isArray(value.warnings) ? value.warnings.filter((warning) => typeof warning === "string") : void 0;
+  return {
+    success: value.success !== false,
+    status,
+    signalSearchRunId: stringValue(value.signal_search_run_id || request.signalSearchRunId),
+    query: stringValue(value.query || request.query),
+    requestedCount: numberValue(value.requested_count) ?? request.limit ?? 100,
+    nextPollAfterSeconds: numberValue(value.next_poll_after_seconds),
+    signals: signals2,
+    signalCount: signals2.length,
+    ...maxCost === void 0 ? {} : {
+      costGuardrail: {
+        maxCostPerQualifiedSignalUsd: maxCost,
+        costPerQualifiedSignalUsd: value.cost_guardrail && typeof value.cost_guardrail === "object" ? numberValue(guardrail.cost_per_qualified_signal_usd) ?? (guardrail.cost_per_qualified_signal_usd === null ? null : void 0) : void 0
+      }
+    },
+    ...warnings?.length ? { warnings } : {},
+    raw: value
+  };
+}
+async function discoverSignalsEverything(request) {
+  const body = request.signalSearchRunId ? {
+    signal_search_run_id: request.signalSearchRunId,
+    ...request.dryRun === void 0 ? {} : { dry_run: request.dryRun },
+    ...request.idempotencyKey ? { idempotency_key: request.idempotencyKey } : {}
+  } : {
+    query: request.query,
+    limit: request.limit ?? 100,
+    ...request.sources ? { sources: request.sources } : {},
+    ...request.lookbackDays === void 0 ? {} : { lookback_days: request.lookbackDays },
+    ...request.dryRun === void 0 ? {} : { dry_run: request.dryRun },
+    ...request.idempotencyKey ? { idempotency_key: request.idempotencyKey } : {}
+  };
+  const response = await fetch(`${resolveBaseUrl()}/api/v1/signals`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${resolveApiKey()}`,
+      ...request.idempotencyKey ? { "Idempotency-Key": request.idempotencyKey } : {}
+    },
+    body: JSON.stringify(body)
   });
+  const responseValue = await response.json().catch(() => ({}));
+  const responseBody = record(responseValue);
+  if (!response.ok) {
+    const error = record(responseBody.error);
+    const code = stringValue(error.code || responseBody.error_code) || `HTTP_${response.status}`;
+    const message = stringValue(error.message || responseBody.message || responseBody.error) || `Signals Everything request failed with status ${response.status}`;
+    throw new import_sdk.SignalizError({
+      code,
+      message,
+      errorType: signalsEverythingErrorType(response.status),
+      retryAfter: numberValue(responseBody.retry_after_seconds || responseBody.retry_after),
+      details: responseBody
+    });
+  }
+  return normalizeSignalsEverythingResult(request, responseBody);
 }
 function output(value, human) {
   if (hasFlag("json") || hasFlag("jsonl")) {
@@ -393,6 +509,7 @@ async function companySignals() {
         enableOutreachIntelligence: row.enableOutreachIntelligence ?? row.enable_outreach_intelligence,
         enablePredictiveIntelligence: row.enablePredictiveIntelligence ?? row.enable_predictive_intelligence,
         skipCache: row.skipCache ?? row.skip_cache ?? hasFlag("skip-cache"),
+        includeCandidateEvidence: row.includeCandidateEvidence ?? row.include_candidate_evidence ?? hasFlag("include-candidate-evidence"),
         maxWaitMs: row.maxWaitMs || row.max_wait_ms || numberFlag("max-wait-ms")
       };
     });
@@ -424,6 +541,7 @@ async function companySignals() {
     enableOutreachIntelligence: hasFlag("outreach-intelligence") || void 0,
     enablePredictiveIntelligence: hasFlag("predictive-intelligence") || void 0,
     skipCache: hasFlag("skip-cache"),
+    includeCandidateEvidence: hasFlag("include-candidate-evidence"),
     maxWaitMs: numberFlag("max-wait-ms"),
     idempotencyKey: flag("idempotency-key")
   };
@@ -443,6 +561,103 @@ Signals: ${result.signalCount}
     }
   });
 }
+function signalQueryFromArgs(args) {
+  const explicitQuery = flag("query");
+  if (explicitQuery) return explicitQuery;
+  const valueFlags = /* @__PURE__ */ new Set([
+    "--limit",
+    "--sources",
+    "--lookback-days",
+    "--signal-search-run-id",
+    "--idempotency-key",
+    "--max-wait-ms",
+    "--poll-interval-ms",
+    "--base-url"
+  ]);
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (value.startsWith("--")) {
+      if (!value.includes("=") && valueFlags.has(value)) index += 1;
+      continue;
+    }
+    return value;
+  }
+  return void 0;
+}
+function signalDiscoveryIsPending(status) {
+  return ["queued", "pending", "processing", "running"].includes(status.toLowerCase());
+}
+function sleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function signals(args) {
+  if (flag("input")) fail("Signals Everything accepts one natural-language query at a time; do not pass --input.");
+  const signalSearchRunId = flag("signal-search-run-id");
+  const query = signalQueryFromArgs(args);
+  if (!query && !signalSearchRunId) {
+    fail('Usage: signaliz signals "companies that just got funded" [--limit 100] OR signaliz signals --signal-search-run-id run_...');
+  }
+  const sourceValues = csvFlag("sources");
+  if (sourceValues?.some((source) => !["web", "news"].includes(source))) {
+    fail("--sources must contain only web or news");
+  }
+  const request = {
+    query,
+    signalSearchRunId,
+    limit: numberFlag("limit"),
+    sources: sourceValues,
+    lookbackDays: numberFlag("lookback-days"),
+    idempotencyKey: flag("idempotency-key"),
+    dryRun: hasFlag("dry-run")
+  };
+  let result = await discoverSignalsEverything(request);
+  if (hasFlag("wait") && !request.dryRun) {
+    const maxWaitMs = numberFlag("max-wait-ms") ?? 15 * 6e4;
+    const pollIntervalMs = numberFlag("poll-interval-ms");
+    const startedAt = Date.now();
+    while (signalDiscoveryIsPending(result.status) && result.signalSearchRunId && Date.now() - startedAt < maxWaitMs) {
+      await sleep(Math.max(250, pollIntervalMs ?? (result.nextPollAfterSeconds || 5) * 1e3));
+      result = await discoverSignalsEverything({ signalSearchRunId: result.signalSearchRunId });
+    }
+  }
+  output(result, () => {
+    if (result.status === "planned") {
+      process.stdout.write(`Signals Everything plan: ${result.requestedCount} distinct companies. No source acquisition was launched.
+`);
+      return;
+    }
+    if (signalDiscoveryIsPending(result.status)) {
+      process.stdout.write(`Signals Everything ${result.status}: ${result.signalSearchRunId}
+`);
+      process.stdout.write(`Resume with --signal-search-run-id ${result.signalSearchRunId}${hasFlag("wait") ? " after the current wait window" : ""}.
+`);
+      return;
+    }
+    if (!result.success || result.status === "failed") {
+      process.stdout.write(`${String(result.raw.error || result.raw.message || "Signals Everything failed.")}
+`);
+      return;
+    }
+    process.stdout.write(`Qualified companies: ${result.signalCount}
+`);
+    const guardrail = result.costGuardrail;
+    if (guardrail) {
+      process.stdout.write(
+        `Source cost per qualified company: ${guardrail.costPerQualifiedSignalUsd ?? "n/a"} (must be < $${guardrail.maxCostPerQualifiedSignalUsd})
+`
+      );
+    }
+    for (const signal of result.signals.slice(0, 20)) {
+      process.stdout.write(`- ${signal.company.name} (${signal.company.domain}) \u2014 ${signal.title}
+  ${signal.sourceUrl || signal.evidence[0]?.url || ""}
+`);
+    }
+    if (result.signalCount > 20) process.stdout.write(`Showing 20 of ${result.signalCount}; use --json for the full result.
+`);
+    for (const warning of result.warnings || []) process.stdout.write(`Warning: ${warning}
+`);
+  });
+}
 async function signalToCopy() {
   rejectAsyncSignalFlags();
   const rows = readBatchInput();
@@ -569,6 +784,8 @@ async function main() {
       return verifyEmail(args);
     case "company-signals":
       return companySignals();
+    case "signals":
+      return signals(args);
     case "signal-to-copy":
       return signalToCopy();
     case "health":
@@ -604,5 +821,12 @@ main().catch((error) => {
     process.exitCode = 1;
     return;
   }
+  if (error instanceof import_sdk.SignalizError && typeof error.details?.signal_run_id === "string") {
+    const signalRunId = error.details.signal_run_id;
+    const command = process.argv[2] === "signal-to-copy" ? "signal-to-copy" : "company-signals";
+    fail(`${message}
+Recoverable signal run: ${signalRunId}
+Retry the same signaliz ${command} command with --signal-run-id ${signalRunId}, or use --json for structured recovery metadata.`);
+  }
   fail(message);
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@signaliz/cli",
-  "version": "1.0.48",
-  "description": "Signaliz CLI for Find Email, Verify Email, Company Signal Enrichment, and Signal to Copy AI.",
+  "version": "1.0.50",
+  "description": "Signaliz CLI for Signals Everything, Find Email, Verify Email, Company Signal Enrichment, and Signal to Copy AI.",
   "bin": {
     "signaliz": "dist/bin.js"
   },
@@ -21,14 +21,15 @@
     "email-finder",
     "email-verification",
     "company-signals",
-    "signal-to-copy"
+    "signal-to-copy",
+    "signals-everything"
   ],
   "license": "MIT",
   "engines": {
     "node": ">=18"
   },
   "dependencies": {
-    "@signaliz/sdk": "^1.0.50"
+    "@signaliz/sdk": "^1.0.53"
   },
   "devDependencies": {
     "tsup": "^8.0.0",