agent-messenger 2.37.2 → 2.38.1

package/src/platforms/slack/cli.test.ts

@@ -1,4 +1,7 @@
-import { describe, expect, it } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
 import { spawn } from 'bun'
 
@@ -94,4 +97,111 @@ describe('CLI Framework', () => {
       expect(output.trim()).toBe(pkg.version)
     })
   })
+
+  describe('global --workspace flag with two stored workspaces', () => {
+    let sandbox: string
+    let preloadPath: string
+
+    const credentialsPath = () => join(sandbox, 'slack-credentials.json')
+    const readConfig = () => JSON.parse(readFileSync(credentialsPath(), 'utf-8'))
+    const workspace = (id: string) => ({
+      workspace_id: id,
+      workspace_name: `Workspace ${id}`,
+      token: `xoxc-${id}`,
+      cookie: `xoxd-${id}`,
+    })
+
+    async function runCli(...args: string[]) {
+      const env: Record<string, string | undefined> = {
+        ...process.env,
+        AGENT_MESSENGER_CONFIG_DIR: sandbox,
+        HOME: sandbox,
+      }
+      for (const key of Object.keys(env)) {
+        if (key.startsWith('E2E_SLACK_')) delete env[key]
+      }
+      const proc = spawn(['bun', '--preload', preloadPath, './src/platforms/slack/cli.ts', ...args], {
+        cwd: process.cwd(),
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited,
+      ])
+      return { stdout, stderr, exitCode }
+    }
+
+    beforeEach(() => {
+      sandbox = mkdtempSync(join(tmpdir(), 'agent-slack-workspace-flag-'))
+      writeFileSync(
+        credentialsPath(),
+        JSON.stringify({ current_workspace: 'T1', workspaces: { T1: workspace('T1'), T2: workspace('T2') } }),
+      )
+      // Answer auth.test offline from the token, so the real CLI never reaches Slack.
+      preloadPath = join(sandbox, 'fake-slack-api.ts')
+      writeFileSync(
+        preloadPath,
+        `import { WebClient } from ${JSON.stringify(import.meta.resolve('@slack/web-api'))}
+WebClient.prototype.apiCall = async function (method) {
+  if (method !== 'auth.test') throw new Error('unexpected Slack API call: ' + method)
+  const teamId = String(this.token).replace('xoxc-', '')
+  return { ok: true, team_id: teamId, team: 'Workspace ' + teamId, user_id: 'U1', user: 'tester' }
+}
+`,
+      )
+    })
+
+    afterEach(() => {
+      rmSync(sandbox, { recursive: true, force: true })
+    })
+
+    it('targets the selected workspace for an ordinary command', async () => {
+      const result = await runCli('--workspace', 'T2', 'workspace', 'current')
+
+      expect(result.exitCode).toBe(0)
+      expect(JSON.parse(result.stdout).workspace_id).toBe('T2')
+      expect(readConfig().current_workspace).toBe('T1')
+    })
+
+    it('auth status reports the selected workspace', async () => {
+      const result = await runCli('--workspace', 'T2', 'auth', 'status')
+
+      expect(result.exitCode).toBe(0)
+      expect(JSON.parse(result.stdout)).toMatchObject({ workspace_id: 'T2', valid: true })
+      expect(readConfig().current_workspace).toBe('T1')
+    })
+
+    it('auth logout removes the selected workspace and keeps the current one', async () => {
+      const result = await runCli('--workspace', 'T2', 'auth', 'logout')
+
+      expect(result.exitCode).toBe(0)
+      expect(JSON.parse(result.stdout)).toEqual({ removed: 'T2', success: true })
+      const config = readConfig()
+      expect(config.current_workspace).toBe('T1')
+      expect(config.workspaces).toEqual({ T1: workspace('T1') })
+    })
+
+    it('auth status fails for a selected workspace that is not stored', async () => {
+      const result = await runCli('--workspace', 'T3', 'auth', 'status')
+
+      expect(result.exitCode).toBe(1)
+      expect(JSON.parse(result.stdout).error).toContain('T3')
+      expect(readConfig().current_workspace).toBe('T1')
+    })
+
+    it('without the flag, auth status and logout still use the current workspace', async () => {
+      const status = await runCli('auth', 'status')
+      expect(status.exitCode).toBe(0)
+      expect(JSON.parse(status.stdout).workspace_id).toBe('T1')
+
+      const logout = await runCli('auth', 'logout')
+      expect(logout.exitCode).toBe(0)
+      expect(JSON.parse(logout.stdout)).toEqual({ removed: 'T1', success: true })
+      const config = readConfig()
+      expect(config.current_workspace).toBeNull()
+      expect(config.workspaces).toEqual({ T2: workspace('T2') })
+    })
+  })
 })

