hippo-memory 1.69.0 → 1.71.0

package/dist/cli/shared.js

@@ -1,82 +1,30 @@
-// Helpers two or more CLI verbs use, split from cli.ts so a verb can move to its own file without importing cli.ts.
+// Store and server helpers the CLI verbs share: audit events, init checks, server routing, git learning and the auth root.
 // This module must never import cli.ts.
-import { envApiKey, envClaudeCodeSessionId, envHippoSessionId, envRequireServer } from '../env.js';
-import * as path from 'path';
-import * as fs from 'fs';
-import { execFileSync, execSync } from 'child_process';
-import { installJsonHooks } from '../hooks/json-hooks.js';
-import { CODEX_TRUST_LINE } from '../hooks/shared.js';
-import { confidenceLabel } from '../memory.js';
-import { getHippoRoot, isInitialized } from '../store/open.js';
-import { explainMatch } from '../search/explain.js';
-import { isSharedStore } from '../config.js';
-import { openHippoDb, closeHippoDb, isSqliteBusy, noteStoreBusy, runWithRequestStores, HOOK_DB_WAIT_MS } from '../db.js';
-import { withLedgerDb } from '../ledger-db.js';
-import { sessionPilotArm } from '../pilot-arm.js';
-import { hookPayloadSessionId, hookPayloadString, isSubagentPayload, recordTokenUse } from '../token-ledger.js';
-import { importAtSessionEnd, currentMachine } from '../agent-memories/sync.js';
-import { summaryLine } from '../agent-memories/report.js';
-import { detectChurnStale } from '../invalidation.js';
-import { resolveProjectIdentity } from '../project-identity.js';
-import { getGlobalRoot, initGlobal } from '../shared.js';
-import { DAILY_TASK_NAME, buildDailyRunnerCommand, buildSchtasksCreateArgs, buildWindowsTaskRun } from '../scheduler.js';
-import { sanitizeLogMessage } from '../capture/compact.js';
-import { appendAuditEvent, reportAuditWriteFailure } from '../audit.js';
-import * as client from '../client.js';
-import { detectServer, removePidfileIfOwned } from '../server-detect.js';
-import { resolveTenantId } from '../tenant.js';
-import { adminActor, learn, CLI_LEARN } from '../api.js';
-import { snapshotText, sessionTrailText, handoffText } from '../context-render.js';
-import { errorMessage, log } from '../log.js';
+import { envApiKey, envRequireServer } from '../util/env.js';
+import { execFileSync } from 'child_process';
+import { isSharedStore } from '../core/config.js';
+import { isInitialized } from '../store/open.js';
+import { detectChurnStale } from '../learn/invalidation.js';
+import { resolveProjectIdentity } from '../core/project-identity.js';
+import { getGlobalRoot, initGlobal } from '../sharing/global-store.js';
+import { reportAuditWriteFailure } from '../store/audit.js';
+import { sqliteSyncStore } from '../store/sqlite/store.js';
+import * as client from './client.js';
+import { detectServer, removePidfileIfOwned } from '../server/server-detect.js';
+import { resolveTenantId } from '../store/tenant.js';
+import { adminActor, learn, CLI_LEARN } from '../api/index.js';
+import { errorMessage, log } from '../util/log.js';
 import { printError } from './output.js';
