@cursor/july 0.1.49 → 0.1.51

package/dist/internal/cli-slack.js

@@ -1,7 +1,6 @@
 /**
- * `agent-serve slack …` CLI — manifests, setup, doctor (Socket Mode), and
- * managed provisioning (`create` / `destroy`) through Cursor's
- * "Add to Slack" API (`slack-provision-client.ts`).
+ * `agent-serve slack …` CLI — doctor, destroy/icon, and `create` as a
+ * dashboard-wizard launcher (`slack-provision-client.ts`).
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -14,10 +13,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { access, chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { basename, extname, join, resolve as resolvePath } from "node:path";
-import { buildSlackManifest, buildSlackManifestPair, envPrefixFromName, formatSlackSetupGuide, initSlackChannel, runSlackDoctor, slackEnvKeys, } from "../channels/slack/index.js";
+import { buildSlackManifestPair, envPrefixFromName, formatSlackSetupGuide, initSlackChannel, runSlackDoctor, slackEnvKeys, } from "../channels/slack/index.js";
 import { resolveDeployAuth } from "./cli-deploy.js";
 import { cursorExternalApiUrl } from "./cursor/credentials.js";
 import { slugFromDirectoryName } from "./deploy-client.js";
+import { inferDeployGitSource } from "./deploy-source.js";
 import { describeError } from "./describe-error.js";
 import { CLI_COMMAND_NAME as CLI } from "./distribution.js";
 import { loadAgentLocalEnv } from "./local-env.js";
@@ -34,33 +34,26 @@ Usage:
                                 [--team <id>] [--json]
   ${CLI} slack icon      <URL-or-FILE> [--dir .] [--slack-team T0123ABCD]
                                 [--prod] [--team <id>] [--json]
-  ${CLI} slack init      [--dir .] [--name NAME] [--prefix PREFIX | --no-prefix]
-                                [--channel-posts]
-  ${CLI} slack manifest --env dev|prod|both [--dir .] [--name NAME]
-                                [--print]
   ${CLI} slack doctor [--dir .] [--prefix PREFIX | --no-prefix] [--json]
 
-create/destroy/icon — Cursor "Add to Slack" managed provisioning:
-  create   One-command Path B setup: connects the Slack workspace (browser
-           consent) when needed, creates + installs this agent's dedicated
-           Socket Mode app from the generated manifest, writes the token
-           pair into <dir>/.env.local, then runs doctor (prose mode; --json
-           reports without the doctor pass). Requires
-           \`${CLI} login\` (or CURSOR_API_KEY) and the feature gate.
-           --prod provisions the prod app (default dev); --slack-team picks
-           the workspace when several are connected. --icon sets the app's
-           icon (best-effort: a bad icon warns, never fails the create).
-           A re-run refuses to overwrite manifest edits made by hand at
-           api.slack.com (manifest_drift); --force overwrites them.
+create/destroy/icon — dedicated Socket Mode app via the Cursor dashboard:
+  create   Opens the signed-in dashboard wizard. Finish name, workspace,
+           and Slack consent there. The CLI writes the token pair into
+           <dir>/.env.local and runs doctor. Requires \`${CLI} login\`
+           (or CURSOR_API_KEY). --prod provisions the prod app (default
+           dev). --name / --icon / --channel-posts prefill the wizard.
   destroy  Delete the provisioned Slack app for this agent (+env). Tokens
            already in .env.local are left in place (they just stop working).
   icon     Set the provisioned app's icon: an https image URL or a local
            png/jpg/gif file (at most 512KB).
 
+\`slack init\` is removed. Use \`slack create\`. Do not paste a manifest
+at api.slack.com.
+
 Env tokens:
   single agent:  SLACK_BOT_TOKEN + SLACK_APP_TOKEN
   multi-agent:   <PREFIX>_SLACK_BOT_TOKEN + <PREFIX>_SLACK_APP_TOKEN
-                 (init/create default PREFIX from the directory name;
+                 (create default PREFIX from the directory name;
                   doctor defaults to it too when those keys are set)
 
 See also: skills/setup-slack/SKILL.md
@@ -98,37 +91,13 @@ export function cmdSlack(subcommand, options) {
 }
 function cmdSlackInit(options) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const dir = resolvePath(options.dir);
-        try {
-            const result = yield initSlackChannel(Object.assign(Object.assign(Object.assign({ dir }, (options.name === undefined ? {} : { name: options.name })), (options.noPrefix === true
-                ? { envPrefix: "" }
-                : options.prefix === undefined
-                    ? {}
-                    : { envPrefix: options.prefix })), (options.channelPosts === true ? { channelPosts: true } : {})));
-            process.stdout.write(`${JSON.stringify({
-                ok: true,
-                directory: result.rootDir,
-                created: result.files,
-                envPrefix: (_a = result.envPrefix) !== null && _a !== void 0 ? _a : null,
-                envKeys: result.envKeys,
-                next: [
-                    "Open https://api.slack.com/apps → Create from manifest",
-                    "Import .agent-serve/slack/manifest.dev.json (then prod)",
-                    `Install apps; set ${result.envKeys.bot} + ${result.envKeys.app}`,
-                    result.envPrefix === undefined
-                        ? "agent-serve slack doctor"
-                        : `agent-serve slack doctor --prefix ${result.envPrefix}`,
-                    "agent-serve serve --dir . --dev",
-                    "agent-serve slack setup",
-                ],
-            }, null, 2)}\n`);
-            return 0;
-        }
-        catch (error) {
-            process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-            return 1;
-        }
+        errStream(options)(`\`slack init\` is removed. Socket Mode apps are created with:
+
+  ${CLI} slack create --dir .
+
+That opens the Cursor dashboard wizard. Do not paste a manifest at api.slack.com.
+`);
+        return 1;
     });
 }
 function runManifest(options) {
@@ -137,10 +106,11 @@ function runManifest(options) {
         const env = (_a = options.env) !== null && _a !== void 0 ? _a : "both";
         const dir = resolvePath(options.dir);
         const name = (_b = options.name) !== null && _b !== void 0 ? _b : basename(dir);
-        const pair = buildSlackManifestPair(Object.assign({ name, 
-            // These files are pasted into api.slack.com by hand, so they must not
-            // carry the manager-token-only managed_app_settings block.
-            managedByCursor: false }, (options.channelPosts === true ? { channelPosts: true } : {})));
+        const pair = buildSlackManifestPair({
+            name,
+            managedByCursor: false,
+            channelPosts: options.channelPosts === true ? true : undefined,
+        });
         if (options.print) {
             if (env === "dev" || env === "both") {
                 process.stdout.write(`${JSON.stringify(pair.dev, null, 2)}\n`);
@@ -210,8 +180,8 @@ function resolveDoctorEnvPrefix(options, dir) {
 // ============================================================================
 // create / destroy — Cursor "Add to Slack" managed provisioning
 // ============================================================================
-const DEFAULT_CONNECT_POLL_INTERVAL_MS = 3000;
-const DEFAULT_CONNECT_POLL_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_WIZARD_POLL_INTERVAL_MS = 3000;
+const DEFAULT_WIZARD_POLL_TIMEOUT_MS = 60 * 60 * 1000;
 function resolveSlackAppTarget(options, err) {
     var _a, _b;
     if (options.env === "both" && options.prod !== true) {
@@ -285,38 +255,26 @@ function toSlackAppIconInput(source) {
         : { base64: source.base64, contentType: source.contentType };
 }
 /**
- * URL icons ride the provision request; file icons post to the icon
- * endpoint afterwards. Best-effort: failures warn, never fail the create.
+ * File icons post after the wizard finishes. URL icons ride the mint
+ * payload. Best-effort: failures warn, never fail the create.
  */