package/src/platforms/slack/cli.ts

@@ -25,6 +25,7 @@ import {
   whoamiCommand,
   workspaceCommand,
 } from './commands/index'
+import { setSelectedWorkspaceId } from './credential-manager'
 import { ensureSlackAuth } from './ensure-auth'
 
 function isAuthCommand(command: CommandType): boolean {
@@ -47,6 +48,10 @@ program
   .option('--workspace <id>', 'Use specific workspace')
 
 program.hook('preAction', async (_thisCommand, actionCommand) => {
+  const workspaceId = program.opts<{ workspace?: string }>().workspace
+  if (workspaceId) {
+    setSelectedWorkspaceId(workspaceId)
+  }
   if (isAuthCommand(actionCommand)) return
   await ensureSlackAuth()
 })

package/src/platforms/slack/commands/auth.ts

@@ -7,7 +7,7 @@ import { formatOutput } from '@/shared/utils/output'
 import { debug } from '@/shared/utils/stderr'
 
 import { SlackClient, SlackError } from '../client'
-import { CredentialManager } from '../credential-manager'
+import { CredentialManager, getSelectedWorkspaceId } from '../credential-manager'
 import { refreshCookie, refreshKnownWorkspaceDomains, tryWebTokenRefresh } from '../ensure-auth'
 import type { RefreshResult } from '../ensure-auth'
 import { loginWithQr } from '../qr-http-login'
@@ -192,7 +192,7 @@ async function logoutAction(workspace: string | undefined, options: { pretty?: b
     const credManager = new CredentialManager()
     const config = await credManager.load()
 
-    let targetWorkspace = workspace
+    let targetWorkspace = workspace ?? getSelectedWorkspaceId() ?? undefined
 
     if (!targetWorkspace) {
       if (!config.current_workspace) {
@@ -229,7 +229,18 @@ async function statusAction(options: { pretty?: boolean }): Promise<void> {
     const ws = await credManager.getWorkspace()
 
     if (!ws) {
-      console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
+      const selectedWorkspace = getSelectedWorkspaceId()
+      console.log(
+        formatOutput(
+          selectedWorkspace
+            ? {
+                error: `Workspace not found: ${selectedWorkspace}`,
+                hint: 'Run "workspace list" to see available workspaces.',
+              }
+            : { error: 'No current workspace set. Run "auth extract" first.' },
+          options.pretty,
+        ),
+      )
       process.exit(1)
     }
 

package/src/platforms/slack/credential-manager.ts

@@ -5,6 +5,20 @@ import { join } from 'node:path'
 import { getConfigDir } from '../../shared/utils/config-dir'
 import type { Config, WorkspaceCredentials } from './types'
 
+// Process-wide workspace selection set from the CLI `--workspace <id>` global flag (see
+// the preAction hook in cli.ts). When present it makes commands target that workspace for
+// this single CLI invocation WITHOUT mutating the persisted current_workspace, so the
+// default (no-flag) path and any long-lived watcher keep resolving to current_workspace.
+let selectedWorkspaceId: string | null = null
+
+export function setSelectedWorkspaceId(id: string | null): void {
+  selectedWorkspaceId = id
+}
+
+export function getSelectedWorkspaceId(): string | null {
+  return selectedWorkspaceId
+}
+
 export class SlackCredentialManager {
   private configDir: string
   private credentialsPath: string
@@ -34,6 +48,10 @@ export class SlackCredentialManager {
   }
 
   async getWorkspace(id?: string): Promise<WorkspaceCredentials | null> {
+    // An explicit id wins; otherwise fall back to the process-wide `--workspace` selection.
+    // When neither is set, behaviour is unchanged (resolves to current_workspace below).
+    const resolvedId = id ?? selectedWorkspaceId ?? undefined
+
     // Check env vars first (take precedence over file-based credentials)
     // Only use env credentials if no specific id requested, or id matches env workspace
     const envToken = process.env.E2E_SLACK_TOKEN
@@ -42,7 +60,7 @@ export class SlackCredentialManager {
     const envWorkspaceName = process.env.E2E_SLACK_WORKSPACE_NAME
 
     if (envToken && envCookie && envWorkspaceId && envWorkspaceName) {
-      if (!id || id === envWorkspaceId) {
+      if (!resolvedId || resolvedId === envWorkspaceId) {
         return {
           token: envToken,
           cookie: envCookie,
@@ -54,8 +72,8 @@ export class SlackCredentialManager {
 
     const config = await this.load()
 
-    if (id) {
-      return config.workspaces[id] ?? null
+    if (resolvedId) {
+      return config.workspaces[resolvedId] ?? null
     }
 
     if (!config.current_workspace) {

package/src/platforms/slack/credential-manager.workspace-select.test.ts

@@ -0,0 +1,70 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { rmSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { CredentialManager, setSelectedWorkspaceId } from '@/platforms/slack/credential-manager'
+import type { WorkspaceCredentials } from '@/platforms/slack/types'
+
+const testConfigDir = join(import.meta.dir, '.test-config-ws-select')
+
+const current: WorkspaceCredentials = {
+  workspace_id: 'ws-current',
+  workspace_name: 'Current',
+  token: 'xoxc-current',
+  cookie: 'xoxd-current',
+}
+const other: WorkspaceCredentials = {
+  workspace_id: 'ws-other',
+  workspace_name: 'Other',
+  token: 'xoxc-other',
+  cookie: 'xoxd-other',
+}
+
+describe('CredentialManager global --workspace selection', () => {
+  let manager: CredentialManager
+
+  beforeEach(async () => {
+    rmSync(testConfigDir, { recursive: true, force: true })
+    manager = new CredentialManager(testConfigDir)
+    setSelectedWorkspaceId(null)
+    await manager.setWorkspace(current)
+    await manager.setWorkspace(other)
+    await manager.setCurrentWorkspace('ws-current')
+  })
+
+  afterEach(() => {
+    setSelectedWorkspaceId(null)
+    rmSync(testConfigDir, { recursive: true, force: true })
+  })
+
+  it('getWorkspace() returns the selected workspace over current when no id is passed', async () => {
+    setSelectedWorkspaceId('ws-other')
+
+    const retrieved = await manager.getWorkspace()
+
+    expect(retrieved).toEqual(other)
+  })
+
+  it('selecting a workspace does not mutate current_workspace', async () => {
+    setSelectedWorkspaceId('ws-other')
+
+    await manager.getWorkspace()
+
+    const config = await manager.load()
+    expect(config.current_workspace).toBe('ws-current')
+  })
+
+  it('falls back to current when nothing is selected (no regression)', async () => {
+    const retrieved = await manager.getWorkspace()
+
+    expect(retrieved).toEqual(current)
+  })
+
+  it('an explicit id argument takes precedence over the selection', async () => {
+    setSelectedWorkspaceId('ws-current')
+
+    const retrieved = await manager.getWorkspace('ws-other')
+
+    expect(retrieved).toEqual(other)
+  })
+})