-export function parseLimitFlag(value) {
-    if (!value)
-        return Infinity;
-    const parsed = parseInt(String(value), 10);
-    return Number.isFinite(parsed) && parsed >= 1 ? parsed : Infinity;
-}
-export function parseCountFlag(value) {
-    if (!value || value === true || Array.isArray(value))
-        return 0;
-    const parsed = parseInt(String(value), 10);
-    return Number.isFinite(parsed) && parsed >= 1 ? parsed : 0;
-}
-export function parseBudgetFlag(value, fallback) {
-    if (value === undefined)
-        return fallback;
-    // A value-less flag and a junk value are different typos; the --hops guard already splits them.
-    if (typeof value !== 'string') {
-        printError('--budget requires an integer value (e.g. --budget 1500).');
-        process.exit(1);
-    }
-    // Number(), like the --hops guard: parseInt('12abc') is 12, silently accepting what this message rejects.
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed < 0) {
-        printError(`Invalid --budget: "${value}". Must be a non-negative integer.`);
-        process.exit(1);
-    }
-    return parsed;
-}
-/**
- * Emit an audit event against `hippoRoot`'s db. Opens its own short-lived
- * connection so callers don't have to thread a db handle. Swallows all errors
- * — audit must never crash a CLI command.
- */
+/** Emit an audit event on its own short-lived connection to `hippoRoot`'s db; swallows all errors, since audit must never crash a CLI command. */
 export function emitCliAudit(hippoRoot, op, targetId, metadata) {
     try {
-        const db = openHippoDb(hippoRoot);
-        try {
-            appendAuditEvent(db, {
+        sqliteSyncStore(hippoRoot).appendAuditEvents([{
                 tenantId: resolveTenantId({}),
                 actor: 'cli',
                 op,
                 targetId,
                 metadata,
-            });
-        }
-        finally {
-            closeHippoDb(db);
-        }
+            }]);
     }
     catch (error) {
         // Best effort: the command already did its work.
@@ -102,39 +50,21 @@ export function runChurnStaleForRepo(hippoRoot, dryRun) {
             return { root, result: detectChurnStale(root, repoRoot, { tenantId, projectName, legacyName, dryRun }) };
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
+            const message = errorMessage(err);
             return { root, result: { checked: 0, marked: 0, alreadyMarked: 0, skippedPinned: [], dryRun, preview: [], error: message } };
         }
     });
 }
-/**
- * When HIPPO_REQUIRE_SERVER is set, the CLI must not silently fall back to
- * direct DB mode — a missing server then masks a real misconfiguration (the
- * configured HIPPO_API_KEY is also silently discarded on fallback). Throws a
- * clear error then. It guards only the routed writes (remember, forget, archive,
- * promote); every other command opens the store directly, knob or not.
- */
+/** With HIPPO_REQUIRE_SERVER set, throw rather than fall back to direct DB mode, which would mask a misconfiguration and discard HIPPO_API_KEY.
+ * Guards only the routed writes (remember, forget, archive, promote). */
 function failIfServerRequired(reason) {
     if (envRequireServer()) {
         throw new Error(`hippo: HIPPO_REQUIRE_SERVER is set but ${reason}. ` +
             `Start \`hippo serve\`, or unset HIPPO_REQUIRE_SERVER to allow direct-mode fallback.`);
     }
 }