-function applySlackCreateIcon(ctx, source, result) {
+function applySlackCreateFileIcon(ctx, source, appId) {
     return __awaiter(this, void 0, void 0, function* () {
-        if (source === undefined) {
+        if (source === undefined || source.kind === "url") {
             return undefined;
         }
-        let failure;
-        if (source.kind === "url") {
-            if (result.iconStatus !== "set") {
-                failure = "Slack did not accept the icon URL";
-            }
-        }
-        else {
-            try {
-                yield ctx.client.setAppIcon({
-                    teamId: ctx.teamId,
-                    slackAppId: result.appId,
-                    icon: toSlackAppIconInput(source),
-                });
-            }
-            catch (error) {
-                failure = describeError(error);
-            }
-        }
-        if (failure === undefined) {
+        try {
+            yield ctx.client.setAppIcon({
+                teamId: ctx.teamId,
+                slackAppId: appId,
+                icon: toSlackAppIconInput(source),
+            });
             return "set";
         }
-        const retryWith = source.kind === "url" ? source.url : source.path;
-        ctx.err(`warning: setting the Slack app icon failed: ${failure}\nRetry with \`${CLI} slack icon ${retryWith}\`.\n`);
-        return "failed";
+        catch (error) {
+            ctx.err(`warning: setting the Slack app icon failed: ${describeError(error)}\nRetry with \`${CLI} slack icon ${source.path}\`.\n`);
+            return "failed";
+        }
     });
 }
 /**
@@ -351,102 +309,18 @@ function prepareProvision(options) {
             out,
             err,
             openBrowserImpl: (_b = options.openBrowserImpl) !== null && _b !== void 0 ? _b : openBrowser,
-            pollIntervalMs: (_c = options.connectPollIntervalMs) !== null && _c !== void 0 ? _c : DEFAULT_CONNECT_POLL_INTERVAL_MS,
-            pollTimeoutMs: (_d = options.connectPollTimeoutMs) !== null && _d !== void 0 ? _d : DEFAULT_CONNECT_POLL_TIMEOUT_MS,
+            pollIntervalMs: (_c = options.connectPollIntervalMs) !== null && _c !== void 0 ? _c : DEFAULT_WIZARD_POLL_INTERVAL_MS,
+            pollTimeoutMs: (_d = options.connectPollTimeoutMs) !== null && _d !== void 0 ? _d : DEFAULT_WIZARD_POLL_TIMEOUT_MS,
         };
     });
 }
-/**
- * Slack's team-scoped admin page listing pending app-install requests.
- * Provisioned apps have no OAuth flow (no redirect URLs, install-from-Slack
- * disabled), so the oauth_authorize_url Slack returns from
- * apps.manifest.create dead-ends; approval happens here instead.
- */
-function slackAppRequestsUrl(slackTeamId) {
-    return `https://app.slack.com/apps-manage/${encodeURIComponent(slackTeamId)}/integrations/requests`;
-}
-/** "Name (T0123ABCD)", or the bare id when the backend has no name. */
-function formatWorkspace(workspace) {
-    var _a;
-    const name = (_a = workspace.slackTeamName) !== null && _a !== void 0 ? _a : "";
-    return name === ""
-        ? workspace.slackTeamId
-        : `${name} (${workspace.slackTeamId})`;
-}
-function matchConnectedWorkspace(workspaces, wait) {
-    const candidates = wait.slackTeamId === undefined
-        ? workspaces
-        : workspaces.filter((workspace) => workspace.slackTeamId === wait.slackTeamId);
-    if (wait.notConnectedAt === undefined) {
-        return candidates[0];
-    }
-    return candidates.find((workspace) => workspace.connectedAt !== wait.notConnectedAt);
-}
-/**
- * Mint the browser consent URL, open it, and poll `GET /status` until the
- * awaited workspace shows up (or the poll times out). Returns the
- * connected workspace, or an exit code with the error already rendered.
- */
-function runConnectFlow(ctx, wait) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let url;
-        try {
-            url = yield ctx.client.connect(ctx.teamId);
-        }
-        catch (error) {
-            return renderSlackApiError(error, ctx.err);
-        }
-        ctx.err(`\nConnect your Slack workspace to Cursor — approve in the browser:\n\n  ${url}\n\n` +
-            `After approving in Slack you land on cursor.com, which links the workspace to your Cursor account — sign in there if the browser is not already signed in as you.\n\n` +
-            `(waiting for the Slack consent to complete, up to ${Math.round(ctx.pollTimeoutMs / 60000)} minutes)\n`);
-        ctx.openBrowserImpl(url);
-        const deadline = Date.now() + ctx.pollTimeoutMs;
-        let lastPollFailure;
-        for (;;) {
-            let workspace;
-            let sleepMs = ctx.pollIntervalMs;
-            try {
-                const status = yield ctx.client.status(ctx.teamId);
-                workspace = matchConnectedWorkspace(status.workspaces, wait);
-                lastPollFailure = undefined;
-            }
-            catch (error) {
-                // Transient poll failures must not abort a minted consent flow; only
-                // a still-failing poll at the deadline surfaces the error.
-                if (Date.now() >= deadline) {
-                    return renderSlackApiError(error, ctx.err);
-                }
-                const failure = describeError(error);
-                if (failure !== lastPollFailure) {
-                    lastPollFailure = failure;
-                    ctx.err(`(status poll failed, retrying: ${failure})\n`);
-                }
-                if (error instanceof SlackProvisionApiError &&
-                    error.retryAfterSeconds !== undefined) {
-                    // Respect backend backpressure instead of hammering at the poll rate.
-                    sleepMs = Math.max(sleepMs, error.retryAfterSeconds * 1000);
-                }
-            }
-            if (workspace !== undefined) {
-                ctx.err(`Connected Slack workspace ${workspace.slackTeamId}.\n`);
-                return workspace;
-            }
-            if (Date.now() >= deadline) {
-                ctx.err(`Timed out waiting for the Slack workspace connection. The consent link stays valid for ~10 minutes — approve it, finish the sign-in on cursor.com, then re-run \`${CLI} slack create\`.\n`);
-                return 1;
-            }
-            yield sleep(sleepMs);
-        }
-    });
-}
 export function cmdSlackCreate(options) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
