@cursor/july 0.1.96 → 0.1.99

package/src/internal/cli-slack-manual.ts

@@ -1,10 +1,21 @@
 /**
- * `slack init --manual` and `slack manifest` — DIY paste-at-api.slack.com.
- * Create/destroy/icon stay in `cli-slack.ts`.
+ * `slack init --manual` and `slack manifest` — unmanaged Slack app.
+ * Slack CLI create+install when `~/.slack/bin/slack` is present;
+ * paste-at-api.slack.com is the fallback. Create/destroy/icon stay
+ * in `cli-slack.ts`.
  */
 
-import { mkdir, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { basename, join, resolve as resolvePath } from "node:path";
+import { promisify } from "node:util";
+import {
+  detectSlackCli,
+  parseSlackAuthTeams,
+  readSlackCliAppId,
+  SLACK_CLI_HOME_BIN,
+  type SlackCliEnvironment,
+} from "../channels/slack/cli-project.js";
 import {
   buildSlackManifestPair,
   initSlackManual,
@@ -12,6 +23,9 @@ import {
 } from "../channels/slack/index.js";
 import { describeError } from "./describe-error.js";
 import { CLI_COMMAND_NAME as CLI } from "./distribution.js";
+import { ensureEnvLocalGitignored, upsertEnvFile } from "./env-file.js";
+
+const execFileAsync = promisify(execFile);
 
 export interface SlackManualCliOptions {
   dir: string;
@@ -23,14 +37,133 @@ export interface SlackManualCliOptions {
   channelPosts?: boolean;
   /** Gate for `slack init`; ignored by `slack manifest`. */
   manual?: boolean;
+  /** Require Slack CLI install (fail if missing or install fails). */
+  install?: boolean;
+  /** Skip Slack CLI install even when the CLI is present. */
+  noInstall?: boolean;
+  slackTeam?: string;
+  prod?: boolean;
+  detectSlackCli?: () => string | undefined;
+  runSlackCli?: SlackCliExec;
   out?: (text: string) => void;
   err?: (text: string) => void;
 }
 
+export interface SlackCliExecRequest {
+  bin: string;
+  argv: string[];
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export interface SlackCliExecResult {
+  code: number;
+  stdout: string;
+  stderr: string;
+}
+
+export type SlackCliExec = (
+  request: SlackCliExecRequest
+) => Promise<SlackCliExecResult>;
+
+interface SlackCliInstallResult {
+  ok: boolean;
+  environment: SlackCliEnvironment;
+  team?: string;
+  appId?: string;
+  error?: string;
+  tokens: { bot: boolean; app: boolean };
+}
+
+interface SlackCliInstallOptions {
+  dir: string;
+  bin: string;
+  envKeys: { bot: string; app: string };
+  environment: SlackCliEnvironment;
+  team?: string;
+  exec?: SlackCliExec;
+}
+
 function errStream(options: SlackManualCliOptions): (text: string) => void {
   return options.err ?? ((text: string) => void process.stderr.write(text));
 }
 
+function afterDoctor(prefix?: string): string[] {
+  return [
+    prefix === undefined
+      ? `${CLI} slack doctor`
+      : `${CLI} slack doctor --prefix ${prefix}`,
+    `${CLI} serve --dir . --dev`,
+    `${CLI} slack setup`,
+  ];
+}
+
+function slackCliEnvironment(prod?: boolean): SlackCliEnvironment {
+  return prod === true ? "deployed" : "local";
+}
+
+function slackAppSettingsUrl(appId?: string): string {
+  return appId === undefined
+    ? "https://api.slack.com/apps"
+    : `https://api.slack.com/apps/${appId}`;
+}
+
+function pasteNext(
+  envKeys: { bot: string; app: string },
+  options: { environment: SlackCliEnvironment; prefix?: string }
+): string[] {
+  return [
+    "Ask the user to install this Slack app on their workspace",
+    `Open ${slackAppSettingsUrl()} → Create from manifest`,
+    "Import .slack/manifest.dev.json (then prod)",
+    `Install apps; set ${envKeys.bot} + ${envKeys.app}`,
+    `Or install Slack CLI to ~/${SLACK_CLI_HOME_BIN}, then slack app install --environment ${options.environment} --team <T> --force`,
+    ...afterDoctor(options.prefix),
+  ];
+}
+
+function cliNext(
+  cli: string,
+  envKeys: { bot: string; app: string },
+  options: {
+    team?: string;
+    environment: SlackCliEnvironment;
+    prefix?: string;
+  }
+): string[] {
+  const workspace = options.team ?? "<T>";
+  return [
+    "Ask the user to install this Slack app on their workspace",
+    `${cli} login --no-prompt`,
+    `In Slack send /slackauthticket <ticket>; then ${cli} login --ticket <ticket> --challenge <code>`,
+    `${cli} app install --environment ${options.environment} --team ${workspace} --force`,
+    `Copy xoxb + xapp (connections:write) from ${slackAppSettingsUrl()} into .env.local as ${envKeys.bot} + ${envKeys.app}`,
+    `Fallback: paste .slack/manifest.dev.json at ${slackAppSettingsUrl()}`,
+    ...afterDoctor(options.prefix),
+  ];
+}
+
+function installedNext(
+  install: SlackCliInstallResult,
+  envKeys: { bot: string; app: string },
+  prefix?: string
+): string[] {
+  const settings = slackAppSettingsUrl(install.appId);
+  const next: string[] = [];
+  if (!install.tokens.bot) {
+    next.push(
+      `Copy the bot token (xoxb-...) from ${settings} into ${envKeys.bot}`
+    );
+  }
+  if (!install.tokens.app) {
+    next.push(
+      `Mint an app-level token with connections:write at ${settings}; set ${envKeys.app}`
+    );
+  }
+  next.push(...afterDoctor(prefix));
+  return next;
+}
+
 export async function cmdSlackInit(
   options: SlackManualCliOptions
 ): Promise<number> {
@@ -42,7 +175,7 @@ export async function cmdSlackInit(
 
 That opens the Cursor dashboard wizard.
 
-To install a custom Slack app from a manifest (api.slack.com):
+To install a custom Slack app from a manifest (Slack CLI or api.slack.com):
 
   ${CLI} slack init --manual --dir .
 `
@@ -53,6 +186,7 @@ To install a custom Slack app from a manifest (api.slack.com):
   const dir = resolvePath(options.dir);
   const out =
     options.out ?? ((text: string) => void process.stdout.write(text));
+  const err = errStream(options);
   try {
     const result = await initSlackManual({
       dir,
@@ -60,32 +194,60 @@ To install a custom Slack app from a manifest (api.slack.com):
       envPrefix: options.noPrefix === true ? "" : options.prefix,
       channelPosts: options.channelPosts,
     });
+    const cli = (options.detectSlackCli ?? detectSlackCli)();
+    const skipInstall = options.noInstall === true;
+    const requireInstall = options.install === true && !skipInstall;
+    let install: SlackCliInstallResult | undefined;
+    if (!skipInstall && cli !== undefined) {
+      install = await installSlackApp({
+        dir: result.rootDir,
+        bin: cli,
+        envKeys: result.envKeys,
+        environment: slackCliEnvironment(options.prod),
+        team: options.slackTeam,
+        exec: options.runSlackCli,
+      });
+      if (!install.ok && requireInstall) {
+        err(`${install.error ?? "slack app install failed"}\n`);
+      }
+    } else if (requireInstall) {
+      err(
+        `Slack CLI not found (~/${SLACK_CLI_HOME_BIN}). Install it or omit --install and paste at api.slack.com.\n`
+      );
+    }
+    const ok = !requireInstall || install?.ok === true;
+    const next =
+      install?.ok === true
+        ? installedNext(install, result.envKeys, result.envPrefix)
+        : cli !== undefined
+          ? cliNext(cli, result.envKeys, {
+              team: install?.team ?? options.slackTeam,
+              environment: slackCliEnvironment(options.prod),
+              prefix: result.envPrefix,
+            })
+          : pasteNext(result.envKeys, {
+              environment: slackCliEnvironment(options.prod),
+              prefix: result.envPrefix,
+            });
     out(
       `${JSON.stringify(
         {
-          ok: true,
+          ok,
           directory: result.rootDir,
           created: result.files,
           envPrefix: result.envPrefix ?? 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
-              ? `${CLI} slack doctor`
-              : `${CLI} slack doctor --prefix ${result.envPrefix}`,
-            `${CLI} serve --dir . --dev`,
-            `${CLI} slack setup`,
-          ],
+          cli: cli ?? null,
+          install: install ?? null,
+          next,
         },
         null,
         2
       )}\n`
     );
-    return 0;
+    return ok ? 0 : 1;
   } catch (error) {
-    errStream(options)(`${describeError(error)}\n`);
+    err(`${describeError(error)}\n`);
     return 1;
   }
 }
@@ -114,7 +276,7 @@ export async function runSlackManifest(
     return 0;
   }
 
-  const outDir = join(dir, ".agent-serve/slack");
+  const outDir = join(dir, ".slack");
   await mkdir(outDir, { recursive: true });
   const written: string[] = [];
   for (const file of slackManifestFileEntries(pair, env)) {
@@ -125,3 +287,173 @@ export async function runSlackManifest(
   process.stdout.write(`${JSON.stringify({ ok: true, written }, null, 2)}\n`);
   return 0;
 }
+
+function parseEnvAssignments(text: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      continue;
+    }
+    const raw = trimmed.startsWith("export ") ? trimmed.slice(7) : trimmed;
+    const eq = raw.indexOf("=");
+    if (eq <= 0) {
+      continue;
+    }
+    out[raw.slice(0, eq)] = raw.slice(eq + 1);
+  }
+  return out;
+}
+
+async function readDotenv(dir: string): Promise<Record<string, string>> {
+  return parseEnvAssignments(
+    await readFile(join(dir, ".env"), "utf8").catch(() => "")
+  );
+}
+
+function newToken(
+  before: string | undefined,
+  after: string | undefined,
+  prefix: string
+): string | undefined {
+  if (after === undefined || !after.startsWith(prefix) || after === before) {
+    return undefined;
+  }
+  return after;
+}
+
+async function copySlackCliTokensToLocalEnv(options: {
+  dir: string;
+  envKeys: { bot: string; app: string };
+  before: Record<string, string>;
+}): Promise<{ bot: boolean; app: boolean }> {
+  const after = await readDotenv(options.dir);
+  const bot = newToken(
+    options.before.SLACK_BOT_TOKEN,
+    after.SLACK_BOT_TOKEN,
+    "xoxb-"
+  );
+  const app = newToken(
+    options.before.SLACK_APP_TOKEN,
+    after.SLACK_APP_TOKEN,
+    "xapp-"
+  );
+  const entries: Array<{ key: string; value: string }> = [];
+  const wrote = { bot: false, app: false };
+  if (bot !== undefined) {
+    entries.push({ key: options.envKeys.bot, value: bot });
+    wrote.bot = true;
+  }
+  if (app !== undefined) {
+    entries.push({ key: options.envKeys.app, value: app });
+    wrote.app = true;
+  }
+  if (entries.length === 0) {
+    return wrote;
+  }
+  await upsertEnvFile(join(options.dir, ".env.local"), entries);
+  await ensureEnvLocalGitignored(options.dir);
+  return wrote;
+}
+
+async function installSlackApp(
+  options: SlackCliInstallOptions
+): Promise<SlackCliInstallResult> {
+  const exec = options.exec ?? defaultSlackCliExec;
+  const auth = await exec({
+    bin: options.bin,
+    argv: ["auth", "list"],
+    cwd: options.dir,
+  });
+  const teams = parseSlackAuthTeams(`${auth.stdout}\n${auth.stderr}`);
+  if (teams.length === 0) {
+    return {
+      ok: false,
+      environment: options.environment,
+      error: "Slack CLI is not logged in. Run slack login --no-prompt.",
+      tokens: { bot: false, app: false },
+    };
+  }
+  let team = options.team;
+  if (team === undefined) {
+    if (teams.length > 1) {
+      return {
+        ok: false,
+        environment: options.environment,
+        error: `Multiple Slack CLI teams (${teams.join(", ")}). Pass --slack-team.`,
+        tokens: { bot: false, app: false },
+      };
+    }
+    team = teams[0];
+  }
+  const before = await readDotenv(options.dir);
+  const installed = await exec({
+    bin: options.bin,
+    argv: [
+      "app",
+      "install",
+      "--environment",
+      options.environment,
+      "--force",
+      "--team",
+      team,
+    ],
+    cwd: options.dir,
+    env: { ...process.env, SLACK_ENV: options.environment },
+  });
+  if (installed.code !== 0) {
+    const detail = installed.stderr.trim() || installed.stdout.trim();
+    return {
+      ok: false,
+      environment: options.environment,
+      team,
+      error:
+        detail === "" ? `slack app install exited ${installed.code}` : detail,
+      tokens: { bot: false, app: false },
+    };
+  }
+  await writeFile(
+    join(options.dir, ".slack/cli-environment"),
+    `${options.environment}\n`
+  );
+  const appId = await readSlackCliAppId(options.dir, options.environment, team);
+  const tokens = await copySlackCliTokensToLocalEnv({
+    dir: options.dir,
+    envKeys: options.envKeys,
+    before,
+  });
+  return {
+    ok: true,
+    environment: options.environment,
+    team,
+    appId,
+    tokens,
+  };
+}
+
+async function defaultSlackCliExec(
+  request: SlackCliExecRequest
+): Promise<SlackCliExecResult> {
+  try {
+    const { stdout, stderr } = await execFileAsync(request.bin, request.argv, {
+      cwd: request.cwd,
+      env: request.env,
+      timeout: 120_000,
+    });
+    return { code: 0, stdout, stderr };
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    const execError = error as Error & {
+      code?: number | string;
+      stdout?: string;
+      stderr?: string;
+    };
+    return {
+      code: typeof execError.code === "number" ? execError.code : 1,
+      stdout: execError.stdout ?? "",
+      stderr: execError.stderr ?? execError.message,
+    };
+  }
+}

package/src/internal/cli-slack.ts

@@ -1,10 +1,10 @@
 /**
  * `agent-serve slack …` CLI — doctor, destroy/icon, `create` as a
  * dashboard-wizard launcher (`slack-provision-client.ts`), and
- * `init --manual` for hand-imported manifests.
+ * `init --manual` for Slack CLI / paste-at-api.slack.com manifests.
  */
 
-import { access, chmod, readFile, writeFile } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import { basename, extname, join, resolve as resolvePath } from "node:path";
 import {
   envPrefixFromName,
@@ -15,12 +15,17 @@ import {
   slackEnvKeys,
 } from "../channels/slack/index.js";
 import { resolveDeployAuth } from "./cli-deploy.js";
-import { cmdSlackInit, runSlackManifest } from "./cli-slack-manual.js";
+import {
+  cmdSlackInit,
+  runSlackManifest,
+  type SlackCliExec,
+} from "./cli-slack-manual.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 { ensureEnvLocalGitignored, upsertEnvFile } from "./env-file.js";
 import { loadAgentLocalEnv } from "./local-env.js";
 import { openBrowser } from "./open-browser.js";
 import {
@@ -60,8 +65,14 @@ export interface SlackCliOptions {
   icon?: string;
   /** create: accepted for compatibility; live-app updates always overwrite. */
   force?: boolean;
-  /** `slack init --manual`: manifests for paste at api.slack.com. */
+  /** `slack init --manual`: Slack CLI project + paste fallback. */
   manual?: boolean;
+  /** `slack init --manual`: require Slack CLI install. */
+  install?: boolean;
+  /** `slack init --manual`: skip Slack CLI install. */
+  noInstall?: boolean;
+  detectSlackCli?: () => string | undefined;
+  runSlackCli?: SlackCliExec;
   /** `slack icon <source>` positional (same URL-or-file forms as --icon). */
   iconSource?: string;
   /** doctor: watched channel ids (`C…`) to verify visibility/membership. */
@@ -90,6 +101,8 @@ Usage:
                                 [--prod] [--team <id>] [--json]
   ${CLI} slack init --manual [--dir .] [--name NAME]
                                 [--prefix PREFIX | --no-prefix] [--channel-posts]
+                                [--install | --no-install]
+                                [--slack-team T0123ABCD] [--prod]
   ${CLI} slack manifest --env dev|prod|both [--dir .] [--name NAME]
                                 [--print]
   ${CLI} slack doctor [--dir .] [--prefix PREFIX | --no-prefix] [--json]
@@ -107,8 +120,13 @@ create/destroy/icon — dedicated Socket Mode app via the Cursor dashboard:
            png/jpg/gif file (at most 512KB).
 
 \`slack init\` without --manual is not the first-run path. Use \`slack create\`.
-\`slack init --manual\` writes the channel file, manifests to paste at
-api.slack.com, env.example, and setup-status.json.
+\`slack init --manual\` writes the channel file, manifests, a Slack CLI
+\`.slack/\` project (get-manifest → those JSON files), env.example, and
+setup-status.json. When \`~/.slack/bin/slack\` is logged in, it installs
+the app. Otherwise \`next\` asks the user to install it. \`--install\`
+requires that install. \`--no-install\` skips it. \`--prod\` selects the
+deployed app. Paste at api.slack.com is the fallback. Do not
+\`slack deploy\`.
 
 Env tokens:
   single agent:  SLACK_BOT_TOKEN + SLACK_APP_TOKEN
@@ -140,7 +158,22 @@ export async function cmdSlack(
     case "icon":
       return cmdSlackIcon(options);
     case "init":
-      return cmdSlackInit(options);
+      return cmdSlackInit({
+        dir: options.dir,
+        name: options.name,
+        prefix: options.prefix,
+        noPrefix: options.noPrefix,
+        channelPosts: options.channelPosts,
+        manual: options.manual,
+        install: options.install,
+        noInstall: options.noInstall,
+        slackTeam: options.slackTeam,
+        detectSlackCli: options.detectSlackCli,
+        runSlackCli: options.runSlackCli,
+        prod: options.prod,
+        out: options.out,
+        err: options.err,
+      });
     case "manifest":
       return runSlackManifest(options);
     case "doctor":
@@ -812,83 +845,6 @@ async function scaffoldSlackChannelFiles(
   }
 }
 
-/**
- * Append `KEY=value` lines to an env file, replacing every existing line
- * for the same key instead of appending duplicates. Creates the file when
- * missing.
- */
-async function upsertEnvFile(
-  path: string,
-  entries: Array<{ key: string; value: string }>
-): Promise<void> {
-  let existing = "";
-  try {
-    existing = await readFile(path, "utf8");
-  } catch (error) {
-    if (!isErrnoException(error) || error.code !== "ENOENT") {
-      throw error;
-    }
-  }
-  const lines =
-    existing === "" ? [] : existing.replace(/\r?\n$/, "").split(/\r?\n/);
-  // A stale `export KEY=…` line would shadow or duplicate the bare line
-  // under some loaders; treat both spellings as the same entry.
-  const matchesKey = (line: string, key: string): boolean =>
-    line.startsWith(`${key}=`) || line.startsWith(`export ${key}=`);
-  for (const { key, value } of entries) {
-    const next = `${key}=${value}`;
-    let replaced = false;
-    for (let i = 0; i < lines.length; ) {
-      if (!matchesKey(lines[i] ?? "", key)) {
-        i += 1;
-        continue;
-      }
-      if (replaced) {
-        lines.splice(i, 1);
-        continue;
-      }
-      lines[i] = next;
-      replaced = true;
-      i += 1;
-    }
-    if (!replaced) {
-      lines.push(next);
-    }
-  }
-  // writeFile's mode only applies on create; clamp pre-existing files too.
-  await writeFile(path, `${lines.join("\n")}\n`, { mode: 0o600 });
-  await chmod(path, 0o600);
-}
-
-/**
- * Ensure the agent directory's .gitignore covers .env.local (create or
- * append). A bare `.env` line does not count — that pattern matches only
- * the file literally named .env.
- */
-async function ensureEnvLocalGitignored(dir: string): Promise<boolean> {
-  const path = join(dir, ".gitignore");
-  let existing = "";
-  try {
-    existing = await readFile(path, "utf8");
-  } catch (error) {
-    if (!isErrnoException(error) || error.code !== "ENOENT") {
-      throw error;
-    }
-  }
-  const covered = existing
-    .split(/\r?\n/)
-    .some((line) => /^\.env(\.local\*?|\.\*|\*)$/.test(line.trim()));
-  if (covered) {
-    return false;
-  }
-  const next =
-    existing === "" || existing.endsWith("\n")
-      ? `${existing}.env.local\n`
-      : `${existing}\n.env.local\n`;
-  await writeFile(path, next);
-  return true;
-}
-
 function renderDoctorReport(result: SlackDoctorResult): string {
   let text = `env: ${result.envKeys.bot} / ${result.envKeys.app}\n`;
   for (const check of result.checks) {

package/src/internal/cursor/account-mcp.ts

@@ -253,6 +253,27 @@ export class CursorAccountMcpBridge {
    * Returns a promise that settles when every ref's log lines are written —
    * callers may ignore it; tests can await it.
    */
+  async probeAuthUrl(
+    ref: CursorAccountConnectionRef
+  ): Promise<string | undefined> {
+    const identifiers =
+      ref.servers !== undefined && ref.servers.length > 0
+        ? [...ref.servers]
+        : (await this.client.getAvailableMcpServers()).map(
+            (server) => server.serverIdentifier ?? server.name
+          );
+    const urls = await probeConnectorAuthUrls({
+      client: this.client,
+      identifiers,
+    });
+    for (const url of urls.values()) {
+      if (url !== "") {
+        return url;
+      }
+    }
+    return undefined;
+  }
+
   logPreflight(refs: CursorAccountConnectionRef[]): Promise<void> {
     return Promise.all(refs.map((ref) => this.runPreflight(ref))).then(
       () => undefined

package/src/internal/cursor-agent-template.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 const MAX = 64;
 const TEMPLATE_NAMES = [
   "agentic-owners",
+  "agents-md",
   "code-wiki",
   "demo",
   "pr-autofixer",

package/src/internal/cursor-event-relay.ts

@@ -616,12 +616,11 @@ export class CursorEventRelay {
           events: [...subscription.events],
         })),
       }),
-      // Empty subscriptions drop this consumer's registration on clean stop
-      // instead of leaving it to lapse by TTL.
-      buildDeregistrationBody: (consumerId) => ({
-        consumerId,
-        subscriptions: [],
-      }),
+      // No deregistration on stop: the backend only records events for a
+      // repo that some consumer is subscribed to, so dropping the
+      // registration leaves a hole in the log until the next process
+      // registers, and the durable offset cannot replay what was never
+      // written. A consumer that does not come back lapses by TTL.
       applyRegistrationResponse: (json) => {
         const result = json as { repos?: SubscriptionStatus[] };
         const statuses = result.repos ?? [];