-/**
- * Run an HTTP-routed command if a `hippo serve` instance is detected for
- * `hippoRoot`. Returns:
- *   - true  if the HTTP path ran (success OR a structured server error that
- *           was already surfaced to stdout/stderr by `httpFn`),
- *   - false if no server was detected, or if the detected pidfile turned out
- *           to be stale (connection refused). On stale, the pidfile is removed
- *           if it still names that dead server (a newer one may have replaced
- *           it) and the caller should fall back to the direct path.
- *
- * Stale pidfiles must self-heal, not crash.
- * When HIPPO_REQUIRE_SERVER is set, both fallback paths throw instead of
- * returning false, so a missing server fails loudly rather than silently
- * degrading to direct mode.
- */
+/** Run an HTTP-routed command if a `hippo serve` is detected: true if it ran, false on no server or a stale pidfile (removed if it names the dead server).
+ * With HIPPO_REQUIRE_SERVER set both fallbacks throw; a stale pidfile must self-heal, not crash. */
 export async function runViaServerIfAvailable(hippoRoot, httpFn) {
     const info = await detectServer(hippoRoot);
     if (!info) {
@@ -147,7 +77,7 @@ export async function runViaServerIfAvailable(hippoRoot, httpFn) {
         return true;
     }
     catch (err) {
-        const failure = client.classifyTransportFailure(err);
+        const failure = err instanceof Error ? client.classifyTransportFailure(err) : 'none';
         if (failure === 'never-sent') {
             failIfServerRequired('the server pidfile was stale (connection refused)');
             log.warn('stale server pidfile detected, falling back to direct mode');
@@ -157,68 +87,14 @@ export async function runViaServerIfAvailable(hippoRoot, httpFn) {
             return false;
         }
         if (failure === 'delivery-unknown') {
-            // Every caller of this helper is a non-idempotent write, so replaying on
-            // the direct path would store a row the server may already have committed.
-            // Leave the pidfile alone: the next command's connect-phase failure heals it.
+            // Every caller is a non-idempotent write, so replaying on the direct path would store a row the server may already have committed;
+            // leave the pidfile alone: the next command's connect-phase failure heals it.
             printError(`hippo: the connection to ${info.url} dropped or timed out mid-request, so the write may already have been applied. Not retrying locally. Check with \`hippo recall\` before running this again.`);
             process.exit(1);
         }
         throw err;
     }
 }
-export function fmt(n, digits = 2) {
-    return n.toFixed(digits);
-}
-// What `hippo recall` prints for one result; the budget prices this same text.
-export function recallEntryText(r, query, showWhy, isGlobal) {
-    const e = r.entry;
-    const label = confidenceLabel(e);
-    const confLabel = label.warn ? `[${label.text}] ⚠️` : `[${label.text}]`;
-    const bars = Math.round(e.strength * 10);
-    const graphMark = r.graphVia ? ` [graph: ${r.graphVia.hops}hop ${r.graphVia.relType}]` : '';
-    const lines = [
-        `--- ${e.id} [${e.layer}] ${confLabel}${isGlobal ? ' [global]' : ''}${e.superseded_by ? ' [superseded]' : ''}${graphMark} score=${fmt(r.score, 3)} strength=${fmt(e.strength)}`,
-        `    [${'█'.repeat(bars)}${'░'.repeat(10 - bars)}] tags: ${e.tags.join(', ') || 'none'} | retrieved: ${e.retrieval_count}x`,
-    ];
-    if (showWhy) {
-        const explanation = explainMatch(query, r);
-        lines.push(`    source:${isGlobal ? ' [global]' : ' [local]'} | layer: [${e.layer}] | confidence: [${label.text}]`, `    reason: ${explanation.reason}`);
-        const env = explanation.envelope;
-        if (env) {
-            lines.push(`    kind: ${env.kind}`);
-            if (env.scope)
-                lines.push(`    scope: ${env.scope}`);
-            if (env.owner)
-                lines.push(`    owner: ${env.owner}`);
-            if (env.artifact_ref)
-                lines.push(`    artifact_ref: ${env.artifact_ref}`);
-            if (env.session_id)
-                lines.push(`    session_id: ${env.session_id}`);
-            lines.push(`    confidence: ${env.confidence}`);
-        }
-        // The recall trace, e.g. "ranking: base 0.420 -> interference x0.30 -> 0.126 -> goal-boost x1.50 -> 0.189".
-        if (r.rerankTrace && r.rerankTrace.length > 0) {
-            const parts = [`base ${fmt(r.rerankTrace[0].scoreBefore, 3)}`];
-            for (const step of r.rerankTrace) {
-                parts.push(`${step.stage}${step.multiplier !== undefined ? ` x${fmt(step.multiplier, 2)}` : ''}`, fmt(step.scoreAfter, 3));
-            }
-            lines.push(`    ranking: ${parts.join(' -> ')}`);
-        }
-    }
-    lines.push('', e.content, '');
-    return lines.join('\n');
-}
-export function recallHeading(entries, tokens, query) {
-    return `Found ${entries} memories (${tokens} tokens) for: "${query}"\n`;
-}
-/** One line when an agent memory import moved anything; its warnings go to stderr. */
-export function printAgentImport(report, indent = '   ') {
-    const line = summaryLine(report);
-    if (line !== null)
-        console.log(`${indent}${line}`);
-    for (const warning of report.warnings)
-        printError(`hippo: agent memories: ${warning}`);
-}
 /** True, after one line, on a shared store: this account's commits and agent notes are not its members' memories. */
 export function skipLearnOnSharedStore(hippoRoot) {
     if (!isSharedStore(hippoRoot))
@@ -226,240 +102,6 @@ export function skipLearnOnSharedStore(hippoRoot) {
     console.log("Shared store: skipped learning from this account's git commits and coding agents' own memories.");
     return true;
 }
-/** Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an untrusted hook. */
-export function installCodexMemoryHooks(indent) {
-    const result = installJsonHooks('codex');
-    if (result.invalidJson) {
-        console.log(`${indent}WARNING: ${result.settingsPath} is not a hooks file hippo can merge into; fix it, then run \`hippo hook install codex\`.`);
-        return;
-    }
-    const added = [
-        result.installedUserPromptSubmit ? 'UserPromptSubmit' : '',
-        result.installedCompactResume ? 'SessionStart(compact)' : '',
-    ].filter(Boolean);
-    console.log(added.length > 0
-        ? `${indent}Installed hippo's Codex memory hooks (${added.join(', ')}) in ${result.settingsPath}`
-        : `${indent}hippo's Codex memory hooks already in ${result.settingsPath}`);
-    console.log(`${indent}${CODEX_TRUST_LINE}`);
-}
-/** The one line init, hook install, hook uninstall and setup print when Claude Code's settings.json is not JSON hippo can edit and so was left unchanged; true when it printed. */
-export function warnClaudeSettingsUnusable(result, indent, action = 'install') {
-    if (!result.invalidJson)
-        return false;
-    console.log(`${indent}WARNING: ${result.settingsPath} is not a JSON object hippo can merge into, so it was left unchanged; fix it, then run \`hippo hook ${action} claude-code\`.`);
-    return true;
-}
-/**
- * Set up a machine-level daily runner that sweeps all registered Hippo
- * workspaces.
- * Linux/macOS: writes to user crontab.
- * Windows: creates a scheduled task.
- * Skips if already installed.
- */
-export function setupDailySchedule(globalRoot) {
-    const runnerDir = path.resolve(globalRoot);
-    // Reject paths with characters that could break shell/crontab quoting
-    // (backslash is normal on Windows, only dangerous in Unix shell/crontab)
-    const unsafeChars = process.platform === 'win32' ? /["`$%\n\r]/ : /["`$\n\r\\]/;
-    if (unsafeChars.test(runnerDir)) {
-        console.log(`   Skipping schedule: runner path contains unsafe characters.`);
-        return;
-    }
-    const isWindows = process.platform === 'win32';
-    const taskName = DAILY_TASK_NAME;
-    const cmd = buildDailyRunnerCommand(runnerDir);
-    if (isWindows) {
-        // Check if task already exists
-        try {
-            const existing = execSync(`schtasks /query /tn "${taskName}" 2>nul`, { encoding: 'utf-8', windowsHide: true });
-            if (existing.includes(taskName)) {
-                return; // already scheduled
-            }
-        }
-        catch {
-            // Task doesn't exist, create it
-        }
-        try {
-            execFileSync('schtasks', buildSchtasksCreateArgs(taskName, cmd), { stdio: 'pipe', windowsHide: true });
-            console.log(`   Scheduled machine-level daily runner (6:15am) via Task Scheduler: ${taskName}`);
-        }
-        catch {
-            // No admin rights or schtasks unavailable, fall back to printing instructions
-            console.log(`   To schedule the machine-level daily runner, run:`);
-            console.log(`   schtasks /create /tn "${taskName}" /tr "${buildWindowsTaskRun(cmd).replace(/"/g, '\\"')}" /sc daily /st 06:15`);
-        }
-    }
-    else {
-        // Unix: check crontab for existing entry
-        const marker = `# hippo:${taskName}`;
-        try {
-            const existing = execSync('crontab -l 2>/dev/null', { encoding: 'utf-8', windowsHide: true });
-            if (existing.includes(marker)) {
-                return; // already scheduled
-            }
-            const cronLine = `15 6 * * * ${cmd} ${marker}`;
-            const newCrontab = existing.trimEnd() + '\n' + cronLine + '\n';
-            execSync('crontab -', { input: newCrontab, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
-            console.log(`   Scheduled machine-level daily runner (6:15am) via crontab`);
-        }
-        catch {
-            // No crontab or no permission: print the line for the user to add by hand.
-            const cronLine = `15 6 * * * ${cmd}`;
-            console.log(`   To schedule the machine-level daily runner, add to crontab (crontab -e):`);
-            console.log(`   ${cronLine}`);
-        }
-    }
-}
-export function parseAsOfFlag(flags) {
-    const asOf = typeof flags['as-of'] === 'string' ? flags['as-of'] : undefined;
-    if (asOf !== undefined && Number.isNaN(new Date(asOf).getTime())) {
-        printError(`Error: --as-of value "${asOf}" is not a valid ISO date (e.g. 2026-04-22 or 2026-04-22T12:00:00Z).`);
-        process.exit(1);
-    }
-    return asOf;
-}
-/** --physics forces physics, --classic forces BM25+cosine, else physics unless the config turns it off. */
-export function engineFlags(flags, config) {
-    return {
-        usePhysics: Boolean(flags['physics']) || (!flags['classic'] && config.physics.enabled !== false),
-        physicsConfig: config.physics,
-        mmr: !flags['no-mmr'] && config.mmr.enabled,
-        mmrLambda: flags['mmr-lambda'] !== undefined ? parseFloat(String(flags['mmr-lambda'])) : config.mmr.lambda,
-        localBump: flags['equal-sources']
-            ? 1.0
-            : flags['local-bump'] !== undefined ? parseFloat(String(flags['local-bump'])) : config.search.localBump,
-    };
-}
-/**
- * Detached worker that counts re-reads, runs sleep, then capture. Invoked via the internal
- * `__session-end-worker` subcommand (not user-facing). Failures in one stage
- * do not block the other.
- */
-/** A folder without its own store never sleeps at session end, so its project's agent notes go to the global store here. */
-export function logSessionEndImport(logFile, transcriptPath) {
-    try {
-        const report = importAtSessionEnd(process.cwd(), transcriptPath, { machine: currentMachine() });
-        const line = summaryLine(report);
-        if (line !== null)
-            appendSessionEndCloseLog(logFile, line);
-        for (const warning of report.warnings)
-            appendSessionEndCloseLog(logFile, `agent memories: ${warning}`);
-    }
-    catch (err) {
-        appendSessionEndCloseLog(logFile, `agent memory import failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-/**
- * Best-effort log line for the snapshot-close step in
- * `cmdSessionEndWorker`. `cmdSleep`/`cmdCapture` each tee console output to
- * `logFile` only for their own duration (the tee is restored before this
- * runs), so a plain `console.log` here would be silently discarded under
- * the detached worker's `stdio: 'ignore'` — write straight to the file
- * instead, matching capture.ts's `appendPreCompactLog` convention.
- */
-export function appendSessionEndCloseLog(logFile, message, opts = {}) {
-    if (!logFile)
-        return;
-    try {
-        fs.mkdirSync(path.dirname(logFile), { recursive: true });
-        // sanitizeLogMessage: `message` interpolates the payload-controlled
-        // session_id — same log-forgery guard appendPreCompactLog applies.
-        const write = opts.startFresh ? fs.writeFileSync : fs.appendFileSync;
-        write(logFile, `[hippo] ${new Date().toISOString()} ${sanitizeLogMessage(message)}\n`, 'utf8');
-    }
-    catch {
-        // Best-effort only — never let a log-write failure surface as an error.
-    }
-}
-export function printActiveTaskSnapshot(snapshot) {
-    console.log(snapshotText(snapshot));
-}
-export function printSessionEvents(events) {
-    console.log(events.length === 0 ? 'No session events found.' : sessionTrailText(events));
-}
-export function printHandoff(handoff) {
-    console.log(handoffText(handoff));
-}
-// parseArgs turns a value-less flag into `true`; refuse rather than silently
-// stringifying it (String(true) === 'true'), mirroring cmdHandoff's guard.
-export function cardStringFlag(flags, key) {
-    const v = flags[key];
-    if (v === undefined)
-        return undefined;
-    if (v === true || v === false || Array.isArray(v)) {
-        printError(`--${key} requires a value`);
-        process.exit(1);
-    }
-    return v.trim();
-}
-// Claude Code exports its own session var, not ours; without the fallback agent-run recalls trace with no session.
-export function hostSessionId() {
-    return envHippoSessionId() ?? envClaudeCodeSessionId();
-}
-/**
- * Compaction drops the pinned blocks the per-prompt hook injected
- * earlier, so record a `reset` for the payload's session and the next prompt
- * injects again even if nothing changed. `requiredSource` limits it to hook
- * payloads with that `source` (SessionStart fires for other reasons too).
- * Best-effort and silent: a malformed payload records nothing.
- */
-export function resetHookInjection(hippoRoot, stdinText, requiredSource) {
-    const sessionId = hookPayloadSessionId(stdinText, requiredSource);
-    // A sub-agent's compaction leaves its parent's context, and the blocks in it, as they were.
-    if (sessionId === null || isSubagentPayload(stdinText))
-        return;
-    withLedgerDb(hippoRoot, (db) => recordTokenUse(db, {
-        tenantId: resolveTenantId({}), sessionId, surface: 'hook', event: 'reset', items: 0, tokens: 0,
-    }));
-}
-/**
- * Run `fn` with console.log captured; returns the captured lines joined by
- * newlines (what the same calls would have printed, minus the final newline).
- */
-export function captureConsole(fn) {
-    const lines = [];
-    const realLog = console.log;
-    console.log = (...parts) => { lines.push(parts.map(String).join(' ')); };
-    try {
-        fn();
-    }
-    finally {
-        console.log = realLog;
-    }
-    return lines.join('\n');
-}
-/**
- * The store a Claude Code hook writes to: the project store when there is
- * one, else an existing global store, else the project path (which the hook
- * then skips, since hooks fire in every directory and must not create one).
- * Pre-compact and compact-resume must agree, or a snapshot saved to one store
- * is looked for in the other.
- */
-export function hookStoreRoot(hippoRoot) {
-    if (isInitialized(hippoRoot))
-        return hippoRoot;
-    const globalRoot = getGlobalRoot();
-    return isInitialized(globalRoot) ? globalRoot : hippoRoot;
-}
-/** `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the payload. */
-export function hookRuntime(flags) {
-    return flags['runtime'] === 'copilot' || flags['format'] === 'copilot' ? 'copilot' : 'claude-code';
-}
-/** A Copilot hook's project root, from the payload's `cwd`, since VS Code runs user-level hooks in the home folder; other runtimes keep `hippoRoot`. */
-export function payloadCwdRoot(hippoRoot, stdinText, runtime) {
-    const cwd = runtime === 'copilot' ? hookPayloadString(stdinText, 'cwd') : null;
-    if (cwd === null || cwd.trim() === '')
-        return hippoRoot;
-    try {
-        // Moving, not just re-rooting, keeps project identity, scope, handoff evidence and the session-end worker on that folder too.
-        process.chdir(cwd);
-    }
-    catch (err) {
-        log.warn(`hippo: payload cwd ${cwd} is not usable, so the hook stays in ${process.cwd()}: ${errorMessage(err)}`);
-        return hippoRoot;
-    }
-    return getHippoRoot(process.cwd());
-}
 export function learnFromRepo(hippoRoot, repoPath, days, label) {
     const prefix = label ? `[${label}] ` : '';
     const ctx = { hippoRoot, tenantId: resolveTenantId({}), actor: adminActor('cli') };
@@ -490,20 +132,4 @@ export function resolveAuthRoot(hippoRoot, flags) {
     requireInit(hippoRoot);
     return hippoRoot;
 }
-/** Hook commands share one handle per store and wait at most HOOK_DB_WAIT_MS for a lock; a store still busy after that skips the hook's work with one warning, exit 0. */
-export async function runHookWithStores(fn) {
-    try {
-        return await runWithRequestStores(fn, { busyWaitMs: HOOK_DB_WAIT_MS, failFastWhenBusy: true });
-    }
-    catch (error) {
-        if (!isSqliteBusy(error))
-            throw error;
-        noteStoreBusy('hook skipped');
-        return undefined;
-    }
-}
-/** Whether this session sits in the pilot's holdout arm; off at rate 0 and with no session id. */
-export function inPilotHoldout(hippoRoot, tenantId, sessionId, write) {
-    return sessionPilotArm(hippoRoot, tenantId, sessionId, write) === 'holdout';
-}
 //# sourceMappingURL=shared.js.map

package/dist/cli/slack.d.ts

@@ -1,2 +1,3 @@
-export declare function cmdSlack(hippoRoot: string, args: string[], flags: Record<string, string | boolean | string[]>): void;
+import { type CommandContext } from './flag-values.js';
+export declare function handleSlack({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=slack.d.ts.map