+        var _a, _b, _c;
         const target = resolveSlackAppTarget(options, errStream(options));
         if (typeof target === "number") {
             return target;
         }
-        // Resolved before any network I/O so a bad path/type/size fails fast.
         let iconSource;
         if (options.icon !== undefined) {
             const resolved = yield resolveSlackIconSource(options.icon, errStream(options));
@@ -459,38 +333,6 @@ export function cmdSlackCreate(options) {
         if (typeof ctx === "number") {
             return ctx;
         }
-        // Workspace: --slack-team wins; one → use it; none → connect; several → ask.
-        let status;
-        try {
-            status = yield ctx.client.status(ctx.teamId);
-        }
-        catch (error) {
-            return renderSlackApiError(error, ctx.err);
-        }
-        let workspace;
-        if (options.slackTeam !== undefined) {
-            workspace = status.workspaces.find((candidate) => candidate.slackTeamId === options.slackTeam);
-        }
-        else if (status.workspaces.length === 1) {
-            workspace = status.workspaces[0];
-        }
-        else if (status.workspaces.length > 1) {
-            ctx.err(`Multiple Slack workspaces are connected:\n` +
-                status.workspaces
-                    .map((candidate) => `  - ${formatWorkspace(candidate)} (Slack user ${candidate.slackUserId}, connected ${candidate.connectedAt})\n`)
-                    .join("") +
-                `Pass --slack-team <id> to pick one.\n`);
-            return 1;
-        }
-        if (workspace === undefined) {
-            const connected = yield runConnectFlow(ctx, {
-                slackTeamId: options.slackTeam,
-            });
-            if (typeof connected === "number") {
-                return connected;
-            }
-            workspace = connected;
-        }
         let wrote;
         try {
             wrote = yield scaffoldSlackChannelFiles(options, target);
@@ -502,90 +344,80 @@ export function cmdSlackCreate(options) {
         if (wrote.length > 0 && !ctx.json) {
             ctx.err(`Scaffolded the Slack channel: ${wrote.join(", ")}\n`);
         }
-        // A re-run rebuilds this manifest from flags, so backend-side
-        // customizations reset to it (documented in the skill).
-        const manifest = buildSlackManifest({
-            name: target.name,
-            env: target.env,
-            channelPosts: options.channelPosts === true,
-        });
-        const manifestJson = JSON.stringify(manifest);
-        // One connect-and-retry for not_connected / insufficient_scopes /
-        // manager_reauth_required (all fixed by a fresh consent grant).
-        let result;
-        let connectRetried = false;
+        const source = yield inferDeployGitSource(target.dir);
+        let minted;
+        try {
+            minted = yield ctx.client.mintWizard({
+                teamId: ctx.teamId,
+                slug: target.slug,
+                env: target.env,
+                envPrefix: target.envPrefix,
+                name: (_a = options.name) !== null && _a !== void 0 ? _a : target.name,
+                gitRepoUrl: source.gitRepoUrl,
+                gitRef: source.gitRef,
+                agentPath: source.agentPath,
+                channelPosts: options.channelPosts === true ? true : undefined,
+                slackTeamId: options.slackTeam,
+                iconUrl: (iconSource === null || iconSource === void 0 ? void 0 : iconSource.kind) === "url" ? iconSource.url : undefined,
+                force: options.force === true ? true : undefined,
+            });
+        }
+        catch (error) {
+            return renderSlackApiError(error, ctx.err);
+        }
+        ctx.err(`Finish Slack setup in the browser:\n\n  ${minted.url}\n\n` +
+            `Sign in as the same Cursor account that ran this command. ` +
+            `The CLI waits here (up to ${Math.round(ctx.pollTimeoutMs / 60000)} minutes).\n`);
+        ctx.openBrowserImpl(minted.url);
+        const deadline = Date.now() + ctx.pollTimeoutMs;
+        let sawPendingAdmin = false;
+        let poll;
         for (;;) {
             try {
-                result = yield ctx.client.provisionApp({
-                    teamId: ctx.teamId,
-                    slackTeamId: workspace.slackTeamId,
-                    slug: target.slug,
-                    env: target.env,
-                    manifest: manifestJson,
-                    icon: (iconSource === null || iconSource === void 0 ? void 0 : iconSource.kind) === "url" ? { url: iconSource.url } : undefined,
-                    force: options.force === true ? true : undefined,
-                });
-                break;
+                poll = yield ctx.client.pollWizard(minted.wizardId);
             }
             catch (error) {
-                if (error instanceof SlackProvisionApiError &&
-                    (error.code === "not_connected" ||
-                        error.code === "insufficient_scopes" ||
-                        error.code === "manager_reauth_required") &&
-                    !connectRetried) {
-                    connectRetried = true;
-                    // All three codes arrive holding a row that GET /status already
-                    // lists, so the poll waits for a fresh grant instead of re-matching
-                    // that row.
-                    const wait = {
-                        slackTeamId: workspace.slackTeamId,
-                        notConnectedAt: workspace.connectedAt,
-                    };
-                    if (error.code === "insufficient_scopes") {
-                        ctx.err(`The Slack connection is missing scopes provisioning needs; approving the consent link again grants them.\n`);
-                    }
-                    else if (error.code === "manager_reauth_required") {
-                        ctx.err(`Slack revoked Cursor's authorization for workspace ${workspace.slackTeamId}; re-approving the consent link restores it.\n`);
-                    }
-                    else {
-                        ctx.err(`The Slack workspace is not connected to Cursor; starting the connect flow.\n`);
-                    }
-                    const connected = yield runConnectFlow(ctx, wait);
-                    if (typeof connected === "number") {
-                        return connected;
-                    }
-                    workspace = connected;
-                    continue;
+                if (Date.now() >= deadline) {
+                    return renderSlackApiError(error, ctx.err);
                 }
-                return renderCreateProvisionError(error, ctx.err);
+                yield sleep(ctx.pollIntervalMs);
+                continue;
             }
-        }
-        const iconStatus = yield applySlackCreateIcon(ctx, iconSource, result);
-        if (result.status === "pending_admin_approval") {
-            const approveUrl = slackAppRequestsUrl(workspace.slackTeamId);
-            if (ctx.json) {
-                ctx.out(`${JSON.stringify({
-                    ok: false,
-                    appId: result.appId,
-                    status: result.status,
-                    slackTeamId: workspace.slackTeamId,
-                    envKeys: target.envKeys,
-                    wrote,
-                    approveUrl,
-                    iconStatus,
-                }, null, 2)}\n`);
+            if (poll.status === "complete") {
+                break;
+            }
+            if (poll.status === "failed") {
+                ctx.err(`${(_b = poll.error) !== null && _b !== void 0 ? _b : "Slack setup failed"}\n`);
+                return 1;
             }
-            else {
-                ctx.err(`The Slack app was created (app ${result.appId}), but installing it needs a Slack workspace-admin approval.\n` +
-                    `\n  A workspace admin can approve it here:\n\n    ${approveUrl}\n\n` +
-                    `Once an admin approves the app, re-run \`${CLI} slack create\` to finish the install and mint the tokens.\n`);
+            if (poll.status === "pending_admin_approval" && !sawPendingAdmin) {
+                sawPendingAdmin = true;
+                const appSuffix = poll.appId === undefined ? "" : ` (${poll.appId})`;
+                ctx.err(`Waiting for a Slack admin to approve the app${appSuffix}. Keep this command running.\n` +
+                    `Managed install does not file the request. Open Slack to submit it; that same page lets you send a reminder to workspace owners.\n`);
+                if (poll.oauthAuthorizeUrl !== undefined &&
+                    poll.oauthAuthorizeUrl.length > 0) {
+                    ctx.err(`  ${poll.oauthAuthorizeUrl}\n`);
+                }
+                ctx.err("After an admin approves, click Retry in the dashboard.\n");
+            }
+            if (Date.now() >= deadline) {
+                ctx.err(`Timed out waiting for Slack setup. Finish it in the browser, then re-run \`${CLI} slack create\`.\n  ${minted.url}\n`);
+                return 1;
             }
+            yield sleep(ctx.pollIntervalMs);
+        }
+        if (poll === undefined || poll.localEnv === undefined) {
+            ctx.err(poll.localEnvClaimed === true
+                ? "Tokens were already claimed by another poll; re-run create to rotate them.\n"
+                : "Slack setup finished but no tokens were returned; re-run create.\n");
             return 1;
         }
-        // Tokens come back exactly once and are never printed.
-        const envEntries = [{ key: target.envKeys.bot, value: result.botToken }];
-        if (result.appToken !== undefined) {
-            envEntries.push({ key: target.envKeys.app, value: result.appToken });
+        const envEntries = [
+            { key: target.envKeys.bot, value: poll.localEnv.botToken },
+        ];
+        if (poll.localEnv.appToken !== undefined) {
+            envEntries.push({ key: target.envKeys.app, value: poll.localEnv.appToken });
         }
         const envFile = join(target.dir, ".env.local");
         try {
@@ -602,29 +434,33 @@ export function cmdSlackCreate(options) {
         for (const { key, value } of envEntries) {
             process.env[key] = value;
         }
-        if (result.appToken === undefined) {
-            ctx.err(`warning: Slack did not return an app-level token, so ${target.envKeys.app} was not written (an existing value was left as-is and may belong to an older app); re-run \`${CLI} slack create\` to recover it.\n`);
+        if (poll.localEnv.appToken === undefined) {
+            ctx.err(`warning: Slack did not return an app-level token, so ${target.envKeys.app} was not written; re-run \`${CLI} slack create\` to recover it.\n`);
+        }
+        let iconStatus;
+        if (poll.appId !== undefined) {
+            iconStatus = yield applySlackCreateFileIcon(ctx, iconSource, poll.appId);
         }
         if (ctx.json) {
             ctx.out(`${JSON.stringify({
                 ok: true,
-                appId: result.appId,
-                status: result.status,
-                slackTeamId: workspace.slackTeamId,
+                appId: poll.appId,
+                status: poll.status,
                 envKeys: target.envKeys,
                 wrote,
                 iconStatus,
             }, null, 2)}\n`);
             return 0;
         }
-        ctx.out(`Provisioned the ${target.env} Slack app for ${target.slug} (app ${result.appId}) in workspace ${workspace.slackTeamId}.\n` +
-            `  wrote ${envEntries.map((entry) => entry.key).join(" + ")} to ${envFile}\n\n`);
-        const doctor = (_a = options.doctorImpl) !== null && _a !== void 0 ? _a : runSlackDoctor;
+        ctx.out(`Slack is connected for ${target.slug}` +
+            (poll.appId === undefined ? "" : ` (app ${poll.appId})`) +
+            `.\n  wrote ${envEntries.map((entry) => entry.key).join(" + ")} to ${envFile}\n\n`);
+        const doctor = (_c = options.doctorImpl) !== null && _c !== void 0 ? _c : runSlackDoctor;
         const doctorResult = yield doctor(target.envPrefix === undefined ? {} : { envPrefix: target.envPrefix });
         ctx.out(renderDoctorReport(doctorResult));
         ctx.out(`\nNext steps:\n` +
-            `  1. ${CLI} dev ${options.dir}\n` +
-            `  2. In Slack, invite @${manifest.features.bot_user.display_name} to a channel and @mention it (or DM it).\n`);
+            `  1. ${CLI} serve --dir ${options.dir} --dev\n` +
+            `  2. Invite the bot in Slack and @mention it.\n`);
         return 0;
     });
 }
@@ -758,10 +594,8 @@ function formatAppList(apps) {
         .join("");
 }
 /**
- * Scaffold the channel files when the channel file is absent. Existing
- * files are never overwritten: initSlackChannel writes with `wx`, and
- * EEXIST means "already scaffolded" (provisioning builds its manifest in
- * memory and does not need the on-disk copies).
+ * Scaffold `agent/channels/slack.ts` when absent. Existing files are
+ * never overwritten: initSlackChannel writes with `wx`.
  */
 function scaffoldSlackChannelFiles(options, target) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -877,42 +711,12 @@ function renderDoctorReport(result) {
     text += result.ok ? "doctor: pass\n" : "doctor: fail\n";
     return text;
 }
-/**
- * Actionable rendering for `POST /apps` failures the create flow does not
- * retry itself (the connect-and-retry codes are handled by the caller).
- */
-function renderCreateProvisionError(error, err) {
-    var _a;
-    if (!(error instanceof SlackProvisionApiError)) {
-        throw error;
-    }
-    switch (error.code) {
-        case "app_conflict":
-            err(`${error.message}\nA concurrent \`${CLI} slack create\` for this agent won the race; re-run create to pick up that app.\n`);
-            return 1;
-        case "ratelimited":
-            err(`${error.message}\nRe-run \`${CLI} slack create\` after the wait.\n`);
-            return 1;
-        case "invalid_app_id":
-            err(`${error.message}\nThe provisioned Slack app seems to have been deleted outside Cursor. Run \`${CLI} slack destroy\` to drop the stale record, then re-run \`${CLI} slack create\`.\n`);
-            return 1;
-        case "manifest_drift":
-            err(`${error.message}\n` +
-                ((_a = error.changedPaths) !== null && _a !== void 0 ? _a : []).map((path) => `  - ${path}\n`).join("") +
-                `Re-run \`${CLI} slack create --force\` to overwrite those edits.\n`);
-            return 1;
-        default:
-            return renderSlackApiError(error, err);
-    }
-}
 function renderSlackApiError(error, err) {
     if (!(error instanceof SlackProvisionApiError)) {
         throw error;
     }
     err(error.code === "manager_reauth_required"
-        ? // There is no standalone connect command: create runs the consent
-            // flow before provisioning.
-            `${error.message}\nRe-approve the Slack consent by re-running \`${CLI} slack create\`, which reconnects the workspace first.\n`
+        ? `${error.message}\nRe-run \`${CLI} slack create\` and finish Slack consent in the dashboard.\n`
         : `${error.message}\n`);
     return 1;
 }

package/dist/internal/convert-automation/convert-workflow.js

@@ -681,7 +681,7 @@ function emitSlackChannel(automation, triggers, slugs, out) {
         out.warnings.push("The Slack trigger marked triggering messages with a completion reaction; agentkit has no completion-reaction option, so that signal is lost unless agent/instructions.md tells the agent to add the reaction itself via Slack tools.");
     }
     if (socketMode) {
-        out.setupSteps.push(`Slack channel-watch / reaction / channel-created triggers need a dedicated Socket Mode Slack app (not the Cursor connection): run \`${CLI_COMMAND_NAME} slack setup\`, then \`${CLI_COMMAND_NAME} slack init --channel-posts\`, and set the generated tokens.`);
+        out.setupSteps.push(`Slack channel-watch / reaction / channel-created triggers need a dedicated Socket Mode Slack app (not the Cursor connection): run \`${CLI_COMMAND_NAME} slack create --channel-posts\`, then finish in the dashboard wizard.`);
     }
     const header = [
         `import { slackChannel } from "${PACKAGE_NAME}/channels/slack";`,
@@ -727,7 +727,7 @@ function emitSlackChannel(automation, triggers, slugs, out) {
         body = [
             "//",
             "// This channel needs a dedicated Socket Mode Slack app (not the Cursor",
-            `// connection): run \`${CLI_COMMAND_NAME} slack setup\` and \`${CLI_COMMAND_NAME} slack init\`.`,
+            `// connection): run \`${CLI_COMMAND_NAME} slack create --channel-posts\`.`,
             "export default slackChannel({",
             ...engagement,
             "});",